Gameover Menu Scripting Help -- Respawning With Difficult to Make Penalties

[diablosbud]

Basically, what I am doing for my game is rewriting my custom gameover so that it has a sweet new respawn system, built into it. I need to make it call a common event, and make a penalty for each choice. I have put the choices together properly, but I am having a problem with the penalties, I do not know how to call a common event through script (this will be used for making the penalties), and I do not know how to make the player respawn without him dying instantly on the map. Also I need some help with the penalties I need to take all the held gold away from party (is 9999999 gold the max because I may be able to do this with events), I need to know how to take off a percentage of a specific actor's EXP with a script (this is 10% of the EXP for this level, and this cannot decrease levels), and how to randomly select a random slot of equipment the certain actor has equipped, and delete that piece of equipment from the player. I know this is quite a bit, but not all of it is hard, pretty much only the equipment penalty. Could someone please help me put this together? Sorry if the gameover menu is a bit confusing, it's my own script, built with command_rotate, a cool different way of displaying options.

Spoiler: My Gameover Menu Script

#=============================================================================== 
# Game Over Menu Script V1.0                          ~By Diablosbud~     
#-------------------------------------------------------------------------------
#    Make your Gameover screen easier to use, and cooler with this script I made
#  for Command_Rotate. This script allows the player, on Gameover to choose if
#  they would like to "Load Game" or "Exit Game". A special feature has been added 
#  to the "Exit Game" choice, now you can either exit to the titlescreen or 
#  shutdown the game  (This is an edit of LordSmith's Gameover Menu re-made with
#  Command_Rotate to make it much cooler). Many features about this are customizable
#  too, such as font, font size, disabled item color, etc.
#
#  Requirements:
#  -Command_Rotate script
#  -This script
#
#  Compatibility:
#  -I am unsure yet if this script is compatible with the SDK
#  
#  Credit
#  -Diablosbud
#  -KHMP
#  -LordSmith
#===============================================================================

#=========================================================
# Command_Rotate
#---------------------------------------------------------
#
# Created by LordSith
# email: lordsith@globetrotter.net
# Version: 1.1
# Date: 2007-06-08 
#---------------------------------------------------------
#
#=========================================================

#==============================================================================
# ** Sprite_Text
#------------------------------------------------------------------------------
#  This class draws text on the screen without the need of a window.
#==============================================================================

class Sprite_Text
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :sprite,  # The sprite used to draw.
                :vx,      # The velocity in the x direction.
                :vy       # The velocity in the y direction.
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(text = 'nil', size = 50, font = 'Times New Roman', disabled = false,
                 disabledcolor = Color.new(255, 255, 255, 108),
                 vx = 0, vy = 0)
    
    # Turn the text into a string even if it already is a string.
    text = text.to_s
    
    # Create the sprite that will allow drawing.
    @sprite = Sprite.new
    @sprite.bitmap = Bitmap.new(1,1)
    
    # Initialize the sprite's bitmap's font properties.
    @sprite.bitmap.font.name = font
    @sprite.bitmap.font.size = size
    
    # Find out the size of the text so the sprite doesn't waste empty space.
    lx = @sprite.bitmap.text_size(text).width 
    ly = @sprite.bitmap.text_size(text).height 
    
    # Initialize the velocity vector
    @vx, @vy = vx, vy
    
    # The offset of the shadow for the text.
    shadow = 1
    
    # Reinitialize the bitmap with the proper size.
    @sprite.bitmap = Bitmap.new(lx + shadow, ly + shadow)

    # Make the z outstanding.
    @sprite.z = 5000
    @sprite.x = @x = 320.0
    @sprite.y = @y = 240.0
    
    # Draw the shadow first.
    @sprite.bitmap.font.color = Color.new(0,0,0,255)
    @sprite.bitmap.draw_text(Rect.new(shadow, shadow, lx + shadow,ly + shadow), 
      text, 0)
    
    # If the sprite is disabled change the text color appropriately.
    @sprite.bitmap.font.color = disabled ? disabledcolor : 
      Color.new(255,255,255,255) # White if not disabled.
    
    # Draw the text onto the bitmap finally.
    @sprite.bitmap.draw_text(Rect.new(0, 0, lx, ly), text)
  end
  #--------------------------------------------------------------------------
  # * Defining X, Y
  #--------------------------------------------------------------------------
  def xy(x, y)
    @x = x
    @y = y
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    angle = Math.atan2(@vx,@vy)
    
    vx = 2 * Math.sin(angle)
    vy = 2 * Math.cos(angle)
    
    @x += vx
    @y += vy
    
    @sprite.x = @x
    @sprite.y = @y
    @sprite.opacity -= 4
    
    if @x > 640 or @x < 0 or @y > 480 or @y < 0 or @sprite.opacity <= 0
      @sprite.bitmap.dispose unless @sprite.bitmap.disposed?
      @sprite.dispose unless @sprite.disposed?
      return true
    end
    
    return false
  end
  #--------------------------------------------------------------------------
  # * Disposal
  #--------------------------------------------------------------------------
  def dispose
    @sprite.bitmap.dispose unless @sprite.bitmap.disposed?
    @sprite.dispose unless @sprite.disposed?
  end
end

def coords(x=0,y="")
  if y.is_a?(String)
    if x==0
      x=$game_player.screen_x
      y=$game_player.screen_y
    else
      y=$game_map.events[x].screen_y
      x=$game_map.events[x].screen_x
    end
    return [x,y]
  elsif x.is_a?(String)
    if y == 0
      x = $game_player.screen_x
      y = $game_player.screen_y
    else
      x = $game_map.events[y].screen_x
      y = $game_map.events[y].screen_y
    end
    return [x,y]
  end
  return [x,y]     
end

def angle(x1,y1,x2,y2)
  return 180*Math.atan2(x2-x1,y2-y1)/Math::PI
end
 
def ecart(id1,id2=0,y1="",y2="")
  x1=coords(id1,y1).at(0)
  y1=coords(id1,y1).at(1)
  x2=coords(id2,y2).at(0)
  y2=coords(id2,y2).at(1)
  return ((x1-x2)**2 + (y1-y2)**2)**0.5
end

#==============================================================================
# ** Command_Rotate
#------------------------------------------------------------------------------
#  This class presents options in circuitous manner.
#==============================================================================

class Command_Rotate
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :index
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(choices, x = 400, y = 240, ray = 200, choices0 = 0,
                 size = 50, font = 'Times New Roman', disabled_items = nil,
                 disabledcolor = Color.new(255, 255, 255, 108))
    # By default visible.
    @visible = true
    
    @text_sprites = []
    @positions = []
    @options = choices
    @disabledcolor = disabledcolor
    @ray = ray
    @angle = 0
    @disabled_items = disabled_items
    @x, @y = coords(x, y)
    n = 0
    
    for choice in choices
      # Don't check for disabled items if it's nil.
      if !disabled_items.nil? && disabled_items.include?(n)
        text_sprite = Sprite_Text.new(choice, size, font, true, @disabledcolor)  
      else
        text_sprite = Sprite_Text.new(choice, size, font)
      end
      
      text_sprite.sprite.ox = text_sprite.sprite.bitmap.width / 2
      text_sprite.sprite.oy = text_sprite.sprite.bitmap.height / 2
      
      teta = n * 360 / choices.size
      @text_sprites << text_sprite
      @positions << teta
      @delay=0
      n+=1
    end
    
    @angle = (@options.size-choices0) * 2 * Math::PI / @options.size
    @selected = @options[choices0]
    @index_self = 0
    update 
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    @angle -= (@angle - (@options.size - @index_self) * 2 * Math::PI / 
      @options.size) / 8
    i = 0
    
    @text_sprites.each do |text_sprite|
      a = @positions.at(i) * Math::PI / 180
      text_sprite.sprite.x = 0
      text_sprite.sprite.x += @x
      text_sprite.sprite.y = @ray * Math.sin(a + @angle) / 2
      text_sprite.sprite.y+=@y
      text_sprite.sprite.zoom_x = text_sprite.sprite.zoom_y = (Math.cos(a + @angle) + 3) / 4
      text_sprite.sprite.opacity = (1 + Math.cos(a + @angle)) * 255 / 2
      i += 1
    end
   
    @delay-=1 
    if @delay<=0
      if Input.trigger?(Input::DOWN) or Input.trigger?(Input::RIGHT)
        @index_self += 1 
        @selected = @options[@index_self % @text_sprites.size]
        @index = @options.index(@selected)
      end
      if Input.trigger?(Input::UP) or Input.trigger?(Input::LEFT)
        @index_self -= 1        
        @selected = @options[@index_self % @text_sprites.size]
        @index = @options.index(@selected)
      end
      @delay=1
    end
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    @text_sprites.each {|sprite| sprite.dispose}
  end
  #--------------------------------------------------------------------------
  # * Visible
  #--------------------------------------------------------------------------
  def visible=(visible)
    return if @visible == visible
    @visible = visible
    @text_sprites[@options.index(@selected)].sprite.visible = @visible
  end
  #--------------------------------------------------------------------------
  # * Visible Accessor
  #--------------------------------------------------------------------------
  def visible
    return @visible
  end
end

#==============================================================================
# ** Scene_Gameover
#------------------------------------------------------------------------------
#  This class performs game over screen processing.
#==============================================================================

class Scene_Gameover
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # By default we assume there are no save games.
    @continue_enabled = false
    
    # Loop through the possible save indexes and determine if a save exist.
    #for i in 0..3
      #if FileTest.exist?("Save#{i+1}.rxdata")
        #@continue_enabled = true
      #end
    #end
 @continue_enabled = (0...CPSL::Save_number).any? {|i|FileTest.exist?(CPSL.make_savename(i))}
    
    # The possible options to select.
    s1 = 'Loose 10% of Experience'
    s2 = 'Loose all Held Illyum'
    s3 = 'Loose all in Inventory (non-quest)'
    s4 = 'Loose a Piece of Equipment'
    s5 = 'Exit Game'
    
    # Creating a command rotate object.
    @commands1 = Command_Rotate.new([s1, s2, s3, s4, s5], # Possible options
                          320,     # X Starting point
                          380,     # Y Starting point
                          100,     # Ray to rotate around?
                          0,       # Starting choice
                          40,      # Font size to use
                          'Times New Roman', # Font name to use
                          @continue_enabled ? nil : [0], # Disabled items array.
                          Color.new(255, 0, 0, 108)) # Color of disabled items
    
    # Change the strings to fit the new window.
    s1 = 'Load Game'
    s2 = 'To Titlescreen'
    s3 = 'Shutdown'
    
    # Creating a command rotate object.
    @commands2 = Command_Rotate.new([s1, s2, s3], # Possible options
                          320,     # X Starting point
                          380,     # Y Starting point
                          100,     # Ray to rotate around?
                          0,       # Starting choice
                          40,      # Font size to use
                          'Times New Roman') # Font name to use
    @commands2.visible = false
    
    # Make game over graphic
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.gameover($data_system.gameover_name)    
    # Play game over ME
    $game_system.me_play($data_system.gameover_me)    
    # Execute transition
    Graphics.transition
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      if $scene != self
        break
      end
    end
    
    # Prepare for transition
    Graphics.freeze
    
    # Dispose of Command_Rotate
    @commands1.dispose
    @commands2.dispose
    
    # Dispose of title graphic
    @sprite.bitmap.dispose unless @sprite.bitmap.disposed?
    @sprite.dispose unless @sprite.disposed?
  end
  #--------------------------------------------------------------------------
  # Frame Update
  #--------------------------------------------------------------------------
  def update
    # Update Command_Rotate only if it's visible.
    @commands1.update if @commands1.visible
    @commands2.update if @commands2.visible
    
    # If the initial Command_Rotate is visible.
    if @commands1.visible
      # If C button was pressed
      if Input.trigger?(Input::C)
        # Branch by command window cursor position
        case @commands1.index
        when 0  # Load game
          command_experience
        when 1  # Exit Game
          command_illyum
        when 2
          command_equipment
        when 3
          command_inventory
        when 4
          command_exit
        end
      end
    else
      # If the B button was pressed, go back.
      if Input.trigger?(Input::B)
        @commands1.visible = true
        @commands2.visible = false
      end
      
      # If C button was pressed
      if Input.trigger?(Input::C)
        # Branch by command window cursor position
        case @commands2.index
        when 0  # Load
          command_continue
        when 1  # Title
          command_to_title
        when 2  # Shutdown 
          command_shutdown
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Command: Experience
  #--------------------------------------------------------------------------
  def command_experience
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Switch to map screen
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Command: Illyum
  #--------------------------------------------------------------------------
  def command_illyum
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Switch to map screen
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Command: Equipment
  #--------------------------------------------------------------------------
  def command_equipment
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Switch to map screen
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Command: Inventory
  #--------------------------------------------------------------------------
  def command_inventory
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Switch to map screen
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Command: Continue
  #--------------------------------------------------------------------------
  def command_continue
    # If continue is disabled
    unless @continue_enabled
      # Play buzzer SE
      $game_system.se_play($data_system.buzzer_se)
      return
    end
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Switch to load screen
    $scene = Scene_Loadslot.new
  end
  #--------------------------------------------------------------------------
  # Command: Exit
  #--------------------------------------------------------------------------
  def command_exit
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Alter the viewing of what windows.
    @commands1.visible = false
    @commands2.visible = true
  end
  #--------------------------------------------------------------------------
  # Command: To Titlescreen
  #--------------------------------------------------------------------------
  def command_to_title
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Fade out BGM, BGS, and ME
    Audio.bgm_fade(800)
    Audio.bgs_fade(800)
    Audio.me_fade(800)
    # Shutdown
    $scene = Scene_GYouSure.new
  end  
  #--------------------------------------------------------------------------
  # Command: Shutdown
  #--------------------------------------------------------------------------
  def command_shutdown
    # Play decision SE
    $game_system.se_play($data_system.decision_se)
    # Fade out BGM, BGS, and ME
    Audio.bgm_fade(800)
    Audio.bgs_fade(800)
    Audio.me_fade(800)
    # Shutdown
    $scene =  Scene_GYouSure2.new

  end
end

I am also using Guillame777's Multi-Slot Equipment, here are the 4 scripts:

Spoiler: Module

#==============================================================================
# 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    = [2,6,7,8,9,12,13,14,15,16,17,18,26,27,29,31,33,34,36,38,37,39,40,41,48,55,56,67,69,70,71]             # ids of 2handed weapons
  DOUBLE_ATTACK_WEAPONS = []             # ids of double attack weapons
  NEEDS_OFFHAND         = []  # ids of weapons requiring an offhand
                           
                           
 
  SWITCH_EQUIP_WEAPONS  = [[], []]  # ids of weapons switched when equipped
  SWITCH_EQUIP_ARMORS   = [[], []]  # ids of switched armors(same above)
  # Use 1 array, first value of array = false item, second value = true item 
  #
  # First value in the above arrays is displayed in the weapons/armors you can
  # choose.  When the weapon/armor is chosen, the second id value IS the weapon
  # or armor that you've chosen.  Example:  Trick someone to equip a cursed bow.
 
  #=========Set weapon/armor properties with element tagging and name edit===
  CURSED_STRING = 'Soul Bound'  # 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  = '2-Handed'  # name of string in item name like (2handed)

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

  NEEDS_OFFHAND_STRING = 'Needs an Offhand' #string in item name if the weapon
                                         #needs an offhand like (needs_offhand)
                                         
  #=====Set character slots properties =======================================
  WEAPON_KINDS = [0]                     # number of weapons,  0 = weapon
  WEAPON_KIND_NAMES = ['Weapon']  # 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,8,9,10]
  # 1 = Shield
  # 2 = helmet
  # 3 = armor
  # 4 = acc
  # 5 = and more : extra slot
  EXTRA_SLOT_NAMES = ['Shoulders','Gloves','Boots','Belt','Ring','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     = false  # 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       = 'Times New Roman'      # 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

 

[diablosbud]

It doesn't fit on one post so I will post the next 3 with 2 different posts.

Spoiler: Actor

#==============================================================================
# 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 0...@data.size
      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

 

[diablosbud]

Spoiler: Windows

#==============================================================================
# Multi-slot equipment script 
#------------------------------------------------------------------------------
# Section 3:  Windows
#------------------------------------------------------------------------------
# Guillaume777
# 6.2.1
# 2006/02/14
#==============================================================================
# Enhanced Equipment Window Customization#
      $desired_font = "Times New Roman"
      $desired_font_size = 18
      $desired_arrow_style = "→"
      $color_coded_bonuses = true 
      $stat_goes_up_color = Color.new(0, 200, 0)
      $stat_goes_down_color = Color.new(200, 0, 0)
      $stat_stays_the_same_color = Color.new(150, 150, 150)
      $display_str = [true, 1] # Strength
      $display_dex = [true, 2] # Dexterity
      $display_agi = [true, 3] # Agility
      $display_int = [true, 4] # Intelligence
      $display_atk = [true, 5] # Attack Power
      $display_pdef = [true, 6] # Physical Defense
      $display_mdef = [true, 7] # Magical Defense
      $list_start_y_pos = 25
      $seperation_distance = 15
#ADDED!#
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor : actor
  #--------------------------------------------------------------------------
class Window_EquipLeft < Window_Base
  def initialize(actor)
    super(0, 64, 272, 192)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $desired_font  # "Equip" left side (Status) window font
    self.contents.font.size = $desired_font_size
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_level(@actor, 4, 20)
    if $display_str[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_str[1]), 3)
    end
    if $display_dex[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_dex[1]), 4)
    end
    if $display_agi[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_agi[1]), 5)
    end
    if $display_int[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_int[1]), 6)
    end
    if $display_atk[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_atk[1]), 0)
    end
    if $display_pdef[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 1)
    end
    if $display_mdef[0] == true
      draw_actor_parameter(@actor, 8, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 2)
    end
  
    if @new_str != nil and $display_str[0] == true
      if $color_coded_bonuses == true
        if @new_str > @actor.str
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_str[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_str[1]), 36, 32, @new_str.to_s, 2)
        elsif @new_str == @actor.str
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_str[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_str[1]), 36, 32, @new_str.to_s, 2)
        elsif @new_str < @actor.str
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_str[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_str[1]), 36, 32, @new_str.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_str[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_str[1]), 36, 32, @new_str.to_s, 2)
    end
  end
    if @new_dex != nil and $display_dex[0] == true
      if $color_coded_bonuses == true
        if @new_dex > @actor.dex
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_dex[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_dex[1]), 36, 32, @new_dex.to_s, 2)
        elsif @new_dex == @actor.dex
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_dex[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_dex[1]), 36, 32, @new_dex.to_s, 2)
        elsif @new_dex < @actor.dex
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_dex[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_dex[1]), 36, 32, @new_dex.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_dex[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_dex[1]), 36, 32, @new_dex.to_s, 2)
    end
  end
    if @new_agi != nil and $display_agi[0] == true
      if $color_coded_bonuses == true
        if @new_agi > @actor.agi
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_agi[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_agi[1]), 36, 32, @new_agi.to_s, 2)
        elsif @new_agi == @actor.agi
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_agi[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_agi[1]), 36, 32, @new_agi.to_s, 2)
        elsif @new_agi < @actor.agi
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_agi[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_agi[1]), 36, 32, @new_agi.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_agi[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_agi[1]), 36, 32, @new_agi.to_s, 2)
    end
  end
    if @new_int != nil and $display_int[0] == true
      if $color_coded_bonuses == true
        if @new_int > @actor.int
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_int[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_int[1]), 36, 32, @new_int.to_s, 2)
        elsif @new_int == @actor.int
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_int[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_int[1]), 36, 32, @new_int.to_s, 2)
        elsif @new_int < @actor.int
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_int[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_int[1]), 36, 32, @new_int.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_int[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_int[1]), 36, 32, @new_int.to_s, 2)
    end
  end
    if @new_atk != nil and $display_atk[0] == true
      if $color_coded_bonuses == true
        if @new_atk > @actor.atk
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_atk[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_atk[1]), 36, 32, @new_atk.to_s, 2)
        elsif @new_atk == @actor.atk
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_atk[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_atk[1]), 36, 32, @new_atk.to_s, 2)
        elsif @new_atk < @actor.atk
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_atk[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_atk[1]), 36, 32, @new_atk.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_atk[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_atk[1]), 36, 32, @new_atk.to_s, 2)
    end
  end
    if @new_pdef != nil and $display_pdef[0] == true
      if $color_coded_bonuses == true
        if @new_pdef > @actor.pdef
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 36, 32, @new_pdef.to_s, 2)
        elsif @new_pdef == @actor.pdef
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 36, 32, @new_pdef.to_s, 2)
        elsif @new_pdef < @actor.pdef
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 36, 32, @new_pdef.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_pdef[1]), 36, 32, @new_pdef.to_s, 2)
    end
  end
    if @new_mdef != nil and $display_mdef[0] == true
      if $color_coded_bonuses == true
        if @new_mdef > @actor.mdef
          self.contents.font.color = $stat_goes_up_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 36, 32, @new_mdef.to_s, 2)
        elsif @new_mdef == @actor.mdef
          self.contents.font.color = $stat_stays_the_same_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 36, 32, @new_mdef.to_s, 2)
        elsif @new_mdef < @actor.mdef
          self.contents.font.color = $stat_goes_down_color
          self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 40, 32, $desired_arrow_style, 1)
          self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 36, 32, @new_mdef.to_s, 2)
        end
      elsif
      self.contents.font.color = system_color
      self.contents.draw_text(160, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 40, 32, $desired_arrow_style, 1)
      self.contents.font.color = normal_color
      self.contents.draw_text(200, $list_start_y_pos+($seperation_distance*$display_mdef[1]), 36, 32, @new_mdef.to_s, 2)
    end
  end
  end
  #--------------------------------------------------------------------------
  # * Set parameters after changing equipment
  #     new_atk  : attack power after changing equipment
  #     new_pdef : physical defense after changing equipment
  #     new_mdef : magic defense after changing equipment
  #--------------------------------------------------------------------------
  def set_new_parameters(new_str, new_dex, new_agi, new_int, new_atk, new_pdef, new_mdef)
    if @new_str != new_str or @new_dex != new_dex or @new_agi != new_agi or @new_int != new_int or @new_atk != new_atk or @new_pdef != new_pdef or @new_mdef != new_mdef
      @new_str = new_str
      @new_dex = new_dex
      @new_agi = new_agi
      @new_int = new_int
      @new_atk = new_atk
      @new_pdef = new_pdef
      @new_mdef = new_mdef
      refresh
    end
  end
end
#END ADDED!#
#==============================================================================
# ** 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 nb_old_windows...@actor.armor_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
      # Erase parameters for after equipment change
    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 0...@actor.weapon_slots.size
      # Push the name(s) of the weapon(s)
      @data.push($data_weapons[@actor.weapon_ids[i]])
    end
    for i in 0...@actor.armor_slots.size
      # Push the names of the armors
      @data.push($data_armors[@actor.armor_ids[i]])
    end
    @caption = []
    for i in 0...@actor.weapon_slots.size
      # Push the name(s) of the weapon slots
      @caption.push(@actor.weapon_slot_names[i])
    end
    for i in 0...@actor.armor_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 0...@data.size
      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 0...@actor.weapon_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 0...@actor.armor_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

 

 

[diablosbud]

and, finally

Spoiler: Other

#==============================================================================
# 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

 

[diablosbud]

BUMP!

 

[diablosbud]

BUMP!

 

[diablosbud]

BUMP!