Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Schrägstrich OverDriven
#1
Schrägstrich OverDriven Battle System ~ Höllenfeuer v2.0b
by Yukari Telepath
May 17 2007

This is a locked, two-post thread from Creation Asylum. Archived here to prevent its loss.
No support is given. If you are the owner of the thread, please contact administration.


This is a handy little compilation script that I essentially fumbled through over a long, arduous weekend. It's essentially an ATB, with HP, SP, and CP bars, and parameter bars for both actor and enemy. Using my innate ability to stumble through things without knowing what the hell I'm doing, I managed to put this together. While I inserted some of my own lines of code in there, it's by no means all mine.


NOTE: I have elected not to post screenshots of this script, due to the following reasons:
- 1. ImageShack is a royal pain in the ass.
- 2. It takes a whole lot of time out of my schedule.
- 3. I... just don't want to. :P

What I will do is essentially provide you with a list of features found in Höllenfeuer, so you can understand in a nutshell, without pictures, what it does.



Höllenfeuer Features
  • Partially transparent HP and SP bars for both actor and enemy, with numerical values for the actors.
  • Parameter bars for both actor and enemy, again with numerical values for the actors.
  • The command "Flee" appears in each character's action window.
  • Modified damage display, courtesy of the renowned Japanese scripter Cogwheel.
  • The ability to regain HP and SP while defending, courtesy of KGC.
  • Actors recover all their HP after battle.
  • Easy-to-read numerical values that increase and decrease in real time to reflect stat changes.

CAUTION: Schrägstrich OverDriven is not SDK or RTAB compatible. If you put it in the wrong place, this script will screw up your game.

These instructions assume that you're operating on Windows XP:
  1. Copy and paste the entire script above Main. You do not want to see what will happen if you stick it below Main, trust me.
  2. Download these fonts, and install them in your Fonts folder.
    - http://www.abstractfonts.com/font/2775 (Save as "Air Millhouse Italic", with two spaces between Millhouse and Italic)
    - http://www.dafont.com/search.php?psize=m&q=Miniskip
    - http://game.salburg.com/hymmnoserver/
    - http://www.dafont.com/search.php?psize=m...usPrinceps
  3. Go to Cogwheel's site, and download the bottom link below the screenshot, the one that doesn't say "RTAB."
  4. Create a new folder called "String" and place the picture files from the zipped folder that you downloaded into "String."
  5. Do a couple of test runs to see if it works. I cannot guarantee compatibility with any and all scripts.

Now then, the code:

ATB Script Code

Part 1 (Had to span two posts)
Code:
#==============================================================================
# ¤ Schrägstrich OverDriven Battle System ~ Höllenfeuer v2.0b  /
#--------------------------------------------------------------------------
# ------------------------------------------ Compiled by Saint Arctica
#========================================
# While Höllenfeuer was largely put together by me, this script is by
# no means all mine. A large number of masterful codes from the
# most professional scripters imaginable are compacted into one
# versatile battle system. A full list of scripts that were used in
# Höllenfeuer is at the bottom of the comment section.
#
# Plagiarism is bad, kids.
#========================================
#========================================
# Notable Scripting Websites ----------------------------------------------
#========================================
# KGC's Second Development Room ---
# http://f44.aaa.livedoor.jp/~ytomy/tkool/rpgtech/frame.php
#
# Castle of Cogwheel
# http://members.jcom.home.ne.jp/cogwheel/main.html
#========================================
#========================================
# Full List of Scripts, and Scripter Credit ---------------------------------
#========================================
# "Enemy HP Script" by SephirothSpawn
# "New_Battle" by Maki
# "Battle End Recovery" by Fukuyama
# "Shadow Text" by TOMY
# "Actor Parameter Bars" by Saint Arctica
# "Damage Indication Remodelling" by Cogwheel
# "ATB Scene_Battle" by XRXS
# "Enemy SP and Parameter Bars" by Saint Arctica
# "Höllenfeuer HUD" by Saint Arctica
# "Defensive HP Recovery" by KGC
# ----------------------------------------------------------------
# If you see a script that I forgot to credit, let me know.
#========================================

#==============================================================================
# Original Scripts by : A bunch of people; see above.
#==============================================================================
#
#===================================================
# ¥£¥ XRXS_BP 3. Ÿ—˜ŽžHP‰ñ•œ ver.1.01 ¥£¥
# by fukuyama, ÷‰ë Ý“y
#
# Battle_End_Recovery
#
# í“¬Œã‚̉ñ•œˆ—ƒ‚ƒWƒ…[ƒ‹
#
# Request: stay
# Script: fukuyama
# Test: ƒmƒRƒmŽq
#
# URL: http://www4.big.or.jp/~fukuyama/rgss/Battle_End_Recovery.txt
#
#===================================================
# --------------- END OF COMMENT SECTION -------------------------------------------------
#===================================================

module Battle_End_Recovery

module Scene_Battle_Module

# ‰ñ•œ—¦•Ï”‚ÌID
@@recovery_rate_variable_id = nil

# ‰ñ•œ—¦‚̎擾
def battle_end_recovery_rate
if @@recovery_rate_variable_id.nil?
   @@recovery_rate_variable_id =
     $data_system.variables.index 'í“¬Œã‚̉ñ•œ—¦'
   if @@recovery_rate_variable_id.nil?
     @@recovery_rate_variable_id = false
   end
end
return 0 unless @@recovery_rate_variable_id
return $game_variables[@@recovery_rate_variable_id]
end

# í“¬Œã‚̉ñ•œˆ—
def battle_end_recovery

# ‰ñ•œ—¦
recovery_rate = battle_end_recovery_rate

# ‰ñ•œ—¦•Ï”‚ª‚OˆÈŠO‚©‚ƒAƒNƒ^[‚ª¶‘¶‚µ‚Ä‚¢‚éê‡Aí“¬Œã‚̉ñ•œ
ˆ—‚ðs‚¤
if recovery_rate != 0 and not actor.dead?

   # ƒp[ƒeƒB‚̃AƒNƒ^[–ˆ‚Ƀ‹[ƒv
   $game_party.actors.each do |actor|

     # ‰ñ•œ—ÊŒvŽZ
     recovery_hp = (actor.maxhp / 100.0 * recovery_rate).truncate
     recovery_sp = (actor.maxsp / 100.0 * recovery_rate).truncate

     # ŽÀÛ‚ɉñ•œ
     actor.hp += recovery_hp
     actor.sp += recovery_sp

     # ƒAƒjƒ[ƒVƒ‡ƒ“Ý’è
     actor.damage = - recovery_hp
     actor.damage_pop = true

   end

   # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðXV
   @status_window.refresh

end
end

end # module Scene_Battle_Module
end # module Battle_End_Recovery

#------------------------------
# í“¬ƒV[ƒ“‚̍Ēè‹`
#------------------------------
class Scene_Battle

# Scene_Battle—pƒ‚ƒWƒ…[ƒ‹‚ðƒCƒ“ƒNƒ‹[ƒh
include Battle_End_Recovery::Scene_Battle_Module

# Œ³‚̃tƒF[ƒY‚TŠJŽn‚É•Ê–¼‚ð‚‚¯‚é
alias battle_end_recovery_original_start_phase5 start_phase5

# ƒtƒF[ƒY‚TŠJŽn‚ðÄ’è‹`
def start_phase5

# í“¬Œã‚̉ñ•œˆ—‚ðŒÄ‚яo‚·
battle_end_recovery

# Œ³‚̃tƒF[ƒY‚TŠJŽn‚ðŒÄ‚яo‚·
battle_end_recovery_original_start_phase5

end
end

# Battle_End_Recovery
# ¥£¥ XRXS_BP10. LEVEL UP!ƒEƒBƒ“ƒhƒE ¥£¥
# by ÷‰ë Ý“y

$data_system_level_up_se = ""                       # ƒŒƒxƒ‹ƒAƒbƒvSEB""‚Å–³‚µB
$data_system_level_up_me = "Audio/ME/007-Fanfare01" # ƒŒƒxƒ‹ƒAƒbƒvME

#==============================================================================
# ¡ Window_LevelUpWindow
#------------------------------------------------------------------------------
# @ƒoƒgƒ‹I—¹ŽžAƒŒƒxƒ‹ƒAƒbƒv‚µ‚½ê‡‚ɃXƒe
[ƒ^ƒX‚ð•\Ž¦‚·‚éƒEƒBƒ“ƒhƒE‚Å‚·B
#==============================================================================
class Window_LevelUpWindow < Window_Base
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
def initialize(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
super(0, 128, 160, 192)
self.contents = Bitmap.new(width - 32, height - 32)
self.visible = false
refresh(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
end
#--------------------------------------------------------------------------
# œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
def refresh(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
self.contents.clear
self.contents.font.color = normal_color
self.contents.font.name = "Palatino Linotype"
self.contents.font.size = 14
self.contents.draw_text( 0,   0, 160, 24, "Level Up!")
self.contents.font.size = 18
self.contents.draw_text( 0,  28, 160, 24, $data_system.words.hp)
self.contents.draw_text( 0,  50, 160, 24, $data_system.words.sp)
self.contents.font.size = 14
self.contents.draw_text( 0,  72,  80, 24, $data_system.words.str)
self.contents.draw_text( 0,  94,  80, 24, $data_system.words.dex)
self.contents.draw_text( 0, 116,  80, 24, $data_system.words.agi)
self.contents.draw_text( 0, 138,  80, 24, $data_system.words.int)
self.contents.draw_text(92,   0, 128, 24, "¨")
self.contents.draw_text(76,  28, 128, 24, "=")
self.contents.draw_text(76,  50, 128, 24, "=")
self.contents.draw_text(76,  72, 128, 24, "=")
self.contents.draw_text(76,  94, 128, 24, "=")
self.contents.draw_text(76, 116, 128, 24, "=")
self.contents.draw_text(76, 138, 128, 24, "=")
self.contents.font.color = normal_color
self.contents.draw_text( 0,   0,  88, 24, last_lv.to_s, 2)
self.contents.draw_text( 0,  28,  72, 24, "+" + up_hp.to_s, 2)
self.contents.draw_text( 0,  50,  72, 24, "+" + up_sp.to_s, 2)
self.contents.draw_text( 0,  72,  72, 24, "+" + up_str.to_s, 2)
self.contents.draw_text( 0,  94,  72, 24, "+" + up_dex.to_s, 2)
self.contents.draw_text( 0, 116,  72, 24, "+" + up_agi.to_s, 2)
self.contents.draw_text( 0, 138,  72, 24, "+" + up_int.to_s, 2)
self.contents.font.size = 20
self.contents.draw_text( 0,   0, 128, 24, actor.level.to_s, 2)
self.contents.draw_text( 0,  26, 128, 24, actor.maxhp.to_s, 2)
self.contents.draw_text( 0,  48, 128, 24, actor.maxsp.to_s, 2)
self.contents.draw_text( 0,  70, 128, 24, actor.str.to_s, 2)
self.contents.draw_text( 0,  92, 128, 24, actor.dex.to_s, 2)
self.contents.draw_text( 0, 114, 128, 24, actor.agi.to_s, 2)
self.contents.draw_text( 0, 136, 128, 24, actor.int.to_s, 2)
end
end

#==============================================================================
# ¡ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# œ ’ljÁEŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor :level_up_flags             # LEVEL UP!•\Ž¦
end

#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# œ ’ljÁEŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor :exp_gain_ban             # EXPŽæ“¾ˆêŽž‹ÖŽ~
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
alias xrxs_bp10_initialize initialize
def initialize
@exp_gain_ban = false
xrxs_bp10_initialize
end
#--------------------------------------------------------------------------
# œ ƒXƒe[ƒg [EXP ‚ðŠl“¾‚Å‚«‚È‚¢] ”»’è
#--------------------------------------------------------------------------
alias xrxs_bp10_cant_get_exp? cant_get_exp?
def cant_get_exp?
if @exp_gain_ban == true
return true
else
return xrxs_bp10_cant_get_exp?
end
end
end

#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
# œ ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
#--------------------------------------------------------------------------
alias xrxs_bp10_start_phase5 start_phase5
def start_phase5
# EXP Šl“¾‹ÖŽ~
for i in 0...$game_party.actors.size
$game_party.actors[i].exp_gain_ban = true
end
xrxs_bp10_start_phase5
# EXP Šl“¾‹ÖŽ~‚̉ðœ
for i in 0...$game_party.actors.size
$game_party.actors[i].exp_gain_ban = false
end
# EXP‚ð‰Šú‰»
@exp_gained = 0
for enemy in $game_troop.enemies
# Šl“¾ EXP‚ð’ljÁ         # ƒGƒlƒ~[‚ª‰B‚êó‘Ô‚Å‚È‚¢ê‡
@exp_gained += enemy.exp if not enemy.hidden
end
# Ý’è
@phase5_step       = 0
@exp_gain_actor    = -1
# ƒŠƒUƒ‹ƒgƒEƒBƒ“ƒhƒE‚ð•\Ž¦
@result_window.y -= 64
@result_window.visible = true
# ƒŒƒxƒ‹ƒAƒbƒv”»’è‚Ö
phase5_next_levelup
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒY)
#--------------------------------------------------------------------------
alias xrxs_bp10_update_phase5 update_phase5
def update_phase5
case @phase5_step
when 1
update_phase5_step1
else
xrxs_bp10_update_phase5
# ƒŒƒxƒ‹ƒAƒbƒv‚µ‚Ä‚¢‚éê‡‚Í‹­§ƒoƒgƒ‹I�
�¹
battle_end(0) if @levelup_window != nil and @phase5_wait_count <= 0
end
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒY 1 : ƒŒƒxƒ‹ƒAƒbƒv)
#--------------------------------------------------------------------------
def update_phase5_step1
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
if Input.trigger?(Input::C)
# ƒEƒBƒ“ƒhƒE‚ð•Â‚¶‚ÄŽŸ‚̃AƒNƒ^[‚Ö
@levelup_window.visible = false if @levelup_window != nil
@status_window.level_up_flags[@exp_gain_actor] = false
phase5_next_levelup
end
end
#--------------------------------------------------------------------------
# œ ŽŸ‚̃AƒNƒ^[‚̃Œƒxƒ‹ƒAƒbƒv•\Ž¦‚Ö
#--------------------------------------------------------------------------
def phase5_next_levelup
begin
# ŽŸ‚̃AƒNƒ^[‚Ö
@exp_gain_actor += 1
# ÅŒã‚̃AƒNƒ^[‚̏ꍇ
if @exp_gain_actor >= $game_party.actors.size
   # ƒAƒtƒ^[ƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
   @phase5_step = 0
   return
end
actor = $game_party.actors[@exp_gain_actor]
if actor.cant_get_exp? == false
   # Œ»Ý‚Ì”\—Í’l‚ð•ÛŽ
   last_level = actor.level
   last_maxhp = actor.maxhp
   last_maxsp = actor.maxsp
   last_str = actor.str
   last_dex = actor.dex
   last_agi = actor.agi
   last_int = actor.int
   # ŒoŒ±’lŽæ“¾‚ÌŒˆ’è“IuŠÔ(“ä
   actor.exp += @exp_gained
   # ”»’è
   if actor.level > last_level
     # ƒŒƒxƒ‹ƒAƒbƒv‚µ‚½ê‡
     @status_window.level_up(@exp_gain_actor)
     if $data_system_level_up_se != ""
       Audio.se_stop
       Audio.se_play($data_system_level_up_se)
     end
     if $data_system_level_up_me != ""
       Audio.me_stop
       Audio.me_play($data_system_level_up_me)
     end
     @levelup_window = Window_LevelUpWindow.new(actor, last_level,
       actor.maxhp - last_maxhp, actor.maxsp - last_maxsp, actor.str - last_str,
       actor.dex - last_dex, actor.agi - last_agi, actor.int - last_int)
     @levelup_window.x = 160 * @exp_gain_actor
     @levelup_window.visible = true
     @phase5_wait_count = 40
     @phase5_step       =  1
     # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
     @status_window.refresh
     return
   end
end
end until false
end
end
# ¥£¥ XRXS_17. ƒXƒŠƒbƒvƒ_ƒ[ƒW–hŒä^Œø‰Ê—ʏڍ׉» ver.1.51 ¥£¥
# by ÷‰ë Ý“y, fukuyama

#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# œ ƒXƒŠƒbƒvƒ_ƒ[ƒW‚ÌŒø‰Ê“K—p
#--------------------------------------------------------------------------
alias xrxs_bp7_slip_damage_effect slip_damage_effect
def slip_damage_effect
# ”’l‚̏‰Šú‰»
slip_damage_percent = 0
slip_damage_plus = 0
# Œ»Ý•t‰Á‚³‚ê‚Ä‚¢‚éƒXƒe[ƒg‚Ì’†‚©‚çƒXƒŠƒbƒvƒ_ƒ[ƒW—L‚è‚̃‚ƒm‚ð’T‚·
for i in @states
if $data_states[i].slip_damage
   # ‚»‚̃Xƒe[ƒg‚ªŽ‚Á‚Ä‚¢‚éƒXƒŠƒbƒvƒ_ƒ[ƒW‚Ì
   # Lvƒvƒ‰ƒXƒXƒe[ƒg‚Ü‚½‚ÍLvƒ}ƒCƒiƒXƒXƒe[ƒg‚ð”»’èB
   for j in $data_states[i].plus_state_set
     if $data_states[j] != nil
       if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)(%|“)/
         slip_damage_percent += $1.to_i
       elsif $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)$/
         slip_damage_plus += $1.to_i
       end
     end
   end
   for j in $data_states[i].minus_state_set
     if $data_states[j] != nil
       if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)(%|“)/
         slip_damage_percent -= $1.to_i
       elsif $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)$/
         slip_damage_plus -= $1.to_i
       end
     end
   end
end
end
if slip_damage_percent == 0 and slip_damage_plus == 0
xrxs_bp7_slip_damage_effect
else
# –h‹ï‚ªƒXƒŠƒbƒv–hŒä‚ª‚ ‚éê‡‚ð”»’è
for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
   armor = $data_armors[i]
   next if armor == nil
   for j in armor.guard_state_set
     if $data_states[j] != nil
       if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)(%|“)/
         if slip_damage_percent > 0
           slip_damage_percent = [slip_damage_percent - $1.to_i, 0].max
         end
       end
       if $data_states[j].name =~ /^ƒXƒŠƒbƒv([0-9]+)$/
         if slip_damage_percent > 0
           slip_damage_plus = [slip_damage_plus - $1.to_i, 0].max
         end
       end
     end
   end
end
# ƒ_ƒ[ƒW‚ðÝ’è
self.damage = self.maxhp * slip_damage_percent / 100 + slip_damage_plus
# •ªŽU
if self.damage.abs > 0
   amp = [self.damage.abs * 15 / 100, 1].max
   self.damage += rand(amp+1) + rand(amp+1) - amp
end
# HP ‚©‚çƒ_ƒ[ƒW‚ðŒ¸ŽZ
self.hp -= self.damage
# ƒƒ\ƒbƒhI—¹
return true
end
end
end

# ¥£¥ XRXS_BP 1. CP§“±“ü ver.15 ¥£¥
# by ÷‰ë Ý“y, ˜aŠó, Jack-R

#==============================================================================
# ¡ Scene_Battle_CP
#==============================================================================
class Scene_Battle_CP
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor   :stop                   # CP‰ÁŽZƒXƒgƒbƒv
#----------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‚̏‰Šú‰»
#----------------------------------------------------------------------------
def initialize
@battlers = []
@cancel = false
@agi_total = 0
# ”z—ñ @count_battlers ‚ð‰Šú‰»
@count_battlers = []
# ƒGƒlƒ~[‚ð”z—ñ @count_battlers ‚ɒljÁ
for enemy in $game_troop.enemies
@count_battlers.push(enemy)
end
# ƒAƒNƒ^[‚ð”z—ñ @count_battlers ‚ɒljÁ
for actor in $game_party.actors
@count_battlers.push(actor)
end
for battler in @count_battlers
@agi_total += battler.agi
end
for battler in @count_battlers
battler.cp = [[65535 * (rand(15) + 85) / 100 * battler.agi / @agi_total * 2, 0].max, 65535].min
end
end
#----------------------------------------------------------------------------
# œ CPƒJƒEƒ“ƒg‚ÌŠJŽn
#----------------------------------------------------------------------------
def start
if @cp_thread != nil then
return
end
@cancel = false
@stop = false
# ‚±‚±‚©‚çƒXƒŒƒbƒh
@cp_thread = Thread.new do
while @cancel != true
   if @stop != true
     self.update # XV
     sleep(0.05)
   end
end
end
# ‚±‚±‚܂ŃXƒŒƒbƒh
end
#----------------------------------------------------------------------------
# œ CPƒJƒEƒ“ƒgƒAƒbƒv
#----------------------------------------------------------------------------
def update
if @count_battlers != nil then
for battler in @count_battlers
   # s“®o—ˆ‚È‚¯‚ê‚Ζ³Ž‹
   if battler.dead? == true #or battler.movable? == false then
     battler.cp = 0
     next
   end
   # ‚±‚±‚Ì 1.3‚ð•Ï‚¦‚邱‚ƂŁ«ƒXƒs[ƒh‚ð•ÏX‰Â”\B‚½‚¾‚µ¬”“_‚ÍŽg—p‚·‚邱‚ƁB
   battler.cp = [[battler.cp + 1.3 * 4096 * battler.agi / @agi_total, 0].max, 65535].min
end
end
end
#----------------------------------------------------------------------------
# œ CPƒJƒEƒ“ƒg‚ÌŠJŽn
#----------------------------------------------------------------------------
def stop
@cancel = true
if @cp_thread != nil then
@cp_thread.join
@cp_thread = nil
end
end
end

#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
attr_accessor :now_guarding             # Œ»Ý–hŒä’†ƒtƒ‰ƒO
attr_accessor :cp                       # Œ»ÝCP
attr_accessor :slip_state_update_ban    # ƒXƒŠƒbƒvEƒXƒe[ƒgŽ©“®ˆ—‚Ì‹ÖŽ~
#--------------------------------------------------------------------------
# œ ƒRƒ}ƒ“ƒh“ü—͉”\”»’è
#--------------------------------------------------------------------------
def inputable?
return (not @hidden and restriction <= 1 and @cp >=65535)
end
#--------------------------------------------------------------------------
# œ ƒXƒe[ƒg [ƒXƒŠƒbƒvƒ_ƒ[ƒW] ”»’è
#--------------------------------------------------------------------------
alias xrxs_bp1_slip_damage? slip_damage?
def slip_damage?
return false if @slip_state_update_ban
return xrxs_bp1_slip_damage?
end
#--------------------------------------------------------------------------
# œ ƒXƒe[ƒgŽ©‘R‰ðœ (ƒ^[ƒ“‚²‚ƂɌĂяo‚µ)
#--------------------------------------------------------------------------
alias xrxs_bp1_remove_states_auto remove_states_auto
def remove_states_auto
return if @slip_state_update_ban
xrxs_bp1_remove_states_auto
end
end

#==============================================================================
# ¡ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# œ ƒZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
alias xrxs_bp1_setup setup
def setup(actor_id)
xrxs_bp1_setup(actor_id)
@hate = 100  # init-value is 100
@cp = 0
@now_guarding = false
@slip_state_update_ban = false
end
end

#==============================================================================
# ¡ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
alias xrxs_bp1_initialize initialize
def initialize(troop_id, member_index)
xrxs_bp1_initialize(troop_id, member_index)
@hate = 100  # init-value is 100
@cp = 0
@now_guarding = false
@slip_state_update_ban = false
end
end

#==============================================================================
# ¡ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor   :update_cp_only                   # CPƒ[ƒ^[‚݂̂̍XV
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
alias xrxs_bp1_initialize initialize
def initialize
@update_cp_only = false
xrxs_bp1_initialize
end
#--------------------------------------------------------------------------
# œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------
alias xrxs_bp1_refresh refresh
def refresh
if @update_cp_only == false
xrxs_bp1_refresh
end
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
actor_x = i * 160 + 4
draw_actor_cp_meter(actor, actor_x, 96, 120, 0)
end
end
#--------------------------------------------------------------------------
# œ CPƒ[ƒ^[ ‚Ì•`‰æ
#--------------------------------------------------------------------------
def draw_actor_cp_meter(actor, x, y, width = 156, type = 0)
self.contents.fill_rect(x-1, y+27, width+2,6, Color.new(0, 0, 0, 155))
if actor.cp == nil
actor.cp = 0
end
w = width * [actor.cp,65535].min / 65535
self.contents.fill_rect(x, y+27, w,1, Color.new(255, 255, 255, 255))
self.contents.fill_rect(x, y+28, w,1, Color.new(255, 0, 255, 255))
self.contents.fill_rect(x, y+29, w,1, Color.new(255, 0, 255, 155))
self.contents.fill_rect(x, y+30, w,1, Color.new(255, 0, 255, 55))
self.contents.fill_rect(x, y+31, w,1, Color.new(255, 0, 255, 155))
self.contents.fill_rect(x, y+32, w,1, Color.new(255, 0, 255, 255))
self.contents.fill_rect(x, y+33, w,1, Color.new(255, 255, 255, 255))
end
end

#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle
# ‚±‚±‚ÉŒø‰Ê‰¹‚ðÝ’è‚·‚é‚ƁAƒAƒNƒ^[ƒRƒ}ƒ“ƒh‚ªƒ|ƒbƒv‚µ‚½‚Æ‚«‚ÉŒø‰Ê‰¹‚ðÄ
¶
$data_system_command_up_se = ""
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹I—¹
#     result : Œ‹‰Ê (0:Ÿ—˜ 1:”s–k 2:“¦‘–)
#--------------------------------------------------------------------------
alias xrxs_bp1_battle_end battle_end
def battle_end(result)
# CPƒJƒEƒ“ƒg’âŽ~
@cp_thread.stop
xrxs_bp1_battle_end(result)
end
#--------------------------------------------------------------------------
# œ ƒvƒŒƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
#--------------------------------------------------------------------------
alias xrxs_bp1_start_phase1 start_phase1
def start_phase1
@agi_total = 0
@cp_thread = Scene_Battle_CP.new
# ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðÄì¬
s1 = $data_system.words.attack
s2 = $data_system.words.skill
s3 = $data_system.words.guard
s4 = $data_system.words.item
@actor_command_window = Window_Command.new(160, [s1, s2, s3, s4, "Flee"])
@actor_command_window.y = 128
@actor_command_window.back_opacity = 60
@actor_command_window.active = false
@actor_command_window.visible = false
@actor_command_window.draw_item(4, $game_temp.battle_can_escape ? @actor_command_window.normal_color : @actor_command_window.disabled_color)
xrxs_bp1_start_phase1
end
#--------------------------------------------------------------------------
# œ ƒp[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
#--------------------------------------------------------------------------
alias xrxs_bp1_start_phase2 start_phase2
def start_phase2
xrxs_bp1_start_phase2
@party_command_window.active = false
@party_command_window.visible = false
# ŽŸ‚Ö
start_phase3
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒp[ƒeƒBƒRƒ}ƒ“ƒhƒtƒF[ƒY)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase2 update_phase2
def update_phase2
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
if Input.trigger?(Input::C)
# ƒp[ƒeƒBƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
case @party_command_window.index
when 0  # í‚¤
   # Œˆ’è SE ‚ð‰‰‘t
   $game_system.se_play($data_system.decision_se)
   @cp_thread.start
   # ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
   start_phase3
end
return
end
xrxs_bp1_update_phase2
end
#--------------------------------------------------------------------------
# œ ŽŸ‚̃AƒNƒ^[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
#--------------------------------------------------------------------------
def phase3_next_actor
# ƒ‹[ƒv
begin
# ƒAƒNƒ^[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_battler != nil
   @active_battler.blink = false
end
# ÅŒã‚̃AƒNƒ^[‚̏ꍇ
if @actor_index == $game_party.actors.size-1
   # ƒƒCƒ“ƒtƒF[ƒYŠJŽn
   @cp_thread.start
   start_phase4
   return
end
# ƒAƒNƒ^[‚̃Cƒ“ƒfƒbƒNƒX‚ði‚ß‚é
@actor_index += 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
if @active_battler.inputable? == false
   @active_battler.current_action.kind = -1
end
# ƒAƒNƒ^[‚ªƒRƒ}ƒ“ƒh“ü—Í‚ðŽó‚¯•t‚¯‚È‚¢ó‘Ô‚È
‚ç‚à‚¤ˆê“x
end until @active_battler.inputable?
@cp_thread.stop
# ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðƒZƒbƒgƒAƒbƒv
@active_battler.now_guarding = false
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# œ ‘O‚̃AƒNƒ^[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
#--------------------------------------------------------------------------
def phase3_prior_actor
# ƒ‹[ƒv
begin
# ƒAƒNƒ^[‚Ì–¾–ŃGƒtƒFƒNƒg OFF
if @active_battler != nil
   @active_battler.blink = false
end
# Å‰‚̃AƒNƒ^[‚̏ꍇ
if @actor_index == 0
   # Å‰‚Ö–ß‚é
   start_phase3
   return
end
# ƒAƒNƒ^[‚̃Cƒ“ƒfƒbƒNƒX‚ð–ß‚·
@actor_index -= 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
# ƒAƒNƒ^[‚ªƒRƒ}ƒ“ƒh“ü—Í‚ðŽó‚¯•t‚¯‚È‚¢ó‘Ô‚È
‚ç‚à‚¤ˆê“x
end until @active_battler.inputable?
@cp_thread.stop
# ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚ðƒZƒbƒgƒAƒbƒv
@active_battler.now_guarding = false
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# œ ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃ZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
alias xrxs_bp1_phase3_setup_command_window phase3_setup_command_window
def phase3_setup_command_window
# Œø‰Ê‰¹‚̍ж
Audio.se_play($data_system_command_up_se) if $data_system_command_up_se != ""
# –ß‚·
xrxs_bp1_phase3_setup_command_window
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒY : Šî–{ƒRƒ}ƒ“ƒh)
#--------------------------------------------------------------------------
alias xrxs_bsp1_update_phase3_basic_command update_phase3_basic_command
def update_phase3_basic_command
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
if Input.trigger?(Input::C)
# ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒEƒBƒ“ƒhƒE‚̃J[ƒ\ƒ‹ˆÊ’u‚Å•ªŠò
case @actor_command_window.index
when 4  # “¦‚°‚é
   if $game_temp.battle_can_escape
     # Œˆ’è SE ‚ð‰‰‘t
     $game_system.se_play($data_system.decision_se)
     # ƒAƒNƒVƒ‡ƒ“‚ðÝ’è
     @active_battler.current_action.kind = 0
     @active_battler.current_action.basic = 4
     # ŽŸ‚̃AƒNƒ^[‚̃Rƒ}ƒ“ƒh“ü—Í‚Ö
     phase3_next_actor
   else
     # ƒuƒU[ SE ‚ð‰‰‘t
     $game_system.se_play($data_system.buzzer_se)
   end
   return
end
end
xrxs_bsp1_update_phase3_basic_command
end
#--------------------------------------------------------------------------
# œ ƒƒCƒ“ƒtƒF[ƒYŠJŽn
#--------------------------------------------------------------------------
alias xrxs_bp1_start_phase4 start_phase4
def start_phase4
xrxs_bp1_start_phase4
# ƒGƒlƒ~[ƒAƒNƒVƒ‡ƒ“ì¬
for enemy in $game_troop.enemies
if enemy.cp < 65535
   enemy.current_action.clear
   enemy.current_action.kind = -1 # ƒ^[ƒ“”ò‚΂µB
   next
end
enemy.make_action
end
# s“®‡˜ì¬
make_action_orders
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 1 : ƒAƒNƒVƒ‡ƒ“€”õ)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step1 update_phase4_step1
def update_phase4_step1
# ‰Šú‰»
@phase4_act_continuation = 0
# Ÿ”s”»’è
if judge
@cp_thread.stop
# Ÿ—˜‚Ü‚½‚Í”s–k‚̏ꍇ : ƒƒ\ƒbƒhI—¹
return
end
# –¢s“®ƒoƒgƒ‰[”z—ñ‚̐擪‚©‚çŽæ“¾
@active_battler = @action_battlers[0]
# ƒXƒe[ƒ^ƒXXV‚ðCP‚¾‚¯‚ÉŒÀ’èB
@status_window.update_cp_only = true
# ƒXƒe[ƒgXV‚ð‹ÖŽ~B
@active_battler.slip_state_update_ban = true if @active_battler != nil
# –ß‚·
xrxs_bp1_update_phase4_step1
# ‹ÖŽ~‚ð‰ðœ
@status_window.update_cp_only = false
@active_battler.slip_state_update_ban = false if @active_battler != nil
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 2 : ƒAƒNƒVƒ‡ƒ“ŠJŽn)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step2 update_phase4_step2
def update_phase4_step2
# ‹­§ƒAƒNƒVƒ‡ƒ“‚Å‚È‚¯‚ê‚Î
unless @active_battler.current_action.forcing
# CP‚ª‘«‚è‚Ä‚¢‚È‚¢ê‡
if @phase4_act_continuation == 0 and @active_battler.cp < 65535
   @phase4_step = 6
   return
end
# §–ñ‚ª [“G‚ð’ʏíUŒ‚‚·‚é] ‚© [–¡•û‚ð’ʏíUŒ‚‚·‚é] ‚̏ꍇ
if @active_battler.restriction == 2 or @active_battler.restriction == 3
   # ƒAƒNƒVƒ‡ƒ“‚ɍUŒ‚‚ðÝ’è
   @active_battler.current_action.kind = 0
   @active_battler.current_action.basic = 0
end
# §–ñ‚ª [s“®‚Å‚«‚È‚¢] ‚̏ꍇ
if @active_battler.restriction == 4
   # ƒAƒNƒVƒ‡ƒ“‹­§‘Ώۂ̃oƒgƒ‰[‚ðƒNƒŠƒA
   $game_temp.forcing_battler = nil
   if @phase4_act_continuation == 0 and @active_battler.cp >= 65535
     # ƒXƒe[ƒgŽ©‘R‰ðœ
     @active_battler.remove_states_auto
     # CPÁ”ï
     @active_battler.cp = [(@active_battler.cp - 65535),0].max
     # ƒXƒe[ƒ^ƒXƒEƒBƒ“ƒhƒE‚ðƒŠƒtƒŒƒbƒVƒ…
     @status_window.refresh
   end
   # ƒXƒeƒbƒv 1 ‚Ɉڍs
   @phase4_step = 1
   return
end
end
# ƒAƒNƒVƒ‡ƒ“‚ÌŽí•Ê‚Å•ªŠò
case @active_battler.current_action.kind
when 0
# UŒ‚¥–hŒäE“¦‚°‚éE‰½‚à‚µ‚È‚¢Žž‚Ì‹¤�
�ʏÁ”ïCP
@active_battler.cp -=     0 if @phase4_act_continuation == 0
when 1
# ƒXƒLƒ‹Žg—pŽž‚̏Á”ïCP
@active_battler.cp -= 65535 if @phase4_act_continuation == 0
when 2
# ƒAƒCƒeƒ€Žg—pŽž‚̏Á”ïCP
@active_battler.cp -= 65535 if @phase4_act_continuation == 0
when -1
# CP‚ª—­‚Ü‚Á‚Ä‚¢‚È‚¢
@phase4_step = 6
return
end
# CP‰ÁŽZ‚ðˆêŽž’âŽ~‚·‚é
@cp_thread.stop = true
# ƒXƒe[ƒgŽ©‘R‰ðœ
@active_battler.remove_states_auto
xrxs_bp1_update_phase4_step2
end
#--------------------------------------------------------------------------
# œ Šî–{ƒAƒNƒVƒ‡ƒ“ Œ‹‰Êì¬
#--------------------------------------------------------------------------
alias xrxs_bp1_make_basic_action_result make_basic_action_result
def make_basic_action_result
# UŒ‚‚̏ꍇ
if @active_battler.current_action.basic == 0 and @phase4_act_continuation == 0
@active_battler.cp -= 65535 # UŒ‚Žž‚ÌCPÁ”ï
end
# –hŒä‚̏ꍇ
if @active_battler.current_action.basic == 1 and @phase4_act_continuation == 0
@active_battler.cp -= 32767 # –hŒäŽž‚ÌCPÁ”ï
end
# “G‚Ì“¦‚°‚é‚̏ꍇ
if @active_battler.is_a?(Game_Enemy) and
  @active_battler.current_action.basic == 2 and @phase4_act_continuation == 0
@active_battler.cp -= 65535 # “¦‘–Žž‚ÌCPÁ”ï
end
# ‰½‚à‚µ‚È‚¢‚̏ꍇ
if @active_battler.current_action.basic == 3 and @phase4_act_continuation == 0
@active_battler.cp -= 32767 # ‰½‚à‚µ‚È‚¢Žž‚ÌCPÁ”ï
end
# “¦‚°‚é‚̏ꍇ
if @active_battler.current_action.basic == 4 and @phase4_act_continuation == 0
@active_battler.cp -= 65535 # “¦‘–Žž‚ÌCPÁ”ï
# “¦‘–‰Â”\‚Å‚Í‚È‚¢ê‡
if $game_temp.battle_can_escape == false
   # ƒuƒU[ SE ‚ð‰‰‘t
   $game_system.se_play($data_system.buzzer_se)
   return
end
# Œˆ’è SE ‚ð‰‰‘t
$game_system.se_play($data_system.decision_se)
# “¦‘–ˆ—
update_phase2_escape
return
end
xrxs_bp1_make_basic_action_result
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 5 : ƒ_ƒ[ƒW•\Ž¦)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step5 update_phase4_step5
def update_phase4_step5
# ƒXƒŠƒbƒvƒ_ƒ[ƒW
if @active_battler.hp > 0 and @active_battler.slip_damage?
@active_battler.slip_damage_effect
@active_battler.damage_pop = true
end
xrxs_bp1_update_phase4_step5
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 6 : ƒŠƒtƒŒƒbƒVƒ…)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step6 update_phase4_step6
def update_phase4_step6
# CP‰ÁŽZ‚ðÄŠJ‚·‚é
@cp_thread.stop = false
# ƒwƒ‹ƒvƒEƒBƒ“ƒhƒE‚ð‰B‚·
@help_window.visible = false
xrxs_bp1_update_phase4_step6
end
end

# ¥£¥ XRXS_BP 7. ƒoƒgƒ‹ƒXƒe[ƒ^ƒXEƒNƒŠƒAƒfƒUƒCƒ“ ver.1.02 ¥£¥
# by ÷‰ë Ý“y, TOMY

#==============================================================================
# ¡ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor   :update_cp_only                   # CPƒ[ƒ^[‚݂̂̍XV
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
alias xrxs_bp7_initialize initialize
def initialize
xrxs_bp7_initialize
# «Full-View‚̏ꍇ‚͉º“ñs‚Ì # ‚ðÁ‚µ‚Ä‚­‚¾‚³‚¢B
#self.opacity = 0
#self.back_opacity = 0
end
#--------------------------------------------------------------------------
# œ ƒŠƒtƒŒƒbƒVƒ…
#--------------------------------------------------------------------------

#==========================================
# Höllenfeuer HUD (by Saint Arctica and XRXS) - XRXS Add-On
#==========================================
alias xrxs_bp7_refresh refresh
def refresh
if @update_cp_only
xrxs_bp7_refresh
return
end
# •`ŽÊ‚ð‹ÖŽ~‚µ‚È‚ª‚ç–ß‚·
@draw_ban = true
xrxs_bp7_refresh
# •`ŽÊ‚Ì‹ÖŽ~‚ð‰ðœ
@draw_ban = false
# •`ŽÊ‚ðŠJŽn
@item_max = $game_party.actors.size
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
actor_x = i * 160 + 21
# •àsƒLƒƒƒ‰ƒOƒ‰ƒtƒBƒbƒN‚Ì•`ŽÊ
draw_actor_graphic(actor, actor_x - 9, 116)
# HP/SPƒ[ƒ^[‚Ì•`ŽÊ
draw_actor_hp_meter_line(actor, actor_x,  72, 96, 12)
draw_actor_sp_meter_line(actor, actor_x, 104, 96, 12)
draw_actor_str_meter_line(actor, actor_x, 34, 96, 4)
draw_actor_int_meter_line(actor, actor_x, 42, 96, 4)
draw_actor_dex_meter_line(actor, actor_x, 50, 96, 4)
draw_actor_agi_meter_line(actor, actor_x, 58, 96, 4)
# HP”’l‚Ì•`ŽÊ
self.contents.font.size = 20            # HP/SP”’l‚Ì•¶Žš‚Ì‘å‚«‚³
self.contents.font.name = "miniskip"
self.contents.font.color = actor.hp == 0 ? knockout_color :
   actor.hp <= actor.maxhp / 4 ? crisis_color : Color.new(255, 0, 0, 255)
draw_shadow_text(actor_x-2, 58, 96, 24, actor.hp.to_s, 2)
# SP”’l‚Ì•`ŽÊ
self.contents.font.name = "miniskip"
self.contents.font.color = actor.sp == 0 ? knockout_color :
   actor.sp <= actor.maxsp / 4 ? crisis_color : Color.new(200, 200, 0, 255)
draw_shadow_text(actor_x-2, 90, 96, 24, actor.sp.to_s, 2)
# —pŒêuHPv‚Æ—pŒêuSPv‚Ì•`ŽÊ
self.contents.font.size = 16            # —pŒêuHP/SPv‚Ì•¶Žš‚Ì‘å‚«‚³
self.contents.font.name = "Air Millhouse  Italic"
self.contents.font.color = Color.new(255, 0, 0, 255)
draw_shadow_text(actor_x, 60, 96, 12, $data_system.words.hp)
self.contents.font.color = Color.new(200, 200, 0, 255)
draw_shadow_text(actor_x, 92, 96, 12, $data_system.words.sp)
self.contents.font.name = "Hymmnos"
self.contents.font.size = 24
draw_actor_state(actor, actor_x, 96)
self.contents.font.name = "OptimusPrinceps"
self.contents.font.size = 14
self.contents.font.color = Color.new(100, 100, 100, 255)
draw_actor_name(actor, actor_x - 14, 4)
self.contents.font.name = "Hymmnos"
self.contents.font.size = 18
self.contents.font.color = Color.new(100, 0, 0, 255)
draw_actor_name(actor, actor_x - 14, -12)
self.contents.font.name = "miniskip"
self.contents.font.size = 14
self.contents.font.color = actor.str == 0 ? knockout_color :
   actor.str <= actor.base_str / 3 ? crisis_color : Color.new(0, 0, 0, 255)
self.contents.draw_text(actor_x, 26, 96, 12, $data_system.words.str + "  -  " + actor.str.to_s)
self.contents.font.color = actor.int == 0 ? knockout_color :
   actor.int <= actor.base_int / 3 ? crisis_color : Color.new(0, 0, 0, 255)    
self.contents.draw_text(actor_x, 34, 96, 12, $data_system.words.int + "  -  " + actor.int.to_s)
self.contents.font.color = actor.dex == 0 ? knockout_color :
   actor.dex <= actor.base_dex / 3 ? crisis_color : Color.new(0, 0, 0, 255)
self.contents.draw_text(actor_x, 42, 96, 12, $data_system.words.dex + "  -  " + actor.dex.to_s)
self.contents.font.color = actor.agi == 0 ? knockout_color :
   actor.agi <= actor.base_agi / 3 ? crisis_color : Color.new(0, 0, 0, 255)
self.contents.draw_text(actor_x, 50, 96, 12, $data_system.words.agi + "  -  " + actor.agi.to_s)
self.contents.font.color = actor.pdef == 0 ? knockout_color :
   actor.pdef <= actor.base_pdef / 3 ? crisis_color : Color.new(0, 0, 0, 255)
self.contents.draw_text(actor_x + 75, 75, 96, 16, actor.pdef.to_s)
self.contents.font.color = actor.mdef == 0 ? knockout_color :
   actor.mdef <= actor.base_mdef / 3 ? crisis_color : Color.new(0, 0, 0, 255)
self.contents.draw_text(actor_x + 75, 107, 96, 16, actor.mdef.to_s)  
self.contents.font.name = "Air Millhouse  Italic"
self.contents.font.size = 12
self.contents.font.color = Color.new(35, 35, 35, 255)
self.contents.draw_text(actor_x + 55, 14, 96, 12, "LV. " + actor.level.to_s)
end
end
end
}
#2
Part 2
Code:
#==============================================================================
# ¡ Window_Base
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# œ HPƒ[ƒ^[ ‚Ì•`‰æ
#--------------------------------------------------------------------------
def draw_actor_hp_meter_line(actor, x, y, width = 160, height = 4)
w = width * actor.hp / actor.maxhp
hp_color_1 = Color.new(0, 0, 0, 100)
hp_color_2 = Color.new(255, 0, 0, 255)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(255, 0, 0, 32))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(255, 0, 0, 64))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(255, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(255, 0, 0, 255))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#--------------------------------------------------------------------------
# œ SPƒ[ƒ^[ ‚Ì•`‰æ
#--------------------------------------------------------------------------
def draw_actor_sp_meter_line(actor, x, y, width = 160, height = 2)
w = width * actor.sp / actor.maxsp
hp_color_1 = Color.new(0, 0, 0, 100)
hp_color_2 = Color.new(200, 200, 0, 255)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 32))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 64))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 255))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#=====================================
# Draw Actor Strength Bar (by Saint Arctica)
#=====================================
def draw_actor_str_meter_line(actor, x, y, width = 160, height = 1)
w = width * actor.str / actor.base_str
hp_color_1 = Color.new(80, 180, 120, 100)
hp_color_2 = Color.new(80, 180, 120, 100)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#=====================================
# Draw Actor Intelligence Bar (by Saint Arctica)
#=====================================
def draw_actor_int_meter_line(actor, x, y, width = 160, height = 1)
w = width * actor.int / actor.base_int
hp_color_1 = Color.new(240, 32, 127, 100)
hp_color_2 = Color.new(240, 32, 127, 100)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#=====================================
# Draw Actor Dexterity Bar (by Saint Arctica)
#=====================================
def draw_actor_dex_meter_line(actor, x, y, width = 160, height = 1)
w = width * actor.dex / actor.base_dex
hp_color_1 = Color.new(12, 234, 234, 100)
hp_color_2 = Color.new(12, 234, 234, 100)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#=====================================
# Draw Actor Agility Bar (by Saint Arctica)
#=====================================
def draw_actor_agi_meter_line(actor, x, y, width = 160, height = 1)
w = width * actor.agi / actor.base_agi
hp_color_1 = Color.new(72, 134, 213, 100)
hp_color_2 = Color.new(72, 134, 213, 100)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(200, 200, 0, 0))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#--------------------------------------------------------------------------
# œ –¼‘O‚Ì•`‰æ
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_name draw_actor_name
def draw_actor_name(actor, x, y)
xrxs_bp7_draw_actor_name(actor, x, y) if @draw_ban != true
end
#--------------------------------------------------------------------------
# œ ƒXƒe[ƒg‚Ì•`‰æ
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_state draw_actor_state
def draw_actor_state(actor, x, y, width = 120)
xrxs_bp7_draw_actor_state(actor, x, y, width) if @draw_ban != true
end
#--------------------------------------------------------------------------
# œ HP ‚Ì•`‰æ
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_hp draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
xrxs_bp7_draw_actor_hp(actor, x, y, width) if @draw_ban != true
end
#--------------------------------------------------------------------------
# œ SP ‚Ì•`‰æ
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_sp draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
xrxs_bp7_draw_actor_sp(actor, x, y, width) if @draw_ban != true
end
end

#==============================================================================
# ž ŠO•”ƒ‰ƒCƒuƒ‰ƒŠ
#==============================================================================
class Window_Base
#--------------------------------------------------------------------------
# œ ƒ‰ƒCƒ“•`‰æ by ÷‰ë Ý“y
#--------------------------------------------------------------------------
def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)
# •`ŽÊ‹——£‚ÌŒvŽZB‘å‚«‚ß‚É’¼ŠpŽž‚Ì’·‚³
B
distance = (start_x - end_x).abs + (start_y - end_y).abs
# •`ŽÊŠJŽn
if end_color == start_color
for i in 1..distance
  x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
  y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
  self.contents.fill_rect(x, y, width, width, start_color)
end
else
for i in 1..distance
  x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
  y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
  r = start_color.red   * (distance-i)/distance + end_color.red   * i/distance
  g = start_color.green * (distance-i)/distance + end_color.green * i/distance
  b = start_color.blue  * (distance-i)/distance + end_color.blue  * i/distance
  a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance
  self.contents.fill_rect(x, y, width, width, Color.new(r, g, b, a))
end
end
end

#--------------------------------------------------------------------------
# œ ‰e•¶Žš•`‰æ by TOMY
#--------------------------------------------------------------------------
def draw_shadow_text(x, y, width, height, string, align = 0)
# Œ³‚̐F‚ð•Û‘¶‚µ‚Ä‚¨‚­
color = self.contents.font.color.dup
# •Žš‚ʼne•`‰æ
self.contents.font.color = Color.new(0, 0, 0)
self.contents.draw_text(x + 2, y + 2, width, height, string, align)
# Œ³‚̐F‚É–ß‚µ‚Ä•`‰æ
self.contents.font.color = color
self.contents.draw_text(x, y, width, height, string, align)
end
end

#--------------------------------------------------------------------------
# Draw HP and SP Slant Bar (by SephirothSpawn)
#--------------------------------------------------------------------------

class Window_Base < Window  
#--------------------------------------------------------------------------
# * Draw Slant Bar(by SephirothSpawn)
#--------------------------------------------------------------------------
def draw_slant_bar(x, y, min, max, width = 152, height = 6,
   bar_color = Color.new(180, 0, 0, 255), end_color = Color.new(0, 0, 255, 255))
  # Draw Border
 for i in 0..height
   self.contents.fill_rect(x + i, y + height - i, width + 1, 1, Color.new(50, 50, 50, 255))
 end
 # Draw Background
 for i in 1..(height - 1)
   r = 100 * (height - i) / height + 0 * i / height
   g = 100 * (height - i) / height + 0 * i / height
   b = 100 * (height - i) / height + 0 * i / height
   a = 255 * (height - i) / height + 255 * i / height
   self.contents.fill_rect(x + i, y + height - i, width, 1, Color.new(r, b, g, a))
 end
 # Draws Bar
 for i in 1..( (min / max.to_f) * width - 1)
   for j in 1..(height - 1)
     r = bar_color.red * (width - i) / width + end_color.red * i / width
     g = bar_color.green * (width - i) / width + end_color.green * i / width
     b = bar_color.blue * (width - i) / width + end_color.blue * i / width
     a = bar_color.alpha * (width - i) / width + end_color.alpha * i / width
     self.contents.fill_rect(x + i + j, y + height - j, 1, 1, Color.new(r, g, b, a))
  end
 end
end
end

#=======================================
# Window_EnemyHP
#=======================================

class Window_EnemyHP < Window_Base

def initialize
 super(0, 0, 640, 480)
 self.contents = Bitmap.new(width - 32, height - 32)
 self.opacity = 0
 refresh
end

def refresh
 self.contents.clear
 for i in 0...$game_troop.enemies.size
   @enemy = $game_troop.enemies[i]
   @percent = (@enemy.hp * 100) / @enemy.maxhp
   unless @enemy.hp == 0
   draw_slant_bar(@enemy.screen_x - 55, @enemy.screen_y - 200, @enemy.hp, @enemy.maxhp,
   width = 75, height = 6, bar_color = Color.new(255, 0, 0, 255), end_color = Color.new(120, 0, 120, 120))
   draw_slant_bar(@enemy.screen_x - 55, @enemy.screen_y - 193, @enemy.sp, @enemy.maxsp,
   width = 75, height = 6, bar_color = Color.new(0, 255, 0, 255), end_color = Color.new(0, 120, 120, 120))
   draw_slant_bar(@enemy.screen_x - 55, @enemy.screen_y - 180, @enemy.str, @enemy.base_str,
   width = 75, height = 4, bar_color = Color.new(40, 75, 156, 255), end_color = Color.new(156, 75, 40, 255))
   draw_slant_bar(@enemy.screen_x - 55, @enemy.screen_y - 175, @enemy.int, @enemy.base_int,
   width = 70, height = 4, bar_color = Color.new(100, 32, 96, 255), end_color = Color.new(96, 32, 100, 255))
   draw_slant_bar(@enemy.screen_x - 55, @enemy.screen_y - 170, @enemy.dex, @enemy.base_dex,
   width = 65, height = 4, bar_color = Color.new(27, 234, 123, 255), end_color = Color.new(123, 234, 27, 255))
   draw_slant_bar(@enemy.screen_x - 55, @enemy.screen_y - 165, @enemy.agi, @enemy.base_agi,
   width = 60, height = 4, bar_color = Color.new(235, 94, 235, 255), end_color = Color.new(235, 94, 235, 255))
   self.contents.font.name = "Air Millhouse  Italic"
   self.contents.font.color = Color.new(255, 0, 0, 255)
   self.contents.font.size = 18
   self.contents.draw_text(@enemy.screen_x - 50, @enemy.screen_y - 215, width = 75, height = 20, @enemy.name)
   self.contents.font.size = 16
   self.contents.font.name = "miniskip"
   self.contents.font.color = @enemy.hp == 0 ? knockout_color :
   @enemy.hp <= @enemy.maxhp / 4 ? crisis_color : Color.new(255, 0, 0, 190)
   self.contents.font.color = @enemy.sp == 0 ? knockout_color :
   @enemy.sp <= @enemy.maxsp / 4 ? crisis_color : Color.new(0, 255, 0, 190)
 end
end
end
end

#======================================
# Scene_Battle
#======================================

class Scene_Battle

alias raz_update update
alias raz_update_phase5 update_phase5
alias raz_update_phase4_step1 update_phase4_step1
alias raz_update_phase4_step5 update_phase4_step5
alias raz_enemy_hp_main main

def main
 @troop_id = $game_temp.battle_troop_id
 $game_troop.setup(@troop_id)
 @enemy_window = Window_EnemyHP.new
 @enemy_window.z = 95
 raz_enemy_hp_main
 @enemy_window.dispose
end

def update
 @enemy_window.update
 raz_update
end

def update_phase5
 # If wait count is larger than 0
 if @phase5_wait_count > 0
   # Decrease wait count
   @phase5_wait_count -= 1
   # If wait count reaches 0
   if @phase5_wait_count == 0
     @enemy_window.visible = false
     # Show result window
     @result_window.visible = true
     # Clear main phase flag
     $game_temp.battle_main_phase = false
     # Refresh status window
     @status_window.refresh
     @enemy_window.refresh
   end
   return
 end
raz_update_phase5
end

def update_phase4_step1
raz_update_phase4_step1
@enemy_window.refresh
end

def update_phase4_step5
 # Hide help window
 @help_window.visible = false
 # Refresh status window
 @status_window.refresh
 @enemy_window.refresh
 raz_update_phase4_step5
end
end

#==================================================
# Damage Indication Remodelling v1.05 - by Cogwheel
#==================================================

# ƒ_ƒ[ƒW•\Ž¦‰ü‘¢(’ʏíí“¬—p) Ver 1.05
# ”z•zŒ³EƒTƒ|[ƒgURL
# http://members.jcom.home.ne.jp/cogwheel/

class Scene_Battle
alias :main_damage :main
def main
  for path in ["num", "critical", "miss"]
    RPG::Cache.numeric(path)
  end
  main_damage
end
end

module RPG
class Sprite < ::Sprite
  WIDTH = 18                  # •¶Žš•
  HEIGHT = 12                 # ƒNƒŠƒeƒBƒJƒ‹‚Ì•¶ŽšE‚‚³
  def damage(value, critical)
    dispose_damage
    if value.is_a?(Numeric)
      damage_string = value.abs.to_s
    else
      damage_string = value.to_s
    end
    if value.is_a?(Numeric)
      damage_string = value.abs.to_s
    else
      damage_string = value.to_s
    end
    if value.is_a?(Numeric)
      if value >= 0
        if critical
          d_bitmap = draw_damage(value, 1)
        else
          d_bitmap = draw_damage(value, 0)
        end
      else
        d_bitmap = draw_damage(value, 2)
      end
    else
      d_bitmap = draw_damage(value, 3)
    end
    @_damage_sprite = ::Sprite.new
    @_damage_sprite.bitmap = d_bitmap
    @_damage_sprite.ox = d_bitmap.width / 2
    @_damage_sprite.oy = d_bitmap.height / 2
    @_damage_sprite.x = self.x + self.viewport.rect.x
    @_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
    @_damage_sprite.z = 3000
    @_damage_duration = 40
  end
  def draw_damage(value, element)
    width = 0
    if value.is_a?(Numeric)
      value = value.abs
      fig = value.to_s.size - 1
      file = RPG::Cache.numeric("num")
      d_width = WIDTH * fig + file.rect.width / 10
      if element == 1
        critical = RPG::Cache.numeric("critical")
        d_width = [d_width, critical.rect.width].max
        d_bitmap = Bitmap.new(d_width, HEIGHT + file.rect.height / 3)
        d_x = (d_width - critical.rect.width) / 2
        d_bitmap.blt(d_x, 0, critical, critical.rect)
      else
        d_bitmap = Bitmap.new(d_width, HEIGHT + file.rect.height / 3)
      end
      d_x = ((d_width) - (WIDTH * fig + file.rect.width / 10)) / 2
      while fig >= 0
        d_bitmap.blt(d_x, HEIGHT, file, Rect.new((value / (10 ** fig)) *
          file.rect.width / 10, element * file.rect.height / 3,
          file.rect.width / 10, file.rect.height / 3))
        d_x += WIDTH
        value %= 10 ** fig
        fig -= 1
      end
    else
      case value
      when ""
        return Bitmap.new(1, 1)
      when "Miss"
        file = RPG::Cache.numeric("miss").dup
      else
        file = RPG::Cache.numeric(value).dup
      end
      d_bitmap = file
    end
    return d_bitmap
  end
end
module Cache
  def self.numeric(filename)
    self.load_bitmap("Graphics/String/", filename)
  end
end
end

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/  ◆防御時回復 - KGC_GuardRecover◆
#_/----------------------------------------------------------------------------
#_/ 防御時にHP/SPを回復する処理を追加します。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★ カスタマイズ項目 ★
#==============================================================================

class Scene_Battle
# ◆HP回復割合(%)
RECOVER_HP_RATE = 5
# ◆SP回復割合(%)
RECOVER_SP_RATE = 5
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆�
��☆★☆★☆★☆★☆★☆★

$imported = {} if $imported == nil
$imported["GuardRecover"] = true

#==============================================================================
# ■ Scene_Battle (分割定義 4)
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# ● 基本アクション 結果作成
#--------------------------------------------------------------------------
alias make_basic_action_result_KGC_GuardRecover make_basic_action_result
def make_basic_action_result
  # 元の処理を実行
  make_basic_action_result_KGC_GuardRecover

  # 行動が防御の場合
  if @active_battler.current_action.kind == 0 &&
      @active_battler.current_action.basic == 1
    # 回復量計算
    recover_hp = @active_battler.maxhp * RECOVER_HP_RATE / 100
    recover_sp = @active_battler.maxsp * RECOVER_SP_RATE / 100
    if recover_hp > 0
      @active_battler.damage = -recover_hp
    end
    if recover_sp > 0
      if $imported["SPDamage"]
        @active_battler.sp_damage = -recover_sp
      else
        @active_battler.damage = "#{$data_system.words.sp}+ #{recover_sp}"
      end
    end
    @active_battler.hp += recover_hp
    @active_battler.sp += recover_sp
    # 回復値を表示
    @target_battlers |= [@active_battler]
  end
end
end




Special thanks:


- CA's very own SephirothSpawn, for his Enemy HP Bars script.
- The Japanese scripters Cogwheel and KGC, for outstanding work on their respective scripts.
- RMXP.ORG's Maki, for his New_Battle script which I relentlessly built off of.
- XRXS for his work on the ATB part.
- Fukuyama, for his Battle End Recovery script.
- Everyone else whose name may have slipped my mind, and I forgot to credit.
}




Users browsing this thread: