#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Dynamic Gardening
# Authors: ForeverZer0, Twb6543, ThallionDarkshine
# Date: 7.17.2011
# Version: v.3.3
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# VERSION HISTORY
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# v.1.1 (4.15.2010)
# - Improved coding
# - No longer uses game variables, events use self-switches instead
# - Added ability to create different graphics for every plant, without
# having to use more event pages
# - Much less tedious setting up multiple events and changing the every
# condition variable.
# v.2.0 (10.10.2010)
# - Total re-write. Code has been vastly improved and is much more efficient.
# - Event setup has been simplified. Now requires only a single comment, and
# does not require multiple pages.
# - Added configurability for the number of stages each item requires.
# - The timers no longer use Game_System to constantly update, but simply
# compare themselves with the Graphics.frame_count when the event exists
# on the current map, which also allows the plants to grow during scenes
# other than Scene_Map and Scene_Battle.
# - Got rid of Scene_Harvest. Scene_Garden now handles both aspects, and has
# been improved.
# - Added item icons to the help window display.
# v.3.0 (5.13.2011)
# - Restructured code completely
# - Increased compatibility and performance
# - Fixed bug with final graphic not behaving correctly
# v.3.1 (7.14.2011) by Twb6543
# - Changed Script to allow for Single Seeds
# - Added the ability to set default values
# v.3.2 (7.17.2011) by Twb6543
# - Changed Script to fix bugs in the last release
# - Fixed Bugs from version 3.0 (May not be completely fixed but I(Twb6543)
# believe that it is mostly fixed)
# v.3.3 (12.19.2017) by ThallionDarkshine
# - Modified script to allow players to choose between single and double seed
# when planting seeds.
# - Fixed a bug where help window would not update correctly.
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#
# Explanation:
#
# This system allows the player to plant seeds, which will eventually grow
# into plants that can be harvested for items. The system is very similar in
# nature to that found in Legend of Mana. Seed's can be combined in different
# ways, which will effect the total growth duration, the number of stages the
# plant passes through, the graphics used, and of course the final result.
#
# Features:
#
# - Totally configurable growth rates, results, and graphics for every plant.
# - Can use arrays of items for each result, so the final item is not
# neccessarily the same every time.
# - Each plant timer is independent, and its progress is saved with the game.
# - Easy setup. Need only a single comment in one of the event's pages.
#
# Instructions:
#
# - Place script below Debug and above Main
# - Configure the options below (instructions are with each setting)
# - Create an event, setting the graphic to whatever you want. This will be the
# graphics used when nothing is growing on the plant.
# - At the very top event's page, place a comment that reads "Garden Event",
# omitting the quotation marks.
# - As long as the page's conditions are met, this event can be clicked on to
# initiate the Garden scene, and can grow plants.
# - Note that plants can be harvested early, but they will yield nothing until
# they are ripe.
#
# Note:
#
# - Any method modified or added in 3.1 or 3.2 has an headed attached to it.
# - The header will be "Double and Single Seed" or
# "Double and Single Seed Method" for modified Methods.
# - The header will be "Double and Single Seed New Method" for new Methods.
# - Headers may also have extra information.
# - The Code for Scene_Garden and Window_Seed can definitely be optimised
# but as I(Twb6543) finally squashed the bug preventing release of v 3.2
# I do not want to change anything with out a bit of forethought.
#
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# BEGIN CONFIGURATION
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
#===============================================================================
# ** Garden
#===============================================================================
module Garden
SEED_IDS = [1, 2, 3, 4, 5, 6, 7, 8]
# IDs of the items in the database that are seeds. Add them into the array in
# the order of value/rarity in your game this currently includes any single
# seeds
HARVEST_SE = '056-Right02'
# This is the SE that will be played when the player harvests the plant.
SEED_DISPLAY = true
# If true, all seeds will be displayed in the seed window, including those
# that the player does not have, though they will be disabled. If false, only
# seeds that that the player currently has will be displayed.
# Define the growth rates here. (the average of both seeds will be used)
def self.growth_rate(seed)
return case seed
# when SEED_ID then SECONDS
when 1 then 10
when 2 then 12
when 3 then 15
when 4 then 20
when 5 then 23
when 6 then 25
when 7 then 30
when 8 then 35
else
10 # Default Value to return if no speed is specified
end
end
#-------------------------------------------------------------------------------
# Define the number of stages that each item uses. The stages will still cycle
# in the same order, but only use up to the defined number of them before going
# to the final graphic. This will not effect the duration that the seed takes to
# grow, only how many times the graphic changes.
#
# You do not have to define anything that uses a three stage configuration.
#-------------------------------------------------------------------------------
def self.number_stages(result)
case result
when 8..16
return 4
when 17..24
return 5
else
return 3
end
end
#-------------------------------------------------------------------------------
# Define the final result of the seeds. A random item from the array will be
# given as the final result.
#
# Each seed is given a value from 0 to the total number of seeds in the SEED_IDS
# array, and both values are added together to determine which 'produce' array
# will be used for the final result. This is why it is important that you have
# the SEED_IDS array in order of value/rarity. You can find the total number of
# cases you will need by subtracting 1 from the total number of different seeds
# in SEED_IDS, and multiplying that number by 2.
#
# EX. Player uses one each of the first and last seed in the SEED_IDS array,
# and there are 8 total seeds in the array...
#
# FIRST_SEED = 2
# LAST_SEED = 5 2 + 5 = RESULT
#
# By placing multiple copies of the same value in an array, you can increase
# the odds of receiving that item over another in the same array.
#-------------------------------------------------------------------------------
#-------------------------------#
# - Double and Single Seed - #
#-------------------------------#
# Now with Else/Defualt Clause #
#-------------------------------#
def self.produce(seed)
return case seed
when 0 then [9, 10] # Only if both seed are the lowest seeds
when 1 then [10, 11]
when 2 then [12, 13]
when 3 then [13, 14]
when 4 then [14, 15]
when 5 then [15, 16]
when 6 then [16, 17] # Every combination in between
when 7 then [17, 18]
when 8 then [18, 19]
when 9 then [19, 20]
when 10 then [20, 21]
when 11 then [21, 22]
when 12 then [22, 23]
when 13 then [23, 24]
when 14 then [24] # Only if both seeds are the highest seeds
else
[9] # Default Value to return, Brackets are important,
# May contain more than one value e.g [9,10] or [9,10,11,12,13]
end
end
#------------------------------------------#
# - Double and Single Seed New Method - #
#------------------------------------------#
# Table set up much in the same way as #
# .produce, however items come from seed #
# _ID_ not position in array #
#------------------------------------------#
# Also the ids are taken from SINGLE_IDS #
# Array #
#------------------------------------------#
def self.produce_single(seed)
return case seed
when 25 then [9, 10] # Only if seed is item with Id 25
else
[9] # Default Value to return, Brackets are important,
# May contain more than one value e.g [9,10] or [9,10,11,12,13]
end
end
#-------------------------------------------------------------------------------
# Define graphics for the final results, and each stage. Follow the below
# template to set it up.
#
# when ITEM_ID/STAGE then ['FILENAME', X, Y]
#
# ITEM_ID = The ID number of the item in your database
# STAGE = The stage during which to display the graphic
#
# FILENAME = The name of the character file the needed graphic is on
# X = The x-coordinate of the correct picture on the charset (1 - 4)
# Y = The y-coordinate of the correct picture on the charset (1 - 4)
#
# ← X → Ex. If the needed graphic was in the bottom
# 1 2 3 4 left corner: X = 1 Y = 4
# ┌──┬──┬──┬──┐
# 1 │ │ │ │ │
# ├──┼──┼──┼──┤
# ↑ 2 │ │ │ │ │
# Y ├──┼──┼──┼──┤
# ↓ 3 │ │ │ │ │
# ├──┼──┼──┼──┤
# 4 │ │ │ │ │
# └──┴──┴──┴──┘
#-------------------------------------------------------------------------------
def self.stage_graphics(stage)
return case stage
when 0 then ['Plants1', 1, 1]
when 1 then ['Plants1', 2, 3]
when 2 then ['Plants1', 2, 1]
when 3 then ['Plants1', 4, 2]
when 4 then ['Plants1', 2, 4]
end
end
def self.final_graphic(item)
return case item
when 9 then ['Garden Plants', 1, 1]
when 10 then ['Garden Plants', 2, 4]
when 11 then ['Garden Plants', 3, 4]
when 12 then ['Garden Plants', 4, 4]
when 13 then ['Garden Plants', 1, 4]
when 14 then ['Garden Plants', 2, 2]
when 15 then ['Garden Plants', 3, 2]
when 16 then ['Garden Plants', 4, 2]
when 17 then ['Garden Plants', 1, 2]
when 18 then ['Garden Plants', 2, 3]
when 19 then ['Garden Plants', 3, 3]
when 20 then ['Garden Plants', 4, 3]
when 21 then ['Garden Plants', 1, 3]
when 22 then ['Garden Plants', 2, 1]
when 23 then ['Garden Plants', 3, 1]
when 24 then ['Garden Plants', 4, 1]
end
end
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END CONFIGURATION
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
# ! Warning ! #
# #
# This rearranges the order of the def #
# variables to allow for Single Seed #
#--------------------------------------#
def self.plant_seeds(event_id, seed1, seed2=nil)
# Create a new instance of a Garden::Plant
if seed2 != nil
# Double Seed Method
plant = self::Plant.new(event_id, seed1, seed2)
if $game_system.garden[$game_map.map_id] == nil
$game_system.garden[$game_map.map_id] = [plant]
else
$game_system.garden[$game_map.map_id].push(plant)
end
else
#Single Seed Method
plant = self::Plant.new(event_id, seed1)
if $game_system.garden[$game_map.map_id] == nil
$game_system.garden[$game_map.map_id] = [plant]
else
$game_system.garden[$game_map.map_id].push(plant)
end
end
end
def self.harvest(id)
# Find the appropriate plant.
plant = $game_system.garden[$game_map.map_id].find {|plant| plant.id == id }
return nil if plant == nil
# Return the result, and delete plant data from array.
result = plant.produce
plant.restore_event
$game_system.garden[$game_map.map_id] -= [plant]
return result
end
#===============================================================================
# ** Garden::Plant
#===============================================================================
class Plant
attr_reader :id, :ripe
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def initialize(id, seed1, seed2=nil)
if seed2 != nil
# Initialize needed instance variables.
@id, @seed1, @seed2, @single = id, seed1, seed2, false
else
# Initialize needed instance variables.
@id, @seed1, @single = id, seed1, true
end
@ripe, @stage = false, -1
# Run setup method, using data in Garden config for this plant's seeds
setup
end
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
# Similar to old method but adds a #
# check for the single flag #
#--------------------------------------#
def setup
# Store original graphic, direction, and pattern in variable.
event = $game_map.events[@id]
@original_event = [event.character_name, event.direction, event.pattern]
# Calculate the total duration of the seed combination.
if @single == true # If single then only the duration of that seed
@duration = Garden.growth_rate(@seed1)
else # IF double then duration of both seeds
@duration = (Garden.growth_rate(@seed1) + Garden.growth_rate(@seed2))
end
# Find the produce that this combination will grow into
if @single == true
@produce = Garden.produce_single(@seed1)
# Get a random produce from case Seed1 id
@produce = @produce[rand(@produce.size)]
else
comb = Garden::SEED_IDS.index(@seed1) + Garden::SEED_IDS.index(@seed2)
@produce = Garden.produce(comb)
@produce = @produce[rand(@produce.size)]
end
# Get the number of stages this plant will use, then setup counts for it
number, count = Garden.number_stages(@produce), 0
dur = (@duration / number.to_f).to_i
@stages = (0...number).to_a
@stages.collect! {|i| $game_system.garden_counter + (i * dur) }
# Refresh the plant to apply changes
refresh
end
def refresh
unless @ripe
# Initialize local variable that will determine if graphic needs redrawn.
previous = @stage
count = @stages.find_all {|rate| $game_system.garden_counter <= rate }
@stage = (@stages.size - count.size)
@ripe = (@stage >= @stages.size - 1)
# Redraw bitmap if needed.
change_graphic(@ripe) if previous != @stage
end
end
def change_graphic(final)
# Set local variable to this plant's event
event = $game_map.events[@id]
data = final ? Garden.final_graphic(@produce) :
Garden.stage_graphics(@stage)
# Apply graphical change by simply altering event's stance and source
event.character_name = data[0] # If you get an error on this line it means
# that the final or stage graphics have not been set up properly or that
# there is missing data in the config for a certain (pair of) item(s).
event.direction = (2 * data[2])
event.pattern = (data[1] - 1)
event.refresh
end
def restore_event
# Restore event to original state before planting.
event = $game_map.events[@id]
event.character_name = @original_event[0]
event.direction = @original_event[1]
event.pattern = @original_event[2]
end
def produce
# Return nil if not yet ripe, else return an item ID.
return (@ripe ? @produce : nil)
end
end
end
#===============================================================================
# ** Game_System
#===============================================================================
class Game_System
attr_accessor :garden, :garden_counter
alias zer0_garden_init initialize
def initialize
# Initialize variables used for the garden system.
@garden_counter = 0
@garden = {}
zer0_garden_init
end
alias zer0_garden_upd update
def update
# Increase garden counter and check if update is needed every second.
if (Graphics.frame_count % 40) == 0
@garden_counter += 1
# Check if current map has any plants on it. If so, refresh them.
if @garden[$game_map.map_id] != nil && !@garden[$game_map.map_id].empty?
@garden[$game_map.map_id].each {|plant| plant.refresh }
end
end
zer0_garden_upd
end
end
#===============================================================================
# ** Game_Event
#===============================================================================
class Game_Event
attr_accessor :character_name, :direction, :pattern
alias zer0_garden_event_refresh refresh
def refresh
# Normal refresh method.
zer0_garden_event_refresh
# Set flag for this event being a garden event.
@garden_event = (@page != nil && @page.list[0].code == 108 &&
@page.list[0].parameters[0] == 'Garden Event')
end
alias zer0_garden_upd update
def update
# Skip update method foe this event if it is a plant.
@garden_event ? return : zer0_garden_upd
end
alias zer0_garden_event_start start
def start
# Redefine the 'start' method if Garden Event flag is present.
if @garden_event
plants, harvest = $game_system.garden[$game_map.map_id], false
# Check if plant exists, and if so check if it is ripe.
pick = plants != nil ? (plants.find {|obj| obj.id == @id }) != nil : false
$scene = Scene_Garden.new(@id, pick)
else
zer0_garden_event_start
end
end
end
#===============================================================================
# ** Game_Map
#===============================================================================
class Game_Map
alias zer0_garden_setup setup
def setup(map_id)
zer0_garden_setup(map_id)
# Refresh each plant when map is set up
if $game_system.garden[@map_id] != nil
$game_system.garden[@map_id].each {|obj| obj.change_graphic(obj.ripe) }
end
end
end
#===============================================================================
# * Window_Seed
#===============================================================================
class Window_Seed < Window_Selectable
def initialize
super(160, 304, 320, 160)
self.index = 0
refresh
end
def refresh
# Clear the bitmap.
self.contents = self.contents.dispose if self.contents != nil
# Determine what seeds to display.
@seeds = Garden::SEED_IDS.collect {|id| $data_items[id] }
unless Garden::SEED_DISPLAY
@seeds.reject! {|seed| $game_party.item_number(seed.id) < 1 }
end
@item_max = @seeds.size
# Draw the items on the bitmap.
if @item_max > 0
self.contents = Bitmap.new(width - 32, @item_max * 32)
@seeds.each_index {|i|
item = @seeds[i]
number = $game_party.item_number(item.id)
self.contents.font.color = number > 0 ? normal_color : disabled_color
opacity = number > 0 ? 255 : 128
# Find icon bitmap and set it to window, and draw the text.
bitmap = RPG::Cache.icon(item.icon_name)
self.contents.blt(4, i*32+4, bitmap, Rect.new(0, 0, 24, 24), opacity)
self.contents.draw_text(32, i*32, 288, 32, item.name)
self.contents.draw_text(-32, i*32, 288, 32, ':', 2)
self.contents.draw_text(-4, i*32, 288, 32, number.to_s, 2)
}
end
end
def seed
# Returns currently highlighted seed item.
return @seeds[self.index]
end
end
#===============================================================================
# * Scene_Garden
#===============================================================================
class Scene_Garden
def initialize(id, harvest)
@event_id, @harvest = id, harvest
# Play SE to give impression that scene never changed.
$game_system.se_play($data_system.decision_se)
$game_player.straighten
garden = $game_system.garden[$game_map.map_id]
if garden != nil
@plant = garden.find {|plant| plant.id == id }
end
end
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def main
# Create map sprite and required windows.
@map, @help_window = Spriteset_Map.new, Window_Help.new
# Create Confirmation window.
@confirm_window = Window_Command.new(128, ['Yes', 'No'])
@confirm_window.x, @confirm_window.y = 496, 336
# Initialize sprites array. Used to handle all the sprites together.
@sprites = [@map, @help_window, @confirm_window]
# Create seed window if plant is not being harvested.
unless @harvest
@seed_window = Window_Seed.new
@sprites.push(@seed_window)
@seed_window.active = @seed_window.visible = false
# Create Seed Count window
@seed_count_window = Window_Command.new(192, ['Yes, plant 1 seed', 'Yes, plant 2 seeds', "No"])
@seed_count_window.x, @seed_count_window.y = 640 - 192 - 16, 480 - 3 * 24 - 96
@sprites.push(@seed_count_window)
@confirm_window.visible = @confirm_window.active = false
@help_window.set_text('Plant seeds here?')
else
@data = $game_system.garden[$game_map.map_id][@event_id]
if @plant != nil && @plant.ripe
text = 'This plant is ripe. Would you like to harvest it?'
else
text = 'Nothing is growing yet on this plant. Harvest it anyway?'
end
@help_window.set_text(text)
end
# Transition instantly then start main loop.
Graphics.transition(0)
loop { Graphics.update; Input.update; update; break if $scene != self }
# Dispose of all the sprites.
@sprites.each {|sprite| sprite.dispose }
# Have map refresh to update any changes made.
$game_map.need_refresh = true
end
def update
@sprites.each {|sprite| sprite.update }
# Branch update method depending on what window is active.
if @confirm_window.active
update_confirm
elsif @seed_count_window != nil && @seed_count_window.active
update_seed_count_select
elsif @seed_window != nil && @seed_window.active
update_seed_select
end
end
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def update_confirm
if Input.trigger?(Input::B)
# Branch by what action is being canceled.
if @harvest
back_to_map
else
cancel_seed_selection
end
elsif Input.trigger?(Input::C)
# Branch by what action is being confirmed.
if @harvest
if @confirm_window.index == 0
item_id = Garden.harvest(@event_id)
if item_id != nil
@confirm_window.active = @confirm_window.visible = false
# Gain item, play the harvest SE, then return to the map.
$game_party.gain_item(item_id, 1)
$game_system.se_play(RPG::AudioFile.new(Garden::HARVEST_SE, 80, 100))
show_results($data_items[item_id])
$scene = Scene_Map.new
else
back_to_map
end
else
back_to_map
end
else
# If asking if player would like to plant seeds at this location.
if @seed1 == nil
back_to_map
return
else # If confirming seed selection.
if @confirm_window.index == 0
# Plant seeds and return to map.
@single = @seed_count_window.index == 0
# This is how Twb6543 reloaded the single command (in case of index
# movement)
if @single == true && @seed2 == nil
# If Single only
Garden.plant_seeds(@event_id, @seed1.id)
else
# If Double or Includes Double Seed
Garden.plant_seeds(@event_id, @seed1.id, @seed2.id)
end
$scene = Scene_Map.new
else # If canceling seed selection
cancel_seed_selection
return
end
end
$game_system.se_play($data_system.decision_se)
end
end
end
def update_seed_count_select
if Input.trigger?(Input::B)
back_to_map
elsif Input.trigger?(Input::C)
case @seed_count_window.index
when 0
@seed_window.active = @seed_window.visible = true
@seed_count_window.active = @seed_count_window.visible = false
@help_window.set_text('Which seed would you like to plant?')
when 1
@seed_window.active = @seed_window.visible = true
@seed_count_window.active = @seed_count_window.visible = false
@help_window.set_text('Which seeds would you like to plant?')
when 2
back_to_map
return
end
$game_system.se_play($data_system.decision_se)
end
end
def show_results(result)
@help_window.contents.clear
# Display the message in the help window.
@help_window.draw_item_name(result, 0, 0)
cw = @help_window.contents.text_size(result.name).width + 32
@help_window.contents.draw_text(cw, 0, 608, 32, ' received!')
# Call Input.update to the clear key press.
Input.update
# Loop until it is pressed again.
until Input.trigger?(Input::C)
Graphics.update; Input.update; update
end
end
#------------------------------------------#
# - Double and Single Seed New Method - #
#------------------------------------------#
def cancel_seed_selection
# Play cancel SE, reset seeds, and activate/deactivate windows.
$game_system.se_play($data_system.cancel_se)
$game_party.gain_item(@seed1.id, 1) unless @seed1.nil? # Added to re add the seeds
$game_party.gain_item(@seed2.id, 1) unless @seed2.nil? # Added to re add the seeds
@seed_window.active = @seed_window.visible = true
@seed_window.refresh
@confirm_window.active = @confirm_window.visible = false
@help_window.set_text('Which seeds would you like to plant?')
@seed1 = @seed2 = nil
end
def back_to_map
# Play cancel SE and return to map.
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
end
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def update_seed_select
if Input.trigger?(Input::B)
# If first seed is selected, go back to re-select, else return to map.
if @seed1 != nil
cancel_seed_selection
else
back_to_map
end
elsif Input.trigger?(Input::C)
# Play Cancle SE if displayed and party has none.
if $game_party.item_number(@seed_window.seed.id) < 1
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
@single = @seed_count_window.index == 0
# Can use @idsingle = @seed_window.seed.id
if @single == true && @seed1 == nil
# Set first seed then continue
@seed1 = @seed_window.seed
$game_party.lose_item(@seed1.id, 1)
@seed_window.active = false
@confirm_window.active = @confirm_window.visible = true
elsif @single == true && @seed1 != nil
# Set second seed then continue
@seed2, @seed_window.active = @seed_window.seed, false
$game_party.lose_item(@seed2.id, 1)
@confirm_window.active = @confirm_window.visible = true
else # 2 seeds
# Set first seed if not defined, else set the second seed and continue.
if @seed1 == nil
@seed1 = @seed_window.seed
$game_party.lose_item(@seed1.id, 1)
else
@seed2, @seed_window.active = @seed_window.seed, false
$game_party.lose_item(@seed2.id, 1)
@confirm_window.active = @confirm_window.visible = true
end
end
# Refresh seed window to show changes in inventory.
set_help
@seed_window.refresh
end
end
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def set_help
# Clear help window.
@help_window.contents.clear
# Draw items
@single = @seed_count_window.index == 0
if @single == true && @seed2 == nil
text = 'Plant this seed?'
else
text = @seed2 != nil ? 'Plant these two seeds?' : 'Select second seed...'
end
@help_window.set_text(text)
@help_window.draw_item_name(@seed1, 224, 0)
if @seed2 != nil
cw = @help_window.contents.text_size(@seed1.name).width + 320
@help_window.draw_item_name(@seed2, cw, 0)
end
end
end