rmxp_extractor 1.8 → 1.9

data/Scripts/Game_BattleAction.rb

@@ -1,145 +0,0 @@
-#==============================================================================
-# ** Game_BattleAction
-#------------------------------------------------------------------------------
-#  This class handles actions in battle. It's used within the Game_Battler
-#  class.
-#==============================================================================
-
-class Game_BattleAction
-  #--------------------------------------------------------------------------
-  # * Public Instance Variables
-  #--------------------------------------------------------------------------
-  attr_accessor :speed                    # speed
-  attr_accessor :kind                     # kind (basic / skill / item)
-  attr_accessor :basic                    # basic (attack / guard / escape)
-  attr_accessor :skill_id                 # skill ID
-  attr_accessor :item_id                  # item ID
-  attr_accessor :target_index             # target index
-  attr_accessor :forcing                  # forced flag
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #--------------------------------------------------------------------------
-  def initialize
-    clear
-  end
-  #--------------------------------------------------------------------------
-  # * Clear
-  #--------------------------------------------------------------------------
-  def clear
-    @speed = 0
-    @kind = 0
-    @basic = 3
-    @skill_id = 0
-    @item_id = 0
-    @target_index = -1
-    @forcing = false
-  end
-  #--------------------------------------------------------------------------
-  # * Determine Validity
-  #--------------------------------------------------------------------------
-  def valid?
-    return (not (@kind == 0 and @basic == 3))
-  end
-  #--------------------------------------------------------------------------
-  # * Determine if for One Ally
-  #--------------------------------------------------------------------------
-  def for_one_friend?
-    # If kind = skill, and effect scope is for ally (including 0 HP)
-    if @kind == 1 and [3, 5].include?($data_skills[@skill_id].scope)
-      return true
-    end
-    # If kind = item, and effect scope is for ally (including 0 HP)
-    if @kind == 2 and [3, 5].include?($data_items[@item_id].scope)
-      return true
-    end
-    return false
-  end
-  #--------------------------------------------------------------------------
-  # * Determine if for One Ally (HP 0)
-  #--------------------------------------------------------------------------
-  def for_one_friend_hp0?
-    # If kind = skill, and effect scope is for ally (only 0 HP)
-    if @kind == 1 and [5].include?($data_skills[@skill_id].scope)
-      return true
-    end
-    # If kind = item, and effect scope is for ally (only 0 HP)
-    if @kind == 2 and [5].include?($data_items[@item_id].scope)
-      return true
-    end
-    return false
-  end
-  #--------------------------------------------------------------------------
-  # * Random Target (for Actor)
-  #--------------------------------------------------------------------------
-  def decide_random_target_for_actor
-    # Diverge with effect scope
-    if for_one_friend_hp0?
-      battler = $game_party.random_target_actor_hp0
-    elsif for_one_friend?
-      battler = $game_party.random_target_actor
-    else
-      battler = $game_troop.random_target_enemy
-    end
-    # If a target exists, get an index, and if a target doesn't exist,
-    # clear the action
-    if battler != nil
-      @target_index = battler.index
-    else
-      clear
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Random Target (for Enemy)
-  #--------------------------------------------------------------------------
-  def decide_random_target_for_enemy
-    # Diverge with effect scope
-    if for_one_friend_hp0?
-      battler = $game_troop.random_target_enemy_hp0
-    elsif for_one_friend?
-      battler = $game_troop.random_target_enemy
-    else
-      battler = $game_party.random_target_actor
-    end
-    # If a target exists, get an index, and if a target doesn't exist,
-    # clear the action
-    if battler != nil
-      @target_index = battler.index
-    else
-      clear
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Last Target (for Actor)
-  #--------------------------------------------------------------------------
-  def decide_last_target_for_actor
-    # If effect scope is ally, then it's an actor, anything else is an enemy
-    if @target_index == -1
-      battler = nil
-    elsif for_one_friend?
-      battler = $game_party.actors[@target_index]
-    else
-      battler = $game_troop.enemies[@target_index]
-    end
-    # Clear action if no target exists
-    if battler == nil or not battler.exist?
-      clear
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Last Target (for Enemy)
-  #--------------------------------------------------------------------------
-  def decide_last_target_for_enemy
-    # If effect scope is ally, then it's an enemy, anything else is an actor
-    if @target_index == -1
-      battler = nil
-    elsif for_one_friend?
-      battler = $game_troop.enemies[@target_index]
-    else
-      battler = $game_party.actors[@target_index]
-    end
-    # Clear action if no target exists
-    if battler == nil or not battler.exist?
-      clear
-    end
-  end
-end

data/Scripts/Game_Battler 1.rb

@@ -1,307 +0,0 @@
-#==============================================================================
-# ** Game_Battler (part 1)
-#------------------------------------------------------------------------------
-#  This class deals with battlers. It's used as a superclass for the Game_Actor
-#  and Game_Enemy classes.
-#==============================================================================
-
-class Game_Battler
-  #--------------------------------------------------------------------------
-  # * Public Instance Variables
-  #--------------------------------------------------------------------------
-  attr_reader   :battler_name             # battler file name
-  attr_reader   :battler_hue              # battler hue
-  attr_reader   :hp                       # HP
-  attr_reader   :sp                       # SP
-  attr_reader   :states                   # states
-  attr_accessor :hidden                   # hidden flag
-  attr_accessor :immortal                 # immortal flag
-  attr_accessor :damage_pop               # damage display flag
-  attr_accessor :damage                   # damage value
-  attr_accessor :critical                 # critical flag
-  attr_accessor :animation_id             # animation ID
-  attr_accessor :animation_hit            # animation hit flag
-  attr_accessor :white_flash              # white flash flag
-  attr_accessor :blink                    # blink flag
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #--------------------------------------------------------------------------
-  def initialize
-    @battler_name = ""
-    @battler_hue = 0
-    @hp = 0
-    @sp = 0
-    @states = []
-    @states_turn = {}
-    @maxhp_plus = 0
-    @maxsp_plus = 0
-    @str_plus = 0
-    @dex_plus = 0
-    @agi_plus = 0
-    @int_plus = 0
-    @hidden = false
-    @immortal = false
-    @damage_pop = false
-    @damage = nil
-    @critical = false
-    @animation_id = 0
-    @animation_hit = false
-    @white_flash = false
-    @blink = false
-    @current_action = Game_BattleAction.new
-  end
-  #--------------------------------------------------------------------------
-  # * Get Maximum HP
-  #--------------------------------------------------------------------------
-  def maxhp
-    n = [[base_maxhp + @maxhp_plus, 1].max, 999999].min
-    for i in @states
-      n *= $data_states[i].maxhp_rate / 100.0
-    end
-    n = [[Integer(n), 1].max, 999999].min
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Get Maximum SP
-  #--------------------------------------------------------------------------
-  def maxsp
-    n = [[base_maxsp + @maxsp_plus, 0].max, 9999].min
-    for i in @states
-      n *= $data_states[i].maxsp_rate / 100.0
-    end
-    n = [[Integer(n), 0].max, 9999].min
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Get Strength (STR)
-  #--------------------------------------------------------------------------
-  def str
-    n = [[base_str + @str_plus, 1].max, 999].min
-    for i in @states
-      n *= $data_states[i].str_rate / 100.0
-    end
-    n = [[Integer(n), 1].max, 999].min
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Get Dexterity (DEX)
-  #--------------------------------------------------------------------------
-  def dex
-    n = [[base_dex + @dex_plus, 1].max, 999].min
-    for i in @states
-      n *= $data_states[i].dex_rate / 100.0
-    end
-    n = [[Integer(n), 1].max, 999].min
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Get Agility (AGI)
-  #--------------------------------------------------------------------------
-  def agi
-    n = [[base_agi + @agi_plus, 1].max, 999].min
-    for i in @states
-      n *= $data_states[i].agi_rate / 100.0
-    end
-    n = [[Integer(n), 1].max, 999].min
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Get Intelligence (INT)
-  #--------------------------------------------------------------------------
-  def int
-    n = [[base_int + @int_plus, 1].max, 999].min
-    for i in @states
-      n *= $data_states[i].int_rate / 100.0
-    end
-    n = [[Integer(n), 1].max, 999].min
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Set Maximum HP
-  #     maxhp : new maximum HP
-  #--------------------------------------------------------------------------
-  def maxhp=(maxhp)
-    @maxhp_plus += maxhp - self.maxhp
-    @maxhp_plus = [[@maxhp_plus, -9999].max, 9999].min
-    @hp = [@hp, self.maxhp].min
-  end
-  #--------------------------------------------------------------------------
-  # * Set Maximum SP
-  #     maxsp : new maximum SP
-  #--------------------------------------------------------------------------
-  def maxsp=(maxsp)
-    @maxsp_plus += maxsp - self.maxsp
-    @maxsp_plus = [[@maxsp_plus, -9999].max, 9999].min
-    @sp = [@sp, self.maxsp].min
-  end
-  #--------------------------------------------------------------------------
-  # * Set Strength (STR)
-  #     str : new Strength (STR)
-  #--------------------------------------------------------------------------
-  def str=(str)
-    @str_plus += str - self.str
-    @str_plus = [[@str_plus, -999].max, 999].min
-  end
-  #--------------------------------------------------------------------------
-  # * Set Dexterity (DEX)
-  #     dex : new Dexterity (DEX)
-  #--------------------------------------------------------------------------
-  def dex=(dex)
-    @dex_plus += dex - self.dex
-    @dex_plus = [[@dex_plus, -999].max, 999].min
-  end
-  #--------------------------------------------------------------------------
-  # * Set Agility (AGI)
-  #     agi : new Agility (AGI)
-  #--------------------------------------------------------------------------
-  def agi=(agi)
-    @agi_plus += agi - self.agi
-    @agi_plus = [[@agi_plus, -999].max, 999].min
-  end
-  #--------------------------------------------------------------------------
-  # * Set Intelligence (INT)
-  #     int : new Intelligence (INT)
-  #--------------------------------------------------------------------------
-  def int=(int)
-    @int_plus += int - self.int
-    @int_plus = [[@int_plus, -999].max, 999].min
-  end
-  #--------------------------------------------------------------------------
-  # * Get Hit Rate
-  #--------------------------------------------------------------------------
-  def hit
-    n = 100
-    for i in @states
-      n *= $data_states[i].hit_rate / 100.0
-    end
-    return Integer(n)
-  end
-  #--------------------------------------------------------------------------
-  # * Get Attack Power
-  #--------------------------------------------------------------------------
-  def atk
-    n = base_atk
-    for i in @states
-      n *= $data_states[i].atk_rate / 100.0
-    end
-    return Integer(n)
-  end
-  #--------------------------------------------------------------------------
-  # * Get Physical Defense Power
-  #--------------------------------------------------------------------------
-  def pdef
-    n = base_pdef
-    for i in @states
-      n *= $data_states[i].pdef_rate / 100.0
-    end
-    return Integer(n)
-  end
-  #--------------------------------------------------------------------------
-  # * Get Magic Defense Power
-  #--------------------------------------------------------------------------
-  def mdef
-    n = base_mdef
-    for i in @states
-      n *= $data_states[i].mdef_rate / 100.0
-    end
-    return Integer(n)
-  end
-  #--------------------------------------------------------------------------
-  # * Get Evasion Correction
-  #--------------------------------------------------------------------------
-  def eva
-    n = base_eva
-    for i in @states
-      n += $data_states[i].eva
-    end
-    return n
-  end
-  #--------------------------------------------------------------------------
-  # * Change HP
-  #     hp : new HP
-  #--------------------------------------------------------------------------
-  def hp=(hp)
-    @hp = [[hp, maxhp].min, 0].max
-    # add or exclude incapacitation
-    for i in 1...$data_states.size
-      if $data_states[i].zero_hp
-        if self.dead?
-          add_state(i)
-        else
-          remove_state(i)
-        end
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Change SP
-  #     sp : new SP
-  #--------------------------------------------------------------------------
-  def sp=(sp)
-    @sp = [[sp, maxsp].min, 0].max
-  end
-  #--------------------------------------------------------------------------
-  # * Recover All
-  #--------------------------------------------------------------------------
-  def recover_all
-    @hp = maxhp
-    @sp = maxsp
-    for i in @states.clone
-      remove_state(i)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Get Current Action
-  #--------------------------------------------------------------------------
-  def current_action
-    return @current_action
-  end
-  #--------------------------------------------------------------------------
-  # * Determine Action Speed
-  #--------------------------------------------------------------------------
-  def make_action_speed
-    @current_action.speed = agi + rand(10 + agi / 4)
-  end
-  #--------------------------------------------------------------------------
-  # * Decide Incapacitation
-  #--------------------------------------------------------------------------
-  def dead?
-    return (@hp == 0 and not @immortal)
-  end
-  #--------------------------------------------------------------------------
-  # * Decide Existance
-  #--------------------------------------------------------------------------
-  def exist?
-    return (not @hidden and (@hp > 0 or @immortal))
-  end
-  #--------------------------------------------------------------------------
-  # * Decide HP 0
-  #--------------------------------------------------------------------------
-  def hp0?
-    return (not @hidden and @hp == 0)
-  end
-  #--------------------------------------------------------------------------
-  # * Decide if Command is Inputable
-  #--------------------------------------------------------------------------
-  def inputable?
-    return (not @hidden and restriction <= 1)
-  end
-  #--------------------------------------------------------------------------
-  # * Decide if Action is Possible
-  #--------------------------------------------------------------------------
-  def movable?
-    return (not @hidden and restriction < 4)
-  end
-  #--------------------------------------------------------------------------
-  # * Decide if Guarding
-  #--------------------------------------------------------------------------
-  def guarding?
-    return (@current_action.kind == 0 and @current_action.basic == 1)
-  end
-  #--------------------------------------------------------------------------
-  # * Decide if Resting
-  #--------------------------------------------------------------------------
-  def resting?
-    return (@current_action.kind == 0 and @current_action.basic == 3)
-  end
-end