Partagez
Aller en bas
Orbital
Orbital
Membre

Nombre de messages : 141
Age : 28
Localisation : Euh, tu vois la France ? l'Isère ? grenoble ? SMH ? ma maison ? le bureau ? le PC ? bah c'est là
Distinction : aucune
Date d'inscription : 09/08/2008

Extension pour script overdrive (style FF8) Empty Extension pour script overdrive (style FF8)

le Dim 7 Mar 2010 - 12:50
Bonjour à tous !
Type de script : euh...add-on SBS/ATB + overdrive
Explication complete :Voilà donc déjà je bosse avec le SBS en version ATB. L'ajout de ce script ne devrait rencontrer aucun problème de compatibilité, je m'explique :
Tout d'abord j'utilise le script KGC_overdrive, très utile. Sauf que les skill overdrive sont dans la partie compétences avec tout les autres sorts.
Bien, je voudrai qu'il y ait en fait une catégorie (en plus d'attaquer, objets, compétence, se protéger) qui se débloque quand la jauge d'overdrive est plein.
De cette manière, quand la jauge d'un chara X est pleine, je veux qu'à chaque fois que c'est à lui de jouer on entende un bruit qui montre qu'il a accès à ces limit et en plus qu'une flèche apparaisse à gauche de la commande "attaquer". Ainsi il nous restera à appuyer sur gauche pour avoir accès à un nouveau micro menu pour choisir les différents overdrive du perso. Si le perso en a plusieurs je veux que le premier apparaisse. Avec une flèche vers le bas. Si on appuie sur bas on a le 2ème OD, et là on a une flèche vers le haut et vers le bas (si il a au moins 3 OD) et ainsi de suite afin de naviguer entre les limit du perso.
En image trop belle ça donne :
Extension pour script overdrive (style FF8) 9651769456527_od1
Puis si on appuie sur bas :
Extension pour script overdrive (style FF8) 6801153296652_od2
Si on appuie sur haut on remonte vers Jugement.
On voit qu'il y a une autre flèche vers le bas quand on se trouve sur Damoclès, Fowne a donc au moins 3 skill overdrive.

De plus que l'on soit sur n'importe quel skill OD, si on appuie sur la flèche de droite on retombe sur la commande attaquer. (et le micro menu des OD disparait)

Notez le fait que tant que les battle command du perso sont visible on doit voir la flèche animé (celle à gauche de "attaquer"), cependant le son lui ne se joue que lors de l'apparition des battle commande du perso X (qu'une fois par tour en somme). Je veux aussi que la nouvelle boite pour choisir les skill soit épaisse pour seulement une ligne.

Spécificités :Je veux qu'une fois la barre overdrive du personnage X remplie, la flèche apparait et un son se fait entendre quand c'est au tour du perso X de jouer (à chacun de ses tours). Dans le script je voudrais pouvoir régler le volume histoire de mettre le truc comme je veux.

Ressources supplémentaires : j'aurais une petite flèche comme ça animée : Extension pour script overdrive (style FF8) 4904502280722_fleche

Exemples dans un jeu video : dans FF8 il y a exactement le même système. Quand la limit du perso se débloque on entend un son aigüe en même temps que l'apparition de la flèche. Ensuite on appuie sur gauche et là on peut choisis son overdrive (suivant le perso).

Voilà, en espérant n'oublier rien et avoir fait une demande clair en bon et dû forme,
merci d'avance !


Edit :

OMFG, j'ai oublié de vous parlez du script KGC_Overdrive..sans ça ça aller être dur de faire la condition de la jauge pleine.

Spoiler:
Code:
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/ ◆ OverDrive System - KGC_OverDrive ◆ VX ◆
#_/ ◇  Last Update: 08/28/2008
#_/ ◆ Written by TOMY   
#_/ ◆ Translation by Touchfuzzy 
#_/ ◆ Extended Translation and Updates by Mr. Anonymous
#_/ ◆ KGC Site:                                                 
#_/ ◆  http://ytomy.sakura.ne.jp/                                 
#_/ ◆ 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 = [
    15,  # 0  Gained per attack.
    60,  # 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.
    20,  # 2  Gained for defeating an enemy.
    5,  # 3  Gained each time you run away from a fight.
    35,  # 4  Gained for each round spent while fighting solo in battle, either
          #    being the only character or being the last one alive.
    5,  # 5  Gained for taking any action in a round
    40,  # 6  Gained for each round surviving with 25% or less HP remaining.
    30,  # 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



Voilà, me semble que la condition serait if @overdrive = max.overdrive, mais vu que j'y connais rien en script je vous laisse faire x)
Orbital
Orbital
Membre

Nombre de messages : 141
Age : 28
Localisation : Euh, tu vois la France ? l'Isère ? grenoble ? SMH ? ma maison ? le bureau ? le PC ? bah c'est là
Distinction : aucune
Date d'inscription : 09/08/2008

Extension pour script overdrive (style FF8) Empty Re: Extension pour script overdrive (style FF8)

le Dim 7 Mar 2010 - 13:03
Il y a aussi surement ce script qui est utile (c'est lui qui gère les images de mes jauges, dont une qui apparait en clignotant quand la jauge est pleine) :
Spoiler:
Code:
#==============================================================================
# ★RGSS2
# STR11+og_KGC Overdrive v1.1 08/03/13
# ◇ Requires STR11e_Battle Status
#
# ・Move above Main if you want to have KGC_OD display and
#  Add this script below STR11e_Battle Status
#  "Btskin_odg.png" is provided in the demo.
#
# <Material Instructions>
# ◇ Skin images are imported to (Graphics\System)
#   Width = Any size
#  Height = Gauge height * 3
#
#  First Row: OD Skin、
#  Second Row: Normal Gauge color
#  Third Row: Gauge MAX (flashing) color
#
#  Mr. Bubble: I fixed a stack error when used with *STR11+atb_Wait Gauge.
#------------------------------------------------------------------------------

#==============================================================================
# ■ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Selectable
  # Gauge skin
  BTSKIN_10 = "Btskin_odg"  # File name
  BTSKIN_10XY = [48, 8]    # Coordinates [x, y]
  #--------------------------------------------------------------------------
  # ★ エイリアス
  #--------------------------------------------------------------------------
  alias initialize_str11pog_od initialize
  def initialize(f = false)
    @odgw = (Cache.system(BTSKIN_10)).width
    initialize_str11pog_od(f)
  end
  #--------------------------------------------------------------------------
  # ● アイテム作成
  #--------------------------------------------------------------------------
  alias draw_item_str11pog draw_item
  def draw_item(index)
    return unless @f
    actor = $game_party.members[index]
    draw_item_str11pog(index)
    s = @s_sprite[index]
    # ODゲージ
    s[21] = Sprite.new(@viewport)
    s[21].bitmap = Cache.system(BTSKIN_10)
    s[21].x = @x[index] + BTSKIN_B_XY[0] + BTSKIN_10XY[0]
    s[21].y = @y[index] + BTSKIN_B_XY[1] + BTSKIN_10XY[1]
    s[21].z = 4
    w = s[21].bitmap.width
    h = s[21].bitmap.height / 3
    s[21].src_rect.set(0, h, w, h)
    # ODゲージ下地
    s[22] = Sprite.new(@viewport)
    s[22].bitmap = Cache.system(BTSKIN_10)
    s[22].x = @x[index] + BTSKIN_B_XY[0] + BTSKIN_10XY[0]
    s[22].y = @y[index] + BTSKIN_B_XY[1] + BTSKIN_10XY[1]
    s[22].z = 3
    s[22].src_rect.set(0, 0, w, h)
    #
    s[23] = ((@odgw * (actor.overdrive / (actor.max_overdrive * 1.0))) + 1).truncate
    s[21].src_rect.width = s[23]
    # 不可視に
    for l in [21,22]
      s[l].opacity = 0
    end
    # 追加判定
    @s_party[index].push(actor.overdrive)
  end
  #--------------------------------------------------------------------------
  # ● オブジェクト開放
  #--------------------------------------------------------------------------
  alias dispose_str11pog dispose
  def dispose
    dispose_str11pog
    for i in 0...@s_sprite.size
      for l in [21,22]
        @s_sprite[i][l].bitmap.dispose
        @s_sprite[i][l].dispose
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias update_str11pog update
  def update
    update_str11pog
    return unless @f
    for i in 0...@s_sprite.size
      s = @s_sprite[i]
      v = (not KGC::OverDrive::HIDE_GAUGE_ACTOR.include?($game_party.members[i].id))
      for l in [21,22]
        s[l].visible = v
      end
      # 不透明度アップ
      if @opacity < 272
        for l in [21,22]
          s[l].opacity = @opacity
        end
      end
      # OD更新
      update_od(s,$game_party.members[i],@s_party[i])
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (OD)
  #--------------------------------------------------------------------------
  def update_od(s,a,m)
    sr = s[21].src_rect
    # 100%フラッシュ!
    if @odgw <= sr.width and Graphics.frame_count % 4 < 2
      s[21].src_rect.y = (s[21].src_rect.height * 2)
    else
      s[21].src_rect.y = s[21].src_rect.height
    end
    # ゲージ更新
    if a.overdrive != m[6]
      s[23] = ((@odgw * (a.overdrive / (a.max_overdrive * 1.0))) + 1).truncate
      m[6] = (a.overdrive)
    end
    if sr.width != s[23]
      if sr.width < s[23]
        sr.width += 1
      else
        sr.width -= 1
      end
      sr.width = s[23] if sr.width.abs <= 1
    end
  end
end

En m'inspirant d'autre script j'ai essayé de faire un truc mais bon.....

Code:
class Sprite_BattleFleche < Sprite
  FLECHE    = "Fleche"
  WAIT      = 4
  SPEED      = 4
  CW        = 20
  CH        = 20
end

class Sprite_BattleFleche < Sprite
  def initialize(viewport)
    super(viewport)
    self.bitmap = Cache.system(FLECHE)
    self.src_rect.set(0, 0, CW, CH)
    self.ox = CW / 2
    self.oy = CH / 2
    self.x = ?
    self.y = ?
  end
  def update
    super
    s = (SPEED - 1)
    self.x = ((self.x * s) ) / SPEED
    self.y = ((self.y * s) ) / SPEED
    @wait -= 1
    return if @wait > 0
    @wait = WAIT
    self.src_rect.x += CW
    self.src_rect.x = 0 if (self.bitmap.width <= self.src_rect.x)
    self.src_rect.y = CH
  end
end

def fleche
  if @overdrive = max_overdrive
    print("Fleche")
    if Input.repeat?(Input::LEFT)
      self.rect(275, 300, 32, 90)
Balbereith
Balbereith
Staffeux retraité

Nombre de messages : 4129
Age : 26
Localisation : dans l'ombre...
Distinction : Péripatéticienne à temps perdu
Helly n°666 [Coco' ;D]
mon ptit balbounet p'tit jardinier en herbe(les râteaux ça le connait) [tonton Adurna]
Cultivateur professionnel de la commu' (il a de bons outils en de nombreux exemplaires Extension pour script overdrive (style FF8) 522164 ) [Coco' Smile]
Date d'inscription : 13/05/2009

Extension pour script overdrive (style FF8) Empty Re: Extension pour script overdrive (style FF8)

le Ven 19 Mar 2010 - 20:42
Résolu ? Dans une semaine, je sanctionne, s'il y a pas de relance ou de réponse, résolvant le problème.
Orbital
Orbital
Membre

Nombre de messages : 141
Age : 28
Localisation : Euh, tu vois la France ? l'Isère ? grenoble ? SMH ? ma maison ? le bureau ? le PC ? bah c'est là
Distinction : aucune
Date d'inscription : 09/08/2008

Extension pour script overdrive (style FF8) Empty Re: Extension pour script overdrive (style FF8)

le Sam 20 Mar 2010 - 1:06
@Balbereith a écrit:Résolu ? Dans une semaine, je sanctionne, s'il y a pas de relance ou de réponse, résolvant le problème.

Donc si on attend la réponse à un de nos problèmes et que personne veut nous aider, on est sanctionné ?
Essayer de faire respecter les règles c'est bien, sanctionner pour un rien, c'est moins bien.
Donc si il faut dire "up" au bout de 4 jours, dans le risque de se prendre un averto parce qu'on a fait un up seulement 3 jours après le dernier message (au lieu de 4) je trouve ça un peu nul.

Donc non personne n'a répondu à ma demande et elle est toujours d'actualité et oui je "up".

Merci bien.

Balbereith :C'est pour cela que je donne une semaine de délais, je demande pas un up tout les trois jours, juste que ta demande ne tombe pas dans l'oublie. Car les membres oublie la question, puis c'est au demandeurs d'oublier puisqu'il a jamais eu de réponse, mais la modération, elle n'oublie pas le règle, je préfère, prévenir que "guérir" (même si c'est trop le termes...)
Contenu sponsorisé

Extension pour script overdrive (style FF8) Empty Re: Extension pour script overdrive (style FF8)

Revenir en haut
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum