Script On/Off Problem

Ankömmling

Mittwoch, 6. Dezember 2006, 22:33

Also, ich weiss dass jemand schon einmal ein ähnliches Problem hatte.Es geht um folgendes: ich
verwende ein Overdrive-Script. Nun soll der Spieler dieses Feature nicht von Beginn an
"benützen" können. Nun habe ich um das zu verhindern einfach zu Beginn des Scripts eine Bedingung
gesetzt, dass der ganze Code erst ausgeführt werden soll wenn irgend eine globale Variable den
Wert 1 hat, initialisiert wird sie im selben Modul mit dem Wert 0, also startet das Script nicht
zu Beginn => ich starte das Spiel, starte einen Kampf, kein Overdrive, soweit so gut, aber jetzt:
wenn ich innerhalb des Spiels diese globale Variable auf 1 setze (also will dass das Overdrive-
Script eingeschalten wird) wird das Modul bzw. das Script nicht gestartet.

Wahrscheinlich gibt es eine bessere Lösung für das, aber ich bedanke mich trotzdem für
alle Antworten,

LG, Salvation

Sven

Legende

2

Freitag, 8. Dezember 2006, 14:51

Nun das Script kann garnicht laufen.

Du startest das Spiel
Er lädt alle Scripte rein
das Spiel läuft
du machst die Variable auf 1
>Woher soll er nun wissen das er alle Scripte neueinlesen soll?

Deine Methode mit der Variabe ist schon sinnvoll, bloß an der falschen Stelle eingesetzt.

Schau mal nach ob man nicht vielleicht irgendwo im Script irgendsowas einstellen kann.

Meld dich wenn du noch weitere Fragen hast. Du kannst sie ruhig stellen. Ich bin auch nicht perfekt, also wenn irgendwas unklar sein sollte, frag ruhig nochmal nach (und nochmal)

Und sollte alles gelöst sein, meld dich auch nochmal, damit man das Problem als abgeharkt kennzeichnen kann.

Ave Abt Ploutôn

YAams	Random Signatur
Weitere Informationen \| Download Mit Support für RGSS Project 1!

Salvation

Ankömmling

3

Samstag, 9. Dezember 2006, 13:15

Im Script selbst lässt sich nichts derartiges um/einstellen. Gibt es denn keine Möglichkeit, das Script
während des Spiels neu zu laden?

markusmks

Krieger

4

Sonntag, 10. Dezember 2006, 12:43

hmm, wie wäre es wenn du das script posten würdest.... wenn nicht versuch ich mal ne Erklärung ._."

Also, du musst das Script erst initialisieren, das machst du ca am anfang, also im Scene_Title oder so.
Bsp: [COLOR="royalblue"]$overdrive = Overdrive.new[/COLOR]

soweit so gut, nun hast du immer eine globale variable mit allen informationen von overdrive.
Du könntest das script so aktivieren:
[COLOR="royalblue"]$overdrive.activ = true[/COLOR]
und deaktivieren
[COLOR="royalblue"]$overdrive.activ = false[/COLOR]

wennst du jedoch unbedingt ein switch oder eine globale variable nehmen willst, musst du eigentlich nicht sonderlich viel umändern....
Die frage stellt sich, magst du das script in Hintergrund laufen lassen, oder eher nur, wenn man es braucht kurz abfragen.

....anyway, wenn du jetzt einmal das mit switches machen willst lauft das nicht recht kompliziert von sich...

also zB:

[COLOR="royalblue"]$overdrive.activ = $game_switches[x] (also true oder false)[/COLOR]

im script selber musst du dann einfach mal Bedinungs Syntaxes machen, wie:
[COLOR="royalblue"]if @activ == true
---Aktiviertes Script
else
---Ausgeschaltet
end[/COLOR]

Um das ganze mit den @activ zu erlauben muss du es natürlich auch irgendwo im script einbauen *g*

also unter [COLOR="royalblue"]class Overdrive[/COLOR]
[COLOR="royalblue"]attr_accessor :activ[/COLOR]

und irgendwo in [COLOR="royalblue"]def initialize[/COLOR]
[COLOR="royalblue"]@activ = false[/COLOR]

um die ganzen abläufe zu kontrollieren, kannst du dann einfach irgendwo im script, wo es dir passt
[COLOR="royalblue"]if @activ == true[/COLOR] stellen, aber du weißt ja eh.

Ausserhalb von editor, kannst du auch abfragen ob das script eingeschaltet ist, mit:
[COLOR="royalblue"]$overdrive.activ[/COLOR]

Also:
[COLOR="royalblue"]if $overdrive.activ == true[/COLOR]
usw...
müsstest dich eigentlich eh jetzt auskennen, ich bin jetzt nur mal von beispielen ausgegangen

dann, cya

Salvation

Ankömmling

5

Sonntag, 10. Dezember 2006, 15:03

Also, zuerst einmal danke an markusmks, jedoch gibt die globale Variable lediglich den Wert nil zurück, obwohl ich ihr den richtigen Wert überwiesen habe, der Rest mit den if-Verzweigungen etc., wäre mir schon klar, zur Sicherheit poste ich das Script jedoch einfach 'mal

Quellcode

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/&#12288;&#12288;&#9670;&#12458;&#12540;&#12496;&#12540;&#12489;&#12521;&#12452;&#12502; &#65293; KGC_OverDrive&#9670;
#_/----------------------------------------------------------------------------
#_/ &#12288;&#23554;&#29992;&#12398;&#12466;&#12540;&#12472;&#12364;MAX&#12395;&#12394;&#12387;&#12383;&#12392;&#12365;&#12398;&#12415;&#20351;&#29992;&#21487;&#33021;&#12395;&#12394;&#12427;&#12473;&#12461;&#65533;
#_/============================================================================
#_/  &#8810;SP&#28040;&#36027;&#25913;&#36896;[SPCostAlter]&#8811;&#12424;&#12426;&#19979;
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
 
#==============================================================================
# &#9733; &#12459;&#12473;&#12479;&#12510;&#12452;&#12474;&#38917;&#30446; &#9733;
#==============================================================================
module KGC 
 
 OD_GAUGE_MAX = 1000
 
 OD_GAIN_RATE = [10, 60, 200, 100, 160, 40, 160]
end
 
class Window_Base < Window
 @@_od_gauge = RPG::Cache.picture("od_gauge.png")
 OD_GAUGE_SLANT = false
 OD_GAUGE_OFF_Y = 26
 OD_GAUGE_OFF_Y_BATTLE = 26
 OD_GAUGE_HIDE = true
end
 
 
 
$imported["OverDrive"] = true
 
# OverDrive&#23646;&#24615;
$game_special_elements["overdrive"] = $data_system.elements.index("OverDrive")
#==============================================================================
# &#9632; Game_Battler (&#20998;&#21106;&#23450;&#32681; 3)
#==============================================================================
 
class Game_Battler
 #--------------------------------------------------------------------------
 # &#9679; &#20844;&#38283;&#12452;&#12531;&#12473;&#12479;&#12531;&#12473;&#22793;&#25968;
 #--------------------------------------------------------------------------
 attr_accessor :base_damage              # &#22522;&#26412;&#12480;&#12513;&#12540;&#12472;&#20516;
 #--------------------------------------------------------------------------
 # &#9679; &#12473;&#12461;&#12523;&#12398;&#20351;&#29992;&#21487;&#33021;&#21028;&#23450;
 #--------------------------------------------------------------------------
 alias skill_can_use_KGC_OverDrive skill_can_use?
 def skill_can_use?(skill_id)
   # OverDrive&#12473;&#12461;&#12523;&#21028;&#23450;
   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_GAUGE_MAX
         return false
       end
     end
   end
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   return skill_can_use_KGC_OverDrive(skill_id)
 end
 
 
 #--------------------------------------------------------------------------
 # &#9679; &#36890;&#24120;&#25915;&#25731;&#12398;&#21177;&#26524;&#36969;&#29992;
 #--------------------------------------------------------------------------
 
 
 alias attack_effect_KGC_OverDrive attack_effect
 def attack_effect(attacker)
   @base_damage = nil
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   result = attack_effect_KGC_OverDrive(attacker)
 
   if @base_damage == nil
     # &#22522;&#26412;&#12480;&#12513;&#12540;&#12472;&#20516;&#12434;&#20445;&#23384;
     @base_damage = [attacker.atk - self.pdef / 2, 0].max *
       (20 + attacker.str) / 20
   end
   # &#12480;&#12513;&#12540;&#12472;&#12434;&#21463;&#12369;&#12383;&#22580;&#21512;
   if result && self.damage.is_a?(Numeric)
     # &#25915;&#25731;&#26178;&#22679;&#21152;&#21028;&#23450;
     if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
         attacker.overdrive_type == 0 && self.base_damage > 0
       # OD&#12466;&#12540;&#12472;&#22679;&#21152;&#37327;&#35336;&#31639;
       od_up = [[self.damage * KGC::OD_GAIN_RATE[0] * 10 / self.base_damage, 1].max, 160].min
       # OD&#12466;&#12540;&#12472;&#22679;&#21152;
       attacker.overdrive += od_up
     # &#34987;&#12480;&#12513;&#12540;&#12472;&#26178;&#22679;&#21152;&#21028;&#23450;
     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
 
 
 #--------------------------------------------------------------------------
 # &#9679; &#12473;&#12461;&#12523;&#12398;&#21177;&#26524;&#36969;&#29992;
 #--------------------------------------------------------------------------
 
 
 alias skill_effect_KGC_OverDrive skill_effect
 def skill_effect(user, skill)
   @base_damage = nil
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   result = skill_effect_KGC_OverDrive(user, skill)
 
   if @base_damage == nil
     # &#23041;&#21147;&#12434;&#35336;&#31639;
     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
     # &#20493;&#29575;&#12434;&#35336;&#31639;
     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)
     # &#22522;&#26412;&#12480;&#12513;&#12540;&#12472;&#12434;&#20445;&#23384;
     @base_damage = power * rate / 20
   end
   # &#12480;&#12513;&#12540;&#12472;&#12434;&#21463;&#12369;&#12383;&#22580;&#21512;
   if result && self.damage.is_a?(Numeric)
     # &#25915;&#25731;&#26178;&#22679;&#21152;&#21028;&#23450;
     if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
         user.overdrive_type == 0 && self.base_damage > 0
       # OD&#12466;&#12540;&#12472;&#22679;&#21152;&#37327;&#35336;&#31639;
       od_up = [[self.damage * KGC::OD_GAIN_RATE[0] * 10 / self.base_damage, 1].max, 160].min
       # OD&#12466;&#12540;&#12472;&#22679;&#21152;
       user.overdrive += od_up
     # &#34987;&#12480;&#12513;&#12540;&#12472;&#26178;&#22679;&#21152;&#21028;&#23450;
     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
   return result
 end
end
 
#==============================================================================
# &#9632; Game_Actor
#==============================================================================
 
class Game_Actor < Game_Battler
 #--------------------------------------------------------------------------
 # &#9679; &#12475;&#12483;&#12488;&#12450;&#12483;&#12503;
 #--------------------------------------------------------------------------
 alias setup_KGC_OverDrive setup
 def setup(actor_id)
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   setup_KGC_OverDrive(actor_id)
 
   @overdrive = 0
   @overdrive_type = 0
 end
 #--------------------------------------------------------------------------
 # &#9679; OverDrive&#12466;&#12540;&#12472;&#12398;&#21462;&#24471;
 #--------------------------------------------------------------------------
 def overdrive
   @overdrive = 0 if @overdrive == nil
   return @overdrive
 end
 #--------------------------------------------------------------------------
 # &#9679; OverDrive&#12466;&#12540;&#12472;&#12398;&#25805;&#20316;
 #--------------------------------------------------------------------------
 def overdrive=(value)
   @overdrive = 0 if @overdrive == nil
   @overdrive = [[value, 0].max, KGC::OD_GAUGE_MAX].min
 end
 #--------------------------------------------------------------------------
 # &#9679; OverDrive&#12479;&#12452;&#12503;&#12398;&#21462;&#24471;
 #--------------------------------------------------------------------------
 def overdrive_type
   @overdrive_type = 0 if @overdrive_type == nil
   return @overdrive_type
 end
 #--------------------------------------------------------------------------
 # &#9679; OverDrive&#12479;&#12452;&#12503;&#12398;&#25805;&#20316;
 #--------------------------------------------------------------------------
 def overdrive_type=(value)
   @overdrive_type = 0 if @overdrive_type == nil
   @overdrive_type = value
 end
end
 
#&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#65533;
 
 
#==============================================================================
# &#9632; Window_Base
#==============================================================================
class Window_Base < Window
 #--------------------------------------------------------------------------
 # &#9679; &#12458;&#12502;&#12472;&#12455;&#12463;&#12488;&#21021;&#26399;&#21270;
 #--------------------------------------------------------------------------
 alias initialize_KGC_OverDrive_Base initialize
 def initialize(x, y, width, height)
 
   @od_gauge = @@_od_gauge
   @od_g_width = @od_gauge.width / 3
   @od_g_height = (@od_gauge.height - 2) / 3
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   initialize_KGC_OverDrive_Base(x, y, width, height)
 end
 
 #--------------------------------------------------------------------------
 # &#9679; &#12466;&#12540;&#12472;&#30011;&#20687;(&#12510;&#12473;&#12479;&#12540;)&#12434;&#21462;&#24471;
 #--------------------------------------------------------------------------
 def _od_gauge
   return @@_od_gauge
 end
 #--------------------------------------------------------------------------
 # &#9679; &#12466;&#12540;&#12472;&#30011;&#20687;(&#12510;&#12473;&#12479;&#12540;)&#12434;&#35373;&#23450;
 #--------------------------------------------------------------------------
 def _od_gauge=(new_bitmap)
   @@_od_gauge.dispose
   @@_od_gauge = new_bitmap
 end
 #--------------------------------------------------------------------------
 # &#9679; &#12466;&#12540;&#12472;&#30011;&#20687;&#12434;&#21462;&#24471;
 #--------------------------------------------------------------------------
 def od_gauge
   return @od_gauge
 end
 #--------------------------------------------------------------------------
 # &#9679; &#12466;&#12540;&#12472;&#30011;&#20687;&#12434;&#35373;&#23450;
 #--------------------------------------------------------------------------
 def od_gauge=(new_bitmap)
   @od_gauge = new_bitmap
 end
 #--------------------------------------------------------------------------
 # &#9679; &#21517;&#21069;&#12398;&#25551;&#30011;
 #--------------------------------------------------------------------------
 alias draw_actor_name_KGC_OverDrive draw_actor_name
 def draw_actor_name(actor, x, y)
   unless (!$game_temp.in_battle && OD_GAUGE_HIDE)
     #draw_actor_od_gauge(actor, x, y , 120)
     draw_actor_od_gauge(actor, x , y - 39, 420) #255
   end
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   draw_actor_name_KGC_OverDrive(actor, x, y)
 end
 #--------------------------------------------------------------------------
 # &#9679; OverDrive &#12466;&#12540;&#12472;&#12398;&#25551;&#30011;
 #--------------------------------------------------------------------------
 def draw_actor_od_gauge(actor, x, y, width)
   # &#12466;&#12540;&#12472;&#24133;&#35336;&#31639;
   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 ? OD_GAUGE_OFF_Y_BATTLE : OD_GAUGE_OFF_Y)
 
     #=================
     #new by Xk8
     #=================
 #-------------------------------------------------------------------------------------------    
     dx = actor.index * 160 + 12
     dy = 30
     self.contents.font.name = "Monotype Corsiva"
     self.contents.font.size = 22
     self.contents.font.color = Color.new(0, 0, 0, 255)
     self.contents.draw_text(dx + 51, dy - 20, 120, 32, "")
     self.contents.font.color = normal_color
     self.contents.draw_text(dx + 50, dy - 21, 120, 32, "")
 #-------------------------------------------------------------------------------------------
     #=================
     #end new by Xk8
     #=================
 
     dx -= 16 if $imported["HPSPAlter"] && !HPSP_DRAW_NAME_LUMP
     gw = @gs_od[actor.index] * @od_g_width / KGC::OD_GAUGE_MAX
     maximum = @gs_od[actor.index] == KGC::OD_GAUGE_MAX
   else
     @gauge_x = 0
     dx = x + width - @od_g_width - 13
     dy = y + ($game_temp.in_battle ? OD_GAUGE_OFF_Y_BATTLE : OD_GAUGE_OFF_Y)
     gw = actor.overdrive * @od_g_width / KGC::OD_GAUGE_MAX
     maximum = actor.overdrive == KGC::OD_GAUGE_MAX
   end
   # &#26012;&#12417;&#25551;&#30011;
   if OD_GAUGE_SLANT
     self.contents.fill_rect(dx, dy, @od_g_width + 7, 6, Color.new(0, 0, 0, 0))
     # &#26528;&#25551;&#30011;
     gy = @od_g_height + 1
     for i in 0...(@od_g_height + 2)
       self.contents.blt(dx + i, dy + gy - i, @od_gauge, Rect.new(0, gy - i, @od_g_width + 2, 1))
     end
     # &#26412;&#20307;&#25551;&#30011;
     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_gauge, Rect.new(@gauge_x, gy2 - i, gw, 1))
     end
   # &#36890;&#24120;&#25551;&#30011;
   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_gauge, 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_gauge, Rect.new(@gauge_x, gy2, gw, @od_g_height))
   end
 end
end
 
#&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#65533;
 
 
#==============================================================================
# &#9632; Window_BattleStatus
#==============================================================================
 
class Window_BattleStatus < Window_Base
 #--------------------------------------------------------------------------
 # &#9679; &#12458;&#12502;&#12472;&#12455;&#12463;&#12488;&#21021;&#26399;&#21270;
 #--------------------------------------------------------------------------
 
 alias initialize_KGC_OverDrive initialize
 def initialize
   @gauge_x, @gs_od = 0, []
   @od_g_width = @@_od_gauge.width / 3
   @od_g_height = (@@_od_gauge.height - 2) / 3
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   initialize_KGC_OverDrive
 end
 #--------------------------------------------------------------------------
 # &#9679; &#12522;&#12501;&#12524;&#12483;&#12471;&#12517;
 #--------------------------------------------------------------------------
 alias refresh_KGC_OverDrive refresh
 def refresh
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   refresh_KGC_OverDrive
 
   for i in 0...$game_party.actors.size
     @gs_od[i] = $game_party.actors[i].overdrive
   end
 end
 #--------------------------------------------------------------------------
 # &#9679; &#12501;&#12524;&#12540;&#12512;&#26356;&#26032;
 #--------------------------------------------------------------------------
 alias update_KGC_OverDrive update
 def update
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   update_KGC_OverDrive
 
   # &#12466;&#12540;&#12472;&#30011;&#20687;&#12434;&#27969;&#12377;
   unless $imported["HPSPAlter"]
     @gauge_x -= [@od_g_width / 20, 1].max
     @gauge_x = @od_g_width * 2 if @gauge_x < 0
   end
   for i in 0...$game_party.actors.size
     draw_actor_od_gauge($game_party.actors[i], 0, 0, 120)
   end
 end
end
#&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#65533;
 
 
#==============================================================================
# &#9632; Scene_Battle (&#20998;&#21106;&#23450;&#32681; 1)
#==============================================================================
 
class Scene_Battle
 #--------------------------------------------------------------------------
 # &#9679; &#12496;&#12488;&#12523;&#32066;&#20102;
 #     result : &#32080;&#26524; (0:&#21213;&#21033; 1:&#36867;&#36208; 2:&#25943;&#21271;)
 #--------------------------------------------------------------------------
 alias battle_end_KGC_OverDrive battle_end
 def battle_end(result)
   case result
   when 0  # &#21213;&#21033;
     for actor in $game_party.actors
       next unless actor.exist?
       # &#12489;&#12521;&#12452;&#12502;&#12479;&#12452;&#12503;&#12364;&#12300;&#21213;&#21033;&#12301;&#12398;&#22580;&#21512;&#12399;&#21152;&#31639;
       if actor.overdrive_type == 2
         actor.overdrive += KGC::OD_GAIN_RATE[2]
       end
     end
   when 1  # &#36867;&#36208;
     for actor in $game_party.actors
       next unless actor.exist?
       # &#12489;&#12521;&#12452;&#12502;&#12479;&#12452;&#12503;&#12364;&#12300;&#36867;&#36208;&#12301;&#12398;&#22580;&#21512;&#12399;&#21152;&#31639;
       if actor.overdrive_type == 3
         actor.overdrive += KGC::OD_GAIN_RATE[3]
       end
     end
   end
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   battle_end_KGC_OverDrive(result)
 end
end
 
#&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#9733;&#9734;&#65533;
 
 
#==============================================================================
# &#9632; Scene_Battle (&#20998;&#21106;&#23450;&#32681; 4)
#==============================================================================
 
class Scene_Battle
 #--------------------------------------------------------------------------
 # &#9679; &#12501;&#12524;&#12540;&#12512;&#26356;&#26032; (&#12513;&#12452;&#12531;&#12501;&#12455;&#12540;&#12474; &#12473;&#12486;&#12483;&#12503; 2 : &#12450;&#12463;&#12471;&#12519;&#12531;&#38283;&#22987;)
 #--------------------------------------------------------------------------
 alias update_phase4_step2_KGC_OverDrive update_phase4_step2
 def update_phase4_step2
   if @active_battler.is_a?(Game_Actor)
     # &#12466;&#12540;&#12472;&#22679;&#21152;&#21028;&#23450;
     case @active_battler.overdrive_type
     when 4  # &#23396;&#29420;&#25126;&#38360;
       alone = true
       for actor in $game_party.actors
         next if actor == @active_battler
         # &#29983;&#23384;&#32773;&#12364;&#12356;&#12427;&#22580;&#21512;&#12399;&#23396;&#29420;&#12391;&#12399;&#12394;&#12356;
         if actor.exist?
           alone = false
           break
         end
       end
       od_up = alone ? KGC::OD_GAIN_RATE[4] : 0
     when 5  # &#34892;&#21205;&#26178;
       od_up = KGC::OD_GAIN_RATE[5]
     when 6  # &#28693;&#27515;
       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
 
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   update_phase4_step2_KGC_OverDrive
 end
 #--------------------------------------------------------------------------
 # &#9679; &#12473;&#12461;&#12523;&#12450;&#12463;&#12471;&#12519;&#12531; &#32080;&#26524;&#20316;&#25104;
 #--------------------------------------------------------------------------
 alias make_skill_action_result_KGC_OverDrive make_skill_action_result
 def make_skill_action_result
   # &#20803;&#12398;&#20966;&#29702;&#12434;&#23455;&#34892;
   make_skill_action_result_KGC_OverDrive
 
   # &#12458;&#12540;&#12496;&#12540;&#12489;&#12521;&#12452;&#12502;&#12473;&#12461;&#12523;&#12434;&#20351;&#29992;&#12375;&#12383;&#22580;&#21512;
   if @active_battler.is_a?(Game_Actor) && @skill.element_set.include?($game_special_elements["overdrive"])
     @active_battler.overdrive = 0
   end
 end
end

Script On/Off Problem

Quellcode

Social Bookmarks