Ruby Quellcode

#############
#
#  "Modifizierte Schadensformeln für Enus SBS" - Script  (Part 2/3)
#    version  1.0d <Beta>  (2nd October 2014)
#    by  Irrlicht <www.rpg-studio.org>
# 
# # Contents: ---------------------------------------------------------------
  #   Dieses Script verändert die Schadensberechnung.                          #
  #   Füge es unter den Scripts "Advanced Actor Status" und "Sideview 2" ein.  #
  # -------------------------------------------------------------- #############
 
 
#==============================================================================
# ** Game_Battler 
#------------------------------------------------------------------------------
#  EXTENSION: Redefine Damage Calculation Process
#==============================================================================
 
class Game_Battler
 
  attr_accessor :crushing  # Crushing Blow indicator flag
 
  #-------------------------------------------------------------------------
  # * Game_Battler#weapon_atk
  #  Determine the battlers current weapon based attack power.
  #-------------------------------------------------------------------------
  def weapon_atk
    result = base_weapon_atk
    @states.each { |id| result *= $data_states[id].atk_rate / 100.0 }
    return result.to_i
  end
 
  #-------------------------------------------------------------------------
  # * Game_Battler#base_weapon_atk
  #  Determine the battlers current basic weapon attack power.
  #-------------------------------------------------------------------------
  def base_weapon_atk
    if USE_ADVANCED_ACTOR_STATUS and actor? and weapons.length >= 2
      i = second_attack ? 1 : 0  # Weapon Index
      factor = Use_Old_Two_Sword_Beahave ? TWO_SWORDS_STYLE[i] : Dual_Attack_Power
      result = (weapons[i].atk + @set_atk / 2) * factor / 100.0
      return [[result.to_i, 0].max, Actor_Max_Atk].min
    else
      return base_atk
    end
  end
 
  #-------------------------------------------------------------------------
  # Stat Replacements when they are not defined by "Advanced Actor Status"
  #-------------------------------------------------------------------------
  define_method(:dmg) { 100 }  unless method_defined?(:dmg)
  define_method(:rdmg) { 0 }  unless method_defined?(:rdmg)
  define_method(:crt) { 5 }  unless method_defined?(:crt)
  define_method(:rcrt) { 0 }  unless method_defined?(:rcrt)
 
  #-------------------------------------------------------------------------
 
  #-------------------------------------------------------------------------
  # Game_Battler#clear_result_variables
  #   Clear effect result. Used within skill/attack effect calculations.
  #-------------------------------------------------------------------------
  def clear_result_variables
    self.critical = self.crushing = @missed = @evaded = false
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#success?
  #   Return current success status of an skill/attack effect.
  #-------------------------------------------------------------------------
  def success?
    not (@missed or @evaded)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#correct_result_variables
  #   Correct damage value and critical flag after an attack/skill effect.
  #-------------------------------------------------------------------------
  def correct_result_variables
    self.critical = false  unless success?
    self.damage = POP_EVA  if @evaded
    self.damage = POP_MISS if @missed
    self.damage = nil      unless $game_temp.in_battle
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_second_attack
  #   Try to switch to the second weapon after an attack effect.
  #-------------------------------------------------------------------------
  def set_second_attack
    if USE_ADVANCED_ACTOR_STATUS and actor? 
      wset = weapons
      self.second_attack = true  if wset[0] != nil and wset[1] != nil
    end
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#normalize_damage
  #   Round fractional damage values.
  #-------------------------------------------------------------------------
  def normalize_damage
    self.damage = (self.damage + rand).to_i  if self.damage.is_a?(Numeric)
  end
 
  #-------------------------------------------------------------------------
 
  #-------------------------------------------------------------------------
  # Game_Battler#attack_effect
  #   REDEFINE: Use new formulas for calculation, fix evade.
  #-------------------------------------------------------------------------
  def attack_effect(attacker)  #EDIT
    process_attack_effect(attacker, false)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#perfect_attack_effect
  #   REDEFINE: Use new formulas for calculation, fix evade.
  #-------------------------------------------------------------------------
  def perfect_attack_effect(attacker) #EDIT
    process_attack_effect(attacker, true)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#process_attack_effect
  #   Replacement for the old attack effect.
  #-------------------------------------------------------------------------
  def process_attack_effect(attacker, perfect)
    clear_result_variables
    set_attack_first_hit(attacker)    unless perfect
    set_attack_result(attacker)       if success?
    @evaded = false                   if perfect
    set_attack_state_change(attacker) if success?
    correct_result_variables
    attacker.set_second_attack
    return true
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_attack_first_hit
  #-------------------------------------------------------------------------
  def set_attack_first_hit(attacker)
    @missed = (rand >= attack_hit_chance(attacker))
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_attack_damage_value
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_attack_damage_value(attacker)
    self.damage = attack_damage_value(attacker)
    self.damage *= elements_correct(attacker.element_set) / 100.0
    normalize_damage
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_attack_hit_value
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_attack_hit_value(attacker)
    @evaded = (self.damage >= 0 and not self.cant_evade?)
    @evaded &&= (rand < attack_eva_chance(attacker))
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_attack_critical
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_attack_critical(attacker)
    self.critical = (rand < attack_crit_chance(attacker))
    self.crushing = (critical and rand < attack_crush_chance(attacker))
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_critical_damage
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_critical_damage(attacker)
    self.damage += attack_crit_bonus(attacker)
    self.damage += attack_crush_bonus(attacker)  if self.crushing
    normalize_damage
  end
 
  #-------------------------------------------------------------------------
 
  #-------------------------------------------------------------------------
  # Game_Battler#skill_effect_n01
  #   REDEFINE: Use new formulas for calculation, fix evade.
  #   Modified Alias from the "Sideview 2" - script:
  #   def skill_effect(user, skill)
  #-------------------------------------------------------------------------
  def skill_effect_n01(user, skill)
    process_skill_effect(user, skill, false)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#perfect_skill_effect_n01
  #   REDEFINE: Use new formulas for calculation, fix evade.
  #   Modified Alias from the "Sideview 2" - script:
  #   def perfect_skill_effect(user, skill)
  #-------------------------------------------------------------------------
  def perfect_skill_effect_n01(user, skill)  #EDIT
    process_skill_effect(user, skill, true)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#process_skill_effect
  #-------------------------------------------------------------------------
  def process_skill_effect(user, skill, perfect)
    clear_result_variables
    return false  unless skill_valid?(skill)
    effective = (skill.common_event_id > 0)
    effective |= set_skill_first_hit(user, skill)  unless perfect
    effective |= set_skill_result(user, skill, effective)  if success?
    @evaded = false  if perfect
    effective |= set_skill_state_change(user, skill, effective)  if success?
    correct_result_variables
    return effective
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#skill_valid?
  #-------------------------------------------------------------------------
  def skill_valid?(skill)
    not (self.hp == 0 ? [3, 4] : [5, 6]).include?(skill.scope)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_first_hit
  #-------------------------------------------------------------------------
  def set_skill_first_hit(user, skill)
    miss_chance = 1 - set_skill_hit(user, skill) * skill.hit / 100.0
    @missed = (rand < miss_chance)
    return (miss_chance > 0)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_hit
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_skill_hit(user, skill)
    skill_hit_chance(user, skill)
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_result
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_skill_result(user, skill, effective)  #EDIT
    set_skill_damage_value(user, skill)
    if self.damage > 0 
      self.damage /= 2 if self.guarding?
      set_skill_critical(user, skill) 
      set_skill_critical_damage(user, skill)  if self.critical
    end
    apply_variance(skill.variance) if skill.variance > 0 and self.damage.abs > 0
    effective |= set_skill_hit_value(user, skill, effective)
    return effective
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_critical
  #-------------------------------------------------------------------------
  def set_skill_critical(user, skill)
    self.critical = (rand < skill_crit_chance(user, skill))
    self.crushing = (critical and rand < skill_crush_chance(user, skill))
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_critical_damage
  #-------------------------------------------------------------------------
  def set_skill_critical_damage(user, skill)
    self.damage += skill_crit_bonus(user, skill)
    self.damage += skill_crush_bonus(user, skill)  if self.crushing
    normalize_damage
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_damage_value
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_skill_damage_value(user, skill)
    self.damage = skill_damage_value(user, skill)
    self.damage *= elements_correct(skill.element_set) / 100.0
    normalize_damage
  end
 
  #-------------------------------------------------------------------------
  # Game_Battler#set_skill_hit_value
  #   REDEFINE
  #-------------------------------------------------------------------------
  def set_skill_hit_value(user, skill, effective)
    if self.damage < 0 or self.cant_evade?
      @evaded = false
      return effective
    else
      evade_chance = skill_eva_chance(user, skill)
      @evaded = (rand < evade_chance)
      return (effective or evade_chance > 0)
    end
  end
end