Overdrive

Créditos
Ao site SDK por criar,moghunter por traduzir.

Introdução
Cria uma barra como se fosse de furia, quando cheia o char pode usar magias diferentes

Caracteristicas
Crie
um atributo chamado "Overdirve" , habilidade que estiver sobre o
atributo "Overdrive" só estará dispónivel se o medidor de Overdrive(A
barra) estiver completo

Screen
Não precisa

Script

Código:

################################################################################
################################### KGC ########################################
################################################################################
=begin
                                OVERDRIVE
                               
--------------------------------------------------------------------------------
Script criado pelo site KGC.
Created by KGC site.
Tradução e tutorial por Moghunter.
--------------------------------------------------------------------------------

CARACTERÍSTICAS
 A habilidade que estiver sobre o atributo "Overdrive" só estará dispónivel
 se o medidor de Overdrive estiver completo.

UTILIZAÇÃO
Crie o atributo com o nome de "Overdrive" e atribu-a a habilidade desejada.

CUSTOMIZAÇÃO
=end
#-------------------------------------------------------------------------------
module KGC
  # Valor limite para atingir o medidor de Overdrive.
  OD_GAUGE_MAX = 1000
  #
  # Definição de calculo de como o medidor vai encher na batalha.
  #------------------------------------------
  #  OD_GAIN_RATE = [A, B, C, D, E, F, G]
  #------------------------------------------
  #  A - Ataque  B - Dano  C-Vitória  D-Escapar  E-Lutar Sozinho
  #  F - Ação  G - Morrer
  #
  OD_GAIN_RATE = [100, 100, 200, 100, 160, 100, 160]
  # Ocultar o medidor de overdrive para o personagem(ID)
  OD_GAUGE_HIDE_ACTOR = []
  # Medidor triangular
  OD_GAUGE_SLANT = true
  # Posição do medidor no menu.
  OD_GAUGE_OFF = [0, 26]
  # Posição do medidor no menu de batalha
  OD_GAUGE_OFF_BATTLE = [0, 26]
  # Ocultar o medidor na batalha
  OD_GAUGE_HIDE_NOT_IN_BATTLE = false
end
class Window_Base < Window
  # Nome do arquivo imagem do medidor de Overdrive.
  @@_od_gauge = RPG::Cache.picture("od_gauge.png")
end
#-------------------------------------------------------------------------------

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

if $game_special_elements == nil
  $game_special_elements = {}
  $data_system = load_data("Data/System.rxdata")
end
$game_special_elements["overdrive"] =
  $data_system.elements.index("OverDrive")
if $game_special_elements["overdrive"] == nil
  $game_special_elements["overdrive"] = $data_system.elements.index("OverDrive")
end
class Game_Battler
  attr_accessor :base_damage
  alias attack_effect_KGC_OverDrive attack_effect
  def attack_effect(attacker)
    @base_damage = nil
    result = attack_effect_KGC_OverDrive(attacker)
    if @base_damage == nil
      @base_damage = [attacker.atk - self.pdef / 2, 0].max *
        (20 + attacker.str) / 20
    end
    if result && self.damage.is_a?(Numeric)
      if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
          attacker.overdrive_type == 0 && self.base_damage > 0
        od_up = [[self.damage * KGC::OD_GAIN_RATE[0] * 10 / self.base_damage,
          1].max, 160].min
        attacker.overdrive += od_up
      elsif attacker.is_a?(Game_Enemy) && self.is_a?(Game_Actor) &&
          self.overdrive_type == 1 && self.base_damage > 0
        od_up = [self.damage * KGC::OD_GAIN_RATE[1] * 10 / self.maxhp, 1].max
        self.overdrive += od_up
      end
    end
    return result
  end
  alias skill_effect_KGC_OverDrive skill_effect
  def skill_effect(user, skill)
    @base_damage = nil
  result = skill_effect_KGC_OverDrive(user, skill)
    if @base_damage == nil
      power = skill.power + user.atk * skill.atk_f / 100
      if power > 0
        power -= self.pdef * skill.pdef_f / 200
        power -= self.mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      rate = 20
      rate += (user.str * skill.str_f / 100)
      rate += (user.dex * skill.dex_f / 100)
      rate += (user.agi * skill.agi_f / 100)
      rate += (user.int * skill.int_f / 100)
      @base_damage = power * rate / 20
    end
    if result && self.damage.is_a?(Numeric)
      if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
          user.overdrive_type == 0 && self.base_damage > 0
        od_up = [[self.damage * KGC::OD_GAIN_RATE[0] * 10 / self.base_damage,
          1].max, 160].min
        user.overdrive += od_up
      elsif user.is_a?(Game_Enemy) && self.is_a?(Game_Actor) &&
          self.overdrive_type == 1 && self.base_damage > 0
        od_up = [self.damage * KGC::OD_GAIN_RATE[1] * 10 / self.maxhp, 1].max
        self.overdrive += od_up
      end
    end
    if user.is_a?(Game_Actor) &&
        skill.element_set.include?($game_special_elements["overdrive"])
      user.overdrive = 0
    end
    return result
  end
end
KGC_Game_Actor_first = "OverDrive" unless defined?(KGC_Game_Actor)

module KGC_Game_Actor
  if defined?(skill_can_use?) && !@_skill_can_use_overdrive
    alias skill_can_use_KGC_OverDrive skill_can_use?
  else
    @_skill_can_use_overdrive = true
  end
  def skill_can_use?(skill_id)
    result = true
    skill = $data_skills[skill_id]
    if skill != nil &&
        skill.element_set.include?($game_special_elements["overdrive"])
      result = self.overdrive == KGC::OD_GAUGE_MAX
    end
    if defined?(skill_can_use_KGC_OverDrive)
      return result & skill_can_use_KGC_OverDrive(skill_id)
    else
      return result & super
    end
  end
  module_function :skill_can_use?
  public :skill_can_use?
end

class Game_Actor < Game_Battler
  include KGC_Game_Actor

  attr_writer :overdrive_type
  alias setup_KGC_OverDrive setup
  def setup(actor_id)
    setup_KGC_OverDrive(actor_id)

    @overdrive, @overdrive_type = 0, 0
  end
  def overdrive
    @overdrive = 0 if @overdrive == nil
    return @overdrive
  end
  def overdrive=(value)
    @overdrive = [[value, 0].max, KGC::OD_GAUGE_MAX].min
  end
  def overdrive_type
    @overdrive_type = 0 if @overdrive_type == nil
    return @overdrive_type
  end
end
class Window_Base < Window
  alias initialize_KGC_OverDrive_Base initialize
  def initialize(x, y, width, height)
    @od_gauge = @@_od_gauge
    @od_g_width = @od_gauge.width / 3
    @od_g_height = (@od_gauge.height - 2) / 3
    initialize_KGC_OverDrive_Base(x, y, width, height)
  end
  def _od_gauge
    return @@_od_gauge
  end
  def _od_gauge=(new_bitmap)
    @@_od_gauge.dispose
    @@_od_gauge = new_bitmap
  end
  def od_gauge
    return @od_gauge
  end
  def od_gauge=(new_bitmap)
    @od_gauge = new_bitmap
  end
  alias draw_actor_name_KGC_OverDrive draw_actor_name
  def draw_actor_name(actor, x, y)
    unless $game_temp.in_battle || KGC::OD_GAUGE_HIDE_NOT_IN_BATTLE
      draw_actor_od_gauge(actor, x, y, 120)
    end
    draw_actor_name_KGC_OverDrive(actor, x, y)
  end
  def draw_actor_od_gauge(actor, x, y, width)
    return if KGC::OD_GAUGE_HIDE_ACTOR.include?(actor.id)
    dx = dy = gw = 0
    maximum = false
    if $game_temp.in_battle && self.is_a?(Window_BattleStatus)
      @gs_od[actor.index] = actor.overdrive if @gs_od[actor.index] == nil
      dx = actor.screen_x - @od_g_width + 52
      dy = y
      dx -= 16 if $imported["HPSPAlter"] && !KGC::HPSP_DRAW_NAME_LUMP
      gw = @gs_od[actor.index] * @od_g_width / KGC::OD_GAUGE_MAX
      maximum = (@gs_od[actor.index] == KGC::OD_GAUGE_MAX)
    else
      @gauge_x = 0
      dx = x + width - @od_g_width - 13
      dy = y
      gw = actor.overdrive * @od_g_width / KGC::OD_GAUGE_MAX
      maximum = (actor.overdrive == KGC::OD_GAUGE_MAX)
    end
    dx += ($game_temp.in_battle ? KGC::OD_GAUGE_OFF_BATTLE[0] :
      KGC::OD_GAUGE_OFF[0])
    dy += ($game_temp.in_battle ? KGC::OD_GAUGE_OFF_BATTLE[1] :
      KGC::OD_GAUGE_OFF[1])
    if KGC::OD_GAUGE_SLANT
      self.contents.fill_rect(dx, dy, @od_g_width + 7, 6, Color.new(0, 0, 0, 0))
      gy = @od_g_height + 1
      (@od_g_height + 2).times { |i|
        self.contents.blt(dx + i, dy + gy - i, @od_gauge,
          Rect.new(0, gy - i, @od_g_width + 2, 1))
      }
      gy -= 1
      gy2 = @od_g_height * (maximum ? 3 : 2) + 1
      @od_g_height.times { |i|
        self.contents.blt(dx + i + 2, dy + gy - i, @od_gauge,
          Rect.new(@gauge_x, gy2 - i, gw, 1))
      }
    else
      self.contents.fill_rect(dx, dy, @od_g_width + 2, @od_g_height + 2,
        Color.new(0, 0, 0, 0))
      self.contents.blt(dx, dy, @od_gauge, Rect.new(0, 0, @od_g_width + 2,
        @od_g_height + 2))
      gy2 = @od_g_height * (maximum ? 2 : 1) + 2
      self.contents.blt(dx + 1, dy + 1, @od_gauge,
        Rect.new(@gauge_x, gy2, gw, @od_g_height))
    end
  end
end
class Window_BattleStatus < Window_Base
  alias initialize_KGC_OverDrive initialize
  def initialize
    @gauge_x, @gs_od = 0, []
    @od_g_width = @@_od_gauge.width / 3
    @od_g_height = (@@_od_gauge.height - 2) / 3
    initialize_KGC_OverDrive
  end
  alias refresh_KGC_OverDrive refresh
  def refresh
    refresh_KGC_OverDrive

    $game_party.actors.each_with_index { |actor, i|
      @gs_od[i] = actor.overdrive
      draw_actor_od_gauge(actor, 0, 0, 120)
    }
  end
  alias update_KGC_OverDrive update
  def update
    update_KGC_OverDrive
    unless $imported["HPSPAlter"]
      @gauge_x -= [@od_g_width / 20, 1].max
      @gauge_x = @od_g_width * 2 if @gauge_x < 0
    end
    $game_party.actors.each { |actor| draw_actor_od_gauge(actor, 0, 0, 120) }
  end
end
class Scene_Battle
  alias battle_end_KGC_OverDrive battle_end
  def battle_end(result)
    case result
    when 0
      $game_party.actors.each { |actor|
        next unless actor.exist?
        if actor.overdrive_type == 2
          actor.overdrive += KGC::OD_GAIN_RATE[2]
        end
      }
    when 1
      $game_party.actors.each { |actor|
        next unless actor.exist?
        if actor.overdrive_type == 3
          actor.overdrive += KGC::OD_GAIN_RATE[3]
        end
      }
    end
    battle_end_KGC_OverDrive(result)
  end
end
class Scene_Battle
  alias update_phase4_step2_KGC_OverDrive update_phase4_step2
  def update_phase4_step2
    if @active_battler.is_a?(Game_Actor)
      case @active_battler.overdrive_type
      when 4
        alone = true
        $game_party.actors.each { |actor|
          next if actor == @active_battler
          if actor.exist?
            alone = false
            break
          end
        }
        od_up = alone ? KGC::OD_GAIN_RATE[4] : 0
      when 5
        od_up = KGC::OD_GAIN_RATE[5]
      when 6
        od_up = (@active_battler.hp <= @active_battler.maxhp / 4) ?
          KGC::OD_GAIN_RATE[6] : 0
      else
        od_up = 0
      end
      @active_battler.overdrive += od_up
    end
    update_phase4_step2_KGC_OverDrive
  end
end

Funfa como "Rage" né?

¬¬ manow isso é um tpo de rage ¬¬ pelo que eu entendi ¬¬





FLWS

tambem intendi como rage ¬¬

bye

---

DOUBLE CORRIGIDO POR DARKIN

---

cade a barra de od? a od_gauge

Bye

@Cocatrique

Corrigi seu Double-Post,tome cuidado com os doubles,se quer reviver,mande um comentário neste tópico




FLWS