Party Changer

[Dargor]

Party Changer
by Dargor
Version 3.9

Introduction

THIS SCRIPT NOW REQUIRES THE CUSTOM COMMANDS SCRIPT!
---> Custom Commands <---

This is an RMVX version of my Party Changer script! It does not contains all features from my XP Party Changer but I'll add these features gradually.

To call the scene use $scene = Scene_PartyChanger.new

Features
Some features might not work without my Large Party script.

• Supports large party
  
• The party changer is available in battle
  
• You can display an actor's detailed status when pressing SHIFT (It also works in battle!)
  
• It's possible to lock an actor in the party and in the reserve (Refer to the script header for more informations!)
  
• Actors can be forced to be in the party (Yes, it's different than the locked_party feature!)
  
• Actors in the reserve can get a % of the exp earned in battle
  
• Party Changer and Party Arrange are available in the Main Menu
  
• On-map Party Switcher
  
• Support for multiple parties
  

You will need an icon named locked.png in the Graphics\System directory.
Be sure to IMPORT the icon with the Materialbase.


Screenshots



Script

Code:

#==============================================================================
# ** Party Changer
#------------------------------------------------------------------------------
#  © Dargor, 2008-2009
#  23/03/09
#  Version 3.9
#------------------------------------------------------------------------------
#  VERSION HISTORY:
#   - 1.0   (08/03/08), Initial release
#   - 1.1   (08/03/08), The party Changer is now available in battle
#   - 1.2   (09/03/08), A member detail window has been added(hold SHIFT)
#   - 1.3   (09/03/08), Members can be locked in the party/reserve
#   - 1.4   (09/03/08), Actors can be forced to be in the party
#             (and yes, it's different than the locked_party feature!)
#   - 1.5   (09/03/08), Reserve Actors can gain a % of the exp earned
#   - 1.5.1 (09/03/08), Graphic bug fixed with the reserve window
#   - 1.6   (09/03/08), Now compatible with Custom Commands script
#   - 1.7   (09/03/08), The party changer is available in the main menu
#   - 1.8   (09/03/08), Party Order is available in the main menu
#   - 1.9   (15/03/08), Party Changer variables now belong to Game_System
#   - 1.9.1 (15/03/08), Graphic bug fixed with the battle reserve window
#   - 1.9.2 (16/03/08), Leading character updated with party order
#   - 1.9.3 (25/03/08), Bug fixed with party and reserve status windows
#   - 1.9.4 (08/05/08), Now works with the Commands 'Selection' method
#   - 2.0   (08/05/08), Script Restructuration  
#   - 2.1   (11/05/08), Added an on-map party switcher (Use with L/R)
#   - 2.2   (24/05/08), Bug fixed with characters opacity
#   - 2.3   (25/05/08), Menu index fixed
#   - 2.4   (01/07/08), Bug fixed with Bitmap creation
#   - 3.0   (04/07/08), Script Restructuration
#   - 3.1   (04/07/08), Added support for Multiple Parties
#   - 3.2   (30/08/08), Freeze has been fixed with the reset command
#   - 3.3   (30/08/08), The double "Order" decision sound has been fixed
#   - 3.4   (30/08/08), The party changer commands have been moved to the
#                       System initialization instead of the scenes
#                       initialization.
#   - 3.5   (15/10/08), Bug fixed with Forced Party/Party Locked actors
#   - 3.6   (17/02/09), Added a configuration module
#   - 3.7   (25/02/09), Added a Custom Commands configuration module specific
#                       to the party changer. Mainly to add command icons
#   - 3.8   (16/03/09), Fixed the "Forced Party" feature not adding members to
#                       the party window
#   - 3.9   (23/03/09), Automatically place the first alive character in the
#                       party as the lead character
#------------------------------------------------------------------------------
#  Instructions:
#     1)  Place this script below the Custom Commands script and after
#           the Large Party script
#     2)  To call the scene, use $scene = Scene_PartyChanger.new
#     3)  To enable/disable the party changer in battle, use:
#             - $game_system.battle_party_changer = true/false
#     4)  To force an actor to be in the party, use:
#             - $game_system.forced_party = [actor1_id,actor2_id, etc.]
#           NOTE: When an actor is included in this array, his party_locked
#                 flag will automatically be set to true.
#     5)  You must import the 'locked' icon into the
#           system folder and name it locked.png
#     6)  To lock an actor in the party, use :
#             - $game_actors[actor_id].party_locked = true/false
#     7)  To lock an actor in the reserve, use :
#             - $game_actors[actor_id].reserve_locked = true/false
#     8)  To change the % of exp gained by actors in the reserve, use :
#             - $game_actors[actor_id].reserve_exp_rate = x (percent)
#     9)  To display detailed status of a member, press SHIFT when a
#           member is selected. Also available in battle.
#     10) Use L/R (PageUP/PageDOWN) to cycle through party actors on map
#     11) You can enable/disable the on-map party switcher by using
#             - $game_system.map_party_switcher = true/false
#==============================================================================

# Vocabulary
Vocab::Party = 'Party'
Vocab::PartyAccept = 'Accept'
Vocab::PartyOrder = 'Order'
Vocab::PartyReset = 'Reset'

#==============================================================================
# ** Party Changer Configuration Module
#==============================================================================

module Party_Changer
  # Menu/Battle Party Changer access
  Menu_Party_Changer = true
  Battle_Party_Changer = true
  # Have Party Order option in the main menu?
  Menu_Party_Order = true
  # Can switch party members directly on map? (Use L/R)
  Map_Party_Switcher = true
  # Default EXP rate gained by members in the reserve
  Reserve_EXP_Rate = 30
end

#==============================================================================
# ** Custom Commands Configuration Module (Specific to Party Changer)
#==============================================================================

module Custom_Commands
  # Create Party Changer command icons
  Party_Changer_Icons = {
                          # party changer
                          Vocab::Party => 100,
                          Vocab::PartyAccept => 101,
                          Vocab::PartyOrder => 102,
                          Vocab::PartyReset => 103
          }
  # Merge Party Changer command icons with Custom Commands icons
  Icons.merge!(Party_Changer_Icons)
end

#==============================================================================
# ** Array
#==============================================================================

class Array
  #--------------------------------------------------------------------------
  # * Roll
  #--------------------------------------------------------------------------
  def roll
    return nil if empty?
    return self if size == 1
    insert size, self[0]
    delete_at(0)
    return self
  end
  #--------------------------------------------------------------------------
  # * Unroll
  #--------------------------------------------------------------------------
  def unroll
    return nil if empty?
    return self if size == 1
    insert 0, self[size - 1]
    delete_at(size - 1)
    return self
  end
end

#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles system-related data. Also manages vehicles and BGM, etc.
# The instance of this class is referenced by $game_system.
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :menu_party_changer
  attr_accessor :battle_party_changer
  attr_accessor :map_party_switcher
  attr_accessor :menu_party_order
  attr_accessor :forced_party
  attr_accessor :reserve_exp_rate
  attr_accessor :multiple_parties
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_vx_temp_party_changer_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    dargor_vx_temp_party_changer_initialize
    @menu_party_changer = Party_Changer::Menu_Party_Changer
    @battle_party_changer = Party_Changer::Battle_Party_Changer
    @menu_party_order = Party_Changer::Menu_Party_Order
    @map_party_switcher = Party_Changer::Map_Party_Switcher
    @forced_party = []
    @reserve_exp_rate = Party_Changer::Reserve_EXP_Rate
    @multiple_parties = false
    index = @menu_commands.index(Vocab::save)
    add_menu_command(index, Vocab::Party) if @menu_party_changer
    add_menu_command(index, Vocab::PartyOrder) if @menu_party_order
    index = @party_commands.index(Vocab::fight) + 1
    add_party_command(index, Vocab::Party) if @battle_party_changer
  end
  #--------------------------------------------------------------------------
  # * Battle Party Changer
  #--------------------------------------------------------------------------
  def battle_party_changer?
    return @battle_party_changer == true && $game_party.reserve_members.size > 0
  end
end

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :party_locked
  attr_accessor :reserve_locked
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_party_changer_actor_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(actor_id)
    dargor_party_changer_actor_initialize(actor_id)
    @party_locked = false
    @reserve_locked = false
  end
end

#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
#  This class handles the party. It includes information on amount of gold
# and items. The instance of this class is referenced by $game_party.
#==============================================================================

class Game_Party < Game_Unit
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :actors
  attr_accessor :reserve_actors
  attr_accessor :temp_actors
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_vx_party_changer_party_initialize initialize
  alias dargor_vx_party_add_actor add_actor
  alias dargor_vx_party_remove_actor remove_actor
  alias dargor_vx_party_setup_starting_members setup_starting_members
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    dargor_vx_party_changer_party_initialize
    @reserve_actors = []
    @temp_actors = []
  end
  #--------------------------------------------------------------------------
  # * Roll Actors
  #--------------------------------------------------------------------------
  def roll_actors
    return unless $game_system.map_party_switcher
    @actors.roll
  end
  #--------------------------------------------------------------------------
  # * Unroll Actors
  #--------------------------------------------------------------------------
  def unroll_actors
    return unless $game_system.map_party_switcher
    @actors.unroll
  end
  #--------------------------------------------------------------------------
  # * Initial Party Setup
  #--------------------------------------------------------------------------
  def setup_starting_members
    dargor_vx_party_setup_starting_members
    for i in $data_system.party_members
      add_reserve_actor(i)
      if $game_parties != nil
        $game_parties.add_actor(i)
        $game_parties.add_reserve_actor(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Get Reserve Members
  #--------------------------------------------------------------------------
  def reserve_members
    result = []
    for i in @reserve_actors
      result.push($game_actors[i])
    end
    return result.uniq
  end
  #--------------------------------------------------------------------------
  # * Get All Members
  #--------------------------------------------------------------------------
  def all_members
    all_actors = (@actors + @reserve_actors).sort
    array = []
    for i in all_actors
      array << $game_actors[i]
    end
    return array.uniq
  end
  #--------------------------------------------------------------------------
  # * Add an Actor
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  def add_actor(actor_id)
    add_reserve_actor(actor_id)
    if $game_parties != nil
      $game_parties.add_actor(actor_id)
      $game_parties.add_reserve_actor(actor_id)
    end
    dargor_vx_party_add_actor(actor_id)
  end
  #--------------------------------------------------------------------------
  # * Add an Actor to the Reserve
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  def add_reserve_actor(actor_id, forced=false)
    if forced
      @reserve_actors.push(actor_id)
      if $game_parties != nil
        $game_parties.add_reserve_actor(actor_id)
      end
      $game_player.refresh
      return
    end
    if @actors.size == MAX_MEMBERS and not @reserve_actors.include?(actor_id)
      @reserve_actors.push(actor_id)
      if $game_parties != nil
        $game_parties.add_reserve_actor(actor_id)
      end
      $game_player.refresh
    end
    unless @reserve_actors.include?(actor_id)
      @reserve_actors.push(actor_id)
      if $game_parties != nil
        $game_parties.add_reserve_actor(actor_id)
      end
      $game_player.refresh
    end
  end
  #--------------------------------------------------------------------------
  # * Remove Actor from the Reserve
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  def remove_reserve_actor(actor_id)
    @reserve_actors.delete(actor_id)
    $game_player.refresh
    if $game_parties != nil
      $game_parties.remove_reserve_actor(actor_id)
    end
  end
  #--------------------------------------------------------------------------
  # * Get members forced in the party
  #--------------------------------------------------------------------------
  def forced_members
    array = []
    for i in $game_system.forced_party
      $game_actors[i].party_locked = true
      array << $game_actors[i]
    end
    return array.uniq
  end
  #--------------------------------------------------------------------------
  # * Get Array of All Living Members
  #--------------------------------------------------------------------------
  def existing_reserve_members
    result = []
    for battler in reserve_members
      next unless battler.exist?
      result.push(battler)
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Get Array of All Living Members
  #--------------------------------------------------------------------------
  def all_existing_members
    result = []
    for battler in members + reserve_members
      next unless battler.exist?
      result.push(battler)
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Clear Temporary Actors Array
  #--------------------------------------------------------------------------
  def clear_temp_actors
    @temp_actors = []
  end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles maps. It includes event starting determinants and map
# scrolling functions. The instance of this class is referenced by $game_map.
#==============================================================================

class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_vx_party_changer_player_update update
  alias dargor_vx_party_changer_player_refresh refresh
  #--------------------------------------------------------------------------
  # * Update Party Switching (On Map)
  #--------------------------------------------------------------------------
  def update_party_switching
    return if $game_party.members.empty? or $game_party.members.size == 1
    $game_party.roll_actors while $game_party.members[0].dead?
    $game_party.roll_actors if Input.trigger?(Input::L) or Input.repeat?(Input::L)
    $game_party.unroll_actors if Input.trigger?(Input::R) or Input.repeat?(Input::R)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    $game_party.roll_actors while $game_party.members[0].dead?
    dargor_vx_party_changer_player_refresh
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    update_party_switching
    dargor_vx_party_changer_player_update
  end
end


#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This is a superclass of all windows in the game.
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Remake Window Contents
  #--------------------------------------------------------------------------
  def remake_contents(width, height)
    self.width = width
    self.height = height
    create_contents
  end
  #--------------------------------------------------------------------------
  # * Draw Lock Graphic
  #--------------------------------------------------------------------------
  def draw_lock(x,y)
    bitmap = Cache.system("Locked")
    self.contents.blt(x, y, bitmap, bitmap.rect)
  end
  #--------------------------------------------------------------------------
  # * Draw Actor Walking Graphic
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_graphic(actor, x, y, opacity = 255)
    draw_character(actor.character_name, actor.character_index, x, y, opacity)
  end
  #--------------------------------------------------------------------------
  # * Draw Character Graphic
  #     character_name  : Character graphic filename
  #     character_index : Character graphic index
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_character(character_name, character_index, x, y, opacity = 255)
    return if character_name == nil
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = character_index
    src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
    self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, opacity)
  end
end

#==============================================================================
# ** Window_Party
#------------------------------------------------------------------------------
#  This window displays party member status on the party changer screen.
#==============================================================================

class Window_PartyMembers < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :members
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 272, 416)
    @members = []
    for i in 1..$data_actors.size
      actor = $game_actors[i]
      next if actor.nil?
      $game_system.forced_party << actor.id if actor.party_locked
    end
    for member in $game_party.forced_members
      add_member(member)
    end
    @selection_rect = false
    @selection_y = 0
    refresh
    self.active = false
    self.index = -1
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = @members.size
    if @selection_rect
      color = Color.new(0,0,0,160)
      self.contents.fill_rect(2, @selection_y, contents.width-4, 92, color)
    end
    i = 0
    for actor in @members
      x = 104
      y = i * 96 + WLH / 2 + 10
      draw_actor_face(actor, 2, i * 96 + 2, 92)
      draw_lock(x-16,y-20) if actor.party_locked
      draw_actor_name(actor, x, y - WLH)
      draw_actor_level(actor, x, y)
      draw_actor_hp(actor, x, y + WLH * 1)
      draw_actor_mp(actor, x, y + WLH * 2)
      i += 1
    end
  end
  #--------------------------------------------------------------------------
  # * Add Member
  #--------------------------------------------------------------------------
  def add_member(member)
    return if @members.include?(member)
    @members.push(member)
    @item_max = @members.size
    if $game_system.multiple_parties
      party = $game_parties
    else
      party = $game_party
    end
    party.temp_actors.push(member.id)
    w = self.width
    h = self.height = 416 + (96 * (@members.size-4))
    remake_contents(w, h)
    self.height = 416
    refresh
  end
  #--------------------------------------------------------------------------
  # * Remove Member
  #--------------------------------------------------------------------------
  def remove_member(member)
    unless $game_party.forced_members.include?(member)
      @members.delete(member)
      if $game_system.multiple_parties
        party = $game_parties
      else
        party = $game_party
      end
      party.temp_actors.delete(member.id)
    end
    self.height = 416 + [(96 * (@members.size-4)), 0].min
    @item_max = [$game_party.forced_members.size, 1].max
    remake_contents(self.width, self.height)
    self.height = 416
    refresh
  end
  #--------------------------------------------------------------------------
  # * Clear Members
  #--------------------------------------------------------------------------
  def clear_members
    for member in $game_party.all_members
      remove_member(member)
    end
  end
  #--------------------------------------------------------------------------
  # * Set Selection Rect
  #--------------------------------------------------------------------------
  def set_selection_rect(index)
    @selection_rect = true
    @selection_y = index * 96 - WLH / 2 + 14
    refresh
  end
  #--------------------------------------------------------------------------
  # * Clear Selection Rect
  #--------------------------------------------------------------------------
  def clear_selection_rect
    @selection_rect = false
    refresh
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get top row
    row = @index  / @column_max
    if row < self.top_row
      self.top_row = row
    end
    # Reset Top Row if at bottom of list
    if row > self.top_row + (self.page_row_max - 1)
      self.top_row = row - (self.page_row_max - 1)
    end
    y = @index / @column_max * 96 - self.oy
    # Draw the cursor
    self.cursor_rect.set(0, y, contents.width, 96)
  end
  #--------------------------------------------------------------------------
  # * Get Top Row
  #--------------------------------------------------------------------------  
  def top_row
    return self.oy / 96
  end
  #--------------------------------------------------------------------------
  # * Set Top Row
  #     row : row shown on top
  #--------------------------------------------------------------------------  
  def top_row=(row)
    if row < 0
      row = 0
    end
    if row > row_max - 1
      row = row_max - 1
    end
    self.oy = row * 96
  end
  #--------------------------------------------------------------------------
  # * Get Number of Rows Displayable on 1 Page
  #--------------------------------------------------------------------------  
  def page_row_max
    return 4
  end
end

#==============================================================================
# ** Window_ReserveMembers
#------------------------------------------------------------------------------
#  This window displays reserve members on the party changer screen.
#==============================================================================

class Window_ReserveMembers < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :members
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize
    if $game_system.multiple_parties
      @members = $game_parties.all_members.dup
    else
      @members = $game_party.all_members.dup
    end
    height =  64 * (@members.size.to_f / 4).ceil
    height = [[height, 96].max, height].max
    super(272, 128, 272, height)
    @item_max = @members.size
    @column_max = 4
    @row_max = (@members.size.to_f / 4).ceil
    refresh
    self.height = 128
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    for i in 0...@members.size
      draw_member(i)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Member
  #--------------------------------------------------------------------------
  def draw_member(index)
    member = @members[index]
    if $game_system.multiple_parties
      party = $game_parties
    else
      party = $game_party
    end
    if member.reserve_locked or member.party_locked or
        party.temp_actors.include?(member.id)
      opacity = 160
    else
      opacity = 255
    end
    x = 24 + index % 4 * 60
    y = 40 + index / 4 * 48
    draw_actor_graphic(member,x,y,opacity)
    draw_lock(x + 8,y - 8) if member.reserve_locked
  end
  #--------------------------------------------------------------------------
  # * Set Member
  #--------------------------------------------------------------------------
  def set_member(index, member)
    @members[index] = member
    draw_member(index)
  end
  #--------------------------------------------------------------------------
  # * Reset Members
  #--------------------------------------------------------------------------
  def reset_members
    if $game_system.multiple_parties
      @members = $game_parties.all_members.dup
    else
      @members = $game_party.all_members.dup
    end
    refresh
  end
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    x = @index % 4 * 60
    y = @index / 4 * 48
    y -= self.oy
    if @index < 0               # No cursor
      self.cursor_rect.empty
    elsif @index < @item_max    # Normal
      self.cursor_rect.set(x, y, 48, 48)
    end
    # Get top row
    row = @index  / @column_max
    if row < self.top_row
      self.top_row = row
    end
    # Reset Top Row if at bottom of list
    if row > self.top_row + (self.page_row_max - 1)
      self.top_row = row - (self.page_row_max - 1)
    end
  end
  #--------------------------------------------------------------------------
  # * Get Top Row
  #--------------------------------------------------------------------------  
  def top_row
    return self.oy / 48
  end
  #--------------------------------------------------------------------------
  # * Set Top Row
  #     row : row shown on top
  #--------------------------------------------------------------------------  
  def top_row=(row)
    if row < 0
      row = 0
    end
    if row > row_max - 1
      row = row_max - 1
    end
    self.oy = row * 48
  end
  #--------------------------------------------------------------------------
  # * Get Number of Rows Displayable on 1 Page
  #--------------------------------------------------------------------------  
  def page_row_max
    return 2
  end
end

#==============================================================================
# ** Window_MemberStatus
#------------------------------------------------------------------------------
#  This window displays a member's status on the party changer screen.
#==============================================================================

class Window_MemberStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     x : window X coordinate
  #     y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize
    super(272, 0, 272, 128)
    @member = nil
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    return if @member.nil?
    actor = @member
    x = 104
    draw_actor_face(actor, 2, 2, 92)
    draw_actor_name(actor, x, 0)
    draw_actor_level(actor, x, WLH)
    draw_actor_hp(actor, x, WLH * 2)
    draw_actor_mp(actor, x, WLH * 3)
  end
  #--------------------------------------------------------------------------
  # * Set Member
  #--------------------------------------------------------------------------
  def set_member(member)
    @member = member
    refresh
  end
end

#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  This window displays the status of all party members on the battle screen.
#==============================================================================

class Window_BattlePartyMembers < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :members
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    @members = $game_party.reserve_members - $game_party.members
    height = 32 + (24 * @members.size)
    super(64, 0, 416, height)
    refresh
    self.height = 128
    self.active = false
    self.index = 0
    self.openness = 0
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    super
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = @members.size
    for i in 0...@item_max
      draw_item(i)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : Item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    actor = @members[index]
    opacity = actor.reserve_locked ? 160 : 255
    draw_actor_graphic(actor, 16, rect.y + 32, opacity)
    draw_lock(x-30,rect.y+6) if actor.reserve_locked
    draw_actor_name(actor, 32, rect.y)
    draw_actor_hp(actor, 174, rect.y, 120)
    draw_actor_mp(actor, 310, rect.y, 70)
  end
  #--------------------------------------------------------------------------
  # * Reset Members
  #--------------------------------------------------------------------------
  def reset_members
    @members = $game_party.reserve_members - $game_party.members
    height = 32 + (24 * @members.size)
    remake_contents(416,height)
    refresh
    self.height = 128
  end
end

#==============================================================================
# ** Window_MemberDetails
#------------------------------------------------------------------------------
#  This window displays full status specs on the party changer screen.
#==============================================================================

class Window_MemberDetails < Window_Status
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor : actor
  #--------------------------------------------------------------------------
  def initialize
    super(nil)
    self.width = 472
    self.height = 312
    create_contents
    @actor = nil
    refresh
    self.x = 272 - width/2
    self.y = 208 - height/2
    self.openness = 0
    self.back_opacity = 255
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    return if @actor.nil?
    draw_actor_name(@actor, 4, 0)
    draw_actor_class(@actor, 128, 0)
    draw_actor_face(@actor, 8, 32)
    draw_basic_info(128, 32)
    draw_parameters(24, 136)
    draw_exp_info(252, 0)
    draw_equipments(200, 136)
  end
  #--------------------------------------------------------------------------
  # * Set Member
  #--------------------------------------------------------------------------
  def set_member(member)
    @actor = member
    refresh
  end
end

#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  This window displays the status of all party members on the battle screen.
#==============================================================================

class Window_BattleStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :show_lock
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_vx_party_changer_initialize initialize
  alias dargor_vx_party_changer_draw_item draw_item
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    dargor_vx_party_changer_initialize
    @show_lock = false
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     index : Item number
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    dargor_vx_party_changer_draw_item(index)
    actor = $game_party.members[index]
    draw_lock(0,rect.y+11) if actor.party_locked and @show_lock
  end
end

#==============================================================================
# ** Scene_PartyChanger
#------------------------------------------------------------------------------
#  This class performs the Party Changer screen processing.
#==============================================================================

class Scene_PartyChanger < Scene_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(from_menu = false, from_party = false)
    @from_menu = from_menu
    @from_party = from_party
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    create_command_window
    create_help_window
    if $game_system.multiple_parties
      party = $game_parties
      for actor_id in $game_party.actors
        $game_parties.temp_actors.delete(actor_id)
      end
    else
      party = $game_party
      party.clear_temp_actors
    end
    @party_window = Window_PartyMembers.new
    @reserve_window = Window_ReserveMembers.new
    # Make Status Window
    @status_window = Window_MemberStatus.new
    member = @reserve_window.members[@reserve_window.index]
    @status_window.set_member(member)
    # Make Detail Window
    @detail_window = Window_MemberDetails.new
    member = @reserve_window.members[@reserve_window.index]
    @detail_window.set_member(member)
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @party_window.dispose
    @reserve_window.dispose
    @command_window.dispose
    @status_window.dispose
    @help_window.dispose
    @detail_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Create Help Window
  #--------------------------------------------------------------------------
  def create_help_window
    @help_window = Window_Help.new
    @help_window.x = 272
    @help_window.y = 416 - 56
    @help_window.width = 272
    @help_window.create_contents
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    s1 = Vocab::PartyAccept
    s2 = Vocab::PartyOrder
    s3 = Vocab::PartyReset
    @command_window = Window_Command.new(160, [s1, s2, s3])
    @command_window.index = 0
    @command_window.x = 272
    @command_window.y = 256
    @command_window.width = 272
    @command_window.active = false
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    update_help
    if @reserve_window.active
      @old_index = @reserve_window.index
    elsif @party_window.active
      @old_index = @party_window.index
    end
    @command_window.update
    @party_window.update
    @reserve_window.update
    @status_window.update
    @help_window.update
    @detail_window.update
    if can_display_status?
      if @reserve_window.active
        member = @reserve_window.members[@reserve_window.index]
      elsif @party_window.active
        member = @party_window.members[@party_window.index]
      end
      @status_window.set_member(member)
      @detail_window.set_member(member)
    end
    if Input.press?(Input::SHIFT)
      @detail_window.open
    else
      @detail_window.close
    end
    if @command_window.active
      update_command_selection
      return
    end
    if @party_window.active
      update_party_selection
      return
    end
    if @reserve_window.active
      update_reserve_selection
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Can Display Status?
  #--------------------------------------------------------------------------
  def can_display_status?
    if @reserve_window.active
      return @reserve_window.index != @old_index
    elsif @party_window.active
      return @party_window.index != @old_index
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Help Window
  #--------------------------------------------------------------------------
  def update_help
    if @party_window.active
      @help_window.set_text('Arrange position')
    end
    if @reserve_window.active
      @help_window.set_text('Form your party')
    end
    if @command_window.active
      case @command_window.selection
      when Vocab::PartyAccept
        @help_window.set_text('Accept selection')
      when Vocab::PartyOrder
        @help_window.set_text('Arrange position')
      when Vocab::PartyReset
        @help_window.set_text('Reset selection')
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Party Window
  #--------------------------------------------------------------------------
  def update_party_selection
    # Jump back to the command window
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @party_window.active = false
      @party_window.index = -1
      @command_window.active = true
      @party_window.clear_selection_rect
      @member1 = nil
      @member2 = nil
      return
    end
    # Arrange selection
    if Input.trigger?(Input::C)
      Sound.play_decision
      # Create first member variable
      if @member1.nil?
        @member1 = @party_window.members[@party_window.index]
        if @member1.party_locked
          @member1 = nil
          return
        end
        @member1_index = @party_window.index
        @party_window.set_selection_rect(@member1_index)
        return
      end
      # Create second member variable
      if @member2.nil?
        @member2 = @party_window.members[@party_window.index]
        if @member2.party_locked
          @member2 = nil
          return
        end
        @member2_index = @party_window.index
        # Exchange members if they are not the same
        if @member1 != @member2
          @party_window.members[@member1_index] = @member2
          @party_window.members[@member2_index] = @member1
        end
        @party_window.clear_selection_rect
        @member1 = nil
        @member2 = nil
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Reserve Window
  #--------------------------------------------------------------------------
  def update_reserve_selection
    # Jump back to the command window if there's at least 1 actor in the party
    if Input.trigger?(Input::B) and @party_window.members.size > 0
      Sound.play_cancel
      @reserve_window.active = false
      @command_window.active = true
      return
    end
    # Add actor to the party
    if Input.trigger?(Input::C)
      if $game_system.multiple_parties
        actor_id = @reserve_window.members[@reserve_window.index].id
        if @reserve_window.members[@reserve_window.index].reserve_locked or
           $game_parties.temp_actors.include?(actor_id)
          Sound.play_buzzer
          return
        end
      else
        if @reserve_window.members[@reserve_window.index].reserve_locked
          Sound.play_buzzer
          return
        end
      end
      Sound.play_decision
      member = @reserve_window.members[@reserve_window.index]
      @party_window.add_member(member)
      @reserve_window.refresh
    end
    # Jump to command window if the party is full
    if @party_window.members.size == $game_party.max_members
      @command_window.active = true
      @reserve_window.active = false
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Command Window
  #--------------------------------------------------------------------------
  def update_command_selection
    if Input.trigger?(Input::C)
      Sound.play_decision
      case @command_window.selection
      # Accept Selection
      when Vocab::PartyAccept
        $game_party.actors.clear
        for member in @party_window.members + @reserve_window.members
          if @party_window.members.include?(member)
            $game_party.add_actor(member.id)
          end
          $game_party.add_reserve_actor(member.id, true)
          if $game_parties != nil
            $game_parties.add_reserve_actor(member.id)
          end
        end
        $game_player.refresh
        if @from_party
          $scene = Scene_Parties.new
          $game_party = $game_parties[0]
          return
        elsif @from_menu
          index = $game_system.menu_commands.index(Vocab::Party)
          $scene = Scene_Menu.new(index)
          return
        else
          $scene = Scene_Map.new
          return
        end
      # Order Selection
      when Vocab::PartyOrder
        @party_window.index = 0
        @party_window.active = true
        @command_window.active = false
      # Reset Selection  
      when Vocab::PartyReset
        @party_window.clear_members
        @party_window.clear_selection_rect
        @reserve_window.reset_members
        @reserve_window.active = true
        @command_window.active = false
      end
    end
  end
end

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_vx_party_changer_battle_start start
  alias dargor_vx_party_changer_battle_create_info_viewport create_info_viewport
  alias dargor_vx_party_changer_battle_update update
  alias dargor_vx_party_changer_battle_update_basic update_basic
  alias dargor_vx_party_changer_battle_update_party_command_selection update_party_command_selection
  alias dargor_vx_party_changer_battle_display_level_up display_level_up
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    dargor_vx_party_changer_battle_start
    @party_viewport = Viewport.new(0,0,544,416)
    @party_viewport.z = 200
    @party_window = Window_BattlePartyMembers.new
    @party_window.viewport = @party_viewport
    @detail_window = Window_MemberDetails.new
    @detail_window.viewport = @party_viewport
    @old_index = 0
  end
  #--------------------------------------------------------------------------
  # * Create Information Display Viewport
  #--------------------------------------------------------------------------
  def create_info_viewport
    commands = $game_system.party_commands
    dargor_vx_party_changer_battle_create_info_viewport
    index = commands.index(Vocab::Party)
    @party_command_window.draw_item(index, $game_system.battle_party_changer?)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    unless @party_window.active or @status_window.active
      dargor_vx_party_changer_battle_update
    else
      super
      update_basic(true)
      update_info_viewport                  # Update information viewport
      if $game_message.visible
        @info_viewport.visible = false
        @message_window.visible = true
      end
      unless $game_message.visible          # Unless displaying a message
        return if judge_win_loss            # Determine win/loss results
        update_scene_change
        if @party_window.active or @status_window.active
          update_party_changer_selection    # Select party changer command
          return
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Basic Update Processing
  #     main : Call from main update method
  #--------------------------------------------------------------------------
  def update_basic(main = false)
    dargor_vx_party_changer_battle_update_basic(main)
    @party_window.update
    @detail_window.update
  end
  #--------------------------------------------------------------------------
  # * Update Party Command Selection
  #--------------------------------------------------------------------------
  def update_party_command_selection
    dargor_vx_party_changer_battle_update_party_command_selection
    if Input.trigger?(Input::C)
      case $game_system.party_commands[@party_command_window.index]
      when Vocab::Party  # Party Changer
        if $game_system.battle_party_changer? == false
          Sound.play_buzzer
          return
        end
        Sound.play_decision
        process_party
      end
    end
    #--------------------------------------------------------------------------
    # * Process Party
    #--------------------------------------------------------------------------
    def process_party
      @status_window.active = true
      @status_window.index = @actor_index = 0
      @party_command_window.active = false
      @party_window.open
      @status_window.active = true
      @status_window.show_lock = true
      @status_window.refresh
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update : Party Selection
  #--------------------------------------------------------------------------
  def update_party_changer_selection
    if Input.press?(Input::SHIFT)
      @detail_window.open
    else
      @detail_window.close
    end
    if @status_window.active
      member = $game_party.members[@status_window.index]
      if @old_index != @status_window.index
        @party_window.members[@party_window.index]
        @detail_window.set_member(member)
      end    
      if Input.trigger?(Input::B)
        @party_command_window.active = true
        @status_window.index = -1
        @status_window.active = false
        @status_window.show_lock = false
        @status_window.refresh
        @party_window.close
        return
      end
      if Input.trigger?(Input::C)
        actor_id = $game_party.actors[@status_window.index]
        if $game_actors[actor_id].party_locked
          Sound.play_buzzer
          return
        end
        Sound.play_decision
        @party_window.index = 0
        @party_window.active = true
        @status_window.active = false
        return
      end
      @old_index = @status_window.index
    end
    if @party_window.active
      member = @party_window.members[@party_window.index]
      if @old_index != @party_window.index
        @detail_window.set_member(member)
      end
      if Input.trigger?(Input::B)
        @status_window.active = true
        @party_window.active = false
        return
      end
      if Input.trigger?(Input::C)
        new_actor = @party_window.members[@party_window.index]
        old_actor = $game_party.actors[@status_window.index]
        if new_actor.nil? or new_actor.reserve_locked
          Sound.play_buzzer
          return
        end
        $game_party.add_reserve_actor(old_actor, true)
        if $game_parties != nil
          $game_parties.add_reserve_actor(old_actor)
        end
        Sound.play_decision
        $game_party.actors[@status_window.index] = new_actor.id
        @party_window.members.delete(new_actor)
        @party_window.reset_members
        @status_window.refresh
        return
      end
      @old_index = @party_window.index
    end
  end
  #--------------------------------------------------------------------------
  # * Display Level Up
  #--------------------------------------------------------------------------
  def display_level_up
    exp = ($game_troop.exp_total / 100) * $game_system.reserve_exp_rate
    for actor in $game_party.existing_reserve_members
      actor.gain_exp(exp, true)
    end
    dargor_vx_party_changer_battle_display_level_up
  end
end

#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  This class performs the menu screen processing.
#==============================================================================

class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # * Alias Listing
  #--------------------------------------------------------------------------
  alias dargor_vx_party_changer_menu_create_command_window create_command_window
  alias dargor_vx_party_changer_menu_update_command_selection update_command_selection
  alias dargor_vx_party_changer_menu_update_actor_selection update_actor_selection
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    commands = $game_system.menu_commands
    dargor_vx_party_changer_menu_create_command_window
    index = commands.index(Vocab::Party)
    if $game_system.menu_party_changer == false # If party changer is forbidden
      @command_window.draw_item(index, false)     # Disable party changer
    end
    index = commands.index(Vocab::PartyOrder)
    if $game_system.menu_party_order == false # If party order is forbidden
      @command_window.draw_item(index, false)     # Disable party arrange
    end
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    command = @command_window.selection
    if $game_system.menu_party_changer == false and command == Vocab::Party
      Sound.play_buzzer
      return
    end
    dargor_vx_party_changer_menu_update_command_selection
    if Input.trigger?(Input::C)
      case @command_window.selection
      when Vocab::Party
        $scene = Scene_PartyChanger.new(true)
      when Vocab::PartyOrder
        start_actor_selection
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_actor_selection
    if Input.trigger?(Input::B)
      @status_window.clear_selection_rect
    end
    if Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      case @command_window.selection
      when Vocab::PartyOrder  # skill
        # Create first member variable
        if @member1.nil?
          @member1 = $game_party.members[@status_window.index]
          if @member1.party_locked
            @member1 = nil
            return
          end
          @member1_index = @status_window.index
          @status_window.set_selection_rect(@member1_index)
          return
        end
        # Create second member variable
        if @member2.nil?
          @member2 = $game_party.members[@status_window.index]
          if @member2.party_locked
            @member2 = nil
            return
          end
          @member2_index = @status_window.index
          # Exchange members if they are not the same
          if @member1 != @member2
            $game_party.actors[@member1_index] = @member2.id
            $game_party.actors[@member2_index] = @member1.id
          end
          @status_window.clear_selection_rect
          @status_window.refresh
          @member1 = nil
          @member2 = nil
          $game_player.refresh
          return
        end
      end
    end
    dargor_vx_party_changer_menu_update_actor_selection
  end
end

Demo

http://www.mediafire.com/?5njd1k6myxw

Notes

This script must now be used with the Custom Commands script.
All Party Changer variables now belong to Game_System (instead of Game_Temp)

Hope you like it!
-Dargor