[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Les forums - [[Rpg maker XP]] Gestion du combat de base

Afin que tu ais plus de précision, mon problème se situe dans ce
morceau de script :

C'est une partie d'un script ATB, il utilise beaucoup d'Alias et de
redéfinition de méthode.
Et lors du jeu, il bloque la bataille dès qu'un évènement de combat
est déclenché.
Je me suis dit qu'en comprenant un peu mieux le code originel des
combats je pourrais en venir à bout, mais non...
Il manque une chose afin que les commandes évent soit fonction-
nelles, j'ai donc réécrit la def setup_battle_event et j'ai
placé un morceau d'update au bon endroit.
Les ajouts que j'ai fait ne fond pas planter le code mais cela ne
change rien à l'affaire.

T'aurais pas une idée ? (je suis certain que c'est ce script qui foire
car sans lui tout marche. Mais je tient absolument à l'utiliser.)
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  include N01
  #--------------------------------------------------------------------------
  alias acbs_main_atb main
  def main
    turn_count_speed  
    @escape_ratio = 40
    $game_temp.escape_count = 0
    @escape_type, @escape_name = Escape_Type, Escape_Name
    @input_battlers, @action_battlers = [], []
    @input_battler, @action_battler = nil, nil
    @escaped = @update_turn_end = @action_phase = false
    acbs_main_atb
  end
  #--------------------------------------------------------------------------
  alias acbs_start_atb start
  def start
    acbs_start_atb
    add_bars
    for battler in $game_party.actors + $game_troop.enemies
      battler.turn_count = 0
      battler.atb = 0
      battler.atb_preset
      battler.cast_action = nil
      battler.cast_target = nil
      battler.defense_pose = false
    end
    for actor in $game_party.actors
      actor.atb = actor.max_atb - 1 if $preemptive
      actor.atb = 0 if $back_attack 
    end
    for enemy in $game_troop.enemies
      enemy.atb = 0 if $preemptive
      enemy.atb = enemy.max_atb - 1 if $back_attack 
    end
    update_meters
  end
  #--------------------------------------------------------------------------
  alias acbs_terminate_atb terminate
  def terminate
    acbs_terminate_atb
    remove_bars
  end
  #--------------------------------------------------------------------------
  def add_bars
    @atb_meters = ATB_Meters.new if Meters
    @atb_meters_enemy = ATB_Meters_Enemy.new if Enemy_Meter != 0 and Meters
    @atb_bars = ATB_Bars.new if Bars
  end
  #--------------------------------------------------------------------------
  def remove_bars
    @atb_meters.dispose if Meters
    @atb_bars.dispose if Bars
    @atb_meters_enemy.dispose if Enemy_Meter != 0 and Meters
  end
  #--------------------------------------------------------------------------
  alias acbs_update_atb update
  def update
    if @phase == 1
      $game_temp.battle_main_phase = true
      @actor_command_window.opacity = 0
      @phase = 0
    elsif @phase != 5
      @phase = 0
    end
    @event_running = true if $game_system.battle_interpreter.running?
    acbs_update_atb
    if $game_system.battle_interpreter.running?
      return
    elsif @event_running
      @status_window.refresh
      @event_running = false
    end
    return $scene = Scene_Gameover.new if $game_temp.gameover
    return update_phase5 if @phase == 5
    @event_running = true if $game_system.battle_interpreter.running?
    if @update_turn_end
      turn_ending 
      @update_turn_end = false
    end
    if Input.press?(Escape_Input) and @escape_type > 0 
      if $game_temp.battle_can_escape
        $game_temp.max_escape_count = update_phase2_escape_rate
        $game_temp.escape_count += 2 unless @wait_on
        @escaping = true
        if !@help_window.visible and @escape_type == 1
          @help_window.set_text('')
          @help_window.set_text(Escape_Message, 1)
        end
        if @escape_type == 2
          if @escape_atb_meters.nil?
            @escape_atb_meters = Escape_Meters.new
            @escape_meter_opacity = 0
            @escape_atb_meters.visible = true
          else @escape_atb_meters != nil
            @escape_atb_meters.opacity = 15 * @escape_meter_opacity
            @escape_meter_opacity = [@escape_meter_opacity + 1, 17].min
            @escape_atb_meters.refresh
          end
        end
        if $game_temp.escape_count >= $game_temp.max_escape_count
          $game_temp.escape_count = 0
          update_phase2_escape unless $game_party.all_dead?
        end
      else
        @help_window.set_text(Cant_Escape_Message, 1) if @escape_type == 1        
        if @escape_type == 2       
          if @escape_atb_meters.nil?
            @escape_atb_meters = Escape_Meters.new
            @escape_meter_opacity = 0
            @escape_atb_meters.visible = true
          else @escape_atb_meters != nil
            @escape_atb_meters.opacity = 15 * @escape_meter_opacity
            @escape_meter_opacity = [@escape_meter_opacity + 1, 17].min
            @escape_atb_meters.refresh
          end
        end
      end
    elsif @escape_type > 0
      if @escaping
        @escaping = false
        @help_window.visible = false
      end
      $game_temp.escape_count = [$game_temp.escape_count - 1, 0].max unless @wait_on
      if @escape_atb_meters != nil and $game_temp.escape_count == 0
        @escape_atb_meters.opacity = 15 * @escape_meter_opacity
        @escape_meter_opacity = [@escape_meter_opacity - 1, 0].max
        if @escape_meter_opacity == 0
          @escape_atb_meters.dispose 
          @escape_atb_meters = nil
        end
      end
      @escape_atb_meters.refresh if @escape_atb_meters != nil
    end
    return if @escaped
    atb_update
    input_battler_update(false)
    if @action_battlers[0] != nil && @action_battler.nil?
      @action_battlers.flatten!
      @action_battler = @action_battlers[0]
      if @action_battler.dead?
        @action_battler.atb = 0
        @action_battler = nil
      else
        start_phase4
      end
    end
    if @action_battler != nil && !@spriteset.effect?
      @active_battler = @action_battler
      update_phase4
    end
  end
  #--------------------------------------------------------------------------
  alias acbs_judge_atb judge
  def judge
    @end_battle = acbs_judge_atb
    return @end_battle
  end
  #--------------------------------------------------------------------------
  alias acbs_update_basic_atb update_basic
  def update_basic
    atb_update unless @battle_start
    input_battler_update(true)
    acbs_update_basic_atb
  end
  #--------------------------------------------------------------------------
  def input_battler_update(basic)
    for battler in  $game_troop.enemies + $game_party.actors
      if battler.atb_full? and battler != @action_battler and not
         @action_battlers.include?(battler)
        battler_turn(battler)
        break if Wait_Act_End and not battler.actor?
      end
    end
    if @input_battlers[0] != nil && @input_battler.nil? && !@wait_on
      @input_battlers.flatten!
      @input_battler = @input_battlers[0]
      if @input_battler.current_action.forcing || @input_battler.restriction == 2 || 
        @input_battler.restriction == 3
        if @input_battler.restriction == 2 || @input_battler.restriction == 3
          @input_battler.current_action.kind = 0
          @input_battler.current_action.basic = 0
        end
        @input_battler.defense_pose = false
        @action_battlers << @input_battler
        @input_battlers.shift
        @input_battler = nil
      elsif @input_battler.inputable?
        @actor_index = $game_party.actors.index(@input_battler)
        @input_battler.current_action.clear
        @input_battler.blink = true
      else
        @input_battler.atb_update
        @input_battlers.shift
        @input_battler = nil
      end
    end
    if @input_battler != nil
      @input_action = true if basic
      @now_battler = @active_battler
      @active_battler = @input_battler
      @input_battler.defense_pose = false
      phase3_setup_command_window if @actor_command_window.opacity == 0
      update_phase3
      @active_battler = @now_battler
      @input_action = false if basic
    end
    for battler in $game_party.actors + $game_troop.enemies
      if battler.dead? or not battler.exist?
        @input_battlers.delete(battler)
        @action_battlers.delete(battler)
      end
    end
  end
  #--------------------------------------------------------------------------
  def battler_turn(battler)
    battler.turn_count += 1
    if battler.is_a?(Game_Actor)
      if battler.inputable? and battler.cast_action.nil?
        @input_battlers << battler
      else
        if battler.restriction == 2 || battler.restriction == 3
          battler.current_action.kind = 0
          battler.current_action.basic = 0
        end
        battler.defense_pose = false
        @action_battlers << battler
      end
    else
      battler.make_action
      @action_battlers << battler
    end
  end
  
  #==========================================================================
  #Ajout de def Battle event Setup + update
  #==========================================================================
  
  #--------------------------------------------------------------------------
  # * Battle Event Setup
  #--------------------------------------------------------------------------
  def setup_battle_event
    # If battle event is running
    if $game_system.battle_interpreter.running?
      return
    end
    # Search for all battle event pages
    for index in 0...$data_troops[@troop_id].pages.size
      # Get event pages
      page = $data_troops[@troop_id].pages[index]
      # Make event conditions possible for reference with c
      c = page.condition
      # Go to next page if no conditions are appointed
      unless c.turn_valid or c.enemy_valid or
             c.actor_valid or c.switch_valid
        next
      end
      # Go to next page if action has been completed
      if $game_temp.battle_event_flags[index]
        next
      end
      # Confirm turn conditions
      if c.turn_valid
        n = $game_temp.battle_turn
        a = c.turn_a
        b = c.turn_b
        if (b == 0 and n != a) or
           (b > 0 and (n < 1 or n < a or n % b != a % b))
          next
        end
      end
      # Confirm enemy conditions
      if c.enemy_valid
        enemy = $game_troop.enemies[c.enemy_index]
        if enemy == nil or enemy.hp * 100.0 / enemy.maxhp > c.enemy_hp
          next
        end
      end
      # Confirm actor conditions
      if c.actor_valid
        actor = $game_actors[c.actor_id]
        if actor == nil or actor.hp * 100.0 / actor.maxhp > c.actor_hp
          next
        end
      end
      # Confirm switch conditions
      if c.switch_valid
        if $game_switches[c.switch_id] == false
          next
        end
      end
      # Set up event
      $game_system.battle_interpreter.setup(page.list, 0)
      # If this page span is [battle] or [turn]
      if page.span <= 1
        # Set action completed flag
        $game_temp.battle_event_flags[index] = true
      end
      return
    end
  end
  
  #==========================================================================
  # Fin de l'ajout
  #==========================================================================
  
  #--------------------------------------------------------------------------
  def atb_update
    @wait_on = wait_on
    return if @wait_on
    @atb_turn_count += 1 if Custom_Turn_Count == 2
    if @atb_turn_count >= @abt_turn_speed
      @update_turn_end = true
      $game_temp.battle_turn += 1
      turn_count_speed
      for battler in $game_party.actors + $game_troop.enemies
        battler.remove_states_auto if battler.exist?
      end
    #========================================================================
    #           Ajout d'update pour les event de combat
    #========================================================================
    
    if $game_system.battle_interpreter.running?
      # Update interpreter
      $game_system.battle_interpreter.update
      # If a battler which is forcing actions doesn't exist
      if $game_temp.forcing_battler == nil
        # If battle event has finished running
        unless $game_system.battle_interpreter.running?
          # Rerun battle event set up if battle continues
          unless judge
            setup_battle_event
          end
        end
        if @phase != 5
          # Refresh status window
          @status_window.refresh
        end
      end
    end
    # If battler forcing an action doesn't exist,
    # and battle event is running
    if $game_temp.forcing_battler == nil and
       $game_system.battle_interpreter.running?
      return
    end
    #========================================================================
    #                  Fin de l'ajout
    #========================================================================
      #setup_battle_event         # Désactivé car redondant
    end
    for battler in $game_party.actors + $game_troop.enemies
      unless battler == @action_battler or
         (@escaping and battler.actor? and @escape_type > 0)
        battler.atb_update if battler.exist? and not battler.restriction == 4
      end
    end
    update_meters
  end
  #--------------------------------------------------------------------------
  def wait_on
    return true if $game_system.wait_mode == 1 and (@skill_window != nil or @item_window != nil)
    return true if $game_system.wait_mode == 0 and @input_battler != nil
    return true if $game_system.action_wait and @action_battler != nil
    return true if @force_wait or @battle_end or @escaped
    return false
  end
  #--------------------------------------------------------------------------
  def start_phase2
  end
  #--------------------------------------------------------------------------
  def update_meters
    @atb_meters.refresh if Meters
    @atb_meters_enemy.refresh if Enemy_Meter != 0 and Meters
    @atb_bars.refresh if Bars
  end
  #--------------------------------------------------------------------------
  def turn_count_speed
    @atb_turn_count = @abt_turn_speed = 0
    case Custom_Turn_Count
    when 0
      for battler in $game_party.actors + $game_troop.enemies
        @abt_turn_speed += 1 if battler.exist?
      end
    when 1
      @abt_turn_speed = Action_Turn_Count
    when 2
      @abt_turn_speed = Time_Tunr_Count
    end
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape
    windows_dispose
    update_phase2_escape_type1 if @escape_type == 0 
    update_phase2_escape_type2 if @escape_type > 0
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape_type1
    enemies_agi = enemies_number = 0
    for enemy in $game_troop.enemies
      if enemy.exist?
        enemies_agi += enemy.agi
        enemies_number += 1
      end
    end
    enemies_agi /= [enemies_number, 1].max
    actors_agi = actors_number = 0
    for actor in $game_party.actors
      if actor.exist?
        actors_agi += actor.agi
        actors_number += 1
      end
    end
    actors_agi /= [actors_number, 1].max
    @success = rand(100) < @escape_ratio * actors_agi / enemies_agi
    if @success
      @battle_end = true
      $game_system.se_play($data_system.escape_se)
      $game_system.bgm_play($game_temp.map_bgm)
      battle_end(1)
    else
      @escape_ratio += 3
      phase3_next_actor
    end
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape_type2
    @escaped = true
    @party_command_window.visible = false
    @party_command_window.active = false
    @actor_command_window.visible = false if @actor_command_window != nil
    @actor_command_window.active = false if @actor_command_window != nil
    wait(1)
    @battle_end = true
    $game_system.se_play($data_system.escape_se)
    $game_system.bgm_play($game_temp.map_bgm)
    if @escape_atb_meters != nil
      @escape_atb_meters.dispose 
      @escape_atb_meters = nil
    end
    battle_end(1)
  end
  #--------------------------------------------------------------------------
  def update_phase2_escape_rate
    enemies_agi = enemies_number = 0
    for enemy in $game_troop.enemies
      if enemy.exist?
        enemies_agi += enemy.agi
        enemies_number += 1
      end
    end
    enemies_agi /= [enemies_number, 1].max
    actors_agi = actors_number = 0
    for actor in $game_party.actors
      if actor.exist?
        actors_agi += actor.agi
        actors_number += 1
      end
    end
    actors_agi /= [actors_number, 1].max
    escape_rate = Escape_Time * enemies_agi / (actors_agi * Speed)
    return escape_rate
  end
  #--------------------------------------------------------------------------
  alias acbs_start_phase5_atb start_phase5
  def start_phase5
    if @input_battler != nil
      @help_window.visible = false if @help_window != nil
      windows_dispose
      @input_battler.blink = false if @input_battler != nil
    end
    @atb_meters.opacity = 0 if Meter_Pos_Style == 3
    update_meters
    acbs_start_phase5_atb
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase5_atb update_phase5
  def update_phase5
    windows_dispose
    acbs_update_phase5_atb
  end
  #--------------------------------------------------------------------------
  def phase3_setup_command_window
    return if @escaped
    if @active_battler != nil && @active_battler.cast_action != nil
      @active_battler.blink = false
      return    
    end
    Audio.se_play('Audio/SE/' + Command_Up_SE)    
    @party_command_window.active = false
    @party_command_window.visible = false
    @actor_command_window.dispose if @actor_command_window != nil
    s1 = $data_system.words.attack
    s2 = $data_system.words.skill
    s3 = $data_system.words.item
    s4 = $data_system.words.guard
    s5 = @escape_name
    if @escape_type == 0
      @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4, s5])  
    else
      @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])  
    end
    @actor_command_window.x = COMMAND_WINDOW_POSITION[0]
    @actor_command_window.y = COMMAND_WINDOW_POSITION[1]
    @actor_command_window.back_opacity = COMMAND_OPACITY
    @actor_command_window.z = 4500
    @active_battler_window.refresh(@active_battler)
    @active_battler_window.visible = BATTLER_NAME_WINDOW
    @active_battler_window.x = COMMAND_WINDOW_POSITION[0]
    @active_battler_window.y = COMMAND_WINDOW_POSITION[1] - 64
    @active_battler_window.z = 4500
  end
  #--------------------------------------------------------------------------
  alias acbs_start_enemy_select_atb start_enemy_select
  def start_enemy_select
    @teste = true
    acbs_start_enemy_select_atb
    @atb_meters.visible = true if Meters
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase3_skill_select_atb update_phase3_skill_select
  def update_phase3_skill_select
    @atb_meters.visible = false if Meters and Meter_Pos_Style < 3 and HIDE_WINDOW
    acbs_update_phase3_skill_select_atb
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase3_item_select_atb update_phase3_item_select
  def update_phase3_item_select
    @atb_meters.visible = false if Meters and Meter_Pos_Style < 3 and HIDE_WINDOW
    acbs_update_phase3_item_select_atb
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_start_actor_select_atb start_actor_select
  def start_actor_select
    acbs_start_actor_select_atb
    @atb_meters.visible = true if Meters
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_start_skill_select_atb start_skill_select
  def start_skill_select
    acbs_start_skill_select_atb
    @atb_meters.visible = false if Meters and Meter_Pos_Style < 3 and HIDE_WINDOW
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_end_skill_select_atb end_skill_select
  def end_skill_select
    acbs_end_skill_select_atb
    @atb_meters.visible = true if Meters
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_start_item_select_atb start_item_select
  def start_item_select
    acbs_start_item_select_atb
    @atb_meters.visible = false if Meters and Meter_Pos_Style < 3 and HIDE_WINDOW
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  alias acbs_end_item_select_atb end_item_select
  def end_item_select
    acbs_end_item_select_atb
    @atb_meters.visible = true if Meters
    update_meters unless Wait_Mode == 2
  end
  #--------------------------------------------------------------------------
  def phase3_next_actor
    @input_battler.blink = false
    action_battler = @input_battlers.shift
    @action_battlers << action_battler
    command_input_cancel
    @input_battler = nil
    @actor_index = nil
    @active_battler = nil
  end
  #--------------------------------------------------------------------------
  def phase3_prior_actor
    @input_battler.current_action.kind = 0
    @input_battler.current_action.basic = 3
    @input_battler.blink = false
    action_battler = @input_battlers.shift
    @action_battlers << action_battler
    @input_battler = nil
    @actor_index = nil
    @active_battler = nil
    windows_dispose
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase3_atb update_phase3
  def update_phase3
    if cancel_command?
      if can_act?
        if [2, 3].include?(@input_battler.restriction)
          @input_battler.current_action.kind = 0
          @input_battler.current_action.basic = 0
        end
        @action_battlers << @input_battler
      end
      command_input_cancel
      return
    end
    acbs_update_phase3_atb
  end
  #--------------------------------------------------------------------------
  def cancel_command?
    return false if @input_battler.nil?
    return true if @input_battler.current_action.forcing
    return true if [2, 3, 4].include?(@input_battler.restriction)
    return true if not $game_party.actors.include?(@input_battler)
    return false
  end
  #--------------------------------------------------------------------------
  def can_act?
    return true if @input_battler.current_action.forcing
    return true if [2, 3].include?(@input_battler.restriction)
    return false
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase3_basic_command_atb update_phase3_basic_command
  def update_phase3_basic_command
    if Input.trigger?(Input::C)
      case @actor_command_window.commands[@actor_command_window.index]
      when @escape_name
        if $game_temp.battle_can_escape == false
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        update_phase2_escape
        return
      end
    end
    if Input.trigger?(Input::UP) and @input_action
      $game_system.se_play($data_system.cursor_se)
      @actor_command_window.index -= 1
      if @actor_command_window.index <= -1   
        @actor_command_window.index = @actor_command_window.commands_size - 1
      end
      return
    end
    if Input.trigger?(Input::DOWN) and @input_action
      $game_system.se_play($data_system.cursor_se)
      @actor_command_window.index += 1
      if @actor_command_window.index >= @actor_command_window.commands_size - 1
        @actor_command_window.index = 0
      end
      return
    end
    if Input.trigger?(Input::B)
      $game_system.se_play($data_system.decision_se)
      phase3_next_actor
      return
    end
    if Input.trigger?(Input::A)
      $game_system.se_play($data_system.decision_se)
      @input_battler.passed = true
      phase3_next_actor
      return
    end
    acbs_update_phase3_basic_command_atb 
  end
  #--------------------------------------------------------------------------
  def command_input_cancel
    windows_dispose
    @input_battler.blink = false
    @input_battlers.delete(@input_battler)
    @input_battler = nil
  end
  #--------------------------------------------------------------------------
  def windows_dispose
    @help_window.visible = false if !@escaping
    if @enemy_arrow != nil
      @enemy_arrow.dispose
      @enemy_arrow = nil
    end
    if @actor_arrow != nil
      @actor_arrow.dispose
      @actor_arrow = nil
    end
    if @actor_arrow != nil
      @actor_arrow.dispose
      @actor_arrow = nil
    end
    if @skill_window != nil
      @skill_window.dispose
      @skill_window = nil
    end
    if @item_window != nil
      @item_window.dispose
      @item_window = nil
    end
    if @enemy_arrow_all != nil
      @enemy_arrow_all.dispose_multi_arrow
      @enemy_arrow_all = nil
    end
    if @actor_arrow_all != nil
      @actor_arrow_all.dispose_multi_arrow
      @actor_arrow_all = nil
    end
    if @battler_arrow_all != nil
      @battler_arrow_all.dispose_multi_arrow
      @battler_arrow_all = nil
    end
    if @actor_command_window != nil
      @actor_command_window.active = false
      @actor_command_window.visible = false
      @active_battler_window.visible = false
      @actor_command_window.opacity = 0
    end
    @status_window.visible = true
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase4_step1_atb update_phase4_step1
  def update_phase4_step1
    if @action_battlers.size == 0
      @input_battlers.clear
      @action_battlers.clear
      @action_battler.atb = 0
      @action_battler = nil
    end
    acbs_update_phase4_step1_atb
  end  
  #--------------------------------------------------------------------------
  alias acbs_update_phase4_step2_atb update_phase4_step2
  def update_phase4_step2
    @active_battler.defense_pose = false
    if @active_battler.cast_action != nil
      active_cast = @active_battler.cast_action
      if active_cast.scope == 1 or active_cast.scope == 3 or active_cast.scope == 5
        @active_battler.current_action.target_index = @active_battler.cast_target
      end
      if active_cast.is_a?(RPG::Skill)
        @active_battler.current_action.kind = 1 
        @active_battler.current_action.skill_id = @active_battler.cast_action.id
      elsif active_cast.is_a?(RPG::Item)  
        @active_battler.current_action.kind = 2 
        @active_battler.current_action.item_id = @active_battler.cast_action.id
      end
    end
    for state in @active_battler.battler_states
      @active_battler.remove_state(state.id) if state.extension.include?("ZEROTURNLIFT")
    end
    acbs_update_phase4_step2_atb
  end
  #--------------------------------------------------------------------------
  alias make_skill_action_result_atb_n01 make_skill_action_result
  def make_skill_action_result
    skill = $data_skills[@action_battler.current_action.skill_id]
    if @action_battler.cast_action == nil
      @active_battler.cast_action = skill
      @active_battler.cast_target = @active_battler.current_action.target_index
      @cast_speed = skill.cast_speed(@active_battler)
      @active_battler.cast_action = nil if @cast_speed == 0
      @spriteset.set_stand_by_action(@active_battler.actor?, @active_battler.index)
      return unless @cast_speed == 0
    end
    make_skill_action_result_atb_n01
    @active_battler.cast_action = nil
  end
  #--------------------------------------------------------------------------
  alias make_item_action_result_atb_n01 make_item_action_result
  def make_item_action_result
    item = $data_items[@action_battler.current_action.item_id]
    if @action_battler.cast_action == nil
      @active_battler.cast_action = item
      @active_battler.cast_target = @active_battler.current_action.target_index
      @cast_speed = item.cast_speed(@active_battler)
      @active_battler.cast_action = nil if @cast_speed == 0
      @spriteset.set_stand_by_action(@active_battler.actor?, @active_battler.index)
      return unless @cast_speed == 0
    end
    make_item_action_result_atb_n01
    @active_battler.cast_action = nil
  end 
  #--------------------------------------------------------------------------
  alias acbs_action_end_atb action_end
  def action_end
    acbs_action_end_atb
    @active_battler.cast_action = nil
  end
  #--------------------------------------------------------------------------
  def start_phase4
    @phase4_step = 1
    @action_phase = true
  end
  #--------------------------------------------------------------------------
  alias acbs_update_phase4_step6_atb update_phase4_step6
  def update_phase4_step6
    acbs_update_phase4_step6_atb
    @atb_turn_count += 1 unless Custom_Turn_Count == 2
    @active_battler.atb = 0 unless @active_battler.passed
    @active_battler.passed = false
    @input_battlers.delete(@active_battler)
    @action_battlers.delete(@active_battler)
    @action_battler = nil
    @action_phase = false
    update_meters
    judge
  end
end