[REQUEST][XP] Script Merger

[XaineC]

I have two scripts that I want to use in my project, however I'm not adept enough at scripting to mix the two together.
The two scripts I need to merge are:

LeonWestbrooke's Party Changer

Code Select Expand

#===================================
#  Party Changing System by Leon_Westbrooke
#   -v 1.2
#----------------------------------------------------------------------
#  Instructions:  Place above main, but below all other default scripts.
# 
#  Features: 
#    -Allows the player to make a party from the minimum to maximum size.
#    -Extra members are limitless.
#    -You can remove a person from the party and put it into reserve using:
#       $game_party.remove_actor_to_party(actor_id)
#    -You can remove a person from the reserve if they exist, and them into
#     the party:
#       $game_party.add_actor_to_party(actor_id)
#    -You can lock a character in reserve or active party by using:
#       $game_party.locked.push(actor_id)
#    -You can set the maximum and minimum number of the party in-game using:
#       $game_party.min_size = x
#       $game_party.max_size = x
#       (NOTE: Do NOT make the max size lower than the minimum size.)
#    -Allows you to use the default add/remove actors command.
#       (NOTE: If you remove an actor with this method, he is gone from both
#              the party and the reserve members.)
#
#  Credits:
#    This setup uses SephirothSpawn's coding to simplify the cursor's position.
#
#
#  Command Quick-list:
#    $game_party.remove_actor_from_party(actor_id)
#      -Removes an actor from the party, and puts them in reserve.
#    $game_party.add_actor_to_party(actor_id)
#      -Replaces the last actor in the party with the actor in reserve.
#    $game_party.locked.push(actor_id)
#      -Locks the actor in place.
#    $game_party.min_size = x
#    $game_party.max_size = x
#      -Sets the minimum and maximum party size.
#
#
#  Notes:
#    This script rewrites these methods from Game_Party:
#      add_actor
#      remove_actor
#===================================

#==================================================
#  Game_Party
#==================================================
class Game_Party

  attr_accessor :party_members
  attr_accessor :move
  attr_accessor :locked
  attr_accessor :min_size
  attr_accessor :max_size
 
  alias leon_partyswitch_gameactor_initialize initialize

  def initialize
    leon_partyswitch_gameactor_initialize
    @party_members = []
    #  Edit :This is to change if an actor is locked or not. To lock them, add
    #        their id to the array below.
    @locked = [1]
    @min_size = 1
    @max_size = 4
  end
 
 
  def add_actor(actor_id)
    actor = $game_actors[actor_id]
    if @actors.size < @max_size
      unless @actors.include?(actor)
        unless @party_members.include?(actor.id)
          @actors.push(actor)
          $game_player.refresh
        end
      end
    else
      unless @party_members.include?(actor.id)
        unless @actors.include?(actor)
          @party_members.push(actor.id)
          $game_player.refresh
        end
      end
    end
  end
 
  def remove_actor(actor_id)
    @actors.delete($game_actors[actor_id])
    @party_members.delete(actor_id)
    $game_player.refresh
  end
 
  def remove_actor_from_party(actor_id)
    if @actors.include?($game_actors[actor_id])
      unless @party_members.include?(actor_id)
        @party_members.push(actor_id)
       
      end
    end
        @actors.delete($game_actors[actor_id])
    $game_player.refresh
  end

  def add_actor_to_party(actor_id)
    if @party_members.include?(actor_id)
      if @actors[@max_size - 1] != nil
        @party_members.push(@actors[@max_size - 1].id)
        @actors.delete_at(@max_size - 1)
      end
      @actors.push($game_actors[actor_id])
      @party_members.delete(actor_id)
    end
  end
end
#==================================================
#  END Game_Party
#==================================================

#==============================================================================
# ** Window_Selectable
#==============================================================================
class Window_Selectable < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :cursor_height
  #--------------------------------------------------------------------------
  # * Alias Initialization
  #--------------------------------------------------------------------------
  alias custom_int initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)
    custom_int(x, y, width, height)
    @cursor_height = 32
  end
  #--------------------------------------------------------------------------
  # * Get Top Row
  #--------------------------------------------------------------------------
  def top_row
    # Divide y-coordinate of window contents transfer origin by 1 row
    # height of @cursor_height
    return self.oy / @cursor_height
  end
  #--------------------------------------------------------------------------
  # * Set Top Row
  # row : row shown on top
  #--------------------------------------------------------------------------
  def top_row=(row)
    # If row is less than 0, change it to 0
    if row < 0
      row = 0
    end
    # If row exceeds row_max - 1, change it to row_max - 1
    if row > row_max - 1
      row = row_max - 1
    end
    # Multiply 1 row height by 32 for y-coordinate of window contents
    # transfer origin
    self.oy = row * @cursor_height
  end
  #--------------------------------------------------------------------------
  # * Get Number of Rows Displayable on 1 Page
  #--------------------------------------------------------------------------
  def page_row_max
    # Subtract a frame height of 32 from the window height, and divide it by
    # 1 row height of @cursor_height
    return (self.height - 32) / @cursor_height
  end
  #--------------------------------------------------------------------------
  # * Update Cursor Rectangle
  #--------------------------------------------------------------------------
  def update_cursor_rect
    # If cursor position is less than 0
    if @index < 0
      self.cursor_rect.empty
      return
    end
    # Get current row
    row = @index / @column_max
    # If current row is before top row
    if row < self.top_row
      # Scroll so that current row becomes top row
      self.top_row = row
    end
    # If current row is more to back than back row
    if row > self.top_row + (self.page_row_max - 1)
      # Scroll so that current row becomes back row
      self.top_row = row - (self.page_row_max - 1)
    end
    # Calculate cursor width
    cursor_width = self.width / @column_max - 32
    # Calculate cursor coordinates
    x = @index % @column_max * (cursor_width + 32)
    y = @index / @column_max * @cursor_height - self.oy
    if self.active == true
      # Update cursor rectangle
      self.cursor_rect.set(x, y, cursor_width, @cursor_height)
    end
  end
end

#==============================================================================
# ** Window_Command
#==============================================================================
class Window_Command < Window_Selectable
  #--------------------------------------------------------------------------
  # * Unisable Item
  # index : item number
  #--------------------------------------------------------------------------
  def undisable_item(index)
    draw_item(index, normal_color)
  end
end
#============================================================


#==================================================
#  Window_Party_Info
#==================================================
class Window_Party_Info < Window_Base
  def initialize
    super(0, 0, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end

  def refresh
    self.contents.clear
    self.contents.draw_text(0, 0, 614, 32, "Please form your party of #{$game_party.min_size.to_s} to #{$game_party.max_size.to_s} members.", 1)
  end
end
#==================================================
#  END Window_Party_Info
#==================================================


#==================================================
#  Window_Party_Slots
#==================================================
class Window_Party_Slots < Window_Selectable

  def initialize
    super(0, 64, 320, 416)
    @item_max = 4
    self.contents = Bitmap.new(width - 32, height - 32)
    self.index = 0
    self.active = true
    refresh
  end
 
  def actors
    if @data[index] != nil
      return @data[index]
    end
  end

  def refresh
    @data = []
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    for i in 0...$game_party.actors.size
      @data.push($game_party.actors[i])
    end
    @item_max = (@data.size + 1)
    if @item_max > 0
      if @item_max > 4
        @item_max = 4
      end
      self.contents = Bitmap.new(width - 32, row_max * 96)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
 
  def draw_item(index)
    @actor = @data[index]
    y = index * 96
    x = 4
    if $game_party.locked.include?(@actor.id)
      self.contents.font.color = disabled_color
      opacity = 128
    else
      self.contents.font.color = normal_color
      opacity = 255
    end
    if @actor != nil
      self.contents.draw_text(x + 100, y, 192, 32, @actor.name)
      draw_actor_hp(@actor, x + 100, y + 32)
      draw_actor_sp(@actor, x + 100, y + 64)
      bitmap = RPG::Cache.character(@actor.character_name, @actor.character_hue)
      cw = bitmap.width/4
      ch = bitmap.height/4
      facing = 0
      src_rect = Rect.new(0, facing*ch, cw, ch)
      self.contents.blt(x + 32, y + 24, bitmap, src_rect, opacity)
    end
  end
 
  def update_cursor_rect
    if @index > -1
      x = 0
      y = index * 96
      self.cursor_rect.set(x, y, (self.width - 32), 96)
    else
      self.cursor_rect.empty
    end
  end
 
end
#==================================================
#  END Window_Party_Slots
#==================================================


#==================================================
#  Window_Party_Extras
#==================================================
class Window_Party_Extras < Window_Selectable
  def initialize
    super(320, 64, 320, 416)
    self.cursor_height = 96
    self.contents = Bitmap.new(width - 32, height - 32)
    self.index = -1
    self.active = false
    refresh
  end
 
  def actors
    if @data != nil
      return @data[index]
    end
  end

  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 0...$game_party.party_members.size
      @data.push($game_actors[$game_party.party_members[i]])
    end
    @data.push(nil)
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 96)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
 
  def draw_item(index)
    @actor = @data[index]
    y = index * 96
    x = 4
    if $game_party.locked.include?(@actor.id)
      self.contents.font.color = disabled_color
      opacity = 128
    else
      self.contents.font.color = normal_color
      opacity = 255
    end
    if @actor != nil
      self.contents.draw_text(x + 100, y, 192, 32, @actor.name)
      draw_actor_hp(@actor, x + 100, y + 32)
      draw_actor_sp(@actor, x + 100, y + 64)
      bitmap = RPG::Cache.character(@actor.character_name, @actor.character_hue)
      cw = bitmap.width / 4
      ch = bitmap.height / 4
      facing = 0
      src_rect = Rect.new(0, facing * ch, cw, ch)
      self.contents.blt(x + 24, y + 32, bitmap, src_rect, opacity)
    end
  end
 
end
#===================================
#  END Window_Party_Extras
#===================================


#===================================
#  Scene_Party_Change
#===================================
class Scene_Party_Change
  def main
   
    @info_window = Window_Party_Info.new
    @slot_window = Window_Party_Slots.new
    @extra_window = Window_Party_Extras.new
   
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
   
    @info_window.dispose
    @slot_window.dispose
    @extra_window.dispose
  end
 
  def update
    @slot_window.update
   
    if @slot_window.active
      update_slot
      return
    end
   
    if @extra_window.active
      update_extra
      return
    end
  end
 
  def update_slot
    if Input.trigger?(Input::B)
      if $game_party.actors.size >= $game_party.min_size and $game_party.actors.size <= $game_party.max_size
        $game_player.refresh
        $game_system.se_play($data_system.cancel_se)
        $scene = Scene_Map.new
      else
        $game_system.se_play($data_system.buzzer_se)
      end
    end
   
    if Input.trigger?(Input::C)
      if $game_party.locked.include?(@slot_window.actors.id) == true
        $game_system.se_play($data_system.buzzer_se)
      else
        $game_system.se_play($data_system.decision_se)
        @slot_window.active = false
        @extra_window.active = true
        @extra_window.index = 0
      end
    end
  end
 
  def update_extra
    @extra_window.update
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.cancel_se)
      @slot_window.active = true
      @extra_window.active = false
      @extra_window.index = -1
    end
   
    if Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se)
      if $game_party.locked.include?(@extra_window.actors.id)
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      if @extra_window.actors == nil
        if $game_party.actors[@slot_window.index] != nil
          $game_party.party_members.push($game_party.actors[@slot_window.index].id)
          $game_party.remove_actor_from_party($game_party.actors[@slot_window.index].id)
          $game_party.party_members.sort!
          @slot_window.refresh
          @extra_window.refresh
          @slot_window.active = true
          @extra_window.active = false
          @extra_window.index = -1
        else
          @slot_window.active = true
          @extra_window.active = false
          @extra_window.index = -1
        end
      else
        if $game_party.actors[@slot_window.index] != nil
          hold = @extra_window.actors
          $game_party.party_members.push($game_party.actors[@slot_window.index].id)
          $game_party.actors[@slot_window.index] = hold
          $game_party.party_members.delete_at(@extra_window.index)
          $game_party.party_members.sort!
          @slot_window.refresh
          @extra_window.refresh
          @slot_window.active = true
          @extra_window.active = false
          @extra_window.index = -1
        else
          $game_party.actors[@slot_window.index] = @extra_window.actors
          $game_party.party_members.delete_at(@extra_window.index)
          $game_party.party_members.sort!
          @slot_window.refresh
          @extra_window.refresh
          @slot_window.active = true
          @extra_window.active = false
          @extra_window.index = -1
        end
      end
    end
  end 
end


And Modern Algebra's Multiparty System:

Code Select Expand

#==============================================================================
#  Multiple Parties Xp
#  Version: 1.0b
#  Date: July 26, 2011
#  Ported by: gerkrt, gerrtunk
#  Small Fix by: Twb6543
#  Idea to port: TheRealDeal
#  Link:
#  http://forum.chaos-project.com/index.php/topic,10097
#
#  Original Author: modern algebra (rmrk.net)
#  Link to Original VX version:
#  http://rmrk.net/index.php/topic,25710.0.html
#
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  Description:
#    This script allows you to maintain multiple parties (separate item lists, steps,
#    everything) and allows you to merge them at will. Primarily useful for a
#    game where parties split up or a game where you can have separate parties
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  Instructions:
#    Place this script under ? Materials in the Script Editor.
#    There are several codes to keep in mind:
#
#      $game_parties[id]                :accesses the party located in that index.
#                                       :creates it if it does not yet exist.
#      $game_parties[id] = X            :Sets the party to X. It MUST be a 
#                                       :Game_Party object
#      p = $game_parties.merge(id1,id2) :merges two parties and saves them in p
#      $game_parties.merge! (id1, id2)  :merges two parties and saves them in
#                                       :$game_parties[id1] and deletes $game_parties[id2]
#      $game_parties.delete (id)        :Deletes $game_parties[id]
#
#    In order to switch the current party, just do this:
#
#      $game_party = $game_parties[id]
#      $game_player.refresh
#
#    By default, the original party is saved in $game_parties[0], so you may
#    want to avoid overwriting $game_parties[0] and just work with 1,2,...
#
#    Also, be very careful when dealing with parties. Always remember what
#    parties exist and where they are in $game_parties or else you may make a
#    stupid error occur.
#
#        *EXAMPLE EVENT*
#
#      @>Change Items: [Potion], + 1
#      @>Change Gold: + 50
#      @>Script: p = $game_parties[1]
#       :      : $game_party = p
#       :      : $game_player.refresh
#      @>Change Party Member: Add [Oscar], Initialize
#      @>Change Weapons: [Bastard Sword], +1
#      @>Change Gold: + 100
#
#    Assuming that $game_parties[1] did not previously exist, this event just
#    switched your party to the party with index 1, and if you looked at your
#    menu you would see that Oscar is in the party, you have 100 Gold, and a
#    Bastard Sword. The potion and the other 50 Gold went to the initial party
#
#    Now, let's say Oscar later meets up with his party and rejoins. Then this
#    event would do the trick:
#
#      @>Script: $game_parties.merge! (0, 1)
#       :      : $game_party = $game_parties[0]
#       :      : $game_player.refresh
#
#    And there, the two parties have been merged and everything that Oscar had
#    obtained goes to the party.
#==============================================================================

#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
#  Summary of Changes:
#    new method - add_multiple_steps
#==============================================================================

class Game_Party
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Add Multiple Steps
  #    amount : the amount of steps to add
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def add_multiple_steps (amount)
    @steps += amount
  end

  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # Adds a function from VX so the script works in XP
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def items
    result = []
    for i in @items.keys.sort
      result.push($data_items[i]) if @items[i] > 0
    end
    for i in @weapons.keys.sort
      result.push($data_weapons[i]) if @weapons[i] > 0
    end
    for i in @armors.keys.sort
      result.push($data_armors[i]) if @armors[i] > 0
    end
    return result
  end

end

#==============================================================================
# ** Game_Parties
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  This class handles Parties. It's a wrapper for the built-in class "Array."
#  It is accessed by $game_parties
#==============================================================================

class Game_Parties
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Object Initialization
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def initialize
    @data = [$game_party]
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Retrieve Party
  #    id : the ID of the party
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def [] (id)
    @data[id] = Game_Party.new if @data[id] == nil
    return @data[id]
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Set Party
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def []= (id, party)
    # Does nothing unless it is a party object
    return unless party.class == Game_Party
    @data[id] = party
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Merge
  #    id_1 : the ID of the first party
  #    id_2 : the ID of the second party
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def merge (id_1, id_2)
    new_party = Game_Party.new
    # Get old parties
    op1 = self[id_1]
    op2 = self[id_2]
    # Gold
    new_party.gain_gold (op1.gold + op2.gold)
    # Members
    (op1.actors | op2.actors).each { |actor| new_party.add_actor (actor.id) }
    # Items, Weapons, and Armor
    (op1.items | op2.items).each { |item|
      new_party.gain_item (item, op1.item_number (item) +  op2.item_number (item))
    }
    # Steps
    new_party.add_multiple_steps (op1.steps + op2.steps)
=begin
    # Not used in RPG Maker Xp
    # Last Item
    new_party.last_item_id = op1.last_item_id
    # Last Actor
    new_party.last_actor_index = op1.last_actor_index
    # Last Target
    new_party.last_target_index = op1.last_target_index
   
    # Quest Log was for Vx not Xp so cut out here.
   
=end
    return new_party
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Merge!
  #    id_1 : the ID of the first party to which the second party is merged
  #    id_2 : the ID of the second party that is deleted
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def merge! (id_1, id_2)
    @data[id_1] = merge (id_1, id_2)
    delete (id_2)
  end
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Delete
  #     id : the ID of the quest to be deleted
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  def delete (id)
    @data[id] = nil
    # If this was the last in the array
    if id == @data.size - 1
      # Delete any nil elements that exist between this party and its successor
      id -= 1
      while @data[id] == nil
        @data.delete (id)
        id -= 1
      end
    end
  end
end

#==============================================================================
# ** Scene_Title
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  Summary of Changes:
#    aliased method - create_game_objects
#==============================================================================

class Scene_Title
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Create Game Objects
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  alias command_new_game_GP_alias command_new_game
  def command_new_game
    $game_parties      = Game_Parties.new
    command_new_game_GP_alias
  end
end

#==============================================================================
# ** Scene_Save
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  Summary of Changes:
#    aliased methods -  write_save_data
#==============================================================================

class Scene_Save

  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Write Save Data
  #     file : write file object (opened)
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  alias modalg_multiparty_wrt_sv_dta_6hye write_save_data
  def write_save_data(file)
    modalg_multiparty_wrt_sv_dta_6hye (file)
    Marshal.dump($game_parties,        file)
  end
end

#==============================================================================
# ** Scene_Load
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#  Summary of Changes:
#    aliased methods - read_save_data
#==============================================================================

class Scene_Load

  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  # * Load Save Data
  #     file : file object for reading (opened)
  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  alias modalg_multiparty_rd_sv_dat_2gte read_save_data
  def read_save_data(file)
    modalg_multiparty_rd_sv_dat_2gte (file)
    $game_parties        = Marshal.load(file)
  end
end


By 'merging' these two scripts, I am looking for a party changer where if you press the L or R buttons, the party switches to another on while maintaining the reserves. I intend to use this for a war-like event system in my new project.