ZI-DamageFormulae

# // Well its a total rewrite @___@
#==============================================================================#
# ** Z
#==============================================================================#
module Z

  # NORMAL_DAMAGE
  # // Added by IceDragon
  # // "NORMAL_DAMAGE", "NORMALDAMAGE", "NORMAL DAMAGE", "NORMAL"
  # // "OBJ_DAMAGE", "OBJDAMAGE", "OBJ DAMAGE", "OBJ"
  # // Sonic: (+/-)n              # // Sonic: 20, Sonic: -20
  # // Percent: (+/-)n% host stat # // Percent: 20% user hp

  # // <damage: Sonic: 20>
  # // <dam: Percent: -20%> # // Healing effect
  def self.damage_formulae( attacker, target, params=[], obj=nil )
    user = attacker
    formula = obj.nil?() ? attacker.damage_formulae : obj.damage
    damage               = 0.0
    hp_damage, mp_damage = 0, 0
    critical             = false
    variance             = 0
    element_set          = attacker.element_set
    element_set          = obj.element_set unless obj.nil?()
    # // Param extracts
    allow_critical   = !params.include?( "NO_CRIT" )
    allow_variance   = !params.include?( "NO_VARI" )
    allow_guard      = !params.include?( "NO_GUARD" )
    allow_element    = !params.include?( "NO_ELEMENT" )
    allow_multiplier = !params.include?( "NO_MULT" )
    allow_divider    = !params.include?( "NO_DIV" )
    use_mp_damage    =  params.include?( "MP_DAM" )
    use_hp_damage    =  params.include?( "HP_DAM" )

    # // Some Procs
    get_host = Proc.new { |host|
      case host.upcase
      when "USER" ; attacker
      when "TARGET" ; target
      end
    }

    formula = attacker.damage_formulae if obj.physical_attack unless obj.nil?()
    # // Formulaes
    case formula.upcase
    # // <dam: stat: min, max, speed>
    when /STAT:[ ](.*),[ ](.*),[ ](.*)/i
      min, max, spd = $1.to_i, $2.to_i, $3.to_f
      da = min + rand(max-min) / spd

      if obj.nil?()
        da = da + ((attacker.atk*0.6) - (target.def*0.2))
        damage += da
        damage = obj.nil? ? rand(2) : 0 if damage < 0
      else
        damage = obj.base_damage.to_f
        da = da + ((attacker.spi*0.55) - (target.def*0.15))
        if damage > 0
          damage += da
          damage = obj.nil? ? rand(2) : 0 if damage < 0
        elsif damage < 0
          damage -= da
        end
      end

      # Object Atk_F and Spi_F calculations
      if damage > 0
        if obj.physical_attack
          damage = damage * obj.atk_f / 100.0
          damage = damage * obj.spi_f / 100.0
        else
          damage += (user.atk*0.6) * obj.atk_f / 100.0
          damage += (user.spi*0.55) * obj.spi_f / 100.0
        end
        unless obj.ignore_defense
          damage -= (target.def*0.2) * obj.atk_f / 100.0
          damage -= (target.spi*0.15) * obj.spi_f / 100.0
        end
      elsif damage < 0
        if obj.physical_attack
          damage = damage * obj.atk_f / 100.0
          damage = damage * obj.spi_f / 100.0
        else
          damage -= (user.atk*0.6) * obj.atk_f / 100.0
          damage -= (user.spi*0.55) * obj.spi_f / 100.0
        end
      end unless obj.nil?()
      variance = obj.variance unless obj.nil?()
      #damage /= 2.0 unless obj.nil?()
      allow_critical   = obj.nil?() ? true : obj.physical_attack
      allow_multiplier = false # // * 4.0
      allow_divider    = true  # // / 100.0
    # // Default Attack Damage Formulae
    when "NORMAL_DAMAGE", "NORMALDAMAGE", "NORMAL DAMAGE", "NORMAL"
      damage = attacker.atk - target.def
      damage = rand(2) if damage <= 0
      allow_multiplier = true
      variance = 20
    # // Default Skill/Item Damage Formulae
    when "OBJ_DAMAGE", "OBJDAMAGE", "OBJ DAMAGE", "OBJ"
      damage = obj.base_damage
      if damage > 0
        damage += user.atk * obj.atk_f / 100.0
        damage += user.spi * obj.spi_f / 100.0
        unless obj.ignore_defense
          damage -= target.def * obj.atk_f / 100.0
          damage -= target.spi * obj.spi_f / 100.0
        end
        damage = 0 if damage < 0
      elsif damage < 0
        damage -= user.atk * obj.atk_f / 100.0
        damage -= user.spi * obj.spi_f / 100.0
      end
      damage /= 100.0
      variance = obj.variance
    # // Sonic: +/-n
    # // Always inflicts n damage
    when /SONIC:[ ]([\+\-]?\d+)/i
      damage = $1.to_i
      allow_critical   = false
      allow_variance   = false
      allow_guard      = false
      allow_element    = false
      allow_multiplier = false
      allow_divider    = false
    # // Percent: +/-n% stat
    # // Inflicts n% damage
    when /(?:PERCENT|PERC):[ ]([\+\-]?\d+)(?:[%％]),[ ](.*),[ ](.*)/i
      perc = $1.to_i
      host = $2
      stat = $3
      case stat.upcase
      when "HP"
        damage += get_host.call(host).hp.to_f * perc.to_f / 100.0
      when "MAXHP"
        damage += get_host.call(host).maxhp.to_f * perc.to_f / 100.0
      when "MP"
        damage += get_host.call(host).mp.to_f * perc.to_f / 100.0
      when "MAXMP"
        damage += get_host.call(host).maxmp.to_f * perc.to_f / 100.0
      when "ATK"
        damage += get_host.call(host).atk.to_f * perc.to_f / 100.0
      when "DEF"
        damage += get_host.call(host).def.to_f * perc.to_f / 100.0
      when "SPI"
        damage += get_host.call(host).spi.to_f * perc.to_f / 100.0
      when "AGI"
        damage += get_host.call(host).agi.to_f * perc.to_f / 100.0
      end
    end
    if allow_critical
      critical = (rand(100) < attacker.cri)
      critical = false if target.prevent_critical
      damage *= 3.0 if critical
    end if damage > 0
    damage   *= target.elements_max_rate(element_set) if allow_element
    damage    = target.apply_variance(damage, variance) if allow_variance
    damage    = target.apply_guard(damage) if allow_guard
    damage   *= 4.0 if allow_multiplier
    damage   /= 100.0 if allow_divider
    hp_damage = Integer(damage) if use_hp_damage
    mp_damage = Integer(damage) if use_mp_damage
    return [hp_damage, mp_damage, critical]
  end

end

#==============================================================================#
# ** RPG::BaseItem
#==============================================================================#
class RPG::BaseItem

  attr_accessor :damage

  def zi_baseitemcache()
    self.note.gsub!(/<stats:[ ](.*) (.*) (.*)>/i) {
      "<dam: Stat: #{$1}, #{$2}, #{$3}>"
    }
    case self
    when RPG::Skill, RPG::Item
      @damage = "OBJ_DAMAGE"
    else
      @damage = "NORMAL_DAMAGE"
    end
    @damage = self.note =~ /<(?:DAMAGE|DMG|DAM):[ ](.*)>/i ? $1 : @damage
  end

end

#==============================================================================#
# ** RPG::Enemy
#==============================================================================#
class RPG::Enemy

  attr_accessor :damage

  def zi_baseenemycache()
    @damage = "NORMAL_DAMAGE"
    @damage = self.note =~ /<(?:DAMAGE|DMG|DAM):[ ](.*)>/i ? $1 : @damage
  end

end

#==============================================================================#
# ** Game_Battler
#==============================================================================#
class Game_Battler

  #--------------------------------------------------------------------------
  # * Calculation of Damage From Normal Attack
  #     attacker : Attacker
  #    The results are substituted for @hp_damage
  #--------------------------------------------------------------------------
  def make_attack_damage_value( attacker )
    damara = Z.damage_formulae(
     attacker, self,
     [ "HP_DAM" ],
     nil ) # // Get Damage Array
    @hp_damage, @mp_damage, @critical = *damara
  end

  #--------------------------------------------------------------------------
  # * Calculation of Damage Caused by Skills or Items
  #     user : User of skill or item
  #     obj  : Skill or item (for normal attacks, this is nil)
  #    The results are substituted for @hp_damage or @mp_damage.
  #--------------------------------------------------------------------------
  def make_obj_damage_value( user, obj )
    damara = Z.damage_formulae(
     user, self,
     [ obj.damage_to_mp ? "MP_DAM" : "HP_DAM" ],
     obj ) # // Get Damage Array
    @hp_damage, @mp_damage, @critical = *damara
  end

end

#==============================================================================#
# ** Game_Enemy
#==============================================================================#
class Game_Enemy < Game_Battler

  def damage_formulae
    return enemy.damage
  end

end

#==============================================================================#
# ** Game_Actor
#==============================================================================#
class Game_Actor < Game_Battler

  def damage_formulae
    return weapons[0].nil? ? "NORMAL_DAMAGE" : weapons[0].damage
  end

end

#==============================================================================#
# ** Scene_Title
#==============================================================================#
class Scene_Title < Scene_Base

  #--------------------------------------------------------------------------#
  # * alias method :load_database
  #--------------------------------------------------------------------------#
  alias :zi_sct_load_database :load_database unless $@
  def load_database()
    zi_sct_load_database()
    load_zi_cache()
  end

  #--------------------------------------------------------------------------#
  # * alias method :load_bt_database
  #--------------------------------------------------------------------------#
  alias :zi_sct_load_bt_database :load_database unless $@
  def load_bt_database()
    zi_sct_load_bt_database()
    load_zi_cache()
  end

  #--------------------------------------------------------------------------#
  # * new method :load_zi_cache
  #--------------------------------------------------------------------------#
  def load_zi_cache()
    objs = [$data_items, $data_skills, $data_weapons, $data_enemies]
    objs.each { |group| group.each { |obj| next if obj.nil?
      obj.zi_baseitemcache() if obj.is_a?(RPG::BaseItem)
      obj.zi_baseenemycache() if obj.is_a?(RPG::Enemy) } }
  end

end