#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ Active Count Battle 2 - KGC_ActiveCountBattle2 ◆
#_/    ◇ Last update : 2008/08/12 ◇
#_/----------------------------------------------------------------------------
#_/  リアルタイム戦闘システム「Active Count Battle Ver.2 (ACB2)」を導入します。
#_/============================================================================
#_/  ※できるだけ [Main] のすぐ上に導入してください。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★ カスタマイズ項目 - Customize ★
#==============================================================================

module KGC
module ACB2
  #   □■ 行動時の待機時間倍率設定【単位：％】 ■□

  # ◆通常攻撃
  ATTACK_WAIT = 100
  # ◆防御
  GUARD_WAIT  = 100
  # ◆スキル
  #  0 以下を指定すると、使用スキルに応じて自動生成。
  SKILL_WAIT  = 0
  # ◆アイテム
  ITEM_WAIT   = 50
  # ◆詠唱後
  #  詠唱が必要なスキルを使用した場合、スキルの待機時間にこの倍率をかける。
  CHANT_WAIT  = 50

  # ◆スキル詠唱
  #  false にすると詠唱無し。
  SKILL_CHANT = true
  # ◆詠唱スキルと見なす「魔力F」の値
  #  「魔力F」がこの値以上のスキルは詠唱が必要。
  CHANT_SKILL_INT_F = 1
  # ◆非詠唱スキルと見なす「攻撃力F」の値
  #  「攻撃力F」がこの値以上のスキルは詠唱しない。
  #  (≪魔法反射≫との併用を考えると、2 以上にするのがベター)
  NOT_CHANT_SKILL_ATK_F = 2
  # ◆詠唱時間倍率
  #  デフォルトの詠唱時間の倍率を百分率で指定。
  #  デフォルトの詠唱時間が 長すぎる or 短すぎる ときに変更。
  CHANT_TIME_REVISE = 100
  # ◆詠唱時間直接指定
  #  指定したIDのスキル詠唱時間を、基本値に対する百分率で指定。
  #  (指定しなかったスキルは自動的に詠唱時間を算出)
  #  直接指定すると、物理スキルを詠唱させることも可能。
  CHANT_TIME = []  # ←この行は消さずに、下に追加してください
  #  CHANT_TIME[10] = 80
  #  <↑例> スキルID:10 の詠唱時間を基本値の 0.8倍(80%) にする。
  # ◆ステートの詠唱時間指定
  #  指定したIDのステートになったときの詠唱時間を、基本値に対する百分率で指定。
  STATE_CHANT_TIME = []
  #  STATE_CHANT_TIME[15] = 25
  #  <↑例> ステートID:15 での詠唱時間を 1/4(25%) にする。

  #   □■ メッセージ・効果音設定 ■□

  # ◆ゲージMAX時 SE
  #  ("SEファイル名", Volume, Pitch)
  GAUGE_MAX_SE = RPG::AudioFile.new("105-Heal01", 100, 150)

  # ◆逃走中メッセージ
  #  nil にすると非表示になります。
  ESCAPE_MESSAGE      = "逃走中……"
  # ◆逃走不可メッセージ
  CANT_ESCAPE_MESSAGE = "逃げられない！！"
  # ◆逃走失敗メッセージ
  #  パーティコマンド用。
  ESCAPE_FAIL_MESSAGE = "回り込まれた！！"

  #   □■ 表示設定 ■□

  # ◆ ACB ゲージ画像
  #  "Graphics/Pictures" から読み込む。
  #  拡張子省略可。
  #  ACB_GAUGE = nil にすると、ゲージ非表示。
  ACB_GAUGE  = "gauge_acb2"

  # ◆ ACB ゲージ位置 [x, y]
  GAUGE_POSITION = [-12, 116]
  # ◆ ACB ゲージ長補正
  GAUGE_LENGTH   = 56

  # ◆ ACB ゲージを流す
  FLOW_GAUGE = true
  # ◆ ACB ゲージが流れる速度
  FLOW_SPEED = 4

  # ◆オーダーバー表示
  SHOW_ORDER_BAR = true
  # ◆オーダーバー描画位置
  #  [X座標, Y座標]
  ORDER_POSITION = [16, 2]
  # ◆オーダーアイコン位置補正
  #  [X座標, Y座標]
  #  X座標は、大きくするほどバーの中心から離れる。
  ORDER_ICON_POSITION = [6, 0]
  # ◆オーダーアイコン相対位置表示
  #  true にすると、バーの最下部が 0 、上部が max に相当。
  #  false にすると、ACBカウントで位置を設定。
  ORDER_ICON_POSITION_RELATIVE = false
  # ◆ウェイトエリア倍率
  #  基準値(100)に対する、ウェイトエリアの幅を百分率で指定。
  #  150 だと、通常の 1.5倍の待機時間までウェイトエリア内に収まる。
  #  ORDER_ICON_POSITION_RELATIVE = false のとき有効。
  WAIT_AREA_SCALE = 200
  # ◆待機時間予測を有効化
  #  コマンド選択時、行動後のウェイトエリア内での位置を予測。
  ORDER_PREDICT = true

  # ◆オーダーバー背景
  #  [フォルダ] Graphics/ACB/
  ORDER_BACK = "acb_order"
  # ◆アクター用オーダーアイコン
  #  【{i}…アクターID】
  ORDER_ICON_ACTOR = "acb_ai{i}"
  # ◆エネミー用オーダーアイコン
  #  【{i}…エネミーINDEX】
  ORDER_ICON_ENEMY = "acb_ei{i}"
  # ◆オーダーアイコン {i} の桁数
  ORDER_ICON_DIGITS = 2
  # ◆待機時間予測アイコン (通常)
  ORDER_ICON_PREDICT_NORMAL = "acb_predict"
  # ◆待機時間予測アイコン (詠唱)
  ORDER_ICON_PREDICT_CHANT  = "acb_predict_chant"

  #   □■ 動作設定 ■□

  # ◆ウェイトモード初期値
  #  0 .. フルアクティブ
  #  1 .. セミアクティブ
  #  2 .. ウェイト
  #  ゲーム中に $game_system.wait_mode で変更可能。
  INITIAL_WAIT_MODE = 0
  # ◆アクションウェイト初期設定
  #  true にすると、行動中は時間が止まる。
  #  ゲーム中に $game_system.action_wait で変更可能。
  INITIAL_ACTION_WAIT = false
  # ◆バトルスピード初期値
  #  10～1000
  #  数値が低いほど高速。
  #  ゲーム中に $game_system.battle_speed で変更可能。
  INITIAL_BATTLE_SPEED = 400
  # ◆アクターの素早さでバトルスピードを調整する
  ADJUST_BATTLE_SPEED = true
  # ◆アクターの素早さ基準値
  #  ADJUST_BATTLE_SPEED = false のときに使用。
  BASE_ACTOR_SPEED = 200

  # ◆ターン進行判定方法
  #  0 .. メンバー数に応じた時間が経過すると進行。
  #  1 .. 一人行動する度に進行。
  #  2 .. 敵味方を合わせて、行動可能者数と同じ回数行動すると進行。
  TURN_METHOD = 0
  # ◆スリップダメージ適用タイミング
  #  0 .. 行動後
  #  1 .. 全体ターン経過後
  SLIP_DAMAGE = 0
  # ◆コマンド入力中はディレイを無効化
  #  コマンド入力中はキャンセル効果を受けなくなる。
  INVALID_DELAY_INPUT = false

  # ◆逃走ボタン
  #  このボタンを押し続けると逃走。
  #  ESCAPE_BUTTON = nil にすると、逃走ボタンなし。
  ESCAPE_BUTTON  = Input::A
  # ◆「フルアクティブ」以外では、逃走ボタンによる逃走を無効化
  #  true にした場合は、パーティコマンド等を使用してください。
  ESCAPE_FA_ONLY = false
  # ◆逃走成功率補正値
  #  逃走に失敗するごとに、逃走成功率に加算。
  ESCAPE_PROB_REVISE = 20

  # ◆パーティコマンド切り替えボタン
  #  コマンド選択中にこのボタンを押すと、パーティコマンドに切り替わる。
  #  (パーティコマンド表示中はポーズ効果あり)
  #  PARTYCOMMAND_BUTTON = nil にすると、パーティコマンドなし。
  PARTYCOMMAND_BUTTON = Input::B

  # ◆入力アクター切り替えボタン
  #  このボタンを押すと、次のアクターにコマンド入力が移る。
  #  (ゲージの蓄積順に移動)
  CHANGE_INPUT_BUTTON = Input::X
  # ◆LR切り替えを使用する
  #  L,Rボタンを押すと、隣のアクターにコマンド入力が移る。
  #  (ゲージの蓄積順は無関係)
  USE_CHANGE_INPUT_NEIGHBOR = true
end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

$imported = {} if $imported == nil
$imported["ActiveCountBattle"] = true

if $game_special_elements == nil
  $game_special_elements = {}
  $data_system = load_data("Data/System.rxdata")
end
if $game_special_states == nil
  $game_special_states = {}
  $data_states = load_data("Data/States.rxdata")
end
# ディレイ属性
$game_special_elements["acb_delay"] = /(?:(?:ディレイ)|(?:Delay))(d+)/i
# ディレイ耐性属性
$game_special_elements["acb_delay_resist"] =
  $data_system.elements.index("ディレイ耐性")
if $game_special_elements["acb_delay_resist"] == nil
  $game_special_elements["acb_delay_resist"] =
    $data_system.elements.index("Delay resistance")
end
# 詠唱時間ステート
$game_special_states["chant_time"] = /詠唱時間(d+)(%|％)?/i

#==============================================================================
# ■ Module_Graphics
#==============================================================================

module Graphics
  unless defined?(transition_interrupt_KGC)
  #--------------------------------------------------------------------------
  # ● トランジション実行
  #--------------------------------------------------------------------------
  class << Graphics
    alias transition_interrupt_KGC transition
  end
  def self.transition(duration = 8, filename = "", vague = 40)
    if @_interrupt_transition
      @_transition_duration = duration
      @_transition_filename = filename.dup
      @_transition_vague = vague
      return
    end

    transition_interrupt_KGC(duration, filename, vague)
  end
  #--------------------------------------------------------------------------
  # ● トランジション割り込み開始
  #--------------------------------------------------------------------------
  def self.start_interrupt_transition
    @_interrupt_transition = true
  end
  #--------------------------------------------------------------------------
  # ● トランジション割り込み終了
  #--------------------------------------------------------------------------
  def self.end_interrupt_transition
    if @_interrupt_transition
      @_interrupt_transition = nil
      transition(@_transition_duration, @_transition_filename,
        @_transition_vague)
      @_transition_duration = @_transition_filename = @_transition_vague = nil
    end
  end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ RPG::Cache
#==============================================================================

module RPG::Cache
  def self.general(directory, filename, hue = 0)
    self.load_bitmap(directory, filename, hue)
  end
  def self.acb(filename, hue = 0)
    self.load_bitmap("Graphics/ACB/", filename, hue)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Temp
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :base_speed                   # 基準スピード
  attr_accessor :base_acb_count               # 基本ACBカウント
  attr_accessor :turn_acb_count_max           # ターン計算用ACBカウント最大値
  attr_accessor :turn_acb_count_speed         # ターン計算用ACBカウント速度
  attr_accessor :interrupt_transition         # トランジション割り込み
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KGC_ACB initialize
  def initialize
    initialize_KGC_ACB

    @base_speed = 500
    @base_acb_count = 500
    @turn_acb_count_max = 500
    @turn_acb_count_speed = 10
    @interrupt_transition = false
  end
  #--------------------------------------------------------------------------
  # ● ACBゲージ最大量設定
  #--------------------------------------------------------------------------
  def set_turn_acb_count_max(speed)
    unless KGC::ACB2::ADJUST_BATTLE_SPEED
      speed = KGC::ACB2::BASE_ACTOR_SPEED
    end
    @base_speed = speed
    @base_acb_count = speed * $game_system.battle_speed / 4
    @turn_acb_count_max = speed * $game_system.battle_speed
    @turn_acb_count_speed = [speed, @turn_acb_count_max / 250].max
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_System
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :wait_mode                # 戦闘ウェイトモード
  attr_accessor :action_wait              # 行動待ち
  attr_accessor :battle_speed             # バトルスピード
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KGC_ACB initialize
  def initialize
    initialize_KGC_ACB

    @wait_mode = KGC::ACB2::INITIAL_WAIT_MODE
    @action_wait = KGC::ACB2::INITIAL_ACTION_WAIT
    @battle_speed = KGC::ACB2::INITIAL_BATTLE_SPEED
  end
  #--------------------------------------------------------------------------
  # ● バトルスピード変更
  #--------------------------------------------------------------------------
  def battle_speed=(speed)
    @battle_speed = [[speed, 10].max, 1000].min
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Battler (分割定義 1)
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_reader   :acb_gauge                # ACBゲージ蓄積量
  attr_accessor :acb_gauge_max            # ACBゲージ最大量
  attr_accessor :chant                    # 詠唱中フラグ
  attr_accessor :turn_count               # 固有ターン数
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KGC_ACB initialize
  def initialize
    initialize_KGC_ACB

    @acb_gauge = 0
    @acb_gauge_max = 1000
    @chant = false
    @turn_count = 0
  end
  #--------------------------------------------------------------------------
  # ● ACBゲージ操作
  #--------------------------------------------------------------------------
  def acb_gauge=(value)
    @acb_gauge = [[value, 0].max, @acb_gauge_max].min
  end
  #--------------------------------------------------------------------------
  # ● 詠唱中か否か
  #--------------------------------------------------------------------------
  def chant?
    return @chant
  end
  #--------------------------------------------------------------------------
  # ● 待機時間設定
  #--------------------------------------------------------------------------
  def set_acb_count
    n = calc_acb_count(@current_action)
    # ゲージを初期化
    @acb_gauge = 0
    @acb_gauge_max = [n, 1].max
    @chant = false
  end
  #--------------------------------------------------------------------------
  # ● 待機時間計算
  #--------------------------------------------------------------------------
  def calc_acb_count(action)
    n = $game_temp.base_acb_count
    # 行動内容で分岐
    case action.kind
    when 0  # 基本
      case action.basic
      when 0  # 攻撃
        n = n * KGC::ACB2::ATTACK_WAIT / 100
      when 1  # 防御
        n = n * KGC::ACB2::GUARD_WAIT / 100
      end
    when 1  # スキル
      if KGC::ACB2::SKILL_WAIT > 0
        n = n * KGC::ACB2::SKILL_WAIT / 100
      else
        # スキルの設定値から待機時間を算出
        skill = $data_skills[action.skill_id]
        all_f = skill.atk_f + skill.str_f + skill.dex_f +
          skill.agi_f + skill.int_f
        rate = skill.sp_cost + skill.power.abs + all_f / 8
        rate = Math.sqrt(rate) / 20.0 + 1.0
        n = Integer(n * rate)
      end
      # 詠唱判定
      if KGC::ACB2::SKILL_CHANT && self.chant?
        skill = $data_skills[action.skill_id]
        n = n * KGC::ACB2::CHANT_WAIT / 100
      end
    when 2  # アイテム
      n = n * KGC::ACB2::ITEM_WAIT / 100
    end
    return (n / self.agi)
  end
  #--------------------------------------------------------------------------
  # ● 詠唱時間設定
  #--------------------------------------------------------------------------
  def set_chant_count
    n = calc_chant_count(@current_action)
    # ゲージを初期化
    @acb_gauge = 0
    @acb_gauge_max = [n, 1].max
    @chant = true
  end
  #--------------------------------------------------------------------------
  # ● 詠唱時間計算
  #--------------------------------------------------------------------------
  def calc_chant_count(action)
    skill = $data_skills[action.skill_id]
    # 直接指定されている場合
    if KGC::ACB2::CHANT_TIME[skill.id] != nil
      chant_time = KGC::ACB2::CHANT_TIME[skill.id] *
        $game_temp.base_acb_count / (100 * self.int)
      return chant_time
    end

    # 基本詠唱時間
    base_time = 0
    if KGC::ACB2::CHANT_TIME[skill.id] != nil
      base_time = KGC::ACB2::CHANT_TIME[skill.id]
    elsif skill.power != 0
      n = skill.sp_cost + skill.power.abs + skill.int_f
      base_time = Math.sqrt(n) * 3.0
    else
      base_time = Math.sqrt(skill.sp_cost + skill.int_f) * 5.0
    end
    chant_time = (base_time.to_i * $game_temp.base_acb_count *
      KGC::ACB2::CHANT_TIME_REVISE) / (10000 * self.int)
    # 詠唱時間補正
    self.states.compact.each { |state|
      rate = -1
      if KGC::ACB2::STATE_CHANT_TIME[state] != nil
        rate = KGC::ACB2::STATE_CHANT_TIME[state]
      elsif $game_special_states["chant_time"] =~ $data_states[state].name
        rate = $1.to_i
      end
      if rate > 0
        chant_time = chant_time * [rate, 0].max / 100
      end
    }
    return chant_time
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Game_Enemy
#==============================================================================

class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● アクション作成
  #--------------------------------------------------------------------------
  def make_action
    # カレントアクションをクリア
    self.current_action.clear
    # 動けない場合
    return unless self.movable?
    # 現在有効なアクションを抽出
    available_actions = []
    rating_max = 0
    self.actions.each { |action|
      # ターン 条件確認
      n = @turn_count
      a = action.condition_turn_a
      b = action.condition_turn_b
      next if (b == 0 && n != a) || (b > 0 && (n < 1 || n < a || n % b != a % b))
      # HP 条件確認
      next if self.hp * 100.0 / self.maxhp > action.condition_hp
      # レベル 条件確認
      next if $game_party.max_level < action.condition_level
      # スイッチ 条件確認
      switch_id = action.condition_switch_id
      next if switch_id > 0 && $game_switches[switch_id] == false
      # 条件に該当 : このアクションを追加
      available_actions.push(action)
      rating_max = action.rating if action.rating > rating_max
    }
    # 最大のレーティング値を 3 として合計を計算 (0 以下は除外)
    ratings_total = 0
    available_actions.each { |action|
      if action.rating > rating_max - 3
        ratings_total += action.rating - (rating_max - 3)
      end
    }
    # レーティングの合計が 0 ではない場合
    if ratings_total > 0
      # 乱数を作成
      value = rand(ratings_total)
      # 作成した乱数に対応するものをカレントアクションに設定
      available_actions.each { |action|
        if action.rating > rating_max - 3
          if value < action.rating - (rating_max - 3)
            self.current_action.kind = action.kind
            self.current_action.basic = action.basic
            self.current_action.skill_id = action.skill_id
            self.current_action.decide_random_target_for_enemy
            return
          else
            value -= action.rating - (rating_max - 3)
          end
        end
      }
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_Help
#==============================================================================

class Window_Help < Window_Base
  #--------------------------------------------------------------------------
  # ● テキスト設定
  #     text  : ウィンドウに表示する文字列
  #     align : アラインメント (0..左揃え、1..中央揃え、2..右揃え)
  #--------------------------------------------------------------------------
  alias set_text_KGC_ACB set_text
  def set_text(text, align = 0)
    last_actor = @actor

    set_text_KGC_ACB(text, align)

    @actor = last_actor
  end
  #--------------------------------------------------------------------------
  # ● 表示文字列取得
  #--------------------------------------------------------------------------
  def text
    return @text
  end
  #--------------------------------------------------------------------------
  # ● リセット
  #--------------------------------------------------------------------------
  def reset
    @text = nil
    @actor = nil
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_Item
#==============================================================================

class Window_Item < Window_Selectable
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  alias refresh_KGC_ACB refresh
  def refresh(itemkind = 0)
    if $imported["ItemGrouping"]
      refresh_KGC_ACB(itemkind)
    else
      refresh_KGC_ACB
    end

    Graphics.frame_reset
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_Skill
#==============================================================================

class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  alias refresh_KGC_ACB refresh
  def refresh
    refresh_KGC_ACB

    Graphics.frame_reset
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Window_BattleStatus
#==============================================================================

class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KGC_ACB initialize
  def initialize
    @_acb_gauge_x = 0
    # ACB ゲージ作成
    create_acb_gauge_sprite
    # オーダーバー作成
    if KGC::ACB2::SHOW_ORDER_BAR
      create_order_bar_sprite
    end

    initialize_KGC_ACB

    @_acb_gauge_sprite.x = self.x
    @_acb_gauge_sprite.y = self.y
    @_acb_gauge_sprite.z = self.z
  end
  #--------------------------------------------------------------------------
  # ● ACBゲージスプライト作成
  #--------------------------------------------------------------------------
  def create_acb_gauge_sprite(viewport = nil)
    if @_acb_gauge_sprite != nil
      sx = @_acb_gauge_sprite.x
      sy = @_acb_gauge_sprite.y
      sz = @_acb_gauge_sprite.z
      @_acb_gauge_sprite.bitmap.dispose
      @_acb_gauge_sprite.dispose
      @_acb_gauge_buffer.dispose
    else
      sx = sy = sz = 0
    end
    @_acb_gauge_sprite = Sprite.new(viewport)
    @_acb_gauge_sprite.bitmap = Bitmap.new(640, 160)
    @_acb_gauge_sprite.x = sx
    @_acb_gauge_sprite.y = sy
    @_acb_gauge_sprite.z = sz

    @_acb_gauge_buffer = Bitmap.new(
      get_parameter_width + KGC::ACB2::GAUGE_LENGTH, 64)
  end
  #--------------------------------------------------------------------------
  # ● オーダーバー作成
  #--------------------------------------------------------------------------
  def create_order_bar_sprite
    @actor_buf = $game_party.actors.dup
    @_order_icon_actor = []
    @_order_icon_enemy = []
    @_order_back_sprite = Sprite.new
    @_order_back_sprite.bitmap = RPG::Cache.acb(KGC::ACB2::ORDER_BACK)
    @_order_back_sprite.x = KGC::ACB2::ORDER_POSITION[0]
    @_order_back_sprite.y = KGC::ACB2::ORDER_POSITION[1]
    @_order_back_sprite.z = 1
    # アクター
    create_order_icon($game_party.actors, @_order_icon_actor,
      KGC::ACB2::ORDER_ICON_ACTOR, 0)
    # エネミー
    create_order_icon($game_troop.enemies, @_order_icon_enemy,
      KGC::ACB2::ORDER_ICON_ENEMY, 1)
    @_wait_area_height = RPG::Cache.acb(KGC::ACB2::ORDER_BACK).height - 32
    # 予測
    @_order_icon_predict = RPG::Sprite.new
    @_order_icon_predict.bitmap =
      RPG::Cache.acb(KGC::ACB2::ORDER_ICON_PREDICT_NORMAL)
    @_order_icon_predict.ox = @_order_icon_actor[0].ox
    @_order_icon_predict.x = @_order_icon_actor[0].x
    @_order_icon_predict.y = KGC::ACB2::ORDER_POSITION[1]
    @_order_icon_predict.z = 50
    @_order_icon_predict.visible = false
    @_order_icon_predict.blink_on
  end
  #--------------------------------------------------------------------------
  # ● オーダーアイコン作成
  #--------------------------------------------------------------------------
  def create_order_icon(battlers, icons, filename, type)
    ix = KGC::ACB2::ORDER_POSITION[0] + @_order_back_sprite.bitmap.width / 2
    case type
    when 0  # アクター
      ix -= KGC::ACB2::ORDER_ICON_POSITION[0]
      index_format = "battler.id"
    when 1  # エネミー
      ix += KGC::ACB2::ORDER_ICON_POSITION[0]
      index_format = "i + 1"
    end
    battlers.each_with_index { |battler, i|
      if battler != nil
        icons[i] = RPG::Sprite.new
        begin
          icons[i].bitmap = RPG::Cache.acb(
            filename.gsub(/{i}/i) {
              sprintf("%0*d", KGC::ACB2::ORDER_ICON_DIGITS, eval(index_format))
            }
          )
        rescue
          icons[i].bitmap = RPG::Cache.acb(filename.gsub(/{i}/i) {""})
        end
        icons[i].x = ix
        icons[i].blink_off
        if type == 0
          icons[i].ox = icons[i].bitmap.width
        else
          icons[i].ox = 0
        end
      else
        icons[i] = nil
      end
    }
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  alias dispose_KGC_ACB dispose
  def dispose
    @_acb_gauge_sprite.bitmap.dispose
    @_acb_gauge_sprite.dispose
    @_acb_gauge_buffer.dispose
    if KGC::ACB2::SHOW_ORDER_BAR
      @_order_back_sprite.bitmap.dispose
      @_order_back_sprite.dispose
      (@_order_icon_actor + @_order_icon_enemy).compact.each { |sprite|
        sprite.bitmap.dispose unless sprite.bitmap.disposed?
        sprite.dispose
      }
      @_order_icon_actor = nil
      @_order_icon_enemy = nil
      @_order_icon_predict.dispose
    end

    dispose_KGC_ACB
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  alias refresh_KGC_ACB refresh
  def refresh
    refresh_KGC_ACB

    draw_acb_gauge_buffer(get_parameter_width)
    update_acb_gauge
  end
  #--------------------------------------------------------------------------
  # ● パラメータ表示幅取得
  #--------------------------------------------------------------------------
  unless method_defined?(:get_parameter_width)
  def get_parameter_width
    return 120
  end
  end
  #--------------------------------------------------------------------------
  # ● アクター間隔取得
  #--------------------------------------------------------------------------
  unless method_defined?(:get_actor_space)
  def get_actor_space
    return 160
  end
  end
  #--------------------------------------------------------------------------
  # ● ACBゲージ用バッファ描画
  #--------------------------------------------------------------------------
  def draw_acb_gauge_buffer(width)
    @_acb_gauge_buffer.clear

    gauge = RPG::Cache.acb(KGC::ACB2::ACB_GAUGE)
    dw = width + KGC::ACB2::GAUGE_LENGTH
    draw_acb_gauge_back(@_acb_gauge_buffer, gauge, 0, 0, dw)
    draw_acb_gauge_fore(@_acb_gauge_buffer, gauge, 0, 32, dw)
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias update_KGC_ACB update
  def update
    update_KGC_ACB

    # ACBゲージ更新
    if KGC::ACB2::FLOW_GAUGE
      flow_acb_gauge
    end
    update_acb_gauge
    # オーダーバー更新
    if KGC::ACB2::SHOW_ORDER_BAR && $game_temp.in_battle &&
        @_order_icon_actor != nil && @_order_icon_enemy != nil
      update_order_bar
    end
  end
  #--------------------------------------------------------------------------
  # ● ACBゲージ更新
  #--------------------------------------------------------------------------
  def update_acb_gauge
    @_acb_gauge_sprite.bitmap.clear
    pw = get_parameter_width
    (0...$game_party.actors.size).each { |i|
      actor = $game_party.actors[i]
      actor_x = i * get_actor_space + 4
      draw_actor_acb_gauge(actor, actor_x, 0, pw)
    }
  end
  #--------------------------------------------------------------------------
  # ● ACBゲージを流す
  #--------------------------------------------------------------------------
  def flow_acb_gauge
    @_acb_gauge_x -= KGC::ACB2::FLOW_SPEED
    if @_acb_gauge_x < 0
      @_acb_gauge_x += 192
    end
  end
  #--------------------------------------------------------------------------
  # ● 予測アイコン位置設定
  #     wait_count : 予測待機時間
  #     chant      : 詠唱フラグ
  #--------------------------------------------------------------------------
  def set_predict_position(wait_count, chant = false)
    if !KGC::ACB2::SHOW_ORDER_BAR || !KGC::ACB2::ORDER_PREDICT
      return
    end

    if wait_count == nil
      @_order_icon_predict.visible = false
    else
      if chant
        @_order_icon_predict.bitmap =
          RPG::Cache.acb(KGC::ACB2::ORDER_ICON_PREDICT_CHANT)
      else
        @_order_icon_predict.bitmap =
          RPG::Cache.acb(KGC::ACB2::ORDER_ICON_PREDICT_NORMAL)
      end
      @_order_icon_predict.y = calc_order_icon_position_y(0, wait_count)
      @_order_icon_predict.visible = true
    end
  end
  #--------------------------------------------------------------------------
  # ● 予測アイコン位置リセット
  #--------------------------------------------------------------------------
  def reset_predict_position
    set_predict_position(nil)
  end
  #--------------------------------------------------------------------------
  # ● オーダーバー更新
  #--------------------------------------------------------------------------
  def update_order_bar
    # オーダーアイコン修復
    if @actor_buf != $game_party.actors
      restore_actor_order_icon
    end
    # アイコン更新
    update_order_bar_icon($game_party.actors, @_order_icon_actor)
    update_order_bar_icon($game_troop.enemies, @_order_icon_enemy)
    @_order_icon_predict.update
  end
  #--------------------------------------------------------------------------
  # ● アクターオーダーアイコン修復
  #--------------------------------------------------------------------------
  def restore_actor_order_icon
    # 破棄
    @_order_icon_actor.each { |icon|
      icon.dispose
    }
    # 再作成
    create_order_icon($game_party.actors, @_order_icon_actor,
      KGC::ACB2::ORDER_ICON_ACTOR, 0)
  end
  #--------------------------------------------------------------------------
  # ● エネミーオーダーアイコン修復
  #--------------------------------------------------------------------------
  def restore_enemy_order_icon
    # 破棄
    @_order_icon_enemy.each { |icon|
      icon.dispose
    }
    # 再作成
    create_order_icon($game_troop.enemies, @_order_icon_enemy,
      KGC::ACB2::ORDER_ICON_ENEMY, 1)
  end
  #--------------------------------------------------------------------------
  # ● オーダーバー アイコン更新
  #--------------------------------------------------------------------------
  def update_order_bar_icon(battlers, icons)
    # ソート
    orders = battlers.dup
    orders.sort! { |a, b|
      a.id - b.id
    }
    orders.sort! { |a, b|
      (a.acb_gauge * 1000 / a.acb_gauge_max) -
        (b.acb_gauge * 1000 / b.acb_gauge_max)
    }
    # 更新
    orders.each_with_index { |battler, i|
      icon = icons[battler.index]
      if icon == nil
        next
      elsif battler.dead?
        icon.visible = false
        next
      else
        icon.visible = true
      end
      icon.y = calc_order_icon_position_y(battler.acb_gauge,
        battler.acb_gauge_max)
      icon.z = i + 2
      if $scene.input_battler == battler
        # コマンド入力中
        icon.blink_on
        icon.y -= 8
        icon.z += 10
      elsif $scene.action_battlers.include?(battler)
        # 行動待機中
        icon.blink_off
        icon.y -= 16 + ($scene.action_battlers.index(battler) << 1)
        icon.z += 20 + $scene.action_battlers.index(battler)
      elsif $scene.action_battler == battler
        # 行動中
        icon.blink_on
        icon.y -= 24
        icon.z += 30
      else
        icon.blink_off
      end
      icon.update
    }
  end
  #--------------------------------------------------------------------------
  # ● オーダーアイコン Y 座標計算
  #--------------------------------------------------------------------------
  def calc_order_icon_position_y(count, count_max)
    n = KGC::ACB2::ORDER_POSITION[1] + KGC::ACB2::ORDER_ICON_POSITION[1] + 32
    temp_n = 0
    temp_y = (count_max - count) * @_wait_area_height
    if KGC::ACB2::ORDER_ICON_POSITION_RELATIVE
      # 相対位置
      temp_n = temp_y / count_max
    else
      # 絶対位置
      temp_n = temp_y / ($game_temp.base_acb_count / $game_temp.base_speed)
      temp_n = temp_n * 100 / KGC::ACB2::WAIT_AREA_SCALE
    end
    temp_n = [[temp_n, 0].max, @_wait_area_height].min
    return (n + temp_n)
  end
  #--------------------------------------------------------------------------
  # ● ACB ゲージの描画
  #--------------------------------------------------------------------------
  def draw_actor_acb_gauge(actor, x, y, width)
    if KGC::ACB2::ACB_GAUGE == nil
      return
    end
    bitmap = @_acb_gauge_sprite.bitmap
    gauge = RPG::Cache.acb(KGC::ACB2::ACB_GAUGE)
    nx = x + KGC::ACB2::GAUGE_POSITION[0]
    ny = y + KGC::ACB2::GAUGE_POSITION[1]
    nw = width + KGC::ACB2::GAUGE_LENGTH
    gauge_width = calc_acb_gauge_width(actor, nw)
    bitmap.blt(nx, ny, @_acb_gauge_buffer, Rect.new(0, 0, nw, 32))
    draw_acb_gauge_inside(bitmap, gauge, actor, nx, ny, nw, gauge_width)
    bitmap.blt(nx, ny, @_acb_gauge_buffer, Rect.new(0, 32, nw, 32))
  end
  #--------------------------------------------------------------------------
  # ● ACB ゲージ背景の描画
  #     bitmap : 描画先画像
  #     image  : ゲージ画像
  #     width  : ゲージ幅
  #--------------------------------------------------------------------------
  def draw_acb_gauge_back(bitmap, image, x, y, width)
    src_rect = Rect.new(0, 0, 32, 32)
    bitmap.blt(x, y, image, src_rect)
    src_rect.set(32, 0, 96, 32)
    dest_rect = Rect.new(x + 32, y, width - 64, 32)
    bitmap.stretch_blt(dest_rect, image, src_rect)
    src_rect.set(128, 0, 32, 32)
    bitmap.blt(x + width - 32, y, image, src_rect)
  end
  #--------------------------------------------------------------------------
  # ● ACB ゲージ内部の描画
  #     bitmap : 描画先画像
  #     image  : ゲージ画像
  #     actro  : アクター
  #     width  : ゲージ幅
  #     gauge_width : ゲージ内部の幅
  #--------------------------------------------------------------------------
  def draw_acb_gauge_inside(bitmap, image, actor, x, y, width, gauge_width)
    src_rect = Rect.new(@_acb_gauge_x, 32, 96, 32)
    if actor.chant?
      src_rect.y = 96
    end
    if gauge_width == width - 64
      src_rect.y = 64
    end
    src_rect.width = gauge_width * 96 / (width - 64)
    dest_rect = Rect.new(x + 32, y, gauge_width, 32)
    bitmap.stretch_blt(dest_rect, image, src_rect)
  end
  #--------------------------------------------------------------------------
  # ● ACB ゲージ前景の描画
  #     bitmap : 描画先画像
  #     image  : ゲージ画像
  #     width  : ゲージ幅
  #--------------------------------------------------------------------------
  def draw_acb_gauge_fore(bitmap, image, x, y, width)
    src_rect = Rect.new(160, 0, 32, 32)
    bitmap.blt(x, y, image, src_rect)
    src_rect.set(192, 0, 96, 32)
    dest_rect = Rect.new(x + 32, y, width - 64, 32)
    bitmap.stretch_blt(dest_rect, image, src_rect)
    src_rect.set(288, 0, 32, 32)
    bitmap.blt(x + width - 32, y, image, src_rect)
  end
  #--------------------------------------------------------------------------
  # ● ACB ゲージ幅の計算
  #--------------------------------------------------------------------------
  def calc_acb_gauge_width(actor, width)
    gw = actor.acb_gauge * (width - 64) / actor.acb_gauge_max
    return [[gw, 0].max, width - 64].min
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Interpreter (分割定義 4)
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # ● アクターの入れ替え
  #--------------------------------------------------------------------------
  alias command_129_KGC_ACB command_129
  def command_129
    if command_129_KGC_ACB
      # ACBカウント作成
      $game_actors[@parameters[0]].set_acb_count
      return true
    else
      return false
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Interpreter (分割定義 7)
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # ● アクションの強制
  #--------------------------------------------------------------------------
  def command_339
    # 戦闘中でなければ無視
    unless $game_temp.in_battle
      return true
    end
    # イテレータで処理 (便宜的なもので、複数になることはない)
    iterate_battler(@parameters[0], @parameters[1]) { |battler|
      next unless battler.exist?
      # アクションを設定
      battler.current_action.kind = @parameters[2]
      if battler.current_action.kind == 0
        battler.current_action.basic = @parameters[3]
      else
        battler.current_action.skill_id = @parameters[3]
      end
      # 行動対象を設定
      if @parameters[4] == -2
        if battler.is_a?(Game_Enemy)
          battler.current_action.decide_last_target_for_enemy
        else
          battler.current_action.decide_last_target_for_actor
        end
      elsif @parameters[4] == -1
        if battler.is_a?(Game_Enemy)
          battler.current_action.decide_random_target_for_enemy
        else
          battler.current_action.decide_random_target_for_actor
        end
      elsif @parameters[4] >= 0
        battler.current_action.target_index = @parameters[4]
      end
      # 強制フラグを設定
      battler.current_action.forcing = true
      # 強制行動
      battler.acb_gauge -= 1
      if $scene.input_battler == battler
        $scene.cancel_command_input(true)
      end
      $scene.input_battlers.delete(battler)
      $scene.action_battlers.delete(battler)
      # アクションが有効かつ [すぐに実行] の場合
      if battler.current_action.valid? && @parameters[5] == 1
        # ACBゲージ最大
        battler.acb_gauge = battler.acb_gauge_max - 1
        # インデックスを進める
        @index += 1
        # 終了
        return false
      end
    }
    # 継続
    return true
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 1)
#==============================================================================

class Scene_Battle
  attr_accessor :input_battler, :action_battler, :input_battlers,
    :action_battlers
  #--------------------------------------------------------------------------
  # ● メイン処理
  #--------------------------------------------------------------------------
  alias main_KGC_ACB main
  def main
    # ACB初期化
    initialize_acb
    # トランジション割り込み開始
    Graphics.start_interrupt_transition

    main_KGC_ACB

    @battler_help_window.dispose
  end
  #--------------------------------------------------------------------------
  # ● ACB初期化
  #--------------------------------------------------------------------------
  def initialize_acb
    # トループを準備
    @troop_id = $game_temp.battle_troop_id
    $game_troop.setup(@troop_id)

    # 基本ACBカウントを計算
    all_speed = 0
    $game_party.actors.each { |battler|
      if $imported["BattlerEffect"]
        battler.effect_reset
      end
      battler.blink = false
      all_speed += battler.agi
    }
    all_speed /= [$game_party.actors.size, 1].max
    $game_temp.set_turn_acb_count_max(all_speed)
    # ACBゲージを設定
    $game_party.actors.each { |battler|
      battler.turn_count = 0
      battler.set_acb_count
      battler.acb_gauge = rand(battler.acb_gauge_max * 2 / 3)
      battler.chant = false
    }
    # ACB各種データを初期化
    @input_battlers = []
    @action_battlers = []
    @input_battler = nil
    @action_battler = nil
    @turn_acb_count = 0
    @escape_count = 0
    @escape_prob_rev = 0
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias update_KGC_ACB update
  def update
    if @phase != 5
      @phase = 0
    end
    if $game_system.battle_interpreter.running?
      @event_running = true
    end

    update_KGC_ACB

    # パーティコマンド表示中は戻る
    if @party_command_window.active
      update_phase2
      return
    end
    # ウェイト中・イベント中は戻る
    if waiting? || $game_system.battle_interpreter.running?
      return
    end
    # リフレッシュ判定
    if @event_running
      @status_window.refresh
      @event_running = false
    end
    # ゲームオーバーの場合
    if $game_temp.gameover
      unless @spriteset.effect?
        # ゲームオーバー画面に切り替え
        $scene = Scene_Gameover.new
      end
      return
    end
    # アフターバトルフェーズの場合
    if @phase == 5
      #update_phase5
      return
    end

    # 逃走判定
    if !KGC::ACB2::ESCAPE_FA_ONLY || $game_system.wait_mode == 0
      update_escape
    end

    # ゲージ加算処理
    acb_add

    # コマンド入力者決定
    if !@input_battlers.empty? && @input_battler == nil && !@wait_on
      set_input_battler
    end
    # コマンド入力処理
    if @input_battler != nil
      @active_battler = @input_battler
      # コマンド入力開始直後はウィンドウ作成
      if @actor_command_window.opacity == 0
        phase3_setup_command_window
      end
      update_phase3
    end

    # 行動者決定
    if !@action_battlers.empty? && @action_battler == nil
      set_action_battler
    end
    # 行動処理
    if @action_battler != nil && !@spriteset.effect?
      @active_battler = @action_battler
      update_phase4
    end
  end
  #--------------------------------------------------------------------------
  # ● ウェイト中判定
  #--------------------------------------------------------------------------
  def waiting?
    action = @action_battler == nil && @wait_count > 0
    bonus = @bonus_wait != nil && @bonus_wait > 0
    preempt = @preempt_wait != nil && @preempt_wait > 0
    return action || bonus || preempt
  end
  #--------------------------------------------------------------------------
  # ● 逃走処理更新
  #--------------------------------------------------------------------------
  def update_escape
    if KGC::ACB2::ESCAPE_BUTTON == nil
      return
    end
    if Input.press?(KGC::ACB2::ESCAPE_BUTTON)
      @escaping = true
      # 逃走可能な場合
      if $game_temp.battle_can_escape && can_escape?
        # 逃走中メッセージを表示
        if !@help_window.visible && KGC::ACB2::ESCAPE_MESSAGE != nil
          @help_window.set_text("")
          @help_window.set_text(KGC::ACB2::ESCAPE_MESSAGE, 1)
        end
        # 逃走カウントを加算
        @escape_count += 1
        # 逃走完了判定
        if @escape_count >= $game_temp.turn_acb_count_max / 600
          @escape_count = 0
          update_phase2_escape
        end
      else
        # 逃走不可能メッセージ表示
        @help_window.set_text(KGC::ACB2::CANT_ESCAPE_MESSAGE, 1)
        @escape_count = 0
      end
    else
      if @escaping
        @escaping = false
        @help_window.set_text("")
        @help_window.visible = false
      end
      # 逃走していない場合はカウントを減らす
      @escape_count = [@escape_count - 1, 0].max
    end
  end
  #--------------------------------------------------------------------------
  # ● 逃走可能判定
  #--------------------------------------------------------------------------
  def can_escape?
    # 一人でも行動可能ならOK
    $game_party.actors.each { |a|
      if a.movable?
        return true
      end
    }
    return false
  end
  #--------------------------------------------------------------------------
  # ● コマンド入力者設定
  #--------------------------------------------------------------------------
  def set_input_battler
    @input_battler = @input_battlers.shift
    # 強制行動の場合
    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
      # 行動バトラーに追加(入力解除)
      @action_battlers << @input_battler
      @input_battler = nil
    # コマンド入力可能判定
    elsif @input_battler.inputable?
      # ゲージMAX SE 演奏
      if KGC::ACB2::GAUGE_MAX_SE.is_a?(RPG::AudioFile)
        $game_system.se_play(KGC::ACB2::GAUGE_MAX_SE)
      else
        Audio.se_play("Audio/SE/" + KGC::ACB2::GAUGE_MAX_SE[0], KGC::ACB2::GAUGE_MAX_SE[1],
          KGC::ACB2::GAUGE_MAX_SE[2])
      end
      # 行動準備
      @actor_index = $game_party.actors.index(@input_battler)
      @input_battler.current_action.clear
      # 明滅エフェクト ON
      @input_battler.blink = true
    else
      # ACBゲージ初期化
      @input_battler.set_acb_count
      # 入力解除
      @input_battler = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● 行動者決定処理
  #--------------------------------------------------------------------------
  def set_action_battler
    @action_battler = @action_battlers.shift
    # 行動不可能な場合
    if @action_battler.dead? || !@action_battler.movable?
      # 行動解除
      @action_battler.acb_gauge = 0
      @action_battler = nil
    else
      # アクター入れ替えで外された場合
      if @action_battler.is_a?(Game_Actor) &&
          !$game_party.actors.include?(@action_battler)
        # 行動解除
        @action_battler.set_acb_count
        @action_battler = nil
      else
        # 行動開始
        @active_battler = @action_battler
        start_phase4
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● ACB ゲージ加算
  #--------------------------------------------------------------------------
  def acb_add
    # バトルウェイト判定
    if battle_wait?
      return
    end

    if KGC::ACB2::TURN_METHOD == 0
      # ターン計算用カウント加算
      @turn_acb_count += $game_temp.turn_acb_count_speed
      # ターン進行
      if @turn_acb_count >= $game_temp.turn_acb_count_max
        progress_turn
      end
    end

    ($game_party.actors + $game_troop.enemies).each { |battler|
      # 行動不可能な場合
      if !battler.movable?
        # ACBゲージ初期化
        battler.acb_gauge = 0
        battler.chant = false
        next
      # 連携スキル発動中の場合
      elsif $imported["CooperationSkill"] && cooperation_exec?(battler)
        # ACBゲージ初期化
        battler.set_acb_count
        # 待機リストから削除
        @input_battlers.delete(battler)
        @action_battlers.delete(battler)
        next
      # 連続攻撃中の場合は飛ばす
      elsif $imported["EquipExtension"] && battler.is_a?(Game_Actor) &&
          battler.attack_count > 0
        next
      # 行動中なら飛ばす
      elsif @action_battler == battler
        next
      end
      # ゲージがMAXでない
      if battler.acb_gauge < battler.acb_gauge_max
        # ゲージ加算
        battler.acb_gauge += 1
        # ゲージがMAXになった場合
        if battler.acb_gauge == battler.acb_gauge_max
          # 固有ターン数加算
          battler.turn_count += 1
          # 強制アクションの場合
          if battler.current_action.forcing
            # 行動者リストに追加
            @action_battlers << battler
          else
            # アクション生成
            make_battler_action(battler)
          end
        end  # <- battler.acb_gauge == battler.acb_gauge_max
      end  # <- battler.acb_gauge < battler.acb_gauge_max
    }  # <- each
  end
  #--------------------------------------------------------------------------
  # ● バトルウェイト判定
  #--------------------------------------------------------------------------
  def battle_wait?
    # 「セミアクティブ」で、各種選択ウィンドウが開いている場合
    if $game_system.wait_mode == 1 &&
        (@skill_window != nil || @item_window != nil)
      return true
    # 「ウェイト」で、コマンド入力キャラがいる場合
    elsif $game_system.wait_mode == 2 && @input_battler != nil
      return true
    # 「セミアクティブ」または「ウェイト」で、行動待ちの場合
    elsif $game_system.wait_mode >= 1 && $game_system.action_wait &&
        @action_battler != nil
      return true
    end
    return false
  end
  #--------------------------------------------------------------------------
  # ● ターン進行
  #--------------------------------------------------------------------------
  def progress_turn
    # ターン数カウント
    $game_temp.battle_turn += 1
    # バトルイベントの全ページを検索
    $data_troops[@troop_id].pages.each_with_index { |page, index|
      # このページのスパンが [ターン] の場合
      if page.span == 1
        # 実行済みフラグをクリア
        $game_temp.battle_event_flags[index] = false
      end
    }
    # ターン計算用カウントを初期化
    @turn_acb_count = 0
    # ボーナスゲージを導入している場合
    if $imported["BonusGauge"]
      # ボーナスレートを減らす
      $game_temp.bonus_rate -= 10
      $game_temp.bonus_rate = [$game_temp.bonus_rate, 0].max
    end
    ($game_party.actors + $game_troop.enemies).compact.each { |battler|
      # ステート自然解除
      battler.remove_states_auto
      # スリップダメージ
      if KGC::ACB2::SLIP_DAMAGE == 1 && battler.hp > 0 && battler.slip_damage?
        battler.slip_damage_effect
        battler.damage_pop = true
      end
    }
    # ステータスウィンドウをリフレッシュ
    @status_window.refresh if @action_battler == nil
    # バトルイベントをセットアップ
    setup_battle_event
  end
  #--------------------------------------------------------------------------
  # ● アクション生成
  #--------------------------------------------------------------------------
  def make_battler_action(battler)
    if battler.is_a?(Game_Actor)
      make_actor_action(battler)
    else
      make_enemy_action(battler)
    end
  end
  #--------------------------------------------------------------------------
  # ● アクション生成(アクター)
  #--------------------------------------------------------------------------
  def make_actor_action(battler)
    # 詠唱中の場合
    if battler.chant?
      # 行動者リストに追加
      @action_battlers << battler
    # コマンド入力可能な場合
    elsif battler.inputable?
      # コマンド入力リストに追加
      @input_battlers << battler
    else
      if battler.restriction == 2 || battler.restriction == 3
        # アクションに攻撃を設定
        battler.current_action.kind = 0
        battler.current_action.basic = 0
      end
      # 行動者リストに追加
      @action_battlers << battler
    end
  end
  #--------------------------------------------------------------------------
  # ● アクション生成(エネミー)
  #--------------------------------------------------------------------------
  def make_enemy_action(battler)
    # 詠唱中なら即行動
    if battler.chant?
      @action_battlers << battler
      return
    end

    i = 0
    loop {
      # アクション生成
      battler.make_action
      # ３回アクション生成に失敗した場合は無理矢理通常攻撃にする
      if i == 2
        battler.current_action.kind = 0
        battler.current_action.basic = 0
      end
      # アクションを実行不可能な場合
      if battler.current_action.kind == 1 &&
          !battler.skill_can_use?(battler.current_action.skill_id)
        i += 1
        # アクションを再生成
        next
      end
      break
    }
    if KGC::ACB2::SKILL_CHANT
      # 詠唱時間セット
      judge_chant(battler)
    else
      # 行動者リストに追加
      @action_battlers << battler
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 2)
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● プレバトルフェーズ開始
  #--------------------------------------------------------------------------
  alias start_phase1_KGC_ACB start_phase1
  def start_phase1
    # バトラーヘルプウィンドウを作成
    @battler_help_window = Window_Help.new
    @battler_help_window.y = 256
    @battler_help_window.back_opacity = 160
    @battler_help_window.visible = false
    # エネミーのACBゲージを初期化
    $game_troop.enemies.each { |battler|
      battler.set_acb_count
      battler.acb_gauge = rand(battler.acb_gauge_max / 2)
      battler.chant = false
    }

    $game_temp.battle_main_phase = true
    @actor_command_window.opacity = 0
    if KGC::ACB2::SHOW_ORDER_BAR
      @status_window.restore_actor_order_icon
      @status_window.restore_enemy_order_icon
      @status_window.update_order_bar
    end

    @status_window.create_acb_gauge_sprite(@spriteset.viewport2)
    @status_window.refresh

    # トランジション割り込み終了
    Graphics.end_interrupt_transition

    start_phase1_KGC_ACB
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (パーティコマンドフェーズ)
  #--------------------------------------------------------------------------
  alias update_phase2_KGC_ACB update_phase2
  def update_phase2
    # C ボタンが押された場合
    if Input.trigger?(Input::C)
      # パーティコマンドウィンドウのカーソル位置で分岐
      case @party_command_window.index
      when 0  # 戦う
        # 決定 SE を演奏
        $game_system.se_play($data_system.decision_se)
        # アクターコマンドに戻す
        @party_command_window.active = false
        @party_command_window.visible = false
        @actor_command_window.active = true
        return
      when 1  # 逃げる
        # 逃走可能ではない場合
        unless $game_temp.battle_can_escape
          # ブザー SE を演奏
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # 決定 SE を演奏
        $game_system.se_play($data_system.decision_se)
        # アクターコマンドに戻す
        @party_command_window.active = false
        @party_command_window.visible = false
        @actor_command_window.active = true
        # 逃走処理
        update_phase2_escape
        # 逃走失敗の場合
        if @escape_failed
          escape_fail_effect
        end
        return
      end
    end

    update_phase2_KGC_ACB
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (パーティコマンドフェーズ : 逃げる)
  #--------------------------------------------------------------------------
  alias update_phase2_escape_KGC_ACB update_phase2_escape
  def update_phase2_escape(skill = nil)
    # 逃走スキルの場合は元の処理を実行
    if skill != nil
      update_phase2_escape_KGC_ACB(skill)
      return
    end

    @escape_failed = false
    # 素早さ平均値を計算
    enemies_agi = calc_agi_average($game_troop.enemies)
    actors_agi = calc_agi_average($game_party.actors)
    # 逃走判定
    prob = 50 * actors_agi / [enemies_agi, 1].max + @escape_prob_rev
    if rand(100) < prob
      # コマンド入力中のアクターがいる場合
      if @input_battler != nil
        dispose_actor_window
        disable_actor_command_window
        # アクターの明滅エフェクト OFF
        @input_battler.blink = false
      end
      # ヘルプウィンドウ消去
      @help_window.visible = false
      if @help_window2 != nil
        @help_window2.visible = false
      end
      # 逃走 SE を演奏
      $game_system.se_play($data_system.escape_se)
      # バトル開始前の BGM に戻す
      $game_system.bgm_play($game_temp.map_bgm)
      # バトル終了
      battle_end(1)
      return
    # 逃走失敗の場合
    else
      @escape_prob_rev += KGC::ACB2::ESCAPE_PROB_REVISE
      @escape_failed = true
      return
    end
  end
  #--------------------------------------------------------------------------
  # ● 平均素早さ計算
  #--------------------------------------------------------------------------
  def calc_agi_average(battlers)
    agi = n = 0
    battlers.each { |battler|
      if battler.exist?
        agi += battler.agi
        n += 1
      end
    }
    if n > 0
      agi /= n
    end
    return agi
  end
  #--------------------------------------------------------------------------
  # ● 逃走失敗効果
  #--------------------------------------------------------------------------
  def escape_fail_effect
    $game_party.actors.each { |actor|
      @input_battlers.delete(actor)
      @action_battlers.delete(actor)
      actor.current_action.clear
      actor.set_acb_count
    }
    cancel_command_input
    @help_window.set_text(KGC::ACB2::ESCAPE_FAIL_MESSAGE, 1)
  end
  #--------------------------------------------------------------------------
  # ● アクター用ウィンドウ解放
  #--------------------------------------------------------------------------
  def dispose_actor_window
    # エネミーアロー解放
    if @enemy_arrow != nil
      @enemy_arrow.dispose
      @enemy_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 @skill_group_window != nil
      @skill_group_window.dispose
      @skill_group_window = nil
    end
    # アイテムウィンドウ解放
    if @item_window != nil
      @item_window.dispose
      @item_window = nil
    end
  end
  #--------------------------------------------------------------------------
  # ● アクターコマンドウィンドウ無効化
  #--------------------------------------------------------------------------
  def disable_actor_command_window
    if @actor_command_window != nil
      @actor_command_window.active = false
      @actor_command_window.visible = false
      @actor_command_window.opacity = 0
    end
  end
  #--------------------------------------------------------------------------
  # ● アフターバトルフェーズ開始
  #--------------------------------------------------------------------------
  alias start_phase5_KGC_ACB start_phase5
  def start_phase5
    # コマンド入力中のアクターがいる場合
    if @input_battler != nil
      dispose_actor_window
      disable_actor_command_window
      # アクターの明滅エフェクト OFF
      @input_battler.blink = false if @input_battler != nil
    end
    # ヘルプウィンドウ消去
    @help_window.visible = false
    @help_window2.visible = false if @help_window2 != nil

    if @phase == 5
      return
    end

    start_phase5_KGC_ACB
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 3)
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● 次のアクターのコマンド入力へ
  #--------------------------------------------------------------------------
  def phase3_next_actor
    # 詠唱を行う場合
    if KGC::ACB2::SKILL_CHANT
      judge_chant(@active_battler)
    else
      # 行動者に追加
      @action_battlers << @active_battler
    end
    # アクターの明滅エフェクト OFF
    @active_battler.blink = false
    # アクターコマンドウィンドウを無効化
    @actor_command_window.active = false
    @actor_command_window.visible = false
    @actor_command_window.opacity = 0
    # 初期化
    @input_battler = nil
    @actor_index = nil
    @active_battler = nil
    # 予測位置をリセット
    @status_window.reset_predict_position
  end
  #--------------------------------------------------------------------------
  # ● 詠唱判定
  #     battler : 判定するバトラー
  #--------------------------------------------------------------------------
  def judge_chant(battler)
    skill = nil
    if battler.current_action.kind == 1 && !battler.chant?
      skill = $data_skills[battler.current_action.skill_id]
    end
    # 詠唱が必要なスキルの場合
    if skill != nil && need_chant?(battler.current_action)
      # 詠唱時間設定
      battler.set_chant_count
    else
      # 行動者に追加
      @action_battlers << battler
    end
  end
  #--------------------------------------------------------------------------
  # ● 詠唱判定
  #     action : 判定するアクション
  #--------------------------------------------------------------------------
  def need_chant?(action)
    skill = $data_skills[action.skill_id]
    # 詠唱判定
    if action.kind == 1
      return (skill.int_f >= KGC::ACB2::CHANT_SKILL_INT_F &&
        skill.atk_f < KGC::ACB2::NOT_CHANT_SKILL_ATK_F)
    end
    return false
  end
  #--------------------------------------------------------------------------
  # ● 前のアクターのコマンド入力へ
  #--------------------------------------------------------------------------
  def phase3_prior_actor
    # 何もしない
  end
  #--------------------------------------------------------------------------
  # ● コマンド入力状態解除
  #     delay : ディレイ効果で解除
  #--------------------------------------------------------------------------
  def cancel_command_input(delay = false)
    dispose_actor_window
    # ヘルプウィンドウを隠す
    @help_window.visible = false
    if $imported["HelpExtension"]
      @help_window2.visible = false
    end
    # バトラーヘルプウィンドウを隠す
    @battler_help_window.reset
    @battler_help_window.visible = false
    # アクターコマンドウィンドウを無効化
    disable_actor_command_window
    # アクターの明滅エフェクト OFF
    @input_battler.blink = false
    # ACBゲージ初期化
    unless delay
      @input_battler.set_acb_count
    end
    # コマンド入力解除
    @input_battler = nil
    # 予測位置をリセット
    @status_window.reset_predict_position
  end
  #--------------------------------------------------------------------------
  # ● アクターコマンドウィンドウのセットアップ
  #--------------------------------------------------------------------------
  unless $imported["SeparationCommand"]
  def phase3_setup_command_window
    # パーティコマンドウィンドウを無効化
    @party_command_window.active = false
    @party_command_window.visible = false
    # アクターコマンドウィンドウを解放
    if @actor_command_window != nil
      @actor_command_window.dispose
    end
    # アクターコマンドウィンドウを作成
    s1 = $data_system.words.attack
    s2 = $data_system.words.skill
    s3 = $data_system.words.guard
    s4 = $data_system.words.item
    @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4])
    @actor_command_window.y = 160
    @actor_command_window.back_opacity = 160
    # アクターコマンドウィンドウを有効化
    @actor_command_window.active = true
    @actor_command_window.visible = true
    # アクターコマンドウィンドウの位置を設定
    @actor_command_window.x =
      [@active_battler.screen_x - 80,
      640 - @actor_command_window.width].min
    # インデックスを 0 に設定
    @actor_command_window.index = 0
  end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (アクターコマンドフェーズ)
  #--------------------------------------------------------------------------
  alias update_phase3_KGC_ACB update_phase3
  def update_phase3
    # 行動不可能になったらコマンド入力解除
    if @active_battler.current_action.forcing ||
        !@active_battler.inputable? ||
        @active_battler.restriction == 2 ||
        @active_battler.restriction == 3 ||
        !$game_party.actors.include?(@active_battler)
      # 強制行動ならば行動者に追加
      if @active_battler.current_action.forcing ||
          @active_battler.restriction == 2 ||
          @active_battler.restriction == 3
        if @active_battler.restriction == 2 || @active_battler.restriction == 3
          # アクションに攻撃を設定
          @active_battler.current_action.kind = 0
          @active_battler.current_action.basic = 0
        end
        @action_battlers << @active_battler
      end
      cancel_command_input
      return
    end

    update_phase3_KGC_ACB

    update_phase3_predict_acb_count
  end
  #--------------------------------------------------------------------------
  # ● 待機時間予測を更新
  #--------------------------------------------------------------------------
  def update_phase3_predict_acb_count
    if @active_battler == nil
      return
    end

    action = get_selecting_action
    if action.kind != 1 || action.skill_id > 0
      # 待機時間を算出
      n = 0
      chant_flag = need_chant?(action)
      if chant_flag
        n = @active_battler.calc_chant_count(action)
      else
        n = @active_battler.calc_acb_count(action)
      end
      @status_window.set_predict_position(n, chant_flag)
    else
      # 待機時間を予測できない場合はリセット
      @status_window.reset_predict_position
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (アクターコマンドフェーズ : 基本コマンド)
  #--------------------------------------------------------------------------
  alias update_phase3_basic_command_KGC_ACB update_phase3_basic_command
  def update_phase3_basic_command
    # パーティコマンドボタンが押された場合
    if KGC::ACB2::PARTYCOMMAND_BUTTON != nil &&
        Input.trigger?(KGC::ACB2::PARTYCOMMAND_BUTTON)
      # パーティコマンドに切り替え
      @party_command_window.active = true
      @party_command_window.visible = true
      @actor_command_window.active = false
      return
    end
    # 切り替えボタンが押された場合
    if Input.trigger?(KGC::ACB2::CHANGE_INPUT_BUTTON)
      # 決定 SE を演奏
      $game_system.se_play($data_system.decision_se)
      # コマンド入力者に追加
      @input_battlers << @active_battler
      # アクターの明滅エフェクト OFF
      @active_battler.blink = false
      # アクターコマンドウィンドウを無効化
      disable_actor_command_window
      # コマンド入力解除
      @input_battler = nil
      @actor_index = nil
      @active_battler = nil
      return
    end
    if KGC::ACB2::USE_CHANGE_INPUT_NEIGHBOR
      # L,R ボタンが押された場合
      if Input.trigger?(Input::L) || Input.trigger?(Input::R)
        # 隣のアクターへ移動
        $game_system.se_play($data_system.decision_se)
        battler = @active_battler
        @input_battlers << @active_battler
        @active_battler.blink = false
        disable_actor_command_window
        @input_battler = nil
        @actor_index = nil
        @active_battler = nil
        input_next_actor(battler, Input.trigger?(Input::L) ? -1 : 1)
        return
      end
    end

    update_phase3_basic_command_KGC_ACB
  end
  #--------------------------------------------------------------------------
  # ● 選択中のアクションを取得
  #--------------------------------------------------------------------------
  unless method_defined?(:get_selecting_action)
  def get_selecting_action(battler = @active_battler)
    action = Game_BattleAction.new
    case @actor_command_window.index
    when 0  # 攻撃
      action.kind = 0
      action.basic = 0
    when 1  # スキル
      action.kind = 1
      if @skill_window != nil && @skill_window.active
        skill = @skill_window.skill
        if skill != nil
          action.skill_id = skill.id
        end
      end
    when 2  # 防御
      action.kind = 0
      action.basic = 1
    when 3  # アイテム
      action.kind = 2
    end
    return action
  end
  end
  #--------------------------------------------------------------------------
  # ● 入力者を隣のアクターへ移動
  #--------------------------------------------------------------------------
  def input_next_actor(target, shift)
    # 隣のアクターを調べる
    index = $game_party.actors.index(target) + shift
    size = $game_party.actors.size
    if index < 0
      index += size
    elsif index >= size
      index -= size
    end
    next_battler = $game_party.actors[index]
    # 隣のアクターを優先指定
    if @input_battlers.include?(next_battler)
      @input_battlers.delete(next_battler)
      @input_battlers.unshift(next_battler)
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (アクターコマンドフェーズ : エネミー選択)
  #--------------------------------------------------------------------------
  alias update_phase3_enemy_select_KGC_ACB update_phase3_enemy_select
  def update_phase3_enemy_select
    # 敵が存在しなくなった場合
    if enemy_none?
      # エネミーの選択を終了
      end_enemy_select
      return
    end

    update_phase3_enemy_select_KGC_ACB
  end
  #--------------------------------------------------------------------------
  # ● エネミー選択開始
  #--------------------------------------------------------------------------
  alias start_enemy_select_KGC_ACB start_enemy_select
  def start_enemy_select
    # 敵が存在しなくなった場合
    if enemy_none?
      # ブザー SE を演奏
      $game_system.se_play($data_system.buzzer_se)
      return
    end

    start_enemy_select_KGC_ACB

    # ヘルプウィンドウを設定
    @help_window.visible = false
    @enemy_arrow.help_window = @battler_help_window
  end
  #--------------------------------------------------------------------------
  # ● エネミー残存判定
  #--------------------------------------------------------------------------
  def enemy_none?
    $game_troop.enemies.each { |enemy|
      # 生存エネミーが存在
      unless enemy.dead?
        return false
      end
    }
    return true
  end
  #--------------------------------------------------------------------------
  # ● エネミー選択終了
  #--------------------------------------------------------------------------
  alias end_enemy_select_KGC_ACB end_enemy_select
  def end_enemy_select
    end_enemy_select_KGC_ACB

    # バトラーヘルプウィンドウを隠す
    @battler_help_window.reset
    @battler_help_window.visible = false
  end
  #--------------------------------------------------------------------------
  # ● アクター選択開始
  #--------------------------------------------------------------------------
  alias start_actor_select_KGC_ACB start_actor_select
  def start_actor_select
    start_actor_select_KGC_ACB

    # ヘルプウィンドウを設定
    @help_window.visible = false
    @actor_arrow.help_window = @battler_help_window
  end
  #--------------------------------------------------------------------------
  # ● アクター選択終了
  #--------------------------------------------------------------------------
  alias end_actor_select_KGC_ACB end_actor_select
  def end_actor_select
    end_actor_select_KGC_ACB

    # バトラーヘルプウィンドウを隠す
    @battler_help_window.reset
    @battler_help_window.visible = false
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Battle (分割定義 4)
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # ● メインフェーズ開始
  #--------------------------------------------------------------------------
  def start_phase4
    # ステップ 1 に移行
    @phase4_step = 1
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (メインフェーズ ステップ 1 : アクション準備)
  #--------------------------------------------------------------------------
  def update_phase4_step1
    # ヘルプウィンドウを隠す
    @help_window.visible = false
    # 勝利または敗北の場合 : メソッド終了
    return if judge
    # アニメーション ID およびコモンイベント ID を初期化
    @animation1_id = 0
    @animation2_id = 0
    @common_event_id = 0
    # スリップダメージ
    if KGC::ACB2::SLIP_DAMAGE == 0 && @active_battler.hp > 0 &&
        @active_battler.slip_damage?
      @active_battler.slip_damage_effect
      @active_battler.damage_pop = true
    end
    if $imported["DelaySkill"] && @active_battler != nil
      # 遅延スキル処理
      for i in 0...@active_battler.delay_skills.size
        # 発動までのターン数を減らす
        @active_battler.delay_skills[i].turn_count -= 1
      end
    end
    # 何もしない場合
    if @active_battler.current_action.kind == 0 &&
        @active_battler.current_action.basic == 3
      # ステップ 6 に移行
      @phase4_step = 6
    else
      # ステップ 2 に移行
      @phase4_step = 2
    end
  end
  #--------------------------------------------------------------------------
  # ● 基本アクション 結果作成
  #--------------------------------------------------------------------------
  alias make_basic_action_result_KGC_ACB make_basic_action_result
  def make_basic_action_result
    make_basic_action_result_KGC_ACB

    # 攻撃の場合
    if @active_battler.current_action.basic == 0
      delay = calc_delay_damage(@active_battler.element_set)
      if delay > 0
        # ディレイ適用
        apply_delay_effect(delay)
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● ディレイダメージ算出
  #--------------------------------------------------------------------------
  def calc_delay_damage(elements)
    delay = 0
    elements.each { |i|
      if $data_system.elements[i] =~ $game_special_elements["acb_delay"]
        delay += $1.to_i
      end
    }
    return delay
  end
  #--------------------------------------------------------------------------
  # ● ディレイ効果適用
  #--------------------------------------------------------------------------
  def apply_delay_effect(delay)
    @target_battlers.each { |target|
      # ダメージを与えていなければ次へ
      if !target.damage.is_a?(Numeric) || target.damage <= 0
        next
      end

      # ディレイ効果を計算
      acb_dmg = $game_temp.base_acb_count / target.agi
      if $game_special_elements["acb_delay_resist"] != nil
        acb_dmg =
          acb_dmg * target.element_rate(
          $game_special_elements["acb_delay_resist"]) / 100
      end
      acb_dmg = [acb_dmg * delay / 100, 0].max
      target.acb_gauge -= acb_dmg
      # コマンド入力キャンセル
      if !KGC::ACB2::INVALID_DELAY_INPUT && target.is_a?(Game_Actor) &&
          target == @input_battler && target.acb_gauge < target.acb_gauge_max
        cancel_command_input(true)
      end
      @input_battlers.delete(target)
      @action_battlers.delete(target)
    }
  end
  #--------------------------------------------------------------------------
  # ● スキルアクション 結果作成
  #--------------------------------------------------------------------------
  alias make_skill_action_result_KGC_ACB make_skill_action_result
  def make_skill_action_result
    # スキルを発動できない場合は通常攻撃に変更
    skill_id = @active_battler.current_action.skill_id
    unless @active_battler.skill_can_use?(skill_id)
      @active_battler.current_action.kind = 0
      @active_battler.current_action.basic = 0
      make_basic_action_result
      @skill_action_canceled = true
      return
    end

    make_skill_action_result_KGC_ACB

    delay = calc_delay_damage(@skill.element_set)
    if delay > 0
      # ディレイ適用
      apply_delay_effect(delay)
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
  #--------------------------------------------------------------------------
  alias update_phase4_step6_KGC_ACB update_phase4_step6
  def update_phase4_step6
    @help_window.reset

    update_phase4_step6_KGC_ACB

    if !($imported["CooperationSkill"] && @cooperation_skill_exec) &&
        !@additional_action_execute
      # バトルイベントをセットアップ
      setup_battle_event
      # ACBゲージ初期化
      @action_battler.set_acb_count
      # 行動解除
      @action_battler.current_action.forcing = false
      @action_battler = nil
      case KGC::ACB2::TURN_METHOD
      when 1
        # ターン進行
        progress_turn
      when 2
        # ターン進行判定
        @turn_acb_count += 1
        if @turn_acb_count >= movable_battler_count
          progress_turn
        end
      end
      # 戦闘終了判定
      judge
    end
  end
  #--------------------------------------------------------------------------
  # ● 行動可能者数取得
  #--------------------------------------------------------------------------
  def movable_battler_count
    n = 0
    # 行動可能者数を計算
    ($game_party.actors + $game_troop.enemies).each { |battler|
      if battler.movable?
        n += 1
      end
    }
    return n
  end
end