Non riesco a trovarne uno buono

[Grayfoxflavio]

Salve ragazzi, Ho un problema: Non riesco a trovare un sistema overdrive che mi permetta ,come una turbo, di far trasformare il miei personaggi in un'altro. Potete aiutarmi? grazie in anticipo

[MasterSion]

Apparte che il titolo poteva essere più chiaro.

Poi dipende da che script usi per il BS (intendo anche l'animazione) .

Se usi Charlie CTB o Tanketai è molto semplice creare una overdrive che sostituisce l'eroe.

[Grayfoxflavio]

Chiedo scusa, cmq il BS è il Charlie CTB/RTAB.

[Grayfoxflavio]

Scusa ancora per il doppio post ma non è più necessiario cercare; accidentalmente sono incappato in un sito di maker dove ho trovato lo script che cercavo (finalmente) ,cmq grazie lo stesso. Ah lo script era il KGC overdrive quello uguale al limitbrek di ffvii.

 

 

 

#==============================================================================

# ** Game_Actor

#==============================================================================

KGC_Game_Actor_first = "LimitBreak" unless defined?(KGC_Game_Actor)

module KGC_Game_Actor

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

# * Active decision of skill

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

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["limitbreak"])

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

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

# * Setup

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

alias setup_KGC_OverDrive setup

def setup(actor_id)

# Executing the processing of the origin

setup_KGC_OverDrive(actor_id)

@overdrive, @overdrive_type = 0, 1

end

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

# * Acquisition of OverDrive gauge

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

def overdrive

@overdrive = 0 if @overdrive == nil

return @overdrive

end

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

# * Operation of OverDrive gauge

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

def overdrive=(value)

@overdrive = [[value, 0].max, KGC::OD_GAUGE_MAX].min

end

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

# * Acquisition of OverDrive type

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

def overdrive_type

@overdrive_type = 0 if @overdrive_type == nil

return @overdrive_type

end

end

 

 

#==============================================================================

# ** Scene_Battle (Part 1)

#==============================================================================

class Scene_Battle

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

# * Battle Ends

# result : results (0:win 1:lose 2:escape)

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

alias battle_end_KGC_OverDrive battle_end

def battle_end(result)

case result

when 0 # Victory

$game_party.actors.each { |actor|

next unless actor.exist?

#When drive type "victory" is, addition

if actor.overdrive_type == 2

actor.overdrive += KGC::OD_GAIN_RATE[2]

end

}

when 1 # Flight

$game_party.actors.each { |actor|

next unless actor.exist?

# When drive type "flight" is, addition

if actor.overdrive_type == 3

actor.overdrive += KGC::OD_GAIN_RATE[3]

end

}

end

# Defeat

battle_end_KGC_OverDrive(result)

end

end

 

 

 

#==============================================================================

# ** Scene_Battle (Part 4)

#==============================================================================

 

class Scene_Battle

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

# * Frame Update (main phase step 2 : start action) (Edited)

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

alias update_phase4_step2_KGC_OverDrive update_phase4_step2

def update_phase4_step2(battler)

if battler.is_a?(Game_Actor)

# Gauge increase decision

case battler.overdrive_type

when 4 # Lonely battle

alone = true

$game_party.actors.each { |actor|

next if actor == battler

# When the survivor is, it is not lonely

if actor.exist?

alone = false

break

end

}

od_up = alone ? KGC::OD_GAIN_RATE[4] : 0

when 5 # When acting

od_up = KGC::OD_GAIN_RATE[5]

when 6 # Dying

od_up = (battler.hp <= battler.maxhp / 4) ?

KGC::OD_GAIN_RATE[6] : 0

else

od_up = 0

end

battler.overdrive += od_up

end

# Executing the processing of the origin

update_phase4_step2_KGC_OverDrive(battler)

end

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

# * Frame Update (main phase step 4 : animation for target) (Meter Edited)

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

alias update_phase4_step4_KGC_OverDrive update_phase4_step4

def update_phase4_step4(battler)

@status_window.refresh

update_phase4_step4_KGC_OverDrive(battler)

end

end

 

#==============================================================================

# ** Window_BattleStatus

#==============================================================================

 

class Window_BattleStatus < Window_Base

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

# * Add Overdrive Meters

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

alias refresh_KGC_OverDrive refresh

def refresh(number = 0)

if self.contents == nil

self.contents = Bitmap.new(width - 32, height - 32)

end

if number == 0

for i in 0...$game_party.actors.size

draw_actor_od($game_party.actors, i * 160 + 4, 88, 120)

end

else

if $game_party.actors[number].is_a?(Game_Actor)

draw_actor_od($game_party.actors[number], number * 160 + 4, 88, 120)

end

end

refresh_KGC_OverDrive(number)

end

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

# * Opacity Fix

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

alias update_KGC_OverDrive update

def update

if $game_temp.battle_main_phase

self.contents_opacity -= 4 if self.contents_opacity > 191

else

self.contents_opacity += 4 if self.contents_opacity < 255

end

end

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

# * Draw Overdrive Meter

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

def draw_actor_od(actor, x, y, width = 144)

rate = actor.overdrive.to_f / KGC::OD_GAUGE_MAX

plus_x = 0

rate_x = 0

plus_y = 25

plus_width = 0

rate_width = 100

height = 10

align1 = 1

align2 = 2

align3 = 0

grade1 = 1

grade2 = 0

color1 = Color.new(0, 0, 0, 192)

color2 = Color.new(255, 255, 192, 192)

color3 = Color.new(0, 0, 0, 192)

color4 = Color.new(64, 0, 0, 192)

color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)

color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)

od = (width + plus_width) * actor.overdrive * rate_width / 100 /

KGC::OD_GAUGE_MAX

gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,

width, plus_width + width * rate_width / 100,

height, od, align1, align2, align3,

color1, color2, color3, color4, color5, color6, grade1, grade2)

end

end

#==============================================================================

# ** KGC_Overdrive Ringer (09-05-2006)

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

# by DerVVulfman

#

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

# A requested feature, this script checks whenever the overdrive bar is filled

# and plays a pre-set sound effect accordingly. There isn't much to the script

# and was fairly easy to write. It will work with both versions 1 and 2 of the

# KGC_Overdrive script that I've posted, and will probably work with the ori-

# ginal version of KGC_Overdrive before it was edited by Minkoff.

#

#==============================================================================

 

 

 

#==============================================================================

# ** Scene_Battle

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

# This class performs battle screen processing.

#==============================================================================

class Scene_Battle

 

# Overdrive gauge maximum (same value as in KGC_OverDrive Script).

OD_GAUGE_MAX = 500

 

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

# * Full OD Gauge SE

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

def fullod_se

Audio.se_play("Audio/SE/015-jump01", 100, 100)

end

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

# * Frame renewal (OD gauge renewal phase)

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

alias update_phase0_overring update_phase0

def update_phase0

# Call the original def from RTAB

update_phase0_overring

# Go through the Actors

$game_party.actors.each { |actor|

# Only perform if the actor exists

next unless actor.exist?

# When the Overdrive bar is set to zero,

# Reset the Overdrive Ringer to false

if actor.overdrive == 0

actor.overdrive_ring = false

end

# When the Overdrive Ringer hasn't rung

if actor.overdrive_ring == false

# But the Overdrive Bar is filled

if actor.overdrive == OD_GAUGE_MAX

# Play the Overdrive Sound Effect

fullod_se

# And Set the Overdrive Ringer to true

actor.overdrive_ring = true

end

end

}

end

end

 

 

 

#==============================================================================

# ** Game_Actor

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

# This class handles the actor. It's used within the Game_Actors class

# ($game_actors) and refers to the Game_Party class ($game_party).

#==============================================================================

class Game_Actor < Game_Battler

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

# * Public Instance Variables

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

attr_accessor :overdrive_ring

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

# * Setup

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

alias setup_KGC_OverRing setup

def setup(actor_id)

# Executing the processing of the origin

setup_KGC_OverRing(actor_id)

@overdrive_ring = false

end

end