[VX/VXA Script] Battle Swap & Last Resort

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