GREATREDSPIRIT'S PROFILE

<physdmg 200>

<magicdmg 200>

damage *= user.state_multiplier(:phys_dmg)

damage *= user.state_multiplier(:magic_dmg)

<physvul 200>
<magicvul 200>

<physvul 50>

<magicvul 50>

<physvul 100>

<magicvul 100>

state_multiplier(:phys_vul)

state_multiplier(:magic_vul)

damage = Integer(damage)

# I'm changing a bit how this is all calculated


# Put more generic stuff in here
class Game_Battler
  
  # Get the state multiplier for a stat
  def state_multiplier(stat)
    mul = states.compact.inject(1) {|product, state| product * get_state_rate(state, stat) }
    return mul
  end
  
  # Get the individual stat bonus (we don't do agi or eva because ugh)
  def get_state_rate(state, stat)
    case stat
      when :maxhp, :maxmp, :cri
        stat_fixed = stat
        # yf uses :hp, I use :maxhp, gotta fix that here
        stat_fixed = :hp if stat == :maxhp
        stat_fixed = :mp if stat == :maxmp
        x = state.stat_per[stat_fixed].nil? ? 1.0 : state.stat_per[stat_fixed] / 100.0
        return x
      when :atk
        return state.atk_rate / 100.0
      when :def
        return state.def_rate / 100.0
      when :spi
        return state.spi_rate / 100.0
      when :agi
        return state.agi_rate / 100.0
      when :hit, :eva # I didn't do these
        return 1
      when :phys_vul # Physical Vulnerability
        return state.physical_vulnerability / 100.0
      when :magic_vul # Magical Vulnerability
        return state.magical_vulnerability / 100.0
      else
        return 1
    end
  end

end

class RPG::State
  
  PHYSICAL_VUL_REGEX = /<PhysVul[\s]+([0-9]+)>/i
  MAGICAL_VUL_REGEX  = /<MagicVul[\s]+([0-9]+)>/i
  
  def physical_vulnerability
    return @phys_vul unless @phys_vul.nil?
    
    if @note =~ PHYSICAL_VUL_REGEX
      @phys_vul = $1.to_i
    else 
      @phys_vul = 100
    end
    
    return @phys_vul 
  end
  
  
  def magical_vulnerability
    return @mag_vul unless @mag_vul.nil?
    
    if @note =~ MAGICAL_VUL_REGEX
      @mag_vul = $1.to_i
    else
      @mag_vul = 100
    end
    
    return @mag_vul 
  end
  
end

class Game_Battler
  
    #--------------------------------------------------------------------------
  # * Calculation of Damage From Normal Attack
  #     attacker : Attacker
  #    The results are substituted for @hp_damage
  #--------------------------------------------------------------------------
  def make_attack_damage_value(attacker)
    damage = attacker.atk * 4 - self.def * 2        # base calculation
    damage = 0 if damage < 0                        # if negative, make 0
    damage *= elements_max_rate(attacker.element_set)   # elemental adjustment
    damage /= 100
    if damage == 0                                  # if damage is 0,
      damage = rand(2)                              # half of the time, 1 dmg
    elsif damage > 0                                # a positive number?
      
      # Apply physical mitigation
      damage *= state_multiplier(:phys_vul)
      damage = Integer(damage) # I did math in floats but VX wants ints so oops
      
      @critical = (rand(100) < attacker.cri)        # critical hit?
      @critical = false if prevent_critical         # criticals prevented?
      damage *= 3 if @critical                      # critical adjustment
    end
    damage = apply_variance(damage, 20)             # variance
    damage = apply_guard(damage)                    # guard adjustment
    @hp_damage = damage                             # damage HP
  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)
    damage = obj.base_damage                        # get base damage
    if damage > 0                                   # a positive number?
      damage += user.atk * 4 * obj.atk_f / 100      # Attack F of the user
      damage += user.spi * 2 * obj.spi_f / 100      # Spirit F of the user
      unless obj.ignore_defense                     # Except for ignore defense
        damage -= self.def * 2 * obj.atk_f / 100    # Attack F of the target
        damage -= self.spi * 1 * obj.spi_f / 100    # Spirit F of the target
      end
      
      # Apply physical vulnerability if the atk_f is > 0
      damage *= state_multiplier(:phys_vul) if obj.atk_f > 0
      # Apply magical vulnerability if the spi_f is >0
      damage *= state_multiplier(:magic_vul) if obj.spi_f > 0
      damage = Integer(damage) # I did math in floats but VX wants ints so oops
      
      damage = 0 if damage < 0                      # If negative, make 0
    elsif damage < 0                                # a negative number?
      damage -= user.atk * 4 * obj.atk_f / 100      # Attack F of the user
      damage -= user.spi * 2 * obj.spi_f / 100      # Spirit F of the user
    end
    damage *= elements_max_rate(obj.element_set)    # elemental adjustment
    damage /= 100
    damage = apply_variance(damage, obj.variance)   # variance
    damage = apply_guard(damage)                    # guard adjustment
    if obj.damage_to_mp  
      @mp_damage = damage                           # damage MP
    else
      @hp_damage = damage                           # damage HP
    end
  end

end