LEECH'S PROFILE

ÿþ#===============================================================================

# 

# Yanfly Engine Melody - New Battle Stats

# Last Date Updated: 2010.06.20

# Level: Normal, Hard

# 

# This script offers the functionality to add new battle stats for both actors

# and enemies alike. These stats can be adjusted in the script itself while any

# potential weapons, armours, states, and enemies can have their settings made

# within their respective noteboxes.

# 

# - DEX - Dexterity

# Dexterity is a new stat that directly impacts hit rates, evasion rates, and

# critical hit rates. In default VX, there was no growth at all over these three

# stats other than through equipment. Now, actors progressing through the game

# can directly impact the hit rate, evasion rate, and critical hit rate of a

# character upon calculation.

# 

# - RES - Resistance

# Resistance is a new stat to provide a magical defense against magical attacks.

# Just like DEF is to ATK, RES is to SPI. In default VX, both magical defense

# and magical attack were found in one stat. Now, they're split across two,

# which frankly makes more sense.

# 

#===============================================================================

# Updates

# -----------------------------------------------------------------------------

# o 2010.06.20 - Bugfix update for dex= and res=

# o 2010.06.14 - Compatibility Update for Skill Equip System.

# o 2010.05.31 - Compatibility Update for YEM Enemy Levels.

# o 2010.05.19 - Started Script and Finished.

#===============================================================================

# Instructions

# -----------------------------------------------------------------------------

# To install this script, open up your script editor and copy/paste this script

# to an open slot below ¼% Materials but above ¼% Main. Remember to save.

# 

# Scroll down and set whichever stats you wish to include in your game. More

# instructions are available in each individual section.

#===============================================================================



$imported = {} if $imported == nil



module YEM

  module STATS

    module DEX

      

      #=========================================================================

      # - DEX - Dexterity

      # -----------------------------------------------------------------------

      # Dexterity is a new stat that directly impacts hit rates, evasion rates, 

      # and critical hit rates. In default VX, there was no growth at all over

      # these three stats other than through equipment. Now, actors progressing

      # through the game can directly impact the hit rate, evasion rate, and

      # critical hit rate of a character upon calculation.

      # 

      # -----------------------------------------------------------------------

      # Item Tags - For Items only.

      # -----------------------------------------------------------------------

      # <dex growth: +x>  or  <dex growth: -x>

      # This raises or lowers the target's base DEX by x amount.

      # 

      # -----------------------------------------------------------------------

      # Equipment Tags - For Weapons and Armours only.

      # -----------------------------------------------------------------------

      # <dex: +x>  or  <dex: -x>

      # <dex: +x%> or  <dex: -x%>

      # This allows the weapon or armour to increase DEX for the actor wearing

      # it by x amount or x%. Using the tag without the percentage will raise

      # the amount by a set value while using the percentage will increase the

      # base DEX of the actor by a percentile value.

      # 

      # -----------------------------------------------------------------------

      # State Tags - For Status Effects only.

      # -----------------------------------------------------------------------

      # <dex: x%>  or  <dex: +x>  or  <dex: -x>

      # This adjusts the DEX stat in battle by x percentile or a set x amount.

      # If multiple of these tags are used, it will be calculated based on the

      # order of operations. Stackable.

      # 

      # -----------------------------------------------------------------------

      # Enemy Tags - For Enemies only.

      # -----------------------------------------------------------------------

      # <base dex: x>

      # This sets the enemy's base DEX to x. The base dex would be the enemy's

      # unaltered DEX value. If this tag isn't present, the enemy's base DEX

      # will be calculated based on the formula provided by the module.

      #=========================================================================

      

      # This changes whether or not the DEX stat will be used at all. Set it

      # to true if you wish to use the DEX stat. False if otherwise.

      $imported["DEX Stat"] = false

      

      # This is the ingame vocabulary for the DEX stat.

      VOCAB = "DEX"

      

      # This hash allows you to edit each actor's base DEX formula and the rate

      # of growth for DEX as levels progress. Note that actor 0 will be used if

      # the actor's ID does not appear on this list.

      ACTOR_BASE ={

      # ID => Formula

         0 => "actor.parameters[2,@level]/2+actor.parameters[5,@level]/2",

         1 => "@level * 5 + 20",

         2 => "@level * 6 + 24",

         3 => "@level * 4 + 16",

         4 => "@level * 3 + 12",

      } # Do not remove this.

      

      # This is the formula used for the base DEX of an enemy if not specific

      # base DEX has been defined by the <base dex: x> tag.

      ENEMY_BASE = "@atk / 2 + @agi / 2"

      

      # These are the formulas used to convert DEX bonuses for each of the

      # varying stats. These bonuses are added onto the previously calculated

      # HIT, EVA, and CRI values.

      DEX_TO_HIT = "self.dex * 0.07"

      DEX_TO_EVA = "self.dex * 0.03"

      DEX_TO_CRI = "self.dex * 0.05"

      

    end # DEX

    module RES

      

      #=========================================================================

      # - RES - Resistance

      # -----------------------------------------------------------------------

      # Resistance is a new stat to provide a magical defense against magical

      # attacks. Just like DEF is to ATK, RES is to SPI. In default VX, both

      # magical defense and magical attack were found in one stat. Now, they're

      # split across two, which frankly makes more sense.

      # 

      # -----------------------------------------------------------------------

      # Item Tags - For Items only.

      # -----------------------------------------------------------------------

      # <res growth: +x>  or  <res growth: -x>

      # This raises or lowers the target's base RES by x amount.

      # 

      # -----------------------------------------------------------------------

      # Equipment Tags - For Weapons and Armours only.

      # -----------------------------------------------------------------------

      # <res: +x>  or  <res: -x>

      # <res: +x%> or  <res: -x%>

      # This allows the weapon or armour to increase RES for the actor wearing

      # it by x amount or x%. Using the tag without the percentage will raise

      # the amount by a set value while using the percentage will increase the

      # base RES of the actor by a percentile value.

      # 

      # -----------------------------------------------------------------------

      # State Tags - For Status Effects only.

      # -----------------------------------------------------------------------

      # <res: x%>  or  <res: +x>  or  <res: -x>

      # This adjusts the RES stat in battle by x percentile or a set x amount.

      # If multiple of these tags are used, it will be calculated based on the

      # order of operations. Stackable.

      # 

      # -----------------------------------------------------------------------

      # Enemy Tags - For Enemies only.

      # -----------------------------------------------------------------------

      # <base res: x>

      # This sets the enemy's base RES to x. The base dex would be the enemy's

      # unaltered RES value. If this tag isn't present, the enemy's base RES

      # will be calculated based on the formula provided by the module.

      #=========================================================================

      

      # This changes whether or not the RES stat will be used at all. Set it

      # to true if you wish to use the RES stat. False if otherwise.

      $imported["RES Stat"] = true

      

      # This is the ingame vocabulary for the RES stat.

      VOCAB = "RES"

      

      # This hash allows you to edit each actor's base RES formula and the rate

      # of growth for RES as levels progress. Note that actor 0 will be used if

      # the actor's ID does not appear on this list.

      ACTOR_BASE ={

      # ID => Formula

         0 => "actor.parameters[3,@level]/2+actor.parameters[4,@level]/2",

         1 => "((190.to_f * (level - 1) / 98).to_int + ((((190.to_f * (level - 1) / 98) - (190.to_f * (level - 1) / 98).to_int) >= 0.5) ? 1 : 0)) + 10

",

         2 => "@level * 3 + 12",

         3 => "@level * 5 + 20",

         4 => "@level * 2 + 50",

         999 => "((190.to_f * (level - 1) / 98).to_int + ((((190.to_f * (level - 1) / 98) - (190.to_f * (level - 1) / 98).to_int) >= 0.5) ? 1 : 0)) + 10

",

      } # Do not remove this.

      

      # This is the formula used for the base RES of an enemy if not specific

      # base RES has been defined by the <base res: x> tag.

      ENEMY_BASE = "@def / 2 + @spi / 2"

      

    end # RES

  end # STATS

end # YEM



#===============================================================================

# Editting anything past this point may potentially result in causing computer

# damage, incontinence, explosion of user's head, coma, death, and/or halitosis.

# Therefore, edit at your own risk.

#===============================================================================



module YEM

  module REGEXP

  module BASEITEM

    

    STAT_PER  = /<(.*):[ ]*([\+\-]\d+)([%ÿ])>/i

    STAT_SET  = /<(.*):[ ]*([\+\-]\d+)>/i

    

  end # BASEITEM

  module ITEM

    

    STAT_GROW = /<(.*)[ ](?:BOOST|growth):[ ]([\+\-]\d+)>/i

    

  end # ITEM

  module STATE

    

    STAT_PER  = /<(.*):[ ]*(\d+)([%ÿ])>/i

    STAT_SET  = /<(.*):[ ]*([\+\-]\d+)>/i

    

  end # STATE

  module ENEMY

    

    BASE_STAT = /<(?:BASE|basic)[ ](.*):[ ]*(\d+)>/i

    

  end # ENEMY

  end # REGEXP

end # YEM



#===============================================================================

# module Vocab

#===============================================================================



module Vocab

  

  #--------------------------------------------------------------------------

  # self.dex

  #--------------------------------------------------------------------------

  def self.dex; return YEM::STATS::DEX::VOCAB; end

  

  #--------------------------------------------------------------------------

  # self.res

  #--------------------------------------------------------------------------

  def self.res; return YEM::STATS::RES::VOCAB; end

    

end



#===============================================================================

# RPG::BaseItem

#===============================================================================



class RPG::BaseItem

  

  #--------------------------------------------------------------------------

  # public instance variables

  #--------------------------------------------------------------------------

  attr_accessor :dex

  attr_accessor :dex_per

  attr_accessor :res

  attr_accessor :res_per

  

  #--------------------------------------------------------------------------

  # common cache: yem_cache_baseitem_nbs

  #--------------------------------------------------------------------------

  def yem_cache_baseitem_nbs

    return if @cached_state_nbs; @cached_state_nbs = true

    @dex = 0

    @res = 0

    @dex_per = 0

    @res_per = 0

    #---

    self.note.split(/[\r\n]+/).each { |line|

      case line

      #---

      when YEM::REGEXP::BASEITEM::STAT_PER

        case $1.upcase

        when "DEX", "DEXTERITY"

          @dex_per = $2.to_i

        when "RES", "RESISTANCE"

          @res_per = $2.to_i

        end

      #---

      when YEM::REGEXP::BASEITEM::STAT_SET

        case $1.upcase

        when "DEX", "DEXTERITY"

          @dex = $2.to_i

        when "RES", "RESISTANCE"

          @res = $2.to_i

        end

      #---

      end

    } # self.note.split

  end # yem_cache_baseitem_nbs

  

end # RPG::BaseItem



#===============================================================================

# RPG::Item

#===============================================================================



class RPG::Item < RPG::UsableItem

  

  #--------------------------------------------------------------------------

  # public instance variables

  #--------------------------------------------------------------------------

  attr_accessor :stat_growth

  

  #--------------------------------------------------------------------------

  # common cache: yem_cache_item_nbs

  #--------------------------------------------------------------------------

  def yem_cache_item_nbs

    return if @cached_item_nbs; @cached_item_nbs = true

    @stat_growth = {} if @stat_growth == nil

    #---

    self.note.split(/[\r\n]+/).each { |line|

      case line

      #---

      when YEM::REGEXP::ITEM::STAT_GROW

        case $1.upcase

        when "DEX", "DEXTERITY"

          type = :dex

        when "RES", "RESISTANCE"

          type = :res

        else; next

        end

        @stat_growth[type] = $2.to_i

      end

    } # self.note.split

  end # yem_cache_item_nbs

  

end # RPG::Item



#===============================================================================

# RPG::State

#===============================================================================



class RPG::State

  

  #--------------------------------------------------------------------------

  # public instance variables

  #--------------------------------------------------------------------------

  attr_accessor :dex_rate

  attr_accessor :dex_set

  attr_accessor :res_rate

  attr_accessor :res_set

  

  #--------------------------------------------------------------------------

  # common cache: yem_cache_state_nbs

  #--------------------------------------------------------------------------

  def yem_cache_state_nbs

    return if @cached_state_nbs; @cached_state_nbs = true

    @dex_rate = 100

    @res_rate = 100

    @dex_set = 0

    @res_set = 0

    #---

    self.note.split(/[\r\n]+/).each { |line|

      case line

      #---

      when YEM::REGEXP::STATE::STAT_PER

        case $1.upcase

        when "DEX", "DEXTERITY"

          @dex_rate = $2.to_i

        when "RES", "RESISTANCE"

          @res_rate = $2.to_i

        end

      #---

      when YEM::REGEXP::STATE::STAT_SET

        case $1.upcase

        when "DEX", "DEXTERITY"

          @dex_set = $2.to_i

        when "RES", "RESISTANCE"

          @res_set = $2.to_i

        end

      #---

      end

    } # self.note.split

  end # yem_cache_state_nbs

  

end # RPG::State



#===============================================================================

# RPG::Enemy

#===============================================================================



class RPG::Enemy

  

  #--------------------------------------------------------------------------

  # public instance variables

  #--------------------------------------------------------------------------

  attr_accessor :dex

  attr_accessor :res

  

  #--------------------------------------------------------------------------

  # common cache: yem_cache_enemy_nbs

  #--------------------------------------------------------------------------

  def yem_cache_enemy_nbs

    return if @cached_enemy_nbs; @cached_enemy_nbs = true

    @dex = eval(YEM::STATS::DEX::ENEMY_BASE)

    @res = eval(YEM::STATS::RES::ENEMY_BASE)

    #---

    self.note.split(/[\r\n]+/).each { |line|

      case line

      #---

      when YEM::REGEXP::ENEMY::BASE_STAT

        case $1.upcase

        when "DEX", "DEXTERITY"

          @dex = $2.to_i

        when "RES", "RESISTANCE"

          @res = $2.to_i

        end

      #---

      end

    } # self.note.split

  end # yem_cache_state_nbs

  

end # RPG::Enemy



#===============================================================================

# Vocab

#===============================================================================



module Vocab

  

  #--------------------------------------------------------------------------

  # new method: self.dex

  #--------------------------------------------------------------------------

  def self.dex; return YEM::STATS::DEX::VOCAB; end

    

  #--------------------------------------------------------------------------

  # new method: self.res

  #--------------------------------------------------------------------------

  def self.res; return YEM::STATS::RES::VOCAB; end

  

end # Vocab



#===============================================================================

# Scene_Title

#===============================================================================



class Scene_Title < Scene_Base

  

  #--------------------------------------------------------------------------

  # alias method: load_bt_database

  #--------------------------------------------------------------------------

  alias load_bt_database_nbs load_bt_database unless $@

  def load_bt_database

    load_bt_database_nbs

    load_nbs_cache

  end

  

  #--------------------------------------------------------------------------

  # alias method: load_database

  #--------------------------------------------------------------------------

  alias load_database_nbs load_database unless $@

  def load_database

    load_database_nbs

    load_nbs_cache

  end

  

  #--------------------------------------------------------------------------

  # new method: load_nbs_cache

  #--------------------------------------------------------------------------

  def load_nbs_cache

    groups = [$data_skills, $data_items, $data_weapons, $data_armors,

      $data_enemies, $data_states]

    for group in groups

      for obj in group

        next if obj == nil

        obj.yem_cache_baseitem_nbs if obj.is_a?(RPG::BaseItem)

        obj.yem_cache_item_nbs if obj.is_a?(RPG::Item)

        obj.yem_cache_state_nbs if obj.is_a?(RPG::State)

        obj.yem_cache_enemy_nbs if obj.is_a?(RPG::Enemy)

      end

    end

  end

  

end # Scene_Title



#===============================================================================

# Game_Battler

#===============================================================================



class Game_Battler

  

  #--------------------------------------------------------------------------

  # anti-crash method: clear_battle_cache

  #--------------------------------------------------------------------------

  unless method_defined?(:clear_battle_cache)

  def clear_battle_cache; @cache_params = {}; end

  end # method_defined?(:clear_battle_cache)

    

  #--------------------------------------------------------------------------

  # anti-crash method: parameter_limit

  #--------------------------------------------------------------------------

  unless method_defined?(:parameter_limit)

  def parameter_limit; return 999; end

  end # method_defined?(:parameter_limit)

  

  #--------------------------------------------------------------------------

  # anti-crash method: stack

  #--------------------------------------------------------------------------

  unless method_defined?(:stack)

  def stack(state); return 1; end

  end # method_defined?(:stack)

  

  #--------------------------------------------------------------------------

  # alias method: item_growth_effect

  #--------------------------------------------------------------------------

  alias item_growth_effect_nbs item_growth_effect unless $@

  def item_growth_effect(user, item)

    item_growth_effect_nbs(user, item)

    if item.stat_growth != {}

      for key in item.stat_growth

        stat = key[0]; value = key[1]

        case stat

        when :dex

          @boost_dex += value

        when :res

          @boost_res += value

        end

      end

    end

  end

  

  if $imported["DEX Stat"]

  #--------------------------------------------------------------------------

  # new method: dex

  #--------------------------------------------------------------------------

  def dex

    clear_battle_cache if @cache_params == nil

    if $scene.is_a?(Scene_Battle)

      return @cache_params[:dex] if @cache_params[:dex] != nil

    end

    #---

    @dex_plus = 0 if @dex_plus == nil

    n = [base_dex + @dex_plus, 1].max

    for state in states

      stack(state).times do

        n = n * state.dex_rate / 100.0

      end

    end

    for state in states

      next if state.dex_set == 0

      n += state.dex_set * stack(state)

    end

    #---

    @cache_params[:dex] = [[Integer(n), parameter_limit].min, 1].max

    return @cache_params[:dex]

  end

  

  #--------------------------------------------------------------------------

  # new method: dex=

  #--------------------------------------------------------------------------

  def dex=(value)

    @dex_plus = 0 if @dex_plus == nil

    @dex_plus += value - self.dex

    @dex_plus = [[@dex_plus, -parameter_limit].max, parameter_limit].min

    clear_battle_cache

  end

  #--------------------------------------------------------------------------

  end # imported["DEX Stat"]



  if $imported["RES Stat"]

  #--------------------------------------------------------------------------

  # new method: res

  #--------------------------------------------------------------------------

  def res

    clear_battle_cache if @cache_params == nil

    if $scene.is_a?(Scene_Battle)

      return @cache_params[:res] if @cache_params[:res] != nil

    end

    #---

    @res_plus = 0 if @res_plus == nil

    n = [base_res + @res_plus, 1].max

    for state in states

      stack(state).times do

        n = n * state.res_rate / 100.0

      end

    end

    for state in states

      next if state.res_set == 0

      n += state.res_set * stack(state)

    end

    #---

    @cache_params[:res] = [[Integer(n), parameter_limit].min, 1].max

    return @cache_params[:res]

  end

  

  #--------------------------------------------------------------------------

  # new method: res=

  #--------------------------------------------------------------------------

  def res=(value)

    @res_plus = 0 if @res_plus == nil

    @res_plus += value - self.res

    @res_plus = [[@res_plus, -parameter_limit].max, parameter_limit].min

    clear_battle_cache

  end

  

  #--------------------------------------------------------------------------

  # overwrite method: make_obj_damage_value

  #--------------------------------------------------------------------------

  unless $imported["BattleEngineMelody"]

  def make_obj_damage_value(user, obj)

    damage = obj.base_damage

    if damage > 0

      damage += user.atk * 4 * obj.atk_f / 100

      damage += user.spi * 2 * obj.spi_f / 100

      unless obj.ignore_defense

        damage -= self.def * 2 * obj.atk_f / 100

        damage -= self.res * 1 * obj.spi_f / 100

      end

      damage = 0 if damage < 0

    elsif damage < 0

      damage -= user.atk * 4 * obj.atk_f / 100

      damage -= user.spi * 2 * obj.spi_f / 100

    end

    damage *= elements_max_rate(obj.element_set)

    damage /= 100

    damage = apply_variance(damage, obj.variance)

    damage = apply_guard(damage)

    if obj.damage_to_mp

      @mp_damage = damage

    else

      @hp_damage = damage

    end

  end

  end # $imported["BattleEngineMelody"]

  #--------------------------------------------------------------------------

  end # imported["RES Stat"]

  

end # Game_Battler



#===============================================================================

# Game_Actor

#===============================================================================



class Game_Actor < Game_Battler

  

  if $imported["DEX Stat"]

  #--------------------------------------------------------------------------

  # new method: base_dex

  #--------------------------------------------------------------------------

  def base_dex

    if YEM::STATS::DEX::ACTOR_BASE.include?(@actor_id)

      n = eval(YEM::STATS::DEX::ACTOR_BASE[@actor_id])

    else

      n = eval(YEM::STATS::DEX::ACTOR_BASE[0])

    end

    #---

    percent = 100

    for equip in equips.compact

      percent += equip.dex_per

    end

    n *= percent / 100.0

    #---

    for equip in equips.compact

      n += equip.dex

    end

    #---

    n += equip_skill_stat_bonus(:dex) if $imported["SkillEquipSystem"]

    #---

    @boost_dex = 0 if @boost_dex == nil

    n += @boost_dex

    return Integer(n)

  end

  

  #--------------------------------------------------------------------------

  # alias method: hit

  #--------------------------------------------------------------------------

  alias hit_game_actor_nbs hit unless $@

  def hit

    n = hit_game_actor_nbs

    n += eval(YEM::STATS::DEX::DEX_TO_HIT)

    return [Integer(n), 0].max

  end

  

  #--------------------------------------------------------------------------

  # alias method: eva

  #--------------------------------------------------------------------------

  alias eva_game_actor_nbs eva unless $@

  def eva

    n = eva_game_actor_nbs

    n += eval(YEM::STATS::DEX::DEX_TO_EVA)

    return [Integer(n), 0].max

  end

  

  #--------------------------------------------------------------------------

  # alias method: cri

  #--------------------------------------------------------------------------

  alias cri_game_actor_nbs cri unless $@

  def cri

    n = cri_game_actor_nbs

    n += eval(YEM::STATS::DEX::DEX_TO_CRI)

    return [Integer(n), 0].max

  end

  #--------------------------------------------------------------------------

  end # imported["DEX Stat"]

  

  if $imported["RES Stat"]

  #--------------------------------------------------------------------------

  # new method: base_res

  #--------------------------------------------------------------------------

  def base_res

    if YEM::STATS::RES::ACTOR_BASE.include?(@actor_id)

      n = eval(YEM::STATS::RES::ACTOR_BASE[@actor_id])

    else

      n = eval(YEM::STATS::RES::ACTOR_BASE[0])

    end

    #---

    percent = 100

    for equip in equips.compact

      percent += equip.res_per

    end

    n *= percent / 100.0

    #---

    for equip in equips.compact

      n += equip.res

    end

    #---

    n += equip_skill_stat_bonus(:res) if $imported["SkillEquipSystem"]

    #---

    @boost_res = 0 if @boost_res == nil

    n += @boost_res

    return Integer(n)

  end

  #--------------------------------------------------------------------------

  end # imported["RES Stat"]

  

end # Game_Actor



#===============================================================================

# Game_Enemy

#===============================================================================



class Game_Enemy < Game_Battler

  

  if $imported["DEX Stat"]

  #--------------------------------------------------------------------------

  # new method: base_dex

  #--------------------------------------------------------------------------

  def base_dex

    @boost_dex = 0 if @boost_dex == nil

    n = Integer(enemy.dex) + @boost_dex

    if $imported["EnemyLevels"]

      base = n

      per = enemy.growth_per[:dex]

      set = enemy.growth_set[:dex]

      result = Integer(eval(YEM::ENEMY_LEVEL::BASE_FORMULAS[:dex]))

    end

    return n

  end

  

  #--------------------------------------------------------------------------

  # alias method: hit

  #--------------------------------------------------------------------------

  alias hit_game_enemy_nbs hit unless $@

  def hit

    n = hit_game_enemy_nbs

    n += eval(YEM::STATS::DEX::DEX_TO_HIT)

    return [Integer(n), 0].max

  end

  

  #--------------------------------------------------------------------------

  # alias method: eva

  #--------------------------------------------------------------------------

  alias eva_game_enemy_nbs eva unless $@

  def eva

    n = eva_game_enemy_nbs

    n += eval(YEM::STATS::DEX::DEX_TO_EVA)

    return [Integer(n), 0].max

  end

  

  #--------------------------------------------------------------------------

  # alias method: cri

  #--------------------------------------------------------------------------

  alias cri_game_enemy_nbs cri unless $@

  def cri

    n = cri_game_enemy_nbs

    n += eval(YEM::STATS::DEX::DEX_TO_CRI)

    return [Integer(n), 0].max

  end

  #--------------------------------------------------------------------------

  end # imported["DEX Stat"]

  

  if $imported["RES Stat"]

  #--------------------------------------------------------------------------

  # new method: base_res

  #--------------------------------------------------------------------------

  def base_res

    @boost_res = 0 if @boost_res == nil

    n = Integer(enemy.res) + @boost_res

    if $imported["EnemyLevels"]

      base = n

      per = enemy.growth_per[:dex]

      set = enemy.growth_set[:dex]

      result = Integer(eval(YEM::ENEMY_LEVEL::BASE_FORMULAS[:dex]))

    end

    return n

  end

  #--------------------------------------------------------------------------

  end # imported["RES Stat"]

  

end # Game_Enemy



#===============================================================================

# Window_Base

#===============================================================================



class Window_Base < Window

  

  #--------------------------------------------------------------------------

  # alias method: draw_actor_parameter

  #--------------------------------------------------------------------------

  alias draw_actor_parameter_nbs draw_actor_parameter unless $@

  def draw_actor_parameter(actor, x, y, type)

    case type

    when 4 # RES

      parameter_name = Vocab::res

      parameter_value = actor.res

    when 5 # DEX

      parameter_name = Vocab::dex

      parameter_value = actor.dex

    else

      draw_actor_parameter_nbs(actor, x, y, type)

      return

    end

    self.contents.font.color = system_color

    self.contents.draw_text(x, y, 120, WLH, parameter_name)

    self.contents.font.color = normal_color

    self.contents.draw_text(x + 120, y, 36, WLH, parameter_value, 2)

  end

  

end # Window_Base



#===============================================================================

# Window_Status

#===============================================================================



class Window_Status < Window_Base

  

  #--------------------------------------------------------------------------

  # alias method: draw_parameters

  #--------------------------------------------------------------------------

  alias draw_parameters_nbs draw_parameters unless $@

  def draw_parameters(x, y)

    draw_parameters_nbs(x, y)

    dy = y+WLH*3

    if $imported["RES Stat"]

      dy += WLH

      draw_actor_parameter(@actor, x, dy, 4)

    end

    if $imported["DEX Stat"]

      dy += WLH

      draw_actor_parameter(@actor, x, dy, 5)

    end

  end

  

end # Window_Status



#===============================================================================

# 

# END OF FILE

# 

#===============================================================================