MasterMoes 19 Posted March 19 Hello again, I'm wondering if there is a way to disable the "pass turn" feature in Yanfly's Battle Engine script. When you press the left and right keys, you can scroll through the actors and select their skills. The only problem is that 1) it lets the player skip turns when I want the player to have to make actions and 2) when you press the right arrow key while selecting the skills of the final actor, it begins the battle sequence, which often leads to accidentally skipping an actor's turn. Here is the link to the script: https://yanflychannel.wordpress.com/rmvxa/battle-scripts/ace-battle-engine/ Share this post Link to post Share on other sites
roninator2 256 Posted March 20 (edited) TheoAllen wrote this for that. It disables the left and right arrow. # TheoAllen class Window_ActorCommand # -------------------------------------------------------------------------- # Delete Handling # -------------------------------------------------------------------------- def process_dir6 end def process_dir4 end end class Scene_Battle # -------------------------------------------------------------------------- # Overwrites # -------------------------------------------------------------------------- def create_actor_command_window scene_battle_create_actor_command_window_abe end end If you want it to be more complex than that, there will be a fair bit of code editing needed. I know there is a script to confirm battle commands as well. Maybe try that in addition to this script. Yanfly Battle Command List Edited March 20 by roninator2 1 Share this post Link to post Share on other sites
PhoenixSoul 1,404 Posted March 23 Yanfly-Battle Command: Yanfly - Battle Command List.rb Or, alternatively, copy and paste this: Spoiler #============================================================================== # # ¥ Yanfly Engine Ace - # -- 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 false unless $imported["YEA-BattleEngine"] return false unless $imported["YEA-BattleSystem-FTB"] return false unless BattleManager.btype?(:ftb) return actor.current_action.valid? end #-------------------------------------------------------------------------- # 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 # #============================================================================== Share this post Link to post Share on other sites
MasterMoes 19 Posted March 28 Thank you, this should work! 1 Share this post Link to post Share on other sites
