[RMXP]Script D'overdrive

# Script Overdrive (cf.FFX) traduit par Ojiro

# Voilà un script qui permet d'installer une jauge Overdrive

# qui se remplit selon les types : Aggresif, Tenace, Victorieux,

# Lache, Solo, Leade ou Revenant.

# Le type peut être modifié en cours de jeu grâce à :

# $game_actors [ID] overdrive_type = x

# A inserer dans une page d'évenement grâce à Insertion Script.

# ID est a remplacer par l'ID du joueur qui changera de type

# L'ID n'est pas la place du joueur dans l'équipe

# Mais le numéro que porte le personnage indiqué dans la liste

# des héros.

# "x" est a remplacer par le numéro du type qui sont :

# 0..Aggresif 1..Tenace 2..Victorieux 3..Lache 4..Solo

# 5..Leader 6..Revenant

# La jauge se remplira en fonction du type :

# Aggressif > Dommage d'une attaque porté sur un ennemi

# Tenace > Dommage d'une attaque porté sur vous

# Victorieux > Lors d'une victoire d'un combat

# Lache > Lors d'une fuite

# Solo > Lorsque le joueur est seul au combat

# Leader > Lors de n'importe quel action

# Revenant > Lorsque l'on meurt

# Ensuite pour définir une technique Overdrive il faut tout

# d'abord ajouter un attribut dans Système que vous

# appellez Overdrive

# Et ensuite il suffira de cocher l'attribut Overdrive

# pour les techniques Overdrives dans la liste des skills.

# Et les faires apprendre a vos personnage comme des techniques

# normales sauf qu'elles ne pourront pas être utilisés

# si la jauge n'est pas pleine.

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#_/ ?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

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

# ? 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