Rpg Maker Developers Group

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