RPGMVX - ATTACK BUTTON

Posts

Pages: 1
In some games, specifically Pokemon, instead of a single attack button, you get a button that brings you to a menu with more attacks.
I had an idea where instead of having the attack, you can choose what attacks you want to use specifically, for example a punch or a kick. Sadly, I have no idea how to grey the attack option out in RPGMVX, and especially not how to get rid of it entirely, so that the skills option is left.
If you have a question, then please ask.
No clue with VX - but in VX Ace it's a simple comment out a line and it no longer draws the attack option. You need to look in something like Window_ActorCommand (that's the VX Ace file) - and it's a command that says "add_attack_command", commenting that out will make it no longer draw (or you can comment out the line in the "def add_attack_command" section).

Really, with a little searching in the script you should be able to figure out to do some simple mods like that.
I checked in the Wincodw_ActorCommand for scripts, and this is what I found:
author=RPG maker VX Window_ActorCommand Script
#==============================================================================
# ** Window_ActorCommand
#------------------------------------------------------------------------------
# This window is used to select actor commands, such as "Attack" or "Skill".
#==============================================================================

class Window_ActorCommand < Window_Command
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(128, , 1, 4)
self.active = false
end
#--------------------------------------------------------------------------
# * Setup
# actor : actor
#--------------------------------------------------------------------------
def setup(actor)
s1 = Vocab::attack
s2 = Vocab::skill
s3 = Vocab::guard
s4 = Vocab::item
if actor.class.skill_name_valid # Skill command name is valid?
s2 = actor.class.skill_name # Replace command name
end
@commands =
@item_max = 4
refresh
self.index = 0
end
end

Edit: What do you mean by commenting out?
Any line that starts with # is commented out - it's not read the engine when it runs code.

#==============================================================================
# ** Window_ActorCommand
#------------------------------------------------------------------------------
# This window is used to select actor commands, such as "Attack" or "Skill".
#==============================================================================

class Window_ActorCommand < Window_Command
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(128, [], 1, 4)
self.active = false
end
#--------------------------------------------------------------------------
# * Setup
# actor : actor
#--------------------------------------------------------------------------
def setup(actor)
s2 = Vocab::skill
s3 = Vocab::guard
s4 = Vocab::item
if actor.class.skill_name_valid # Skill command name is valid?
s2 = actor.class.skill_name # Replace command name
end
@commands = [s2, s3, s4]
@item_max = 3
refresh
self.index = 0
end
end

I made a slight change to the code there - it should now completely remove the attack option and you'll only have Skill, Guard, and Item in whatever names you use.

I just realized you'll need to make another change elsewhere as well because this window doesn't actually handle the values for selecting a particular option. I don't have VX - I find it a step back from both XP and Ace - so I can't be too much help, but I expect the further changes will need to be made in Scene_Battle (or the equivalent in VX).
Hey dude. This is the script for Scene_Battle. You seem to know what you are doing, and I don't trust myself with scripting, as I don't want to fuck up and have to start from the beginning(I've been working alot since we last spoke, making characters, items, classes, skills, ect.)
author=RPG Maker VX Scene_Battle script
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================

class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * Start processing
#--------------------------------------------------------------------------
def start
super
$game_temp.in_battle = true
@spriteset = Spriteset_Battle.new
@message_window = Window_BattleMessage.new
@action_battlers =
create_info_viewport
end
#--------------------------------------------------------------------------
# * Post-Start Processing
#--------------------------------------------------------------------------
def post_start
super
process_battle_start
end
#--------------------------------------------------------------------------
# * Termination Processing
#--------------------------------------------------------------------------
def terminate
super
dispose_info_viewport
@message_window.dispose
@spriteset.dispose
unless $scene.is_a?(Scene_Gameover)
$scene = nil if $BTEST
end
end
#--------------------------------------------------------------------------
# * Basic Update Processing
# main : Call from main update method
#--------------------------------------------------------------------------
def update_basic(main = false)
Graphics.update unless main # Update game screen
Input.update unless main # Update input information
$game_system.update # Update timer
$game_troop.update # Update enemy group
@spriteset.update # Update sprite set
@message_window.update # Update message window
end
#--------------------------------------------------------------------------
# * Wait a set amount of time
# duration : Wait time (number of frames)
# no_fast : Fast forward disabled
# A method for inserting a wait during scene class update processing.
# As a rule, update is called once for each frame, but during battle it
# can be difficult to grasp the processing flow, so this method is used#
# as an exception.
#--------------------------------------------------------------------------
def wait(duration, no_fast = false)
for i in 0...duration
update_basic
break if not no_fast and i >= duration / 2 and show_fast?
end
end
#--------------------------------------------------------------------------
# * Wait Until Message Display has Finished
#--------------------------------------------------------------------------
def wait_for_message
@message_window.update
while $game_message.visible
update_basic
end
end
#--------------------------------------------------------------------------
# * Wait Until Animation Display has Finished
#--------------------------------------------------------------------------
def wait_for_animation
while @spriteset.animation?
update_basic
end
end
#--------------------------------------------------------------------------
# * Determine Fast Forward
#--------------------------------------------------------------------------
def show_fast?
return (Input.press?(Input::A) or Input.press?(Input::C))
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
update_basic(true)
update_info_viewport # Update information viewport
if $game_message.visible
@info_viewport.visible = false
@message_window.visible = true
end
unless $game_message.visible # Unless displaying a message
return if judge_win_loss # Determine win/loss results
update_scene_change
if @target_enemy_window != nil
update_target_enemy_selection # Select target enemy
elsif @target_actor_window != nil
update_target_actor_selection # Select target actor
elsif @skill_window != nil
update_skill_selection # Select skill
elsif @item_window != nil
update_item_selection # Select item
elsif @party_command_window.active
update_party_command_selection # Select party command
elsif @actor_command_window.active
update_actor_command_selection # Select actor command
else
process_battle_event # Battle event processing
process_action # Battle action
process_battle_event # Battle event processing
end
end
end
#--------------------------------------------------------------------------
# * Create Information Display Viewport
#--------------------------------------------------------------------------
def create_info_viewport
@info_viewport = Viewport.new(0, 288, 544, 128)
@info_viewport.z = 100
@status_window = Window_BattleStatus.new
@party_command_window = Window_PartyCommand.new
@actor_command_window = Window_ActorCommand.new
@status_window.viewport = @info_viewport
@party_command_window.viewport = @info_viewport
@actor_command_window.viewport = @info_viewport
@status_window.x = 128
@actor_command_window.x = 544
@info_viewport.visible = false
end
#--------------------------------------------------------------------------
# * Dispose of Information Display Viewport
#--------------------------------------------------------------------------
def dispose_info_viewport
@status_window.dispose
@party_command_window.dispose
@actor_command_window.dispose
@info_viewport.dispose
end
#--------------------------------------------------------------------------
# * Update Information Display Viewport
#--------------------------------------------------------------------------
def update_info_viewport
@party_command_window.update
@actor_command_window.update
@status_window.update
if @party_command_window.active and @info_viewport.ox > 0
@info_viewport.ox -= 16
elsif @actor_command_window.active and @info_viewport.ox < 128
@info_viewport.ox += 16
end
end
#--------------------------------------------------------------------------
# * Battle Event Processing
#--------------------------------------------------------------------------
def process_battle_event
loop do
return if judge_win_loss
return if $game_temp.next_scene != nil
$game_troop.interpreter.update
$game_troop.setup_battle_event
wait_for_message
process_action if $game_troop.forcing_battler != nil
return unless $game_troop.interpreter.running?
update_basic
end
end
#--------------------------------------------------------------------------
# * Determine Win/Loss Results
#--------------------------------------------------------------------------
def judge_win_loss
if $game_temp.in_battle
if $game_party.all_dead?
process_defeat
return true
elsif $game_troop.all_dead?
process_victory
return true
else
return false
end
else
return true
end
end
#--------------------------------------------------------------------------
# * End Battle
# result : Results (0: win, 1: escape, 2:lose)
#--------------------------------------------------------------------------
def battle_end(result)
if result == 2 and not $game_troop.can_lose
call_gameover
else
$game_party.clear_actions
$game_party.remove_states_battle
$game_troop.clear
if $game_temp.battle_proc != nil
$game_temp.battle_proc.call(result)
$game_temp.battle_proc = nil
end
unless $BTEST
$game_temp.map_bgm.play
$game_temp.map_bgs.play
end
$scene = Scene_Map.new
@message_window.clear
Graphics.fadeout(30)
end
$game_temp.in_battle = false
end
#--------------------------------------------------------------------------
# * Go to Command Input for Next Actor
#--------------------------------------------------------------------------
def next_actor
loop do
if @actor_index == $game_party.members.size-1
start_main
return
end
@status_window.index = @actor_index += 1
@active_battler = $game_party.members
if @active_battler.auto_battle
@active_battler.make_action
next
end
break if @active_battler.inputable?
end
start_actor_command_selection
end
#--------------------------------------------------------------------------
# * Go to Command Input of Previous Actor
#--------------------------------------------------------------------------
def prior_actor
loop do
if @actor_index == 0
start_party_command_selection
return
end
@status_window.index = @actor_index -= 1
@active_battler = $game_party.members
next if @active_battler.auto_battle
break if @active_battler.inputable?
end
start_actor_command_selection
end
#--------------------------------------------------------------------------
# * Start party command selection
#--------------------------------------------------------------------------
def start_party_command_selection
if $game_temp.in_battle
@status_window.refresh
@status_window.index = @actor_index = -1
@active_battler = nil
@info_viewport.visible = true
@message_window.visible = false
@party_command_window.active = true
@party_command_window.index = 0
@actor_command_window.active = false
$game_party.clear_actions
if $game_troop.surprise or not $game_party.inputable?
start_main
end
end
end
#--------------------------------------------------------------------------
# * Update Party Command Selection
#--------------------------------------------------------------------------
def update_party_command_selection
if Input.trigger?(Input::C)
case @party_command_window.index
when 0 # Fight
Sound.play_decision
@status_window.index = @actor_index = -1
next_actor
when 1 # Escape
if $game_troop.can_escape == false
Sound.play_buzzer
return
end
Sound.play_decision
process_escape
end
end
end
#--------------------------------------------------------------------------
# * Start Actor Command Selection
#--------------------------------------------------------------------------
def start_actor_command_selection
@party_command_window.active = false
@actor_command_window.setup(@active_battler)
@actor_command_window.active = true
@actor_command_window.index = 0
end
#--------------------------------------------------------------------------
# * Update Actor Command Selection
#--------------------------------------------------------------------------
def update_actor_command_selection
if Input.trigger?(Input::B)
Sound.play_cancel
prior_actor
elsif Input.trigger?(Input::C)
case @actor_command_window.index
when 0 # Attack
Sound.play_decision
@active_battler.action.set_attack
start_target_enemy_selection
when 1 # Skill
Sound.play_decision
start_skill_selection
when 2 # Guard
Sound.play_decision
@active_battler.action.set_guard
next_actor
when 3 # Item
Sound.play_decision
start_item_selection
end
end
end
#--------------------------------------------------------------------------
# * Start Target Enemy Selection
#--------------------------------------------------------------------------
def start_target_enemy_selection
@target_enemy_window = Window_TargetEnemy.new
@target_enemy_window.y = @info_viewport.rect.y
@info_viewport.rect.x += @target_enemy_window.width
@info_viewport.ox += @target_enemy_window.width
@actor_command_window.active = false
end
#--------------------------------------------------------------------------
# * End Target Enemy Selection
#--------------------------------------------------------------------------
def end_target_enemy_selection
@info_viewport.rect.x -= @target_enemy_window.width
@info_viewport.ox -= @target_enemy_window.width
@target_enemy_window.dispose
@target_enemy_window = nil
if @actor_command_window.index == 0
@actor_command_window.active = true
end
end
#--------------------------------------------------------------------------
# * Update Target Enemy Selection
#--------------------------------------------------------------------------
def update_target_enemy_selection
@target_enemy_window.update
if Input.trigger?(Input::B)
Sound.play_cancel
end_target_enemy_selection
elsif Input.trigger?(Input::C)
Sound.play_decision
@active_battler.action.target_index = @target_enemy_window.enemy.index
end_target_enemy_selection
end_skill_selection
end_item_selection
next_actor
end
end
#--------------------------------------------------------------------------
# * Start Target Actor Selection
#--------------------------------------------------------------------------
def start_target_actor_selection
@target_actor_window = Window_BattleStatus.new
@target_actor_window.index = 0
@target_actor_window.active = true
@target_actor_window.y = @info_viewport.rect.y
@info_viewport.rect.x += @target_actor_window.width
@info_viewport.ox += @target_actor_window.width
@actor_command_window.active = false
end
#--------------------------------------------------------------------------
# * End Target Actor Selection
#--------------------------------------------------------------------------
def end_target_actor_selection
@info_viewport.rect.x -= @target_actor_window.width
@info_viewport.ox -= @target_actor_window.width
@target_actor_window.dispose
@target_actor_window = nil
end
#--------------------------------------------------------------------------
# * Update Target Actor Selection
#--------------------------------------------------------------------------
def update_target_actor_selection
@target_actor_window.update
if Input.trigger?(Input::B)
Sound.play_cancel
end_target_actor_selection
elsif Input.trigger?(Input::C)
Sound.play_decision
@active_battler.action.target_index = @target_actor_window.index
end_target_actor_selection
end_skill_selection
end_item_selection
next_actor
end
end
#--------------------------------------------------------------------------
# * Start Skill Selection
#--------------------------------------------------------------------------
def start_skill_selection
@help_window = Window_Help.new
@skill_window = Window_Skill.new(0, 56, 544, 232, @active_battler)
@skill_window.help_window = @help_window
@actor_command_window.active = false
end
#--------------------------------------------------------------------------
# * End Skill Selection
#--------------------------------------------------------------------------
def end_skill_selection
if @skill_window != nil
@skill_window.dispose
@skill_window = nil
@help_window.dispose
@help_window = nil
end
@actor_command_window.active = true
end
#--------------------------------------------------------------------------
# * Update Skill Selection
#--------------------------------------------------------------------------
def update_skill_selection
@skill_window.active = true
@skill_window.update
@help_window.update
if Input.trigger?(Input::B)
Sound.play_cancel
end_skill_selection
elsif Input.trigger?(Input::C)
@skill = @skill_window.skill
if @skill != nil
@active_battler.last_skill_id = @skill.id
end
if @active_battler.skill_can_use?(@skill)
Sound.play_decision
determine_skill
else
Sound.play_buzzer
end
end
end
#--------------------------------------------------------------------------
# * Confirm Skill
#--------------------------------------------------------------------------
def determine_skill
@active_battler.action.set_skill(@skill.id)
@skill_window.active = false
if @skill.need_selection?
if @skill.for_opponent?
start_target_enemy_selection
else
start_target_actor_selection
end
else
end_skill_selection
next_actor
end
end
#--------------------------------------------------------------------------
# * Start Item Selection
#--------------------------------------------------------------------------
def start_item_selection
@help_window = Window_Help.new
@item_window = Window_Item.new(0, 56, 544, 232)
@item_window.help_window = @help_window
@actor_command_window.active = false
end
#--------------------------------------------------------------------------
# * End Item Selection
#--------------------------------------------------------------------------
def end_item_selection
if @item_window != nil
@item_window.dispose
@item_window = nil
@help_window.dispose
@help_window = nil
end
@actor_command_window.active = true
end
#--------------------------------------------------------------------------
# * Update Item Selection
#--------------------------------------------------------------------------
def update_item_selection
@item_window.active = true
@item_window.update
@help_window.update
if Input.trigger?(Input::B)
Sound.play_cancel
end_item_selection
elsif Input.trigger?(Input::C)
@item = @item_window.item
if @item != nil
$game_party.last_item_id = @item.id
end
if $game_party.item_can_use?(@item)
Sound.play_decision
determine_item
else
Sound.play_buzzer
end
end
end
#--------------------------------------------------------------------------
# * Confirm Item
#--------------------------------------------------------------------------
def determine_item
@active_battler.action.set_item(@item.id)
@item_window.active = false
if @item.need_selection?
if @item.for_opponent?
start_target_enemy_selection
else
start_target_actor_selection
end
else
end_item_selection
next_actor
end
end
#--------------------------------------------------------------------------
# * Battle Start Processing
#--------------------------------------------------------------------------
def process_battle_start
@message_window.clear
wait(10)
for name in $game_troop.enemy_names
text = sprintf(Vocab::Emerge, name)
$game_message.texts.push(text)
end
if $game_troop.preemptive
text = sprintf(Vocab::Preemptive, $game_party.name)
$game_message.texts.push(text)
elsif $game_troop.surprise
text = sprintf(Vocab::Surprise, $game_party.name)
$game_message.texts.push(text)
end
wait_for_message
@message_window.clear
make_escape_ratio
process_battle_event
start_party_command_selection
end
#--------------------------------------------------------------------------
# * Create Escape Ratio
#--------------------------------------------------------------------------
def make_escape_ratio
actors_agi = $game_party.average_agi
enemies_agi = $game_troop.average_agi
@escape_ratio = 150 - 100 * enemies_agi / actors_agi
end
#--------------------------------------------------------------------------
# * Escape Processing
#--------------------------------------------------------------------------
def process_escape
@info_viewport.visible = false
@message_window.visible = true
text = sprintf(Vocab::EscapeStart, $game_party.name)
$game_message.texts.push(text)
if $game_troop.preemptive
success = true
else
success = (rand(100) < @escape_ratio)
end
Sound.play_escape
if success
wait_for_message
battle_end(1)
else
@escape_ratio += 10
$game_message.texts.push('\.' + Vocab::EscapeFailure)
wait_for_message
$game_party.clear_actions
start_main
end
end
#--------------------------------------------------------------------------
# * Victory Processing
#--------------------------------------------------------------------------
def process_victory
@info_viewport.visible = false
@message_window.visible = true
RPG::BGM.stop
$game_system.battle_end_me.play
unless $BTEST
$game_temp.map_bgm.play
$game_temp.map_bgs.play
end
display_exp_and_gold
display_drop_items
display_level_up
battle_end(0)
end
#--------------------------------------------------------------------------
# * Display Gained Experience and Gold
#--------------------------------------------------------------------------
def display_exp_and_gold
exp = $game_troop.exp_total
gold = $game_troop.gold_total
$game_party.gain_gold(gold)
text = sprintf(Vocab::Victory, $game_party.name)
$game_message.texts.push('\|' + text)
if exp > 0
text = sprintf(Vocab::ObtainExp, exp)
$game_message.texts.push('\.' + text)
end
if gold > 0
text = sprintf(Vocab::ObtainGold, gold, Vocab::gold)
$game_message.texts.push('\.' + text)
end
wait_for_message
end
#--------------------------------------------------------------------------
# * Display Gained Drop Items
#--------------------------------------------------------------------------
def display_drop_items
drop_items = $game_troop.make_drop_items
for item in drop_items
$game_party.gain_item(item, 1)
text = sprintf(Vocab::ObtainItem, item.name)
$game_message.texts.push(text)
end
wait_for_message
end
#--------------------------------------------------------------------------
# * Display Level Up
#--------------------------------------------------------------------------
def display_level_up
exp = $game_troop.exp_total
for actor in $game_party.existing_members
last_level = actor.level
last_skills = actor.skills
actor.gain_exp(exp, true)
end
wait_for_message
end
#--------------------------------------------------------------------------
# * Defeat Processing
#--------------------------------------------------------------------------
def process_defeat
@info_viewport.visible = false
@message_window.visible = true
text = sprintf(Vocab::Defeat, $game_party.name)
$game_message.texts.push(text)
wait_for_message
battle_end(2)
end
#--------------------------------------------------------------------------
# * Execute Screen Switch
#--------------------------------------------------------------------------
def update_scene_change
case $game_temp.next_scene
when "map"
call_map
when "gameover"
call_gameover
when "title"
call_title
else
$game_temp.next_scene = nil
end
end
#--------------------------------------------------------------------------
# * Switch to Map Screen
#--------------------------------------------------------------------------
def call_map
$game_temp.next_scene = nil
battle_end(1)
end
#--------------------------------------------------------------------------
# * Switch to Game Over Screen
#--------------------------------------------------------------------------
def call_gameover
$game_temp.next_scene = nil
$scene = Scene_Gameover.new
@message_window.clear
end
#--------------------------------------------------------------------------
# * Switch to Title Screen
#--------------------------------------------------------------------------
def call_title
$game_temp.next_scene = nil
$scene = Scene_Title.new
@message_window.clear
Graphics.fadeout(60)
end
#--------------------------------------------------------------------------
# * Start Execution of Battle Processing
#--------------------------------------------------------------------------
def start_main
$game_troop.increase_turn
@info_viewport.visible = false
@info_viewport.ox = 0
@message_window.visible = true
@party_command_window.active = false
@actor_command_window.active = false
@status_window.index = @actor_index = -1
@active_battler = nil
@message_window.clear
$game_troop.make_actions
make_action_orders
wait(20)
end
#--------------------------------------------------------------------------
# * Create Action Orders
#--------------------------------------------------------------------------
def make_action_orders
@action_battlers =
unless $game_troop.surprise
@action_battlers += $game_party.members
end
unless $game_troop.preemptive
@action_battlers += $game_troop.members
end
for battler in @action_battlers
battler.action.make_speed
end
@action_battlers.sort! do |a,b|
b.action.speed - a.action.speed
end
end
#--------------------------------------------------------------------------
# * Battle Action Processing
#--------------------------------------------------------------------------
def process_action
return if judge_win_loss
return if $game_temp.next_scene != nil
set_next_active_battler
if @active_battler == nil
turn_end
return
end
@message_window.clear
wait(5)
@active_battler.white_flash = true
unless @active_battler.action.forcing
@active_battler.action.prepare
end
if @active_battler.action.valid?
execute_action
end
unless @active_battler.action.forcing
@message_window.clear
remove_states_auto
display_current_state
end
@active_battler.white_flash = false
@message_window.clear
end
#--------------------------------------------------------------------------
# * Execute Battle Actions
#--------------------------------------------------------------------------
def execute_action
case @active_battler.action.kind
when 0 # Basic
case @active_battler.action.basic
when 0 # Attack
execute_action_attack
when 1 # Guard
execute_action_guard
when 2 # Escape
execute_action_escape
when 3 # Wait
execute_action_wait
end
when 1 # Skill
execute_action_skill
when 2 # Item
execute_action_item
end
end
#--------------------------------------------------------------------------
# * End Turn
#--------------------------------------------------------------------------
def turn_end
$game_troop.turn_ending = true
$game_party.slip_damage_effect
$game_troop.slip_damage_effect
$game_party.do_auto_recovery
$game_troop.preemptive = false
$game_troop.surprise = false
process_battle_event
$game_troop.turn_ending = false
start_party_command_selection
end
#--------------------------------------------------------------------------
# * Set Next Battler to Act
# When the event command is being performed, set
# that battler and remove him from the list. Otherwise, get from top of
# list. If an actor that is not currently in the party is obtained (may
# occur if the index is nil, just after leaving via a battle event, etc.)
# it is skipped.
#--------------------------------------------------------------------------
def set_next_active_battler
loop do
if $game_troop.forcing_battler != nil
@active_battler = $game_troop.forcing_battler
@action_battlers.delete(@active_battler)
$game_troop.forcing_battler = nil
else
@active_battler = @action_battlers.shift
end
return if @active_battler == nil
return if @active_battler.index != nil
end
end
#--------------------------------------------------------------------------
# * Natural Removal of States
#--------------------------------------------------------------------------
def remove_states_auto
last_st = @active_battler.states
@active_battler.remove_states_auto
if @active_battler.states != last_st
wait(5)
display_state_changes(@active_battler)
wait(30)
@message_window.clear
end
end
#--------------------------------------------------------------------------
# * Show Current State
#--------------------------------------------------------------------------
def display_current_state
state_text = @active_battler.most_important_state_text
unless state_text.empty?
wait(5)
text = @active_battler.name + state_text
@message_window.add_instant_text(text)
wait(45)
@message_window.clear
end
end
#--------------------------------------------------------------------------
# * Execute Battle Action: Attack
#--------------------------------------------------------------------------
def execute_action_attack
text = sprintf(Vocab::DoAttack, @active_battler.name)
@message_window.add_instant_text(text)
targets = @active_battler.action.make_targets
display_attack_animation(targets)
wait(20)
for target in targets
target.attack_effect(@active_battler)
display_action_effects(target)
end
end
#--------------------------------------------------------------------------
# * Execute Battle Action: Guard
#--------------------------------------------------------------------------
def execute_action_guard
text = sprintf(Vocab::DoGuard, @active_battler.name)
@message_window.add_instant_text(text)
wait(45)
end
#--------------------------------------------------------------------------
# * Execute Battle Action: Escape
#--------------------------------------------------------------------------
def execute_action_escape
text = sprintf(Vocab::DoEscape, @active_battler.name)
@message_window.add_instant_text(text)
@active_battler.escape
Sound.play_escape
wait(45)
end
#--------------------------------------------------------------------------
# * Execute Battle Action: Wait
#--------------------------------------------------------------------------
def execute_action_wait
text = sprintf(Vocab::DoWait, @active_battler.name)
@message_window.add_instant_text(text)
wait(45)
end
#--------------------------------------------------------------------------
# * Execute Battle Action: Skill
#--------------------------------------------------------------------------
def execute_action_skill
skill = @active_battler.action.skill
text = @active_battler.name + skill.message1
@message_window.add_instant_text(text)
unless skill.message2.empty?
wait(10)
@message_window.add_instant_text(skill.message2)
end
targets = @active_battler.action.make_targets
display_animation(targets, skill.animation_id)
@active_battler.mp -= @active_battler.calc_mp_cost(skill)
$game_temp.common_event_id = skill.common_event_id
for target in targets
target.skill_effect(@active_battler, skill)
display_action_effects(target, skill)
end
end
#--------------------------------------------------------------------------
# * Execute Battle Action: Item
#--------------------------------------------------------------------------
def execute_action_item
item = @active_battler.action.item
text = sprintf(Vocab::UseItem, @active_battler.name, item.name)
@message_window.add_instant_text(text)
targets = @active_battler.action.make_targets
display_animation(targets, item.animation_id)
$game_party.consume_item(item)
$game_temp.common_event_id = item.common_event_id
for target in targets
target.item_effect(@active_battler, item)
display_action_effects(target, item)
end
end
#--------------------------------------------------------------------------
# * Show Animation
# targets : Target array
# animation_id : Animation ID (-1: same as normal attack)
#--------------------------------------------------------------------------
def display_animation(targets, animation_id)
if animation_id < 0
display_attack_animation(targets)
else
display_normal_animation(targets, animation_id)
end
wait(20)
wait_for_animation
end
#--------------------------------------------------------------------------
# * Show Attack Animation
# targets : Target array
# If enemy, play the sound effect and wait
# a moment. If actor, take dual wielding into account (display left hand
# weapon reversed)
#--------------------------------------------------------------------------
def display_attack_animation(targets)
if @active_battler.is_a?(Game_Enemy)
Sound.play_enemy_attack
wait(15, true)
else
aid1 = @active_battler.atk_animation_id
aid2 = @active_battler.atk_animation_id2
display_normal_animation(targets, aid1, false)
display_normal_animation(targets, aid2, true)
end
wait_for_animation
end
#--------------------------------------------------------------------------
# * Show Normal Animation
# targets : Target array
# animation_id : Animation ID
# mirror : Flip horizontal
#--------------------------------------------------------------------------
def display_normal_animation(targets, animation_id, mirror = false)
animation = $data_animations
if animation != nil
to_screen = (animation.position == 3) # Is the positon "screen"?
for target in targets.uniq
target.animation_id = animation_id
target.animation_mirror = mirror
wait(20, true) unless to_screen # If for one, wait
end
wait(20, true) if to_screen # If for all, wait
end
end
#--------------------------------------------------------------------------
# * Show Action Results
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_action_effects(target, obj = nil)
unless target.skipped
line_number = @message_window.line_number
wait(5)
display_critical(target, obj)
display_damage(target, obj)
display_state_changes(target, obj)
if line_number == @message_window.line_number
display_failure(target, obj) unless target.states_active?
end
if line_number != @message_window.line_number
wait(30)
end
@message_window.back_to(line_number)
end
end
#--------------------------------------------------------------------------
# * Show Critical Hit
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_critical(target, obj = nil)
if target.critical
if target.actor?
text = Vocab::CriticalToActor
else
text = Vocab::CriticalToEnemy
end
@message_window.add_instant_text(text)
wait(20)
end
end
#--------------------------------------------------------------------------
# * Show Damage
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_damage(target, obj = nil)
if target.missed
display_miss(target, obj)
elsif target.evaded
display_evasion(target, obj)
else
display_hp_damage(target, obj)
display_mp_damage(target, obj)
end
end
#--------------------------------------------------------------------------
# * Show Miss
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_miss(target, obj = nil)
if obj == nil or obj.physical_attack
if target.actor?
text = sprintf(Vocab::ActorNoHit, target.name)
else
text = sprintf(Vocab::EnemyNoHit, target.name)
end
Sound.play_miss
else
text = sprintf(Vocab::ActionFailure, target.name)
end
@message_window.add_instant_text(text)
wait(30)
end
#--------------------------------------------------------------------------
# * Show Escape
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_evasion(target, obj = nil)
if target.actor?
text = sprintf(Vocab::ActorEvasion, target.name)
else
text = sprintf(Vocab::EnemyEvasion, target.name)
end
Sound.play_evasion
@message_window.add_instant_text(text)
wait(30)
end
#--------------------------------------------------------------------------
# * Show HP Damage
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_hp_damage(target, obj = nil)
if target.hp_damage == 0 # No damage
return if obj != nil and obj.damage_to_mp
return if obj != nil and obj.base_damage == 0
fmt = target.actor? ? Vocab::ActorNoDamage : Vocab::EnemyNoDamage
text = sprintf(fmt, target.name)
elsif target.absorbed # Absorb
fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
text = sprintf(fmt, target.name, Vocab::hp, target.hp_damage)
elsif target.hp_damage > 0 # Damage
if target.actor?
text = sprintf(Vocab::ActorDamage, target.name, target.hp_damage)
Sound.play_actor_damage
$game_troop.screen.start_shake(5, 5, 10)
else
text = sprintf(Vocab::EnemyDamage, target.name, target.hp_damage)
Sound.play_enemy_damage
target.blink = true
end
else # Recovery
fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
text = sprintf(fmt, target.name, Vocab::hp, -target.hp_damage)
Sound.play_recovery
end
@message_window.add_instant_text(text)
wait(30)
end
#--------------------------------------------------------------------------
# * Show MP Damage
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_mp_damage(target, obj = nil)
return if target.dead?
return if target.mp_damage == 0
if target.absorbed # Absorb
fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)
elsif target.mp_damage > 0 # Damage
fmt = target.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)
else # Recovery
fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
text = sprintf(fmt, target.name, Vocab::mp, -target.mp_damage)
Sound.play_recovery
end
@message_window.add_instant_text(text)
wait(30)
end
#--------------------------------------------------------------------------
# * Show State Change
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_state_changes(target, obj = nil)
return if target.missed or target.evaded
return unless target.states_active?
if @message_window.line_number < 4
@message_window.add_instant_text("")
end
display_added_states(target, obj)
display_removed_states(target, obj)
display_remained_states(target, obj)
if @message_window.last_instant_text.empty?
@message_window.back_one
else
wait(10)
end
end
#--------------------------------------------------------------------------
# * Show Added State
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_added_states(target, obj = nil)
for state in target.added_states
if target.actor?
next if state.message1.empty?
text = target.name + state.message1
else
next if state.message2.empty?
text = target.name + state.message2
end
if state.id == 1 # Incapacitated
target.perform_collapse
end
@message_window.replace_instant_text(text)
wait(20)
end
end
#--------------------------------------------------------------------------
# * Show Removed State
# target : Target
# obj : Skill or item
#--------------------------------------------------------------------------
def display_removed_states(target, obj = nil)
for state in target.removed_states
next if state.message4.empty?
text = target.name + state.message4
@message_window.replace_instant_text(text)
wait(20)
end
end
#--------------------------------------------------------------------------
# * Show Unchanged State
# target : Target
# obj : Skill or item
# Used when trying to put someone to sleep who is already asleep, etc.
#--------------------------------------------------------------------------
def display_remained_states(target, obj = nil)
for state in target.remained_states
next if state.message3.empty?
text = target.name + state.message3
@message_window.replace_instant_text(text)
wait(20)
end
end
#--------------------------------------------------------------------------
# * Show Failure
# target : Target (actor)
# obj : Skill or item
#--------------------------------------------------------------------------
def display_failure(target, obj)
text = sprintf(Vocab::ActionFailure, target.name)
@message_window.add_instant_text(text)
wait(20)
end
end
Well, this looks nice and easy; can't test to see if it works but...

Find this section in Scene_Battle and replace what's there with what's here and it should take care of it. Indentation doesn't matter; it's just my personal preference for how to format code.


#--------------------------------------------------------------------------
# * Update Actor Command Selection
#--------------------------------------------------------------------------
def update_actor_command_selection
if Input.trigger?(Input::B)
Sound.play_cancel
prior_actor
elsif Input.trigger?(Input::C)
case @actor_command_window.index
when 0 # Skill
Sound.play_decision
start_skill_selection
when 1 # Guard
Sound.play_decision
@active_battler.action.set_guard
next_actor
when 2 # Item
Sound.play_decision
start_item_selection
end
end
end

If you're looking to get any sort of start on scripting, just compare the originals of both sections to the altered versions I posted; they're pretty simple changes, so it's not hard to understand what I did.

There's probably some other sections of Scene_Battle that can be removed since you're no longer calling them (basically the ones that just handle regular attacks), but it doesn't hurt to leave them in - the size they add to the file is negligible (a couple kilobytes, max, if they're not well written).

Keep in mind - this just keeps the player from use the attack command. You need to make sure when making enemies that they, too, don't use the regular attack command if you want to keep the verisimilitude of the setting - but because the basic attack code was left in place, it's still possible for enemies to use the "Attack" command should you wish.
I guess I'll have to make due. I'm sadly unable to do it.
This time, what it did was not draw the attack button. Instead of removing the ability to attack however, it makes the Skill button act like the attack button, the Guard button act like a Skill button, and the Item button act like the Guard button. All it did was move the commands up.
Apparently, editing the scripts can't fix this. :|
Edit: I tried something new, and it didn't work. I pretty much used what you used, but kept the numbers the same, meaning instead of Skill being 0, it was 1. I went into the battle, and Skill was still an attack instead of Skill. .3.
This is why I don't like working with unformatted code - it makes it hard to read and find things. In the future, just to make it easier for everyone, use the code tag and not the quote tag - it'll preserve formatting like in my snippets.

Yes, editing the scripts can fix it - I've done some pretty heavy battle edits before, so I know what scripting can do for the battle menus. =P

Did you save before running the test? Any time you alter scripts, you need to save before running a battle test so that it compiles the scripts. If you don't, the battle test runs using the last compiled set of scripts you have.

Basically, what the last snippet I posted does is account for what you just described by changing the index values to match - Skills becomes Index 0, Guard Index 1, and Items Index 2.

If after saving so it compiles my fix didn't work, then either a) you have another script that's overwriting the default battle scene, or b) there's another place aside from Scene_Battle that also somehow deals with this particular function.
So I did as I said, saving before running the test, and now the Skill button doesn't do anything whatsoever. Also, Guard acts like Skill and Item acts like Guard. I am going to take a look at the edits you made, and see if returning one of them to default will help.

Edit: So I returned the Window_ActorCommand script to normal and so the Attack button returned, but with the function of the Skill Button, and you get the drill, as the other Buttons began to act like other Buttons. Nonetheless, that seems to be the issue, seeing as returning the Scene_Battle to normal still got the Skill button to not do anything, even after saving. I assume the ActorCommand somehow deals with the numbers, and I assume that this means that the number for the final option should still be used, even if it doesn't do anything.
So, I shouldn't mess with ActorCommand, and should instead look for another way to fix it, most likely dealing with numbers.

Edit 2: Now I feel like a fucking idiot.
I had two Scene_Battle, and most likely the game read both. I don't know how I got the two Scene_Battle, but it happened. Anyways, it's finally working. Thanks dude. :3
It sounds like either you have another script that's defining the battle command menu actions or there's another place that also reads the input from the command box to determine what to do. Either case, I can't really help as I don't have access to the scripts you're using or the VX default scripts to scour for where it might be.

... wait, no, there's another section in Scene_Battle that references action types, but I don't quite... urg, this is why I don't like bad formatting on code/not having access to the entire script library to figure out what is doing what. =/

Yeah, to be able to know the correct changes to make to that section, I'd need to see the battler code as well, cause it's making calls to functions of the active battler to set the numbers.
Pages: 1