*Multi-Slot Equipment 1 Voti 1

[mizard]

DESCRIZIONE:

Dopo tantissimo tempo di ricerca, pomeriggi sprecati davanti al PC (lol), sono riuscito a trovarlo ed è qui per voi: il Multi-Slot Equipment. Unica pecca, in inglese, ma io ho volto in italiano solo i nomi degli slots. Questo script è impostato per poter equipaggiare:

• Mano Destra
• Mano Sinistra
• Scudo
• Elmo
• Armatura
• Accessorio
• Guanti
• Gambali
• Amuleto

Sarà possibile equipaggiare due armi contemporaneamente, e anche armi a due mani. Ovviamente, quando si presenterà uno di questi casi, non si potrà equipaggiare lo scudo; potrete anche creare armi con maledizioni; inzomma è tutto descritto nello script. E' un sistema di equipaggiamento completo, il migliore a mio avviso, perché rende l'equipaggiamento dell'eroe più realistico.
 

AUTORE:

Script made by Guillaume777
 

ALLEGATI:

Eccovi quattro screen che ve lo mostrano: Screen 1 - Screen 2 - Screen 3 - Screen 4
 

DEMO:

Eccovi la demo dello script. Vi ricordo purtroppo che è in inglese, ma tra tutti i mali, è quello peggiore, perché è perfettamente funzionante!
Scarica qui!

 

 

Edit Apo: Aggiungo direttamente lo script per sicurezza!

Spoiler

#==============================================================================
# Multi-slot equipment script
#------------------------------------------------------------------------------
# Section 1:  Modules
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.2
# 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         = [3,4,5,6,7,8,  # ids of weapons requiring an offhand
                           9,10,11,12,
                           25,26,27,28,29,30,31,32,33,34,35,36,37,38]
 
  SWITCH_EQUIP_WEAPONS  = [[38,36], [43,42]]  # ids of weapons switched when equipped
  SWITCH_EQUIP_ARMORS   = [[41,40], [42,39]]  # 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       = 'Arial'      # 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.
  STATUS_WINDOW_SPACING = 24    # Space between each item in 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
            # Delete the element
            self.element_set.delete(elementnb)
          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
        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 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
    # If equipped for real
    else
      if self.enough_hands?(equip_type,id) != false then
        # Switch items to be equipped to fool the players
        id = self.switch_items(equip_type,id)
      end
    end
    # If not enough hands then don't equip
    if self.enough_hands?(equip_type,id) == false then 
      id = 0
    # If cursed and player tried to remove it, do nothing
    elsif self.equip_from_menu and self.cursed?(equip_type) then
      id = 0
    # If the slot is one of the 5 basic ones
    elsif equip_type <= 4
      # Equip the goold old way
      g7_ms_game_actor_equip(equip_type, id)
    else 
      # Equip in the new way
      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 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 #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 != true 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
  #--------------------------------------------------------------------------
  # * 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, id)
  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 its an extra armor slot
    if equip_type <= [self.armor_slots.size,4].max
      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 its 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 )
          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 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 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
  #--------------------------------------------------------------------------
  # * 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)                        # 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              # Re-equip 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) # 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
  #--------------------------------------------------------------------------
  # * 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 weapons are equipped
      if array[i] == nil then array[i] = 0 end
      if i == 0 then            # If 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
    # Ensure no nil values are returned
    for i in 0...self.armor_slots.size
      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 then @weapon_ids = Array.new(self.weapon_slots.size) end
    ids = @weapon_ids
    ids[0] = @weapon_id
    # Ensure no nil values are returned
    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 #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... 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 = []
    # Search all armor equipped
    for id in self.armor_ids
      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
          attacks.push(i) #add attacks
        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
  #--------------------------------------------------------------------------
  # * Get Offensive Animation ID for Normal Attacks
  #--------------------------------------------------------------------------
  def animation1_id
    # Set animation for current weapon
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.animation1_id : 0
  end
  #--------------------------------------------------------------------------
  # * Get Target Animation ID for Normal Attacks
  #--------------------------------------------------------------------------
  def animation2_id
    # Set animation for current weapon
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.animation2_id : 0
  end
  #--------------------------------------------------------------------------
  # * Get Basic Attack Power
  #   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 & 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 defined 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
    # Return elemental set of the current weapon
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.element_set : []
  end
  #--------------------------------------------------------------------------
  # * Get Normal Attack State Change (+)
  #--------------------------------------------------------------------------  
  def plus_state_set
    # Status the weapon can give
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.plus_state_set : []
  end
  #--------------------------------------------------------------------------
  # * Get Normal Attack State Change (-)
  #--------------------------------------------------------------------------  
  def minus_state_set
    # Status the weapon can remove
    weapon = self.get_weapon_data
    return weapon != nil ? weapon.minus_state_set : []
  end
  #--------------------------------------------------------------------------
  # * Determine State Guard
  #     state_id : state ID
  #--------------------------------------------------------------------------
  def state_guard?(state_id)
    # Return state defense of all armor
    for i in self.armor_ids
      armor = $data_armors[i]
      if armor != nil
        if armor.guard_state_set.include?(state_id)
          return true
        end
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * Get Element Revision Value
  #     element_id : element ID
  #--------------------------------------------------------------------------
  alias g7_ms_game_actor_element_rate element_rate
  def element_rate(element_id)
    result = g7_ms_game_actor_element_rate(element_id)
    # Methods calculate bonus of extra weapon and armor
    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 protected]
      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
    @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 protected]_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
        # Make left window shorter
        @left_window.height -= 64
      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 Armor
    if index >= @actor.weapon_slots.size
      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 armor
    if index >= @actor.weapon_slots.size
      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.
#==============================================================================
class Window_EquipRight < Window_Selectable
  #--------------------------------------------------------------------------
  # * Item Fix On
  #--------------------------------------------------------------------------
  def item_fix_on
    # Fix window
    @fixed_item = @data[self.index]
    @fixed = true
  end
  #--------------------------------------------------------------------------
  # * Item Fix Off
  #--------------------------------------------------------------------------
  def item_fix_off
    #stop fixing window
    @fixed_item = nil
    @fixed = false
  end
  #--------------------------------------------------------------------------
  # * Don't scroll right window if you press L or R
  #--------------------------------------------------------------------------
  def update
    if Input.repeat?(Input::R) or  Input.repeat?(Input::L) then
      return
    else
      super
    end
  end
  #--------------------------------------------------------------------------
  # Draws equipped items with support of translucent and cursed items
  #     item        : item
  #     x           : draw spot x-coordinate
  #     y           : draw spot y-coordinate
  #     translucent : draw translucent
  #--------------------------------------------------------------------------
  def draw_item_name(item, x, y, translucent = false)
    if item == nil
      return
    end
    bitmap = RPG::Cache.icon(item.icon_name)
    if item.cursed
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
      self.contents.font.color = G7_MS_MOD::CURSED_COLOR
    elsif translucent 
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), 128)
      self.contents.font.color = disabled_color
    else
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
      self.contents.font.color = normal_color
    end
    self.contents.draw_text(x + 28, y, 212, 32, item.name)
  end
  #--------------------------------------------------------------------------
  # * Prevent needless update of item quantities in item window
  #--------------------------------------------------------------------------
  alias g7_ms_window_equipright_item item 
  def item
    # This ensures that the number of items doesn't get updated if you move 
    # cursor in item window
    return @fixed_item if @fixed
    return g7_ms_window_equipright_item
  end
  #--------------------------------------------------------------------------
  # * Change the height of right windows to fit the slots
  #     actor : actor
  #--------------------------------------------------------------------------
  alias g7_ms_window_equipright_initialize initialize
  def initialize(actor)
    # Initialize with a different height
    g7_ms_window_equipright_initialize(actor)
    # Total height of right window
    h = (actor.weapon_slots.size + actor.armor_slots.size) * 32
    # Change the height                                                        
    self.contents = Bitmap.new(width - 32, h)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Shows the slot names and the name of the items you have equipped
  #--------------------------------------------------------------------------
  def refresh
    # Replaced method to show caption of all items and slot
    self.contents.clear
    @data = [] 
    # Begin Multi-slot equipment script Edit
    self.contents.font.name = G7_MS_MOD::FONT_NAME
    for i in [email protected]_slots.size
      # Push the name(s) of the weapon(s)
      @data.push($data_weapons[@actor.weapon_ids[i]])
    end
    for i in [email protected]_slots.size
      # Push the names of the armors
      @data.push($data_armors[@actor.armor_ids[i]])
    end
    @caption = []
    for i in [email protected]_slots.size
      # Push the name(s) of the weapon slots
      @caption.push(@actor.weapon_slot_names[i])
    end
    for i in [email protected]_slots.size
      # Push the names of the armor slots
      @caption.push(@actor.armor_slot_names[@actor.armor_slots[i]-1])
    end
    @item_max = @data.size
    if @actor.translucent_texts == nil then @actor.translucent_texts = Array.new end
    for i in [email protected]
      if @caption[i] != nil
        self.contents.font.color = system_color
        # Draw the name of the slots
        self.contents.draw_text(4, 32 * i, 92, 32, @caption[i])
      end
      # Draw the name of the equipment
      draw_item_name(@data[i], 92, 32 * i, @actor.translucent_texts[i])
    end
    # Support for other script
    if defined? xrxs_additional_refresh
      xrxs_additional_refresh
    end
  # End Multi-slot equipment script Edit
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Window EquipRight
  #--------------------------------------------------------------------------
end



#============================================================================
# ** Window_EquipOffHand
#----------------------------------------------------------------------------
#  A new window class that displays an equipped item in the actor's off hand.
#============================================================================
class Window_EquipOffHand < Window_EquipItem
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    # Add equippable weapons
    weapon_set = $data_classes[@actor.class_id].weapon_set
    for i in 1...$data_weapons.size
      if $game_party.weapon_number(i) > 0 and weapon_set.include?(i)
        weapon = $data_weapons[i]
        if weapon.needs_offhand == false
          if G7_MS_MOD::TWOHANDED_IN_OFFHAND != false and weapon.nb_hands <= 1 then
            @data.push(weapon)
          end
        end
      end
    end
    # Add blank page
    @data.push(nil)
    # Make a bit map and draw all items
    @item_max = @data.size
    self.contents = Bitmap.new(width - 32, row_max * 32)
    self.contents.font.name = G7_MS_MOD::FONT_NAME
    #self.contents.font.size = 24
    for i in 0...@item_max-1
      draw_item(i)
    end
    if G7_MS_MOD::SHOW_REMOVE then
       i = @item_max -1
       x = 4 + i % @column_max * (288 + 32)
       y = i / @column_max * 32
       self.contents.draw_text(x+4, y, 100, 32, '[Remove]')
    end
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Window EquipOffHand
  #--------------------------------------------------------------------------
end



#==============================================================================
# ** Window_Selectable
#------------------------------------------------------------------------------
#  This window class contains cursor movement and scroll functions.
#==============================================================================
class Window_Selectable < Window_Base
  #--------------------------------------------------------------------------
  # * Scroll Fix On
  #--------------------------------------------------------------------------
  def scroll_fix_on
    @scroll_fixed = true
  end
  #--------------------------------------------------------------------------
  # * Scroll Fix Off
  #--------------------------------------------------------------------------  
  def scroll_fix_off
    @scroll_fixed = false
    update_cursor_rect
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  alias g7_ms_update_cursor_rect update_cursor_rect
  def update_cursor_rect
    # This prevents the windows from scrolling if scroll is fixed
    # This was added to ensure that if there are few slots, the right equip
    # screen doesn't scroll needlessly
    return if @scroll_fixed
    g7_ms_update_cursor_rect
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Window Selectable
  #--------------------------------------------------------------------------  
end



#==============================================================================
# *** Global IF condition
#     Shows a new status window if Status_window_arrange is true
#==============================================================================
if G7_MS_MOD::STATUS_WINDOW_ARRANGE
  #============================================================================
  # ** Window_Status
  #----------------------------------------------------------------------------
  #  This window displays full status specs on the status screen.
  #============================================================================
  class Window_Status < Window_Base
    #--------------------------------------------------------------------------
    # * Refresh
    #--------------------------------------------------------------------------
    def refresh
      # Begin Multi-slot equipment script Edit
      self.contents.font.name = G7_MS_MOD::FONT_NAME
      # End Multi-slot equipment script Edit
      self.contents.clear 
      draw_actor_graphic(@actor, 40, 112)
      draw_actor_name(@actor, 4, 0)
      draw_actor_class(@actor, 4 + 144, 0)
      draw_actor_level(@actor, 96, 32)
      draw_actor_state(@actor, 96, 64)
      draw_actor_hp(@actor, 96, 112, 172)
      draw_actor_sp(@actor, 96, 144, 172)
      draw_actor_parameter(@actor, 96, 192, 0)
      draw_actor_parameter(@actor, 96, 224, 1)
      draw_actor_parameter(@actor, 96, 256, 2)
      draw_actor_parameter(@actor, 96, 304, 3)
      draw_actor_parameter(@actor, 96, 336, 4)
      draw_actor_parameter(@actor, 96, 368, 5)
      draw_actor_parameter(@actor, 96, 400, 6)
      # Begin Multi-slot equipment script Edit
      if G7_MS_MOD::EVADE
        # Activate if you have a draw_actor_paramter method that draws evade
        draw_actor_parameter(@actor, 96, 432, 7)
      end
      self.contents.font.color = system_color
      self.contents.draw_text(320, 16, 80, 32, 'EXP')
      self.contents.draw_text(320, 48, 80, 32, 'NEXT')
      self.contents.font.color = normal_color
      self.contents.draw_text(320 + 80, 16, 84, 32, @actor.exp_s, 2)
      self.contents.draw_text(320 + 80, 48, 84, 32, @actor.next_rest_exp_s, 2)
      self.contents.font.color = system_color
      self.contents.draw_text(320, 80, 96, 32, 'Equipment')
      y = 108
      for i in [email protected]_slots.size
        draw_item_name($data_weapons[@actor.weapon_ids[i]], 320 + 16, y)
        y += G7_MS_MOD::STATUS_WINDOW_SPACING
      end
      for i in [email protected]_slots.size
        draw_item_name($data_armors[@actor.armor_ids[i]], 320 + 16, y)
        y += G7_MS_MOD::STATUS_WINDOW_SPACING
      end
      # End Multi-slot equipment script Edit      
    end
    #------------------------------------------------------------------------
    # * End of CLASS:  Window Status
    #------------------------------------------------------------------------
  end
  #--------------------------------------------------------------------------
  # * End of Global IF condition
  #--------------------------------------------------------------------------
end


#==============================================================================
# Multi-slot equipment script
#------------------------------------------------------------------------------
# Section 4:  Other
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.1
# 2006/02/14
#==============================================================================

#==============================================================================
# ** Scene_Battle (part 4)
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------  
  # *  Go to phase4 step2 for attack if attack_count < attacks.size
  #--------------------------------------------------------------------------
  alias g7_ms_scene_battle_phase4_step6 update_phase4_step6
  def update_phase4_step6(battler=nil) 
    # This methods make the battler return to phase4 step2 if there is an
    # extra attack to be made
    # If no battler parameter
    if battler== nil then
      # First do the appropriate action
      g7_ms_scene_battle_phase4_step6
      if @active_battler.is_a?(Game_Enemy) then return end
      # Increase the number of attacks made  
      @active_battler.attack_count += 1
      # If all attacks have been made
      if @active_battler.attack_count == @active_battler.attacks.size or
      @active_battler.current_action.kind != 0 or 
      @active_battler.current_action.basic != 0 or
      judge == true
        # End of turn, and return attack count to 0
        @active_battler.attack_count = 0
      else
        # Return for extra attack
        @phase4_step = 2
      end
    # If it requres the battle as a parameter  
    else
      g7_ms_scene_battle_phase4_step6(battler)
      if battler.is_a?(Game_Enemy) then return end
      # Increase the number of attacks made  
      battler.attack_count += 1
      # If all attacks have been made
      if battler.attack_count == battler.attacks.size or
      battler.current_action.kind != 0 or battler.current_action.basic != 0 or 
      judge == true
        # End of turn, and return attack count to 0
        battler.attack_count = 0
      else
        # Add the battler again to the action
        if @action_battlers.include?(@active_battler) == false then @action_battlers.push(battler) end
        # Return for extra attack  
        battler.phase = 2
      end
    end
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Scene Battle
  #--------------------------------------------------------------------------  
end



#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  This class performs load screen processing.
#==============================================================================

class Scene_Load < Scene_File
  #--------------------------------------------------------------------------
  # * Fix equiped item if user load saved game
  #--------------------------------------------------------------------------
  alias g7_ms_scene_load_read_save_data read_save_data
  def read_save_data(file) 
    g7_ms_scene_load_read_save_data(file)
    $game_actors.order_items    # Order armor when you load a saved game in
                                # case it is an old game
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Scene Load
  #--------------------------------------------------------------------------  
end



#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs title screen processing.
#==============================================================================

class Scene_Title
  #--------------------------------------------------------------------------
  # * Fix items as you open RMXP
  #-------------------------------------------------------------------------- 
  alias g7_ms_scene_title_main main
  def main
    RPG.initialized_item_types = false
    g7_ms_scene_title_main
    RPG.set_new_item_types
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Scene Title
  #--------------------------------------------------------------------------  
end



#==============================================================================
# ** Interpreter (part 3)
#------------------------------------------------------------------------------
#  This interpreter runs event commands. This class is used within the
#  Game_System class and the Game_Event class.
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------  
  # * Conditional Branch to make it work when comparing extra items
  #--------------------------------------------------------------------------
  alias g7_ms_interpreter_command_111 command_111
  def command_111
    result = false
    broken = false
    case @parameters[0]
    # When Actor
    when 4
      actor = $game_actors[@parameters[1]]
      if actor != nil
        case @parameters[2]
        # If weapon
        when 3
          for i in 0...actor.weapon_ids.size
            # Compare
            result |= (actor.weapon_ids[i] == @parameters[3])
          end
          broken = true
        # If Armor  
        when 4
          for i in 0...actor.armor_ids.size
            # Compare
            result |= (actor.armor_ids[i] == @parameters[3])
          end
          broken = true
        end
      end
    end
    # If other conditional branch
    unless broken
      # Do the normal condition
      g7_ms_interpreter_command_111
      return
    end
    @branch[@list[@index].indent] = result
    if @branch[@list[@index].indent] == true
      @branch.delete(@list[@index].indent)
      return true
    end
    return command_skip
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Interpreter
  #--------------------------------------------------------------------------  
end



#==============================================================================
# ** MODULE:  Kernel
#------------------------------------------------------------------------------
#  A module defining the methods that can be referred to by all classes. Object
#  classes are included in this module.
#==============================================================================

module Kernel
  private
  def Rg(from, to, *step) Rg.new(from, to, *step) end
end



#==============================================================================
# ** Rg
#------------------------------------------------------------------------------
#   Class of modified RGSS statements, enhanced with module Kernel.
#==============================================================================
class Rg
  #Used to a more effective for ... in ... 
  include Enumerable
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------   
  def initialize(from, to, step = sign(to - from))
    @from, @to, @step = from, to, step
    @to += @step - ((@to - @from) % @step)
  end
  #--------------------------------------------------------------------------
  # * Each
  #--------------------------------------------------------------------------    
  def each
    x = @from
    until x == @to
      yield x
      x += @step
    end
    self
  end
  #--------------------------------------------------------------------------
  # * Sign
  #--------------------------------------------------------------------------    
  def sign(x)
    case
    when x > 0
      1
    when x == 0
      0
    else
      -1
    end
  end
  #--------------------------------------------------------------------------
  # * End of CLASS:  Rg
  #--------------------------------------------------------------------------  
end
 

 

Modificato da Apo, 22 March 2013 - 17:17 PM.
aggiunto lo script

[lotgd]

bello ed utilissimo, da mettere fra i migliori script ^_^ (da parte mia)

[Luigi]

utilissimo, è il miglior multi-slot che abbia mai visto

[mizard]

peccato ke sia in inglese...anke se si può modificare. x il resto è davvero ottimo, un capolavoro direi!

[Kenshin]

A dire la verità, mi interessa solo il fatto di poter equipaggiare 2 armi o un'arma a 2 mani e impedire lo scudo...
Ma m'attizza veramente, lo rubo ^^

[mizard]

con molto piacere!

[Satsume]

In effetti non oso immaginare come lo tenga lo scudo avendo 2 spade in mano x-x

[mizard]

già! ^^
xò mi stò accorgendo ke può fare un po' di confusione...ma basta organizzare le armi e le armature in un modo particolare e non dà problemi...

[Dark Sora]

Potreste ripostare il link? Non funziona più... Grazie

[Dark Sora]

C'è nessuno?

[makgyver]

Ciao!! come già detto da dark sora il link non funzia più quindi perfavore potrestri riappare?! Grazie mille!!

[Viewtiful Joe]

DESCRIZIONE:

Dopo tantissimo tempo di ricerca, pomeriggi sprecati davanti al PC (lol), sono riuscito a trovarlo ed è qui per voi: il Multi-Slot Equipment. Unica pecca, in inglese, ma io ho volto in italiano solo i nomi degli slots. Questo script è impostato per poter equipaggiare:

• Mano Destra
• Mano Sinistra
• Scudo
• Elmo
• Armatura
• Accessorio
• Guanti
• Gambali
• Amuleto

Sarà possibile equipaggiare due armi contemporaneamente, e anche armi a due mani. Ovviamente, quando si presenterà uno di questi casi, non si potrà equipaggiare lo scudo; potrete anche creare armi con maledizioni; inzomma è tutto descritto nello script. E' un sistema di equipaggiamento completo, il migliore a mio avviso, perché rende l'equipaggiamento dell'eroe più realistico.

AUTORE:

Script made by Guillaume777

ALLEGATI:

Eccovi quattro screen che ve lo mostrano: Screen 1 - Screen 2 - Screen 3 - Screen 4

DEMO:

Eccovi la demo dello script. Vi ricordo purtroppo che è in inglese, ma tra tutti i mali, è quello peggiore, perché è perfettamente funzionante!
Scarica qui!

Il link non funziona!!!!

[Mattone]

già, non funziona. rinnovalo che vorrei provarlo, sembra buono!

[alvi dandee]

riuppa per favoreeeeeee ç_ç

[SimyDark]

Potreste riuppare????

[Invisible]

Potreste riuppare????

io ho un problema! ho questo script e quello di MOG per il save e altri.... e mi crasha quando vado a caricare!
Mi da questo problema:

[the legend]

io ho un problema! ho questo script e quello di MOG per il save e altri.... e mi crasha quando vado a caricare!
Mi da questo problema:

Si vede che non sono compatibili.

[Riccio90]

Ma non c'è il Download :'(

[Guardian of Irael]

Basta una piccola ricerca con google e ta-dah! ^ ^