Batalla Lateral 2.7 + ATB

[Fegarur 0]

Descripción:
El sistema de batalla lateral de RPG Tankentai, pero funcionando como ATB (Batalla en Tiempo Activo). Esto le da un aire a Final Fantasy a las batallas.

Screens:
[SPOILER]
[/SPOILER]
Vídeo:
[VIDEO]toLVTz_rBLw[/VIDEO]

Demo:
Descargar Demo (SkyDrive)
Descargar Demo (FileFront)
Descargar Demo (MegaUpload)

Instrucciones:
Lee los comentarios en los scripts, porque más o menos viene todo lo necesario para hacerlo funcionar. Está complicado, eh, así que tómatelo con calma.

Yo no hice este script. Eso significa que no esperes que te resuelva todas las dudas derivadas del él, aunque pueda intentarlo.

Compatibilidad:
Es un milagro si no da problemas con algo. Suerte a la hora de usarlo.

Créditos:
Script creado por RPG Tankentai (SBL) y Star (ATB).
Traducción al Inglés por Mr. Bubble.
Traducción al Español por Fegarur. Edited September 16, 2008 by Fegarur

[topotin 1]

esto esta muy bien, mejora muxo el sistema este de batalla, porque yo almenos, siempre he sido mas a fabor de barras que no de turnos ^^

PD: no funciona bien con el kgc, las barras no se mueven

[Fegarur 0]

¿Con el KGC? Si dices lo del script que viene por defecto debajo de Main, recuerdo que se necesita aparte (no incluído) el script de Overdrive de KGC.

[ramiazul 0]

la verdad que esta muy bueno, era lo que estaba buscando gracias fegarur te debo una.

[seroc 0]

La verdad que incluso usando el de kgc me da errores con el overdrive.

Otra cosa que no hay es poder añadir barra de carga en las habilidades o al menos no estan activas...

Pero igualmente mejora en cuanto a lo demas aunque no se si podra ser con mas de 4 personajes ahora que esta el atb...

[Fegarur 0]

Los fallos que tenga esta versión no se van a arreglar, porque el autor del ATB y el de la batalla lateral no son el mismo. Al principio el autor del ATB intentó compatibilizarlos, pero en las últimas versiones creo que desistió, por hacerse más complejo cada script por separado y actualizarse los dos regularmente.

El script de KGC para tener más personajes en el grupo no es compatible ni siquiera en la versión 'simple', así que en esta me supongo que mucho menos.

PD: No he visto ninguna demo con el script de Overdrive funcionando, pero la screen demuestra que es posible. Edited September 10, 2008 by Fegarur

[seroc 0]

Te refieres que no funcionara con el atb, porque el otro va perfectamente, yo tengo configurado 8 personajes y funciona a las mil marabillas incluso el cambio de party en medio del combate funciona.

En cuanto al ATB ya me lo supongo...XD

Y el overdrive... pues se las habran arreglado la cuestion es como...XD

[Fegarur 0]

Ah, pues no se por qué tenía yo la idea de que no funcionaba con ese script... mirándolo, el que no funciona en el otro es el KCG_AlterMPCost.

Ya buscaré alguna demo o algo con el Overdrive funcionando.

[Fegarur 0]

Actualizado: Ahora el script de configuración está 100% traducido ( v1.8 )
Además, he visto que la versión anterior daba errores que no debería, supongo que por algún fallo mío. Probad si funciona ahora el script de Overdrive. Edited September 10, 2008 by Fegarur

[seroc 0]

Bueno he de decir que lo del over drive me seguia fallando asta que pense en que quizas el problema que era es que estaba usando la version mas nueva...
Por lo cual probe la version inicial la cual no usa imagenes ni nada.
Y esa va especialmente bien, por lo cual para que nadie se vuelva loco buscando el script o pensando que algo falla pondre el script.
Antes que nada decir una cosa, este script por si solo lo que aria es poner una barra hecha con los recursos del maker sin necesidad de nada. Pero el script que hay en la demo hace que en los combates tenga un grafico que esta en la carpeta de system con el nombre de Btskin_odg.

[SPOILER]

CODE

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ オーバードライブ - KGC_OverDrive ◆ VX ◆
#_/    ◇ Last update : 2008/08/12 ◇
#_/----------------------------------------------------------------------------
#_/  専用のゲージを消費して使用するスキルを作成します。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

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

module KGC
module OverDrive
 # ◆ ドライブゲージ最大値
 #  普通はこのままでOK。微調整したい場合に変更。
 GAUGE_MAX = 1000
 # ◆ ドライブゲージ増加量
 #  高いほどゲージが溜まりやすい。
 #  マイナス値を指定すると減少。
 #  「被ダメージ」は、受けたダメージの最大 HP に対する割合で増加量を算出。
 #  (500 だと、最大 HP 相当のダメージで 500 溜まる)
 GAIN_RATE = [
    80,  # 攻撃
   500,  # 被ダメージ
   200,  # 勝利
   100,  # 逃走
   160,  # 孤独
    40,  # 行動
   160,  # 瀕死
    50,  # 防御
 ]  # ← この ] は消さないこと！

 # ◆ ゲージの初期本数
 DEFAULT_GAUGE_NUMBER = 1

 # ◆ アクターのデフォルトドライブタイプ
 #   0..攻撃  1..被ダメージ  2..勝利  3..逃走  4..孤独  5..行動  6..瀕死
 #   7..防御
 DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6]
 # ◆ エネミーのデフォルトドライブタイプ
 DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]

 # ◆ ドライブゲージの開始色 (通常時)
 #  数値  : \C[n] と同じ色。
 #  Color : 指定した色。 ( Color.new(255, 128, 128) など )
 GAUGE_NORMAL_START_COLOR = 14
 # ◆ ドライブゲージの終了色 (通常時)
 GAUGE_NORMAL_END_COLOR   = 6
 # ◆ ドライブゲージの開始色 (最大時)
 GAUGE_MAX_START_COLOR    = 10
 # ◆ ドライブゲージの終了色 (最大時)
 GAUGE_MAX_END_COLOR      = 2

 # ◆ ドライブゲージの Y 座標補正値
 #  -8 にすると、HP/MP ゲージと同じ位置になります。
 GAUGE_OFFSET_Y = -8
 # ◆ ゲージ蓄積量の数値表記
 #   0 .. なし  ※ゲージが 2 本以上の場合は非推奨
 #   1 .. 即値 (蓄積量そのまま)
 #   2 .. 割合 --> x%
 #   3 .. 割合 (詳細１) --> x.x%
 #   4 .. 割合 (詳細２) --> x.xx%
 #   5 .. 蓄積済み本数
 GAUGE_VALUE_STYLE = 5
 # ◆ ゲージ蓄積量のフォントサイズ
 #  大きくしすぎると名前に被ります。
 GAUGE_VALUE_FONT_SIZE = 14

 # ◆ 死亡（HP 0）時にドライブゲージを 0 にする
 EMPTY_ON_DEAD = true

 # ◆ ドライブゲージを表示しないアクター
 #  ゲージを隠すアクターのIDを配列に格納。
 HIDE_GAUGE_ACTOR = []
 # ◆ 非戦闘時はドライブゲージを隠す
 HIDE_GAUGE_NOT_IN_BATTLE = false
 # ◆ オーバードライブスキル未修得ならゲージを隠す
 HIDE_GAUGE_NO_OD_SKILLS  = true
 # ◆ ゲージを隠している場合はゲージを増加させない
 NOT_GAIN_GAUGE_HIDING    = true

 # ◆ ゲージ不足のときはオーバードライブスキルを隠す
 HIDE_SKILL_LACK_OF_GAUGE = false
end
end

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

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

module KGC::OverDrive
 # ドライブタイプ
 module Type
   ATTACK  = 0  # 攻撃
   DAMAGE  = 1  # 被ダメージ
   VICTORY = 2  # 勝利
   ESCAPE  = 3  # 逃走
   ALONE   = 4  # 孤独
   ACTION  = 5  # 行動
   FATAL   = 6  # 瀕死
   GUARD   = 7  # 防御
 end

 # 蓄積量表記
 module ValueStyle
   NONE         = 0  # なし
   IMMEDIATE    = 1  # 即値
   RATE         = 2  # 割合
   RATE_DETAIL1 = 3  # 割合 (詳細１)
   RATE_DETAIL2 = 4  # 割合 (詳細２)
   NUMBER       = 5  # 蓄積済み本数
 end

 # 正規表現
 module Regexp
   # スキル
   module Skill
     # オーバードライブ
     OVER_DRIVE = /<(?:OVER_DRIVE|Overdrive)\s*(\d+)?>/i
     # ゲージ増加率
     OD_GAIN_RATE = /<(?:OD_GAIN_RATE|CARGAOD)\s*(\d+)[%％]?>/i
   end
 end
end

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

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

module KGC::Commands
 module_function
 #--------------------------------------------------------------------------
 # ○ アクターのドライブゲージの増減
 #     actor_id : アクター ID (-1 : パーティ全体)
 #     value    : 増加量 (マイナスも可)
 #--------------------------------------------------------------------------
 def gain_actor_od_gauge(actor_id, value)
   if actor_id == -1
     # 生存メンバー全員のゲージを操作
     $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_index : エネミー index (-1 : 全体)
 #     value       : 増加量 (マイナスも可)
 #--------------------------------------------------------------------------
 def gain_enemy_od_gauge(enemy_index, value)
   if enemy_index == -1
     # 生存エネミー全員のゲージを操作
     $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
 #--------------------------------------------------------------------------
 # ○ アクターのドライブゲージの取得
 #     actor_id    : アクター ID
 #     variable_id : 戻り値を格納する変数 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
 #--------------------------------------------------------------------------
 # ○ エネミーのドライブゲージの取得
 #     enemy_index : エネミー index
 #     variable_id : 戻り値を格納する変数 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
 #--------------------------------------------------------------------------
 # ○ アクターのドライブゲージの本数を設定
 #     actor_id : アクター ID (-1 : パーティ全体)
 #     number   : ゲージ本数
 #--------------------------------------------------------------------------
 def set_actor_od_gauge_number(actor_id, number)
   if actor_id == -1
     # メンバー全員の本数を設定
     $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
 #--------------------------------------------------------------------------
 # ○ エネミーのドライブゲージの本数を設定
 #     enemy_index : エネミー index (-1 : 全体)
 #     number   : ゲージ本数
 #--------------------------------------------------------------------------
 def set_enemy_od_gauge_number(enemy_index, number)
   if enemy_index == -1
     # 生存エネミー全員の本数を設定
     $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
 #--------------------------------------------------------------------------
 # ○ アクターのドライブゲージが最大か判定
 #     actor_id : アクター ID
 #--------------------------------------------------------------------------
 def actor_od_gauge_max?(actor_id)
   actor = $game_actors[actor_id]
   return false if actor == nil
   return actor.overdrive == actor.max_overdrive
 end
 #--------------------------------------------------------------------------
 # ○ エネミーのドライブゲージが最大か判定
 #     enemy_index : エネミー 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
 #--------------------------------------------------------------------------
 # ○ アクターのドライブタイプの変更
 #     actor_id : アクター ID (-1 : パーティ全体)
 #     types    : ドライブタイプの配列 (省略時 : 初期化)
 #--------------------------------------------------------------------------
 def set_actor_drive_type(actor_id, types = nil)
   if actor_id == -1
     # メンバー全員のドライブタイプを変更
     $game_party.members.each { |actor|
       actor.drive_type = types
     }
   else
     actor = $game_actors[actor_id]
     actor.drive_type = types if actor != nil
   end
 end
 #--------------------------------------------------------------------------
 # ○ エネミーのドライブタイプの変更
 #     enemy_index : エネミー index (-1 : 全体)
 #     types       : ドライブタイプの配列 (省略時 : 初期化)
 #--------------------------------------------------------------------------
 def set_enemy_drive_type(enemy_index, types = nil)
   if enemy_index == -1
     # エネミー全員のドライブタイプを変更
     $game_troop.members.each { |enemy|
       enemy.drive_type = types
     }
   else
     enemy = $game_troop.members[enemy_index]
     enemy.drive_type = types if enemy != nil
   end
 end
end

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

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

class RPG::Skill < RPG::UsableItem
 #--------------------------------------------------------------------------
 # ○ オーバードライブのキャッシュ生成
 #--------------------------------------------------------------------------
 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
       # オーバードライブ
       @__is_overdrive = true
       @__od_cost = $1.to_i if $1 != nil
     when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
       # ゲージ増加率
       @__od_gain_rate = $1.to_i
     end
   }

   # ドライブスキルでなければ、ゲージ消費量 0
   unless @__is_overdrive
     @__od_cost = 0
   end
 end
 #--------------------------------------------------------------------------
 # ○ ドライブスキルであるか
 #--------------------------------------------------------------------------
 def overdrive?
   create_overdrive_cache if @__is_overdrive == nil
   return @__is_overdrive
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ消費量
 #--------------------------------------------------------------------------
 def od_cost
   create_overdrive_cache if @__od_cost == nil
   return @__od_cost
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ増加率
 #--------------------------------------------------------------------------
 def od_gain_rate
   create_overdrive_cache if @__od_gain_rate == nil
   return @__od_gain_rate
 end
end

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

#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
 #--------------------------------------------------------------------------
 # ● 公開インスタンス変数
 #--------------------------------------------------------------------------
 attr_writer   :drive_type               # ドライブタイプ
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ量取得
 #--------------------------------------------------------------------------
 def overdrive
   @overdrive = 0 if @overdrive == nil
   return @overdrive
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの操作
 #--------------------------------------------------------------------------
 def overdrive=(value)
   @overdrive = [[value, max_overdrive].min, 0].max
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ最大量取得
 #--------------------------------------------------------------------------
 def max_overdrive
   return KGC::OverDrive::GAUGE_MAX * drive_gauge_number
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ本数取得
 #--------------------------------------------------------------------------
 def drive_gauge_number
   if @drive_gauge_number == nil
     @drive_gauge_number = KGC::OverDrive::DEFAULT_GAUGE_NUMBER
   end
   return @drive_gauge_number
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ本数の操作
 #--------------------------------------------------------------------------
 def drive_gauge_number=(value)
   @drive_gauge_number = [value, 1].max
 end
 #--------------------------------------------------------------------------
 # ○ ドライブタイプの取得
 #--------------------------------------------------------------------------
 def drive_type
   return []
 end
 #--------------------------------------------------------------------------
 # ○ ドライブスキル習得済み判定
 #--------------------------------------------------------------------------
 def overdrive_skill_learned?
   return true
 end
 #--------------------------------------------------------------------------
 # ○ ゲージ表示判定
 #--------------------------------------------------------------------------
 def od_gauge_visible?
   return false
 end
 #--------------------------------------------------------------------------
 # ○ ゲージ増加可否判定
 #--------------------------------------------------------------------------
 def can_gain_overdrive?
   return true
 end
 #--------------------------------------------------------------------------
 # ○ 攻撃時増加判定
 #--------------------------------------------------------------------------
 def drive_attack?
   return drive_type.include?(KGC::OverDrive::Type::ATTACK)
 end
 #--------------------------------------------------------------------------
 # ○ 被ダメージ時増加判定
 #--------------------------------------------------------------------------
 def drive_damage?
   return drive_type.include?(KGC::OverDrive::Type::DAMAGE)
 end
 #--------------------------------------------------------------------------
 # ○ 勝利時増加判定
 #--------------------------------------------------------------------------
 def drive_victory?
   return drive_type.include?(KGC::OverDrive::Type::VICTORY)
 end
 #--------------------------------------------------------------------------
 # ○ 逃走時増加判定
 #--------------------------------------------------------------------------
 def drive_escape?
   return drive_type.include?(KGC::OverDrive::Type::ESCAPE)
 end
 #--------------------------------------------------------------------------
 # ○ 孤独時増加判定
 #--------------------------------------------------------------------------
 def drive_alone?
   return drive_type.include?(KGC::OverDrive::Type::ALONE)
 end
 #--------------------------------------------------------------------------
 # ○ 行動時増加判定
 #--------------------------------------------------------------------------
 def drive_action?
   return drive_type.include?(KGC::OverDrive::Type::ACTION)
 end
 #--------------------------------------------------------------------------
 # ○ 瀕死時増加判定
 #--------------------------------------------------------------------------
 def drive_fatal?
   return drive_type.include?(KGC::OverDrive::Type::FATAL)
 end
 #--------------------------------------------------------------------------
 # ○ 防御時増加判定
 #--------------------------------------------------------------------------
 def drive_guard?
   return drive_type.include?(KGC::OverDrive::Type::GUARD)
 end
 #--------------------------------------------------------------------------
 # ● ステートの付加
 #     state_id : ステート ID
 #--------------------------------------------------------------------------
 alias add_state_KGC_OverDrive add_state
 def add_state(state_id)
   add_state_KGC_OverDrive(state_id)

   reset_overdrive_on_dead if dead?
 end
 #--------------------------------------------------------------------------
 # ○ スキルの消費ドライブゲージ計算
 #     skill : スキル
 #--------------------------------------------------------------------------
 def calc_od_cost(skill)
   return 0 unless skill.is_a?(RPG::Skill)

   return skill.od_cost
 end
 #--------------------------------------------------------------------------
 # ● スキルの使用可能判定
 #     skill : スキル
 #--------------------------------------------------------------------------
 alias skill_can_use_KGC_OverDrive? skill_can_use?
 def skill_can_use?(skill)
   return false unless skill_can_use_KGC_OverDrive?(skill)

   return false if calc_od_cost(skill) > overdrive
   return true
 end
 #--------------------------------------------------------------------------
 # ● ダメージの反映
 #     user : スキルかアイテムの使用者
 #    呼び出し前に @hp_damage、@mp_damage、@absorbed が設定されていること。
 #--------------------------------------------------------------------------
 alias execute_damage_KGC_OverDrive execute_damage
 def execute_damage(user)
   execute_damage_KGC_OverDrive(user)

   increase_overdrive(user)
 end
 #--------------------------------------------------------------------------
 # ○ 死亡時ドライブゲージ初期化処理
 #--------------------------------------------------------------------------
 def reset_overdrive_on_dead
   return unless KGC::OverDrive::EMPTY_ON_DEAD

   self.overdrive = 0
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージ増加処理
 #     attacker : 攻撃者
 #--------------------------------------------------------------------------
 def increase_overdrive(attacker = nil)
   return unless attacker.is_a?(Game_Battler)  # 攻撃者がバトラーでない
   return if self.class == attacker.class      # 攻撃側と防御側が同じ
   return if hp_damage == 0 && mp_damage == 0  # ダメージなし

   if can_gain_overdrive?
     increase_attacker_overdrive(attacker)
     increase_defender_overdrive(attacker)
   end
   reset_overdrive_on_dead if dead?
 end
 #--------------------------------------------------------------------------
 # ○ 攻撃側のドライブゲージ増加処理
 #     attacker : 攻撃者
 #--------------------------------------------------------------------------
 def increase_attacker_overdrive(attacker)
   return unless attacker.drive_attack?  # ドライブタイプ「攻撃」なし

   od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
   if attacker.action.kind == 1
     rate = attacker.action.skill.od_gain_rate  # スキルの倍率を適用
     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
 end
 #--------------------------------------------------------------------------
 # ○ 防御側のドライブゲージ増加処理
 #     attacker : 攻撃者
 #--------------------------------------------------------------------------
 def increase_defender_overdrive(attacker)
   return unless self.drive_damage?  # ドライブタイプ「ダメージ」なし

   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
 end
 #--------------------------------------------------------------------------
 # ● スキルの効果適用
 #     user  : スキルの使用者
 #     skill : スキル
 #--------------------------------------------------------------------------
 alias skill_effect_KGC_OverDrive skill_effect
 def skill_effect(user, skill)
   skill_effect_KGC_OverDrive(user, skill)

   # アイテムでスキルを発動した場合はゲージ消費判定を無視
   if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
     return
   end
 end
end

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

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
 #--------------------------------------------------------------------------
 # ● セットアップ
 #     actor_id : アクター ID
 #--------------------------------------------------------------------------
 alias setup_KGC_OverDrive setup
 def setup(actor_id)
   setup_KGC_OverDrive(actor_id)

   @overdrive = 0
   @drive_type = nil
 end
 #--------------------------------------------------------------------------
 # ○ ドライブタイプの取得
 #--------------------------------------------------------------------------
 def drive_type
   unless @drive_type.is_a?(Array)
     return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
   end
   return @drive_type
 end
 #--------------------------------------------------------------------------
 # ○ ドライブスキル習得済み判定
 #--------------------------------------------------------------------------
 def overdrive_skill_learned?
   result = false
   # 一時的に戦闘中フラグを解除
   last_in_battle = $game_temp.in_battle
   $game_temp.in_battle = false

   self.skills.each { |skill|
     if skill.overdrive?
       result = true
       break
     end
   }
   $game_temp.in_battle = last_in_battle
   return result
 end
 #--------------------------------------------------------------------------
 # ○ ゲージ増加可否判定
 #--------------------------------------------------------------------------
 def can_gain_overdrive?
   if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
     # 非表示
     return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
   end
   if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
     # 未修得
     return false unless overdrive_skill_learned?
   end

   return true
 end
 #--------------------------------------------------------------------------
 # ○ ゲージ表示判定
 #--------------------------------------------------------------------------
 def od_gauge_visible?
   # 戦闘中非表示
   if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
     return false
   end
   # 非表示
   return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
   # ゲージ増加不可
   return false unless can_gain_overdrive?

   return true
 end
end

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

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

class Game_Enemy < Game_Battler
 #--------------------------------------------------------------------------
 # ● オブジェクト初期化
 #     index    : 敵グループ内インデックス
 #     enemy_id : 敵キャラ ID
 #--------------------------------------------------------------------------
 alias initialize_KGC_OverDrive initialize
 def initialize(index, enemy_id)
   initialize_KGC_OverDrive(index, enemy_id)

   @overdrive = 0
   @drive_type = nil
 end
 #--------------------------------------------------------------------------
 # ○ ドライブタイプの取得
 #--------------------------------------------------------------------------
 def drive_type
   unless @drive_type.is_a?(Array)
     return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
   end
   return @drive_type
 end
end

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

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

class Window_Base < Window
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの通常時の色 1 の取得
 #--------------------------------------------------------------------------
 def od_gauge_normal_color1
   color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
   return (color.is_a?(Integer) ? text_color(color) : color)
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの通常時の色 2 の取得
 #--------------------------------------------------------------------------
 def od_gauge_normal_color2
   color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
   return (color.is_a?(Integer) ? text_color(color) : color)
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの最大時の色 1 の取得
 #--------------------------------------------------------------------------
 def od_gauge_max_color1
   color = KGC::OverDrive::GAUGE_MAX_START_COLOR
   return (color.is_a?(Integer) ? text_color(color) : color)
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの最大時の色 2 の取得
 #--------------------------------------------------------------------------
 def od_gauge_max_color2
   color = KGC::OverDrive::GAUGE_MAX_END_COLOR
   return (color.is_a?(Integer) ? text_color(color) : color)
 end
 #--------------------------------------------------------------------------
 # ● 名前の描画
 #     actor : アクター
 #     x     : 描画先 X 座標
 #     y     : 描画先 Y 座標
 #--------------------------------------------------------------------------
 alias draw_actor_name_KGC_OverDrive draw_actor_name
 def draw_actor_name(actor, x, y)
   draw_actor_od_gauge(actor, x, y, 108)

   draw_actor_name_KGC_OverDrive(actor, x, y)
 end
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの描画
 #     actor : アクター
 #     x     : 描画先 X 座標
 #     y     : 描画先 Y 座標
 #     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
 #--------------------------------------------------------------------------
 # ○ ドライブゲージの描画
 #     actor : アクター
 #     x     : 描画先 X 座標
 #     y     : 描画先 Y 座標
 #     width : 幅
 #--------------------------------------------------------------------------
 def draw_actor_od_gauge_value(actor, x, y, width = 120)
   text = ""
   case KGC::OverDrive::GAUGE_VALUE_STYLE
   when KGC::OverDrive::ValueStyle::IMMEDIATE
     text = actor.overdrive.to_s
   when KGC::OverDrive::ValueStyle::RATE
     value = actor.overdrive * 100 / actor.max_overdrive
     text = "#{value}%"
   when KGC::OverDrive::ValueStyle::RATE_DETAIL1
     value = actor.overdrive * 100.0 / actor.max_overdrive
     text = sprintf("%0.1f%%", value)
   when KGC::OverDrive::ValueStyle::RATE_DETAIL2
     value = actor.overdrive * 100.0 / actor.max_overdrive
     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
 #--------------------------------------------------------------------------
 # ○ スキルをリストに含めるかどうか
 #     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?)
 #--------------------------------------------------------------------------
 # ● リフレッシュ
 #--------------------------------------------------------------------------
 def refresh
   @data = []
   for skill in @actor.skills
     next unless include?(skill)
     @data.push(skill)
     if skill.id == @actor.last_skill_id
       self.index = @data.size - 1
     end
   end
   @item_max = @data.size
   create_contents
   for i in 0...@item_max
     draw_item(i)
   end
 end
end

end  # <-- class
end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE

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

#==============================================================================
# ■ Scene_Skill
#==============================================================================

class Scene_Skill < Scene_Base
 #--------------------------------------------------------------------------
 # ● スキルの使用 (味方対象以外の使用効果を適用)
 #--------------------------------------------------------------------------
 alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget
 def use_skill_nontarget
   consume_od_gauge

   use_skill_nontarget_KGC_OverDrive
 end
 #--------------------------------------------------------------------------
 # ○ スキル使用時のドライブゲージ消費
 #--------------------------------------------------------------------------
 def consume_od_gauge
   @actor.overdrive -= @actor.calc_od_cost(@skill)
 end
end

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

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
 #--------------------------------------------------------------------------
 # ● 戦闘終了
 #     result : 結果 (0:勝利 1:逃走 2:敗北)
 #--------------------------------------------------------------------------
 alias battle_end_KGC_OverDrive battle_end
 def battle_end(result)
   increase_overdrive_on_battle_end(result)

   battle_end_KGC_OverDrive(result)
 end
 #--------------------------------------------------------------------------
 # ○ 戦闘終了時のドライブゲージ増加処理
 #     result : 結果 (0:勝利 1:逃走 2:敗北)
 #--------------------------------------------------------------------------
 def increase_overdrive_on_battle_end(result)
   case result
   when 0  # 勝利
     od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]
     $game_party.existing_members.each { |actor|
       actor.overdrive += od_gain if actor.drive_victory?
     }
   when 1  # 逃走
     od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]
     $game_party.existing_members.each { |actor|
       actor.overdrive += od_gain if actor.drive_escape?
     }
   end
 end
 #--------------------------------------------------------------------------
 # ● 戦闘行動の実行
 #--------------------------------------------------------------------------
 alias execute_action_KGC_OverDrive execute_action
 def execute_action
   increase_overdrive_on_action

   execute_action_KGC_OverDrive
 end
 #--------------------------------------------------------------------------
 # ○ 行動時のドライブゲージ増加処理
 #--------------------------------------------------------------------------
 def increase_overdrive_on_action
   battler = @active_battler
   od_gain = 0
   unit = (battler.actor? ? $game_party : $game_troop)

   # 孤独戦闘
   if battler.drive_alone? && unit.existing_members.size == 1
     od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE]
   end
   # 行動
   if battler.drive_action?
     od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION]
   end
   # 瀕死
   if battler.drive_fatal? && battler.hp < battler.maxhp / 4
     od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL]
   end
   # 防御
   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
 #--------------------------------------------------------------------------
 # ● 戦闘行動の実行 : スキル
 #--------------------------------------------------------------------------
 alias execute_action_skill_KGC_OverDrive execute_action_skill
 def execute_action_skill
   execute_action_skill_KGC_OverDrive

   consume_od_gauge
 end
 #--------------------------------------------------------------------------
 # ○ スキル使用時のドライブゲージ消費
 #--------------------------------------------------------------------------
 def consume_od_gauge
   skill = @active_battler.action.skill
   @active_battler.overdrive -= @active_battler.calc_od_cost(skill)
 end
end

[/SPOILER]
Es en japones pero todo sigue igual para que un ataque especial sea overdrive solo hay que poner en el panel de notas de las habilidades este codigo.

CODE

<overdrive>

Es sencillo de usar verdad?
tambien puede poner que una habilidad aumente mas el % de od ganado en cada accion, ejemplo se gana 80 con el ataque pues poniendo.

CODE

<odgain 200%>

Ganarias 160.
se aria como el over drive y esa habilidad seria como una habilidad pasiva por lo que pude entender. Edited September 10, 2008 by seroc

[Fegarur 0]

Muchas gracias por la información, es muy útil.
¿Hay mucha diferencia entre las dos versiones del Overdrive?

[KloudZ! 0]

Lo probé pero le puse combatir en mi juego y las barras de WAIT Se kedan pegadas

[seroc 0]

Fer: Bueno si que hay diferencias, en el 1 osea el que puse si miras en el menu aparece una raya simple de overdrive que es la misma que se ve en batalla pero que configuraron para este cbs y pone un grafico bastante mas interesante, que la simple linea.

En cuanto al 2 y mas avanzado y tiene una imagen como barra, pero es incompatible con este cbs.

Por lo cual quizas para otro cbs iria bien tener el otro, pero para este hay que coger el simple que aunque en el menu no lo cambie en combate hace el efecto del 2.
Pero en si es solo visualmente, ninguna cambio en cuanto a lo demas creo.
Me he dado cuenta que el script que te viene de over drive normal en la demo en ingles como en el el que puse es el mismo pero estaba anulado con el comando =begin el cual solo funcionaba el overdrive2 por lo cual lo pongo en ingles para mayor entendimiento...XD

[SPOILER]

CODE

=begin  

     A note concerning OverDrive versions: Please use one or the other, not
      both.
     If you decide to use this instead, remember to remove this text, the
     "=begin" seen above, and "=end" at the very end of the file.
     This version uses system-drawn gauges.
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/    ◆              Overdrive System - KGC_OverDrive                  ◆ VX ◆
#_/    ◇                  Last update : 2008/04/21                           ◇
#_/    ◆             Original Translation by Touchfuzzy                      ◆
#_/    ◆              Extended Updates by Mr. Anonymous                      ◆
#_/-----------------------------------------------------------------------------
#_/                      ★ 2008/04/19 UPDATE [KGC] ★
#_/  Increased compatibility with negative values of attack and suffered damage.
#_/-----------------------------------------------------------------------------
#_/                      ★ 2008/04/09 UPDATE [MRA] ★
#_/   The defend command may now increase the Overdrive guage. Also added an
#_/   option to have sound effects when the guage becomes full.
#_/-----------------------------------------------------------------------------
#_/                      ★ 2008/03/13 UPDATE [KGC] ★
#_/                       Several minor bugs fixed.
#_/-----------------------------------------------------------------------------
#_/  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 <odgain n%> (where n = a number) into the desired skill's
#_/  "Notes" box. Example: <odgain 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]
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
=end
#===============================================================================
#                          ★ Customization ★
#===============================================================================

module KGC
module OverDrive
 #                      ◆ Maximum Gauge Points ◆
 #  This affects the amount of OP (Overdrive Points) required to fill the
 #   Overdrive Gauge. Default: GAUGE_MAX = 1000
 GAUGE_MAX = 1000

 #                      ◆ Default OP Gain Rates ◆
 #  You may specify the amount of OP battlers will be rewarded for specific
 #   actions performed.  
 GAIN_RATE = [
    80,  # 0  Gained per attack.
   500,  # 1  Gained for taking damage.
         #    This is per 100% MHP of damage taken, so with 500 you would have
         #    to take 2 times your MHP to fill a 1000 GAUGE_MAX
   200,  # 2  Gained for defeating an enemy.
   100,  # 3  Gained each time you run away from a fight.
   160,  # 4  Gained for each round spent while fighting solo in battle, either
         #    being the only character or being the last one alive.
    40,  # 5  Gained for taking any action in a round
   160,  # 6  Gained for each round surviving with 25% or less HP remaining.
   180,  # 7  Gained for each round for guarding.
 ]  # ← No not remove these lines. Alter to your heart's content, though.

 #                 ◆ Default Actor OD Increase Options ◆
 #  Default Overdrive types that affect player-characters. The numbers in the
 #   brackets [] are chosen from the GAIN_RATE above, to the right of the #.
 #  It appears these numbers "stack" when setting up an individual character's
 #   Overdrive parameters.
 DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6, 7]
 
 #                 ◆ Default Enemy OD Increase Options ◆
 #  Default Overdrive types that affect enemies. The numbers in the brackets []
 #    are chosen from the GAIN_RATE above, to the right of the #.
 DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]

 #                       ◆ OD Gauge Colors ◆
 #  Allows you to change the color of the overdrive gauges.
 #  The color can also be determined by a numerical expression.
 #  Example: GAUGE_NORMAL_START_COLOR = Color.new(255, 0, 0)  <- This is red.
 #  If you've worked with HTML or image editing software, this should be
 #   fairly familiar.
 #  Gauge 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

 #                    ◆ 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
 
 #                ◆ Play sound on OD Max ◆  
 #  Play sound on gauge max.(Filename, Pitch, Volume)
 #   Removed until all bugs are ironed out
 #ODMAX_SOUND = RPG::SE.new("Flash2",     100,    150)
 
end
end

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

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

module KGC::OverDrive
 # Drive Increase Type Module
 module Type
   ATTACK  = 0  
   DAMAGE  = 1
   VICTORY = 2
   ESCAPE  = 3  
   ALONE   = 4  
   ACTION  = 5  
   FATAL   = 6  
   GUARD   = 7
 end

 # Regular Expressions Module
 module Regexp
   # Skills Module
   module Skill
     # OverDrive Skill Tag
     OVER_DRIVE = /<(?:OVER_DRIVE|overdrive)\s*(\d+)?>/i
     # Overdrive Point Gain Rate Tag
     OD_GAIN_RATE = /<(?:OD_GAIN_RATE|odgain)\s*(\d+)[%％]?>/i
   end
 end
end

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

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

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

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

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

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

#==================================End Class===================================#
#==============================================================================
# ■ 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

#==================================End Class===================================#
#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
 #--------------------------------------------------------------------------
 # ● Open Global Variable
 #--------------------------------------------------------------------------
 attr_writer   :drive_type               # Drive Type
 #--------------------------------------------------------------------------
 # ○ Acquire amount of drive gauge
 #--------------------------------------------------------------------------
 def overdrive
   @overdrive = 0 if @overdrive == nil
   return @overdrive
 end
 #--------------------------------------------------------------------------
 # ○ Drive gauge maximum amount acquisition
 #--------------------------------------------------------------------------
 def max_overdrive
   return KGC::OverDrive::GAUGE_MAX
 end
 #--------------------------------------------------------------------------
 # ○ Drive Gauge Operation
 #--------------------------------------------------------------------------
 def overdrive=(value)
   @overdrive = [[value, max_overdrive].min, 0].max
 end
 #--------------------------------------------------------------------------
 # ○ Sound played on gauge max - Removed until bugs are fixed
 #--------------------------------------------------------------------------
# def odmax_sound
#   return KGC::OverDrive::ODMAX_SOUND
# end
 #--------------------------------------------------------------------------
 # ○ Determine 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
 #--------------------------------------------------------------------------
 # ○ 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
 #--------------------------------------------------------------------------
 # ● Damage Reflection
 #     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) #
   return if self.class == attacker.class     # Actors attack and defend
   return if hp_damage == 0 && mp_damage == 0 # No Damage

   if can_gain_overdrive?
     increase_attacker_overdrive(attacker)
     increase_defender_overdrive(attacker)
   end
   reset_overdrive_on_dead if dead?
 end
 #--------------------------------------------------------------------------
 # ○ Increase Attacker's Overdrive
 #     attacker : Attacker
 #--------------------------------------------------------------------------
 def increase_attacker_overdrive(attacker)
   return unless attacker.drive_attack?  # Drive type "Attack" none

   od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
   if attacker.action.kind == 1
     rate = attacker.action.skill.od_gain_rate  # Rate of the skill is applied.
     od_gain = [od_gain * rate / 100, 1].max
   end
   attacker.overdrive += od_gain
 end
 #--------------------------------------------------------------------------
 # ○ Increase Defender's Overdrive
 #     attacker : Attacker
 #--------------------------------------------------------------------------
 def increase_defender_overdrive(attacker)
   return unless self.drive_damage?  # No Drive Type "Damage"

   rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
   od_gain = 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
 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

#==================================End Class===================================#
#==============================================================================
# ■ 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
     # Unmastered
     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

#==================================End Class===================================#
#==============================================================================
# ■ 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

#==================================End Class===================================#
#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
 #--------------------------------------------------------------------------
 # ○ 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
 #--------------------------------------------------------------------------
 # ● 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
 #--------------------------------------------------------------------------
 # ○ 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?

   gw = width * actor.overdrive / actor.max_overdrive
   gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)
   gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)
   self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
   self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
 end
end

#==================================End Class===================================#
#==============================================================================
# ■ 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

   return false unless skill.overdrive?

   return (@actor.calc_od_cost(skill) <= @actor.overdrive)
 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
 end
end

end  # <-- class
end  # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE

#==================================End Class===================================#
#==============================================================================
# ■ 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

#==================================End Class===================================#
#==============================================================================
# ■ 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?
     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
#==================================End Class===================================#

[/SPOILER]

KloudZ!: si pusiste el que recomiendo deberia de funcionar igualmente debes ponerlo de este modo que yo ahora te indicare.

Vete a la zona de "<script Opcionales ATB>" justo debajo hay un script llamado: "STR33g1_Estado de Batalla" Debajo de ese debes poner el script que hay debajo de main llamado: "STR11+og_KGC Overdrive" y debajo de "STR11+og_KGC Overdrive" poner el que puse, principlamente yo lo llamaria: "KGC_OverDrive" ya que aparte de que es su nombre identifica lo que hace y quien lo hizo a la hora de recopilar los autores de scripts. y si te da un error en algun momento todo el mundo lo conoce como ese nombre y poder dar una aclaracion mas explicita.

De esa forma te tiene que ir bien si o si, despues para que funcione la barra y suba al atacar y demas tienes que tener una habilidad asignada como overdrive.

Para ello lo cuento antes como iba pero repetire, pones en el bloque de notas de la habilidad concreta <overdrive> eso automaticamente ara que en el menu tengas la barra de overdrive y que en batalla aumente la linea, y no debe de darte error con el ATB ya que he testeado un poco y funciona a la perfeccion todo lo que he probado. Edited September 10, 2008 by seroc

[KloudZ! 0]

La barra que no se mueve no es la de OVD es la de WAIT, la ke necesito ke se llene para ke me salgan los comandos para poder atacar.


Edited September 10, 2008 by KloudZ!

[seroc 0]

as puesto los script como te he dicho? ya que de otra forma a mi tambien me pasaba y de ese modo se me mueve a la perfeccion.
Y te entendi a la primer esa barra es la de espera, osea en ingles wait.


Por cierto acabo de descubrir una cosa fuertemente interesante, para hacer tiempo de carga de una habilidad osea para que una vez selecionada la habilidad cargue otra vez para efectuar el ataque hay que poner en la configuracion de la habilidad al lado de consumo de PM y % de exito, hay un comando llamado velocidad, pues puedes poner ahi un porcentaje, se pone dese 0 a 999, pero teniendo en cuenta que aparte 0 que es 0 tiempo, lo demas hace que 1 sea lo mas lento y 999 lo mas rapido. en 999 apenas tarda en cargar la habilidad, pero lo hace.
Por cierto cuando carga una habilidad se pone en rojo lo cual queda curioso porque se ve llena y no se ve como ahora, que se ve como se reduce a minimos al efectuar el ataque con 0. Edited September 10, 2008 by seroc

[KloudZ! 0]

Sip, y es verdad, mira me funciona el overdrive todo, pero en Probar Batalla en la Base de Datos > Grupos de Enemigo, pero al colocar Combatir > Limo Azul en el juego, la barra de wait no se mueve, pero cuando es en probar batalla si se mueve!

Dews

[Fegarur 0]

Pues no se, revísalo porque como dice Seroc funciona bien. Quizá es que tienes puesto que la barra suba muy lento, los enemigos tengan muuucha agilidad y los tuyos tan poca que la barra practicamente no se mueva...

¿Lo has pasado a un proyecto tuyo o es la demo? Lo digo por si hay incompatibilidad con algún script tuyo.

[KloudZ! 0]

Es la demo al 100% y no le he modificado nada...

[Fegarur 0]

Te paso el archivo Scripts ya modificado por si hacías algo mal.
Scripts

En cuanto lo bajes lo borraré, que no lo quiero tener ahí subido para nada. Edited September 10, 2008 by Fegarur

[KloudZ! 0]

Gracias Fer, pero recién había terminado de arreglarlo, no se cómo, pero el punto es que funciona

[Fegarur 0]

De acuerdo, eliminando...
Por cierto, ¿habéis probado más cosas de esta versión? La forma de huída tampoco está mal, pero no recuerdo si había más cosas de interés.

[seroc 0]

En cuanto a huida, no puedes usarla mientras estas con comandos debes esperar a que esten cargando para apretar la letra Q. No esta mal, aunque estaria bien poder ponerlo siempre que quieras...XD

Aunque de este modo no pueden hacer trampas ni tampoco huir tan facilmente.


En cuanto a la KGC_Party, tiene dos problemas, el primero es estetico ya que no dan errores de programacion, peor cuando hay mas de 4 el 5 contador de vida y demas se ve a medias...
Mire de poner el script de resolucion pero se corta igual, mirare a ver si con suerte puedo modificarlo para que se vea entero y ponerlo a mi agrado, tambien habria que añadir una tecla tipo W para cambiar de party.

[Mr. Bubble 0]

ATB has been updated to v1.0. I highly recommend upgrading as it fixes errors and new features have been added as well.

There's only 3 scripts that are updated.

- *STR33a_Active Time Battle
- *STR33b_ATB Customization
- *STR33g2_Enemy CT Gauge

ATB Manual at the bottom of *STR33b_ATB Customization has been fully translated, corrected some things and has instructions for some new functions.

Have fun!

[Fegarur 0]

Thanks! I've seen v1.1 of this script, and the version in this post is 1.0 so I suppose you meant v1.1. If I only have to review 3 scripts I may update soon with the new version.

**¡Gracias! He visto la v1.1 de este script, y la versión de este tema es 1.0 así que supongo que te referías a la v1.1. Si solo tengo que revisar 3 scripts puede que actualice pronto con la nueva versión.

[seroc 0]

existe un problema existencial importante a tener en cuenta al unir estos dos script y es que desactiva el poder hace ataques conjuntos, y la verdad es una gran perdida, si se pudiese mejorar, para que al poner un comando de notas tipo <antipoda> en las habilidades de unión, y poner carga de habilidad poniendo velocidad, una vez este recargada una de las dos habilidades se activara el combo.

O eso o el que al accionar una habilidad de combo automáticamente el otro personaje queda ya seleccionado como si hubiese escogido esa habilidad.

si algún buen scriper lee esto y cree que es posible hacerlo y lo hace la verdad es que ayudaría a muchos...XD