#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Dynamic Gardening
# Authors: ForeverZer0, Twb6543
# Date: 7.17.2011
# Version: v.3.2
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# 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)
# -
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#
# 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 = [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48]
# 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
SINGLE_IDS = [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48]
# IDS of the items in the database that are seeds that are grown singularly.
# These can be any Id's (They used to have to be different to the SEED_IDS)
# Any reference to SEED_ID in the Configuration also refers to this
HARVEST_SE = '056-Right02'
# This is the SE that will be played when the player harvests the plant.
SEED_DISPLAY = false
# 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 33 then 300
when 34 then 600
when 35 then 900
when 36 then 900
when 37 then 600
when 38 then 720
when 39 then 960
when 40 then 1200
when 41 then 1080
when 42 then 960
when 43 then 1020
when 44 then 1200
when 45 then 1500
when 46 then 1500
when 47 then 1800
when 48 then 2700
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 49
then @Result_drievijf
return 2
when 50
then @Result_driezes
return 2
when 51
then @Result_driezeven
return 2
when 52
then @Result_drieacht
return 2
when 53
then @Result_drienegen
return 2
when 54
then @Result_viernul
return 2
when 55
then @Result_viereen
return 2
when 56
then @Result_viertwee
return 2
when 57
then @Result_vierdrie
return 2
when 58
then @Result_viervier
return 2
when 59
then @Result_viervijf
return 2
when 60
then @Result_vierzes
return 2
when 61
then @Result_vierzeven
return 2
when 62
then @Result_vieracht
return 2
when 63
then @Result_driedrie
return 2
when 64
then @Result_drievier
return 2
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 [63, 63] # Only if both seed are the lowest seeds
when 1 then [64, 64]
when 2 then [49, 49]
when 3 then [50, 50]
when 4 then [51, 51]
when 5 then [52, 52]
when 6 then [53, 53] # Every combination in between
when 7 then [54, 54]
when 8 then [55, 55]
when 9 then [56, 56]
when 10 then [57, 57]
when 11 then [58, 58]
when 12 then [59, 59]
when 13 then [60, 60]
when 14 then [61, 61]
when 15 then [62, 62] # Only if both seeds are the highest seeds
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 33 then [63, 63]
when 34 then [64, 64]
when 35 then [49, 49]
when 36 then [50, 50]
when 37 then [51, 51]
when 38 then [52, 52]
when 39 then [53, 53]
when 40 then [54, 54]
when 41 then [55, 55]
when 42 then [56, 56]
when 43 then [57, 57]
when 44 then [58, 58]
when 45 then [59, 59]
when 46 then [60, 60]
when 47 then [61, 61]
when 48 then [62, 62]
else
[49] # 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.final_graphic(item)
return case item
when 49 then ['3334', 3, 1]
when 50 then ['3334', 3, 3]
when 51 then ['4546', 4, 1]
when 52 then ['4142', 3, 1]
when 53 then ['3738', 3, 1]
when 54 then ['3940', 3, 1]
when 55 then ['4344', 3, 3]
when 56 then ['3536', 3, 3]
when 57 then ['4546', 4, 3]
when 58 then ['4142', 3, 3]
when 59 then ['3536', 3, 1]
when 60 then ['3940', 3, 3]
when 61 then ['4748', 4, 1]
when 62 then ['4344', 3, 1]
when 63 then ['3738', 3, 3]
when 64 then ['4748', 4, 3]
end
end
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END CONFIGURATION
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# Stage Configuration #
class Result_drievijf
@Result_drievijf = Result_drievijf.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3334', 1, 1]
when 1 then ['3334', 2, 1]
return
end
end
end
class Result_driezes
@Result_driezes = Result_driezes.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3334', 1, 3]
when 1 then ['3334', 2, 3]
end
end
end
class Result_driezeven
@Result_driezeven = Result_driezeven.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4546', 2, 1]
when 1 then ['4546', 3, 1]
end
end
end
class Result_drieacht
@Result_drieacht = Result_drieacht.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4142', 1, 1]
when 1 then ['4142', 2, 1]
end
end
end
class Result_drienegen
@Result_drienegen = Result_drienegen.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3738', 1, 1]
when 1 then ['3738', 2, 1]
end
end
end
class Result_viernul
@Result_viernul = Result_viernul.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3940', 1, 1]
when 1 then ['3940', 2, 1]
end
end
end
class Result_viereen
@Result_viereen = Result_viereen.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4344', 1, 3]
when 1 then ['4344', 2, 3]
end
end
end
class Result_viertwee
@Result_viertwee = Result_viertwee.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3536', 1, 3]
when 1 then ['3536', 2, 3]
end
end
end
class Result_vierdrie
@Result_vierdrie = Result_vierdrie.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4546', 2, 3]
when 1 then ['4546', 3, 3]
end
end
end
class Result_viervier
@Result_viervier = Result_viervier.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4142', 1, 3]
when 1 then ['4142', 2, 3]
end
end
end
class Result_viervijf
@Result_viervijf = Result_viervijf.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3536', 1, 1]
when 1 then ['3536', 2, 1]
end
end
end
class Result_vierzes
@Result_vierzes = Result_vierzes.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3940', 1, 3]
when 1 then ['3940', 2, 3]
end
end
end
class Result_vierzeven
@Result_vierzeven = Result_vierzeven.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4748', 2, 1]
when 1 then ['4748', 3, 1]
end
end
end
class Result_vieracht
@Result_vieracht = Result_vieracht.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4344', 1, 1]
when 1 then ['4344', 2, 1]
end
end
end
class Result_driedrie
@Result_driedrie = Result_driedrie.new
def self.stage_graphics(stage)
return case stage
when 0 then ['3738', 1, 3]
when 1 then ['3738', 2, 3]
end
end
end
class Result_drievier
@Result_drievier = Result_drievier.new
def self.stage_graphics(stage)
return case stage
when 0 then ['4748', 2, 3]
when 1 then ['4748', 3, 3]
end
end
end
#--------------------------------------#
# - 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
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def initialize
super(160, 304, 320, 160)
@seednum1 = false
self.index = 0
refresh
end
#--------------------------------------#
# - Double and Single Seed Method - #
#--------------------------------------#
def refresh
# Clear the bitmap.
self.contents = self.contents.dispose if self.contents != nil
# Determine what seeds to display.
# makes an array of all Ids
if @ids_add == nil
@dup = Garden::SEED_IDS.dup
@ids_add = Garden::SINGLE_IDS.dup
@ids_add.each {|val|
if @dup.include?(val)
@ids_add.delete(val)
end
}
# This is the one line that caused the last bug
# I was using .concat() instead of + so dup
# also contained the single ids...
@idss = @dup + @ids_add
end
# If compacting does something
# (.compact! return nil when nothing happens)
if @idss.compact! != nil
@ids = @idss.compact!
else
@ids = @idss
end
if @dup.compact! != nil
@idse = @dup.compact!
else
@idse = @dup
end
@seeds = nil
@seeds = @ids.collect {|id| $data_items[id]}
unless @seednum1 == false
@seeds = nil
@seeds = @idse.collect {|id| $data_items[id]}
end
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
if @seednum1 != true
@seednum1 = true
end
end
def seed
# Returns currently highlighted seed item.
return @seeds[self.index]
end
#------------------------------------------#
# - Double and Single Seed New Method - #
#------------------------------------------#
def resetseed
@seednum1 = false
end
#------------------------------------------#
# - Double and Single Seed New Method - #
#------------------------------------------#
# Just use seed.id instead it's much #
# easier #
#------------------------------------------#
# Here for the sake of History #
#------------------------------------------#
def seedid
return @seeds[self.index].id
end
#------------------------------------------#
# - Double and Single Seed New Method - #
#------------------------------------------#
def single(id=nil)
# This could be optimised into
# result = Garden::SINGLE_IDS.includes?(seed.id)=true&&id=nil ? True : False
# or
# result = Garden::SINGLE_IDS.includes?(seed.id)&&id==nil ? True : False
result = false
if Garden::SINGLE_IDS.include?(seedid) && id == nil
# Can use seed.id
result = true
end
# This part could be optimised into
# result = id !=nil ? Garden::SINGLE_IDS.include?(id) : result
if id != nil
result = Garden::SINGLE_IDS.include?(id)
end
return result
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_Help2.new
# Create Confirmation window.
@confirm_window = Window_Command.new(128, ['Ja', 'Nee'])
@confirm_window.x, @confirm_window.y = 496, 336
# Used in Set_Help
@r = 0
# 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
@help_window.set_text('Hier planten?')
else
@data = $game_system.garden[$game_map.map_id][@event_id]
if @plant != nil && @plant.ripe
text = 'Deze plant is rijp. Wil je oogsten?'
else
text = 'Er groeit nog niks aan deze plant. Weghalen?'
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_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
@seed1 == nil ? back_to_map : 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
if @confirm_window.index == 0
@seed_window.active = @seed_window.visible = true
@confirm_window.active = @confirm_window.visible = false
@help_window.set_text('Welke plant wil je verbouwen?')
else
back_to_map
return
end
else # If confirming seed selection.
if @confirm_window.index == 0
# Plant seeds and return to map.
@single = @seed_window.single(@idsingle)
# 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
if Garden::SEED_IDS.include?(@seed1.id) && @seed2 == nil
cancel_single
else
cancel_seed_selection
end
return
end
end
$game_system.se_play($data_system.decision_se)
end
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, ' +1')
# 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_single
@seed_window.active = @seed_window.visible = true
@confirm_window.active = @confirm_window.visible = false
@r = 1
set_help
@seed_window.refresh
end
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) # Added to re add the seeds
$game_party.gain_item(@seed2.id, 1) # Added to re add the seeds
@seed_window.active = @seed_window.visible = true
@confirm_window.active = @confirm_window.visible = false
@r = 0
@help_window.set_text('Welke plant wil je verbouwen?')
@seed1 = @seed2 = nil
@seed_window.resetseed
@seed_window.refresh
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
$game_party.gain_item(@seed1.id, 1) # Regain seed
@seed_window.resetseed
@seed1 = nil
@seed_window.refresh
$game_system.se_play($data_system.cancel_se)
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_window.single
@idsingle = @seed_window.seedid # How Twb6543 set the Id
# 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
elsif @single != true
# 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_window.single(@idsingle)
if @single == true && @seed2 == nil && @r == 0
text = 'Deze plant verbouwen?'
else
text = @seed2 != nil ? '..' : '..'
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