Partagez
Aller en bas
avatar
Jordix
Membre

Nombre de messages : 7
Distinction : aucune
Date d'inscription : 08/02/2011

Problème script overdrive

le Ven 15 Jan 2016 - 22:11
Salut ,
J'ai un problème avec le script Overdrive de KGC , tout se passe bien pour la charge de la barre, mais lorsque j'utilise
l'attaque avec l'overdrive, la gauge ne se vide pas. J'ai un peu scruté le script pour savoir si il y avait une booléenne à mettre en
true, c'est le cas si le héros est mort mais je ne vois pas pour l'utilisation d'une attaque.

Je reposte le script au besoin:
Script:
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/   ◆               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 into the "Notes"
#_/  text box. Also, you may desire some skills to increase the Overdrive Gauge
#_/  more than others.
#_/  To do so, enter (where n = a number) into the desired skill's
#_/  "Notes" box. Example: 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 = 2000

 #                      ◆ Default OP Gain Rates ◆
 #  You may specify the amount of OverDrive Points that battlers will be given  
 #   for specific actions performed.  
 GAIN_RATE = [
   160,  # 0  Gained per attack.
   700,  # 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.
   10,  # 3  Gained each time you run away from a fight.
   50,  # 4  Gained for each round spent while fighting solo in battle, either
         #    being the only character or being the last one alive.
    50,  # 5  Gained for taking any action in a round
   100,  # 6  Gained for each round surviving with 25% or less HP remaining.
   20,  # 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, 4, 5, 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, 7]

 #                    ◆ 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 = 0
 
 #                   ◆ 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


Si vous pouviez m'aider, please Smile
avatar
tonyryu
Membre

Nombre de messages : 895
Age : 38
Localisation : Près de Nantes
Distinction : aucune
Date d'inscription : 27/05/2010
http://www.tonyryudev.com

Re: Problème script overdrive

le Sam 16 Jan 2016 - 11:48
Tu peux mettre une capture d'écran de ton skill overdrive sensé consommer ta jauge?
avatar
Jordix
Membre

Nombre de messages : 7
Distinction : aucune
Date d'inscription : 08/02/2011

Re: Problème script overdrive

le Sam 16 Jan 2016 - 15:41
Voici l'image du skill :
Screen:
avatar
tonyryu
Membre

Nombre de messages : 895
Age : 38
Localisation : Près de Nantes
Distinction : aucune
Date d'inscription : 27/05/2010
http://www.tonyryudev.com

Re: Problème script overdrive

le Sam 16 Jan 2016 - 17:08
J'ai pas la version VX sous la main pour tester, si quelqu'un peut débuguer les appels de cette méthode :

Code:
 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

afin de connaitre la valeur de la propriété @__od_cost pour le skill utilisé dans l'overdrive.
Contenu sponsorisé

Re: Problème script overdrive

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