Catunazo de Script

#_______________________________________________________________________________
# MOG - Active Hud VX 1.2
#_______________________________________________________________________________
# By Moghunter
# [Tienes que estar registrado y conectado para ver este vínculo]
#_______________________________________________________________________________
# - Apresenta o status do herói no mapa.
# (HP,SP,Condição,Exp,level) em imagens.
#
# ARQUIVOS NECESSÁRIOS
#
# Hud_Exp_Meter.png
# Hud_Exp_Number
# Hud_Face
# Hud_HP_Meter
# Hud_HP_Number
# Hud_Layout
# Hud_SP_Meter
# Hud_SP_Number
#
# Deixe as imagens na pasta System
#
# FACES ANIMADAS
# É preciso ter uma imagem com o nome. " Hud_Face.png "
# A imagem deve conter 5 faces um do lado do outro na
# seguinte ordem.
# 1 - Normal 2 - Alegre 3 - triste 4 - Ação 5 - Cansado.
#
# MEDIDORES ANIMADOS
# Crie uma imagem em gradiente e crie um outro arquivo imagem
# com o tamanho em largura 3 vezes maior que a imagem original.
# Agora coloque neste arquivo 3 imagens originais um do lado
# do outro mas com a direção oposta a da imagem anterior.
# Esse será seu medidor em gradiente animado.
#_______________________________________________________________________________
# Histórico
# 08 / 12 / 2010 - V1.1 Melhor codificação e compatibilidade.
#_______________________________________________________________________________
module MOG
#Posição geral da HUD
HUD = [0,330]
#Posição do Medidor de HP
HP_METER = [73,42]
#Posição do numero de HP
HP_NUMBER = [95,30]
#Posição do Medidor de SP
SP_METER = [33,64]
#Posição do numero de SP
SP_NUMBER = [55,53]
#Posição do medidor de EXP
EXP_METER = [60,26]
#Posição do Level.
EXP_NUMBER = [60,5]
#Posição do layout
LAYOUT = [5,10]
#Posição da face
FACE = [5,10]
#Posição das condições
STATES = [150,50]
#Ativar posição das condições em relação ao personagem?
STATES_POS_CHARACTER = false
#Apresenta as condições com efeito levitação.
FLOAT_STATES = true
#Definição da % quando o HP está baixo. Isso influência na
#cor do HP e SP
LOWHP = 30
#Switch que desativa a Hud
DISABLE_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

#==============================================================================
# Game_Temp
#==============================================================================
class Game_Temp
attr_accessor :hud_face_type
attr_accessor :hud_face_time
attr_accessor :hud_face_time2
attr_accessor :hud_face_refresh
alias active_hud_initialize initialize
def initialize
active_hud_initialize
@hud_face_type = 0
@hud_face_time = 0
@hud_face_time2 = 0
@hud_face_refresh = false
end
end
#==============================================================================
# Active_Hud
#==============================================================================
class Active_Hud < Sprite
include MOG
#--------------------------------------------------------------------------
# * Initialize
#--------------------------------------------------------------------------
def initialize(viewport)
super(viewport)
@actor = $game_party.members[0]
return if @actor == nil
create_layout
create_state
create_hp
create_sp
create_level
create_face
update_visible
end

#--------------------------------------------------------------------------
# * create_layout
#--------------------------------------------------------------------------
def create_layout
@layout_image = Cache.system("Hud_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 = 150
@layout_sprite.x = HUD[0] + LAYOUT[0]
@layout_sprite.y = HUD[1] + LAYOUT[1]
end

#--------------------------------------------------------------------------
# * create_face
#--------------------------------------------------------------------------
def create_face
@face_image = Cache.system("Hud_Face")
@face_bitmap = Bitmap.new(@face_image.width,@face_image.height)
@face_sprite = Sprite.new
@face_sprite.bitmap = @face_bitmap
@face_cw = @face_bitmap.width / 5
@face_ch = @face_bitmap.height
@face_src_rect_back = Rect.new(@face_cw * $game_temp.hud_face_type, 0,@face_cw , @face_ch)
@face_bitmap.blt(0,0, @face_image, @face_src_rect_back)
@face_sprite.z = 153
@face_sprite.x = HUD[0] + FACE[0]
@face_sprite.y = HUD[1] + FACE[1]
if @actor.hp < @actor.maxhp * @low_hp / 100
$game_temp.hud_face_type = 4
else
$game_temp.hud_face_type = 0
end
$game_temp.hud_face_time = 10
end

#--------------------------------------------------------------------------
# * create_state
#--------------------------------------------------------------------------
def create_state
@states_max = 0
@states = Sprite.new
@states.bitmap = Bitmap.new(104,24)
@states_x = @actor.states.size
@states_y = 0
@states_f = false
@states_max = 0
for i in @actor.states
unless @states_max > 3
icon = Cache.system("Iconset")
icon_index = i.icon_index
rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
@states.bitmap.blt(24 * @states_max, 0, icon, rect)
@states_max += 1
end
end
if STATES_POS_CHARACTER == true
@states.x = 5 -(13 * @states_x) + $game_player.screen_x
@states.y = @states_y + $game_player.screen_y
else
@states.x = HUD[0] + STATES[0]
@states.y = @states_y + HUD[1] + STATES[1]
end
@states.z = 153
end

#--------------------------------------------------------------------------
# * create_hp
#--------------------------------------------------------------------------
def create_hp
@low_hp = LOWHP
@hp = @actor.hp
@hp_flow = 0
@hp_damage_flow = 0
@hp_old = @actor.hp
@hp_ref = @hp_old
@hp_refresh = false
@hp_number_image = Cache.system("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 = 153
@hp_number_sprite.x = HUD[0] + HP_NUMBER[0]
@hp_number_sprite.y = HUD[1] + HP_NUMBER[1]
@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 [Tienes que estar registrado y conectado para ver este vínculo] - 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
#Number HP -----
@hp_image = Cache.system("Hud_HP_Meter")
@hp_bitmap = Bitmap.new(@hp_image.width,@hp_image.height)
@hp_range = @hp_image.width / 3
@hp_width = @hp_range * @actor.hp / @actor.maxhp
@hp_height = @hp_image.height / 2
@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 = 152
@hp_sprite.x = HUD[0] + HP_METER[0]
@hp_sprite.y = HUD[1] + HP_METER[1]
hp_flow_update
hp_number_refresh
end

#--------------------------------------------------------------------------
# * create_sp
#--------------------------------------------------------------------------
def create_sp
@low_sp = LOWHP
@sp = @actor.mp
@sp_old = @actor.mp
@sp_ref = @sp_old
@sp_refresh = false
@sp_flow = 0
@sp_damage_flow = 0
@sp_number_image = Cache.system("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 = 153
@sp_number_sprite.x = HUD[0] + SP_NUMBER[0]
@sp_number_sprite.y = HUD[1] + SP_NUMBER[1]
@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.mp.abs.to_s.split(//)
for r in [Tienes que estar registrado y conectado para ver este vínculo] - 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
#Number SP -----
@sp_image = Cache.system("Hud_SP_Meter")
@sp_bitmap = Bitmap.new(@sp_image.width,@sp_image.height)
@sp_range = @sp_image.width / 3
@sp_width = @sp_range * @actor.mp / @actor.maxmp
@sp_height = @sp_image.height / 2
@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 = 152
@sp_sprite.x = HUD[0] + SP_METER[0]
@sp_sprite.y = HUD[1] + SP_METER[1]
sp_flow_update
sp_number_refresh
end

#--------------------------------------------------------------------------
# * create_level
#--------------------------------------------------------------------------
def create_level
@level = @actor.level
@exp = @actor.exp
@level_image = Cache.system("Hud_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 = 152
@level_sprite.x = HUD[0] + EXP_METER[0]
@level_sprite.y = HUD[1] + EXP_METER[1]
# Level Number -----
@level_number_image = Cache.system("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 = 153
@level_number_sprite.x = HUD[0] + EXP_NUMBER[0]
@level_number_sprite.y = HUD[1] + EXP_NUMBER[1]
@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 [Tienes que estar registrado y conectado para ver este vínculo] - 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
end

#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
return if @actor == nil
#Hp Number Dispose
@hp_number_sprite.bitmap.dispose
@hp_number_sprite.dispose
@hp_number_bitmap.dispose
#HP Meter Dispose
@hp_sprite.bitmap.dispose
@hp_sprite.dispose
@hp_bitmap.dispose
#SP Number Dispose
@sp_number_sprite.bitmap.dispose
@sp_number_sprite.dispose
@sp_number_bitmap.dispose
#SP Meter Dispose
@sp_sprite.bitmap.dispose
@sp_sprite.dispose
@sp_bitmap.dispose
#States Dispose
@states.bitmap.dispose
@states.dispose
#Level Meter Dispose
@level_sprite.bitmap.dispose
@level_sprite.dispose
@level_bitmap.dispose
#Level Number Dispose
@level_number_sprite.bitmap.dispose
@level_number_sprite.dispose
@level_number_bitmap.dispose
#Layout Dispose
@layout_sprite.bitmap.dispose
@layout_sprite.dispose
@layout_bitmap.dispose
#Face Dispose
@face_sprite.bitmap.dispose
@face_sprite.dispose
@face_bitmap.dispose
super
end
#--------------------------------------------------------------------------
# * Visible_on
#--------------------------------------------------------------------------
def update_visible
#Visible
if $game_switches[MOG::DISABLE_HUD_SWITCH] == true
@hp_number_sprite.visible = false
@hp_sprite.visible = false
@sp_number_sprite.visible = false
@sp_sprite.visible = false
@states.visible = false
@level_sprite.visible = false
@level_number_sprite.visible = false
@layout_sprite.visible = false
@face_sprite.visible = false
else
@hp_number_sprite.visible = true
@hp_sprite.visible = true
@sp_number_sprite.visible = true
@sp_sprite.visible = true
@states.visible = true
@level_sprite.visible = true
@level_number_sprite.visible = true
@layout_sprite.visible = true
@face_sprite.visible = true
end
end

#--------------------------------------------------------------------------
# * Updade
#--------------------------------------------------------------------------
def update
super
return if @actor == nil
update_visible
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.mp
sp_number_refresh if @sp_refresh == true
level_update if @level != @actor.level
level_up_effect if @level_number_sprite.zoom_x > 1.00
exp_update if @exp != @actor.exp
states_effect if @states.zoom_x > 1.00
face_chance if $game_temp.hud_face_refresh == true or $game_temp.hud_face_time == 1
face_normal if $game_temp.hud_face_time2 == 1
face_effect
states_update
hp_flow_update
sp_flow_update
$game_temp.hud_face_time -= 1 if $game_temp.hud_face_time > 0
$game_temp.hud_face_time2 -= 1 if $game_temp.hud_face_time2 > 0
end

#--------------------------------------------------------------------------
# * face_normal
#--------------------------------------------------------------------------
def face_normal
$game_temp.hud_face_refresh = false
if @actor.hp < @actor.maxhp * @low_hp / 100
$game_temp.hud_face_type = 4
else
$game_temp.hud_face_type = 0
end
$game_temp.hud_face_time2 = 0
@face_sprite.bitmap.clear
@face_src_rect_back = Rect.new(@face_cw * $game_temp.hud_face_type, 0,@face_cw , @face_ch)
@face_bitmap.blt(0,0, @face_image, @face_src_rect_back)
@face_sprite.x = HUD[0] + FACE[0]
end

#--------------------------------------------------------------------------
# * Face Chance
#--------------------------------------------------------------------------
def face_chance
$game_temp.hud_face_refresh = false
@face_sprite.bitmap.clear
@face_src_rect_back = Rect.new(@face_cw * $game_temp.hud_face_type, 0,@face_cw , @face_ch)
@face_bitmap.blt(0,0, @face_image, @face_src_rect_back)
@face_sprite.x = HUD[0] + FACE[0]
end

#--------------------------------------------------------------------------
# * Face Effect
#--------------------------------------------------------------------------
def face_effect
if $game_temp.hud_face_type == 2
@face_sprite.x = HUD[0] + FACE[0] + rand(10)
if $game_temp.hud_face_time == 2
if @actor.hp < @actor.maxhp * @low_hp / 100
$game_temp.hud_face_type = 4
else
$game_temp.hud_face_type = 0
end
end
end
end

#--------------------------------------------------------------------------
# * States_Update
#--------------------------------------------------------------------------
def states_update
if STATES_POS_CHARACTER == true
@states.x = 5 -(13 * @states_x) + $game_player.screen_x
@states.y = @states_y + $game_player.screen_y
else
@states.x = HUD[0] + STATES[0]
@states.y = @states_y + HUD[1] + STATES[1]
end
if FLOAT_STATES == true
if @states_f == false
@states_y += 1
@states_f = true if @states_y > 10
else
@states_y -= 1
@states_f = false if @states_y < -10
end
end
@states.opacity = 155 + rand(100)
if @states_x != @actor.states.size
@states_x = @actor.states.size
@states.bitmap.clear
@states_max = 0
for i in @actor.states
unless @states_max > 3
icon = Cache.system("Iconset")
icon_index = i.icon_index
rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
@states.bitmap.blt(24 * @states_max, 0, icon, rect)
@states_max += 1
end
end
@states.zoom_x = 2
@states.zoom_y = 2
end
end

#--------------------------------------------------------------------------
# * States_Effect
#--------------------------------------------------------------------------
def states_effect
@states.zoom_x -= 0.02
@states.zoom_y -= 0.02
if @states.zoom_x <= 1.00
@states.zoom_x = 1.00
@states.zoom_y = 1.00
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 $game_temp.hud_face_type != 1
$game_temp.hud_face_type = 1
$game_temp.hud_face_refresh = true
@face_sprite.x = HUD[0] + FACE[0]
end
if @hp >= @actor.hp
@hp_old = @actor.hp
@hp = @actor.hp
@hp_ref = 0
if @actor.hp < @actor.maxhp * @low_hp / 100 and
$game_temp.hud_face_type != 4
$game_temp.hud_face_type = 4
$game_temp.hud_face_time = 30
elsif $game_temp.hud_face_type != 0
$game_temp.hud_face_type = 0
$game_temp.hud_face_time = 30
end
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 $game_temp.hud_face_type != 2
$game_temp.hud_face_type = 2
$game_temp.hud_face_refresh = true
end
if @hp <= @actor.hp
@hp_old = @actor.hp
@hp = @actor.hp
@hp_ref = 0
if $game_temp.hud_face_type != 0
$game_temp.hud_face_time = 30
end
end
end
end

#--------------------------------------------------------------------------
# * hp_number_refresh
#--------------------------------------------------------------------------
def hp_number_refresh
@hp_number_sprite.bitmap.clear
@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 [Tienes que estar registrado y conectado para ver este vínculo] - 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---------------------------------
if @hp_width_old != @hp_width
valor = (@hp_width_old - @hp_width) * 3 / 100
valor = 0.5 if valor < 1
@hp_width_old -= valor if @hp_width_old > @hp_width
if @hp_width_old < @hp_width
@hp_width_old = @hp_width
end
@hp_src_rect_old = Rect.new(@hp_flow, @hp_height,@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)

@hp_flow += 5
if @hp_flow >= @hp_image.width - @hp_range
@hp_flow = 0
end
end

#--------------------------------------------------------------------------
# * Sp_number_update
#--------------------------------------------------------------------------
def sp_number_update
@sp_refresh = true
if @sp_old < @actor.mp
@sp_refresh = true
@sp_ref = 5 * (@actor.mp - @sp_old) / 100
@sp_ref = 1 if @sp_ref < 1
@sp += @sp_ref
if $game_temp.hud_face_type != 1
$game_temp.hud_face_type = 1
$game_temp.hud_face_refresh = true
@face_sprite.x = HUD[0] + FACE[0]
end
if @sp >= @actor.mp
@sp_old = @actor.mp
@sp = @actor.mp
@sp_ref = 0
if @actor.hp < @actor.maxmp * @low_hp / 100 and
$game_temp.hud_face_type != 4
$game_temp.hud_face_type = 4
$game_temp.hud_face_time = 30
elsif $game_temp.hud_face_type != 0
$game_temp.hud_face_type = 0
$game_temp.hud_face_time = 30
end
end
elsif @sp_old >= @actor.mp
@sp_ref = 5 * (@sp_old - @actor.mp) / 100
@sp_ref = 1 if @sp_ref < 1
@sp -= @sp_ref
if $game_temp.hud_face_type != 3
$game_temp.hud_face_type = 3
$game_temp.hud_face_refresh = true
end
if @sp <= @actor.mp
@sp_old = @actor.mp
@sp = @actor.mp
@sp_ref = 0
if @actor.hp < @actor.maxhp * @low_hp / 100 and
$game_temp.hud_face_type != 4
$game_temp.hud_face_type = 4
$game_temp.hud_face_time = 35
elsif $game_temp.hud_face_type != 0
$game_temp.hud_face_type = 0
$game_temp.hud_face_time = 35
end
end
end
end

#--------------------------------------------------------------------------
# * sp_number_refresh
#--------------------------------------------------------------------------
def sp_number_refresh
@sp_number_sprite.bitmap.clear
@s = @actor.mp * 100 / @actor.maxmp
@sp_number_text = @sp.abs.to_s.split(//)
for r in [Tienes que estar registrado y conectado para ver este vínculo] - 1
@sp_number_abs = @sp_number_text[r].to_i
if @actor.mp <= @actor.maxmp * @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.mp
end

#--------------------------------------------------------------------------
# * Sp Flow Update
#--------------------------------------------------------------------------
def sp_flow_update
@sp_sprite.bitmap.clear
@sp_width = @sp_range * @actor.mp / @actor.maxmp
#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, @sp_height,@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)
@sp_flow += 5
if @sp_flow >= @sp_image.width - @sp_range
@sp_flow = 0
end
end

#--------------------------------------------------------------------------
# * level_update
#--------------------------------------------------------------------------
def level_update
@level_number_sprite.bitmap.clear
@level_number_text = @actor.level.abs.to_s.split(//)
for r in [Tienes que estar registrado y conectado para ver este vínculo] - 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
@level_number_sprite.zoom_x = 2
@level_number_sprite.zoom_y = 2
end

#--------------------------------------------------------------------------
# * level_update
#--------------------------------------------------------------------------
def level_up_effect
@level_number_sprite.zoom_x -= 0.02
@level_number_sprite.zoom_y -= 0.02
if @level_number_sprite.zoom_x <= 1.00
@level_number_sprite.zoom_x = 1.00
@level_number_sprite.zoom_y = 1.00
end
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

#==============================================================================
# Spriteset_Map
#==============================================================================
class Spriteset_Map
#--------------------------------------------------------------------------
# ● initialize
#--------------------------------------------------------------------------
alias mog_act_hud_initialize initialize
def initialize
create_acthud
mog_act_hud_initialize
end
#--------------------------------------------------------------------------
# ● Acthud Create
#--------------------------------------------------------------------------
def create_acthud
@acthud = Active_Hud.new(@viewport1)
end
#--------------------------------------------------------------------------
# ● dispose
#--------------------------------------------------------------------------
alias mog_acthud_dispose dispose
def dispose
dispose_active_hud
mog_acthud_dispose
end
#--------------------------------------------------------------------------
# ● Dispose Active Hud
#--------------------------------------------------------------------------
def dispose_active_hud
@acthud.dispose
end
#--------------------------------------------------------------------------
# ● update
#--------------------------------------------------------------------------
alias mog_acthud_update update
def update
update_act_hud
mog_acthud_update
end
#--------------------------------------------------------------------------
# ● Update Act Hud
#--------------------------------------------------------------------------
def update_act_hud
@acthud.update
end
end


#-------------------------------------------------------------------------------
$mog_rgssvx_active_hud = true

#==============================================================================
# MOG VX - Combo Display V1.2
#==============================================================================
# By Moghunter
# [Tienes que estar registrado y conectado para ver este vínculo]
#
# ■ Apresenta a quantidade de acertos no alvo e o dano maximo.
# ---------------------------------------------------------------------------
# É necessário ter os arquivos imagens na pasta Graphics/Systems.
# Combo_Damage.png
# Combo_Hud.png
# Combo_Number.png
# ---------------------------------------------------------------------------
module MOG
#Ativar tempo para fazer combo.
TIME_COUNT = true
# Tempo para fazer um combo. (60 = 1s)
COMBO_TIME = 120
# Cancelar a contagem de　Combo caso o inimigo acertar o herói.
ENEMY_CANCEL_COMBO = true
# Posição geral das imagens. X Y
COMBO_POSITION = [10,80]
# Posição do número de HITS. X Y
HIT_POSITION = [15,20]
# Posição do número de dano. X Y
TOTAL_POSITION = [60,-20]
end
#===============================================================================
# ■ Game_Temp
#===============================================================================
class Game_Temp
attr_accessor :combo_hit
attr_accessor :max_damage
attr_accessor :combo_time
#--------------------------------------------------------------------------
# ● initialize
#--------------------------------------------------------------------------
alias mog_combo_display_initialize initialize
def initialize
@combo_hit = 0
@max_damage = 0
@combo_time = 0
mog_combo_display_initialize
end
end
#===============================================================================
# ■ Game_Battler
#===============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# ● execute_damage
#--------------------------------------------------------------------------
alias mog_combo_display_execute_damage execute_damage
def execute_damage(user)
mog_combo_display_execute_damage(user)
if @hp_damage > 0
if user.is_a?(Game_Actor)
$game_temp.combo_hit += 1
$game_temp.max_damage += @hp_damage
$game_temp.combo_time = MOG::COMBO_TIME
else
$game_temp.combo_time = 0 if MOG::ENEMY_CANCEL_COMBO == true
end
end
end
end
#===============================================================================
# Combo_Sprite_Hud
#===============================================================================
class Combo_Sprite_Hud < Sprite
attr_accessor :combo_wait
include MOG
#--------------------------------------------------------------------------
# Initialize
#--------------------------------------------------------------------------
def initialize
super
@combo_wait = false
$game_temp.combo_time = 0
$game_temp.combo_hit = 0
$game_temp.max_damage = 0
@combo_hit_old = 0
@animation_speed = 0
@pos_x = COMBO_POSITION[0]
@pos_x_fix = 0
@pos_y = COMBO_POSITION[1]
create_combo_sprite
create_total_damage_sprite
create_hud_sprite
end
#----------------------------------------------------------------