Quellcode

#===============================================================================
# MOG - C Hud 1.0 (Classic Hud)
#===============================================================================
# By Moghunter
# Atelier-RGSS
#===============================================================================
# Translated by Calvin624
# XAS Tutorials
#===============================================================================
###############################-DESCRIPTION-####################################
#===============================================================================
# Classic HUD System that's easy to configure.
#===============================================================================
#
# Graphics required:
#
# C_Layout
# C_Exp_Meter
# C_Layout
# C_HP_Meter
# C_SP_Meter
# Hud_HP_Number
# Hud_SP_Number
# Hud_Exp_Number
#
# All images must be in the Windowskin folder.
#===============================================================================
 
module MOG
# General position of the HUD
CHUD_X = 0
CHUD_Y = 0
# Position of the layout
C_LAYOUT_X = 0
C_LAYOUT_Y = 0
# Position of the numerical value for HP
C_HP_NUMBER_X = 170
C_HP_NUMBER_Y = 32
# Position of the HP meter
C_HP_METER_X = 146
C_HP_METER_Y = 32
# Position of the numerical value for SP
C_SP_NUMBER_X = 166
C_SP_NUMBER_Y = 52
# Position of the SP meter
C_SP_METER_X = 142
C_SP_METER_Y = 52
# Position of the Level
C_LEVEL_X = 30
C_LEVEL_Y = 22
# Position of the EXP meter
C_LEVEL_METER_X = 150
C_LEVEL_METER_Y = 82
# Position of the Status icons
C_STATES_X = 460
C_STATES_Y = 0
#Deixar a HUD opaco caso o herói estiver em cima da HUD.
C_FADE = true
#Tamanho planejado da hud, isso influência no sensor do FADE.
C_HUD_SIZE_X = 420
C_HUD_SIZE_Y = 64
# Switch to disable the HUD
DISABLE_C_HUD_SWITCH = 5
end
#==============================================================================
# Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# Now Exp
#--------------------------------------------------------------------------
def now_exp
return @exp - @exp_list[@level]
end
#--------------------------------------------------------------------------
# Next Exp
#--------------------------------------------------------------------------
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end
#==============================================================================
# C_Hud
#==============================================================================
class C_Hud < Sprite
include MOG
#--------------------------------------------------------------------------
# * Initialize
#--------------------------------------------------------------------------
def initialize(viewport)
super(viewport)
@actor = $game_party.actors[0]
return if @actor == nil
@low_sp = 30
@low_hp = 30
@hp = @actor.hp
@sp = @actor.sp
@exp = @actor.exp
@level = @actor.level
@hp_old = @actor.hp
@hp_ref = @hp_old
@hp_refresh = false
@sp_old = @actor.sp
@sp_ref = @sp_old
@sp_refresh = false
hud_size_x = C_HUD_SIZE_X
hud_size_y = C_HUD_SIZE_Y
@oc_range_x = hud_size_x + CHUD_X
@oc_range_y = hud_size_y + CHUD_Y
# Layout -------------------------------------------------------------------
@layout_image = RPG::Cache.windowskin("C_Layout")
@layout_bitmap = Bitmap.new(@layout_image.width,@layout_image.height)
@layout_sprite = Sprite.new
@layout_sprite.bitmap = @layout_bitmap
@layout_src_rect_back = Rect.new(0, 0,@layout_image.width, @layout_image.height)
@layout_bitmap.blt(0,0, @layout_image, @layout_src_rect_back)
@layout_sprite.z = 5001
@layout_sprite.x = CHUD_X + C_LAYOUT_X
@layout_sprite.y = CHUD_Y + C_LAYOUT_Y
# HP NUMBER ---------------------------------------------------------------------
@hp_number_image = RPG::Cache.windowskin("Hud_HP_Number")
@hp_number_bitmap = Bitmap.new(@hp_number_image.width,@hp_number_image.height)
@hp_number_sprite = Sprite.new
@hp_number_sprite.bitmap = @hp_number_bitmap
@hp_number_sprite.z = 5003
@hp_number_sprite.x = CHUD_X + C_HP_NUMBER_X
@hp_number_sprite.y = CHUD_Y + C_HP_NUMBER_Y
@im_cw = @hp_number_image.width / 10
@im_ch = @hp_number_image.height / 2
@hp_src_rect = Rect.new(@im_cw,0, @im_cw, @im_ch)
@hp_number_text = @actor.hp.abs.to_s.split(//)
lowhp2 = @actor.maxhp * 30 / 100
if @actor.hp < lowhp2
@health2 = @im_ch
else
@health2 = 0
end
@hp_health = @health2
for r in 0..@hp_number_text.size - 1
@hp_number_abs = @hp_number_text[r].to_i
@hp_src_rect = Rect.new(@im_cw * @hp_number_abs, @hp_health, @im_cw, @im_ch)
@hp_number_bitmap.blt(20 + ((@im_cw - 7) * r), 0, @hp_number_image, @hp_src_rect)
end
#HP Meter
@hp_flow = 0
@hp_damage_flow = 0
@hp_image = RPG::Cache.windowskin("C_HP_Meter")
@hp_bitmap = Bitmap.new(@hp_image.width,@hp_image.height)
@hp_range = @hp_image.width
@hp_width = @hp_range * @actor.hp / @actor.maxhp
@hp_height = @hp_image.height
@hp_width_old = @hp_width
@hp_src_rect = Rect.new(@hp_range, 0, @hp_width, @hp_height)
@hp_bitmap.blt(0,0, @hp_image, @hp_src_rect)
@hp_sprite = Sprite.new
@hp_sprite.bitmap = @hp_bitmap
@hp_sprite.z = 5002
@hp_sprite.x = CHUD_X + C_HP_METER_X
@hp_sprite.y = CHUD_Y + C_HP_METER_Y
# SP Number ---------------------------------------------------------------------
@sp_number_image = RPG::Cache.windowskin("Hud_SP_Number")
@sp_number_bitmap = Bitmap.new(@sp_number_image.width,@sp_number_image.height)
@sp_number_sprite = Sprite.new
@sp_number_sprite.bitmap = @sp_number_bitmap
@sp_number_sprite.z = 5003
@sp_number_sprite.x = CHUD_X + C_SP_NUMBER_X
@sp_number_sprite.y = CHUD_Y + C_SP_NUMBER_Y
@sp_im_cw = @sp_number_image.width / 10
@sp_im_ch = @sp_number_image.height / 2
@sp_src_rect = Rect.new(@sp_im_cw,0, @sp_im_cw, @sp_im_ch)
@sp_number_text = @actor.sp.abs.to_s.split(//)
for r in 0..@sp_number_text.size - 1
@sp_number_abs = @sp_number_text[r].to_i
@sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, 0, @sp_im_cw, @sp_im_ch)
@sp_number_bitmap.blt(20 + ((@sp_im_cw - 7) * r), 0, @sp_number_image, @sp_src_rect)
end
@sp_flow = 0
@sp_damage_flow = 0
@sp_image = RPG::Cache.windowskin("C_SP_Meter")
@sp_bitmap = Bitmap.new(@sp_image.width,@sp_image.height)
@sp_range = @sp_image.width
@sp_width = @sp_range * @actor.sp / @actor.maxsp
@sp_height = @sp_image.height
@sp_width_old = @sp_width
@sp_src_rect = Rect.new(@sp_range, 0, @sp_width, @sp_height)
@sp_bitmap.blt(0,0, @sp_image, @sp_src_rect)
@sp_sprite = Sprite.new
@sp_sprite.bitmap = @sp_bitmap
@sp_sprite.z = 5002
@sp_sprite.x = CHUD_X + C_SP_METER_X
@sp_sprite.y = CHUD_Y + C_SP_METER_Y
# Level Number ---------------------------------------------------------------------
@level_number_image = RPG::Cache.windowskin("Hud_Exp_Number")
@level_number_bitmap = Bitmap.new(@level_number_image.width,@level_number_image.height)
@level_number_sprite = Sprite.new
@level_number_sprite.bitmap = @level_number_bitmap
@level_number_sprite.z = 5003
@level_number_sprite.x = CHUD_X + C_LEVEL_X
@level_number_sprite.y = CHUD_Y + C_LEVEL_Y
@level_im_cw = @level_number_image.width / 10
@level_im_ch = @level_number_image.height
@level_number_text = @actor.level.abs.to_s.split(//)
for r in 0..@level_number_text.size - 1
@level_number_abs = @level_number_text[r].to_i
@level_src_rect = Rect.new(@level_im_cw * @level_number_abs, 0, @level_im_cw, @level_im_ch)
@level_number_bitmap.blt(13 + ((@level_im_cw - 12) * r), 0, @level_number_image, @level_src_rect)
end
# Level Meter ---------------------------------------------------------------------
@level_image = RPG::Cache.windowskin("C_Exp_Meter")
@level_bitmap = Bitmap.new(@level_image.width,@level_image.height)
@level_sprite = Sprite.new
if @actor.next_exp != 0
rate = @actor.now_exp.to_f / @actor.next_exp
else
rate = 1
end
if @actor.level < 99
@level_cw = @level_image.width * rate
else
@level_cw = @level_image.width
end
@level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
@level_bitmap.blt(0,0, @level_image, @level_src_rect_back)
@level_sprite.bitmap = @level_bitmap
@level_sprite.z = 5007
@level_sprite.x = CHUD_X + C_LEVEL_METER_X
@level_sprite.y = CHUD_Y + C_LEVEL_METER_Y
# States -------------------------------------------------------------------
@states_max = 0
@states = Sprite.new
@states.bitmap = Bitmap.new(156,24)
@states_x = @actor.states.size
@states_y = 0
@states_f = false
sta = []
for i in @actor.states
unless @states_max > 5
sta.push($data_states.name)
image = RPG::Cache.icon(sta[@states_max])
cw = image.width
ch = image.height
@states.bitmap.blt(26 * @states_max, 0, image, Rect.new(0, 0, cw, ch))
@states_max += 1
end
end
@states.x = CHUD_X + C_STATES_X
@states.y = CHUD_Y + C_STATES_Y
@states.z = 5003
hud_visible_update
sp_flow_update
sp_number_refresh
hp_flow_update
hp_number_refresh
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
return if @actor == nil
#Layout Dispose
@layout_sprite.bitmap.dispose
@layout_sprite.bitmap = nil
@layout_sprite.dispose
@layout_sprite = nil
@layout_bitmap.dispose
@layout_bitmap = nil
#Hp Number Dispose
@hp_number_sprite.bitmap.dispose
@hp_number_sprite.bitmap = nil
@hp_number_sprite.dispose
@hp_number_sprite = nil
@hp_number_bitmap.dispose
@hp_number_bitmap = nil
#HP Meter Dispose
@hp_sprite.bitmap.dispose
@hp_sprite.bitmap = nil
@hp_sprite.dispose
@hp_sprite = nil
@hp_bitmap.dispose
@hp_bitmap = nil
#SP Number Dispose
@sp_number_sprite.bitmap.dispose
@sp_number_sprite.bitmap = nil
@sp_number_sprite.dispose
@sp_number_sprite = nil
@sp_number_bitmap.dispose
@sp_number_bitmap = nil
#SP Meter Dispose
@sp_sprite.bitmap.dispose
@sp_sprite.bitmap = nil
@sp_sprite.dispose
@sp_sprite = nil
@sp_bitmap.dispose
@sp_bitmap = nil
#Level Number Dispose
@level_number_sprite.bitmap.dispose
@level_number_sprite.bitmap = nil
@level_number_sprite.dispose
@level_number_sprite = nil
@level_number_bitmap.dispose
@level_number_bitmap = nil
#Level Meter Dispose
@level_sprite.bitmap.dispose
@level_sprite.bitmap = nil
@level_sprite.dispose
@level_sprite = nil
@level_bitmap.dispose
@level_bitmap = nil
#States Dispose
@states.bitmap.dispose
@states.bitmap = nil
@states.dispose
@states = nil
end
#--------------------------------------------------------------------------
# * Updade
#--------------------------------------------------------------------------
def update
return if @actor == nil
hud_visible_update
hp_number_update if @hp_old != @actor.hp
hp_number_refresh if @hp_refresh == true or @actor.hp == 0
sp_number_update if @sp_old != @actor.sp
sp_number_refresh if @sp_refresh == true
level_update if @level != @actor.level
exp_update if @exp != @actor.exp
hp_flow_update
sp_flow_update
fade_update if C_FADE == true
states_update
end
#--------------------------------------------------------------------------
# fade_update
#--------------------------------------------------------------------------
def fade_update
x = ($game_player.real_x - $game_map.display_x) / 4
y = ($game_player.real_y - $game_map.display_y) / 4
if x < @oc_range_x and x > CHUD_X - 5 and
y > CHUD_Y - 5 and y < @oc_range_y and
@hp_number_sprite.opacity > 120
@hp_number_sprite.opacity -= 10
@hp_sprite.opacity -= 10
@sp_number_sprite.opacity -= 10
@sp_sprite.opacity -= 10
@states.opacity -= 10
@level_sprite.opacity -= 10
@level_number_sprite.opacity -= 10
@layout_sprite.opacity -= 10
elsif @hp_number_sprite.opacity < 255
@hp_number_sprite.opacity += 10
@hp_sprite.opacity += 10
@sp_number_sprite.opacity += 10
@sp_sprite.opacity += 10
@states.opacity += 10
@level_sprite.opacity += 10
@level_number_sprite.opacity += 10
@layout_sprite.opacity += 10
end
end
#--------------------------------------------------------------------------
# * States_Update
#--------------------------------------------------------------------------
def states_update
@states.x = CHUD_X + C_STATES_X
@states.y = CHUD_Y + C_STATES_Y
if @states_x != @actor.states.size
@states_x = @actor.states.size
@states.bitmap.clear
@states_max = 0
sta = []
for i in @actor.states
unless @states_max > 5
sta.push($data_states[i].name)
image = RPG::Cache.icon(sta[@states_max])
cw = image.width
ch = image.height
@states.bitmap.blt(26 * @states_max, 0, image, Rect.new(0, 0, cw, ch))
@states_max += 1
end
end
sta = nil
end
end
#--------------------------------------------------------------------------
# * hud_visible_update
#--------------------------------------------------------------------------
def hud_visible_update
if $game_switches[MOG::DISABLE_C_HUD_SWITCH] == true
@layout_sprite.visible = false
@hp_number_sprite.visible = false
@hp_sprite.visible = false
@sp_number_sprite.visible = false
@sp_sprite.visible = false
@level_number_sprite.visible = false
@states.visible = false
else
@layout_sprite.visible = true
@hp_number_sprite.visible = true
@hp_sprite.visible = true
@sp_number_sprite.visible = true
@sp_sprite.visible = true
@level_number_sprite.visible = true
@states.visible = true
end
end
#--------------------------------------------------------------------------
# * hp_number_update
#--------------------------------------------------------------------------
def hp_number_update
@hp_refresh = true
if @hp_old < @actor.hp
@hp_ref = 5 * (@actor.hp - @hp_old) / 100
@hp_ref = 1 if @hp_ref < 1
@hp += @hp_ref
if @hp >= @actor.hp
@hp_old = @actor.hp
@hp = @actor.hp
@hp_ref = 0
end
elsif @hp_old > @actor.hp
@hp_refresh = true
@hp_ref = 5 * (@hp_old - @actor.hp) / 100
@hp_ref = 1 if @hp_ref < 1
@hp -= @hp_ref
if @hp <= @actor.hp
@hp_old = @actor.hp
@hp = @actor.hp
@hp_ref = 0
end
end
end
#--------------------------------------------------------------------------
# * hp_number_refresh
#--------------------------------------------------------------------------
def hp_number_refresh
@hp_number_sprite.bitmap.clear
@hp = 0 if @actor.hp == 0
@hp_number_text = @hp.abs.to_s.split(//)
lowhp2 = @actor.maxhp * @low_hp / 100
if @actor.hp < lowhp2
@health2 = @im_ch
else
@health2 = 0
end
@hp_health = @health2
for r in 0..@hp_number_text.size - 1
@hp_number_abs = @hp_number_text[r].to_i
@hp_src_rect = Rect.new(@im_cw * @hp_number_abs, @hp_health, @im_cw, @im_ch)
@hp_number_bitmap.blt(20 + ((@im_cw - 7) * r), 0, @hp_number_image, @hp_src_rect)
end
@hp_refresh = false if @hp == @actor.hp
end
#--------------------------------------------------------------------------
# * Hp Flow Update
#--------------------------------------------------------------------------
def hp_flow_update
@hp_sprite.bitmap.clear
@hp_width = @hp_range * @actor.hp / @actor.maxhp
#HP Damage---------------------------------
valor = (@hp_width_old - @hp_width) * 3 / 100
valor = 0.5 if valor < 1
if @hp_width_old != @hp_width
@hp_width_old -= valor if @hp_width_old > @hp_width
@hp_width_old = 0 if @actor.hp == 0
if @hp_width_old < @hp_width
@hp_width_old = @hp_width
end
@hp_src_rect_old = Rect.new(@hp_flow, 0,@hp_width_old, @hp_height)
@hp_bitmap.blt(0,0, @hp_image, @hp_src_rect_old)
end
 
#HP Real------------------------------------
@hp_src_rect = Rect.new(@hp_flow, 0,@hp_width, @hp_height)
@hp_bitmap.blt(0,0, @hp_image, @hp_src_rect)
end
#--------------------------------------------------------------------------
# * Sp_number_update
#--------------------------------------------------------------------------
def sp_number_update
@sp_refresh = true
if @sp_old < @actor.sp
@sp_refresh = true
@sp_ref = 5 * (@actor.sp - @sp_old) / 100
@sp_ref = 1 if @sp_ref < 1
@sp += @sp_ref
if @sp >= @actor.sp
@sp_old = @actor.sp
@sp = @actor.sp
@sp_ref = 0
end
elsif @sp_old >= @actor.sp
@sp_ref = 5 * (@sp_old - @actor.sp) / 100
@sp_ref = 1 if @sp_ref < 1
@sp -= @sp_ref
if @sp <= @actor.sp
@sp_old = @actor.sp
@sp = @actor.sp
@sp_ref = 0
end
end
end
#--------------------------------------------------------------------------
# * sp_number_refresh
#--------------------------------------------------------------------------
def sp_number_refresh
@sp_number_sprite.bitmap.clear
@s = @actor.sp * 100 / @actor.maxsp
@sp_number_text = @sp.abs.to_s.split(//)
for r in 0..@sp_number_text.size - 1
@sp_number_abs = @sp_number_text[r].to_i
if @actor.sp <= @actor.maxsp * @low_sp / 100
@sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, @sp_im_ch, @sp_im_cw, @sp_im_ch)
else
@sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, 0, @sp_im_cw, @sp_im_ch)
end
@sp_number_bitmap.blt(20 + ((@sp_im_cw - 7) * r), 0, @sp_number_image, @sp_src_rect)
end
@sp_refresh = false if @sp == @actor.sp
end
#--------------------------------------------------------------------------
# * Sp Flow Update
#--------------------------------------------------------------------------
def sp_flow_update
@sp_sprite.bitmap.clear
@sp_width = @sp_range * @actor.sp / @actor.maxsp
#SP Damage---------------------------------
if @sp_width_old != @sp_width
valor = (@sp_width_old - @sp_width) * 3 / 100
valor = 0.5 if valor < 1
@sp_width_old -= valor if @sp_width_old > @sp_width
if @sp_width_old < @sp_width
@sp_width_old = @sp_width
end
@sp_src_rect_old = Rect.new(@sp_flow, 0,@sp_width_old, @sp_height)
@sp_bitmap.blt(0,0, @sp_image, @sp_src_rect_old)
end
#SP Real------------------------------------
@sp_src_rect = Rect.new(@sp_flow, 0,@sp_width, @sp_height)
@sp_bitmap.blt(0,0, @sp_image, @sp_src_rect)
end
#--------------------------------------------------------------------------
# * level_update
#--------------------------------------------------------------------------
def level_update
@level_number_sprite.bitmap.clear
@level_number_text = @actor.level.abs.to_s.split(//)
for r in 0..@level_number_text.size - 1
@level_number_abs = @level_number_text[r].to_i
@level_src_rect = Rect.new(@level_im_cw * @level_number_abs, 0, @level_im_cw, @level_im_ch)
@level_number_bitmap.blt(13 + ((@level_im_cw - 12) * r), 0, @level_number_image, @level_src_rect)
end
@level = @actor.level
end
#--------------------------------------------------------------------------
# * exp_update
#--------------------------------------------------------------------------
def exp_update
@level_sprite.bitmap.clear
if @actor.next_exp != 0
rate = @actor.now_exp.to_f / @actor.next_exp
else
rate = 1
end
if @actor.level < 99
@level_cw = @level_image.width * rate
else
@level_cw = @level_image.width
end
@level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
@level_bitmap.blt(0,0, @level_image, @level_src_rect_back)
@exp = @actor.exp
end
 
end
#===============================================================================
# Scene_Map
#===============================================================================
class Scene_Map
alias chud_main main
#--------------------------------------------------------------------------
# Main
#--------------------------------------------------------------------------
def main
@c_viewport = Viewport.new(0, 0, 640, 480)
@c_viewport.z = 9999
@chud = C_Hud.new(@c_viewport)
chud_main
@chud.dispose
@chud = nil
@c_viewport.dispose
@c_viewport = nil
end
#--------------------------------------------------------------------------
# Update
#--------------------------------------------------------------------------
alias chud_update update
def update
chud_update
@chud.update
end
end
 
$mog_rgss_c_hud = true