# HP/SP gauge animation indication Ver1.03
# 07/01/11
# Distribution original support URL
# http://members.jcom.home.ne.jp/cogwheel/
#==============================================================================
# ** 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
def now_exp
return @exp - @exp_list[@level]
end
def next_exp
return (@exp_list[@level+1] > 0 ?
@exp_list[@level+1] - @exp_list[@level] : 0)
end
end
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
# This class is for all in-game windows.
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# * Object Initialization
# x : window x-coordinate
# y : window y-coordinate
# width : window width
# height : window height
#--------------------------------------------------------------------------
alias :initialize_gauge :initialize
def initialize(x, y, width, height)
initialize_gauge(x, y, width, height)
# Initialize HP and SP gauge values
@hp_gauge = {}
@sp_gauge = {}
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
alias :dispose_gauge :dispose
def dispose
# ƒQ[ƒW,Ìíœ
gauge_delete
# ƒIƒŠƒWƒiƒ‹,̉ð•úˆ--
dispose_gauge
end
#--------------------------------------------------------------------------
# * Gauge Delete
#--------------------------------------------------------------------------
def gauge_delete
# HP ƒQ[ƒW,ÌÁ‹Ž
for gauge in @hp_gauge.values
gauge[0].bitmap.dispose
gauge[0].dispose
end
# SP ƒQ[ƒW,ÌXV
for gauge in @sp_gauge.values
gauge[0].bitmap.dispose
gauge[0].dispose
end
@hp_gauge = {}
@sp_gauge = {}
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
alias :update_gauge :update
def update
update_gauge
# HP ƒQ[ƒW,ÌXV
for gauge in @hp_gauge.values
gauge_refresh(gauge, 0)
end
# SP ƒQ[ƒW,ÌXV
for gauge in @sp_gauge.values
gauge_refresh(gauge, 1)
end
end
#--------------------------------------------------------------------------
# * Draw HP Gauge
#--------------------------------------------------------------------------
# Modification of the original Draw HP process
alias :draw_actor_hp_hpsp :draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
# ‰•`‰æ,Ìê‡
if @hp_gauge[actor] == nil
# ƒQ[ƒW,
height = 10
# FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
# color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(64, 0, 0, 192)
color4 = Color.new(0, 0, 0, 192)
# ‹óƒQ[ƒW,Ì•`‰æ
@hp_frame = gauge_rect(width, height, color1, color2, color3, color4)
sprite = Sprite.new
sprite.bitmap = Bitmap.new(width, height)
sprite.x = self.x + x + 16
sprite.y = self.y + y + 42 - height
sprite.z = self.z + 1
count = rand(400)
# •Ï"rate,É Œ»Ý,ÌHP/MHP,ð'ã"ü
if actor.maxhp != 0
rate = ((width - 4) * actor.hp.to_f / actor.maxhp).ceil
else
rate = width - 4
end
# ˆÊ'u"™î•ñ,Ì‹L‰¯
@hp_gauge[actor] = [sprite, actor, rate, count, x, y - height]
# ƒQ[ƒW•`‰æ
gauge_refresh(@hp_gauge[actor], 0)
# ƒ^[ƒQƒbƒgƒEƒBƒ"ƒhƒE,Ìê‡A‰Šúó'Ô,Í"ñ•\Ž¦
@hp_gauge[actor][0].visible = false if self.is_a?(Window_Target)
end
# •Ï"rate,É Œ»Ý,ÌHP/MHP,ð'ã"ü
if actor.maxhp != 0
rate = ((width - 4) * actor.hp.to_f / actor.maxhp).ceil
else
rate = width - 4
end
@hp_gauge[actor][2] = rate
# ƒIƒŠƒWƒiƒ‹,ÌHP•`‰æˆ--,ðŒÄ,Ño,µ
draw_actor_hp_hpsp(actor, x, y, width)
end
#--------------------------------------------------------------------------
# * Draw SP Gauge
#--------------------------------------------------------------------------
# Modification of the original Draw SP process
alias :draw_actor_sp_hpsp :draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
# ‰•`‰æ,Ìê‡
if @sp_gauge[actor] == nil
# ƒQ[ƒW,
height = 10
# FÝ'èBcolor1:ŠO˜gCcolor2:'†˜g
# color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 64, 64, 192)
color4 = Color.new(0, 0, 0, 192)
# ‹óƒQ[ƒW,Ì•`‰æ
@sp_frame = gauge_rect(width, height, color1, color2, color3, color4)
sprite = Sprite.new
sprite.bitmap = Bitmap.new(width, height)
sprite.x = self.x + x + 16
sprite.y = self.y + y + 42 - height
sprite.z = self.z + 1
count = rand(400)
# •Ï"rate,É Œ»Ý,ÌHP/MHP,ð'ã"ü
if actor.maxsp != 0
rate = ((width - 4) * actor.sp.to_f / actor.maxsp).ceil
else
rate = width - 4
end
# ˆÊ'u"™î•ñ,Ì‹L‰¯
@sp_gauge[actor] = [sprite, actor, rate, count, x, y - height]
# ƒQ[ƒW•`‰æ
gauge_refresh(@sp_gauge[actor], 1)
# ƒ^[ƒQƒbƒgƒEƒBƒ"ƒhƒE,Ìê‡A‰Šúó'Ô,Í"ñ•\Ž¦
@sp_gauge[actor][0].visible = false if self.is_a?(Window_Target)
end
# •Ï"rate,É Œ»Ý,ÌHP/MHP,ð'ã"ü
if actor.maxsp != 0
rate = ((width - 4) * actor.sp.to_f / actor.maxsp).ceil
else
rate = width - 4
end
@sp_gauge[actor][2] = rate
# ƒIƒŠƒWƒiƒ‹,ÌHP•`‰æˆ--,ðŒÄ,Ño,µ
draw_actor_sp_hpsp(actor, x, y, width)
end
#--------------------------------------------------------------------------
# * Drawing of gauge
#--------------------------------------------------------------------------
def gauge_rect(width, height, color1, color2, color3, color4)
bitmap = Bitmap.new(width, height)
# ˜g•`‰æ
bitmap.fill_rect(0, 0, width, height, color1)
bitmap.fill_rect(1, 1, width - 2, height - 2, color2)
# ‹óƒQ[ƒW,Ì•`‰æ
bitmap.gradation_rect(2, 2, width-4, height-4, color3, color4, 1)
return bitmap
end
#--------------------------------------------------------------------------
# œ ŽÀƒQ[ƒW,ÌXV
#--------------------------------------------------------------------------
def gauge_refresh(gauge, type)
# ƒ^ƒCƒv,É,æ,蕪Šò
case type
when 0 # HPƒQ[ƒW,Ìê‡
graphic = RPG::Cache.system("Gauge_HP")
rate = gauge[2] * 100 / (gauge[0].bitmap.width - 4)
point = (rate < 50 ? 8 : 0) + (rate < 25 ? 8 : 0)
frame = @hp_frame
when 1 # SPƒQ[ƒW,Ìê‡
graphic = RPG::Cache.system("Gauge_SP")
rate = gauge[2] * 100 / (gauge[0].bitmap.width - 4)
point = (rate < 50 ? 8 : 0) + (rate < 25 ? 8 : 0)
frame = @sp_frame
end
# ƒJƒEƒ"ƒg,ÌXV
gauge[3] = (gauge[3] - 2) % 400
# ‹óƒQ[ƒW,Ì,Ì•`‰æ
gauge[0].bitmap.fill_rect(0, 0, gauge[0].bitmap.width,
gauge[0].bitmap.height, Color.new(0, 0, 0, 0))
gauge[0].bitmap.blt(0, 0, frame, frame.rect)
# ƒQ[ƒW,Ì'†g,ð•`‰æ‰Â"\,Èê‡
if gauge[2] > 0
# ŽÀƒQ[ƒW,Ì•`‰æ
gauge[0].bitmap.blt(2, 2, graphic,
Rect.new(gauge[3], point, gauge[2], gauge[0].bitmap.height - 4), 192)
gauge[0].bitmap.fill_rect(3, 3, gauge[2] - 2,
gauge[0].bitmap.height - 6,Color.new(0, 0, 0, 0))
gauge[0].bitmap.blt(3, 3, graphic,
Rect.new(gauge[3]+1,point+1,gauge[2]-2,gauge[0].bitmap.height- 6), 128)
end
# ƒQ[ƒWÀ•W,ÌXV
gauge[0].x = [self.x - self.ox + gauge[4] + 16, self.x + 16].max
gauge[0].y = [self.y - self.oy + gauge[5] + 42, self.y + 16].max
gauge[0].src_rect = Rect.new([self.ox - gauge[4], 0].max,
[self.oy - gauge[5] - 26, 0].max,
[self.ox + self.width - gauge[4] - 32, gauge[0].bitmap.width].min,
[self.oy + self.height - gauge[5] - 32, gauge[0].bitmap.height].min)
gauge[0].visible = self.visible
end
#--------------------------------------------------------------------------
# Set X-position for gauge
#--------------------------------------------------------------------------
def x=(new_x)
super(new_x)
if @hp_gauge != nil
# HP ƒQ[ƒW,ÌXV
for gauge in @hp_gauge.values + @sp_gauge.values
gauge[0].x = self.x + gauge[4] + 16
end
end
end
#--------------------------------------------------------------------------
# Set Y-position for gauge
#--------------------------------------------------------------------------
def y=(new_y)
super(new_y)
if @hp_gauge != nil
# HP ƒQ[ƒW,ÌXV
for gauge in @hp_gauge.values + @sp_gauge.values
gauge[0].y = self.y + gauge[5] + 42
end
end
end
#--------------------------------------------------------------------------
# Set Z-depth for gauge
#--------------------------------------------------------------------------
def z=(new_z)
super(new_z)
if @hp_gauge != nil
# HP ƒQ[ƒW,ÌXV
for gauge in @hp_gauge.values + @sp_gauge.values
gauge[0].z = self.z + 1
end
end
end
end
#==============================================================================
# ** Window_Help
#------------------------------------------------------------------------------
# This window shows skill and item explanations along with actor status.
#==============================================================================
class Window_Help < Window_Base
#--------------------------------------------------------------------------
# * Set Text
# text : text string displayed in window
# align : alignment (0..flush left, 1..center, 2..flush right)
#--------------------------------------------------------------------------
alias :gauge_set_text :set_text
def set_text(text, align = 0)
# ƒeƒLƒXƒg,ƃAƒ‰ƒCƒ"ƒƒ"ƒg,Ì*,È,*,Æ,àˆê•û,ª'O‰ñ,ƈá,Á,Ä,¢,éê‡
if text != @text or align != @align
# ƒQ[ƒW,Ìíœ
gauge_delete
# ƒIƒŠƒWƒiƒ‹,̈--
gauge_set_text(text, align)
end
end
#--------------------------------------------------------------------------
# * Set Actor
# actor : status displaying actor
#--------------------------------------------------------------------------
alias :gauge_set_actor :set_actor
def set_actor(actor)
if actor != @actor
# ƒQ[ƒW,Ìíœ
gauge_delete
# ƒIƒŠƒWƒiƒ‹,̈--
gauge_set_actor(actor)
end
end
#--------------------------------------------------------------------------
# * Set Enemy
# enemy : name and status displaying enemy
#--------------------------------------------------------------------------
alias :gauge_set_enemy :set_enemy
def set_enemy(enemy)
# ƒQ[ƒW,Ìíœ
gauge_delete
# ƒIƒŠƒWƒiƒ‹,̈--
gauge_set_enemy(enemy)
end
end
#==============================================================================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
# This class brings together battle screen sprites. It's used within
# the Scene_Battle class.
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
alias :initialize_gauge :initialize
def initialize
initialize_gauge
@viewport2.z = 100
end
end
#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
# New routine added to the Bitmap class.
#==============================================================================
class Bitmap
#--------------------------------------------------------------------------
# * Rectangle Gradation Indicator
# color1: Start color
# color2: Ending color
# align: 0: On side gradation
# 1: Vertically gradation
# 2: The gradation (intense concerning slantedly heavily note)
#--------------------------------------------------------------------------
def gradation_rect(x, y, width, height, color1, color2, align = 0)
if align == 0
for i in x...x + width
red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
green = color1.green +
(color2.green - color1.green) * (i - x) / (width - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - x) / (width - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - x) / (width - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(i, y, 1, height, color)
end
elsif align == 1
for i in y...y + height
red = color1.red +
(color2.red - color1.red) * (i - y) / (height - 1)
green = color1.green +
(color2.green - color1.green) * (i - y) / (height - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - y) / (height - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - y) / (height - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(x, i, width, 1, color)
end
elsif align == 2
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
elsif align == 3
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
end
end
end
#==============================================================================
# ** Sprite
#------------------------------------------------------------------------------
# Class for sprites added to various effect handling used within RPGXP
#==============================================================================
module RPG
class Sprite < ::Sprite
def damage(value, critical)
dispose_damage
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
bitmap = Bitmap.new(160, 48)
bitmap.font.name = "Arial Black"
bitmap.font.size = 32
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
if value.is_a?(Numeric) and value < 0
bitmap.font.color.set(176, 255, 144)
else
bitmap.font.color.set(255, 255, 255)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
bitmap.font.color.set(255, 255, 255)
bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
end
@_damage_sprite = ::Sprite.new
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80 + self.viewport.ox
@_damage_sprite.oy = 20 + self.viewport.oy
@_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 animation(animation, hit)
dispose_animation
@_animation = animation
return if @_animation == nil
@_animation_hit = hit
@_animation_duration = @_animation.frame_max
animation_name = @_animation.animation_name
animation_hue = @_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_animation_sprites = []
if @_animation.position != 3 or not @@_animations.include?(animation)
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_animation_sprites.push(sprite)
end
unless @@_animations.include?(animation)
@@_animations.push(animation)
end
end
update_animation
end
def loop_animation(animation)
return if animation == @_loop_animation
dispose_loop_animation
@_loop_animation = animation
return if @_loop_animation == nil
@_loop_animation_index = 0
animation_name = @_loop_animation.animation_name
animation_hue = @_loop_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_loop_animation_sprites = []
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_loop_animation_sprites.push(sprite)
end
update_loop_animation
end
def animation_set_sprites(sprites, cell_data, position)
for i in 0..15
sprite = sprites
pattern = cell_data[i, 0]
if sprite == nil or pattern == nil or pattern == -1
sprite.visible = false if sprite != nil
next
end
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
if position == 3
if self.viewport != nil
sprite.x = self.viewport.rect.width / 2
sprite.y = self.viewport.rect.height - 160
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2
sprite.y = self.y + self.viewport.rect.y -
self.oy + self.src_rect.height / 2
sprite.y -= self.src_rect.height / 4 if position == 0
sprite.y += self.src_rect.height / 4 if position == 2
end
sprite.x += cell_data[i, 1]
sprite.y += cell_data[i, 2]
sprite.z = 2000
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
sprite.blend_type = cell_data[i, 7]
end
end
end
end
#==============================================================================
# ** RPG
#------------------------------------------------------------------------------
# A module containing RPGXP's data structures and more.
#==============================================================================
module RPG
#============================================================================
# ** Cache
#----------------------------------------------------------------------------
# A module that loads each of RPGXP's graphic formats, creates a Bitmap
# object, and retains it.
#============================================================================
module Cache
def self.system(filename)
self.load_bitmap("Graphics/Pictures/", filename)
end
end
end