[XP] Dynamic Gardening v.3.0

[Zvarr]

Autor:
ForeverZer0

Skrypt:

Spoiler: (Otwórz)

Kod: (Zaznacz wszystko)

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:​
# Dynamic Gardening
# Author: ForeverZer0
# Date: 5.13.2011
# Version: v.3.0
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:​
#                            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
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:​
#
# 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.
#
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::​
#  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
  
  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
    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.
#-------------------------------------------------------------------------------

  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
    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
#:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::​

  def self.plant_seeds(seed1, seed2, event_id)
    # Create a new instance of a Garden::Plant
    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
  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
    
    def initialize(id, seed1, seed2)
      # Initialize needed instance variables.
      @id, @seed1, @seed2 = id, seed1, seed2
      @ripe, @stage = false, -1
      # Run setup method, using data in Garden config for this plant's seeds
      setup
    end
    
    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.
      @duration = (Garden.growth_rate(@seed1) + Garden.growth_rate(@seed2))
      # Find the produce that this combination will grow into
      comb = Garden::SEED_IDS.index(@seed1) + Garden::SEED_IDS.index(@seed2)
      @produce = Garden.produce(comb)
      @produce = @produce[rand(@produce.size)]
      # 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]
      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
  
  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
      @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_window != nil && @seed_window.active
      update_seed_select
    end
  end
  
  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('Which seeds would you like to plant?')
          else
            back_to_map
            return
          end
        else # If confirming seed selection.
          if @confirm_window.index == 0
            # Plant seeds and return to map.
            Garden.plant_seeds(@seed1.id, @seed2.id, @event_id)
            $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 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
  
  def cancel_seed_selection
    # Play cancel SE, reset seeds, and activate/deactivate windows.
    $game_system.se_play($data_system.cancel_se)
    @seed_window.active = @seed_window.visible = true
    @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
  
  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)
        @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)
      # 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
      # Refresh seed window to show changes in inventory.
      set_help
      @seed_window.refresh
    end
  end
  
  def set_help
    # Clear help window.
    @help_window.contents.clear
    # Draw items
    text = @seed2 != nil ? 'Plant these two seeds?' : 'Select second seed...'
    @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

Screeny:

Spoiler: (Otwórz)

Dodatkowe informacje:
Skrypt wywołujemy komentarzem: "Garden Event"
Potrzebne graficzki:
- "Garden Plants"
- "Plants1"