#===============================================================================
# ** Ruby.Array.find
#===============================================================================

class Array
  #-----------------------------------------------------------------------------
  # * Name      : Next Index From
  #   Info      : Gets next item in array (in a wrapped fashion)
  #   Author    : Kain Nobel
  #   Call Info : Item is the object in question
  #               Indexes is how many spaces ahead to look
  #-----------------------------------------------------------------------------
  def next_index_from(item, indexes = 1)
    indexes = -indexes if indexes < 0
    if self.include?(item)
      for i in 0...self.size
        if self[i] == item
          if self.size > (i + indexes)
            return self[i + indexes]
          end
          return self[(i + indexes) - self.size]
        end
      end
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Prev Index From
  #   Info      : Gets previous item in array (in a wrapped fashion)
  #   Author    : Kain Nobel
  #   Call Info : Item is the object in question
  #               Indexes is how many spaces ahead to look
  #-----------------------------------------------------------------------------
  def prev_index_from(item, indexes = 1)
    indexes = -indexes if indexes < 0
    if self.include?(item)
      for i in 0...self.size
        if self[i] == item
          if self.size >= i - indexes
            return self[i - indexes]
          end
          return self[self.size + (i - indexes)]
        end
      end
    end
  end
end


#===============================================================================
# ** RGSS.Actor and Party Info
#-------------------------------------------------------------------------------
#
# Method List:
# ------------
#
#   Game_Actor
#   ----------
#   exp_s
#   next_exp_s
#   next_rest_exp_s
#   now_exp
#   next_exp
#   weapon_set
#   armor_set
#   weapon_stats
#   armor_stats
#   strongest_weapon
#   weakest_weapon
#   strongest_armor
#   weakest_armor
#
#   Game_Actors
#   -----------
#   each
#   min_stat
#   max_stat
#   average
#   avg_stat
#   min_stats
#   max_stats
#   avg_stats
#   
#
#   Game_Party
#   ----------
#   members
#   gain_all
#   lose_all
#   min_stat
#   max_stat
#   min_stats
#   max_stats
#   average
#   recover_all
#   revive_all
#   kill_all
#   recover_hp
#   recover_sp
#   add_state
#   add_states
#   remove_state
#   remove_states
#   change_states
#
#===============================================================================
#-------------------------------------------------------------------------------
# * MACL Loading
#-------------------------------------------------------------------------------
if Object.const_defined?(:MACL)
  MACL::Loaded << 'RGSS.Actor and Party Info'
end
#===============================================================================
# ** Game_Actor
#===============================================================================
class Game_Actor < Game_Battler
  #-----------------------------------------------------------------------------
  # * Public Instance Variables
  #-----------------------------------------------------------------------------
  attr_accessor :weapon_id
  attr_accessor :armor1_id
  attr_accessor :armor2_id
  attr_accessor :armor3_id
  attr_accessor :armor4_id
  attr_accessor :exp_list
  #-----------------------------------------------------------------------------
  # * Alias Listings
  #-----------------------------------------------------------------------------
  alias_method :kn_macl_gm_actor_equip, :equip
  #-----------------------------------------------------------------------------
  # * Equip
  #-----------------------------------------------------------------------------
  def equip(equip_type, id)
    unless id < 0
      kn_macl_gm_actor_equip(equip_type, id)
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Now Exp
  #   Info      : Gets Actors Next in Current Level
  #   Author    : Near Fantastica
  #   Call Info : No Arguments
  #-----------------------------------------------------------------------------
  def now_exp
    return @exp - @exp_list[@level]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Next Exp
  #   Info      : Gets Actors Exp for Next Level
  #   Author    : Near Fantastica
  #   Call Info : No Arguments
  #-----------------------------------------------------------------------------
  def next_exp
    exp = @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
    return exp
  end
  #-----------------------------------------------------------------------------
  # * Name      : Last Exp
  #   Info      : Returns numerical value of last exp
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def last_exp
    return @exp_list[-2]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Last Level
  #   Info      : Returns numerical value of last level achievable
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def final_level
    unless $data_actors[id].nil?
      return $data_actors[id].final_level
    end
    return 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : Experience String (Overwrite)
  #   Info      : Returns Experience String
  #   Author    : Kain Nobel
  #   Call Info : Format will format experience string with commas
  #-----------------------------------------------------------------------------
  def exp_s(format = true)
    if format == true
      return now_exp.between?(0, last_exp) ? now_exp.format_s : "Master"
    else
      return now_exp.between?(0, last_exp) ? now_exp.to_s     : "Master"
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Next Experience String (Overwrite)
  #   Info      : Returns Experience String
  #   Author    : Kain Nobel
  #   Call Info : Format will format experience string with commas
  #-----------------------------------------------------------------------------
  def next_exp_s(format = true)
    if self.now_exp >= self.last_exp
      return "Master"
    else
      if format == true
        return now_exp.between?(0, next_exp) ? next_exp.format_s : now_exp.format_s
      else
        return now_exp.between?(0, next_exp) ? next_exp.to_s     : now_exp.to_s
      end
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Weapon Set
  #   Info      : Returns all weapon objects for an actor's class
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def weapon_set
    return $data_classes[@class_id].weapon_set
  end
  #-----------------------------------------------------------------------------
  # * Name      : Armor Set
  #   Info      : Returns all armor objects for an actor's class
  #   Author    : Kain Nobel
  #   Call Info : Kind ID for the Armors to check
  #-----------------------------------------------------------------------------
  def armor_set(kind = nil)
    if kind.nil?
      return $data_classes[@class_id].armor_set
    end
    armors = []
    ($data_classes[@class_id].armor_set).each do |armor|
      armors.push(armor) if $data_armors[armor].kind == kind
    end
    return armors
  end
  #-----------------------------------------------------------------------------
  # * Name      : Weapon Stats
  #   Info      : Returns a list of desired stats for the actor's weapon set
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def weapon_stats(parameter)
    arr, weapons = Array.new, Array.new
    weapon_set.each do |id|
      if $game_party.weapons.has_key?(id)
        if $game_party.weapons[id] > 0
          weapons << id
        end
      end
    end
    weapons.sort!
    weapons.each do |id|
      case parameter
      when 'name' ; arr << [id, $data_weapons[id].name]
      when 'price'; arr << [id, $data_weapons[id].price]
      when 'atk'  ; arr << [id, $data_weapons[id].atk]
      when 'pdef' ; arr << [id, $data_weapons[id].pdef]
      when 'mdef' ; arr << [id, $data_weapons[id].mdef]
      when 'str'  ; arr << [id, $data_weapons[id].str_plus]
      when 'dex'  ; arr << [id, $data_weapons[id].dex_plus]
      when 'agi'  ; arr << [id, $data_weapons[id].agi_plus]
      when 'int'  ; arr << [id, $data_weapons[id].int_plus]
      else ; print(":"+parameter+": is not a valid parameter when\n",
      "checking for $game_actor["+@actor_id.to_s+"].weapon_stats()")
      end
    end
    return arr
  end
  #-----------------------------------------------------------------------------
  # * Name      : Armor Stats
  #   Info      : Returns a list of desired stats for an actor's armor set
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #               Kind refers to the kind of amror it is
  #-----------------------------------------------------------------------------
  def armor_stats(parameter, kind = 0)
    arr, armors = Array.new, Array.new
    armor_set.each do |id|
      if $data_armors[id].kind == kind && $game_party.armors.has_key?(id)
        if $game_party.armors[id] > 0
          armors << id
        end
      end
    end
    armors.sort!
    armors.each do |id|
      case parameter
      when 'name' ; arr << [id, $data_armors[id].name]
      when 'price'; arr << [id, $data_armors[id].price]
      when 'atk'  ; arr << [id, $data_armors[id].atk]
      when 'pdef' ; arr << [id, $data_armors[id].pdef]
      when 'mdef' ; arr << [id, $data_armors[id].mdef]
      when 'str'  ; arr << [id, $data_armors[id].str_plus]
      when 'dex'  ; arr << [id, $data_armors[id].dex_plus]
      when 'agi'  ; arr << [id, $data_armors[id].agi_plus]
      when 'int'  ; arr << [id, $data_armors[id].int_plus]
      else ; print(":"+parameter+": is not a valid parameter when\n",
      "checking for $game_actor["+@actor_id.to_s+"].armor_stats()")
      end
    end
    return arr
  end
  #-----------------------------------------------------------------------------
  # * Name      : Strongest Weapon
  #   Info      : Returns the strongest weapon, based on parameter
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def strongest_weapon(parameter)
    arr, stats = Array.new, Array.new
    weapon_stats(parameter).each do |stat|
      stats << stat[1]
    end
    stats.sort!
    stats.reverse!
    stats.each do |stat|
      weapon_stats(parameter).each do |param|
        if param[1] == stat && stat > 0
          return param[0]
        end
      end
    end
    return -1
  end
  #-----------------------------------------------------------------------------
  # * Name      : Strongest Armor
  #   Info      : Returns the strongest armor, based on parameter and kind
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #               Kind is what kind of armor it is (shield, helmet, etc.)
  #-----------------------------------------------------------------------------
  def strongest_armor(parameter, kind = 0)
    arr, stats = Array.new, Array.new
    armor_stats(parameter, kind).each do |stat|
      stats << stat[1]
    end
    stats.sort!
    stats.reverse!
    stats.each do |stat|
      armor_stats(parameter, kind).each do |param|
        if param[1] == stat && stat > 0
          return param[0]
        end
      end
    end
    return -1
  end
  #-----------------------------------------------------------------------------
  # * Name      : Weakest Weapon
  #   Info      : Returns the weakest weapon, based on parameter
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def weakest_weapon(parameter)
    arr, stats = Array.new, Array.new
    weapon_stats(parameter).each do |stat|
      stats << stat[1]
    end
    stats.sort!
    stats.each do |stat|
      weapon_stats(parameter).each do |param|
        if param[1] == stat && stat > 0
          return param[0]
        end
      end
    end
    return -1
  end
  #-----------------------------------------------------------------------------
  # * Name      : Weakest Armor
  #   Info      : Returns the strongest armor, based on parameter and kind
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #               Kind is what kind of armor it is (shield, helmet, etc.)
  #-----------------------------------------------------------------------------
  def weakest_armor(parameter, kind = 0)
    arr, stats = Array.new, Array.new
    armor_stats(parameter, kind).each do |stat|
      stats << stat[1]
    end
    stats.sort!
    stats.each do |stat|
      armor_stats(parameter, kind).each do |param|
        if param[1] == stat && stat > 0
          return param[0]
        end
      end
    end
    return -1
  end
  #-----------------------------------------------------------------------------
  # * Name      : Unequip All
  #   Info      : Removes all equipment from actor
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def unequip_all
    [0,1,2,3,4].each do |i|
      equip(i, 0)
    end
  end
end

#===============================================================================
# ** Game_Actors
#===============================================================================

class Game_Actors
  #-----------------------------------------------------------------------------
  # * Name      : Each
  #   Info      : Adds an 'each' method to $game_actors
  #   Author    : Kain Nobel
  #   Call Info : Any normal way you'd call an 'each' method
  #-----------------------------------------------------------------------------
  def each(&block)
    @data.each(&block)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Min Stat
  #   Info      : For attribute in question, returns lowest value from actors
  #   Author    : Kain Nobel
  #   Call Info : Attribute is a String representing attribute in question
  #-----------------------------------------------------------------------------
  def min_stat(attribute)
    attributes = Array.new
    for actor in @data
      value = eval("actor.#{attribute}")
      attributes << value
    end
    attributes.sort!
    return attributes[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Max Stat
  #   Info      : For attribute in question, returns highest value from actors
  #   Author    : Kain Nobel
  #   Call Info : Attribute is a String representing attribute in question
  #-----------------------------------------------------------------------------
  def max_stat(attribute)
    attributes = Array.new
    for actor in @data
      value = eval("actor.#{attribute}")
      attributes << value
    end
    attributes.sort!
    return attributes[-1]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Average
  #   Info      : Same as 'avg_stat'
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def average(attribute)
    return avg_stat(attribute)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Avg Stat
  #   Info      : Returns average of all actors' stats, based on parameter
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def avg_stat(stat)
    avg = 0
    for i in 1...$data_actors.size
      case stat
      when 'hp'     ; avg += self[i].hp
      when 'maxhp'  ; avg += self[i].maxhp
      when 'sp'     ; avg += self[i].sp
      when 'maxsp'  ; avg += self[i].maxsp
      when 'level'  ; avg += self[i].level
      when 'exp'    ; avg += self[i].exp
      when 'str'    ; avg += self[i].str
      when 'dex'    ; avg += self[i].dex
      when 'agi'    ; avg += self[i].agi
      when 'int'    ; avg += self[i].int
      when 'atk'    ; avg += self[i].atk
      when 'pdef'   ; avg += self[i].pdef
      when 'mdef'   ; avg += self[i].mdef
      when 'eva'    ; avg += self[i].eva
      end
    end
    return (avg / $data_actors.size - 1)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Min Stats
  #   Info      : Generates an array of attributes with 'min_stat' method
  #   Author    : Kain Nobel
  #   Call Info : Attributes is an Array of attributes names in Question
  #-----------------------------------------------------------------------------
  def min_stats(attributes)
    list = Array.new
    attributes.each {|attr| list << min_stat(attr)}
    return list
  end
  #-----------------------------------------------------------------------------
  # * Name      : Max Stats
  #   Info      : Generates an array of attributes with 'max_stat' method
  #   Author    : Kain Nobel
  #   Call Info : Attributes is an Array of attributes names in Question
  #-----------------------------------------------------------------------------
  def max_stats(attributes)
    list = Array.new
    attributes.each {|attr| list << max_stat(attr)}
    return list
  end
  #-----------------------------------------------------------------------------
  # * Name      : Avg Stats
  #   Info      : Generates an array of attributes with 'average' method
  #   Author    : Kain Nobel
  #   Call Info : Attributes is an Array of attributes names in Question
  #-----------------------------------------------------------------------------
  def avg_stats(attributes)
    list = Array.new
    attributes.each {|attr| list << avg_stat(attr)}
    return list
  end
end

#===============================================================================
# ** Game_Party
#===============================================================================

class Game_Party
  #-----------------------------------------------------------------------------
  # * Public Instance Variables
  #-----------------------------------------------------------------------------
  attr_accessor :gold # This is set so you can do $game_party.gold = n
  #-----------------------------------------------------------------------------
  # * Name      : Members
  #   Info      : Returns @actors
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def members
    return @actors
  end
  #-----------------------------------------------------------------------------
  # * Name      : Gain All
  #   Info      : Gain all items (depending on type)
  #   Author    : Kain Nobel
  #   Call Info : Type is the type of 'item' to gain
  #                 -1 : All Items, Weapons, Armors
  #                  0 : All Items
  #                  1 : All Weapons
  #                  2 : All Armors
  #               Quantity is an integer from 1 to 99 (Optional)
  #-----------------------------------------------------------------------------
  def gain_all(type, quantity = 99)
    if type.is_a?(Fixnum) && type.between?(-1, 2)
      case type
      when -1
        $data_items.each_index    {|i| gain_item(i, quantity.abs)}
        $data_weapons.each_index  {|i| gain_weapon(i, quantity.abs)}
        $data_armors.each_index   {|i| gain_armor(i, quantity.abs)}
      when 0 ; $data_items.each_index   {|i| gain_item(i, quantity.abs)}
      when 1 ; $data_weapons.each_index {|i| gain_weapon(i, quantity.abs)}
      when 2 ; $data_armors.each_index  {|i| gain_armor(i, quantity.abs)}
      end
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Lose All
  #   Info      : Lose all items (depending on type)
  #   Author    : Kain Nobel
  #   Call Info : Type is the type of 'item' to lose
  #                 -1 : All Items, Weapons, Armors
  #                  0 : All Items
  #                  1 : All Weapons
  #                  2 : All Armors
  #               Quantity is an integer from 1 to 99 (Optional)
  #-----------------------------------------------------------------------------
  def lose_all(type, quantity = 99)
    quantity = -quantity.abs if quantity > 0
    gain_all(type, quantity)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Min Stat
  #   Info      : For attribute in question, returns lowest value from members
  #   Author    : Kain Nobel
  #   Call Info : Attribute is a String representing attribute in question
  #-----------------------------------------------------------------------------
  def min_stat(attribute)
    attributes = Array.new
    for member in self.members
      value = eval("member.#{attribute}")
      attributes << value
    end
    attributes.sort!
    return attributes[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Max Stat
  #   Info      : For attribute in question, returns highest value from members
  #   Author    : Kain Nobel
  #   Call Info : Attribute is a String representing attribute in question
  #-----------------------------------------------------------------------------
  def max_stat(attribute)
    attributes = Array.new
    for member in self.members
      value = eval("member.#{attribute}")
      attributes << value
    end
    attributes.sort!
    return attributes[-1]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Average
  #   Info      : Same as 'avg_stat'
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def average(attribute)
    return avg_stat(attribute)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Avg Stat
  #   Info      : Returns average of party's attributes, based on parameter
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def avg_stat(attribute)
    return 0 if self.members.size == 0
    avg = 0
    case attribute.downcase
    when 'hp'    ; self.members.each {|m| avg += m.hp}
    when 'maxhp' ; self.members.each {|m| avg += m.maxhp}
    when 'sp'    ; self.members.each {|m| avg += m.sp}
    when 'maxsp' ; self.members.each {|m| avg += m.maxsp}
    when 'level' ; self.members.each {|m| avg += m.level}
    when 'exp'   ; self.members.each {|m| avg += m.exp}
    when 'str'   ; self.members.each {|m| avg += m.str}
    when 'dex'   ; self.members.each {|m| avg += m.dex}
    when 'agi'   ; self.members.each {|m| avg += m.agi}
    when 'int'   ; self.members.each {|m| avg += m.int}
    when 'atk'   ; self.members.each {|m| avg += m.atk}
    when 'pdef'  ; self.members.each {|m| avg += m.pdef}
    when 'mdef'  ; self.members.each {|m| avg += m.mdef}
    when 'eva'   ; self.members.each {|m| avg += m.eva}
    end
    return (avg / self.members.size)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Min Stats
  #   Info      : Generates an array of attributes with 'min_stat' method
  #   Author    : Kain Nobel
  #   Call Info : Attributes is an Array of attributes names in Question
  #-----------------------------------------------------------------------------
  def min_stats(attributes)
    list = Array.new
    attributes.each {|attr| list << min_stat(attr)}
    return list
  end
  #-----------------------------------------------------------------------------
  # * Name      : Max Stats
  #   Info      : Generates an array of attributes with 'max_stat' method
  #   Author    : Kain Nobel
  #   Call Info : Attributes is an Array of attributes names in Question
  #-----------------------------------------------------------------------------
  def max_stats(attributes)
    list = Array.new
    attributes.each {|attr| list << max_stat(attr)}
    return list
  end
  #-----------------------------------------------------------------------------
  # * Name      : Avg Stats
  #   Info      : Generates an array of attributes with 'average' method
  #   Author    : Kain Nobel
  #   Call Info : Attributes is an Array of attributes names in Question
  #-----------------------------------------------------------------------------
  def avg_stats(attributes)
    list = Array.new
    attributes.each {|attr| list << avg_stat(attr)}
    return list
  end
  #-----------------------------------------------------------------------------
  # * Name      : Recover All
  #   Info      : Recover HP/SP and States
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def recover_all
    self.members.each {|m| m.recover_all}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Revive All
  #   Info      : Revive all actors with percent/direct ammount of HP
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def revive_all(direct = 0, percent = 0)
    self.members.each {|m|
    unless m.hp > 0
      m.hp += Integer(direct * (percent / 100.0))
    end}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Kill All
  #   Info      : Kill all actors instantly
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def kill_all
    self.members.each {|m| m.hp = 0}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Add State
  #   Info      : Inflicts all actors with designated state
  #   Author    : Kain Nobel
  #   Call Info : State ID - Integer representing State's ID in database
  #-----------------------------------------------------------------------------
  def add_state(state_id)
    self.members.each {|m| m.add_state(state_id)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Remove State
  #   Info      : Removes designated State from all actors
  #   Author    : Kain Nobel
  #   Call Info : State ID - Integer representing State's ID in database
  #-----------------------------------------------------------------------------
  def remove_state(state_id)
    self.members.each {|m| m.remove_state(state_id)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Add States
  #   Info      : Inflicst all actors with an array of states
  #   Author    : Kain Nobel
  #   Call Info : States - Array with State IDs to be added
  #-----------------------------------------------------------------------------
  def add_states(states = [])
    states.compact!
    states.each {|state| self.add_state(state)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Remove States
  #   Info      : Removes an array of states from all actors
  #   Author    : Kain Nobel
  #   Call Info : States - Array of State IDs to be removed
  #-----------------------------------------------------------------------------
  def remove_states(states = [])
    states.compact!
    states.each {|state| self.remove_state(state)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Change States
  #   Info      : Compresses 'add_states' and 'remove_states'
  #   Author    : Kain Nobel
  #   Call Info : States - Array of State IDs to be added/removed
  #                 State IDs must be positive to be added
  #                 State IDs must be negative to be removed
  #               States can also be a Hash with (State ID => true/false)
  #                 If State ID points to True  : it will be added
  #                 If State ID points to False : it will be removed
  #-----------------------------------------------------------------------------
  def change_states(states = [])
    add, rem = Array.new, Array.new
    if states.is_a?(Array)
      states.each do |id|
        add << id if id > 0
        rem << -id if id < 0
      end
    elsif states.is_a?(Hash)
      states.each_key do |key|
        add << key if states[key] == true
        rem << key if states[key] == false
      end
    end
    self.add_states(add)
    self.remove_states(rem)
  end
end


]#===============================================================================
# ** RGSS.Battler
#===============================================================================

class Game_Battler
  #-----------------------------------------------------------------------------
  # * Name      : Is Actor?
  #   Info      : Returns true/false if self is a Game_Actor class
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_actor?
    return (self.is_a?(Game_Actor) || self.kind_of?(Game_Actor))
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Enemy?
  #   Info      : Returns true/false if self is a Game_Enemy class
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_enemy?
    return (self.is_a?(Game_Enemy) || self.kind_of?(Game_Enemy))
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Ally With?
  #   Info      : Returns true/false if battler kind is same
  #   Author    : Kain Nobel
  #   Call Info : Battler is the Game_Battler object in question.
  #-----------------------------------------------------------------------------
  def is_ally_with?(battler)
    return self.kind_of?(battler.class)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Enemy With?
  #   Info      : Returns true/false if battler kind is different
  #   Author    : Kain Nobel
  #   Call Info : Battler is the Game_Battler object in question.
  #-----------------------------------------------------------------------------
  def is_enemy_with?(battler)
    return !self.kind_of?(battler.class)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Belongs To Unit?
  #   Info      : Returns true/false if self belongs to Party or Troop
  #   Author    : Kain Nobel
  #   Call Info : Unit is either a Game_Party or Game_Troop class
  #-----------------------------------------------------------------------------
  def belongs_to_unit?(unit)
    belongs = false
    belongs |= self.is_actor? && unit.is_a?(Game_Party)
    belongs |= self.is_enemy? && unit.is_a?(Game_Troop)
    return belongs
  end
  #-----------------------------------------------------------------------------
  # * Name      : Member of Unit?
  #   Info      : Returns true/false if Party or Troop has battler
  #   Author    : Kain Nobel
  #   Call Info : Unit is either a Game_Party or Game_Troop class
  #-----------------------------------------------------------------------------
  def member_of_unit?(unit)
    case unit.class
    when Game_Party ; return unit.actors.include?(self)
    when Game_Troop ; return unit.enemies.include?(self)
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Belongs To Party? 
  #   Info      : Returns true/false if self belongs to Game_Party
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def belongs_to_party?
    return self.belongs_to_unit?(Game_Party.new)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Belongs To Party? 
  #   Info      : Returns true/false if self belongs to Game_Troop
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def belongs_to_troop?
    return self.belongs_to_unit?(Game_Troop.new)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Member of Party?
  #   Info      : Returns true/false if Party has battler
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def member_of_party?
    return self.member_of_unit?($game_party) rescue return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Member of Troop?
  #   Info      : Returns true/false if Troop has battler
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def member_of_troop?
    return self.member_of_unit?($game_troop) rescue return false
  end
end


#===============================================================================
# ** RGSS.Character
#===============================================================================

class Game_Character
  #-----------------------------------------------------------------------------
  # * Name      : XY
  #   Info      : Returns @x and @y properties to array.
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def xy
    return [self.x, self.y]
  end
  #-----------------------------------------------------------------------------
  # * Name      : XYD
  #   Info      : Returns @x, @y and @direction properties to array.
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def xyd
    return [self.x, self.y, self.direction]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Next X
  #   Info      : Returns next X coord for facing direction
  #   Author    : Kain Nobel
  #   Call Info : Direction is the direction character is facing
  #-----------------------------------------------------------------------------
  def next_x(d = self.direction, steps = 1)
    return (self.x + (steps * (d == 6 ? 1 : d == 4 ? -1 : 0)))
  end
  #-----------------------------------------------------------------------------
  # * Name      : Next Y
  #   Info      : Returns next Y coord for facing direction
  #   Author    : Kain Nobel
  #   Call Info : Direction is the direction character is facing
  #-----------------------------------------------------------------------------
  def next_y(d = self.direction, steps = 1)
    return (self.y + (steps * (d == 2 ? 1 : d == 8 ? -1 : 0)))
  end
  #-----------------------------------------------------------------------------
  # * Name      : Next X/Y
  #   Info      : Returns next X & Y coord for facing direction (to an array)
  #   Author    : Kain Nobel
  #   Call Info : Direction is the direction character is facing
  #-----------------------------------------------------------------------------
  def next_xy(d = self.direction, steps = 1)
    return [self.next_x(d, steps), self.next_y(d, steps)]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Events Front
  #   Info      : Returns all events on same tile
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def events_here
    return $game_map.events_at(*self.xy)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Events Front
  #   Info      : Returns all events on tile front
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def events_front
    return $game_map.events_at(*self.xyd)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Events Behind
  #   Info      : Returns all events on tile behind
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def events_behind
    d = case self.direction
    when 2 then 8
    when 4 then 6
    when 6 then 4
    when 8 then 2
    end
    return $game_map.events_at(self.x, self.y, d)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Events Left
  #   Info      : Returns all events on tile to left hand of self
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def events_left
    d = case self.direction
    when 2 then 6
    when 4 then 2
    when 6 then 8
    when 8 then 4
    end
    return $game_map.events_at(self.x, self.y, d)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Events Right
  #   Info      : Returns all events on tile to right hand of self
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def events_right
    d = case self.direction
    when 2 then 4
    when 4 then 8
    when 6 then 2
    when 8 then 6
    end
    return $game_map.events_at(self.x, self.y, d)
  end
  #-----------------------------------------------------------------------------
  # * Name      : This Event
  #   Info      : Returns very first event from 'events_here' or 'event_front'
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def this_event
    return self.event_here unless self.event_here.nil?
    return self.event_front
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event Here
  #   Info      : Returns very first event from 'events_here'
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def event_here
    return self.events_here[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event Front
  #   Info      : Returns very first event from 'events_front'
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def event_front
    return self.events_front[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event Behind
  #   Info      : Returns very first event from 'events_behind'
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def event_behind
    return self.events_behind[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event Left
  #   Info      : Returns very first event from 'events_left'
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def event_left
    return self.events_left[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event Right
  #   Info      : Returns very first event from 'events_right'
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def event_right
    return self.events_right[0]
  end
end


#===============================================================================
# ** RGSS.Enemy and Troop Info
#===============================================================================

#===============================================================================
# ** Game_Troop
#===============================================================================

class Game_Troop
  #-----------------------------------------------------------------------------
  # * Name      : Members
  #   Info      : Returns @enemies
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def members
    return @enemies
  end
  #-----------------------------------------------------------------------------
  # * Name      : Average
  #   Info      : Returns average of party's stats, based on parameter
  #   Author    : Kain Nobel
  #   Call Info : Parameter is a string representing parameter in question
  #-----------------------------------------------------------------------------
  def average(stat)
    return 0 if self.members.size == 0
    avg = 0
    case stat.downcase
    when 'hp'    ; self.members.each {|m| avg += m.hp}
    when 'maxhp' ; self.members.each {|m| avg += m.maxhp}
    when 'sp'    ; self.members.each {|m| avg += m.sp}
    when 'maxsp' ; self.members.each {|m| avg += m.maxsp}
    when 'level' ; self.members.each {|m| avg += m.level}
    when 'exp'   ; self.members.each {|m| avg += m.exp}
    when 'str'   ; self.members.each {|m| avg += m.str}
    when 'dex'   ; self.members.each {|m| avg += m.dex}
    when 'agi'   ; self.members.each {|m| avg += m.agi}
    when 'int'   ; self.members.each {|m| avg += m.int}
    when 'atk'   ; self.members.each {|m| avg += m.atk}
    when 'pdef'  ; self.members.each {|m| avg += m.pdef}
    when 'mdef'  ; self.members.each {|m| avg += m.mdef}
    when 'eva'   ; self.members.each {|m| avg += m.eva}
    end
    return (avg / self.members.size)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Recover All
  #   Info      : Recover HP/SP and States
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def recover_all
    self.members.each {|m| m.recover_all}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Revive All
  #   Info      : Revive all enemies with percent/direct ammount of HP
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def revive_all(direct = 0, percent = 0)
    self.members.each {|m|
    unless m.hp > 0
      m.hp += Integer(direct * (percent / 100.0))
    end}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Kill All
  #   Info      : Kill all enemies instantly
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def kill_all
    self.members.each {|m| m.hp = 0}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Add State
  #   Info      : Inflicts all enemies with designated state
  #   Author    : Kain Nobel
  #   Call Info : State ID - Integer representing State's ID in database
  #-----------------------------------------------------------------------------
  def add_state(state_id)
    self.members.each {|m| m.add_state(state_id)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Remove State
  #   Info      : Removes designated State from all enemies
  #   Author    : Kain Nobel
  #   Call Info : State ID - Integer representing State's ID in database
  #-----------------------------------------------------------------------------
  def remove_state(state_id)
    self.members.each {|m| m.remove_state(state_id)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Add States
  #   Info      : Inflicst all enemies with an array of states
  #   Author    : Kain Nobel
  #   Call Info : States - Array with State IDs to be added
  #-----------------------------------------------------------------------------
  def add_states(states = [])
    states.compact!
    states.each {|state| self.add_state(state)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Remove States
  #   Info      : Removes an array of states from all enemies
  #   Author    : Kain Nobel
  #   Call Info : States - Array of State IDs to be removed
  #-----------------------------------------------------------------------------
  def remove_states(states = [])
    states.compact!
    states.each {|state| self.remove_state(state)}
  end
  #-----------------------------------------------------------------------------
  # * Name      : Change States
  #   Info      : Compresses 'add_states' and 'remove_states'
  #   Author    : Kain Nobel
  #   Call Info : States - Array of State IDs to be added/removed
  #                 State IDs must be positive to be added
  #                 State IDs must be negative to be removed
  #               States can also be a Hash with (State ID => true/false)
  #                 If State ID points to True  : it will be added
  #                 If State ID points to False : it will be removed
  #-----------------------------------------------------------------------------
  def change_states(states = [])
    add, rem = Array.new, Array.new
    if states.is_a?(Array)
      states.each do |id|
        add << id if id > 0
        rem << -id if id < 0
      end
    elsif states.is_a?(Hash)
      states.each_key do |key|
        add << key if states[key] == true
        rem << key if states[key] == false
      end
    end
    self.add_states(add)
    self.remove_states(rem)
  end
end


#===============================================================================
# ** RGSS.Map
#-------------------------------------------------------------------------------
# Methods List
# ------------
#
# this_event
# event_count
# exists?
# map_infos
# map_count
# map_name
# parent_id
# parent_name
# print_list
#===============================================================================
#-------------------------------------------------------------------------------
# * MACL Loading
#-------------------------------------------------------------------------------
if Object.const_defined?(:MACL)
  MACL::Loaded << 'RGSS.Map'
end
#===============================================================================
# ** Game_Map
#===============================================================================

class Game_Map
  #-----------------------------------------------------------------------------
  # * Name      : Events At
  #   Info      : Returns an array of events at location
  #   Author    : Kain Nobel
  #   Call Info : Two Arguments Integer X, Y - Position to Check
  #               D (Optional) Integer - Directional modifier to check
  #-----------------------------------------------------------------------------
  def events_at(x, y, d = 0, attr = nil)
    events = Array.new
    x += (d == 6 ? 1 : d == 4 ? -1 : 0)
    y += (d == 2 ? 1 : d == 8 ? -1 : 0)
    @events.each_value {|event|
    if event.x == x && event.y == y
      eval "events << (attr.nil? ? event : event.#{attr})"
    end}
    return events
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event At
  #   Info      : Returns very first event from events_at method.
  #   Author    : SephirothSpawn / Kain Nobel
  #   Call Info : Two Arguments Integer X, Y - Position to Check
  #               D (Optional) Integer - Directional modifier to check
  #-----------------------------------------------------------------------------
  def event_at(x, y, d = 0, attr = nil)
    return events_at(x, y, d, attr)[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Characters At
  #   Info      : Returns an array of characters at location
  #   Author    : Kain Nobel
  #   Call Info : Two Arguments Integer X, Y - Position to Check
  #               D (Optional) Integer - Directional modifier to check
  #-----------------------------------------------------------------------------
  def characters_at(x, y, d = 0, attr = nil)
    characters = Array.new
    x += (d == 6 ? 1 : d == 4 ? -1 : 0)
    y += (d == 2 ? 1 : d == 8 ? -1 : 0)
    @characters.each_value {|character|
    if character.x == x && character.y == y
      eval "characters << (attr.nil? ? character : character.#{attr})"
    end}
    return characters
  end
  #-----------------------------------------------------------------------------
  # * Name      : Character At
  #   Info      : Returns very first character from characters_at method.
  #   Author    : SephirothSpawn / Kain Nobel
  #   Call Info : Two Arguments Integer X, Y - Position to Check
  #               D (Optional) Integer - Directional modifier to check
  #-----------------------------------------------------------------------------
  def character_at(x, y, d = 0, attr = nil)
    return characters_at(x, y, d, attr)[0]
  end
  #-----------------------------------------------------------------------------
  # * Name      : This Event
  #   Info      : Finds the first event directly in front of $game_player
  #   Author    : Kain Nobel
  #   Call Info : None, returns event here or event in front or nil if no event
  #-----------------------------------------------------------------------------
  def this_event
    return $game_player.this_event
  end
  #-----------------------------------------------------------------------------
  # * Name      : Event Count
  #   Info      : Simply counts how many events are on the $game_map
  #   Author    : Kain Nobel
  #   Call Info : None, returns number of events on map
  #-----------------------------------------------------------------------------
  def event_count
    return @events.empty? ? 0 : @events.size
  end
  #-----------------------------------------------------------------------------
  # * Name      : Exists?
  #   Info      : Tests to see if Map exists
  #   Author    : Kain Nobel
  #   Call Info : Map ID is the Map in question
  #-----------------------------------------------------------------------------
  def exists?(map_id)
    return FileTest.exist?(sprintf("Data/Map%03d.rxdata", map_id))
  end
  #-----------------------------------------------------------------------------
  # * Name      : Map Infos
  #   Info      : Returns "Data/MapInfos.rxdata"
  #   Author    : Kain Nobel
  #   Call Info : Miscellaneous
  #-----------------------------------------------------------------------------
  def map_infos
    @map_infos ||= load_data("Data/MapInfos.rxdata")
    return @map_infos
  end
  #-----------------------------------------------------------------------------
  # * Name      : Map Count
  #   Info      : Returns number of valid Map filenames
  #   Author    : Kain Nobel
  #   Call Info : None, returns number of maps in project folder
  #-----------------------------------------------------------------------------
  def map_count
    return map_infos.keys.size
  end
  #-----------------------------------------------------------------------------
  # * Name      : Map Name
  #   Info      : Sends name of the map in question to a string
  #   Author    : Kain Nobel
  #   Call Info : Map ID (Optional) returns specified Map ID's name
  #-----------------------------------------------------------------------------
  def map_name(map_id = @map_id)
    begin ; return map_infos[map_id].name
    rescue ; return ""
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Parent ID
  #   Info      : Returns ID of parent map
  #   Author    : Kain Nobel
  #   Call Info : Map ID (Optional) returns specified Map ID's parent Map ID
  #-----------------------------------------------------------------------------
  def parent_id(map_id = @map_id)
    begin  ; return map_infos[map_id].parent_id
    rescue ; return 0
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Parent Name
  #   Info      : Sends name of the parent map in question to a string
  #   Author    : Kain Nobel
  #   Call Info : Map ID (Optional) returns specified Map ID's parent's name
  #-----------------------------------------------------------------------------
  def parent_name
    begin ; return map_name(parent_id)
    rescue ; return ""
    end
  end
  #-----------------------------------------------------------------------------
  # * Name      : Print List
  #   Info      : Prints an Event's Command List in a human readable format
  #   Author    : Kain Nobel
  #   Call Info : Event ID, the event whom's list shall be printed
  #-----------------------------------------------------------------------------
  def print_list(event_id)
    list = String.new
    unless $game_map.events[event_id].nil?
      for c in $game_map.events[event_id].list
        code = c.code.to_s
        code.gsub!("101", "Show Text")
        code.gsub!("102", "Show Choices")
        code.gsub!("401", "" * c.indent)
        code.gsub!("402", "When [**]")
        code.gsub!("403", "When Cancel")
        code.gsub!("103", "Input Number")
        code.gsub!("104", "Change Text Options")
        code.gsub!("105", "Button Input Processing")
        code.gsub!("106", "Wait")
        code.gsub!("111", "Conditional Branch")
        code.gsub!("411", "Else")
        code.gsub!("412", "Branch End")
        code.gsub!("112", "Loop")
        code.gsub!("413", "Repeat Above")
        code.gsub!("113", "Break Loop")
        code.gsub!("115", "Exit Event Processing")
        code.gsub!("116", "Erase Event")
        code.gsub!("117", "Call Common Event")
        code.gsub!("118", "Label")
        code.gsub!("119", "Jump to Label")
        code.gsub!("121", "Control Switches")
        code.gsub!("122", "Control Variables")
        code.gsub!("123", "Control Self Switch")
        code.gsub!("124", "Control Timer")
        code.gsub!("125", "Change Gold")
        code.gsub!("126", "Change Items")
        code.gsub!("127", "Change Weapons")
        code.gsub!("128", "Change Armor")
        code.gsub!("129", "Change Party Member")
        code.gsub!("131", "Change Windowskin")
        code.gsub!("132", "Change Battle BGM")
        code.gsub!("133", "Change Battle End ME")
        code.gsub!("134", "Change Save Access")
        code.gsub!("135", "Change Menu Access")
        code.gsub!("136", "Change Encounter")
        code.gsub!("201", "Transfer Player")
        code.gsub!("202", "Set Event Location")
        code.gsub!("203", "Scroll Map")
        code.gsub!("204", "Change Map Settings")
        code.gsub!("205", "Change Fog Color Tone")
        code.gsub!("206", "Change Fog Opacity")
        code.gsub!("207", "Show Animation")
        code.gsub!("208", "Change Transparent Flag")
        code.gsub!("209", "Set Move Route")
        code.gsub!("210", "Wait for Move's Completion")
        code.gsub!("221", "Prepare for Transition")
        code.gsub!("222", "Execute Transition")
        code.gsub!("223", "Change Screen Color Tone")
        code.gsub!("224", "Screen Flash")
        code.gsub!("225", "Screen Shake")
        code.gsub!("231", "Show Picture")
        code.gsub!("232", "Move Picture")
        code.gsub!("233", "Rotate Picture")
        code.gsub!("234", "Change Picture Color Tone")
        code.gsub!("235", "Erase Picture")
        code.gsub!("236", "Set Weather Effects")
        code.gsub!("241", "Play BGM")
        code.gsub!("242", "Fade Out BGM")
        code.gsub!("245", "Play BGS")
        code.gsub!("246", "Fade Out BGS")
        code.gsub!("247", "Memorize BGM/BGS")
        code.gsub!("248", "Restore BGM/BGS")
        code.gsub!("249", "Play ME")
        code.gsub!("250", "Play SE")
        code.gsub!("251", "Stop SE")
        code.gsub!("301", "Battle Processing")
        code.gsub!("601", "If Win")
        code.gsub!("602", "If Escape")
        code.gsub!("603", "If Lose")
        code.gsub!("302", "Shop Processing")
        code.gsub!("303", "Name Input Processing")
        code.gsub!("311", "Change HP")
        code.gsub!("312", "Change SP")
        code.gsub!("313", "Change State")
        code.gsub!("314", "Recover All")
        code.gsub!("315", "Change EXP")
        code.gsub!("316", "Change Level")
        code.gsub!("317", "Change Parameters")
        code.gsub!("318", "Change Skills")
        code.gsub!("319", "Change Equipment")
        code.gsub!("320", "Change Actor Name")
        code.gsub!("321", "Change Actor Class")
        code.gsub!("322", "Change Actor Graphic")
        code.gsub!("331", "Change Enemy HP")
        code.gsub!("332", "Change Enemy SP")
        code.gsub!("333", "Change Enemy State")
        code.gsub!("334", "Enemy Recover All")
        code.gsub!("335", "Enemy Appearance")
        code.gsub!("336", "Enemy Transform")
        code.gsub!("337", "Show Battle Animation")
        code.gsub!("338", "Deal Damage")
        code.gsub!("339", "Force Action")
        code.gsub!("340", "Abort Battle")
        code.gsub!("351", "Call Menu Screen")
        code.gsub!("352", "Call Save Screen")
        code.gsub!("353", "Game Over")
        code.gsub!("354", "Return to Title Screen")
        code.gsub!("355", "Script")
        code.gsub!("0",   "")
        code = ("  " * c.indent) + "@>#{code}:#{c.parameters}\n"
        list += code
      end
    end
    print list
  end
end


#===============================================================================
# ** RGSS.RPG::Cache
#===============================================================================

class << RPG::Cache
  #-----------------------------------------------------------------------------
  # * Alias Listings
  #-----------------------------------------------------------------------------
  unless self.method_defined?(:knmacl_rpgcache_clear)
    alias_method :knmacl_rpgcache_clear, :clear
  end
  #-----------------------------------------------------------------------------
  # * Name      : Clear
  #   Info      : Clears keys similiar to the specified key
  #   Author    : Kain Nobel
  #   Call Info : Key (optional) is a string representing what kind of objects
  #                 to delete. For instance "Fog" remove any objects with keys
  #                 that include the word "Fog" in it. If no key is omitted,
  #                 the entire @cache is cleared.
  #-----------------------------------------------------------------------------
  def self.clear(key = nil)
    if key.nil?
      knmacl_rpgcache_clear
      return
    end
    @cache.each_key do |key|
      if key.is_a?(String) && key.include?(key)
        @cache.delete(key)
      end
    end
  end
end


#===============================================================================
# ** RGSS.RPG::Item
#===============================================================================

class RPG::Item
  #-----------------------------------------------------------------------------
  # * Name      : HP Neutral?
  #   Info      : Returns Recover HP and Recover HP Rate is 0
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def hp_neutral?
    return @recover_hp == 0 && @recover_hp_rate == 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : HP Recovery?
  #   Info      : Returns Recover HP and Recover HP Rate more than 0
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def hp_recovery?
    return @recover_hp > 0 && @recover_hp_rate > 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : HP Damage?
  #   Info      : Returns Recover HP and Recover HP Rate less than 0
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def hp_damage?
    return @recover_hp < 0 && @recover_hp_rate < 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : SP Neutral?
  #   Info      : Returns Recover SP and Recover SP Rate is 0
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def sp_neutral?
    return @recover_sp == 0 && @recover_sp_rate == 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : SP Recovery?
  #   Info      : Returns Recover SP and Recover SP Rate more than 0
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def sp_recovery?
    return @recover_sp > 0 && @recover_sp_rate > 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : SP Damage?
  #   Info      : Returns Recover SP and Recover SP Rate less than 0
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def sp_damage?
    return @recover_sp < 0 && @recover_sp_rate < 0
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Item?
  #   Info      : Returns true
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_item?
    return true
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Armor?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_armor?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Weapon?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_weapon?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Skill?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_skill?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Party Quant
  #   Info      : Returns how many of self is in $game_party.items
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def party_quant
    return 0 if $game_party.nil?
    unless $game_party.items.has_key?(@id)
      return 0
    end
    return $game_party.items[@id]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns if @element_set includes element
  #   Author    : Kain Nobel
  #   Call Info : Element is Integer representing Element Tag ID in question
  #-----------------------------------------------------------------------------
  def has_element?(id = 0)
    return true if id == 0
    return @element_set.include?(id)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns an array of elements from 'has_element?'
  #   Author    : Kain Nobel
  #   Call Info : Elements is an Array - See 'has_element?'
  #-----------------------------------------------------------------------------
  def has_elements?(elements = [])
    list = Array.new
    elements.each {|e| list << e if self.has_element?(e)}
    return list
  end
end


#===============================================================================
# ** RGSS.RPG::Armor
#===============================================================================

class RPG::Armor
  #-----------------------------------------------------------------------------
  # * Name      : Is Item?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_item?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Armor?
  #   Info      : Returns true
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_armor?
    return true
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Weapon?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_weapon?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Skill?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_skill?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Party Quant
  #   Info      : Returns how many of self is in $game_party.armors
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def party_quant
    return 0 if $game_party.nil?
    unless $game_party.armors.has_key?(@id)
      return 0
    end
    return $game_party.armors[@id]
  end
  #-----------------------------------------------------------------------------
  # * Has Element? (ID)
  #-----------------------------------------------------------------------------
  def has_element?(id = 0)
    return true if id == 0
    return @guard_element_set.include?(id)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns if @guard_element_set includes element
  #   Author    : Kain Nobel
  #   Call Info : Element is Integer representing Element Tag ID in question
  #-----------------------------------------------------------------------------
  def has_element?(id = 0)
    return true if id == 0
    return @guard_element_set.include?(id)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns an array of elements from 'has_element?'
  #   Author    : Kain Nobel
  #   Call Info : Elements is an Array - See 'has_element?'
  #-----------------------------------------------------------------------------
  def has_elements?(elements = [])
    list = Array.new
    elements.each {|e| list << e if self.has_element?(e)}
    return list
  end
end


#===============================================================================
# ** RGSS.RPG::Weapon
#===============================================================================

class RPG::Weapon
  #-----------------------------------------------------------------------------
  # * Name      : Is Item?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_item?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Armor?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_armor?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Weapon?
  #   Info      : Returns true
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_weapon?
    return true
  end
  #-----------------------------------------------------------------------------
  # * Name      : Is Skill?
  #   Info      : Returns false
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def is_skill?
    return false
  end
  #-----------------------------------------------------------------------------
  # * Name      : Party Quant
  #   Info      : Returns how many of self is in $game_party.weapons
  #   Author    : Kain Nobel
  #   Call Info : None
  #-----------------------------------------------------------------------------
  def party_quant
    return 0 if $game_party.nil?
    unless $game_party.weapons.has_key?(@id)
      return 0
    end
    return $game_party.weapons[@id]
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns if @element_set includes element
  #   Author    : Kain Nobel
  #   Call Info : Element is Integer representing Element Tag ID in question
  #-----------------------------------------------------------------------------
  def has_element?(id = 0)
    return true if id == 0
    return @element_set.include?(id)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns an array of elements from 'has_element?'
  #   Author    : Kain Nobel
  #   Call Info : Elements is an Array - See 'has_element?'
  #-----------------------------------------------------------------------------
  def has_elements?(elements = [])
    list = Array.new
    elements.each {|e| list << e if self.has_element?(e)}
    return list
  end
end


#===============================================================================
# ** RGSS.RPG::Skill
#===============================================================================

class RPG::Skill
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns if @element_set includes element
  #   Author    : Kain Nobel
  #   Call Info : Element is Integer representing Element Tag ID in question
  #-----------------------------------------------------------------------------
  def has_element?(id = 0)
    return true if id == 0
    return @element_set.include?(id)
  end
  #-----------------------------------------------------------------------------
  # * Name      : Has Element?
  #   Info      : Returns an array of elements from 'has_element?'
  #   Author    : Kain Nobel
  #   Call Info : Elements is an Array - See 'has_element?'
  #-----------------------------------------------------------------------------
  def has_elements?(elements = [])
    list = Array.new
    elements.each {|e| list << e if self.has_element?(e)}
    return list
  end
end