[#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/    ◆              Overdrive System - KGC_OverDrive                  ◆ VX ◆
#_/    ◇                  Last update : 2008/03/13                          ◇
#_/    ◆                  Translation by Touchfuzzy                          ◆
#_/    ◆            Additional polish by Mr. Anonymous                      ◆
#_/-----------------------------------------------------------------------------
# Modified to work with PHLiM2's MenuStatus System
#===============================================================================
#                          ★ Customization ★
#===============================================================================

module KGC
  module OverDrive
   
    #                      ◆ Maximum Gauge Points ◆ 
    #  This affects the amount of OP (Overdrive Points) required to fill the
    #  Overdrive Gauge. Default: GAUGE_MAX = 1000 
    GAUGE_MAX = 1000 
   
    #                      ◆ Default OP Gain Rates ◆
    #  You may specify the amount of OP battlers will be rewarded for specific 
    #  actions performed.  GAIN_RATE = [   
    100,  # 0  Gained for attack. 
    500,  # 1  Gained for taking damage.         
              #    This is per 100% MHP of damage taken, so with 500 you would have         
              #    to take 2 times your MHP to fill a 1000 GAUGE_MAX   
    200,  # 2  Gained for defeating an enemy.   
    100,  # 3  Gained each time you run away from a fight.   
    160,  # 4  Gained for each round spent while fighting solo in battle, either         
              #    being the only character or being the last one alive.   
      0,    # 5  Gained for taking any action in a round   
    160,  # 6  Gained for each round surviving with 25% or less HP remaining.   
    250,  # 7  Gained for each round for guarding. 
    ]
   
    #                ◆ Default Actor OD Increase Options ◆ 
    #  Default Overdrive types that affect player-characters. The numbers in the 
    #  brackets [] are chosen from the GAIN_RATE above, to the right of the #. 
    #  It appears these numbers "stack" when setting up an individual character's
    #  Overdrive parameters. 
    DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6, 7] 
   
    #                ◆ Default Enemy OD Increase Options ◆ 
    #  Default Overdrive types that affect enemies. The numbers in the brackets [] 
    #    are chosen from the GAIN_RATE above, to the right of the #. 
    DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6] 
   
    #                      ◆ OD Gauge Colors ◆ 
    #  Allows you to change the color of the overdrive gauges. 
    #  The color can also be determined by a numerical expression. 
    #  Example: GAUGE_NORMAL_START_COLOR = Color.new(255, 0, 0)  <- This is red. 
    #  If you've worked with HTML or image editing software, this should be 
    #  fairly familiar. 
    GAUGE_NORMAL_START_COLOR = 14 
    GAUGE_NORMAL_END_COLOR  = 6 
    GAUGE_MAX_START_COLOR    = 10 
    GAUGE_MAX_END_COLOR      = 2
   
    #                    ◆ Empty OD Gauge Upon Death ◆ 
    #  This toggle affects wether the OP Gauge is reset to zero once an actor 
    #  dies. true = Reset to 0. false = Gauge remains persistant.
    EMPTY_ON_DEAD = true 
   
    #                      ◆ Hide Actor OD Gauge ◆ 
    #  Hide the gauge for individual characters. The number of the character in 
    #  the Actors Database is inserted in the brackets. 
    #  Example: HIDE_GAUGE_ACTOR = [2] would always hide the gauge for the second 
    #  actor in the database. (Simple stuff.) 
    HIDE_GAUGE_ACTOR = [8,9,10]
 
    #                      ◆ Hide OD Gauge in Menu ◆ 
    #  This toggle allows you to hide the Overdrive gauge from the command menu. 
    #  true = Gauge is hidden. 
    #  false = Gauge remains persistant even in menu. 
    HIDE_GAUGE_NOT_IN_BATTLE = false 
   
    #                ◆ Hide OD Gauge When Actor Lacks OD Skills ◆ 
    #  This toggle allows you to hide the gauge if a character has no Overdrive
    #  skills in his/her arsenal. 
    #  true = Gauge is hidden. 
    #  false = Gauge is not hidden. 
    HIDE_GAUGE_NO_OD_SKILLS  = false
   
    #            ◆ Prevent Actors Without OD Skills From Gaining OP ◆
    # This toggle stops OP from being gained for characters that have no Overdrive 
    # skills when
    HIDE_GAUGE_NO_OD_SKILLS  = true. 
    NOT_GAIN_GAUGE_HIDING    = true 
   
    #                ◆ Hide OD Skills When Actor Lacks Max OP ◆
    #  This toggle allows you to specify wether skills that do not yet meet the 
    #  required OP are visible.  #  true = Skills are hidden
    #  false = skills are not hidden. 
    HIDE_SKILL_LACK_OF_GAUGE = true
   
    #                ◆ Play sound on OD Max ◆ 
    #  Play sound on gauge max.(Filename, Pitch, Volume) 
    ODMAX_SOUND = RPG::SE.new("Flash2",    100,    0)
  end
end

#------------------------------------------------------------------------------#

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

module KGC::OverDrive 
  module Type   
    ATTACK  = 0 
    DAMAGE  = 1 
    VICTORY = 2   
    ESCAPE  = 3   
    ALONE  = 4   
    ACTION  = 5 
    FATAL  = 6   
    GUARD  = 7 
  end 
 
  module Regexp   
    module Skill
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
#  Unless you know what you're doing, it's best not to alter anything beyond  #
#  this point, as this only affects the tags used for "Notes" in database.   
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #

#  Whatever word(s) are after the separator ( | ) in the following lines are
#  what are used to determine what is searched for in the "Notes" section of a
#  skill to see if it is an Overdrive skill.#  Default Overdrive tag is <overdrive>
#  Default OD_GAIN_RATE is <OD_GAIN>     

      OVER_DRIVE = /<(?:OVER_DRIVE|overdrive)[ ]*(\d+)?>/i
      OD_GAIN_RATE = /<(?:OD_GAIN_RATE|odgain)[ ]*(\d+)[%％]?>/i   
    end 
  end
end

# In events if you wish to use scripting to increase the OD Gauge for a
#  character you just use this line "gain_actor_od_gauge(ID, IG)"
#  ID = Actor ID Number,#  IG = number of points to increase gauge
#  Inserting -1 in ID makes it affect all characters.

# In events if you wish to use scripting to increase the OD Gauge for an
#  enemy you just use this line "gain_enemy_od_gauge(ID, IG)"
#  ID = Enemy ID Number in group 0-7
#  IG = number of points to increase gauge
#  Inserting -1 in ID makes it affect all enemies.

# In events if you wish to use scripting to change what increases the OD gauge
#  for a character use this line "set_actor_drive_type(ID, [ODT])"
#  ID = Actor ID Number
#  ODT = numbers of types of Overdrive adders to use
#  If the [ODT] is omitted it goes back to the defaults

# In events if you wish to use scripting to change what increases the OD gauge
#  for an us this line "set_enemy_drive_type(ID, [ODT])"
#  ID = Enemy ID Number in group 0-7
#  ODT = numbers of types of Overdrive adders to use
#  If the [ODT] is omitted it goes back to the defaults

#==============================================================================
# □ KGC::Commands
#==============================================================================

module KGC::Commands 
  module_function 
  #-------------------------------------------------------------------------- 
  # ○ Actor Overdrive Gain Gauge 
  #    actor_id : Actor ID (-1 : Entire Party) 
  #    value    : Increase Amount (Subtraction works as well) 
  #-------------------------------------------------------------------------- 
  def gain_actor_od_gauge(actor_id, value) 
    if actor_id == -1   
    # A all living members gauge is operated.     
    $game_party.existing_members.each { |actor|
    actor.overdrive += value
    }
  else
    actor = $game_actors[actor_id]     
    actor.overdrive += value if actor != nil && actor.exist?
  end
 end
  #-------------------------------------------------------------------------- 
  # ○ Enemy Overdrive Gain Gauge
  #    enemy_index : Enemy index (-1 : All Enemies) 
  #    value    : Increase Amount (Subtraction works as well) 
  #-------------------------------------------------------------------------- 
  def gain_enemy_od_gauge(enemy_index, value)   
    if enemy_index == -1   
      # A all living enemies gauge is operated.
      $game_troop.existing_members.each { |enemy|     
      enemy.overdrive += value   
      } 
    else
      enemy = $game_troop.members[enemy_index]     
      enemy.overdrive += value if enemy != nil && enemy.exist?
    end
  end 
  #-------------------------------------------------------------------------- 
  # ○ Set Actor Drive Type 
  #    actor_id : Actor ID (-1 : Entire Party) 
  #    types    : Array of drive type ( When omitted: Initialization. ) 
  #-------------------------------------------------------------------------- 
  def set_actor_drive_type(actor_id, types = nil)   
    if actor_id == -1     
      # A drive type all members is changed.     
      $game_party.members.each { |actor|       
      actor.drive_type = types
      }
    else
      actor = $game_actors[actor_id]
      actor.drive_type = types if actor != nil
    end
  end 
  #--------------------------------------------------------------------------
  # ○ Set Enemy Drive Type 
  #    actor_id : Enemy ID (-1 : All Enemies) 
  #    types    : Array of drive type ( When omitted: Initialization. )
  #-------------------------------------------------------------------------- 
  def set_enemy_drive_type(enemy_index, types = nil) 
    if enemy_index == -1
      # A drive type all enemies is changed.
      $game_troop.members.each { |enemy|
      enemy.drive_type = types
      }
    else
      enemy = $game_troop.members[enemy_index]     
      enemy.drive_type = types if enemy != nil   
    end
  end
end

#==============================================================================
# ■ RPG::Skill
#==============================================================================

class RPG::Skill < RPG::UsableItem 
  #--------------------------------------------------------------------------
  # ○ Overdrive cache generation 
  #-------------------------------------------------------------------------- 
  def create_overdrive_cache
    @__is_overdrive = false
    @__od_cost = KGC::OverDrive::GAUGE_MAX
    @__od_gain_rate = 100
   
    self.note.split(/[\r\n]+/).each { |line|
    case line   
    when KGC::OverDrive::Regexp::Skill::OVER_DRIVE
      # Overdrive
      @__is_overdrive = true
      @__od_cost = $1.to_i if $1 != nil
      when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
        # Gauge increase rate
        @__od_gain_rate = $1.to_i
      end
      }
      # Unless OverDrive doesn't consume gauge
      unless @__is_overdrive
        @__od_cost = 0
      end
    end
    #--------------------------------------------------------------------------
    # ○ OverDrive is a skill?
    #--------------------------------------------------------------------------
    def overdrive?
      create_overdrive_cache if @__is_overdrive == nil
      return @__is_overdrive
      end
      #-------------------------------------------------------------------------- 
      # ○ Consumption of drive gauge 
      #-------------------------------------------------------------------------- 
      def od_cost    create_overdrive_cache if @__od_cost == nil
        return @__od_cost
      end
      #-------------------------------------------------------------------------- 
      # ○ The drive gauge increase rate 
      #-------------------------------------------------------------------------- 
      def od_gain_rate    create_overdrive_cache if @__od_gain_rate == nil   
        return @__od_gain_rate
      end
    end
   
    #==============================================================================
    # ■ Game_Battler
    #==============================================================================
   
    class Game_Battler
      #--------------------------------------------------------------------------
      # ● Open Global Variable
      #--------------------------------------------------------------------------
      attr_writer  :drive_type
      # Drive Type
      #--------------------------------------------------------------------------
      # ○ Acquire amount of drive gauge
      #-------------------------------------------------------------------------
      def overdrive   
        @overdrive = 0 if @overdrive == nil
        return @overdrive
      end
      #--------------------------------------------------------------------------
      # ○ Drive gauge maximum amount acquisition
      #--------------------------------------------------------------------------
      def max_overdrive
        return KGC::OverDrive::GAUGE_MAX
      end
      #--------------------------------------------------------------------------
      # ○ ドライブゲージの操作
      #--------------------------------------------------------------------------
      def overdrive=(value)
        @overdrive = [[value, max_overdrive].min, 0].max
      end
     
      #--------------------------------------------------------------------------
      # ○ Sound played on gauge max
      #--------------------------------------------------------------------------
      def odmax_sound
        return KGC::OverDrive::ODMAX_SOUND
      end
     
      #------------------------#
      def odmax_sound_played?   
        return false
        end 
       
        #------------------------#
       
        #-------------------------------------------------------------------------- 
        # ○ ドライブタイプの取得 
        #-------------------------------------------------------------------------- 
        def drive_type
          return []
        end 
        #--------------------------------------------------------------------------
        # ○ OverDrive スキル習得済み判定
        #-------------------------------------------------------------------------- 
        def overdrive_skill_learned?   
          return true
        end
        #--------------------------------------------------------------------------
        # ○ ゲージ表示判定
        #-------------------------------------------------------------------------- 
        def od_gauge_visible?
          return false
        end
        #--------------------------------------------------------------------------
        # ○ ゲージ増加可否判定
        #--------------------------------------------------------------------------
        def can_gain_overdrive?
          return true
        end
        #--------------------------------------------------------------------------
        # ○ 攻撃時増加判定
        #--------------------------------------------------------------------------
        def drive_attack?
          return drive_type.include?(KGC::OverDrive::Type::ATTACK)
        end
        #--------------------------------------------------------------------------
        # ○ 被ダメージ時増加判定
        #-------------------------------------------------------------------------- 
        def drive_damage?   
          return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
        end
        #--------------------------------------------------------------------------
        # ○ 勝利時増加判定
        #--------------------------------------------------------------------------
        def drive_victory?
          return drive_type.include?(KGC::OverDrive::Type::VICTORY)
        end
        #--------------------------------------------------------------------------
        # ○ 逃走時増加判定
        #--------------------------------------------------------------------------
        def drive_escape?
          return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
        end
        #--------------------------------------------------------------------------
        # ○ 孤独時増加判定
        #--------------------------------------------------------------------------
        def drive_alone?
          return drive_type.include?(KGC::OverDrive::Type::ALONE)
        end
        #--------------------------------------------------------------------------
        # ○ 行動時増加判定
        #--------------------------------------------------------------------------
        def drive_action?
          return drive_type.include?(KGC::OverDrive::Type::ACTION)
        end
        #--------------------------------------------------------------------------
        # ○ 瀕死時増加判定
        #--------------------------------------------------------------------------
        def drive_fatal? 
          return drive_type.include?(KGC::OverDrive::Type::FATAL)
        end
        #--------------------------------------------------------------------------
        # ○ Determine guard
        #--------------------------------------------------------------------------
        def drive_guard?
          return drive_type.include?(KGC::OverDrive::Type::GUARD)
        end
       
        #--------------------------------------------------------------------------
        # ● ステートの付加
        #    state_id : ステート ID
        #--------------------------------------------------------------------------
        alias add_state_KGC_OverDrive add_state
        def add_state(state_id)
          add_state_KGC_OverDrive(state_id)
          reset_overdrive_on_dead if dead?
        end
        #--------------------------------------------------------------------------
        # ○ スキルの消費ドライブゲージ計算
        #    skill : スキル
        #--------------------------------------------------------------------------
        def calc_od_cost(skill)
          return 0 unless skill.is_a?(RPG::Skill)
         
          return skill.od_cost
        end
        #--------------------------------------------------------------------------
        # ● スキルの使用可能判定
        #    skill : スキル
        #--------------------------------------------------------------------------
        alias skill_can_use_KGC_OverDrive? skill_can_use?
        def skill_can_use?(skill)
          return false unless skill_can_use_KGC_OverDrive?(skill)
         
          return false if calc_od_cost(skill) > overdrive
          return true
        end
        #--------------------------------------------------------------------------
        # ● ダメージの反映
        #    user : スキルかアイテムの使用者
        #    呼び出し前に @hp_damage、@mp_damage、@absorbed が設定されていること。
        #-------------------------------------------------------------------------- 
        alias execute_damage_KGC_OverDrive execute_damage
        def execute_damage(user)
          execute_damage_KGC_OverDrive(user)
          increase_overdrive(user)
        end
        #--------------------------------------------------------------------------
        # ○ 死亡時ドライブゲージ初期化処理
        #--------------------------------------------------------------------------
        def reset_overdrive_on_dead
          return unless KGC::OverDrive::EMPTY_ON_DEAD
          self.overdrive = 0
        end
        #--------------------------------------------------------------------------
        # ○ ドライブゲージ増加処理
        #    attacker : 攻撃者
        #-------------------------------------------------------------------------- 
        def increase_overdrive(attacker = nil)
          return unless attacker.is_a?(Game_Battler)  # 攻撃者がバトラーでない
          return if self.class == attacker.class      # 攻撃側と防御側が同じ 
          return if hp_damage == 0 && mp_damage == 0  # ダメージなし
         
          if can_gain_overdrive?
            increase_attacker_overdrive(attacker)
            increase_defender_overdrive(attacker)
          end
          reset_overdrive_on_dead if dead?
        end
       
        #--------------------------------------------------------------------------
        # ○ Increase Attacker's Overdrive
        #    attacker : Attacker
        #--------------------------------------------------------------------------
        def increase_attacker_overdrive(attacker)
          return unless attacker.drive_attack?
          # Drive type "Attack" none
         
          od_gain = [KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK], 1].max
          if attacker.action.kind == 1
            rate = attacker.action.skill.od_gain_rate  # Rate of the skill is applied.
            od_gain = od_gain * rate / 100
          end
          attacker.overdrive += od_gain
          # Added by Mr. Anonymous 4/9/08 
          # if attacker's overdrive = gauge_max
          if attacker.overdrive == max_overdrive && odmax_sound_played? == false
            odmax_sound.play      def odmax_sound_played?
            return true
          end
        end
      end
      #--------------------------------------------------------------------------
      # ○ Increase Defender's Overdrive
      #    attacker : Attacker
      #--------------------------------------------------------------------------
      def increase_defender_overdrive(attacker)
        return unless self.drive_damage?  # No Drive Type "Damage"
       
        rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
        od_gain = hp_damage * rate / maxhp
        od_gain += mp_damage * rate / maxmp if maxmp > 0
        self.overdrive += [od_gain, 1].max    # Added by Mr. Anonymous 4/9/08
        # if actor recieves damage leading to overdrive = gauge_max
        if self.overdrive == max_overdrive && odmax_sound_played? == false
          odmax_sound.play
          def odmax_sound_played?
            return true
          end
        end
      end
      #--------------------------------------------------------------------------
      # ● Skill Effects
      #    user  : User
      #    skill : Skill
      #--------------------------------------------------------------------------
      alias skill_effect_KGC_OverDrive skill_effect
      def skill_effect(user, skill)
      skill_effect_KGC_OverDrive(user, skill)
     
      # If imported KGC_ReproduceFunctions & item used has execute skill tag...
      if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
        return
      end
    end
  end
 
  #==============================================================================
  # ■ Game_Actor
  #==============================================================================
 
  class Game_Actor < Game_Battler
    #--------------------------------------------------------------------------
    # ● セットアップ  #    actor_id : アクター ID
    #--------------------------------------------------------------------------
    alias setup_KGC_OverDrive setup
    def setup(actor_id)
    setup_KGC_OverDrive(actor_id)
   
    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive タイプの取得
  #--------------------------------------------------------------------------
  def drive_type
    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
    end
    return @drive_type
  end
  #--------------------------------------------------------------------------
  # ○ OverDrive スキル習得済み判定
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    result = false
    # 一時的に戦闘中フラグを解除
    last_in_battle = $game_temp.in_battle
    $game_temp.in_battle = false
   
    self.skills.each { |skill|
    if skill.overdrive?
      result = true
      break
    end
    }
    $game_temp.in_battle = last_in_battle
    return result
  end
  #--------------------------------------------------------------------------
  # ○ ゲージ増加可否判定
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
      # 非表示
      return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    end    if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
    # 未修得
    return false unless overdrive_skill_learned?
    end
    return true
  end
  #--------------------------------------------------------------------------
  # ○ ゲージ表示判定
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    # 戦闘中非表示
    if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
      return false    end
      # 非表示
      return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
      # ゲージ増加不可
      return false unless can_gain_overdrive?
      return true
    end
  end
 
  #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★
 
  #==============================================================================
  # ■ Game_Enemy
  #==============================================================================
 
  class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # ● オブジェクト初期化
    #    index    : 敵グループ内インデックス
    #    enemy_id : 敵キャラ ID 
    #--------------------------------------------------------------------------
    alias initialize_KGC_OverDrive initialize
    def initialize(index, enemy_id)
      initialize_KGC_OverDrive(index, enemy_id)
     
      @overdrive = 0
      @drive_type = nil
    end 
    #--------------------------------------------------------------------------
    # ○ OverDrive　タイプの取得
    #--------------------------------------------------------------------------
    def drive_type    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
    end
    return @drive_type
  end
end

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの通常時の色 1 の取得
  #--------------------------------------------------------------------------
  def od_gauge_normal_color1
    color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの通常時の色 2 の取得
  #--------------------------------------------------------------------------
  def od_gauge_normal_color2
    color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR 
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの最大時の色 1 の取得
  #-------------------------------------------------------------------------- 
  def od_gauge_max_color1 
    color = KGC::OverDrive::GAUGE_MAX_START_COLOR 
    return (color.is_a?(Integer) ? text_color(color) : color) 
  end 
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの最大時の色 2 の取得 
  #-------------------------------------------------------------------------- 
  def od_gauge_max_color2   
    color = KGC::OverDrive::GAUGE_MAX_END_COLOR 
    return (color.is_a?(Integer) ? text_color(color) : color) 
  end
  #-------------------------------------------------------------------------- 
  # ● 名前の描画 
  #    actor : アクター 
  #    x    : 描画先 X 座標 
  #    y    : 描画先 Y 座標
  #-------------------------------------------------------------------------- 
  alias draw_actor_name_KGC_OverDrive draw_actor_name
  def draw_actor_name(actor, x, y)   
    draw_actor_od_gauge(actor, x, y, 120)   
 
    draw_actor_name_KGC_OverDrive(actor, x, y) 
  end
  #-------------------------------------------------------------------------- 
  # ● 名前の描画
  #    actor : アクター 
  #    x    : 描画先 X 座標
  #    y    : 描画先 Y 座標
  #--------------------------------------------------------------------------
  # ○ ドライブゲージの描画 
  #    actor : アクター 
  #    x    : 描画先 X 座標 
  #    y    : 描画先 Y 座標 
  #    width : 幅 
  #-------------------------------------------------------------------------- 
  def draw_actor_od_gauge(actor, x, y, width = 76) 
    return unless actor.od_gauge_visible?   
    gw = width * actor.overdrive / actor.max_overdrive 
    gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)   
    gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)   
    self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
  end
end

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

if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
  class Window_Skill < Window_Selectable
    #--------------------------------------------------------------------------
    # ○ スキルをリストに含めるかどうか
    #    skill : スキル
    #-------------------------------------------------------------------------- 
    unless $@ 
      alias include_KGC_OverDrive? include? if method_defined?(:include?) 
    end
    def include?(skill)   
    return false if skill == nil 
   
    if defined?(include_KGC_OverDrive?)   
      return false unless include_KGC_OverDrive?(skill)
    end 
   
    return false unless skill.overdrive? 
    return (@actor.calc_od_cost(skill) <= @actor.overdrive) 
  end
 
  if method_defined?(:include_KGC_OverDrive?) 
    #--------------------------------------------------------------------------
    # ● リフレッシュ
    #-------------------------------------------------------------------------- 
    def refresh 
      @data = [] 
      for skill in @actor.skills     
        next unless include?(skill)   
        @data.push(skill)     
        if skill.id == @actor.last_skill_id     
          self.index = @data.size - 1     
        end 
      end 
      @item_max = @data.size 
      create_contents 
      for i in 0...@item_max   
        draw_item(i) 
      end 
      end
    end
 
  end # <-- class
  end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
 
  #==============================================================================
  # ■ Scene_Skill
  #==============================================================================
 
  class Scene_Skill < Scene_Base
    #--------------------------------------------------------------------------
    # ● Use Skill(The effects of use other than the ally object are applied.)
    #--------------------------------------------------------------------------
    alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget 
    def use_skill_nontarget
      consume_od_gauge
     
      use_skill_nontarget_KGC_OverDrive
    end 
    #--------------------------------------------------------------------------
    # ○ Consume Drive gauge when skill is used
    #-------------------------------------------------------------------------- 
    def consume_od_gauge
      @actor.overdrive -= @actor.calc_od_cost(@skill)
    end
  end
 
  #==============================================================================
  # ■ Scene_Battle
  #==============================================================================
 
  class Scene_Battle < Scene_Base
    #--------------------------------------------------------------------------
    # ● 戦闘終了  #    result : 結果 (0:勝利 1:逃走 2:敗北)
    #-------------------------------------------------------------------------- 
    alias battle_end_KGC_OverDrive battle_end
    def battle_end(result)    increase_overdrive_on_battle_end(result)   
      battle_end_KGC_OverDrive(result) 
    end
    #--------------------------------------------------------------------------
    # ○ 戦闘終了時のドライブゲージ増加処理 
    #    result : 結果 (0:Victory 1:Escape 2:Defeat)
    #-------------------------------------------------------------------------- 
    def increase_overdrive_on_battle_end(result)   
      case result   
      when 0  # 勝利   
        od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]   
        $game_party.existing_members.each { |actor|     
        actor.overdrive += od_gain if actor.drive_victory?   
        }   
        when 1  # 逃走     
          od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]   
          $game_party.existing_members.each { |actor|     
          actor.overdrive += od_gain if actor.drive_escape? 
          } 
        end
      end
      #--------------------------------------------------------------------------
      # ● 戦闘行動の実行
      #-------------------------------------------------------------------------- 
      alias execute_action_KGC_OverDrive execute_action
      def execute_action
        increase_overdrive_on_action 
        execute_action_KGC_OverDrive 
      end 
      #--------------------------------------------------------------------------
      # ○ Increase Gauge on Action
      #-------------------------------------------------------------------------- 
      def increase_overdrive_on_action   
        battler = @active_battler 
        od_gain = 0
        unit = (battler.actor? ? $game_party : $game_troop) 
       
        # Alone 
        if battler.drive_alone? && unit.existing_members.size == 1   
          od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE] 
        end 
        # Action 
        if battler.drive_action?   
          od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION] 
        end 
        # Fatal 
        if battler.drive_fatal? && battler.hp < battler.maxhp / 4   
          od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL] 
        end   
        # Guard 
        if battler.drive_guard?   
          od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::GUARD] 
        end    battler.overdrive += od_gain  end
        #--------------------------------------------------------------------------
        # ● Execution of battle action: Skill
        #-------------------------------------------------------------------------- 
        alias execute_action_skill_KGC_OverDrive execute_action_skill
        def execute_action_skill 
        execute_action_skill_KGC_OverDrive 
       
        consume_od_gauge
      end 
      #--------------------------------------------------------------------------
      # ○ Drive gauge consumption when skill is used
      #-------------------------------------------------------------------------- 
      def consume_od_gauge 
        skill = @active_battler.action.skill 
        @active_battler.overdrive -= @active_battler.calc_od_cost(skill)
      end
      end