#==============================================================================

#
# Yanfly Engine Ace - Battle Command List v1.09b
# -- Last Updated: 2012.12.18
# -- Level: Normal
# -- Requires: n/a
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YEA-BattleCommandList"] = true
#==============================================================================
# Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.12.18 - Completely fixed the command hide switch bug.
# 2012.12.17 - Fixed Bug with command hide until switch.
# 2012.01.10 - Compatibility Update: Battle System FTB
# 2011.12.30 - Bug Fixed: Disappearing windows when no confirm window is used.
# 2011.12.26 - Bug Fixed: Actor Command Window disappears without Battle Engine
#
Ace installed.
# 2011.12.19 - Compatibility Update: Class System
#
- New Actor Command: Subclass List
# 2011.12.17 - Bug Fixed: Item command from Actor Command Window fixed.
# 2011.12.15 - Bug Fixed: Prevented multiple actions per battler.
# 2011.12.13 - Compatibility Update: Command Equip
#
Compatibility Update: Add-On: Command Party
# 2011.12.12 - Compatibility Update: Command Autobattle
# 2011.12.10 - Started Script and Finished.
#
- Compatibility Update: Combat Log Display
#
#==============================================================================
# Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script allows you to change the order to commands that appear in battle
# for the Party Command Window and Actor Command Window. In addition to the
# ability to change the order commands appear, you may also add commands to the
# Actor Command Window that can trigger the usage of skills and/or items. The
# Confirm Command Window is also a new addition that appears at the end of the
# action select phase (after the last actor has made a choice) before entering
# the battle phase.
#
#==============================================================================
# Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below Materials/ f but above Main. Remember to save.
#
# ----------------------------------------------------------------------------# Actor Notetags - These notetags go in the actors notebox in the database.
# ----------------------------------------------------------------------------# <command list>
# string
# string
# </command list>
# These lines go inside of an actor's notebox to adjust the battle commands
# that appear in the actor's Actor Command Window. Refer to the module as to
# what to use for the strings. If a custom command list is used for an actor,
# it will take priority over its class's custom command list, which takes place
# over the default command list.

#
# ----------------------------------------------------------------------------# Class Notetags - These notetags go in the class notebox in the database.
# ----------------------------------------------------------------------------# <command list>
# string
# string
# </command list>
# These lines go inside of a class's notebox to adjust the battle commands
# that appear in the actor's Actor Command Window. Refer to the module as to
# what to use for the strings. A custom command list for a class does not take
# priority over an actor's custom command list, but it does take priority over
# the default command list.
#
# ----------------------------------------------------------------------------# Skill Notetags - These notetags go in the skill notebox in the database.
# ----------------------------------------------------------------------------# <command name: string>
# If this skill is being used as a command, it will use "string" to replace the
# skill's name in the command list window.
#
# <command hide until learn>
# This hides the command until the actor has learned the respective skill for
# the command to appear in the actor's command list.
#
# <command hide until usable>
# This hides the command until the actor is capable of using the command by
# meeting TP costs or MP costs.
#
# <command hide until switch: x>
# This switch x is OFF, then the command remains hidden. If the switch is ON,
# then the command becomes enabled and appears in the command list.
#
# ----------------------------------------------------------------------------# Item Notetags - These notetags go in the item notebox in the database.
# ----------------------------------------------------------------------------# <command name: string>
# If this item is being used as a command, it will use "string" to replace the
# item's name in the command list window.
#
# <command hide until usable>
# This hides the command until the actor is capable of using the command as
# long as that item is usable normally.
#
# <command hide until switch: x>
# This switch x is OFF, then the command remains hidden. If the switch is ON,
# then the command becomes enabled and appears in the command list.
#
#==============================================================================
# Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
# For maximum compatibility with Yanfly Engine Ace - Ace Battle Engine, place
# this script under Ace Battle Engine.
#
#==============================================================================
module YEA

module BATTLE_COMMANDS
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# - Party Command Window Settings #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# This section adjusts the commands for the Party Command Window. Rearrange
# commands as you see fit or add in new ones. Here's a list of which
# command does what:
#
# ------------------------------------------------------------------------# :command
Description
# ------------------------------------------------------------------------# :fight
Enters the command selection phase for actors. Default.
# :escape
Party attempts to escape from battle. Default.
#
# :combatlog
Requires YEA - Combat Log Display.
# :autobattle
Requires YEA - Command Autobattle.
# :party
Requires YEA - Party System Add-On: Command Party.
#
# And that's all of the currently available commands. This list will be
# updated as more scripts become available.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# This array arranges the order of which the commands appear in the Party
# Command window.
PARTY_COMMANDS =[
:fight,
:autobattle,
:party,
# :custom1,
# :custom2,
:escape,
] # Do not remove this.
#-------------------------------------------------------------------------# - Party Command Custom Commands # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # For those who use scripts to that may produce unique effects in battle,
# use this hash to manage the custom commands for the Party Command Window.
# You can disable certain commands or prevent them from appearing by using
# switches. If you don't wish to bind them to a switch, set the proper
# switch to 0 for it to have no impact.
#-------------------------------------------------------------------------CUSTOM_PARTY_COMMANDS ={
# :command => ["Display Name", EnableSwitch, ShowSwitch, Handler Method],
:custom1 => [ "Custom Name",
0,
0, :command_name1],
:custom2 => [ "Custom Name",
13,
0, :command_name2],
} # Do not remove this.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# - Actor Command Window Settings #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# This section only adjusts the default commands for actors. If you wish
# for an actor to have a unique command list, use the notetags listed in
# the instructions to apply them. The custom command lists for actors will
# override this command list.
#
# Here's a list of which command does what:
#
# ------------------------------------------------------------------------# :command
Description

# ------------------------------------------------------------------------# "ATTACK"
Normal attack for actor. Default.
# "SKILL LIST"
All of the skill types the actor can use. Default.
# "DEFEND"
Set defend action for actor. Default.
# "ITEMS"
Opens up the item menu for the actor. Default.
#
# "SKILL TYPE X" Specifically puts in skill type X if actor has it.
# "SKILL X"
Uses Skill X in that slot.
# "ITEM X"
Uses Item X in that slot.
#
# "AUTOBATTLE"
Requires YEA - Command Autobattle.
# "EQUIP"
Requires YEA - Command Equip
# "SUBCLASS LIST" Requires YEA - Class System. Adds subclass skill types.
#
# And that's all of the currently available commands. This list will be
# updated as more scripts become available.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# This array arranges the order of which the commands appear in the Actor
# Command window if the actor does not have a custom command list.
DEFAULT_ACTOR_COMMANDS =[
# "AUTOBATTLE",
"ATTACK",
"SKILL LIST",
"SUBCLASS LIST",
"DEFEND",
"ITEMS",
"EQUIP",
] # Do not remove this.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# - Confirm Command Window Settings #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=# The confirm window is something new that's been added. It shows after the
# last actor has made a decision as to what actions the player wishes to
# take for the turn Here's a list of which command does what:
#
# ------------------------------------------------------------------------# :command
Description
# ------------------------------------------------------------------------# :execute
Start the battle turn. Comes with this script.
#
# :combatlog
Requires YEA - Combat Log Display.
#
# And that's all of the currently available commands. This list will be
# updated as more scripts become available.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=USE_CONFIRM_WINDOW = true
# Set to false if you don't wish to use it.
# This array arranges the order of which the commands appear in the Party
# Command window.
CONFIRM_COMMANDS =[
:execute,
:combatlog,
# :custom1,
# :custom2,
] # Do not remove this.
# This sets what text appears for the execute command.
EXECUTE_VOCAB = "Execute"

#-------------------------------------------------------------------------# - Confirm Command Custom Commands # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # For those who use scripts to that may produce unique effects in battle,
# use this hash to manage the custom commands for the Confirm Command
# Window. You can disable certain commands or prevent them from appearing
# by using switches. If you don't wish to bind them to a switch, set the
# proper switch to 0 for it to have no impact.
#-------------------------------------------------------------------------CUSTOM_CONFIRM_COMMANDS ={
# :command => ["Display Name", EnableSwitch, ShowSwitch, Handler Method],
:custom1 => [ "Custom Name",
0,
0, :command_name1],
:custom2 => [ "Custom Text",
13,
0, :command_name2],
} # Do not remove this.
end # BATTLE_COMMANDS
end # YEA
#==============================================================================
# Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
module YEA
module REGEXP
module BASEITEM
COMMAND_LIST_ON = /<(?:COMMAND_LIST|command list)>/i
COMMAND_LIST_OFF = /<\/(?:COMMAND_LIST|command list)>/i
end # BASEITEM
module USABLEITEM
COMMAND_NAME = /<(?:COMMAND NAME|command name):[ ](.*)>/i
COMMAND_HIDE_LEARN =
/<(?:COMMAND_HIDE_UNTIL_LEARN|command hide until learn)>/i
COMMAND_HIDE_USABLE =
/<(?:COMMAND_HIDE_UNTIL_USABLE|command hide until usable)>/i
COMMAND_HIDE_SWITCH =
/<(?:COMMAND_HIDE_UNTIL_SWITCH|command hide until switch):[ ](\d+)>/i
end # USABLEITEM
end # REGEXP
end # YEA
#==============================================================================
# DataManager
#==============================================================================
module DataManager
#-------------------------------------------------------------------------# alias method: load_database
#-------------------------------------------------------------------------class <<self; alias load_database_bcl load_database; end
def self.load_database
load_database_bcl
load_notetags_bcl
end

#-------------------------------------------------------------------------# new method: load_notetags_bcl

#-------------------------------------------------------------------------def self.load_notetags_bcl
groups = [$data_actors, $data_classes, $data_skills, $data_items]
for group in groups
for obj in group
next if obj.nil?
obj.load_notetags_bcl
end
end
end
end # DataManager
#==============================================================================
# RPG::BaseItem
#==============================================================================
class RPG::BaseItem
#-------------------------------------------------------------------------# public instance variables
#-------------------------------------------------------------------------attr_accessor :battle_commands
#-------------------------------------------------------------------------# common cache: load_notetags_bcl
#-------------------------------------------------------------------------def load_notetags_bcl
@battle_commands = []
@command_list = false
#--self.note.split(/[\r\n]+/).each { |line|
case line
#--when YEA::REGEXP::BASEITEM::COMMAND_LIST_ON
@command_list = true
when YEA::REGEXP::BASEITEM::COMMAND_LIST_OFF
@command_list = false
else
next unless @command_list
@battle_commands.push(line.to_s.upcase)
#--end
} # self.note.split
#--if @battle_commands == [] and self.is_a?(RPG::Class)
@battle_commands = YEA::BATTLE_COMMANDS::DEFAULT_ACTOR_COMMANDS
end
end
end # RPG::BaseItem
#==============================================================================
# RPG::UsableItem
#==============================================================================
class RPG::UsableItem < RPG::BaseItem

#-------------------------------------------------------------------------# public instance variables

#-------------------------------------------------------------------------attr_accessor :command_name
attr_accessor :command_hide_until_learn
attr_accessor :command_hide_until_usable
attr_accessor :command_hide_until_switch
#-------------------------------------------------------------------------# common cache: load_notetags_bcl
#-------------------------------------------------------------------------def load_notetags_bcl
@command_name = @name.clone
@command_hide_until_switch = 0
#--self.note.split(/[\r\n]+/).each { |line|
case line
#--when YEA::REGEXP::USABLEITEM::COMMAND_NAME
@command_name = $1.to_s
when YEA::REGEXP::USABLEITEM::COMMAND_HIDE_LEARN
@command_hide_until_learn = true
when YEA::REGEXP::USABLEITEM::COMMAND_HIDE_USABLE
@command_hide_until_usable = true
when YEA::REGEXP::USABLEITEM::COMMAND_HIDE_SWITCH
@command_hide_until_switch = $1.to_i
#--end
} # self.note.split
#--end
end # RPG::UsableItem
#==============================================================================
# Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#-------------------------------------------------------------------------# new method: battle_commands
#-------------------------------------------------------------------------def battle_commands
return self.actor.battle_commands unless actor.battle_commands == []
return self.class.battle_commands
end
#-------------------------------------------------------------------------# new method: next_command_valid?
#-------------------------------------------------------------------------def next_command_valid?
if $imported["YEA-BattleSystem-FTB"] && BattleManager.btype?(:ftb)
return false
end
return false if @action_input_index >= @actions.size - 1
return true
end

end # Game_Actor
#==============================================================================
# Window_PartyCommand
#==============================================================================
class Window_PartyCommand < Window_Command
#-------------------------------------------------------------------------# overwrite method: make_command_list
#-------------------------------------------------------------------------def make_command_list
for command in YEA::BATTLE_COMMANDS::PARTY_COMMANDS
case command
when :fight
add_command(Vocab::fight, :fight)
when :escape
add_command(Vocab::escape, :escape, BattleManager.can_escape?)
when :combatlog
next unless $imported["YEA-CombatLogDisplay"]
add_command(YEA::COMBAT_LOG::COMMAND_NAME, :combatlog)
when :autobattle
next unless $imported["YEA-CommandAutobattle"]
add_autobattle_command
when :party
next unless $imported["YEA-PartySystem"]
next unless $imported["YEA-CommandParty"]
add_party_command
else
process_custom_command(command)
end
end
end
#-------------------------------------------------------------------------# new method: process_custom_command
#-------------------------------------------------------------------------def process_custom_command(command)
return unless YEA::BATTLE_COMMANDS::CUSTOM_PARTY_COMMANDS.include?(command)
show = YEA::BATTLE_COMMANDS::CUSTOM_PARTY_COMMANDS[command][2]
continue = show <= 0 ? true : $game_switches[show]
return unless continue
text = YEA::BATTLE_COMMANDS::CUSTOM_PARTY_COMMANDS[command][0]
switch = YEA::BATTLE_COMMANDS::CUSTOM_PARTY_COMMANDS[command][1]
enabled = switch <= 0 ? true : $game_switches[switch]
add_command(text, command, enabled)
end
end # Window_PartyCommand
#==============================================================================
# Window_ConfirmCommand
#==============================================================================
class Window_ConfirmCommand < Window_Command
#-------------------------------------------------------------------------# initialize
#-------------------------------------------------------------------------def initialize

super(0, 0)
deactivate
hide
end
#-------------------------------------------------------------------------# window_width
#-------------------------------------------------------------------------def window_width; return 128; end
#-------------------------------------------------------------------------# visible_line_number
#-------------------------------------------------------------------------def visible_line_number; return 4; end
#-------------------------------------------------------------------------# overwrite method: make_command_list
#-------------------------------------------------------------------------def make_command_list
for command in YEA::BATTLE_COMMANDS::CONFIRM_COMMANDS
case command
when :execute
text = YEA::BATTLE_COMMANDS::EXECUTE_VOCAB
add_command(text, :execute)
when :combatlog
next unless $imported["YEA-CombatLogDisplay"]
add_command(YEA::COMBAT_LOG::COMMAND_NAME, :combatlog)
else
process_custom_command(command)
end
end
end
#-------------------------------------------------------------------------# new method: process_custom_command
#-------------------------------------------------------------------------def process_custom_command(command)
return unless YEA::BATTLE_COMMANDS::CUSTOM_CONFIRM_COMMANDS.include?(command
)
show = YEA::BATTLE_COMMANDS::CUSTOM_CONFIRM_COMMANDS[command][2]
continue = show <= 0 ? true : $game_switches[show]
return unless continue
text = YEA::BATTLE_COMMANDS::CUSTOM_CONFIRM_COMMANDS[command][0]
switch = YEA::BATTLE_COMMANDS::CUSTOM_CONFIRM_COMMANDS[command][1]
enabled = switch <= 0 ? true : $game_switches[switch]
add_command(text, command, enabled)
end
#-------------------------------------------------------------------------# setup
#-------------------------------------------------------------------------def setup
clear_command_list
make_command_list
refresh
select(0)
activate
self.openness = 255
show
end

#-------------------------------------------------------------------------# process_handling
#-------------------------------------------------------------------------if $imported["YEA-BattleEngine"]
def process_handling
return unless open? && active
return process_dir4 if Input.repeat?(:LEFT)
return super
end
#-------------------------------------------------------------------------# process_dir4
#-------------------------------------------------------------------------def process_dir4
Sound.play_cursor
Input.update
deactivate
call_handler(:dir4)
end
end # $imported["YEA-BattleEngine"]
end # Window_ConfirmCommand
#==============================================================================
# Window_ActorCommand
#==============================================================================
class Window_ActorCommand < Window_Command
#-------------------------------------------------------------------------# alias method: setup
#-------------------------------------------------------------------------alias window_actorcommand_setup_bcl setup
def setup(actor)
window_actorcommand_setup_bcl(actor)
show
end
#-------------------------------------------------------------------------# overwrite method: make_command_list
#-------------------------------------------------------------------------def make_command_list
return if @actor.nil?
@stype_list = []
for command in @actor.battle_commands
case command.upcase
#--when /ATTACK/i
add_attack_command
when /SKILL LIST/i
add_skill_commands
when /DEFEND/i
add_guard_command
when /ITEMS/i
add_item_command
#--when /SKILL TYPE[ ](\d+)/i
add_skill_type_command($1.to_i)
when /SKILL[ ](\d+)/i

add_skill_id_command($1.to_i)
when /ITEM[ ](\d+)/i
add_item_id_command($1.to_i)
#--when /AUTOBATTLE/i
next unless $imported["YEA-CommandAutobattle"]
add_autobattle_command
when /EQUIP/i
next unless $imported["YEA-CommandEquip"]
add_equip_command
when /SUBCLASS LIST/i
add_subclass_skill_types
#--else; next
end
end
end
#-------------------------------------------------------------------------# overwrite method: add_skill_commands
#-------------------------------------------------------------------------def add_skill_commands
@actor.added_skill_types.each do |stype_id|
next if @stype_list.include?(stype_id)
next if include_subclass_type?(stype_id)
add_skill_type_command(stype_id)
end
end
#-------------------------------------------------------------------------# new method: include_subclass_type?
#-------------------------------------------------------------------------def include_subclass_type?(stype_id)
return false unless $imported["YEA-ClassSystem"]
return @actor.subclass_skill_types.include?(stype_id)
end
#-------------------------------------------------------------------------# new method: add_subclass_skill_types
#-------------------------------------------------------------------------def add_subclass_skill_types
return unless $imported["YEA-ClassSystem"]
return if @actor.subclass.nil?
@actor.subclass_skill_types.sort.each do |stype_id|
next if @stype_list.include?(stype_id)
add_skill_type_command(stype_id)
end
end
#-------------------------------------------------------------------------# new method: add_skill_type_command
#-------------------------------------------------------------------------def add_skill_type_command(stype_id)
return unless @actor.added_skill_types.include?(stype_id)
return if @stype_list.include?(stype_id)
@stype_list.push(stype_id)
name = $data_system.skill_types[stype_id]
add_command(name, :skill, true, stype_id)
end

#-------------------------------------------------------------------------# new method: add_skill_id_command

#-------------------------------------------------------------------------def add_skill_id_command(skill_id)
return if $data_skills[skill_id].nil?
return unless add_use_skill?(skill_id)
name = $data_skills[skill_id].command_name
add_command(name, :use_skill, use_skill_valid?(skill_id), skill_id)
end
#-------------------------------------------------------------------------# new method: add_use_skill?
#-------------------------------------------------------------------------def add_use_skill?(skill_id)
skill = $data_skills[skill_id]
return false if hide_until_learn?(skill)
return false if hide_until_usable?(skill)
return false if hide_until_switch?(skill)
return true
end
#-------------------------------------------------------------------------# new method: hide_until_learn?
#-------------------------------------------------------------------------def hide_until_learn?(skill)
return false unless skill.command_hide_until_learn
return false if @actor.skill_learn?(skill)
return false if @actor.added_skills.include?(skill.id)
return true
end
#-------------------------------------------------------------------------# new method: hide_until_usable?
#-------------------------------------------------------------------------def hide_until_usable?(skill)
return false unless skill.command_hide_until_usable
return false if @actor.usable?(skill)
return true
end
#-------------------------------------------------------------------------# new method: hide_until_switch?
#-------------------------------------------------------------------------def hide_until_switch?(skill)
return false unless skill.command_hide_until_switch > 0
return false if $game_switches[skill.command_hide_until_switch]
return true
end
#-------------------------------------------------------------------------# new method: use_skill_valid?
#-------------------------------------------------------------------------def use_skill_valid?(skill_id)
skill = $data_skills[skill_id]
return false unless @actor.skill_conditions_met?(skill)
return true
end
#-------------------------------------------------------------------------# new method: add_item_id_command

#-------------------------------------------------------------------------def add_item_id_command(item_id)
return if $data_items[item_id].nil?
return unless add_use_item?(item_id)
name = $data_items[item_id].command_name
add_command(name, :use_item, use_item_valid?(item_id), item_id)
end
#-------------------------------------------------------------------------# new method: add_use_item?
#-------------------------------------------------------------------------def add_use_item?(item_id)
item = $data_items[item_id]
return false if hide_until_usable?(item)
return false if hide_until_switch?(item)
return true
end
#-------------------------------------------------------------------------# new method: use_item_valid?
#-------------------------------------------------------------------------def use_item_valid?(item_id)
item = $data_items[item_id]
return false unless @actor.item_conditions_met?(item)
return true
end
end # Window_ActorCommand
#==============================================================================
# Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#-------------------------------------------------------------------------# alias method: create_all_windows
#-------------------------------------------------------------------------alias scene_battle_create_all_windows_bcl create_all_windows
def create_all_windows
scene_battle_create_all_windows_bcl
create_confirm_command_window
end
#-------------------------------------------------------------------------# alias method: create_party_command_window
#-------------------------------------------------------------------------alias create_party_command_window_bcl create_party_command_window
def create_party_command_window
create_party_command_window_bcl
process_custom_party_commands
end
#-------------------------------------------------------------------------# new method: process_custom_party_commands
#-------------------------------------------------------------------------def process_custom_party_commands
for command in YEA::BATTLE_COMMANDS::PARTY_COMMANDS
next unless YEA::BATTLE_COMMANDS::CUSTOM_PARTY_COMMANDS.include?(command)
called_method = YEA::BATTLE_COMMANDS::CUSTOM_PARTY_COMMANDS[command][3]

@party_command_window.set_handler(command, method(called_method))
end
end
#-------------------------------------------------------------------------# alias method: create_actor_command_window
#-------------------------------------------------------------------------alias create_actor_command_window_bcl create_actor_command_window
def create_actor_command_window
create_actor_command_window_bcl
@actor_command_window.set_handler(:use_skill, method(:command_use_skill))
@actor_command_window.set_handler(:use_item, method(:command_use_item))
end
#-------------------------------------------------------------------------# alias method: start_actor_command_selection
#-------------------------------------------------------------------------alias start_actor_command_selection_bcl start_actor_command_selection
def start_actor_command_selection
@confirm_command_window.hide unless @confirm_command_window.nil?
start_actor_command_selection_bcl
@actor_command_window.show
end
#-------------------------------------------------------------------------# new method: command_use_skill
#-------------------------------------------------------------------------def command_use_skill
@skill = $data_skills[@actor_command_window.current_ext]
BattleManager.actor.input.set_skill(@skill.id)
BattleManager.actor.last_skill.object = @skill
status_redraw_target(BattleManager.actor)
if $imported["YEA-BattleEngine"]
$game_temp.battle_aid = @skill
if @skill.for_opponent?
select_enemy_selection
elsif @skill.for_friend?
select_actor_selection
else
next_command
$game_temp.battle_aid = nil
end
else
if !@skill.need_selection?
next_command
elsif @skill.for_opponent?
select_enemy_selection
else
select_actor_selection
end
end
end
#-------------------------------------------------------------------------# new method: command_use_item
#-------------------------------------------------------------------------def command_use_item
@item = $data_items[@actor_command_window.current_ext]
BattleManager.actor.input.set_item(@item.id)
status_redraw_target(BattleManager.actor)

if $imported["YEA-BattleEngine"]
$game_temp.battle_aid = @item
if @item.for_opponent?
select_enemy_selection
elsif @item.for_friend?
select_actor_selection
else
next_command
$game_temp.battle_aid = nil
end
else
if !@item.need_selection?
next_command
elsif @item.for_opponent?
select_enemy_selection
else
select_actor_selection
end
end
end
#-------------------------------------------------------------------------# alias method: on_actor_ok
#-------------------------------------------------------------------------alias scene_battle_on_actor_ok_bcl on_actor_ok
def on_actor_ok
scene_battle_on_actor_ok_bcl
return if !@confirm_command_window.nil? && @confirm_command_window.visible
@actor_command_window.show
end
#-------------------------------------------------------------------------# alias method: on_actor_cancel
#-------------------------------------------------------------------------alias scene_battle_on_actor_cancel_bcl on_actor_cancel
def on_actor_cancel
scene_battle_on_actor_cancel_bcl
case @actor_command_window.current_symbol
when :use_skill, :use_item
@help_window.hide
@status_window.show
@actor_command_window.activate
status_redraw_target(BattleManager.actor)
end
end
#-------------------------------------------------------------------------# alias method: on_enemy_ok
#-------------------------------------------------------------------------alias scene_battle_on_enemy_ok_bcl on_enemy_ok
def on_enemy_ok
scene_battle_on_enemy_ok_bcl
return if !@confirm_command_window.nil? && @confirm_command_window.visible
@actor_command_window.show
end
#-------------------------------------------------------------------------# alias method: on_enemy_cancel
#-------------------------------------------------------------------------alias scene_battle_on_enemy_cancel_bcl on_enemy_cancel

def on_enemy_cancel
scene_battle_on_enemy_cancel_bcl
case @actor_command_window.current_symbol
when :use_skill, :use_item
@help_window.hide
@status_window.show
@actor_command_window.activate
status_redraw_target(BattleManager.actor)
end
end
#-------------------------------------------------------------------------# new method: status_redraw_target
#-------------------------------------------------------------------------def status_redraw_target(target)
return unless target.actor?
@status_window.draw_item($game_party.battle_members.index(target))
end
#-------------------------------------------------------------------------# new method: create_confirm_command_window
#-------------------------------------------------------------------------def create_confirm_command_window
return unless YEA::BATTLE_COMMANDS::USE_CONFIRM_WINDOW
@confirm_command_window = Window_ConfirmCommand.new
@confirm_command_window.viewport = @info_viewport
@confirm_command_window.set_handler(:execute, method(:command_execute))
@confirm_command_window.set_handler(:cancel, method(:on_confirm_cancel))
@confirm_command_window.set_handler(:dir4, method(:on_confirm_cancel))
@confirm_command_window.unselect
@confirm_command_window.x = Graphics.width
process_custom_confirm_commands
process_confirm_compatibility_commands
end
#-------------------------------------------------------------------------# new method: process_custom_confirm_commands
#-------------------------------------------------------------------------def process_custom_confirm_commands
for command in YEA::BATTLE_COMMANDS::CONFIRM_COMMANDS
next unless YEA::BATTLE_COMMANDS::CUSTOM_CONFIRM_COMMANDS.include?(command
)
called_method = YEA::BATTLE_COMMANDS::CUSTOM_CONFIRM_COMMANDS[command][3]
@party_command_window.set_handler(command, method(called_method))
end
end
#-------------------------------------------------------------------------# new method: process_confirm_compatibility_commands
#-------------------------------------------------------------------------def process_confirm_compatibility_commands
#--if $imported["YEA-CombatLogDisplay"]
@confirm_command_window.set_handler(:combatlog, method(:open_combatlog))
end
#--end
#-------------------------------------------------------------------------# new method: start_confirm_command_selection

#-------------------------------------------------------------------------def start_confirm_command_selection
if $imported["YEA-BattleEngine"]
@status_window.show
redraw_current_status
@status_aid_window.hide
end
@status_window.unselect
@actor_command_window.hide
@confirm_command_window.setup
end
#-------------------------------------------------------------------------# new method: on_confirm_cancel
#-------------------------------------------------------------------------def on_confirm_cancel
@confirm_command_window.hide unless @confirm_command_window.nil?
@actor_command_window.show
@actor_command_window.setup(BattleManager.actor)
@status_window.select(BattleManager.actor.index)
prior_command unless BattleManager.actor.inputable?
end
#-------------------------------------------------------------------------# alias method: next_command
#-------------------------------------------------------------------------alias scene_battle_next_command_bcl next_command
def next_command
if prompt_next_actor?
scene_battle_next_command_bcl
elsif YEA::BATTLE_COMMANDS::USE_CONFIRM_WINDOW
start_confirm_command_selection
else
turn_start
end
end
#-------------------------------------------------------------------------# new method: prompt_next_actor?
#-------------------------------------------------------------------------def prompt_next_actor?
index = @status_window.index
last_index = $game_party.battle_members.size - 1
for member in $game_party.battle_members.reverse
break if member.inputable?
last_index -= 1
end
if index >= last_index
actor = $game_party.battle_members[index]
return true if prompt_ftb_action?(actor)
return true if actor.next_command_valid?
return false if YEA::BATTLE_COMMANDS::USE_CONFIRM_WINDOW
end
return true
end
#-------------------------------------------------------------------------# new method: prompt_ftb_action?
#-------------------------------------------------------------------------def prompt_ftb_action?(actor)

return
return
return
return
end

false unless $imported["YEA-BattleEngine"]

false unless $imported["YEA-BattleSystem-FTB"]
false unless BattleManager.btype?(:ftb)
actor.current_action.valid?

#-------------------------------------------------------------------------# new method: command_execute

#-------------------------------------------------------------------------def command_execute
@confirm_command_window.close
turn_start
end
#-------------------------------------------------------------------------# new method: command_name1
#-------------------------------------------------------------------------def command_name1
# Do nothing.
end
#-------------------------------------------------------------------------# new method: command_name2
#-------------------------------------------------------------------------def command_name2
# Do nothing.
end
end # Scene_Battle
#==============================================================================
#
# End of File
#
#==============================================================================