rmxp_extractor 1.5 → 1.6

data/Scripts/Game_Battler 2.rb

@@ -0,0 +1,294 @@
+#==============================================================================
+# ** Game_Battler (part 2)
+#------------------------------------------------------------------------------
+#  This class deals with battlers. It's used as a superclass for the Game_Actor
+#  and Game_Enemy classes.
+#==============================================================================
+
+class Game_Battler
+  #--------------------------------------------------------------------------
+  # * Check State
+  #     state_id : state ID
+  #--------------------------------------------------------------------------
+  def state?(state_id)
+    # Return true if the applicable state is added.
+    return @states.include?(state_id)
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if a state is full or not.
+  #     state_id : state ID
+  #--------------------------------------------------------------------------
+  def state_full?(state_id)
+    # Return false if the applicable state is not added.
+    unless self.state?(state_id)
+      return false
+    end
+    # Return true if the number of maintenance turns is -1 (auto state).
+    if @states_turn[state_id] == -1
+      return true
+    end
+    # Return true if the number of maintenance turns is equal to the
+    # lowest number of natural removal turns.
+    return @states_turn[state_id] == $data_states[state_id].hold_turn
+  end
+  #--------------------------------------------------------------------------
+  # * Add State
+  #     state_id : state ID
+  #     force    : forcefully added flag (used to deal with auto state)
+  #--------------------------------------------------------------------------
+  def add_state(state_id, force = false)
+    # For an ineffective state
+    if $data_states[state_id] == nil
+      # End Method
+      return
+    end
+    # If not forcefully added
+    unless force
+      # A state loop already in existance
+      for i in @states
+        # If a new state is included in the state change (-) of an existing
+        # state, and that state is not included in the state change (-) of
+        # a new state (example: an attempt to add poison during dead)
+        if $data_states[i].minus_state_set.include?(state_id) and
+           not $data_states[state_id].minus_state_set.include?(i)
+          # End Method
+          return
+        end
+      end
+    end
+    # If this state is not added
+    unless state?(state_id)
+      # Add state ID to @states array
+      @states.push(state_id)
+      # If option [regarded as HP 0]is effective
+      if $data_states[state_id].zero_hp
+        # Change HP to 0
+        @hp = 0
+      end
+      # All state loops
+      for i in 1...$data_states.size
+        # Dealing with a state change (+)
+        if $data_states[state_id].plus_state_set.include?(i)
+          add_state(i)
+        end
+        # Dealing with a state change (-)
+        if $data_states[state_id].minus_state_set.include?(i)
+          remove_state(i)
+        end
+      end
+      # line change to a large rating order (if value is the same, then a
+      # strong restriction order)
+      @states.sort! do |a, b|
+        state_a = $data_states[a]
+        state_b = $data_states[b]
+        if state_a.rating > state_b.rating
+          -1
+        elsif state_a.rating < state_b.rating
+          +1
+        elsif state_a.restriction > state_b.restriction
+          -1
+        elsif state_a.restriction < state_b.restriction
+          +1
+        else
+          a <=> b
+        end
+      end
+    end
+    # If added forcefully
+    if force
+      # Set the natural removal's lowest number of turns to -1
+      @states_turn[state_id] = -1
+    end
+    # If not added forcefully
+    unless  @states_turn[state_id] == -1
+      # Set the natural removal's lowest number of turns
+      @states_turn[state_id] = $data_states[state_id].hold_turn
+    end
+    # If unable to move
+    unless movable?
+      # Clear action
+      @current_action.clear
+    end
+    # Check the maximum value of HP and SP
+    @hp = [@hp, self.maxhp].min
+    @sp = [@sp, self.maxsp].min
+  end
+  #--------------------------------------------------------------------------
+  # * Remove State
+  #     state_id : state ID
+  #     force    : forcefully removed flag (used to deal with auto state)
+  #--------------------------------------------------------------------------
+  def remove_state(state_id, force = false)
+    # If this state is added
+    if state?(state_id)
+      # If a forcefully added state is not forcefully removed
+      if @states_turn[state_id] == -1 and not force
+        # End Method
+        return
+      end
+      # If current HP is at 0 and options are effective [regarded as HP 0]
+      if @hp == 0 and $data_states[state_id].zero_hp
+        # Determine if there's another state [regarded as HP 0] or not
+        zero_hp = false
+        for i in @states
+          if i != state_id and $data_states[i].zero_hp
+            zero_hp = true
+          end
+        end
+        # Change HP to 1 if OK to remove incapacitation.
+        if zero_hp == false
+          @hp = 1
+        end
+      end
+      # Delete state ID from @states and @states_turn hash array
+      @states.delete(state_id)
+      @states_turn.delete(state_id)
+    end
+    # Check maximum value for HP and SP
+    @hp = [@hp, self.maxhp].min
+    @sp = [@sp, self.maxsp].min
+  end
+  #--------------------------------------------------------------------------
+  # * Get State Animation ID
+  #--------------------------------------------------------------------------
+  def state_animation_id
+    # If no states are added
+    if @states.size == 0
+      return 0
+    end
+    # Return state animation ID with maximum rating
+    return $data_states[@states[0]].animation_id
+  end
+  #--------------------------------------------------------------------------
+  # * Get Restriction
+  #--------------------------------------------------------------------------
+  def restriction
+    restriction_max = 0
+    # Get maximum restriction from currently added states
+    for i in @states
+      if $data_states[i].restriction >= restriction_max
+        restriction_max = $data_states[i].restriction
+      end
+    end
+    return restriction_max
+  end
+  #--------------------------------------------------------------------------
+  # * Determine [Can't Get EXP] States
+  #--------------------------------------------------------------------------
+  def cant_get_exp?
+    for i in @states
+      if $data_states[i].cant_get_exp
+        return true
+      end
+    end
+    return false
+  end
+  #--------------------------------------------------------------------------
+  # * Determine [Can't Evade] States
+  #--------------------------------------------------------------------------
+  def cant_evade?
+    for i in @states
+      if $data_states[i].cant_evade
+        return true
+      end
+    end
+    return false
+  end
+  #--------------------------------------------------------------------------
+  # * Determine [Slip Damage] States
+  #--------------------------------------------------------------------------
+  def slip_damage?
+    for i in @states
+      if $data_states[i].slip_damage
+        return true
+      end
+    end
+    return false
+  end
+  #--------------------------------------------------------------------------
+  # * Remove Battle States (called up during end of battle)
+  #--------------------------------------------------------------------------
+  def remove_states_battle
+    for i in @states.clone
+      if $data_states[i].battle_only
+        remove_state(i)
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Natural Removal of States (called up each turn)
+  #--------------------------------------------------------------------------
+  def remove_states_auto
+    for i in @states_turn.keys.clone
+      if @states_turn[i] > 0
+        @states_turn[i] -= 1
+      elsif rand(100) < $data_states[i].auto_release_prob
+        remove_state(i)
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * State Removed by Shock (called up each time physical damage occurs)
+  #--------------------------------------------------------------------------
+  def remove_states_shock
+    for i in @states.clone
+      if rand(100) < $data_states[i].shock_release_prob
+        remove_state(i)
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * State Change (+) Application
+  #     plus_state_set  : State Change (+)
+  #--------------------------------------------------------------------------
+  def states_plus(plus_state_set)
+    # Clear effective flag
+    effective = false
+    # Loop (added state)
+    for i in plus_state_set
+      # If this state is not guarded
+      unless self.state_guard?(i)
+        # Set effective flag if this state is not full
+        effective |= self.state_full?(i) == false
+        # If states offer [no resistance]
+        if $data_states[i].nonresistance
+          # Set state change flag
+          @state_changed = true
+          # Add a state
+          add_state(i)
+        # If this state is not full
+        elsif self.state_full?(i) == false
+          # Convert state effectiveness to probability,
+          # compare to random numbers
+          if rand(100) < [0,100,80,60,40,20,0][self.state_ranks[i]]
+            # Set state change flag
+            @state_changed = true
+            # Add a state
+            add_state(i)
+          end
+        end
+      end
+    end
+    # End Method
+    return effective
+  end
+  #--------------------------------------------------------------------------
+  # * Apply State Change (-)
+  #     minus_state_set : state change (-)
+  #--------------------------------------------------------------------------
+  def states_minus(minus_state_set)
+    # Clear effective flag
+    effective = false
+    # Loop (state to be removed)
+    for i in minus_state_set
+      # Set effective flag if this state is added
+      effective |= self.state?(i)
+      # Set a state change flag
+      @state_changed = true
+      # Remove state
+      remove_state(i)
+    end
+    # End Method
+    return effective
+  end
+end

data/Scripts/Game_Battler 3.rb

@@ -0,0 +1,354 @@
+#==============================================================================
+# ** Game_Battler (part 3)
+#------------------------------------------------------------------------------
+#  This class deals with battlers. It's used as a superclass for the Game_Actor
+#  and Game_Enemy classes.
+#==============================================================================
+
+class Game_Battler
+  #--------------------------------------------------------------------------
+  # * Determine Usable Skills
+  #     skill_id : skill ID
+  #--------------------------------------------------------------------------
+  def skill_can_use?(skill_id)
+    # If there's not enough SP, the skill cannot be used.
+    if $data_skills[skill_id].sp_cost > self.sp
+      return false
+    end
+    # Unusable if incapacitated
+    if dead?
+      return false
+    end
+    # If silent, only physical skills can be used
+    if $data_skills[skill_id].atk_f == 0 and self.restriction == 1
+      return false
+    end
+    # Get usable time
+    occasion = $data_skills[skill_id].occasion
+    # If in battle
+    if $game_temp.in_battle
+      # Usable with [Normal] and [Only Battle]
+      return (occasion == 0 or occasion == 1)
+    # If not in battle
+    else
+      # Usable with [Normal] and [Only Menu]
+      return (occasion == 0 or occasion == 2)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Applying Normal Attack Effects
+  #     attacker : battler
+  #--------------------------------------------------------------------------
+  def attack_effect(attacker)
+    # Clear critical flag
+    self.critical = false
+    # First hit detection
+    hit_result = (rand(100) < attacker.hit)
+    # If hit occurs
+    if hit_result == true
+      # Calculate basic damage
+      atk = [attacker.atk - self.pdef / 2, 0].max
+      self.damage = atk * (20 + attacker.str) / 20
+      # Element correction
+      self.damage *= elements_correct(attacker.element_set)
+      self.damage /= 100
+      # If damage value is strictly positive
+      if self.damage > 0
+        # Critical correction
+        if rand(100) < 4 * attacker.dex / self.agi
+          self.damage *= 2
+          self.critical = true
+        end
+        # Guard correction
+        if self.guarding?
+          self.damage /= 2
+        end
+      end
+      # Dispersion
+      if self.damage.abs > 0
+        amp = [self.damage.abs * 15 / 100, 1].max
+        self.damage += rand(amp+1) + rand(amp+1) - amp
+      end
+      # Second hit detection
+      eva = 8 * self.agi / attacker.dex + self.eva
+      hit = self.damage < 0 ? 100 : 100 - eva
+      hit = self.cant_evade? ? 100 : hit
+      hit_result = (rand(100) < hit)
+    end
+    # If hit occurs
+    if hit_result == true
+      # State Removed by Shock
+      remove_states_shock
+      # Substract damage from HP
+      self.hp -= self.damage
+      # State change
+      @state_changed = false
+      states_plus(attacker.plus_state_set)
+      states_minus(attacker.minus_state_set)
+    # When missing
+    else
+      # Set damage to "Miss"
+      self.damage = "Miss"
+      # Clear critical flag
+      self.critical = false
+    end
+    # End Method
+    return true
+  end
+  #--------------------------------------------------------------------------
+  # * Apply Skill Effects
+  #     user  : the one using skills (battler)
+  #     skill : skill
+  #--------------------------------------------------------------------------
+  def skill_effect(user, skill)
+    # Clear critical flag
+    self.critical = false
+    # If skill scope is for ally with 1 or more HP, and your own HP = 0,
+    # or skill scope is for ally with 0, and your own HP = 1 or more
+    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
+       ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
+      # End Method
+      return false
+    end
+    # Clear effective flag
+    effective = false
+    # Set effective flag if common ID is effective
+    effective |= skill.common_event_id > 0
+    # First hit detection
+    hit = skill.hit
+    if skill.atk_f > 0
+      hit *= user.hit / 100
+    end
+    hit_result = (rand(100) < hit)
+    # Set effective flag if skill is uncertain
+    effective |= hit < 100
+    # If hit occurs
+    if hit_result == true
+      # Calculate power
+      power = skill.power + user.atk * skill.atk_f / 100
+      if power > 0
+        power -= self.pdef * skill.pdef_f / 200
+        power -= self.mdef * skill.mdef_f / 200
+        power = [power, 0].max
+      end
+      # Calculate rate
+      rate = 20
+      rate += (user.str * skill.str_f / 100)
+      rate += (user.dex * skill.dex_f / 100)
+      rate += (user.agi * skill.agi_f / 100)
+      rate += (user.int * skill.int_f / 100)
+      # Calculate basic damage
+      self.damage = power * rate / 20
+      # Element correction
+      self.damage *= elements_correct(skill.element_set)
+      self.damage /= 100
+      # If damage value is strictly positive
+      if self.damage > 0
+        # Guard correction
+        if self.guarding?
+          self.damage /= 2
+        end
+      end
+      # Dispersion
+      if skill.variance > 0 and self.damage.abs > 0
+        amp = [self.damage.abs * skill.variance / 100, 1].max
+        self.damage += rand(amp+1) + rand(amp+1) - amp
+      end
+      # Second hit detection
+      eva = 8 * self.agi / user.dex + self.eva
+      hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
+      hit = self.cant_evade? ? 100 : hit
+      hit_result = (rand(100) < hit)
+      # Set effective flag if skill is uncertain
+      effective |= hit < 100
+    end
+    # If hit occurs
+    if hit_result == true
+      # If physical attack has power other than 0
+      if skill.power != 0 and skill.atk_f > 0
+        # State Removed by Shock
+        remove_states_shock
+        # Set to effective flag
+        effective = true
+      end
+      # Substract damage from HP
+      last_hp = self.hp
+      self.hp -= self.damage
+      effective |= self.hp != last_hp
+      # State change
+      @state_changed = false
+      effective |= states_plus(skill.plus_state_set)
+      effective |= states_minus(skill.minus_state_set)
+      # If power is 0
+      if skill.power == 0
+        # Set damage to an empty string
+        self.damage = ""
+        # If state is unchanged
+        unless @state_changed
+          # Set damage to "Miss"
+          self.damage = "Miss"
+        end
+      end
+    # If miss occurs
+    else
+      # Set damage to "Miss"
+      self.damage = "Miss"
+    end
+    # If not in battle
+    unless $game_temp.in_battle
+      # Set damage to nil
+      self.damage = nil
+    end
+    # End Method
+    return effective
+  end
+  #--------------------------------------------------------------------------
+  # * Application of Item Effects
+  #     item : item
+  #--------------------------------------------------------------------------
+  def item_effect(item)
+    # Clear critical flag
+    self.critical = false
+    # If item scope is for ally with 1 or more HP, and your own HP = 0,
+    # or item scope is for ally with 0 HP, and your own HP = 1 or more
+    if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or
+       ((item.scope == 5 or item.scope == 6) and self.hp >= 1)
+      # End Method
+      return false
+    end
+    # Clear effective flag
+    effective = false
+    # Set effective flag if common ID is effective
+    effective |= item.common_event_id > 0
+    # Determine hit
+    hit_result = (rand(100) < item.hit)
+    # Set effective flag is skill is uncertain
+    effective |= item.hit < 100
+    # If hit occurs
+    if hit_result == true
+      # Calculate amount of recovery
+      recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp
+      recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp
+      if recover_hp < 0
+        recover_hp += self.pdef * item.pdef_f / 20
+        recover_hp += self.mdef * item.mdef_f / 20
+        recover_hp = [recover_hp, 0].min
+      end
+      # Element correction
+      recover_hp *= elements_correct(item.element_set)
+      recover_hp /= 100
+      recover_sp *= elements_correct(item.element_set)
+      recover_sp /= 100
+      # Dispersion
+      if item.variance > 0 and recover_hp.abs > 0
+        amp = [recover_hp.abs * item.variance / 100, 1].max
+        recover_hp += rand(amp+1) + rand(amp+1) - amp
+      end
+      if item.variance > 0 and recover_sp.abs > 0
+        amp = [recover_sp.abs * item.variance / 100, 1].max
+        recover_sp += rand(amp+1) + rand(amp+1) - amp
+      end
+      # If recovery code is negative
+      if recover_hp < 0
+        # Guard correction
+        if self.guarding?
+          recover_hp /= 2
+        end
+      end
+      # Set damage value and reverse HP recovery amount
+      self.damage = -recover_hp
+      # HP and SP recovery
+      last_hp = self.hp
+      last_sp = self.sp
+      self.hp += recover_hp
+      self.sp += recover_sp
+      effective |= self.hp != last_hp
+      effective |= self.sp != last_sp
+      # State change
+      @state_changed = false
+      effective |= states_plus(item.plus_state_set)
+      effective |= states_minus(item.minus_state_set)
+      # If parameter value increase is effective
+      if item.parameter_type > 0 and item.parameter_points != 0
+        # Branch by parameter
+        case item.parameter_type
+        when 1  # Max HP
+          @maxhp_plus += item.parameter_points
+        when 2  # Max SP
+          @maxsp_plus += item.parameter_points
+        when 3  # Strength
+          @str_plus += item.parameter_points
+        when 4  # Dexterity
+          @dex_plus += item.parameter_points
+        when 5  # Agility
+          @agi_plus += item.parameter_points
+        when 6  # Intelligence
+          @int_plus += item.parameter_points
+        end
+        # Set to effective flag
+        effective = true
+      end
+      # If HP recovery rate and recovery amount are 0
+      if item.recover_hp_rate == 0 and item.recover_hp == 0
+        # Set damage to empty string
+        self.damage = ""
+        # If SP recovery rate / recovery amount are 0, and parameter increase
+        # value is ineffective.
+        if item.recover_sp_rate == 0 and item.recover_sp == 0 and
+           (item.parameter_type == 0 or item.parameter_points == 0)
+          # If state is unchanged
+          unless @state_changed
+            # Set damage to "Miss"
+            self.damage = "Miss"
+          end
+        end
+      end
+    # If miss occurs
+    else
+      # Set damage to "Miss"
+      self.damage = "Miss"
+    end
+    # If not in battle
+    unless $game_temp.in_battle
+      # Set damage to nil
+      self.damage = nil
+    end
+    # End Method
+    return effective
+  end
+  #--------------------------------------------------------------------------
+  # * Application of Slip Damage Effects
+  #--------------------------------------------------------------------------
+  def slip_damage_effect
+    # Set damage
+    self.damage = self.maxhp / 10
+    # Dispersion
+    if self.damage.abs > 0
+      amp = [self.damage.abs * 15 / 100, 1].max
+      self.damage += rand(amp+1) + rand(amp+1) - amp
+    end
+    # Subtract damage from HP
+    self.hp -= self.damage
+    # End Method
+    return true
+  end
+  #--------------------------------------------------------------------------
+  # * Calculating Element Correction
+  #     element_set : element
+  #--------------------------------------------------------------------------
+  def elements_correct(element_set)
+    # If not an element
+    if element_set == []
+      # Return 100
+      return 100
+    end
+    # Return the weakest object among the elements given
+    # * "element_rate" method is defined by Game_Actor and Game_Enemy classes,
+    #    which inherit from this class.
+    weakest = -100
+    for i in element_set
+      weakest = [weakest, self.element_rate(i)].max
+    end
+    return weakest
+  end
+end