class Game_Actor < Game_Battler
 include G7_MS_MOD
 attr_accessor :equip_mode #used to restore equipment after false equip
 attr_accessor :equip_type_force #used to bypass equip_type
 attr_accessor :equip_from_menu  #used to prevent the user to unequip cursed items
 attr_accessor :translucent_texts #used to store translucents slots
#--------------------------------------------------------------------------
# Init the new slots
#--------------------------------------------------------------------------
 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

 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
#=========================================================
# Modify how equipment is equiped so that extra items can be equipped
#=========================================================
 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 for it 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
    else #if equipping for real
        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 ensure 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 got checked and adds translucent
#=========================================================
 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 the id of an item to be equiped with another id to trick player
#=========================================================
 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

#=========================================================
# Returns if there are enough hands to hold weapon
#=========================================================
 def enough_hands?(equip_type, id)
   if id == 0 then return true end # enough hand = true if you remove something
     
   if equip_type == 0 or equip_type > [self.armor_slots.size ,4].max #if weapon
       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 #nb 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 #penalities 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 #penalities if cant 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

 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

 def equip_armor(index, id)
     self.equip(index+1, armor)
 end
#=========================================================
# Equip extra items
#=========================================================
 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
  else #if its weapon slot
   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


#=========================================================
# This fix multi handed weapons
#=========================================================
 def fix_handed_weapons(equip_keep=nil) #parameter for weapon to keep

  array_wield_hands = Array.new #stores slot of weapon that need 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
 
   while nb_emp_hands != 0 and nb_hands > 1
      #if it finds empty hand
      nb_hands += -1 #decrease counter
      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 if nhnad ==0
     end #end if nb_hands != 1
        while nb_emp_hands != 0 and nb_hands > 1
          #if it finds empty hand
           nb_hands += -1 #decrease counter
           nb_emp_hands += -1
        end
    end #end for nahand
   end #end if self.weapon
 
 
   if nb_hands > 1 #if still can't find a slot, remove the weapon
 
    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
   while nb_emp_hands != 0 and nb_hands > 1
      #if it finds empty hand
      nb_hands += -1 #decrease counter
      nb_emp_hands += -1
   end
   if nb_hands > 1 then #if STILL not enough hands
    self.equip(equip_keep,0) # remove the item the user tried to equip
   end
  end #loop
 
 
  @equip_type_force = save_force #returns old equip_type_force
  @equip_from_menu = save_menu #return old equip_from_menu
 end

#=========================================================
# Return true if there is a cursed item at that position
#=========================================================
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
  elsif equip_type <= self.armor_slots.size #if armor
     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 then 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

#--------------------------------------------------------------------------
# It orders armor_ids to fit 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 if iaitem != nil
  end #end for i in
 
  self.armor_ids = armors
 end

#=========================================================
# Change weapon slots
#=========================================================
 def weapon_slots=(array) #change slots of weapons
  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
#=========================================================
 def armor_slots=(array) # change slots of armor
  if array == nil then array = ARMOR_KINDS end #returns to default if nothing
  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 #end def
#--------------------------------------------------------------------------
# Set new array of weapons, if nil then it removes all weapon
#--------------------------------------------------------------------------
 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
   if array[i] == nil then array[i] = 0 end #ensure no nil are equiped
   if i == 0 then #if first weapon
    self.equip(0, array[i]) #equip weapon
   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
#--------------------------------------------------------------------------
 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

 def weapon_ids
  #returns ids with all weapon, also store first weapon
  unless self.is_a?(Game_Actor)
   return []
  end
  if @weapon_ids == nil then @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 = [$data_system.words.armor1,$data_system.words.armor2, $data_system.words.armor3, $data_system.words.armor4, self.extra_slot_names].flatten #default names of slots
  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 temp_array[i] == nil then temp_array[i] = default_names[i] end #set as constant
   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]
   set += (armor != nil ? armor.guard_element_set : []) #add the element to 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 weapon != nil and weapon.atk != 0 then #if weapon is valid
    for counter in 0...weapon.nb_attacks
     attacks.push(i) #add attacks
    end
   end
 
  end
 
  if attacks.size == 0 then attacks[0] = 0 end #give 1 unarmed attack if no weapons on
  return Array.new(attacks)
 
 end #end nb_attacks

#--------------------------------------------------------------------------
# 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
 def animation1_id #set animation for current weapon
  weapon = self.get_weapon_data
  return weapon != nil ? weapon.animation1_id : 0
 end
 def animation2_id #set animation for current weapon
  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

 def element_set #return elemental set of the current weapon
  weapon = self.get_weapon_data
  return weapon != nil ? weapon.element_set : []
 end
 def plus_state_set #status the weapon can give
  weapon = self.get_weapon_data
  return weapon != nil ? weapon.plus_state_set : []
 end
 def minus_state_set #status the weapon can remove
  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

 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

 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

 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

 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

 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

 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

 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 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 #end class game actor

class Game_Actors
  def order_items
    for actor in 0...@data.size
      if @data[actor] != nil and @data[actor] != 0 then
        @data[actor].order_armor_ids #order armors
      end
    end
  end
end