rgss3_default_scripts 1.0.2

data/lib/rgss3_default_scripts/Game_Timer.rb

@@ -0,0 +1,56 @@
+#==============================================================================
+# ** Game_Timer
+#------------------------------------------------------------------------------
+#  This class handles timers. Instances of this class are referenced by 
+# $game_timer.
+#==============================================================================
+
+class Game_Timer
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    @count = 0
+    @working = false
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    if @working && @count > 0
+      @count -= 1
+      on_expire if @count == 0
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Start
+  #--------------------------------------------------------------------------
+  def start(count)
+    @count = count
+    @working = true
+  end
+  #--------------------------------------------------------------------------
+  # * Stop
+  #--------------------------------------------------------------------------
+  def stop
+    @working = false
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Working
+  #--------------------------------------------------------------------------
+  def working?
+    @working
+  end
+  #--------------------------------------------------------------------------
+  # * Get Seconds
+  #--------------------------------------------------------------------------
+  def sec
+    @count / Graphics.frame_rate
+  end
+  #--------------------------------------------------------------------------
+  # * Processing When Timer Reaches 0
+  #--------------------------------------------------------------------------
+  def on_expire
+    BattleManager.abort
+  end
+end

data/lib/rgss3_default_scripts/Game_Troop.rb

@@ -0,0 +1,205 @@
+#==============================================================================
+# ** Game_Troop
+#------------------------------------------------------------------------------
+#  This class handles enemy groups and battle-related data. Also performs
+# battle events. The instance of this class is referenced by $game_troop.
+#==============================================================================
+
+class Game_Troop < Game_Unit
+  #--------------------------------------------------------------------------
+  # * Characters to be added to the end of enemy names
+  #--------------------------------------------------------------------------
+  LETTER_TABLE_HALF = [' A',' B',' C',' D',' E',' F',' G',' H',' I',' J',
+                       ' K',' L',' M',' N',' O',' P',' Q',' R',' S',' T',
+                       ' U',' V',' W',' X',' Y',' Z']
+  LETTER_TABLE_FULL = ['Ａ','Ｂ','Ｃ','Ｄ','Ｅ','Ｆ','Ｇ','Ｈ','Ｉ','Ｊ',
+                       'Ｋ','Ｌ','Ｍ','Ｎ','Ｏ','Ｐ','Ｑ','Ｒ','Ｓ','Ｔ',
+                       'Ｕ','Ｖ','Ｗ','Ｘ','Ｙ','Ｚ']
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_reader   :screen                   # battle screen state
+  attr_reader   :interpreter              # battle event interpreter
+  attr_reader   :event_flags              # battle event executed flag
+  attr_reader   :turn_count               # number of turns
+  attr_reader   :name_counts              # hash for enemy name appearance
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    super
+    @screen = Game_Screen.new
+    @interpreter = Game_Interpreter.new
+    @event_flags = {}
+    clear
+  end
+  #--------------------------------------------------------------------------
+  # * Get Members
+  #--------------------------------------------------------------------------
+  def members
+    @enemies
+  end
+  #--------------------------------------------------------------------------
+  # * Clear
+  #--------------------------------------------------------------------------
+  def clear
+    @screen.clear
+    @interpreter.clear
+    @event_flags.clear
+    @enemies = []
+    @turn_count = 0
+    @names_count = {}
+  end
+  #--------------------------------------------------------------------------
+  # * Get Troop Objects
+  #--------------------------------------------------------------------------
+  def troop
+    $data_troops[@troop_id]
+  end
+  #--------------------------------------------------------------------------
+  # * Setup
+  #--------------------------------------------------------------------------
+  def setup(troop_id)
+    clear
+    @troop_id = troop_id
+    @enemies = []
+    troop.members.each do |member|
+      next unless $data_enemies[member.enemy_id]
+      enemy = Game_Enemy.new(@enemies.size, member.enemy_id)
+      enemy.hide if member.hidden
+      enemy.screen_x = member.x
+      enemy.screen_y = member.y
+      @enemies.push(enemy)
+    end
+    init_screen_tone
+    make_unique_names
+  end
+  #--------------------------------------------------------------------------
+  # * Initialize Screen Tone
+  #--------------------------------------------------------------------------
+  def init_screen_tone
+    @screen.start_tone_change($game_map.screen.tone, 0) if $game_map
+  end
+  #--------------------------------------------------------------------------
+  # * Add letters (ABC, etc) to enemy characters with the same name
+  #--------------------------------------------------------------------------
+  def make_unique_names
+    members.each do |enemy|
+      next unless enemy.alive?
+      next unless enemy.letter.empty?
+      n = @names_count[enemy.original_name] || 0
+      enemy.letter = letter_table[n % letter_table.size]
+      @names_count[enemy.original_name] = n + 1
+    end
+    members.each do |enemy|
+      n = @names_count[enemy.original_name] || 0
+      enemy.plural = true if n >= 2
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Get Text Table to Place Behind Enemy Name
+  #--------------------------------------------------------------------------
+  def letter_table
+    $game_system.japanese? ? LETTER_TABLE_FULL : LETTER_TABLE_HALF
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    @screen.update
+  end
+  #--------------------------------------------------------------------------
+  # * Get Enemy Name Array
+  #    For display at start of battle. Overlapping names are removed.
+  #--------------------------------------------------------------------------
+  def enemy_names
+    names = []
+    members.each do |enemy|
+      next unless enemy.alive?
+      next if names.include?(enemy.original_name)
+      names.push(enemy.original_name)
+    end
+    names
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Battle Event (Page) Conditions Are Met
+  #--------------------------------------------------------------------------
+  def conditions_met?(page)
+    c = page.condition
+    if !c.turn_ending && !c.turn_valid && !c.enemy_valid &&
+       !c.actor_valid && !c.switch_valid
+      return false      # Conditions not set: not executed
+    end
+    if @event_flags[page]
+      return false      # Executed
+    end
+    if c.turn_ending    # At turn end
+      return false unless BattleManager.turn_end?
+    end
+    if c.turn_valid     # Number of turns
+      n = @turn_count
+      a = c.turn_a
+      b = c.turn_b
+      return false if (b == 0 && n != a)
+      return false if (b > 0 && (n < 1 || n < a || n % b != a % b))
+    end
+    if c.enemy_valid    # Enemy
+      enemy = $game_troop.members[c.enemy_index]
+      return false if enemy == nil
+      return false if enemy.hp_rate * 100 > c.enemy_hp
+    end
+    if c.actor_valid    # Actor
+      actor = $game_actors[c.actor_id]
+      return false if actor == nil 
+      return false if actor.hp_rate * 100 > c.actor_hp
+    end
+    if c.switch_valid   # Switch
+      return false if !$game_switches[c.switch_id]
+    end
+    return true         # Condition met
+  end
+  #--------------------------------------------------------------------------
+  # * Battle Event Setup
+  #--------------------------------------------------------------------------
+  def setup_battle_event
+    return if @interpreter.running?
+    return if @interpreter.setup_reserved_common_event
+    troop.pages.each do |page|
+      next unless conditions_met?(page)
+      @interpreter.setup(page.list)
+      @event_flags[page] = true if page.span <= 1
+      return
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Increase Turns
+  #--------------------------------------------------------------------------
+  def increase_turn
+    troop.pages.each {|page| @event_flags[page] = false if page.span == 1 }
+    @turn_count += 1
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Total Experience
+  #--------------------------------------------------------------------------
+  def exp_total
+    dead_members.inject(0) {|r, enemy| r += enemy.exp }
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Total Gold
+  #--------------------------------------------------------------------------
+  def gold_total
+    dead_members.inject(0) {|r, enemy| r += enemy.gold } * gold_rate
+  end
+  #--------------------------------------------------------------------------
+  # * Get Multiplier for Gold
+  #--------------------------------------------------------------------------
+  def gold_rate
+    $game_party.gold_double? ? 2 : 1
+  end
+  #--------------------------------------------------------------------------
+  # * Create Array of Dropped Items
+  #--------------------------------------------------------------------------
+  def make_drop_items
+    dead_members.inject([]) {|r, enemy| r += enemy.make_drop_items }
+  end
+end

data/lib/rgss3_default_scripts/Game_Unit.rb

@@ -0,0 +1,131 @@
+#==============================================================================
+# ** Game_Unit
+#------------------------------------------------------------------------------
+#  This class handles units. It's used as a superclass of the Game_Party and
+# and Game_Troop classes.
+#==============================================================================
+
+class Game_Unit
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_reader   :in_battle                # in battle flag
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    @in_battle = false
+  end
+  #--------------------------------------------------------------------------
+  # * Get Members
+  #--------------------------------------------------------------------------
+  def members
+    return []
+  end
+  #--------------------------------------------------------------------------
+  # * Get Array of Living Members
+  #--------------------------------------------------------------------------
+  def alive_members
+    members.select {|member| member.alive? }
+  end
+  #--------------------------------------------------------------------------
+  # * Get Array of Incapacitated Members
+  #--------------------------------------------------------------------------
+  def dead_members
+    members.select {|member| member.dead? }
+  end
+  #--------------------------------------------------------------------------
+  # * Get Array of Movable Members
+  #--------------------------------------------------------------------------
+  def movable_members
+    members.select {|member| member.movable? }
+  end
+  #--------------------------------------------------------------------------
+  # * Clear all Members' Battle Actions
+  #--------------------------------------------------------------------------
+  def clear_actions
+    members.each {|member| member.clear_actions }
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Average Value of Agility
+  #--------------------------------------------------------------------------
+  def agi
+    return 1 if members.size == 0
+    members.inject(0) {|r, member| r += member.agi } / members.size
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Total Target Rate
+  #--------------------------------------------------------------------------
+  def tgr_sum
+    alive_members.inject(0) {|r, member| r + member.tgr }
+  end
+  #--------------------------------------------------------------------------
+  # * Random Selection of Target
+  #--------------------------------------------------------------------------
+  def random_target
+    tgr_rand = rand * tgr_sum
+    alive_members.each do |member|
+      tgr_rand -= member.tgr
+      return member if tgr_rand < 0
+    end
+    alive_members[0]
+  end
+  #--------------------------------------------------------------------------
+  # * Randomly Determine Target (K.O.)
+  #--------------------------------------------------------------------------
+  def random_dead_target
+    dead_members.empty? ? nil : dead_members[rand(dead_members.size)]
+  end
+  #--------------------------------------------------------------------------
+  # * Smooth Selection of Target
+  #--------------------------------------------------------------------------
+  def smooth_target(index)
+    member = members[index]
+    (member && member.alive?) ? member : alive_members[0]
+  end
+  #--------------------------------------------------------------------------
+  # * Smooth Selection of Target (K.O.)
+  #--------------------------------------------------------------------------
+  def smooth_dead_target(index)
+    member = members[index]
+    (member && member.dead?) ? member : dead_members[0]
+  end
+  #--------------------------------------------------------------------------
+  # * Clear Action Results
+  #--------------------------------------------------------------------------
+  def clear_results
+    members.select {|member| member.result.clear }
+  end
+  #--------------------------------------------------------------------------
+  # * Processing at Start of Battle
+  #--------------------------------------------------------------------------
+  def on_battle_start
+    members.each {|member| member.on_battle_start }
+    @in_battle = true
+  end
+  #--------------------------------------------------------------------------
+  # * Processing at End of Battle
+  #--------------------------------------------------------------------------
+  def on_battle_end
+    @in_battle = false
+    members.each {|member| member.on_battle_end }
+  end
+  #--------------------------------------------------------------------------
+  # * Create Battle Action
+  #--------------------------------------------------------------------------
+  def make_actions
+    members.each {|member| member.make_actions }
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Everyone is Dead
+  #--------------------------------------------------------------------------
+  def all_dead?
+    alive_members.empty?
+  end
+  #--------------------------------------------------------------------------
+  # * Get Substitute Battler
+  #--------------------------------------------------------------------------
+  def substitute_battler
+    members.find {|member| member.substitute? }
+  end
+end

data/lib/rgss3_default_scripts/Game_Variables.rb

@@ -0,0 +1,34 @@
+#==============================================================================
+# ** Game_Variables
+#------------------------------------------------------------------------------
+#  This class handles variables. It's a wrapper for the built-in class "Array."
+# The instance of this class is referenced by $game_variables.
+#==============================================================================
+
+class Game_Variables
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    @data = []
+  end
+  #--------------------------------------------------------------------------
+  # * Get Variable
+  #--------------------------------------------------------------------------
+  def [](variable_id)
+    @data[variable_id] || 0
+  end
+  #--------------------------------------------------------------------------
+  # * Set Variable
+  #--------------------------------------------------------------------------
+  def []=(variable_id, value)
+    @data[variable_id] = value
+    on_change
+  end
+  #--------------------------------------------------------------------------
+  # * Processing When Setting Variables
+  #--------------------------------------------------------------------------
+  def on_change
+    $game_map.need_refresh = true
+  end
+end

data/lib/rgss3_default_scripts/Game_Vehicle.rb

@@ -0,0 +1,193 @@
+#==============================================================================
+# ** Game_Vehicle
+#------------------------------------------------------------------------------
+#  This class handles vehicles. It's used within the Game_Map class. If there
+# are no vehicles on the current map, the coordinates are set to (-1,-1).
+#==============================================================================
+
+class Game_Vehicle < Game_Character
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_reader   :altitude                 # altitude (for airships)
+  attr_reader   :driving                  # driving flag
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #     type:  vehicle type (:boat, :ship, :airship)
+  #--------------------------------------------------------------------------
+  def initialize(type)
+    super()
+    @type = type
+    @altitude = 0
+    @driving = false
+    @direction = 4
+    @walk_anime = false
+    @step_anime = false
+    @walking_bgm = nil
+    init_move_speed
+    load_system_settings
+  end
+  #--------------------------------------------------------------------------
+  # * Initialize Move Speed
+  #--------------------------------------------------------------------------
+  def init_move_speed
+    @move_speed = 4 if @type == :boat
+    @move_speed = 5 if @type == :ship
+    @move_speed = 6 if @type == :airship
+  end
+  #--------------------------------------------------------------------------
+  # * Get System Settings
+  #--------------------------------------------------------------------------
+  def system_vehicle
+    return $data_system.boat    if @type == :boat
+    return $data_system.ship    if @type == :ship
+    return $data_system.airship if @type == :airship
+    return nil
+  end
+  #--------------------------------------------------------------------------
+  # * Load System Settings
+  #--------------------------------------------------------------------------
+  def load_system_settings
+    @map_id           = system_vehicle.start_map_id
+    @x                = system_vehicle.start_x
+    @y                = system_vehicle.start_y
+    @character_name   = system_vehicle.character_name
+    @character_index  = system_vehicle.character_index
+  end
+  #--------------------------------------------------------------------------
+  # * Refresh
+  #--------------------------------------------------------------------------
+  def refresh
+    if @driving
+      @map_id = $game_map.map_id
+      sync_with_player
+    elsif @map_id == $game_map.map_id
+      moveto(@x, @y)
+    end
+    if @type == :airship
+      @priority_type = @driving ? 2 : 0
+    else
+      @priority_type = 1
+    end
+    @walk_anime = @step_anime = @driving
+  end
+  #--------------------------------------------------------------------------
+  # * Change Position
+  #--------------------------------------------------------------------------
+  def set_location(map_id, x, y)
+    @map_id = map_id
+    @x = x
+    @y = y
+    refresh
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Coordinate Match
+  #--------------------------------------------------------------------------
+  def pos?(x, y)
+    @map_id == $game_map.map_id && super(x, y)
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Transparency
+  #--------------------------------------------------------------------------
+  def transparent
+    @map_id != $game_map.map_id || super
+  end
+  #--------------------------------------------------------------------------
+  # * Board Vehicle
+  #--------------------------------------------------------------------------
+  def get_on
+    @driving = true
+    @walk_anime = true
+    @step_anime = true
+    @walking_bgm = RPG::BGM.last
+    system_vehicle.bgm.play
+  end
+  #--------------------------------------------------------------------------
+  # * Get Off Vehicle
+  #--------------------------------------------------------------------------
+  def get_off
+    @driving = false
+    @walk_anime = false
+    @step_anime = false
+    @direction = 4
+    @walking_bgm.play
+  end
+  #--------------------------------------------------------------------------
+  # * Synchronize With Player 
+  #--------------------------------------------------------------------------
+  def sync_with_player
+    @x = $game_player.x
+    @y = $game_player.y
+    @real_x = $game_player.real_x
+    @real_y = $game_player.real_y
+    @direction = $game_player.direction
+    update_bush_depth
+  end
+  #--------------------------------------------------------------------------
+  # * Get Move Speed
+  #--------------------------------------------------------------------------
+  def speed
+    @move_speed
+  end
+  #--------------------------------------------------------------------------
+  # * Get Screen Y-Coordinates
+  #--------------------------------------------------------------------------
+  def screen_y
+    super - altitude
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Movement is Possible
+  #--------------------------------------------------------------------------
+  def movable?
+    !moving? && !(@type == :airship && @altitude < max_altitude)
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    super
+    update_airship_altitude if @type == :airship
+  end
+  #--------------------------------------------------------------------------
+  # * Update Airship Altitude
+  #--------------------------------------------------------------------------
+  def update_airship_altitude
+    if @driving
+      @altitude += 1 if @altitude < max_altitude && takeoff_ok?
+    elsif @altitude > 0
+      @altitude -= 1
+      @priority_type = 0 if @altitude == 0
+    end
+    @step_anime = (@altitude == max_altitude)
+    @priority_type = 2 if @altitude > 0
+  end
+  #--------------------------------------------------------------------------
+  # * Get Maximum Altitude of Airship
+  #--------------------------------------------------------------------------
+  def max_altitude
+    return 32
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Takeoff Is Possible
+  #--------------------------------------------------------------------------
+  def takeoff_ok?
+    $game_player.followers.gather?
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Docking/Landing Is Possible
+  #     d:  Direction (2,4,6,8)
+  #--------------------------------------------------------------------------
+  def land_ok?(x, y, d)
+    if @type == :airship
+      return false unless $game_map.airship_land_ok?(x, y)
+      return false unless $game_map.events_xy(x, y).empty?
+    else
+      x2 = $game_map.round_x_with_direction(x, d)
+      y2 = $game_map.round_y_with_direction(y, d)
+      return false unless $game_map.valid?(x2, y2)
+      return false unless $game_map.passable?(x2, y2, reverse_dir(d))
+      return false if collide_with_characters?(x2, y2)
+    end
+    return true
+  end
+end