|
| | Overdrive | |
| | Auteur | Message |
---|
Invité Invité
| Sujet: Overdrive Mar 03 Juil 2007, 10:17 | |
| Script Overdrive - Auteur : Inconnu ; traduit par Ojiro- Incompatibilité : Avec Script combat vu de côté. - Screen : - Installation : Vous devez mettre cette jauge dans un dossier Pictures à l'intérieur du dossier Graphics de votre jeu. La jauge doit être nommée od_gauge et elle doit etre en format png. Créez ensuite un nouveau script nommé Overdrive au dessus de Main et collez-y ce code : - Code:
-
# 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
[center] |
| | | Invité Invité
| Sujet: Re: Overdrive Mar 03 Juil 2007, 10:18 | |
| Suite et fin du code : - Code:
-
#-------------------------------------------------------------------------- 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ées, puis Système) que vous nommerez Overdrive [Ne pas oublier la majuscule] ; 2. Créer un skill et y mettre l'attribut overdrive, ce skill sera un des skills spécial que vous pouvez créer ; 3. Dans un combat, vous verrez une jauge apparaître et a chaque coup donné a lennemi (par defaut), la jauge se remplira un peu plus. 4. Pour utiliser votre skill spécial, dans un combat vous n'avez qu'à aller dans le menu habituel de vos magies et si la barre est pleine, vous pourrez l'utiliser. J' espère que ce script plaira à certains d'entre vous ; je n'ai pas trouvé le créateur de ce script, mais celui qui l'a traduit est Ojiro. |
| | | moms Luthiste
Nombre de messages : 375 Age : 35 Projet(s) en cours : héhé pas de nom... Date d'inscription : 24/08/2007
| Sujet: Re: Overdrive Ven 24 Aoû 2007, 01:18 | |
| à préciser se script et incompatible avec le combat vue de coté... et c'est vraiment dommage! | |
| | | Contenu sponsorisé
| Sujet: Re: Overdrive | |
| |
| | | | Overdrive | |
|
Sujets similaires | |
|
Sujets similaires | |
| |
| Permission de ce forum: | Vous ne pouvez pas répondre aux sujets dans ce forum
| |
| |
| |
|