| | Jauge Overdrive a la FFX | |
| | Auteur | Message |
---|
mikami Admin
Messages : 25 Date d'inscription : 12/12/2007
| Sujet: Jauge Overdrive a la FFX Mer 12 Déc - 20:48 | |
| mettre au dessus de main. # 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 #-------------------------------------------------------------------------- # ? 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
Dernière édition par le Mer 12 Déc - 20:51, édité 1 fois | |
| | | mikami Admin
Messages : 25 Date d'inscription : 12/12/2007
| Sujet: Re: Jauge Overdrive a la FFX Mer 12 Déc - 20:50 | |
| #-------------------------------------------------------------------------- # ? 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 | |
| | | | Jauge Overdrive a la FFX | |
|
| Permission de ce forum: | Vous ne pouvez pas répondre aux sujets dans ce forum
| |
| |
| |