[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français

Oui.

Edit 14 juin 2021.
Le script présenté ne fonctionnant apparemment pas, voici la version traduite en anglais, qui est un peu différente (étendue par Mr Anonymous).
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/   ◆               OverDrive System - KGC_OverDrive                   ◆ VX ◆
#_/   ◇                   Last Update: 2008/08/28                             ◇
#_/   ◆              Original Translation by Touchfuzzy                       ◆
#_/   ◆        Extended Translation and Updates by Mr. Anonymous              ◆
#_/   ◆ KGC Site:                                                             ◆
#_/   ◆ http://f44.aaa.livedoor.jp/~ytomy/                                    ◆
#_/   ◆ Translator's Blog:                                                    ◆
#_/   ◆ http://mraprojects.wordpress.com                                      ◆
#_/-----------------------------------------------------------------------------
#_/  This script allows the designer to create skills that are not usable in
#_/  battle until a character gains enough points from specified actions to use
#_/  them. To set up a skill as an "Overdrive" skill (which doesn't appear until
#_/  the Overdrive Gauge is full), go into the database, click the Skills tab,
#_/  locate the skill you desire, and then enter <overdrive> into the "Notes"
#_/  text box. Also, you may desire some skills to increase the Overdrive Gauge
#_/  more than others. 
#_/  To do so, enter <OD_gain n%> (where n = a number) into the desired skill's 
#_/  "Notes" box. Example: <OD_gain 200%> would increase Overdrive Points 
#_/  gained from Attack Gain Rate (80 by default) by 200 percent (x2).
#_/  The formula for this is [attackgainrate * n / 100]
#_/=============================================================================
#_/                       ◆ Script Commands ◆
#_/  These commands are used in "Script" function in the third page of event
#_/   commands under "Advanced".
#_/
#_/  Increase OverDrive for an actor:
#_/   * gain_actor_od_gauge(ActorID, Increase)
#_/  
#_/  Increase OverDrive for an enemy:
#_/   * gain_enemy_od_gauge(EnemyID, Increase)
#_/
#_/  Modify an actor's drive types:
#_/   * set_actor_drive_type(ActorID, [DriveTypes])
#_/
#_/  Modify an enemy's drive types:
#_/   * set_enemy_drive_type(EnemyID, [DriveTypes])
#_/
#_/  [ Quick Key:                                                              ]
#_/  [ ActorID = The ID number of the selected Actor in the database.          ]
#_/  [  Setting this to -1 will effect all actors.                             ]
#_/  [                                                                         ]
#_/  [ EnemyID = The ID number of the selected Enemy in the current troop. 0-7 ]
#_/  [  Setting this to -1 will effect all enemies.                            ]
#_/  [                                                                         ]
#_/  [ Increase = The amount of OverDrive points to increase.                  ]
#_/  [                                                                         ]
#_/  [ DriveTypes = The drive types as seen below in the customization block   ]
#_/  [  "DEFAULT_ACTOR_DRIVE_TYPE". If this is omitted, it's reset to default. ]
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
 
#=============================================================================#
#                          ★ 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 OverDrive Points that battlers will be given  
  #   for specific actions performed.  
  GAIN_RATE = [
    100,  # 0  Gained per attack.
    500,  # 1  Gained for taking damage.
          #    This is per 100% MaxHP of damage taken, so with 500 you would
          #    have to take 2 times your MaxHP to fill a 1,000 point 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.
     40,  # 5  Gained for taking any action in a round
    160,  # 6  Gained for each round surviving with 25% or less HP remaining.
    180,  # 7  Gained for each round for guarding.
  ]  # ← No not remove these lines. Alter to your heart's content, though.
 
  #                         ◆ Amount of Gauges ◆
  # This allows you to specify how many gauges the actor has. These gauges stack
  #  meaning when that after the first gauge is maxed, OverDrive points are 
  #  allocated to the next gauge. This also means that after using an OverDrive
  #  skill, OverDrive points are given for that action if applicable.
  #  As a final note, these gauges are displayed as one whole gauge.
  DEFAULT_GAUGE_NUMBER = 1
 
  #              ◆ Default Actor OverDrive 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 OverDrive 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]
 
  #                    ◆ OverDrive Gauge Colors ◆
  #  Allows you to change the color of the overdrive gauges.
  #  The color can also be determined by a red, green, and blue values.
  #  Example: GAUGE_NORMAL_START_COLOR = Color.new(255, 0, 0)  <- This is red.
  #   This method of color assignment is much like Tint Screen event command.
  #  Gauge Start Color
  GAUGE_NORMAL_START_COLOR = 14
  #  Gauge End Color
  GAUGE_NORMAL_END_COLOR   = 6
  #  Max Gauge Start Color
  GAUGE_MAX_START_COLOR    = 10
  #  Max Gauge End Color
  GAUGE_MAX_END_COLOR      = 2
 
  #                        ◆ Gauge Y Coordinate ◆
  # This allows you to adjust the Y coordinate(depth) of the overdrive gauge.
  #  Setting to -8 places the OD gauge at the same depth as the HP/MP gauges. 
  GAUGE_OFFSET_Y = -8
  
  #              ◆ Numerical Display of OverDrive Gauge Style ◆
  # This function allows you to display a numerical representation of the 
  #  current amount of OverDrive points an actor has.
  #   0: No numerical amount is displayed.
  #   1: Default - Displays the current amount as a straight number.
  #   2: Ratio 1 --> x%
  #   3: Ratio 2 --> x.x%
  #   4: Ratio 3 --> x.xx%
  #   5: Maxing  - Amount of times the gauge has maxed since the battle started.
  GAUGE_VALUE_STYLE = 2
  
  #                   ◆ Numerical Display Font Size ◆
  #  This allows you to change the font size of the numerical display of the
  #   OverDrive gauge, as defined above.
  GAUGE_VALUE_FONT_SIZE = 14
 
  #                    ◆ 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 = []
  
  #                       ◆ 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  = true
 
  #             ◆ 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 = false
  
  #                      ◆ Use Image as Gauge Toggle ◆
  # If set to true, the old-style system-drawn gauges are replaced by user
  #  created images. Note that as of now, using this option hides the numerical
  #  gauge display function. This MAY be fixed by adjusting GAUGE_OFFSET_Y as
  #  seen above, but hasn't been tested.
  USE_IMAGE_GAUGE = true
  #                        ◆ Gauge Image Graphic ◆
  #  This setting allows you to define the image you want to use as the drive
  #   gauge bar. The image must be located in the "Graphics\System" folder.
  GAUGE_IMAGE  = "gauge_od2"
  
  #                  ◆ Menu Gauge Image Position [x, y] ◆
  #  Actor names are relative to the coordinates in the menu defined below.
  GAUGE_POSITION = [-32, -8]
  #                      ◆ Menu Gauge Image Length ◆
  #  For a longer or shorter gauge, increase or decrease this number.
  GAUGE_LENGTH   = 52
  
  #                 ◆ Battle Gauge Image Position [x, y] ◆
  #  Actor names are relative to the coordinates during battle defined below.
  GAUGE_POSITION_BATTLE = [-32, -8]
  
  #                     ◆ Battle Gauge Image Length ◆
  #  For a longer or shorter gauge, increase or decrease this number.
  GAUGE_LENGTH_BATTLE   = 52
  
  #                      ◆ OverDrive Max Sound Play ◆  
  #  Sound played on overdrive gauge max. (Filename, Pitch, Volume)
  #   Sounds are selected from the Audio\SE folder.
  ODMAX_SOUND = RPG::SE.new("Flash2",     100,    150)
  end
end
 
#=============================================================================#
#                          ★ End Customization ★                              #
#=============================================================================#
 
#=================================================#
#                    IMPORT                       #
#=================================================#
 
$imported = {} if $imported == nil
$imported["OverDrive"] = true
 
#=================================================#
 
module KGC::OverDrive
  # Drive Increase Type Module
  module Type
    ATTACK  = 0  # Attack
    DAMAGE  = 1  # Damage
    VICTORY = 2  # Victory
    ESCAPE  = 3  # Escape
    ALONE   = 4  # Alone
    ACTION  = 5  # Action
    FATAL   = 6  # Fatal
    GUARD   = 7  # Guard
  end
 
#=================================================#  
  
  # Numerical Display of OverDrive Gauge
  module ValueStyle
    NONE         = 0  # None
    IMMEDIATE    = 1  # Immediate
    RATE         = 2  # Ratio 1
    RATE_DETAIL1 = 3  # Ratio 2
    RATE_DETAIL2 = 4  # Ratio 3
    NUMBER       = 5  # Gauge Number
  end
 
#==============================================================================
# □ KGC::SkillCPSystem::Regexp
#==============================================================================
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
#                          Note Field Tag Strings                             #
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
#  Whatever word(s) are after the separator ( | ) in the following lines are 
#   what are used to determine what is searched for in the "Note" section of a 
#   skill.
  
  # Regular Expressions Module
  module Regexp
    # Skill Module
    module Skill
      # OverDrive tag string
      OVER_DRIVE = /<(?:OVER_DRIVE|overdrive)\s*(\d+)?>/i
      # OverDrive Gain Rate tag string
      OD_GAIN_RATE = /<(?:OD_GAIN_RATE|OD_gain)\s*(\d+)[%％]?>/i
    end
  end
end
 
#=================================================#
 
#==============================================================================
# □ KGC::Commands
#==============================================================================
 
module KGC
  module 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
        # All living party 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
        # All living enemies in troop's 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
  #--------------------------------------------------------------------------
  # ○ Get Actor OverDrive Gauge
  #     actor_id    : Actor ID (-1 : Entire Party)
  #     variable_id : Variable ID
  #--------------------------------------------------------------------------
    def get_actor_od_gauge(actor_id, variable_id = 0)
      actor = $game_actors[actor_id]
      n = (actor != nil ? actor.overdrive : 0)
      if variable_id > 0
        $game_variables[variable_id] = n
      end
      return n
    end
  #--------------------------------------------------------------------------
  # ○ Get Enemy OverDrive Gauge
  #     enemy_index : EnemyID (-1 : Entire Party)
  #     variable_id : Variable ID
  #--------------------------------------------------------------------------
    def get_enemy_od_gauge(enemy_index, variable_id = 0)
      enemy = $game_troop.members[enemy_index]
      n = (enemy != nil ? enemy.overdrive : 0)
      if variable_id > 0
        $game_variables[variable_id] = n
      end
      return n
    end
  #--------------------------------------------------------------------------
  # ○ Set Actor Drive Number
  #     actor_id : Actor ID (-1 : Entire Party)
  #     number    : Array of number type 
  #--------------------------------------------------------------------------
    def set_actor_od_gauge_number(actor_id, number)
      if actor_id == -1
        # All living party members members gauge is operated.
        $game_party.members.each { |actor|
          actor.drive_gauge_number = number
        }
      else
        actor = $game_actors[actor_id]
        actor.drive_gauge_number = number if actor != nil
      end
    end
  #--------------------------------------------------------------------------
  # ○ Set Enemy Drive Number
  #     enemy_index : Enemy ID
  #     number    : Array of number type 
  #--------------------------------------------------------------------------
    def set_enemy_od_gauge_number(enemy_index, number)
      if enemy_index == -1
        # All living enemies in troop's gauge is operated.
        $game_troop.members.each { |enemy|
          enemy.drive_gauge_number = number
        }
      else
        enemy = $game_troop.members[enemy_index]
        enemy.drive_gauge_number = number if enemy != nil
      end
    end
  #--------------------------------------------------------------------------
  # ○ Determine Actor Drive Max
  #     actor_id : ActorID
  #--------------------------------------------------------------------------
  def actor_od_gauge_max?(actor_id)
    actor = $game_actors[actor_id]
    return false if actor == nil
    return actor.overdrive == actor.max_overdrive
  end
   #--------------------------------------------------------------------------
  # ○ Determine Enemy Drive Max
  #     enemy_index : Enemy Index
  #--------------------------------------------------------------------------
  def enemy_od_gauge_max?(enemy_index)
    enemy = $game_troop.members[enemy_index]
    return false if enemy == nil
    return enemy.overdrive == enemy.max_overdrive
  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
      # Set all party members' drive types
      $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
      # All enemies' gauge is operated.
      $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
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
  #--------------------------------------------------------------------------
  # ● Public Instance Variables
  #--------------------------------------------------------------------------
  attr_writer   :drive_type               # Drive Type
  attr_writer   :odmax_sound_played       # OverDrive Max Sound Flag
  #--------------------------------------------------------------------------
  # ○ Acquire amount of drive gauge
  #--------------------------------------------------------------------------
  def overdrive
    @overdrive = 0 if @overdrive == nil
    return @overdrive
  end
  #--------------------------------------------------------------------------
  # ○ Drive Gauge Max Acquisition
  #--------------------------------------------------------------------------
  def overdrive=(value)
    @overdrive = [[value, max_overdrive].min, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ Obtain Max OverDrive
  #--------------------------------------------------------------------------
  def max_overdrive
    return KGC::OverDrive::GAUGE_MAX * drive_gauge_number
  end
  #--------------------------------------------------------------------------
  # ○ Numerical Drive Gauge Definition
  #--------------------------------------------------------------------------
  def drive_gauge_number
    if @drive_gauge_number == nil
      @drive_gauge_number = KGC::OverDrive::DEFAULT_GAUGE_NUMBER
    end
    return @drive_gauge_number
  end
  #--------------------------------------------------------------------------
  # ○ Aquire Numerical Drive Value
  #--------------------------------------------------------------------------
  def drive_gauge_number=(value)
    @drive_gauge_number = [value, 1].max
  end
  #--------------------------------------------------------------------------
  # ○ Define Drive Type
  #--------------------------------------------------------------------------
  def drive_type
    return []
  end
  #--------------------------------------------------------------------------
  # ○ Determine OverDrive Skill Aquired
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    return true
  end
  #--------------------------------------------------------------------------
  # ○ Determine True/False Gauge Display
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    return false
  end
  #--------------------------------------------------------------------------
  # ○ Determine True/False Gauge Increase 
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    return true
  end
  #--------------------------------------------------------------------------
  # ○ Defined Sound Played on Gauge Max - Added by Mr. Anonymous 8/19/08
  #--------------------------------------------------------------------------
  def odmax_sound
    return KGC::OverDrive::ODMAX_SOUND
  end
  #--------------------------------------------------------------------------
  # ○ Defined Sound Played on Gauge Max - Added by Mr. Anonymous 8/19/08
  #--------------------------------------------------------------------------
  def odmax_sound_played
   # return true
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Attack
  #--------------------------------------------------------------------------
  def drive_attack?
    return drive_type.include?(KGC::OverDrive::Type::ATTACK)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Damage
  #--------------------------------------------------------------------------
  def drive_damage?
    return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Victory
  #--------------------------------------------------------------------------
  def drive_victory?
    return drive_type.include?(KGC::OverDrive::Type::VICTORY)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Escape
  #--------------------------------------------------------------------------
  def drive_escape?
    return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Alone
  #--------------------------------------------------------------------------
  def drive_alone?
    return drive_type.include?(KGC::OverDrive::Type::ALONE)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Action
  #--------------------------------------------------------------------------
  def drive_action?
    return drive_type.include?(KGC::OverDrive::Type::ACTION)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Fatal
  #--------------------------------------------------------------------------
  def drive_fatal?
    return drive_type.include?(KGC::OverDrive::Type::FATAL)
  end
  #--------------------------------------------------------------------------
  # ○ Determine OD Increase: Guard
  #--------------------------------------------------------------------------
  def drive_guard?
    return drive_type.include?(KGC::OverDrive::Type::GUARD)
  end
  #--------------------------------------------------------------------------
  # ● State Addition
  #     state_id : State 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
  #--------------------------------------------------------------------------
  # ○ Calculate Skill Drive Gauge Consumption
  #     skill : Skill
  #--------------------------------------------------------------------------
  def calc_od_cost(skill)
    return 0 unless skill.is_a?(RPG::Skill)
 
    return skill.od_cost
  end
  #--------------------------------------------------------------------------
  # ● Skill Use Determination
  #     skill : 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
  #--------------------------------------------------------------------------
  # ● Execute Damage
  #     user : User of Skill or Item
  #    Before @hp_damage、@mp_damage、@absorbed is called, they must be set.
  #--------------------------------------------------------------------------
  alias execute_damage_KGC_OverDrive execute_damage
  def execute_damage(user)
    execute_damage_KGC_OverDrive(user)
 
    increase_overdrive(user)
  end
  #--------------------------------------------------------------------------
  # ○ Reset OverDrive on Death
  #--------------------------------------------------------------------------
  def reset_overdrive_on_dead
    return unless KGC::OverDrive::EMPTY_ON_DEAD
 
    self.overdrive = 0
  end
  #--------------------------------------------------------------------------
  # ○ Increase Overdrive
  #     attacker : Attacker
  #--------------------------------------------------------------------------
  def increase_overdrive(attacker = nil)
    return unless attacker.is_a?(Game_Battler)  # Unless attacker is a battler
    return if self.class == attacker.class      # and attacker class is predefined
    return if hp_damage == 0 && mp_damage == 0  # and they cannot attack,
    # if they can gain overdrive...
    if can_gain_overdrive?
      # increase the overdrive. 
      increase_attacker_overdrive(attacker)
      increase_defender_overdrive(attacker)
    end
    # If battler dies, reset overdrive.
    reset_overdrive_on_dead if dead?
  end
  #--------------------------------------------------------------------------
  # ○ Increase Attacker's Overdrive
  #     attacker : Attacker
  #--------------------------------------------------------------------------
  def increase_attacker_overdrive(attacker)
    return unless attacker.drive_attack?  # Unless attack has od attack type
 
    od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
    if attacker.action.kind == 1
      rate = attacker.action.skill.od_gain_rate  # obtain rate from od type
      od_gain = od_gain * rate / 100
      if rate > 0
        od_gain = [od_gain, 1].max
      elsif rate < 0
        od_gain = [od_gain, -1].min
      end
    end
    attacker.overdrive += od_gain
    #----------------------------------------------------------------
    # Determine OverDrive Max Sound's play state and play when maxed.
    #  Added by Mr. Anonymous 8/19/08
    #----------------------------------------------------------------
    # If Attacker's overdrive is greater than GAUGE_MAX...
    if attacker.overdrive < KGC::OverDrive::GAUGE_MAX
      # set attacker's overdrive max sound played flag to false.
      attacker.odmax_sound_played = false
    end
      # If attacker's overdrive max sound played flag is set to false...
    if attacker.odmax_sound_played == false 
      # and attacker's overdrive is equal to GAUGE_MAX...
      if attacker.overdrive == KGC::OverDrive::GAUGE_MAX
        # Play overdrive max sound...
        odmax_sound.play
       # set attacker's overdrive max sound played flag to true.       
        attacker.odmax_sound_played = true
      end
    end
    #----------------------------------------------------------------
    # End max OverDrive determination.
    #----------------------------------------------------------------
  end
  #--------------------------------------------------------------------------
  # ○ Increase Attacker's Overdrive
  #     attacker : Attacker
  #--------------------------------------------------------------------------
  def increase_defender_overdrive(attacker)
    return unless self.drive_damage?  # Unless attacker has od damage type
 
    rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
    od_gain = 0
    od_gain += hp_damage * rate / maxhp if hp_damage > 0
    od_gain += mp_damage * rate / maxmp if mp_damage > 0 && maxmp > 0
    if rate > 0
      od_gain = [od_gain, 1].max
    elsif rate < 0
      od_gain = [od_gain, -1].min
    end
    self.overdrive += od_gain
    #----------------------------------------------------------------
    # Determine OverDrive Max Sound's play state and play when maxed.
    #  Added by Mr. Anonymous 8/19/08
    #----------------------------------------------------------------
    # If defender's overdrive is greater than GAUGE_MAX...
    if self.overdrive < KGC::OverDrive::GAUGE_MAX
      # set defender's overdrive max sound played flag to false.
      self.odmax_sound_played = false
    end
      # If defender's overdrive max sound played flag is set to false...
    if self.odmax_sound_played == false 
      # and defender's overdrive is equal to GAUGE_MAX...
      if self.overdrive == KGC::OverDrive::GAUGE_MAX
        # Play overdrive max sound...
        odmax_sound.play
       # set defender's overdrive max sound played flag to true.       
        self.odmax_sound_played = true
      end
    end
    #----------------------------------------------------------------
    # End max OverDrive determination.
    #----------------------------------------------------------------
  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
  #--------------------------------------------------------------------------
  # ● Setup
  #     actor_id : ActorID
  #--------------------------------------------------------------------------
  alias setup_KGC_OverDrive setup
  def setup(actor_id)
    setup_KGC_OverDrive(actor_id)
 
    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ Aquire OverDrive Type
  #--------------------------------------------------------------------------
  def drive_type
    unless @drive_type.is_a?(Array)
      return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
    end
    return @drive_type
  end
  #--------------------------------------------------------------------------
  # ○ Determine OverDrive Skill Aquired
  #--------------------------------------------------------------------------
  def overdrive_skill_learned?
    result = false
    # Temporarily Cancel Battle Flag
    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
  #--------------------------------------------------------------------------
  # ○ Determine Gauge Increase
  #--------------------------------------------------------------------------
  def can_gain_overdrive?
    if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
      # Hide
      return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    end
    if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
      # No learned
      return false unless overdrive_skill_learned?
    end
 
    return true
  end
  #--------------------------------------------------------------------------
  # ○ Determine Gauge Display
  #--------------------------------------------------------------------------
  def od_gauge_visible?
    # Hide gauge in Battle
    if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
      return false
    end
    # Hide Gauge
    return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
    # Gauge amount doesn't increase.
    return false unless can_gain_overdrive?
 
    return true
  end
end
 
#=================================================#
 
#==============================================================================
# ■ Game_Enemy
#==============================================================================
 
class Game_Enemy < Game_Battler
  #--------------------------------------------------------------------------
  # ● Object Initialization
  #     index    : Index in enemy group
  #     enemy_id : EnemyID
  #--------------------------------------------------------------------------
  alias initialize_KGC_OverDrive initialize
  def initialize(index, enemy_id)
    initialize_KGC_OverDrive(index, enemy_id)
 
    @overdrive = 0
    @drive_type = nil
  end
  #--------------------------------------------------------------------------
  # ○ Aquire OverDrive　Type
  #--------------------------------------------------------------------------
  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
  #----------------------------------------------------------------------
  # Determine Gauge Image Type
  # - Added by Mr. Anonymous 8/19/08
  # If the user doesn't use gauge images, define system gauge properties.
  #----------------------------------------------------------------------
  if KGC::OverDrive::USE_IMAGE_GAUGE = false
    #--------------------------------------------------------------------------
    # ○ OD Gauge Normal Color 1 
    #--------------------------------------------------------------------------
    def od_gauge_normal_color1
      color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
      return (color.is_a?(Integer) ? text_color(color) : color)
    end
    #--------------------------------------------------------------------------
    # ○ OD Gauge Normal Color 2
    #--------------------------------------------------------------------------
    def od_gauge_normal_color2
      color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
      return (color.is_a?(Integer) ? text_color(color) : color)
    end
    #--------------------------------------------------------------------------
    # ○ OD Gauge Max Color 1 
    #--------------------------------------------------------------------------
    def od_gauge_max_color1
      color = KGC::OverDrive::GAUGE_MAX_START_COLOR
      return (color.is_a?(Integer) ? text_color(color) : color)
    end
    #--------------------------------------------------------------------------
    # ○ OD Gauge Max Color 2 
    #--------------------------------------------------------------------------
    def od_gauge_max_color2
      color = KGC::OverDrive::GAUGE_MAX_END_COLOR
      return (color.is_a?(Integer) ? text_color(color) : color)
    end
  end # <- if KGC::OverDrive::USE_IMAGE_GAUGE = false
  #--------------------------------------------------------------------------
  # ● Draw Actor Name
  #     actor : Actor
  #     x     : Coordinates at X Axis
  #     y     : Coordinates at Y Axis
  #--------------------------------------------------------------------------
  alias draw_actor_name_KGC_OverDrive draw_actor_name
  def draw_actor_name(actor, x, y)
    draw_actor_od_gauge(actor, x, y, 108)
    draw_actor_name_KGC_OverDrive(actor, x, y)
  end
  #----------------------------------------------------------------------
  # Determine Gauge Image Type
  # - Added by Mr. Anonymous 8/19/08
  # If the user doesn't use gauge images, draw system gauge.
  #----------------------------------------------------------------------
  if KGC::OverDrive::USE_IMAGE_GAUGE = false
    #--------------------------------------------------------------------------
    # ○ Draw Actor OverDrive Gauge
    #     actor : Actor
    #     x     : Coordinates at X Axis
    #     y     : Coordinates at Y Axis
    #     width : Width
    #--------------------------------------------------------------------------
    def draw_actor_od_gauge(actor, x, y, width = 120)
      return unless actor.od_gauge_visible?
 
      n = actor.overdrive % KGC::OverDrive::GAUGE_MAX
      n = KGC::OverDrive::GAUGE_MAX if actor.overdrive == actor.max_overdrive
      gw = width * n / KGC::OverDrive::GAUGE_MAX
      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 + KGC::OverDrive::GAUGE_OFFSET_Y,
        width, 6, gauge_back_color)
      self.contents.gradient_fill_rect(
        x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y, gw, 6, gc1, gc2)
 
      draw_actor_od_gauge_value(actor, x, y, width)
    end
  #----------------------------------------------------------------------
  # Determine Gauge Image Type
  # - Added by Mr. Anonymous 8/19/08
  # Else, the user IS using gauge images...
  #----------------------------------------------------------------------
  else 
    #--------------------------------------------------------------------------
    # ○ Draw Actor OverDrive Gauge
    #     actor    : Actor
    #     x        : Coordinates at X Axis
    #     y        : Coordinates at Y Axis
    #     in_width : Inner Width
    #--------------------------------------------------------------------------
    def draw_actor_od_gauge(actor, x, y, in_width)
      # Exit process if the OD Gauge isn't visible.
      return unless actor.od_gauge_visible?
      
      bitmap = self.contents 
      # Define the gauge image.
      gauge = Bitmap.new("Graphics/System/" + KGC::OverDrive::GAUGE_IMAGE)
      nx = x # X Coordinate
      ny = y # Y Coordinate
      nw = in_width # Inner image width
      if $game_temp.in_battle # If inside a battle
        # Pull customized battle values from the OverDrive module.
        nx += KGC::OverDrive::GAUGE_POSITION_BATTLE[0]
        ny += KGC::OverDrive::GAUGE_POSITION_BATTLE[1]
        nw += KGC::OverDrive::GAUGE_LENGTH_BATTLE
      else # when outside of battle
        # Pull customized values from the OverDrive module.
        nx += KGC::OverDrive::GAUGE_POSITION[0]
        ny += KGC::OverDrive::GAUGE_POSITION[1]
        nw += KGC::OverDrive::GAUGE_LENGTH
      end
      gauge_width = calc_od_gauge_width(actor, nw)
      full = (gauge_width == nw - 64)
      draw_od_gauge_back(bitmap, gauge, nx, ny, nw)
      draw_od_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width, full)
      draw_od_gauge_fore(bitmap, gauge, nx, ny, nw)
      draw_actor_od_gauge_value(actor, x, y, width)
    end
    #--------------------------------------------------------------------------
    # ○ Draw Gauge Background
    #     bitmap : Draw Image At...
    #     image  : Gauge Image
    #     in_width : Internal Width of Gauge
    #--------------------------------------------------------------------------
    def draw_od_gauge_back(bitmap, image, x, y, in_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, in_width - 64, 32)
      bitmap.stretch_blt(dest_rect, image, src_rect)
      src_rect.set(128, 0, 32, 32)
      bitmap.blt(x + in_width - 32, y, image, src_rect)
    end
    #--------------------------------------------------------------------------
    # ○ Draw Inner Drive Gauge
    #     bitmap : Draw Image At...
    #     image  : Gauge Image
    #     in_width    : Internal Width of Gauge
    #     gauge_width : Gauge External Width
    #     full :  Full Gauge 
    #--------------------------------------------------------------------------
    def draw_od_gauge_inside(bitmap, image, x, y, in_width, gauge_width, full)
      src_rect = Rect.new(0, (full ? 64 : 32), 0, 32)
      src_rect.width = gauge_width * 96 / (in_width - 64)
      dest_rect = Rect.new(x + 32, y, gauge_width, 32)
      bitmap.stretch_blt(dest_rect, image, src_rect)
    end
    #--------------------------------------------------------------------------
    # ○ Draw Gauge Foreground
    #     bitmap : Draw Image At...
    #     image  : Gauge Image
    #     in_width : Internal Width of Gauge
    #--------------------------------------------------------------------------
    def draw_od_gauge_fore(bitmap, image, x, y, in_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, in_width - 64, 32)
      bitmap.stretch_blt(dest_rect, image, src_rect)
      src_rect.set(288, 0, 32, 32)
      bitmap.blt(x + in_width - 32, y, image, src_rect)
    end
    #--------------------------------------------------------------------------
    # ○ Calculate Gauge Width
    #--------------------------------------------------------------------------
    def calc_od_gauge_width(actor, in_width)
      gw = actor.overdrive * (in_width - 64) / KGC::OverDrive::GAUGE_MAX
      return [[gw, 0].max, in_width - 64].min
    end
  #----------------------------------------------------------------------
  # End Gauge Image Type Determination
  # end ( if KGC::OverDrive::USE_IMAGE_GAUGE )
  #----------------------------------------------------------------------  
  end 
  #--------------------------------------------------------------------------
  # ○ Draw Actor OverDrive Numerical Value
  #     actor : Actor
  #     x     : Coordinates at X Axis
  #     y     : Coordinates at Y Axis
  #     width : Width
  #--------------------------------------------------------------------------
  def draw_actor_od_gauge_value(actor, x, y, width = 120)
    text = ""
    value = actor.overdrive * 100.0 / KGC::OverDrive::GAUGE_MAX
    case KGC::OverDrive::GAUGE_VALUE_STYLE
    when KGC::OverDrive::ValueStyle::IMMEDIATE
      text = actor.overdrive.to_s
    when KGC::OverDrive::ValueStyle::RATE
      text = sprintf("%d%%", actor.overdrive * 100 / KGC::OverDrive::GAUGE_MAX)
    when KGC::OverDrive::ValueStyle::RATE_DETAIL1
      text = sprintf("%0.1f%%", value)
    when KGC::OverDrive::ValueStyle::RATE_DETAIL2
      text = sprintf("%0.2f%%", value)
    when KGC::OverDrive::ValueStyle::NUMBER
      text = "#{actor.overdrive / KGC::OverDrive::GAUGE_MAX}"
    else
      return
    end
 
    last_font_size = self.contents.font.size
    new_font_size = KGC::OverDrive::GAUGE_VALUE_FONT_SIZE
    self.contents.font.size = new_font_size
    self.contents.draw_text(
      x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y - new_font_size / 2,
      width, new_font_size, text, 2)
    self.contents.font.size = last_font_size
  end
end
 
#=================================================#
 
#==============================================================================
# ■ Window_Skill
#==============================================================================
 
if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
 
  class Window_Skill < Window_Selectable
    #--------------------------------------------------------------------------
    # ○ Determine Skill in List
    #     skill : 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
 
      if skill.overdrive?
        return (@actor.calc_od_cost(skill) <= @actor.overdrive)
      else
        return true
      end
    end
 
    if method_defined?(:include_KGC_OverDrive?)
      #--------------------------------------------------------------------------
      # ● Refresh
      #--------------------------------------------------------------------------
      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  # <-- for i in 0...@item_max
      end  # <-- refresh
    end  # <-- if method_defined?(:include_KGC_OverDrive?)
  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
  #--------------------------------------------------------------------------
  # ● Battle End
  #     result : Result (0:Victory 1:Escape 2:Defeat)
  #--------------------------------------------------------------------------
  alias battle_end_KGC_OverDrive battle_end
  def battle_end(result)
    increase_overdrive_on_battle_end(result)
 
    battle_end_KGC_OverDrive(result)
  end
  #--------------------------------------------------------------------------
  # ○ Increase OverDrive on Battle End
  #     result : Result (0:Victory 1:Escape 2:Defeat)
  #--------------------------------------------------------------------------
  def increase_overdrive_on_battle_end(result)
    case result
    when 0  # Victory
      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  # Escape
      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
  #--------------------------------------------------------------------------
  # ● Execute Battle Action
  #--------------------------------------------------------------------------
  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? && battler.action.kind == 0 &&
        battler.action.basic == 1
      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