[Scripte]Overdrive

C'est un script qui permet de créer ce qu'on appelle une overdrive .C'est une barre qui va monter a chaque coups donnés à l'adversaire(par defaut). Lorsque la barre est au maximum, le personnage peut faire un skill spécial!
auteur:inconnu mais par Ojiro
Créez un nouveau script au dessus de main et appellez le overdrive.

Code:

# script Overdrive (cf.FFX) traduit par Ojiro
 
# Voilà un script qui permet d'installer une jauge Overdrive
# qui se remplit selon les types : Aggressif, Tenace, Victorieux,
# Lâche, Solo, Leader ou Revenant.
# Le type peut être modifié en cours de jeu grâce à :
# $game_actors [ID].overdrive_type = x
 
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/  ?Overdrive - KGC_OverDrive? Traduit par Ojiro
#_/----------------------------------------------------------------------------
#_/ Jauge privé d'un joueur lui permettant d'activer une technique unique.
#_/============================================================================
#==============================================================================
# ? Paramètres ?
#==============================================================================
 
module KGC
  # ?Jauge Max
  #  Indique la valeur pour que la jauge soit pleine
  OD_jauge_MAX = 1000
  # ?Progression de la barre Si
  #  Dépend du Drive Mode du joueur
  #  Pour le 0 et 1, le Drive s'effectue selon la valeurs des dommages reçus.
  OD_GAIN_RATE = [10, 30, 200, 100, 160, 40, 160]
 
  # ?jauge d'Overdrive incliné
  OD_jauge_SLANT = true
  # ?Position Y de la jauge overdrive en non Combat
  OD_jauge_OFF_Y = 26
  # ?Position Y de la jauge overdrive en Combat
  OD_jauge_OFF_Y_BATTLE = 26
  # ?Barre caché en non Combat / True (Vrai) ou False (Faux)
  OD_jauge_HIDE = false
end
 
class Window_Base < Window
  # ?Image de la jauge Overdrive
  @@_od_jauge = RPG::Cache.picture("od_gauge.png")
end
 
#???????????????????????????????????????
$game_special_elements = {}
$imported = {}
$data_states = load_data("Data/States.rxdata")
$data_system = load_data("Data/System.rxdata")
$imported["OverDrive"] = true
 
# OverDrive??
$game_special_elements["overdrive"] = $data_system.elements.index("Overdrive")
 
#???????????????????????????????????????
 
#==============================================================================
# ¦ Game_Battler
#==============================================================================
 
class Game_Battler
  #--------------------------------------------------------------------------
  # ? Exécute le processus d'origineExécute le processus d'origine?????
  #--------------------------------------------------------------------------
  attr_accessor :base_damage              # Valeur des Dommmages de Base
  #--------------------------------------------------------------------------
  # ? Activation de l'Overdrive
  #--------------------------------------------------------------------------
  alias skill_can_use_KGC_OverDrive skill_can_use?
  def skill_can_use?(skill_id)
    # Activation de l'Overdrive
    if self.is_a?(Game_Actor)
      skill = $data_skills[skill_id]
      if skill != nil && skill.element_set.include?($game_special_elements["overdrive"])
        if self.overdrive < KGC::OD_jauge_MAX
          return false
        end
      end
    end
 
    # Exécute le processus d'origine
    return skill_can_use_KGC_OverDrive(skill_id)
  end
  #--------------------------------------------------------------------------
  # ? Application effective d'une Aggresif normale
  #--------------------------------------------------------------------------
  alias attack_effect_KGC_OverDrive attack_effect
  def attack_effect(attacker)
    @base_damage = nil
 
    # Exécute le processus d'origine
    result = attack_effect_KGC_OverDrive(attacker)
 
    if @base_damage == nil
      # Retient les dommages de base d'origine
      @base_damage = [attacker.atk - self.pdef / 2, 0].max *
        (20 + attacker.str) / 20
    end
    # Dommages reçus
    if result && self.damage.is_a?(Numeric)
      # Augmentation d'Aggresif
      if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
          attacker.overdrive_type == 0 && self.base_damage > 0
        # Calcul du Drive
        od_up = [[self.damage * KGC::OD_GAIN_RATE[0] * 10 / self.base_damage, 1].max, 160].min
        # Drive
        attacker.overdrive += od_up
      # Lors des dégâts reçus
      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
  #--------------------------------------------------------------------------
  # ? Application effective de la technique
  #--------------------------------------------------------------------------
  alias skill_effect_KGC_OverDrive skill_effect
  def skill_effect(user, skill)
    @base_damage = nil
 
    # Exécute le processus d'origine
    result = skill_effect_KGC_OverDrive(user, skill)
 
    if @base_damage == nil
      # Calcul de la Puissance
      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
      # Calcul d'augmentation en pourcentage
      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)
      # Retient les dommages de base
      @base_damage = power * rate / 20
    end
    # Lors des Tenaces reçus
    if result && self.damage.is_a?(Numeric)
      # Augmentation des dégâts
      if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
          user.overdrive_type == 0 && self.base_damage > 0
        # Calcul du Drive
        od_up = [[self.damage * KGC::OD_GAIN_RATE[0] * 10 / self.base_damage, 1].max, 160].min
        # Drive
        user.overdrive += od_up
      # Lors des Tenaces reçus
      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
    # Lors de l'utilisation de l'Overdrive
    if user.is_a?(Game_Actor) && skill.element_set.include?($game_special_elements["overdrive"])
      user.overdrive = 0
    end
    return result
  end
end
 
#???????????????????????????????????????
 
#==============================================================================
# ¦ Game_Actor
#==============================================================================
 
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ? Installation
  #--------------------------------------------------------------------------
  alias setup_KGC_OverDrive setup
  def setup(actor_id)
    # Exécute le processus d'origine
    setup_KGC_OverDrive(actor_id)
 
    @overdrive, @overdrive_type = 0, 0
  end
 

(Partie 1)

(partie 2)

Code:

#--------------------------------------------------------------------------
  # ? Acquisition d'une jauge d'overdrive
  #--------------------------------------------------------------------------
  def overdrive
    @overdrive = 0 if @overdrive == nil
    return @overdrive
  end
  #--------------------------------------------------------------------------
  # ? Opération de la jauge Overdrive
  #--------------------------------------------------------------------------
  def overdrive=(value)
    @overdrive = 0 if @overdrive == nil
    @overdrive = [[value, 0].max, KGC::OD_jauge_MAX].min
  end
  #--------------------------------------------------------------------------
  # ? Acquisition du type d'Overdrive
  #--------------------------------------------------------------------------
  def overdrive_type
    @overdrive_type = 0 if @overdrive_type == nil
    return @overdrive_type
  end
  #--------------------------------------------------------------------------
  # ? Opération du type d'Overdrive
  #--------------------------------------------------------------------------
  def overdrive_type=(value)
    @overdrive_type = 0 if @overdrive_type == nil
    @overdrive_type = value
  end
end
 
#???????????????????????????????????????
 
#==============================================================================
# ¦ Window_Base
#==============================================================================
 
class Window_Base < Window
  #--------------------------------------------------------------------------
  # ? Initialisation
  #--------------------------------------------------------------------------
  alias initialize_KGC_OverDrive_Base initialize
  def initialize(x, y, width, height)
    @od_jauge = @@_od_jauge
    @od_g_width = @od_jauge.width / 3
    @od_g_height = (@od_jauge.height - 2) / 3
 
    # Exécute le processus d'origine
    initialize_KGC_OverDrive_Base(x, y, width, height)
  end
  #--------------------------------------------------------------------------
  # ? Image de la jauge overdrive
  #--------------------------------------------------------------------------
  def _od_jauge
    return @@_od_jauge
  end
  #--------------------------------------------------------------------------
  # ? Placement de la jauge
  #--------------------------------------------------------------------------
  def _od_jauge=(new_bitmap)
    @@_od_jauge.dispose
    @@_od_jauge = new_bitmap
  end
  #--------------------------------------------------------------------------
  # ? Acquisition de l'image
  #--------------------------------------------------------------------------
  def od_jauge
    return @od_jauge
  end
  #--------------------------------------------------------------------------
  # ? Mise en place de la jauge
  #--------------------------------------------------------------------------
  def od_jauge=(new_bitmap)
    @od_jauge = new_bitmap
  end
  #--------------------------------------------------------------------------
  # ? Nom
  #--------------------------------------------------------------------------
  alias draw_actor_name_KGC_OverDrive draw_actor_name
  def draw_actor_name(actor, x, y)
    unless (!$game_temp.in_battle && KGC::OD_jauge_HIDE)
      draw_actor_od_jauge(actor, x, y, 120)
    end
 
    # Exécute le processus d'origine
    draw_actor_name_KGC_OverDrive(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # ? Jauge OD
  #--------------------------------------------------------------------------
  def draw_actor_od_jauge(actor, x, y, width)
    # Jauge
    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 + 52 - @od_g_width
      dy = y + ($game_temp.in_battle ? KGC::OD_jauge_OFF_Y_BATTLE : KGC::OD_jauge_OFF_Y)
      dx -= 16 if $imported["HPSPAlter"] && !KGC::HPSP_DRAW_NAME_LUMP
      gw = @gs_od[actor.index] * @od_g_width / KGC::OD_jauge_MAX
      maximum = @gs_od[actor.index] == KGC::OD_jauge_MAX
    else
      @jauge_x = 0
      dx = x + width - @od_g_width - 13
      dy = y + ($game_temp.in_battle ? KGC::OD_jauge_OFF_Y_BATTLE : KGC::OD_jauge_OFF_Y)
      gw = actor.overdrive * @od_g_width / KGC::OD_jauge_MAX
      maximum = actor.overdrive == KGC::OD_jauge_MAX
    end
    # Schéma
    if KGC::OD_jauge_SLANT
      self.contents.fill_rect(dx, dy, @od_g_width + 7, 6, Color.new(0, 0, 0, 0))
      # Graduation
      gy = @od_g_height + 1
      for i in 0...(@od_g_height + 2)
        self.contents.blt(dx + i, dy + gy - i, @od_jauge, Rect.new(0, gy - i, @od_g_width + 2, 1))
      end
      # Effet de Substance
      gy -= 1
      gy2 = @od_g_height * (maximum ? 3 : 2) + 1
      for i in 0...@od_g_height
        self.contents.blt(dx + i + 2, dy + gy - i, @od_jauge, Rect.new(@jauge_x, gy2 - i, gw, 1))
      end
    # Normal
    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_jauge, 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_jauge, Rect.new(@jauge_x, gy2, gw, @od_g_height))
    end
  end
end
 
#???????????????????????????????????????
 
#==============================================================================
# ¦ Window_BattleStatus
#==============================================================================
 
class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  # ? Initialisation
  #--------------------------------------------------------------------------
  alias initialize_KGC_OverDrive initialize
  def initialize
    @jauge_x, @gs_od = 0, []
    @od_g_width = @@_od_jauge.width / 3
    @od_g_height = (@@_od_jauge.height - 2) / 3
 
    # Exécute du processus d'origine
    initialize_KGC_OverDrive
  end
  #--------------------------------------------------------------------------
  # ? Rafraichissement
  #--------------------------------------------------------------------------
  alias refresh_KGC_OverDrive refresh
  def refresh
    # Exécute le processus d'origine
    refresh_KGC_OverDrive
 
    for i in 0...$game_party.actors.size
      @gs_od[i] = $game_party.actors[i].overdrive
    end
  end
  #--------------------------------------------------------------------------
  # ? Renouvelement de la graduation
  #--------------------------------------------------------------------------
  alias update_KGC_OverDrive update
  def update
    # Exécute le processus d'origine
    update_KGC_OverDrive
 
    # L'image de la gauge est laissée
    unless $imported["HPSPAlter"]
      @jauge_x -= [@od_g_width / 20, 1].max
      @jauge_x = @od_g_width * 2 if @jauge_x < 0
    end
    for i in 0...$game_party.actors.size
      draw_actor_od_jauge($game_party.actors[i], 0, 0, 120)
    end
  end
end
 
#???????????????????????????????????????
 
#==============================================================================
# ¦ Scene_Battle
#==============================================================================
 
class Scene_Battle
  #--------------------------------------------------------------------------
  # ? Fin du combat
  #    result : Résultat (0:Victorieux 1:Lache 2:Défaite)
  #--------------------------------------------------------------------------
  alias battle_end_KGC_OverDrive battle_end
  def battle_end(result)
    case result
    when 0  # Victorieux
      for actor in $game_party.actors
        next unless actor.exist?
        # Quand le type d'OD est Victorieux
        if actor.overdrive_type == 2
          actor.overdrive += KGC::OD_GAIN_RATE[2]
        end
      end
    when 1  # Lache
      for actor in $game_party.actors
        next unless actor.exist?
        # Quand le type d'OD est Lache
        if actor.overdrive_type == 3
          actor.overdrive += KGC::OD_GAIN_RATE[3]
        end
      end
    end
 
    # Exécute le processus d'origine
    battle_end_KGC_OverDrive(result)
  end
end
 
#???????????????????????????????????????
 
#==============================================================================
# ¦ Scene_Battle
#==============================================================================
 
class Scene_Battle
  #--------------------------------------------------------------------------
  # ? Renouvelement de la graduation
  #--------------------------------------------------------------------------
  alias update_phase4_step2_KGC_OverDrive update_phase4_step2
  def update_phase4_step2
    if @active_battler.is_a?(Game_Actor)
      # Augmentation
      case @active_battler.overdrive_type
      when 4  # Solo
        alone = true
        for actor in $game_party.actors
          next if actor == @active_battler
          # S'il y a un survivant, ce n'est pas considéré comme solo.
          if actor.exist?
            alone = false
            break
          end
        end
        od_up = alone ? KGC::OD_GAIN_RATE[4] : 0
      when 5  # Action
        od_up = KGC::OD_GAIN_RATE[5]
      when 6  # Si Revenant
        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
 
    # Exécute le processus d'origine
    update_phase4_step2_KGC_OverDrive
  end
end

Utilisation :
1. Créer un attribut(base de donné puis systeme) que vous nommerez overdrive
2. Créer un skill et mettez lattribut overdrive, ce skill sera un des skill special ke vous pouvez créer
3. Dans un combat, vous verrez une jauge apparaitre et a chaque coups donnés a l'enemi (par defaut), la jauge sera remplit un peut plus.
4. Pour utiliser votre skill special, dans un combat vous n'avez qu'à aller dans le menu habituelle de vos magie et si la barre est pleine, vous pourrez l'utiliser.

super ce script :D

Ca c'est un flood , ce genre de messages
Mais , j'en passe.
Ce script est valid , merci pour ce partage.

Ce script m'a l'air très utile ^^

Encore merci ^^