Battle Swap & Last Resort

[Ebanyle]

Battle Swap & Last Resort v 1.0

By Ebanyle

Have you ever felt the need to try another strategy in the middle of the battle, but not being able to pull your warrior or archer into the team? Did you ever helplessly watch a Game Over after your party was beaten to a pulp, even though it has 1001 members who are not currently in battle?
Fear no more! This script will (perhaps) help you!

Features

• Call members in reserve to battle;
  
• Call a reserve member to battle when your current battle members have been defeated;
  
• Set a cooldown for swaps;
  
• Set a limit for swaps.
  

How to Use

Paste this below materials but above main. If you have any battle scripts, I recommend you to paste this below them.

Compatibility

This script may not work with any scripts that modify the battle scene, such as HUDs and some battle systems, especially ATB.

It is supposed to be compatible with the following:

• Yanfly Engine Ace - Battle Engine
  

• Theolized Sideview Battlescript
  

I may or may not be able to make some scripts compatible if asked.

Screenshots

Content Hidden

 
 
 

With YEA - Battle Engine

Code

Github

Content Hidden

Code:

#==============================================================================
# Battle Swap & Last Resort 1.0
# By Ebanyle
#==============================================================================
$imported = {} if $imported.nil?
$imported["EBONY_BattleSwap"] = true
#==============================================================================
# Version History (DD/MM/YY)
# 24/01/23 - v. 1.0 - Release
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# This script allows you to swap members mid-battle. No more lazy backup!
# You can also set cooldowns and a limit for swaps per battle.
#==============================================================================
# Instructions
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Paste this script above Main and below Materials, preferably under all battle
# scripts.
#==============================================================================
# Terms of Use
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# - You may post this anywhere, edited or not;
# - You may use it in any games, commercial or not;
# - Credit me as Ebanyle;
# - Do not remove this header.
#==============================================================================
# Thanks
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Yanfly - For some coding reference
# Traverse - Snippet fix for adding members mid-battle in TSBS
#==============================================================================
# Compatibility
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# This script may need some patches with any script that changes the battle
# scene, including HUDs, ATB, etc.
# It is currently (supposed to be) compatible with the following:
# - Yanfly Engine Ace - Battle Engine
# - Theolized Sideview Battle System
#==============================================================================
# Know issues
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# - If you are using YEA - Battle Engine and have too many members, it might not
# look good;
# - If you have a Popup script, it may pop up the Death state when swapping.
#==============================================================================
# Configuration
#==============================================================================
module EBONY
  module SWAP
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   Vocab: Name of the command in battle
    Vocab = "Swap"   
#
#   Cooldown: Amount of turns that command will be inactive after swapping.
#   Set to zero if you don't want to use this option.
    Cooldown = 2
#
#   Max_Uses: Amount of times you can use command per battle.
#   Set to zero if you don't want to use this option.
    Max_Uses = 3
#
#   Log: Message to appear in the battle log when swapping.
#   Names must be set by %s. 1st is the battle member, 2nd the reserve member.
#   If you don't want a log to appear, simply leave string empty like this: ""
    Log = "%s swapped places with %s."
#
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Configuration for Yanfly Engine Ace - Battle Engine
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#   Style: Layout of the reserve members window for YEA - Battle Engine.
#          Does not affect anything if the aforementioned script is not present.
#          For Battle Engine, actors will get real squishy if there's too
#          many of them. Unfortunately there's no scroll option (yet?).
#
#   :side    - Reserve window will appear to the side of the party window.
#              Recommended if you have 1 or 2 reserve members as it is tiny
#              and any more members than that get REAL squishy.
#   :default - Reserve window will appear above party window.
    Style = :default
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  end
end
#==============================================================================
# ** Game_Troop
#==============================================================================
class Game_Troop
  attr_reader    :swap_cooldown
  attr_reader    :swap_max
  attr_accessor  :allow_swap
  #--------------------------------------------------------------------------
  # * aliased method: clear
  #--------------------------------------------------------------------------
  alias eb_swap_clear clear
  def clear
      eb_swap_clear
      @swap_cooldown = 0
      @swap_max = 0
      @allow_swap = false
  end
  #--------------------------------------------------------------------------
  # * new method: apply swap cooldown
  #--------------------------------------------------------------------------
  def apply_swap_cooldown
    unless EBONY::SWAP::Cooldown == 0
      @swap_cooldown = (EBONY::SWAP::Cooldown)
      @swap_max += 1
    end
  end
  #--------------------------------------------------------------------------
  # * new method: allow swap?
  #--------------------------------------------------------------------------
  def allow_swap?
    if @swap_max == EBONY::SWAP::Max_Uses && EBONY::SWAP::Max_Uses != 0
      @allow_swap = false
    elsif @swap_cooldown != 0 or !$game_party.reserve_exist?
      @allow_swap = false
    else
      @allow_swap = true
    end
  end
  #--------------------------------------------------------------------------
  # * aliased method: Increase Turns
  #--------------------------------------------------------------------------
  alias eb_swap_increase_turn increase_turn
  def increase_turn
    eb_swap_increase_turn
    @swap_cooldown -= 1 unless @swap_cooldown == 0
  end
end # Game_Troop

#==============================================================================
# ** Game_Party
#==============================================================================

class Game_Party
  attr_accessor :dead_reserve_members
  attr_accessor :after_swap_dead_members
  #--------------------------------------------------------------------------
  # * alias method: initalize
  #--------------------------------------------------------------------------
  alias eb_swap_initialize initialize
  def initialize
    eb_swap_initialize
    @dead_reserve_members = []
  end
  #--------------------------------------------------------------------------
  # * new method: last resort
  #--------------------------------------------------------------------------
  def last_resort
    all_dead? && reserve_exist? && !reserve_all_dead?
  end
  #--------------------------------------------------------------------------
  # * new method: reserve_all_dead?
  #--------------------------------------------------------------------------
  def reserve_all_dead?
    return if reserve_members == nil
    dead_reserve_members.size == reserve_members.size
  end
  #--------------------------------------------------------------------------
  # * Get Array of Incapacitated Reserve Members
  #--------------------------------------------------------------------------
  def dead_reserve_members
    unless reserve_members == nil
      @dead_reserve_members = reserve_members.select {|member| member.dead? }
    end
  end
  #--------------------------------------------------------------------------
  # * new method: party_will_be_dead?
  #--------------------------------------------------------------------------
  def party_will_be_dead?(battle_member,reserve_member)
    party_after_swap = members.map { |member| member }
    party_after_swap[battle_member] = all_members[reserve_member]
    @after_swap_dead_members = party_after_swap.select {|member| member.dead? }
    if @after_swap_dead_members.size == members.size
      return true
    else
      return false
    end
  end
  #--------------------------------------------------------------------------
  # * new method: reserve amount
  #--------------------------------------------------------------------------
  def reserve_amount
    all_members.size - max_battle_members
  end
  #--------------------------------------------------------------------------
  # * new method: reserve members
  #--------------------------------------------------------------------------
  def reserve_members
    return [] if all_members.size < max_battle_members
    all_members[max_battle_members, reserve_amount].select {|actor| actor.exist? }
  end
  #--------------------------------------------------------------------------
  # * new method: reserve_exist?
  #--------------------------------------------------------------------------
  def reserve_exist?
    return true if $game_party.all_members.size > $game_party.max_battle_members
  end
end # Game_Party

#==============================================================================
# ** Window_ReserveActor
#  Window for showing party that is currently not in battle.
#==============================================================================

class Window_ReserveActor < Window_BattleStatus
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super()
    self.x = Graphics.width - width
    self.visible = false
    self.openness = 255
  end
  #--------------------------------------------------------------------------
  # * Activate Window
  #--------------------------------------------------------------------------
  def activate
    select(0)
    super
  end
  #--------------------------------------------------------------------------
  # * Get Number of Items
  #--------------------------------------------------------------------------
  def item_max
    if $game_party.all_members.size > $game_party.max_battle_members
      return $game_party.reserve_members.size
    else
      super
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #--------------------------------------------------------------------------
  def draw_item(index)
    if $game_party.all_members.size > $game_party.max_battle_members
      actor = $game_party.reserve_members[index]
      draw_basic_area(basic_area_rect(index), actor)
      draw_gauge_area(gauge_area_rect(index), actor)
    else
      super
    end
  end
end  # Window_ReserveActor

#==============================================================================
# ** Window_PartyCommand
#==============================================================================

class Window_PartyCommand < Window_Command
  #--------------------------------------------------------------------------
  # * aliased method: create Command List
  #--------------------------------------------------------------------------
  alias eb_swap_make_command_list make_command_list
  def make_command_list
    eb_swap_make_command_list
    add_command(EBONY::SWAP::Vocab, :swap, $game_troop.allow_swap?)
  end
end

#==============================================================================
# ** Window_BattleLog
#==============================================================================

class Window_BattleLog < Window_Selectable
  #--------------------------------------------------------------------------
  # * new method: Display Swap
  #--------------------------------------------------------------------------
  def display_swap(target,subject)
    add_text(sprintf(EBONY::SWAP::Log, target, subject))
    wait if line_number > 0
  end
end # Window_BattleLog

#==============================================================================
# ** Scene_Battle
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # * aliased method: create All Windows
  #--------------------------------------------------------------------------
  alias eb_swap_create_all_windows create_all_windows
  def create_all_windows
    eb_swap_create_all_windows
    create_reserve_window
    create_swap_actor_window
    create_dactor_window
  end
  #--------------------------------------------------------------------------
  # * new method: create Reserve Window
  #--------------------------------------------------------------------------
  def create_reserve_window
    @reserve_window = Window_ReserveActor.new
    @reserve_window.set_handler(:ok,     method(:on_reserve_ok))
    @reserve_window.set_handler(:cancel, method(:on_reserve_cancel))
    oy = Graphics.height - @reserve_window.height - @status_window.height
    @reserve_window.y = oy
  end
  #--------------------------------------------------------------------------
  # * new method: Create Swap Actor Window
  #--------------------------------------------------------------------------
  def create_swap_actor_window
    @swap_actor_window = Window_BattleActor.new(@info_viewport)
    @swap_actor_window.set_handler(:ok,     method(:on_s_actor_ok))
    @swap_actor_window.set_handler(:cancel, method(:on_s_actor_cancel))
  end
  #--------------------------------------------------------------------------
  # * aliased method: Create Party Commands Window
  #--------------------------------------------------------------------------
  alias eb_swap_create_party_command_window create_party_command_window
  def create_party_command_window
    eb_swap_create_party_command_window
    @party_command_window.set_handler(:swap, method(:command_swap))
  end
  #--------------------------------------------------------------------------
  # * new method: Create Dead Actor Window
  #--------------------------------------------------------------------------
  def create_dactor_window
    @dactor_window = Window_BattleActor.new(@info_viewport)
    @dactor_window.set_handler(:ok,     method(:on_dactor_ok))
    @dactor_window.x = (@party_command_window.width / 2)
  end
  #--------------------------------------------------------------------------
  # * new method: on_dactor_ok
  #--------------------------------------------------------------------------
  def on_dactor_ok
    on_s_actor_ok
  end
  #--------------------------------------------------------------------------
  # * aliased method: Processing at End of Action
  #--------------------------------------------------------------------------
  alias eb_swap_process_action_end process_action_end
  def process_action_end
    apply_last_resort if $game_party.last_resort
    eb_swap_process_action_end
  end
  #--------------------------------------------------------------------------
  # * new method: apply last resort
  #--------------------------------------------------------------------------
  def apply_last_resort
    @dactor_window.refresh
    @dactor_window.show.activate
    @status_window.hide
    @reserve_window.refresh
    @reserve_window.show
    @reserve_window.unselect
  end
  #--------------------------------------------------------------------------
  # * new method: Reserve actor [OK]
  #--------------------------------------------------------------------------
  def on_reserve_ok
    if check_for_disallow_swap_process
      disallow_swap_process
    else
      process_swap
    end
  end
  #--------------------------------------------------------------------------
  # * new metod: Check if to Disallow Swap Process
  #--------------------------------------------------------------------------
  def check_for_disallow_swap_process
    bm = battle_member_to_swap
    rm = reserve_member_to_swap
    bmd = both_members_dead?
    ald = $game_party.all_dead?
    return true if $game_party.party_will_be_dead?(bm,rm) or bmd && ald
  end
  #--------------------------------------------------------------------------
  # * new method: disallow swap process
  #--------------------------------------------------------------------------
  def disallow_swap_process
    Sound.play_buzzer
    $game_party.reserve_amount != 1 ? w = @reserve_window : w = @swap_actor_window
    i = w.index
    w.refresh
    w.activate
    w.select(i)
  end
  #--------------------------------------------------------------------------
  # * new method: Reserve actor [Cancel]
  #--------------------------------------------------------------------------
  def on_reserve_cancel
    if !$game_party.last_resort
      @swap_actor_window.refresh
      @swap_actor_window.activate
    else
      @dactor_window.refresh
      @dactor_window.activate
    end
    @reserve_window.unselect
  end
  #--------------------------------------------------------------------------
  # * new method: both_members_dead?
  #--------------------------------------------------------------------------
  def both_members_dead?
    bm = $game_party.members[battle_member_to_swap]
    rm = $game_party.reserve_members[@reserve_window.index]
    return true if bm.dead? && rm.dead?
  end
  #--------------------------------------------------------------------------
  # * new method: battle_member_to_swap
  #--------------------------------------------------------------------------
  def battle_member_to_swap
    if $game_party.last_resort
      return @dactor_window.index
    else
      return @swap_actor_window.index
    end
  end
  #--------------------------------------------------------------------------
  # * new method: reserve_member_to_swap
  #--------------------------------------------------------------------------
  def reserve_member_to_swap
    ra = $game_party.reserve_amount
    mxb = $game_party.max_battle_members
    if ra != 1
      return mxb + @reserve_window.index
    else
      return mxb
    end
  end
  #--------------------------------------------------------------------------
  # * new method: process direct swap
  #--------------------------------------------------------------------------
  def process_swap
    $game_troop.apply_swap_cooldown
    rmn = $game_party.reserve_members[@reserve_window.index].name
    bmn = $game_party.members[battle_member_to_swap].name
    @reserve_window.hide
    @swap_actor_window.hide
    @dactor_window.hide
    @status_window.show
    start_party_command_selection
    $game_party.swap_order(battle_member_to_swap,reserve_member_to_swap)
    $game_party.make_actions
    refresh_status
    unless (EBONY::SWAP::Log).empty?
      @party_command_window.show
      @log_window.display_swap(rmn,bmn)
      @log_window.wait_and_clear
    end
  end
  #--------------------------------------------------------------------------
  # * new method: Command Swap
  #--------------------------------------------------------------------------
  def command_swap
    select_s_actor_selection
    @reserve_window.refresh && @reserve_window.show && @reserve_window.unselect
  end
  #--------------------------------------------------------------------------
  # * new method: Start Swap Actor Selection
  #--------------------------------------------------------------------------
  def select_s_actor_selection
    @swap_actor_window.refresh
    @swap_actor_window.show.activate
  end
  #--------------------------------------------------------------------------
  # * new metod: start reserve selection (unused?)
  #--------------------------------------------------------------------------
  def select_reserve_selection
    @reserve_window.activate
  end
  #--------------------------------------------------------------------------
  # * new metod: Swap Actor [OK]
  #--------------------------------------------------------------------------
  def on_s_actor_ok
    if $game_party.reserve_amount != 1
      @reserve_window.activate
    else
      check_for_disallow_swap_process ? disallow_swap_process : process_swap
    end
  end
  #--------------------------------------------------------------------------
  # * new method: Swap Actor [Cancel]
  #--------------------------------------------------------------------------
  def on_s_actor_cancel
    @party_command_window.refresh
    @party_command_window.activate
    @swap_actor_window.hide
    @reserve_window.hide
  end

end # Scene_Battle

class << BattleManager
  #--------------------------------------------------------------------------
  # * overwrite: Determine Win/Loss Results
  #--------------------------------------------------------------------------
  alias eb_swap_judge_win_loss judge_win_loss
  def judge_win_loss
    if $game_party.last_resort
      turn_end
      @phase = :input
      return
    else
      eb_swap_judge_win_loss
    end
  end
end # BattleManager

if $imported["YEA-BattleEngine"]

#==============================================================================
# ** Window_ReserveActor
#==============================================================================

class Window_ReserveActor < Window_BattleStatus
  #--------------------------------------------------------------------------
  # overwrite method: col_max
  #--------------------------------------------------------------------------
  def col_max
    if $game_party.reserve_members.empty?
      return 1
    else
      return $game_party.reserve_amount
    end
  end
  #--------------------------------------------------------------------------
  # new method: battle_members
  #--------------------------------------------------------------------------
  def battle_members; return $game_party.reserve_members; end

  #--------------------------------------------------------------------------
  # new method: actor
  #--------------------------------------------------------------------------
  def actor; return battle_members[@index]; end
  #--------------------------------------------------------------------------
  # overwrite method: item_rect
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = Rect.new
    rect.width = [[128, contents.width / col_max].min,0].max
    rect.height = contents.height
    rect.x = index * rect.width
    if YEA::BATTLE::BATTLESTATUS_CENTER_FACES
      rect.x += (contents.width - $game_party.reserve_amount * rect.width) / 2
    end
    rect.y = 0
    return rect
  end
  #--------------------------------------------------------------------------
  # overwrite method: draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    return if index.nil?
    clear_item(index)
    actor = battle_members[index]
    rect = item_rect(index)
    return if actor.nil?
    draw_actor_face(actor, rect.x+2, rect.y+2, actor.alive?)
    draw_actor_name(actor, rect.x-20, rect.y, rect.width)
    draw_actor_icons(actor, rect.x, line_height*1, rect.width)
    gx = YEA::BATTLE::BATTLESTATUS_HPGAUGE_Y_PLUS
    contents.font.size = YEA::BATTLE::BATTLESTATUS_TEXT_FONT_SIZE
    draw_actor_hp(actor, rect.x+2, line_height*2+gx, rect.width-4)
    if draw_tp?(actor) && draw_mp?(actor)
      dw = rect.width/2-2
      dw += 1 if $imported["YEA-CoreEngine"] && YEA::CORE::GAUGE_OUTLINE
      draw_actor_tp(actor, rect.x+2, line_height*3, dw)
      dw = rect.width - rect.width/2 - 2
      draw_actor_mp(actor, rect.x+rect.width/2, line_height*3, dw)
    elsif draw_tp?(actor) && !draw_mp?(actor)
      draw_actor_tp(actor, rect.x+2, line_height*3, rect.width-4)
    else
      draw_actor_mp(actor, rect.x+2, line_height*3, rect.width-4)
    end
  end
  #--------------------------------------------------------------------------
  # * Get Window Width
  #--------------------------------------------------------------------------
  def window_width
    if EBONY::SWAP::Style == :side
      return 128
    else
      super
    end
  end
end # Window_ReserveActor

class Scene_Battle
  #--------------------------------------------------------------------------
  # * new method: window_side?
  #--------------------------------------------------------------------------
  def window_side?
    EBONY::SWAP::Style == :side
  end
  #--------------------------------------------------------------------------
  # * overwrite method: create Reserve Window
  #--------------------------------------------------------------------------
  def create_reserve_window
    @reserve_window = Window_ReserveActor.new
    @reserve_window.set_handler(:ok,     method(:on_reserve_ok))
    @reserve_window.set_handler(:cancel, method(:on_reserve_cancel))
    oy = Graphics.height - @reserve_window.height
    oy = oy - @party_command_window.height unless window_side?
    @reserve_window.y = oy
  end
  #--------------------------------------------------------------------------
  # * overwrite method: Create Swap Actor Window
  #--------------------------------------------------------------------------
  def create_swap_actor_window
    @swap_actor_window = Window_BattleActor.new(@info_viewport)
    @swap_actor_window.set_handler(:ok,     method(:on_s_actor_ok))
    @swap_actor_window.set_handler(:cancel, method(:on_s_actor_cancel))
    @swap_actor_window.x = @party_command_window.width unless window_side?
  end
  #--------------------------------------------------------------------------
  # * overwrite method: Create Dead Actor Window
  #--------------------------------------------------------------------------
  def create_dactor_window
    @dactor_window = Window_BattleActor.new(@info_viewport)
    @dactor_window.set_handler(:ok,     method(:on_dactor_ok))
    @dactor_window.x = (@party_command_window.width / 2) if !window_side?
  end
  #--------------------------------------------------------------------------
  # * alias method: apply last resort
  #--------------------------------------------------------------------------
  alias eb_yeab_apply_last_resort apply_last_resort
  def apply_last_resort
    eb_yeab_apply_last_resort
    @party_command_window.show if !window_side?
    @reserve_window.x = @dactor_window.x if !window_side? && $game_party.last_resort
  end
  #--------------------------------------------------------------------------
  # * new method: hide windows on swap
  #--------------------------------------------------------------------------
  def hide_windows_on_swap
    @help_window.hide
    refresh_status
    @status_window.show
  end
  #--------------------------------------------------------------------------
  # * aliased method: Swap Actor [Cancel]
  #--------------------------------------------------------------------------
  alias yeab_on_s_actor_cancel on_s_actor_cancel
  def on_s_actor_cancel
    yeab_on_s_actor_cancel
    hide_windows_on_swap
    @party_command_window.show
  end
  #--------------------------------------------------------------------------
  # * aliased method: process direct swap
  #--------------------------------------------------------------------------
  alias eb_yeab_process_swap process_swap
  def process_swap
    eb_yeab_process_swap
    hide_windows_on_swap
  end
  #--------------------------------------------------------------------------
  # * aliased method: command swap
  #--------------------------------------------------------------------------
  alias eb_yeab_command_swap command_swap
  def command_swap
    eb_yeab_command_swap
    @party_command_window.hide if window_side?
    @status_window.hide
    @reserve_window.x = @party_command_window.width if !window_side?
  end
  #--------------------------------------------------------------------------
  # * aliased method: disallow swap process
  #--------------------------------------------------------------------------
  alias eb_yeab_disallow_swap_process disallow_swap_process
  def disallow_swap_process
    eb_yeab_disallow_swap_process
  end
end # Scene_Battle

#==============================================================================
end # Imported

if $imported[:TSBS]
#==============================================================================
# ** Game_Party
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # * aliased method: Change Order
  #--------------------------------------------------------------------------
  alias eb_tsbs_swap_order swap_order
  def swap_order(index1, index2)
    eb_tsbs_swap_order(index1, index2)
    if SceneManager.scene_is?(Scene_Battle)
      SceneManager.scene.spriteset.actor_sprites.each_index { |i|
          sprite = SceneManager.scene.spriteset.actor_sprites[i]
          mem = $game_party.battle_members[i] ; return unless mem
          if sprite.battler.nil? || sprite.battler != mem
            mem.init_oripost ; mem.reset_pos(1) ; mem.battle_phase = :idle
          end
        }
        SceneManager.scene.spriteset.update
    end
  end
end # Game_Party
#==============================================================================
end # Imported

Terms of Use

• You may post this anywhere, edited or not;
  
• You may use it in any games, commercial or not;
  
• Credit me as Ebanyle;
  
• Do not remove the header.
  

Thanks

• Yanfly - For some code reference
  
• Traverse - Snippet fix for adding members mid-battle in TSBS (from here)
  

Notes
There is an issue with the battle log's speed (message spawns out too fast iirc), and also with both active and reserve party's windows not being properly centralized (they keep to the right accounting for battle command's window). I unfortunately have not managed to be able to move either at this state.
I kind of f*ed around and found out with whatever methods would work to prevent a Game Over before checking for swaps, which in my case was... aliasing a BattleManager method.
I don't know anything about programming and consider it a miracle I even managed to make such a script, so it's probably really crude even for my own usage within other systems, really. I was just bummed there was no script available with such a concept, which I'm a sucker for. But well! Everyone starts somewhere, right?