Help making EquAP and Multi-equip compatible

[Ravenith]

Hello all. The past 2-3 weeks I've been trying to figure out how to make Guillaume777's Multi-slot equipment script compatible with Blizzard's EquAP script. Unfortunately, a sewer rat knows much more about scripting than I do. Let me explain:

Guillaume's Multi slot equipment script allows multiple weapon and armor slots (among many other features).

Blizzard's script allows actors to learn a skill when they equip an item and forget it once the item is removed, or learn the skill by gaining AP (just like in ff9)

To make these two work together, I think I must find the modified equipment slot IDs from Guillaume's script and put them in Blizzard's script in the appropriate Game_Actor section. I might be wrong, though.

Here they go:

#==============================================================================
# Multi-slot equipment script
#------------------------------------------------------------------------------
# Section 1:  Modules
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.1
# 2006/02/14
#==============================================================================

# To change slots of character
#     $game_actors[1].weapon_slots = [0,0] 
#     $game_actors[1].armor_slots = [2,3,4,5,6,7]
#
# To make armor equipable in new slot :
#     Add (5) in its name, where 5 is its slot number
# To make 2handed weapons :
#     Add an element called 2handed to a weapon 
#     or, adds its id in TWO_HANDED_WEAPONS = []
#     or, adds (2handed) in its name
# To make a weapon double attack
#     Add an element called 2attacks to a weapon
#     or, adds its id in DOUBLE_ATTACK_WEAPONS = []
#     or, adds (2atks) in its name
# To make a weapon/armor cursed
#     Adds its id in CURSED_WEAPONS or CURSED_ARMORS, or
#     put (cursed) in its name
# To make a weapon require an offhand instead of any weapon
#     Adds its id in NEEDS_OFFHAND or
#     Adds (needs_offhand) in its name

#==============================================================================
# *** MODULE:  Guillaume777's Multi-Slot Module
#------------------------------------------------------------------------------
#  This is the configuration module of the Multi-Slot system.  It allows you to
#  set the default names of your slots, tag your weapons and/or armors for many
#  types of enhancements and features, and etc.
#==============================================================================
module G7_MS_MOD
  
  #--------------------------------------------------------------------------
  # * Configuration Section
  #--------------------------------------------------------------------------
  #========Set weapon/armor properties ======================================
  CURSED_WEAPONS        = []        # ids of weapons to be cursed 
  CURSED_ARMORS         = []        # ids of armors to be cursed
  TWO_HANDED_WEAPONS    = []           # ids of 2handed weapons
  DOUBLE_ATTACK_WEAPONS = []            # ids of double attack weapons
  NEEDS_OFFHAND = []                   # ids of weapons requiring an offhand
  
  SWITCH_EQUIP_WEAPONS = [[]]       # ids of weapons switched when equipped
  SWITCH_EQUIP_ARMORS = [[], []]  # ids of switched armors(same above)
  # Use 1 array, first value of array = false item, second value = true item 
  #
  # First value in the above arrays is displayed in the weapons/armors you can
  # choose.  When the weapon/armor is chosen, the second id value IS the weapon
  # or armor that you've chosen.  Example:  Trick someone to equip a cursed bow.
  
  #=========Set weapon/armor properties with element tagging and name edit===
  CURSED_STRING = 'cursed'  # put (cursed) in item name for it to be cursed
  HANDS_ELEMENT = 'handed'  # no. of hands in front of HANDS_ELEMENT in database
  HANDS_STRING  = 'handed'  # name of string in item name like (2handed)

  MULTI_ATTACK_ELEMENT = 'attacks' # name of element to tag to multi attacks
                                   # like (2attacks)
  MULTI_ATTACK_STRING = 'atks'     # string in item name, like (3atks)

  NEEDS_OFFHAND_STRING = 'needs_offhand' #string in item name if the weapon
                                         #needs an offhand like (needs_offhand)
                                         
  #=====Set character slots properties =======================================
  WEAPON_KINDS = [0,0]                      # number of weapons,  0 = weapon
  WEAPON_KIND_NAMES = ['R-Hand', 'L-Hand']  # custom name of extra weapon slots 
  WEAPON_KIND_POWERS = [100, 100]           # 100 = normal power, 90 = 90% power
                                            # Leave empty or put nil inside
                                            # if you want the default names.
  ARMOR_KINDS = [1,2,3,4,5,6,7]
  # 1 = shield
  # 2 = helmet
  # 3 = armor
  # 4 = acc
  # 5 = and more : extra slot
  EXTRA_SLOT_NAMES = ['Gauntlet','Boots','Amulet'] 
  # Name of the extra slots in equip window
  # You need as many words as there are '5' or more in armor_kinds
  # The first order of the slots names reflect the order of the 5 in armor_kinds
  # Put (5) or more to in the armor name to have it assigned to the extra slot 

  #=============Set multi-weapon behavior====================================
  IGNORE_OFFHAND          = false # ignore off_hand support 
  TWOHANDED_IN_OFFHAND    = true  # If false don't show two handed weapons in
                                  # the offhand window
  ALL_WEAPONS_FOR_SKILLS  = true  # true  = combined pwr of all weaps for skills 
                                  # false = only power of first weapon
  SHIELD_HAND_SLOT        = 1     # slot number to be used for shield hand
  WEAPON_SHIELD_SHARE     = true  # if true, can't use a shield and a second
                                  # weapon at the same time
  SHIELD_HAND_WIELD       = true  # true = can use shield hand for 2handed weap.
  WEAPON_HAND_WIELD       = true  # true = can use weapon hand for 2handed weap.
  MULTI_WEAPONS_PENALITY  = 0     # percent of atk that will be subtracted if 
                                  # you use two weapons at the same time.
                                  
  #============Set appearance properties ====================================
  FONT_NAME       = 'Monotype Corsiva'      # Font to use
  CURSED_COLOR    = Color.new(255, 50, 50)  # Color of cursed equiped items
  SHOW_REMOVE     = false                   # Show empty in offhand window
 
  WINDOWS_STRETCH = true    # true : equip_right stretch to adjust to # of slots
  MAX_SHOW_SLOTS  = 6       # Maximum number of slots in 1 screen in equip right
                            # window.  Useless if windows_stretch = false
  HELP_AT_BOTTOM  = false   # If true,  will leave place for help window at bot-
                            # tom.  Useless if you didn't modify the help window
                            # y-coordinate.

  STATUS_WINDOW_ARRANGE = true  # If true, you get a new status window.
  EVADE                 = false # If draw_actor_parameter is configured to 
                                # receive parameter number 7 (evade), then it
                                # will show in new status window.
  # EVADE = true has no effect if STATUS_WINDOW_ARRANGE is false
  
  #================ end of settings =========================================

  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super
    RPG.set_new_item_types #fix armor and weapon properties at start of game
  end 
  #--------------------------------------------------------------------------
  # * End of MODULE:  Guillaume777's Multi-Slot Module
  #--------------------------------------------------------------------------
end



#============================================================================
# ** MODULE:  RPG Module
#----------------------------------------------------------------------------
#  This sprite is used as an arrow cursor for the battle screen. This class
#  is used as a superclass for the Arrow_Enemy and Arrow_Actor classes.
#============================================================================
module RPG
  #--------------------------------------------------------------------------
  # * Set New Item Types
  #--------------------------------------------------------------------------
  def RPG.set_new_item_types
    if @initialized_item_types then return end
    for armor in $data_armors     # for each armor
      unless armor == nil         # if armor
        armor.set_adv_type        # set new type
        armor.set_cursed          # set if item is cursed or not
      end
    end
    for weapon in $data_weapons   # for each armor
      unless weapon == nil        # if armor
        weapon.set_needs_offhand  # set if it needs an offhand or not
        weapon.set_nb_hands       # set the number of hands to wield it
        weapon.set_nb_attacks     # set the number of attacks it can do
        weapon.set_cursed         # set if item is cursed or not
      end
    end
    @initialized_item_types = true
  end
  #--------------------------------------------------------------------------
  # * Initialized Item Types
  #     bool      : boolean value (true/false)
  #--------------------------------------------------------------------------
  def RPG.initialized_item_types=(bool)
    @initialized_item_types = bool
  end

  #==========================================================================
  # ** Armor
  #--------------------------------------------------------------------------
  # Data class for armors, adds new armor types
  #==========================================================================
  class Armor
    attr_accessor :cursed
    #------------------------------------------------------------------------
    # * Set Adv Type
    #------------------------------------------------------------------------
    def set_adv_type
      pattern =  /\((\d+)\)/
      if @name.sub!(pattern, '') != nil 
        # Set kind to the number in name of armor
        @kind = $1.to_i - 1
      end
    end
    #------------------------------------------------------------------------
    # * Set Cursed
    #------------------------------------------------------------------------
    def set_cursed
      pattern = '('+G7_MS_MOD::CURSED_STRING+')'     
      if @name.sub!(pattern, '') != nil then cursed = true end
      if G7_MS_MOD::CURSED_ARMORS.include?(@id) then cursed = true end
      @cursed = cursed
    end
    #------------------------------------------------------------------------
    # * End of Armor Class
    #------------------------------------------------------------------------
  end 
  
  #==========================================================================
  # ** Weapon
  #--------------------------------------------------------------------------
  # Data class for weapons, adds new weapon types
  #==========================================================================
  class Weapon
    #------------------------------------------------------------------------
    # * Public Instance Variables
    #------------------------------------------------------------------------
    attr_accessor :needs_offhand  # does it need an offhand weapon
    attr_accessor :nb_hands       # numbers of hands it requires
    attr_accessor :nb_attacks     # number of attacks it can do
    attr_accessor :cursed         # true if item is cursed
    #------------------------------------------------------------------------
    # * Set Cursed
    #------------------------------------------------------------------------
    def set_cursed
      pattern = '('+G7_MS_MOD::CURSED_STRING+')'
      if @name.sub!(pattern, '') != nil then cursed = true end
      if G7_MS_MOD::CURSED_WEAPONS.include?(@id) then cursed = true end
      @cursed = cursed
    end 
    #------------------------------------------------------------------------
    # * Set Needs OffHand
    #------------------------------------------------------------------------
    def set_needs_offhand
      pattern = '('+G7_MS_MOD::NEEDS_OFFHAND_STRING+')'
      if @name.sub!(pattern, '') != nil then
        @needs_offhand = true
      elsif G7_MS_MOD::NEEDS_OFFHAND.include?(self.id) then
        @needs_offhand = true
      elsif @needs_offhand== nil then
        @needs_offhand = false
      end
    end
    #------------------------------------------------------------------------
    # Returns number of hands needed for weapons 
    #------------------------------------------------------------------------
    def set_nb_hands 
      if G7_MS_MOD::TWO_HANDED_WEAPONS.include?(self.id) then
        nb_hands = 2
      end
      pattern = /\((\d+)#{G7_MS_MOD::HANDS_STRING}\)/
      if @name.sub!(pattern, '') != nil 
        nb_hands = $1.downcase.delete('a-z')
        nb_hands = $1.to_i
      end
      # Search through the elements
      for elementnb in self.element_set
        elementname = $data_system.elements[elementnb].downcase
        # If the weapon has an element for another attack
        if elementname.delete('0-9') == G7_MS_MOD::HANDS_ELEMENT.downcase 
          # Get the number of attacks
          elementname = elementname.delete('a-z')
          if elementname != '' then
            nb_hands = elementname.to_i
          end
        end
      end
      if nb_hands.is_a?(Integer) == false or nb_hands <= 0 then nb_hands = 1 end
      @nb_hands = nb_hands
    end
    #------------------------------------------------------------------------
    # Returns the number of attack the weapon can do
    #------------------------------------------------------------------------
    def set_nb_attacks
      if G7_MS_MOD::DOUBLE_ATTACK_WEAPONS.include?(self.id) then
        nb_attacks = 2
      else
        nb_attacks = 1
      end
      pattern = /\((\d+)#{G7_MS_MOD::MULTI_ATTACK_STRING}\)/
      if @name.sub!(pattern, '') != nil
        nb_attacks = $1.downcase.delete('a-z')
        nb_attacks = $1.to_i
      end
      # Search elements that could add more attacks  
      for elementnb in self.element_set
        #add more attacks
        elementname = $data_system.elements[elementnb].downcase
        # If the weapon has an element for another attack
        if elementname.delete('0-9') == G7_MS_MOD::MULTI_ATTACK_ELEMENT.downcase
          # Get the number of attacks
          elementname = elementname.delete('a-z')
          if elementname != '' then
            nb_attacks = elementname.to_i
            # Delete the element
            self.element_set.delete(elementnb)
          end
        end
      end 
      if nb_attacks.is_a?(Integer) == false or nb_attacks <= 0
        then nb_attacks = 1
      end
      @nb_attacks = nb_attacks
    end
    #------------------------------------------------------------------------
    # * End of CLASS:  Weapon
    #------------------------------------------------------------------------
  end
  #--------------------------------------------------------------------------
  # * End of MODULE:  RPG Module
  #--------------------------------------------------------------------------
end

#==============================================================================
# Multi-slot equipment script
#------------------------------------------------------------------------------
# Section 2:  Actor
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.1
# 2006/02/14
#==============================================================================

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
  include G7_MS_MOD
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :equip_mode         # To restore equipment after false equip
  attr_accessor :equip_type_force   # To bypass equip_type
  attr_accessor :equip_from_menu    # To prevent users to unequip cursed items
  attr_accessor :translucent_texts  # To store translucents slots
  #--------------------------------------------------------------------------
  # * Setup (Initializing new Slots)
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_setup setup
  def setup(actor_id) 
    g7_ms_game_actor_setup(actor_id) #setup normaly
    self.order_armor_ids
  end
  #--------------------------------------------------------------------------
  # * Number of Offhand Required
  #     ignore   : ignore  
  #--------------------------------------------------------------------------
  def nb_offhand_required(ignore=nil)
    nb_offhand = 0
    nb_need_offhand = 0
    for i in 0...self.weapon_slots.size
      if i != ignore then
        weapon = self.weapon_ids[i]
        if weapon == 0 then
          nb_offhand += 1
        elsif $data_weapons[weapon].needs_offhand then
          nb_need_offhand += 1
        else
          nb_offhand += 1
        end
      end
    end
    return (nb_need_offhand - nb_offhand)
  end
  #--------------------------------------------------------------------------
  # * Change Equipment ( Modified for extra equipment)
  #     equip_type : type of equipment
  #     id    : weapon or armor ID (If 0, remove equipment)
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_equip equip
  def equip(equip_type, id)
    if @equip_type_force != nil then equip_type = @equip_type_force end
    # equip_type_force is used to bypass the equip_type argument
    if self.equip_mode == 'STORE' then
      # Store equipment to be restored after checking what the stats would
      self.equip_mode = nil
      @stored_armors = self.armor_ids.dup
      @stored_weapons = self.weapon_ids.dup
      saved_mode = 'STORE'
    elsif self.equip_mode == 'RESTORE'
      # Restore equipment after preview of new equipment on stats
      self.equip_mode = nil
      self.restore(equip_type)
      return
    # If equipping for real  
    else
      if self.enough_hands?(equip_type,id) != false then
        id = self.switch_items(equip_type,id) # Switch item to be equiped to 
                                              # fool players
      end
    end
    if self.enough_hands?(equip_type,id) == false then # If not enough hands
      id = 0                                           # then don't equip
    elsif self.equip_from_menu and self.cursed?(equip_type) then
      id = 0              # If cursed and player tried to remove it, do nothing
    elsif equip_type <= 4 # If the slot is one of the 5 basic one
      g7_ms_game_actor_equip(equip_type, id) #equip the good old way
    else 
      equip_extra(equip_type,id) #equip in the new way 
    end 
    # Fix in case there are no enough empty hands for all the equipped weapons
    if id != 0 then self.fix_handed_weapons(equip_type) end
    # This ensures that the next equiping will restore the original equipment
    if saved_mode == 'STORE' then  self.equip_mode = 'RESTORE'  end 
  end
  #--------------------------------------------------------------------------
  # * Restore Equipment once the stats are checked and adds translucent
  #     equip_type : type of equipment
  #--------------------------------------------------------------------------
  def restore(equip_type)
    if self.translucent_texts == nil then self.translucent_texts = Array.new end
    self.equip_from_menu = false
    if equip_type != 0 and @stored_weapons[0] != self.weapon_ids[0]
      self.translucent_texts[0] = true
    end
    for i in 1...@stored_weapons.size 
      if i+[self.armor_slots.size,4].max != equip_type and 
        @stored_weapons[i] != self.weapon_ids[i] then
        self.translucent_texts[i] = true
      end
    end
    for i in 0...@stored_armors.size 
      if i+1 != equip_type and 
        @stored_armors[i] != self.armor_ids[i] then
        self.translucent_texts[self.weapon_slots.size + i] = true
      end
    end
    @equip_type_force = nil 
    copy = self.translucent_texts.dup
    self.weapon_ids = @stored_weapons
    self.armor_ids = @stored_armors
    self.translucent_texts = copy
  end
  #--------------------------------------------------------------------------
  # * Switch Items.  Switches equipment to fool a player.
  #     equip_type : type of equipment
  #     id         : id
  #--------------------------------------------------------------------------
  def switch_items(equip_type,id)
    if self.cursed?(equip_type) == false then 
      if equip_type == 0 or equip_type > [self.armor_slots.size,4].max
        for i in 0...SWITCH_EQUIP_WEAPONS.size
          if SWITCH_EQUIP_WEAPONS[i][0] == id then
            $game_party.lose_weapon(SWITCH_EQUIP_WEAPONS[i][0], 1)
            $game_party.gain_weapon(SWITCH_EQUIP_WEAPONS[i][1], 1)
            id = SWITCH_EQUIP_WEAPONS[i][1]
          end
        end
      else 
        for i in 0...SWITCH_EQUIP_ARMORS.size
          if SWITCH_EQUIP_ARMORS[i][0] == id then
            $game_party.lose_armor(SWITCH_EQUIP_ARMORS[i][0], 1)
            $game_party.gain_armor(SWITCH_EQUIP_ARMORS[i][1], 1)
            id = SWITCH_EQUIP_ARMORS[i][1]
          end
        end
      end
    end 
  return id
  end
  #--------------------------------------------------------------------------
  # * Enough Hands?  Returns if there are enough hands to hold a weapon
  #     equip_type : type of equipment
  #     id         : ID
  #--------------------------------------------------------------------------
  def enough_hands?(equip_type, id)
    # Enough Hand = true if you unequip something
    if id == 0 then return true end 
    # If it's a weapon
    if equip_type == 0 or equip_type > [self.armor_slots.size ,4].max
      nb = $data_weapons[id].nb_hands
    elsif self.weapon_shield_share and 
      self.armor_slots[equip_type-1] == self.shield_hand_slot
      nb = 1
    else
      return true # Return true if not shield or weapon
    end
    nb_s = 0 # Number of shield slots
    if self.shield_hand_wield then
      for i in 0...self.armor_slots.size
        if self.armor_slots[i] == self.shield_hand_slot
          if self.weapon_shield_share == false then nb_s += 1  end
          if  self.cursed?(i+1) then nb += 1 end
        end
      end
    end
    if self.weapon_hand_wield 
      if self.cursed?(0) then # Penalties if can't remove first weapon
        nb = nb +  $data_weapons[self.weapon_ids[0]].nb_hands
      end
      for i in 1...self.weapon_slots.size # Penalties if can't remove weapon
        if self.cursed?(self.armor_slots.size + i)
          nb = nb +  $data_weapons[self.weapon_ids[i]].nb_hands
        end
      end
    end
    if nb == 1 then # If it only takes 1 hand to hold
      return true
    elsif nb > nb_s+1 and self.weapon_hand_wield != true 
      return false
    elsif nb > self.weapon_slots.size+ nb_s and self.weapon_hand_wield
      return false
    elsif self.shield_hand_wield != true and self.weapon_hand_wield != true
      return false
    else
      return true
    end
  end
  #--------------------------------------------------------------------------
  # * Equip Weapon
  #     index : Index of weapon
  #     id    : weapon ID (If 0, remove equipment)
  #--------------------------------------------------------------------------
  def equip_weapon(index,id)
    if index == 0 then
      self.equip(0, id)
    else
      self.equip([self.armor_slots.size, 4].max + index, id)
    end
  end
  #--------------------------------------------------------------------------
  # * Equip Armor
  #     index : Index of armor
  #     id    : armor ID (If 0, remove equipment)
  #--------------------------------------------------------------------------
  def equip_armor(index, id)
    self.equip(index+1, armor)
  end
  #--------------------------------------------------------------------------
  # * Equip Extra Items
  #     equip_type : Index of item being equipped
  #     id         : ID if either armor or weapon (If 0, remove equipment)
  #--------------------------------------------------------------------------
  def equip_extra(equip_type,id)
    if equip_type <= [self.armor_slots.size,4].max # if its extra armor slot 
      if id == 0 or $game_party.armor_number(id) > 0
        update_auto_state($data_armors[self.armor_ids[equip_type-1]], $data_armors[id])
        $game_party.gain_armor(self.armor_ids[equip_type-1], 1)
        self.armor_ids[equip_type-1] = id
        $game_party.lose_armor(id, 1)
      end
    # If it's a weapon slot  
    else
      if id == 0 or $game_party.weapon_number(id) > 0
        equip_type = equip_type - [self.armor_slots.size, 4].max
        weapon = self.weapon_ids[equip_type]
        if weapon != nil then 
          $game_party.gain_weapon(weapon, 1) 
        end
        self.weapon_ids[equip_type] = id
        $game_party.lose_weapon(id, 1)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Fix Multi-Handed Weapons
  #     equip_keep : ID of weapon to keep
  #--------------------------------------------------------------------------
  def fix_handed_weapons(equip_keep=nil)
    array_wield_hands = Array.new         # Stores the slot of the weapon that
                                          # needs empty hands
    nb_emp_hands = 0                      # Store nb of empty hands
    penalities = 0                        # Stores extra hand required
    save_force = @equip_type_force
    save_menu = @equip_from_menu
    @equip_from_menu = false
    @equip_type_force = nil
    if self.shield_hand_wield 
      for narmor in 0...self.armor_slots.size
        if self.armor_slots[narmor] == self.shield_hand_slot 
          if self.weapon_shield_share == true then
            penalities += 1
          end
          if self.armor_ids[narmor] == 0 then
            nb_emp_hands += 1             # Stores empty shield hand
          end
        end
      end
    end
    for nweapon in 0...self.weapon_slots.size
      if self.weapon_ids[nweapon] == 0 
        if self.weapon_hand_wield then
          nb_emp_hands += 1
        end
      else
        array_wield_hands.push(nweapon)   # Stores the hand to wield weapon
      end
    end
    for nweapon in Rg(array_wield_hands.size-1, 0, -1)
      if self.weapon_ids[array_wield_hands[nweapon]] != 0 then
        nb_hands = $data_weapons[self.weapon_ids[array_wield_hands[nweapon]]].nb_hands
        nb_hands += penalities
        penalities = 0
        save_hands = nb_hands
      end
      # If it finds an empty hand
      while nb_emp_hands != 0 and nb_hands > 1
        # Decrease the counter
        nb_hands += -1
        nb_emp_hands += -1
      end
      # if shield needs to be removed for empty hand
      if self.shield_hand_wield then
        for namor in 0...self.armor_slots.size 
          if nb_hands > 1 and self.armor_ids[namor] != 0 and
            self.armor_slots[namor] == self.shield_hand_slot and 
            namor+1 != equip_keep and self.cursed?(namor+1) == false then
            nb_hands += -1
            self.equip(namor+1,0)
          end
        end
      end
      # if it must remove weapons to make room for empty hands
      if self.weapon_hand_wield == true then 
        for nhand in Rg(self.weapon_slots.size-1, 0, -1)
          if nb_hands > 1 and self.weapon_ids[nhand] != 0 
            if nhand == 0 then
              if equip_keep != 0 and self.cursed?(0) == false then
                n = nb_emp_hands
                nb_emp_hands += $data_weapons[self.weapon_ids[nhand]].nb_hands
                n = nb_emp_hands - n
                self.equip(0,0)
              end
              else
                if nhand+[self.armor_slots.size,4].max != equip_keep and
                  self.cursed?(nhand+[self.armor_slots.size,4].max) == false 
                  then
                  if nhand < array_wield_hands[nweapon] then
                    nb_emp_hands += 1
                  else
                    nb_emp_hands += $data_weapons[self.weapon_ids[nhand]].nb_hands
                  end
                  self.equip([self.armor_slots.size,4].max+nhand, 0) 
                end
              end   # End of ( if nhnad == 0 )
            end     # End of ( if nb_hands != 1 )
            # If it finds an empty hand
            while nb_emp_hands != 0 and nb_hands > 1 
              # Decrease the counter
              nb_hands += -1
              nb_emp_hands += -1
            end 
          end   # End of ( for nahand )
        end     # End of ( if self.weapon )
      # If still can't find a slot, remove the weapon
      if nb_hands > 1
        if array_wield_hands[nweapon] == 0 and self.cursed?(0) == false then
          nb_emp_hands = 1 + nb_emp_hands + save_hands - nb_hands 
          self.equip(0, 0)
        elsif self.cursed?(array_wield_hands[nweapon]+[self.armor_slots.size,4].max) == false and
          array_wield_hands[nweapon] != 0 then
          nb_emp_hands = 1 + nb_emp_hands + save_hands - nb_hands 
          self.equip(array_wield_hands[nweapon]+[self.armor_slots.size,4].max,0)
        end 
      end
      # If it finds an empty hand
      while nb_emp_hands != 0 and nb_hands > 1 
        # Decrease the counter
        nb_hands += -1
        nb_emp_hands += -1
      end
      # If STILL not enough hands
      if nb_hands > 1 then 
        # Remove the item the user tried to equip
        self.equip(equip_keep,0)
      end
    end
    @equip_type_force = save_force  # Returns old equip_type_force
    @equip_from_menu = save_menu    # Return old equip_from_menu
  end
  #--------------------------------------------------------------------------
  # * Cursed Items
  #     equip_type : ID if either armor or weapon
  #--------------------------------------------------------------------------
  def cursed?(equip_type)
    if equip_type == 0 
      weapon_id = self.weapon_ids[0]
      if weapon_id != 0 and $data_weapons[weapon_id].cursed then return true end
    # If Armor    
    elsif equip_type <= self.armor_slots.size 
      armor_id = self.armor_ids[equip_type - 1]
      if armor_id != 0 and $data_armors[armor_id].cursed then return true end
    else
      weapon_id = self.weapon_ids[equip_type - [self.armor_slots.size, 4].max]
      if weapon_id != nil and weapon_id != 0 and $data_weapons[weapon_id].cursed
        return true
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * Remove all cursed items
  #--------------------------------------------------------------------------
  def remove_curse
    self.equip_type_force = nil
    for i in 0...(self.weapon_slots.size + self.armor_slots.size)
      if self.cursed?(i) then self.equip(i,0) end
    end
  end
  #--------------------------------------------------------------------------
  # * Order Armor IDs for Slots
  #-------------------------------------------------------------------------- 
  def order_armor_ids
    equipment_array = Array.new 
    for i in 0...self.armor_ids.size 
      if self.armor_ids[i] != nil and self.armor_ids[i] != 0
        kind = $data_armors[self.armor_ids[i]].kind
        if equipment_array[kind] == nil then 
          equipment_array[kind] = Array.new
        end
        equipment_array[kind].push(self.armor_ids[i]) 
        #array in which 0 = array for shield, 1 = array for helmet,
        #2 = array for armor and 3 = array for accessory, etc
      end 
    end
    self.armor_ids = nil # Remove all armors
    armors = Array.new
    for i in 0...self.armor_slots.size
      aitem = nil
      if equipment_array[(self.armor_slots[i])-1] == nil then 
        equipment_array[(self.armor_slots[i])-1] = Array.new
      end
      while aitem == nil and equipment_array[(self.armor_slots[i])-1].size != 0
        aitem = equipment_array[(self.armor_slots[i])-1].delete_at(0)
        if aitem == 0 then aitem = nil end
      end 
      if aitem != nil then 
        armors.push(aitem)  # Adds armor
      else
        armors.push(0)      # Adds empty 
      end   # End of ( if iaitem != nil )
    end     # End of ( for i in  )
    self.armor_ids = armors
  end
  #--------------------------------------------------------------------------  
  # * Change Weapon Slots
  #     array      : Array for weapon slots
  #--------------------------------------------------------------------------
  def weapon_slots=(array) 
    if array == nil then array = WEAPON_KINDS end   # Use default slots
    weapon_array = Array.new(self.weapon_ids)       # Save weapons
    self.weapon_ids = nil
    @weapon_slots = Array.new(array)                # New slots
    self.weapon_ids = weapon_array                  # Reequip items
    i = self.weapon_ids.size
    while self.nb_offhand_required > 1 
      if self.weapon_ids[i] != nil and self.weapon_ids[i] != 0 then
        self.equip_weapon(i,0)
      end
    i = i-1
    end
  end
  #--------------------------------------------------------------------------  
  # * Change Armor Slots
  #     array      : Array for armor slots
  #--------------------------------------------------------------------------
  def armor_slots=(array)
    # Returns to default if array is empty/nil
    if array == nil then array = ARMOR_KINDS end
    equipment_array = Array.new 
    for i in 0...[array.max, self.armor_slots.max].max+1
      if equipment_array[i] == nil then 
        equipment_array[i] = Array.new
      end 
    end
    for i in 0...self.armor_ids.size
      if self.armor_ids[i] != nil and self.armor_ids[i] != 0 then
        kind = $data_armors[self.armor_ids[i]].kind + 1
        equipment_array[kind].push(self.armor_ids[i]) 
        #array in which 0 = array for shield, 1 = array for helmet,
        #2 = array for armor and 3 = array for accessory, etc
      end
    end
    for kind in 0...[array.max, self.armor_slots.max].max+1
      if array.include?(kind) and self.armor_slots.include?(kind) then
        nb_i_new = 0
        nb_i_old = 0
        for i in 0...self.armor_slots.size
          if self.armor_slots[i] == kind then nb_i_old += 1 end
        end
        for i in 0...array.size
          if array[i] == kind then nb_i_new += 1 end
        end
        for i in nb_i_new...nb_i_old
          for k in 0...equipment_array[kind].size
            index = equipment_array[kind].index(0)
            if index != nil then
              equipment_array[kind].delete_at(index)
            end
          end
        end
      end
    end
    self.armor_ids = nil          # Remove items
    @armor_slots = array          # New array 
    for i in 0...self.armor_slots.size
      aitem = nil
      kind = self.armor_slots[i]
      if equipment_array[kind].size != 0
        aitem = equipment_array[kind].delete_at(0)
        self.equip(i+ 1,aitem)    # Adds armor
      else
        self.equip(i+ 1,0)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Set new array of weapons, if nil then it removes all weapon
  #     array      : Array of weapon IDs
  #--------------------------------------------------------------------------
  def weapon_ids=(array)  # Be careful @item_type_force needs to be nil !
    if array == nil then 
      self.equip(0, 0)    # Remove first weapon
      for i in 1...self.weapon_ids.size
        self.equip(i + [self.armor_slots.size,4].max, 0 ) # Remove all weapons
      end
      return
    end
    self.weapon_ids = nil
    for i in 0...self.weapon_slots.size 
      # Ensure no nil weapons are equipped
      if array[i] == nil then array[i] = 0 end
      if i == 0 then            # If the first weapon
        self.equip(0, array[i]) # Equip weapon
      else                      # else if extra weapons
        self.equip(i + [self.armor_slots.size, 4].max, array[i])
      end 
    end
  end
  #--------------------------------------------------------------------------
  # * Set new array of armors in ordered fashion
  #     array      : Array of armor IDs
  #--------------------------------------------------------------------------
  def armor_ids=(array) 
    if array == nil then 
      for i in 0...self.armor_slots.size
        self.equip(i + 1, 0)        # Remove all armors
      end
      return
    end
    self.armor_ids = nil            # Remove all armors
    for i in 0...self.armor_slots.size
      self.equip(i+ 1, array[i])    # Adds armor
    end
  end
  #--------------------------------------------------------------------------
  # * Return @armor_ids
  #--------------------------------------------------------------------------
  def armor_ids
    #returns ids with all armor, also store 4 armor
    unless self.is_a?(Game_Actor)
      return []
    end
    if @armor_ids == nil then @armor_ids = Array.new(self.armor_slots.size) end
    ids = @armor_ids
    ids[0] = @armor1_id
    ids[1] = @armor2_id
    ids[2] = @armor3_id
    ids[3] = @armor4_id
    for i in 0...self.armor_slots.size
      # Ensure no nil values are returned
      if ids[i] == nil then ids[i] = 0 end
    end
    return ids
  end
  #--------------------------------------------------------------------------
  # * Return @Weapon_ids
  #--------------------------------------------------------------------------
  def weapon_ids 
    #returns ids with all weapon, also store first weapon
    unless self.is_a?(Game_Actor)
      return []
    end
    if @weapon_ids == nil
      @weapon_ids = Array.new(self.weapon_slots.size)
    end
    ids = @weapon_ids
    ids[0] = @weapon_id
    for i in 0...self.weapon_slots.size
      if ids[i] == nil then ids[i] = 0 end
    end
    return ids
  end
  #--------------------------------------------------------------------------
  # * Returns names of armor
  #--------------------------------------------------------------------------
  def armor_slot_names # Return custom words for slots, or default ones
    if @armor_slot_names == nil then @armor_slot_names = Array.new end
    temp_array = Array.new(@armor_slot_names)
    # Default names of slots
    default_names = [$data_system.words.armor1,$data_system.words.armor2,$data_system.words.armor3,$data_system.words.armor4, self.extra_slot_names].flatten
    for i in 0...default_names.size
      if temp_array[i] == nil then temp_array[i] = default_names[i] end #if not
      # Custom then set as default
      if temp_array[i] == nil then temp_array[i] = $data_system.words.armor4 end
    end
    return temp_array
  end 
  #--------------------------------------------------------------------------
  # * Returns names of weapons
  #--------------------------------------------------------------------------
  def weapon_slot_names #return custom words for weapon slots, of default ones
    if @weapon_slot_names != nil then 
      temp_array = Array.new(@weapon_slot_names)      # Use the custom values
    else
      temp_array = Array.new(self.weapon_slots.size)  # Use default values
    end
    default_names = WEAPON_KIND_NAMES                 # Default names of slots
    for i in 0...self.weapon_slots.size
      # If... Set as Constant
      if temp_array[i] == nil then temp_array[i] = default_names[i] end 
      if temp_array[i] == nil then temp_array[i] = $data_system.words.weapon end 
      # If constant array is empty then use default one 
    end
    return temp_array
  end
  #--------------------------------------------------------------------------
  # * Return all element of all equipped armor
  #--------------------------------------------------------------------------
  def guard_element_set
    # Return array with guard_element_set of all equipped armor
    set = []
    for id in self.armor_ids #seach all armor equipped
      next if id.nil?
      armor = $data_armors[id]
      # Add the element to set
      set += (armor != nil ? armor.guard_element_set : []) 
    end
    return set 
  end
  #--------------------------------------------------------------------------
  # * Return all equipment
  #--------------------------------------------------------------------------
  def equipments
    # Return array with all equipment
    equipments = []
    self.weapon_ids.each {|id| equipments.push($data_weapons[id])}
    self.armor_ids.each {|id| equipments.push($data_armors[id])}
    return equipments
  end
  #--------------------------------------------------------------------------
  # * Return if item is equiped
  #--------------------------------------------------------------------------
  def equiped?(item)
    # Return if item is equipped, works with both armor and weapon
    case item
    when RPG::Weapon
      return self.weapon_ids.include?(item.id)
    when RPG::Armor
      return self.armor_ids.include?(item.id)
    else
      return false
    end 
  end
  #--------------------------------------------------------------------------  
  # * Return list of weapons to use for attacks
  #--------------------------------------------------------------------------
  def attacks #this return an array with the list of all attacks of a character
              #this takes in consideration extra weapon + number of attacks of
              #each weapon
    attacks = Array.new
    for i in 0...self.weapon_ids.size
      weapon = $data_weapons[self.weapon_ids[i]]
      # If the weapon is valid
      if weapon != nil and weapon.atk != 0 then
        for counter in 0...weapon.nb_attacks
          # Add attacks
          attacks.push(i)
        end
      end 
    end 
    # Give one unarmed attack if no weapons on
    if attacks.size == 0 then attacks[0] = 0 end
    return Array.new(attacks)
  end
  #--------------------------------------------------------------------------
  # * Get the weapon to be used in attack
  #--------------------------------------------------------------------------
  def get_weapon_data
    # This returns the weapon to use for the attack.
    weaponid = self.weapon_ids[self.attacks[self.attack_count]]
    weapon = $data_weapons[weaponid]
    return weapon
  end
  # Set the attacker's animation for the current weapon
  def animation1_id
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.animation1_id : 0
  end
  # Set the target's animation for the current weapon
  def animation2_id
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.animation2_id : 0
  end
  #--------------------------------------------------------------------------
  # * Get the atk to be used in attack ( or shown in menu screen )
  #--------------------------------------------------------------------------
  def base_atk
    multiplier = nil
    if $game_temp.in_battle and (self.current_action.kind == 0 or
      self.all_weapons_for_skills? != true)
      #if in battle and doing a normal attack only use one weapon's attack power
      weapon = self.get_weapon_data
      n = weapon != nil ? weapon.atk : 0
      #multiplier of hand as definied in self.weapon_slot_powers
      if weapon != nil and weapon.nb_hands == 1 then
        multiplier = self.weapon_slot_powers[self.attacks[self.attack_count]]
      end
      if multiplier == nil then multiplier = 100 end
      n = n * (multiplier/100.0)
    else # Use cumulative attack power of all weapons if in status screen or
         # if using skill and all_weapons_for_skills == true 
      n = 0
      for i in 0...self.weapon_slots.size
        weapon = $data_weapons[self.weapon_ids[i]]
        atk = weapon != nil ? weapon.atk : 0
        if weapon != nil and weapon.nb_hands == 1 then
          multiplier = self.weapon_slot_powers[i]
        else
          multiplier = nil
        end
        if multiplier == nil then multiplier = 100 end
        atk = atk * (multiplier/100.0)
        n += atk
      end
    end
    nb_weap = 0 
    for i in 0...self.weapon_slots.size
      if self.weapon_ids[i] != nil and self.weapon_ids[i] != 0
        nb_weap = nb_weap + 1
      end
    end #penality if more than 1 weapon
    penality = self.multi_weapons_penality != nil ? self.multi_weapons_penality : 0
    penality = penality /100.0
    if nb_weap > 1 then n = n * ( 1 - penality ) end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Normal Attack Element
  #--------------------------------------------------------------------------
  def element_set
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.element_set : []
  end
  #--------------------------------------------------------------------------
  # * Get Normal Attack State Change (+)
  #--------------------------------------------------------------------------
  def plus_state_set
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.plus_state_set : []
  end
  #--------------------------------------------------------------------------
  # * Get Normal Attack State Change (-)
  #--------------------------------------------------------------------------
  def minus_state_set
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.minus_state_set : []
  end
  #--------------------------------------------------------------------------
  # * Return state defense of all armor
  #-------------------------------------------------------------------------- 
  def state_guard?(state_id)
    # Begin Multi-slot equipment script Edit
    for i in self.armor_ids
      # End Multi-slot equipment script Edit
      armor = $data_armors[i]
      if armor != nil
        if armor.guard_state_set.include?(state_id)
          return true
        end
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * Methods calculate bonus of extra weapon and armor
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_element_rate element_rate
  def element_rate(element_id)
    result = g7_ms_game_actor_element_rate(element_id)
    if self.armor_slots.size > 4
      for i in 4...self.armor_slots.size
        armor = $data_armors[self.armor_ids[i]]
        if armor != nil and armor.guard_element_set.include?(element_id)
          result /= 2
        end
      end
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Get Basic Strength
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_str base_str
  def base_str
    n = g7_ms_game_actor_base_str
    for i in 1...self.weapon_slots.size
      weapon = $data_weapons[self.weapon_ids[i]]
      n += weapon != nil ? weapon.str_plus : 0 
    end
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.str_plus : 0
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Dexterity
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_dex base_dex
  def base_dex
    n = g7_ms_game_actor_base_dex
    for i in 1...self.weapon_slots.size
      weapon = $data_weapons[self.weapon_ids[i]]
      n += weapon != nil ? weapon.dex_plus : 0 
    end
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.dex_plus : 0 
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Agility
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_agi base_agi
  def base_agi
    n = g7_ms_game_actor_base_agi
    for i in 1...self.weapon_slots.size
      weapon = $data_weapons[self.weapon_ids[i]]
      n += weapon != nil ? weapon.agi_plus : 0 
    end
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.agi_plus : 0 
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Intelligence
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_int base_int
  def base_int
    n = g7_ms_game_actor_base_int
    for i in 1...self.weapon_slots.size
      weapon = $data_weapons[self.weapon_ids[i]]
      n += weapon != nil ? weapon.int_plus : 0 
    end
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.int_plus : 0 
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Physical Defense
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_pdef base_pdef
  def base_pdef
    n = g7_ms_game_actor_base_pdef
    for i in 1...self.weapon_slots.size
      weapon = $data_weapons[self.weapon_ids[i]]
      n += weapon != nil ? weapon.pdef : 0 
    end
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.pdef : 0 
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Magic Defense
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_mdef base_mdef
  def base_mdef
    n = g7_ms_game_actor_base_mdef
    for i in 1...self.weapon_slots.size
      weapon = $data_weapons[self.weapon_ids[i]]
      n += weapon != nil ? weapon.mdef : 0 
    end
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.mdef : 0
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Get Basic Evasion Correction
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_base_eva base_eva
  def base_eva
    n = g7_ms_game_actor_base_eva
    for i in 4...self.armor_slots.size
      armor = $data_armors[self.armor_ids[i]]
      n += armor != nil ? armor.eva : 0
    end
    return n
  end
  #--------------------------------------------------------------------------
  # * Reset all slot data to default one
  #--------------------------------------------------------------------------
  def reset_all_slots 
    self.armor_slots = nil
    self.weapon_slots = nil
    self.armor_slot_names = nil
    self.weapon_slot_names = nil
    self.extra_slot_names = nil
    self.weapon_slot_powers = nil
    self.shield_hand_wield = nil
    self.weapon_hand_wield = nil
    self.shield_hand_slot = nil
    self.weapon_shield_share = nil
    self.multi_weapons_penality = nil
    self.ignore_offhand = nil
    self.all_weapons_for_skills = nil
  end 
  #--------------------------------------------------------------------------
  # * Returns behavior of items on character
  #--------------------------------------------------------------------------
  def weapon_shield_share
    return @weapon_shield_share != nil ? @weapon_shield_share : WEAPON_SHIELD_SHARE
  end
  def weapon_slots 
    return @weapon_slots != nil ? @weapon_slots : WEAPON_KINDS
  end
  def armor_slots
    return @armor_slots != nil ? @armor_slots : ARMOR_KINDS
  end
  def shield_hand_wield
    return @shield_hand_wield != nil ? @shield_hand_wield : SHIELD_HAND_WIELD
  end
  def multi_weapons_penality
    return @multi_weapons_penality != nil ? @multi_weapons_penality : MULTI_WEAPONS_PENALITY
  end
  def weapon_slot_powers
    return @weapon_slot_powers != nil ? @weapon_slot_powers : WEAPON_KIND_POWERS
  end
  def weapon_hand_wield
    return @weapon_hand_wield != nil ? @weapon_hand_wield : WEAPON_HAND_WIELD
  end
  def shield_hand_slot
    return @shield_hand_slot != nil ? @shield_hand_slot : SHIELD_HAND_SLOT
  end
  def extra_slot_names
    return @extra_slot_names != nil ? @extra_slot_names : EXTRA_SLOT_NAMES
  end 
  def ignore_offhand?
    return @ignore_offhand != nil ? @ignore_offhand : IGNORE_OFFHAND
  end
  def attack_count 
    # Returns number of attacks already made
    return @attack_count != nil ? @attack_count : 0
  end
  def all_weapons_for_skills?
    return @all_weapons_for_skills != nil ? @all_weapons_for_skills : ALL_WEAPONS_FOR_SKILLS
  end
  #--------------------------------------------------------------------------
  # * Change behavior of items on character
  #--------------------------------------------------------------------------
  def multi_weapons_penality=(value)
    @multi_weapons_penality = value
  end
  def weapon_slot_powers=(value)
    @weapon_slot_powers = value
  end
  def weapon_shield_share=(bool)
    @weapon_shield_share = bool
  end
  def shield_hand_slot=(int)
    @shield_hand_slot = int
  end 
  def shield_hand_wield=(bool)
    @shield_hand_wield = bool
  end
  def weapon_hand_wield=(bool)
    @weapon_hand_wield = bool
  end
  def ignore_offhand=(bool)
    @ignore_offhand = bool
  end
  def all_weapons_for_skills=(bool)
    @all_weapons_for_skills = bool
  end
  def attack_count=(value) 
    # Set number of attacks already made
    @attack_count = value
  end
  #--------------------------------------------------------------------------
  # * Change names for your slots
  #--------------------------------------------------------------------------
  def shield_name=(text) 
    # Set the shield slot name with...
    # $game_actors[numberofactor].shield_name = 'Yourname'
    @armor_slot_names[0] = text
  end 
  def helmet_name=(text)
    @armor_slot_names[1] = text
  end 
  def armor_name=(text)
    @armor_slot_names[2] = text
  end
  def accessory_name=(text)
    @armor_slot_names[3] = text
  end
  def extra_slot_names=(array) 
    @extra_slot_names = array
  end
  def armor_slot_names=(array) 
    # Set a new array of names.
    @armor_slot_names = array
  end
  def weapon_slot_names=(array) 
    # Set a new array of weapon names. 
    @weapon_slot_names = array
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Game Actor
  #--------------------------------------------------------------------------  
end



#==============================================================================
# ** Game_Actors
#------------------------------------------------------------------------------
#  This class handles the actor array. Refer to "$game_actors" for each
#  instance of this class.
#==============================================================================

class Game_Actors
  #--------------------------------------------------------------------------
  # * Order Items
  #--------------------------------------------------------------------------  
  def order_items
    for actor in [email=0...@data.size]0...@data.size[/email]
      if @data[actor] != nil and @data[actor] != 0 then
        # Order armors
        @data[actor].order_armor_ids
      end
    end
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Game Actors
  #--------------------------------------------------------------------------  
end

#==============================================================================
# Multi-slot equipment script
#------------------------------------------------------------------------------
# Section 3:  Windows
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.1
# 2006/02/14
#==============================================================================

#==============================================================================
# ** Scene_Equip
#------------------------------------------------------------------------------
#  This class performs equipment screen processing.
#==============================================================================
class Scene_Equip
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  alias g7_ms_scene_equip_main main
  def main
    # Closes extra windows
    @additional_initialize_done = false
    g7_ms_scene_equip_main
    for i in 5...@item_windows.size
     @item_windows[i].dispose unless @item_windows[i].nil?
    end
  end
  #--------------------------------------------------------------------------
  # * Initialize the extra right windows
  #--------------------------------------------------------------------------
  def g7_ms_scene_equip_additional_initialize
    unless @additional_initialize_done
      @item_windows = []
      @item_windows[0] = @item_window1 # Weapon
      @item_windows[1] = @item_window2 # Shield
      @item_windows[2] = @item_window3 # Helmet
      @item_windows[3] = @item_window4 # Armor
      @item_windows[4] = @item_window5 # Accessory
      nb_old_windows = @item_windows.size
      for i in [email=nb_old_windows...@actor.armor]nb_old_windows...@actor.armor[/email]_slots.max+1
        # Add the remaining windows for extra slots
        @item_windows.push(Window_EquipItem.new(@actor, i) )
        @item_windows[i].help_window = @help_window
      end
      @item_windows.push(Window_EquipOffHand.new(@actor, 0))
      @item_windows[-1].help_window = @help_window
      # If windows_stretch is true, stretch window
      if G7_MS_MOD::WINDOWS_STRETCH
        h = (@actor.weapon_slots.size + @actor.armor_slots.size + 1) * 32
        h2 = (G7_MS_MOD::MAX_SHOW_SLOTS+1) * 32
        h = [h, h2].min
        @right_window.height = h
        if @right_window.index > @actor.weapon_slots.size + @actor.armor_slots.size - 1
          @right_window.index = @actor.weapon_slots.size + @actor.armor_slots.size - 1
        end
        if @left_window.y + @left_window.height == 256
          @left_window.height = @right_window.height
        elsif G7_MS_MOD::HELP_AT_BOTTOM == true and @left_window.height == 416 then
          @left_window.height -= 64 #make left window shorter
        end
        y_pos = (@right_window.y + @right_window.height)
        y_space = 480 - y_pos
        # If help at bottom, reduce bottom item window size
        if G7_MS_MOD::HELP_AT_BOTTOM == true then y_space -= 64 end 
        for item_window in @item_windows
          next if item_window.nil?
          item_window.y = y_pos
          item_window.height = y_space
        end
      end
      @additional_initialize_done = true
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh and make visible the correct right window
  #--------------------------------------------------------------------------
  alias g7_ms_scene_equip_refresh refresh
  def refresh
    # This part is used to refresh the equipped item at the right window
    g7_ms_scene_equip_additional_initialize
    @actor.translucent_texts.fill(false)
    @actor.equip_type_force = index_to_equip_part(@right_window.index)
    @right_window.item_fix_on
    @right_window.scroll_fix_on
    save = @right_window.index
    @right_window.index = index_to_equip_kind(@right_window.index)
    if @right_window.index == 0 and @actor.ignore_offhand? != true then
      if @actor.nb_offhand_required(save) > 0 then
        @right_window.index = @item_windows.size-1
      end
    end
    @actor.equip_from_menu = true
    # Ensure current equipment will get properly stored...
    @actor.equip_mode = 'STORE'
    # ...and re-equiped
    @item_window = @item_windows[@right_window.index]
    @item_windows[@right_window.index].visible = true
    for i in 0...@item_windows.size
      if i != @right_window.index then
        @item_windows[i].visible = false
      end
    end
    # Equip and remove item
    g7_ms_scene_equip_refresh
    @actor.equip_from_menu = false 
    @actor.equip_mode = nil
    @actor.equip_type_force = nil
    @right_window.index = save 
    @right_window.scroll_fix_off
    @right_window.item_fix_off  
    if @item_window.index != @old_index
      @right_window.refresh
    end
    @old_index = @item_window.index
  end
  #--------------------------------------------------------------------------
  # * Convert the right_window.index to equip_type
  #--------------------------------------------------------------------------
  alias g7_ms_scene_equip_update_item update_item
    def update_item 
      # This changes the @right_window.index to the correct value to take 
      # account of extra slots
      @actor.equip_type_force = index_to_equip_part(@right_window.index)
      @right_window.item_fix_on
      @right_window.scroll_fix_on
      save = @right_window.index
      @right_window.index = index_to_equip_kind(@right_window.index)
      @actor.equip_from_menu = true
      # Equip item
      g7_ms_scene_equip_update_item
      @actor.equip_from_menu = false
      @actor.equip_type_force = nil
      # If not in item_window screen
      if @item_window.index == -1
        # If shield-weapon can modify each other 
        if @actor.shield_hand_wield == true and 
          if @right_window.index == @actor.shield_hand_slot then
            @item_windows[0].refresh
            @item_windows[-1].refresh
          elsif @right_window.index == 0
             # Refresh the shield slot
             @item_windows[@actor.shield_hand_slot].refresh
          end
        end
        if @right_window.index == 0 and @actor.ignore_offhand? != true then
        if @item_window == @item_windows[-1] then 
          @item_windows[0].refresh
        elsif @item_window == @item_windows[0] then
          @item_windows[-1].refresh
        end
      end
    end
    @right_window.index = save 
    @right_window.scroll_fix_off
    @right_window.item_fix_off
    @actor.equip_type_force = nil
  end
  #--------------------------------------------------------------------------
  # * Convert index to equip part
  #     index : slot number
  #--------------------------------------------------------------------------
  def index_to_equip_part(index)
    # Return index of slot in the 
    # array [0, @actor.armor_slots, actor.weapon_slots] 
    if index >= @actor.weapon_slots.size #if armor
      return index - (@actor.weapon_slots.size - 1)
    # If extra weapon
    elsif index >= 1
      # Make it last
      return index + [@actor.armor_slots.size, 4].max
    else
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # Convert index to equip kind
  #     index : slot number
  #--------------------------------------------------------------------------
  def index_to_equip_kind(index)
    # Return index of slot in either actor.weapon_slots or actor.armor_slots
    i = index_to_equip_part(index)
    if index >= @actor.weapon_slots.size #if armor
      set = @actor.armor_slots[i-1] 
    # If weapon  
    else
      i = i == 0 ? 0 : i - [@actor.armor_slots.size, 4].max
      set = @actor.weapon_slots[i]
    end
    return set != nil ? set : 0
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Scene Equip
  #--------------------------------------------------------------------------  
end



#==============================================================================
# ** Window_EquipRight
#------------------------------------------------------------------------------
#  This window displays items the actor is currently equipped with on the
#  equipment screen.
#==========================================================================

 

[Ravenith]

Now Blizzard's EquAP:
(Blizzard's equap script here was part of his great "tons of addons" script pack, so if something is missing, do not worry. All that matters are the lines marked with ##)

#==============================================================================
# EQUAP Skills by Blizzard
# Version: 3.02b
# Date: 28.05.2006
# Date v2.0: 13.06.2006
# Date v2.02b: 16.1.2007
# Date v3.0b: 19.2.2007
# Date v3.02b: 7.3.2007
# 
# 
# Explanation:
# 
# This add-on will allow you to bound skills to equipment. Equip it and you
# learn the skill, unequip it and you will forget it. The AP system allows to
# gain AP for skills and learn the permanently if the max AP for the skill are
# gathered. (This system is a very similar one to FF9's AP Skill System.)
# 
# 
# v2.0:
# - fixed bug, that appeared, when more equipment parts had the same skill
# - new multi-skill support
# 
# v2.02b:
# - improved coding a little bit
# 
# v3.0b:
# - completely overworked and added optional AP system (similar to FF9)
#   (I want to mention here I made this especially for blazinhandle =) )
# 
# v3.02b:
# - fixed bugs
# 
# 
# Compatibility:
# 
# 99% chance of full compatibility with SDK, not tested altough. WILL cause
# incompatibility with custom equipment scripts but there are instructions how
# to configure the script. Please note, that this script depends on the layout
# of your Equip Screen and needs to be put UNDER a CMS script if you are using
# one. Also there needs to be something changed if you are using another script,
# that uses dummy elements. Add your dummy element IDs to the triple commented
# array (###). This add-on WILL corrupt your old savegames. Might not work with
# some CMS-es.
# 
# 
# Instructions:
# 
# - Configuration:
# Press CRTL+SHIFT+F and type into the window one of the following:
# 
# Start EQ Database
# Start MAXAP Database
# Start GAINAP Database
# 
# You can jump now to the database directly. There are more instructions.
# Also change EQUAP_ELEMENT = XXX, where XXX is the ID number of the dummy
# element, that determines, which skill is bound to the equipment. Be sure to
# give that element every EQ skill or the system WILL glitch.
# 
# - Merge with a Custom Equipment System:
# The lines, that need to be edited are double commented with ##. If you are no 
# at least a bit of experienced scripter, it may be better to ask somebody else
# to perform the edit for you. Please note, that the person, who is going to
# edit this script needs the custom equipment script for reference.
# 
# 
# NOTE:
# DO NOT USE EQUAP SKILLS AS NORMAL SKILLS! THE SYSTEM WORKS WITH TEMPORARY
# LEARNING AND FORGETTING THE EQUAP SKILL. IF YOU LET YOUR CHARACTER LEARN AN
# EQUAP SKILL BY NORMAL MEANS, HE WILL FORGET IT AFTER HE UNEQUIPS THE
# APPROPRIATE EQUIPMENT!
# 
# 
# If you find any bugs, please report them here:
# http://www.chaosproject.co.nr/
# or send me an e-mail:
# boris_blizzard@yahoo.de
#==============================================================================

if TONS_OF_ADDONS::EQUAP_SKILLS

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# Start EQUAP General Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

$EQUAP_ELEMENT = 19 # your EQ element ID
if $DUMMY_ELEMENTS == nil
  $DUMMY_ELEMENTS = [$EQUAP_ELEMENT] ### add more dummy elements if you have any
else
  $DUMMY_ELEMENTS.push($EQUAP_ELEMENT)
end
DISPLAY_AP_GAIN = true # uses a modified Battle Result to display gained AP
DISPLAY_AP_REQ = true # show CURRENT_AP/NEEDED_AP in the skill's name
GAIN_DEAD = false # dead actor also gain AP, no matter what

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# End EQUAP General Configuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

#==============================================================================
# Game_System
#==============================================================================

class Game_System
  
  def maxap(id)
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# Start of MAXAP Database
#
# Here you can define the APs needed to learn a skill. If you add no skills
# here the AP system is automatically disabled. Configure it like this template:
# 
# when SKILL_ID then return MAXAP
# 
# SKILL_ID - the ID of the skill that will be learned with AP
# MAXAP - how many AP are required to learn the skill
# 
# Note:
# Don't forget to assign your AP skills to equipment in the EQ Database below.
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    case id
    when 1 then return 0
    end
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# End of MAXAP Database
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    return 0
  end
  
  def gainap(id)
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# Start of GAINAP Database
#
# Here you can define how many AP you will get from enemy troops. Configure it
# like this template:
# 
# when TROOP_ID then return GAINAP
# 
# TROOP_ID - the ID of the enemy troop
# GAINAP - how many AP will the player get from this troop.
# 
# Note:
# This will automatically be disabled if there are no AP skills.
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    case id
    when 1 then return 2
    end
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# End of MAXAP Database
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    return 0
  end
  
  def eq_database(ids)
    skill_ids = []
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# Start of EQ Database
#
# This is your equipment database. To add one or more new EQUAP skills to a
# weapon is very simple. Add another "when"-branch in the script snipplet below
# (they have comments next to it). Configure it like this template:
# 
# when "weapon ID"
#   @skill_ids.push(EQUAP_SKILL_ID1)
#   @skill_ids.push(EQUAP_SKILL_ID2)
# 
# The same works for armors:
# 
# when "armor_ID"
#   @skill_ids.push(EQUAP_SKILL_ID1)
#   @skill_ids.push(EQUAP_SKILL_ID2)
# 
# Please note, that you need to configure this for every equipment part
# separately. That means you need to set it seperately for shields, armors,
# helmets and accessories. This also goes for custom equipment additions.
# 
# The lines are commented below so you should have no problems with the script.
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    case ids[0]
    when 40 # weapon ID
      skill_ids.push(96) # EQUAP skill ID
      skill_ids.push(11) # EQUAP skill ID
    when 0 # weapon ID
      skill_ids.push(8) # EQUAP skill ID
      skill_ids.push(12) # EQUAP skill ID
    end
    case ids[1]
    when 0 # armor1 ID
      skill_ids.push(1) # EQUAP skill ID
      skill_ids.push(25) # EQUAP skill ID
    when 0 # armor1 ID
      skill_ids.push(25) # EQUAP skill ID
    end
    case ids[2]
    when 0 # armor2 ID
      skill_ids.push(15) # EQUAP skill ID
    when 0 # armor2 ID
      skill_ids.push(27) # EQUAP skill ID
    end
    case ids[3]
    when 0 # armor3 ID
      skill_ids.push(2) # EQUAP skill ID
      skill_ids.push(25) # EQUAP skill ID
    when 0 # armor3 ID
      skill_ids.push(7) # EQUAP skill ID
      skill_ids.push(4) # EQUAP skill ID
    end
    case ids[4]
    when 0 # armor3 ID
      skill_ids.push(7) # EQUAP skill ID
      skill_ids.push(4) # EQUAP skill ID
    end
    case ids[5]
    when 0 # armor3 ID
      skill_ids.push(7) # EQUAP skill ID
      skill_ids.push(4) # EQUAP skill ID
    end
    case ids[6]
    when 0 # armor3 ID
      skill_ids.push(7) # EQUAP skill ID
      skill_ids.push(4) # EQUAP skill ID
    end
    case ids[7]
    when 34 # armor3 ID
      skill_ids.push(96) # EQUAP skill ID
    when 35  
      skill_ids.push(97) # EQUAP skill ID
    end
    case ids[7] ## add more ids if you are using a custom number of equip parts
    when 29 # armor4 ID
      skill_ids.push(10) # EQUAP skill ID
    when 8 # armor4 ID
      skill_ids.push(32) # EQUAP skill ID
      skill_ids.push(29) # EQUAP skill ID
    end
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# End of EQ Database
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    return skill_ids
  end
    
end
  
#==============================================================================
# Game_Battler
#==============================================================================

class Game_Battler
  
  def elements_correct(element_set)
    elements = element_set.clone
    return 100 if elements == []
    multiplier = 0
    size = 0
    for i in elements
      unless $DUMMY_ELEMENTS.include?(i)
        multiplier += self.element_rate(i)
        size += 1
      end
    end
    return 100 if size == 0
    return multiplier/size
  end
  
end

#==============================================================================
# Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  
  alias setup_equap_later setup
  def setup(id)
    setup_equap_later(id)
    if $ap_enabled
      @ap = {}
      for id in 1...$data_skills.size
        @ap[id] = 0 if $game_system.maxap(id) != 0
      end
    end
    test_equap
  end
  
  def add_ap(val)
    return unless $ap_enabled
    for key in @ap.keys
      if @skills.include?(key)
        max = $game_system.maxap(key)
        @ap[key] = self.ap(key) + val
        @ap[key] = max if @ap[key] > max
        @ap[key] = 0 if @ap[key] < 0
      end
    end
  end
  
  def ap(id)
    return (!$ap_enabled ? 0 : @ap[id] == nil ? 0 : @ap[id])
  end
  
  alias equip_equap_later equip
  def equip(equip_type, id)
    equip_equap_later(equip_type, id)
    test_equap
  end
  
  def test_equap
    ids = []
    ids.push(@weapon_id) ## this part here needs to be edited if a custom
    ids.push(@armor1_id) ## number of equipment parts is used. In that case it
    ids.push(@armor2_id) ## is enough to add more of these commands here. Also
    ids.push(@armor3_id) ## be sure to use the correct names for the IDs like
    ids.push(@armor4_id) ## i.e. "armor3_id"
        skill_ids = $game_system.eq_database(ids)
    for id in 1...$data_skills.size
      if $data_skills[id].element_set.include?(EQUAP_ELEMENT) and
          (not $ap_enabled or self.ap(id) < $game_system.maxap(id))
        forget_skill(id)
      end
    end
    for id in skill_ids
      learn_skill(id)
    end
  end
  
end

#==============================================================================
# Game_Troop
#==============================================================================

class Game_Troop
  
  attr_reader :id
  
  alias setup_equap_later setup
  def setup(troop_id)
    setup_equap_later(troop_id)
    @id = troop_id if $ap_enabled
  end
  
end

#==============================================================================
# Window_BattleResult
#==============================================================================

class Window_BattleResult
  
  def refresh_extra(aps)
    self.contents.fill_rect(0, 0, self.width, 32, Color.new(0, 0, 0, 0))
    x = 4
    self.contents.font.color = normal_color
    cx = contents.text_size(@exp.to_s).width
    self.contents.draw_text(x, 0, cx, 32, @exp.to_s)
    x += cx + 4
    self.contents.font.color = system_color
    cx = contents.text_size("EXP").width
    self.contents.draw_text(x, 0, 64, 32, "EXP")
    x += cx + 16
    self.contents.font.color = normal_color
    cx = contents.text_size(@gold.to_s).width
    self.contents.draw_text(x, 0, cx, 32, @gold.to_s)
    x += cx + 4
    self.contents.font.color = system_color
    cx = contents.text_size($data_system.words.gold).width
    self.contents.draw_text(x, 0, 128, 32, $data_system.words.gold)
    x += cx + 16
    self.contents.font.color = normal_color
    cx = contents.text_size(aps.to_s).width
    self.contents.draw_text(x, 0, cx, 32, aps.to_s)
    x += cx + 4
    self.contents.font.color = system_color
    self.contents.draw_text(x, 0, 128, 32, "AP")
  end

end

#==============================================================================
# Window_Skill
#==============================================================================

class Window_Skill
  
  alias draw_item_equap_later draw_item
  def draw_item(index)
    skill = @data[index]
    aps = $game_system.maxap(skill.id)
    if DISPLAY_AP_REQ and aps != 0 and not $scene.is_a?(Scene_Battle)
      if @actor.skill_can_use?(skill.id)
        self.contents.font.color = normal_color
      else
        self.contents.font.color = disabled_color
      end
      x = 4 + index % 2 * (288 + 32)
      y = index / 2 * 32
      rect = Rect.new(x, y, self.width / @column_max - 32, 32)
      self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
      bitmap = RPG::Cache.icon(skill.icon_name)
      opacity = self.contents.font.color == normal_color ? 255 : 128
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
      text = "#{skill.name} (#{@actor.ap(skill.id)}/#{aps})"
      self.contents.draw_text(x + 28, y, 204, 32, text, 0)
      self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
    else    
      draw_item_equap_later(index)
    end
  end
  
end

#==============================================================================
# Scene_Battle
#==============================================================================

class Scene_Battle
  
  alias start_phase5_equap_later start_phase5
  def start_phase5
    start_phase5_equap_later
    if $ap_enabled and DISPLAY_AP_GAIN
      aps = $game_system.gainap($game_troop.id)
      @result_window.refresh_extra(aps)
      for actor in $game_party.actors
        actor.add_ap(aps) if GAIN_DEAD or not actor.dead?
      end
    end
  end
  
end

#==============================================================================
# AP enabled test
#==============================================================================

sys = Game_System.new
skills = load_data("Data/Skills.rxdata")
skills.delete(nil)
$ap_enabled = false
for skill in skills
  if sys.maxap(skill.id) != 0
    $ap_enabled = true
    break
  end
end
sys = nil
skills = nil

end

If someone has suggestions on this, I'd appreciate it, since it's now a matter of learning to me, plus that I based my project on this. Thank you.
->Ravenith

 

[Ravenith]

Okay, this is it, BUMP. Pointless bump, but Bump anyway. Maybe I could use Trickster's equipment scipt... any ideas?