#_______________________________________________________________________________
# MOG TP System V2.1
#_______________________________________________________________________________
# By Moghunter
# http://www.atelier-rgss.com
#_______________________________________________________________________________
# Troca o custo de SP por TP, ou seja, é possível definir
#que certas habilidades tenham o custo de TP no lugar do SP,
# O sistema é útil quando quisermos, por exemplo, que habilidades
#físicas não gastem SP mas outro parâmetro.
#_______________________________________________________________________________
module MOG
#Definição do nome do TP (Talent Points).
TP_NAME = "SP "
#NOTA - Para mudar o nome do SP basta entrar no banco
#de dados na parte de System e mudar o nome de SP para outro
#nome, por exemplo, MP.
#-------------------------------------------------------------------------------
#Definição de quais habilidades terão o custo de TP.
#
#TP_COST = {A=>B, A=>B, ...}
#
#A = ID of SKILL.
#B = Cost of TP.
TP_COST = {
57=>500, #Cross Cut
58=>12, #Feint Attack
59=>26, #Hurricane
60=>40, #Spiral Blade
61=>7, #Leag Sweep
62=>15, #Beast Slayer
63=>32, #Thunder Pierce
64=>50, #Screw Thrust
65=>6, #Power Break
66=>13, #Mind Break
67=>28, #Aqua Buster
68=>32, #Rolling Axe
73=>10, #Bird Killer
74=>15 #Mute Arrow
}
#-------------------------------------------------------------------------------
#Definição da quantidade inicial de TP.
#(Caso não especificado TP inicial igual a 1)
#
#A=>B
#
#A = ID do personagem.
#B = Quantidade inicial de TP.
INITP = {
1=>1000,
2=>70,
7=>15,
8=>20
}
#-------------------------------------------------------------------------------
#Definição da quantidade de TP ganho ao fazer LV-UP.
#(Caso não especificado TP ganho igual a 1)
#
#A=>B
#
#A = ID do personagem.
#B = Quantidade de TP ganho.
TP_EXP = {
1=>0,
2=>0,
7=>0,
8=>0
}
#-------------------------------------------------------------------------------
#Itens que recuperam o TP.
#A=>B
#
#A = ID do Item
#B = Quantidade de TP recuperado.
ITEM_TP_RECOVER = {
1=>10,
2=>999
}
#-------------------------------------------------------------------------------
end
#===============================================================================
# Game_Actor
#===============================================================================
class Game_Actor < Game_Battler
attr_accessor :tp
attr_accessor :maxtp
#--------------------------------------------------------------------------
# Setup
#--------------------------------------------------------------------------
alias mog45_setup setup
def setup(actor_id)
mog45_setup(actor_id)
@maxtp = 0
@maxtp_plus = 0
@tp_exp = MOG::TP_EXP[actor_id]
ini_tp = MOG::INITP[actor_id]
if ini_tp != nil
@base_tp = ini_tp
else
@base_tp = 0
end
if @tp_exp != nil
tpx = (@tp_exp * @level) - @tp_exp
else
tpx = 1
end
@tp = @base_tp + tpx
end
#--------------------------------------------------------------------------
# maxtp_plus
#--------------------------------------------------------------------------
def maxtp_plus
if @tp_exp != nil and @level > 1
cal = @tp_exp * @level
return @maxtp_plus + cal - @tp_exp
else
return @maxtp_plus
end
end
#--------------------------------------------------------------------------
# maxtp
#--------------------------------------------------------------------------
def maxtp
n = [[@base_tp + maxtp_plus, 1].max, 9999].min
return n
end
#--------------------------------------------------------------------------
# TP
#--------------------------------------------------------------------------
def tp=(tp)
@tp = [[tp, maxtp].min, 0].max
end
end
#===============================================================================
# Game_Battler
#===============================================================================
class Game_Battler
alias mog45_skill_can_use? skill_can_use?
def skill_can_use?(skill_id)
tp_cost = MOG::TP_COST[skill_id]
if tp_cost != nil and self.is_a?(Game_Actor)
if tp_cost > self.tp
return false
end
else
if $data_skills[skill_id].sp_cost > self.sp
return false
end
end
if dead?
return false
end
if $data_skills[skill_id].atk_f == 0 and self.restriction == 1
return false
end
occasion = $data_skills[skill_id].occasion
if $game_temp.in_battle
return (occasion == 0 or occasion == 1)
else
return (occasion == 0 or occasion == 2)
end
return
mog45_skill_can_use?(skill_id)
end
end
#===============================================================================
# Scene_Battle
#===============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
# update_phase4_step5
#--------------------------------------------------------------------------
alias mog45_update_phase4_step5 update_phase4_step5
def update_phase4_step5
mog45_update_phase4_step5
item_tp_recover_id = MOG::ITEM_TP_RECOVER[@item.id]
if @active_battler.is_a?(Game_Actor) and @active_battler.current_action.kind == 2 and @item =! nil
for target_tp in @target_battlers
if target_tp.is_a?(Game_Actor) and item_tp_recover_id != nil
target_tp.tp += item_tp_recover_id
target_tp.damage = MOG::TP_NAME.to_s + item_tp_recover_id.to_s
target_tp.damage_pop = true
end
end
end
end
#--------------------------------------------------------------------------
# make_skill_action_result
#--------------------------------------------------------------------------
alias mog45_make_skill_action_result make_skill_action_result
def make_skill_action_result
@skill = $data_skills[@active_battler.current_action.skill_id]
unless @active_battler.current_action.forcing
unless @active_battler.skill_can_use?(@skill.id)
$game_temp.forcing_battler = nil
@phase4_step = 1
return
end
end
tp_cost = MOG::TP_COST[@skill.id]
if tp_cost != nil and @active_battler.is_a?(Game_Actor)
@active_battler.tp -= tp_cost
else
@active_battler.sp -= @skill.sp_cost
end
@status_window.refresh
@help_window.set_text(@skill.name, 1)
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
@common_event_id = @skill.common_event_id
set_target_battlers(@skill.scope)
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
return
mog45_make_skill_action_result
end
end
#===============================================================================
# Game_Battler
#===============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# item_effect
#--------------------------------------------------------------------------
alias mog45_item_effect item_effect
def item_effect(item)
if $game_temp.in_battle == false
item_tp_recover = MOG::ITEM_TP_RECOVER[item.id]
if item_tp_recover != nil
if self.tp < self.maxtp
self.tp += item_tp_recover
return true
else
return false
end
return false
end
end
mog45_item_effect(item)
end
end
#===============================================================================
# Interpreter
#===============================================================================
class Interpreter
#--------------------------------------------------------------------------
# command_314
#--------------------------------------------------------------------------
alias mog45_command_314 command_314
def command_314
mog45_command_314
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
actor.tp = actor.maxtp
end
return true
end
end
#===============================================================================
# Window_Base
#===============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# draw_actor_tp
#--------------------------------------------------------------------------
def draw_actor_tp(actor, x, y,type)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 32, MOG::TP_NAME)
self.contents.font.color = normal_color
case type
when 0
self.contents.draw_text(x - 40, y, 198, 32, actor.tp.to_s + " / " + actor.maxtp.to_s, 2)
when 1
self.contents.draw_text(x - 70, y, 198, 32, actor.tp.to_s + " / " + actor.maxtp.to_s, 2)
when 2
self.contents.draw_text(x + 40, y, 80, 32, actor.tp.to_s,2)
when 3
self.contents.draw_text(x - 20, y, 150, 32, actor.tp.to_s + " / " + actor.maxtp.to_s, 2)
when 4
self.contents.font.name = "Georgia"
self.contents.draw_text(x - 55, y, 130, 32, actor.tp.to_s, 2)
end
end
#--------------------------------------------------------------------------
# draw_actor_tp2
#--------------------------------------------------------------------------
def draw_actor_tp2(actor, x, y)
self.contents.font.name = "Georgia"
back = RPG::Cache.picture("STBAR_Back")
cw = back.width
ch = back.height
src_rect = Rect.new(0, 0, cw, ch)
self.contents.blt(x + 86, y - ch + 40, back, src_rect)
meter = RPG::Cache.picture("STBAR.png")
cw2 = meter.width * actor.tp / actor.maxtp
ch2 = meter.height
src_rect2 = Rect.new(0, 0, cw2, ch2)
self.contents.blt(x + 86, y - ch + 40, meter, src_rect2)
self.contents.font.color = normal_color
self.contents.draw_text(x - 40, y, 198, 32, MOG::TP_NAME + actor.tp.to_s, 2)
end
end
#===============================================================================
# Window_Help
#===============================================================================
class Window_Help < Window_Base
#--------------------------------------------------------------------------
# set_actor
#--------------------------------------------------------------------------
alias mog45_set_actor set_actor
def set_actor(actor)
if actor != @actor
self.contents.clear
draw_actor_name(actor, 4, 0)
draw_actor_hp(actor, 110, 0)
draw_actor_sp(actor, 460, 0)
draw_actor_tp(actor, 284, 0,0)
@actor = actor
@text = nil
self.visible = true
end
return
mog45_set_actor(actor)
end
end
#===============================================================================
# Window_SkillStatus
#===============================================================================
class Window_SkillStatus < Window_Base
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
alias mog45_refresh refresh
def refresh
self.contents.clear
draw_actor_name(@actor, 4, 0)
draw_actor_hp(@actor, 110, 0)
draw_actor_sp(@actor, 460, 0)
draw_actor_tp(@actor, 284, 0,0)
return
mog45_refresh
end
end
#===============================================================================
# Window_Status
#===============================================================================
class Window_Status < Window_Base
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
alias mog45_refresh refresh
def refresh
mog45_refresh
if $mog_rgss_Scene_Status != nil
draw_actor_tp2(@actor, 435, 250)
else
draw_actor_tp(@actor, 96, 170,0)
end
end
end
#===============================================================================
# Window_BattleStatus
#===============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
alias mog45_refresh refresh
def refresh
self.contents.clear
@item_max = $game_party.actors.size
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
actor_x = i * 160 + 4
draw_actor_name(actor, actor_x, 0)
draw_actor_hp(actor, actor_x, 24, 120)
draw_actor_sp(actor, actor_x, 48, 120)
draw_actor_tp(actor, actor_x, 72,2)
if @level_up_flags[i]
self.contents.font.color = normal_color
self.contents.draw_text(actor_x, 96, 120, 32, "LEVEL UP!")
else
draw_actor_state(actor, actor_x, 96)
end
end
end
end
#===============================================================================
# Window_MenuStatus
#===============================================================================
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
alias mog45_refresh refresh
def refresh
self.contents.clear
mog45_refresh
for i in 0...$game_party.actors.size
x = 64
y = i * 116
actor = $game_party.actors[i]
draw_actor_tp(actor, x + 236, y,1 )
end
end
end
#===============================================================================
# Window_Target
#===============================================================================
class Window_Target < Window_Selectable
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
alias mog45_refresh refresh
def refresh
self.contents.clear
for i in 0...$game_party.actors.size
x = 4
y = i * 116
actor = $game_party.actors[i]
draw_actor_name(actor, x, y)
draw_actor_level(actor, x + 8, y + 32)
draw_actor_state(actor, x + 8, y + 64)
draw_actor_hp(actor, x + 152, y + 0)
draw_actor_tp(actor, x + 152, y + 32,3)
draw_actor_sp(actor, x + 152, y + 64)
end
return
mog45_refresh
end
end
#===============================================================================
# Window_Skill
#===============================================================================
class Window_Skill < Window_Selectable
#--------------------------------------------------------------------------
# draw_item
#--------------------------------------------------------------------------
alias mog45_draw_item draw_item
def draw_item(index)
skill = @data[index]
if @actor.skill_can_use?(skill.id)
self.contents.font.color = normal_color
else
self.contents.font.color = disabled_color
end
x = 4 + index % 2 * (288 + 32)
y = index / 2 * 32
rect = Rect.new(x, y, self.width / @column_max - 32, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
bitmap = RPG::Cache.icon(skill.icon_name)
opacity = self.contents.font.color == normal_color ? 255 : 128
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
tp_cost = MOG::TP_COST[skill.id]
if tp_cost != nil
self.contents.font.color = Color.new(50,250,150,255)
self.contents.draw_text(x + 180, y, 48, 32,MOG::TP_NAME, 2)
self.contents.font.color = Color.new(255,255,255,255)
self.contents.draw_text(x + 232, y, 48, 32,tp_cost.to_s, 2)
else
self.contents.font.color = Color.new(250,150,50,255)
self.contents.draw_text(x + 180, y, 48, 32,$data_system.words.sp, 2)
self.contents.font.color = Color.new(255,255,255,255)
self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
end
return
mog45_draw_item(index)
end
end
#===============================================================================
# Scene_Skill
#===============================================================================
class Scene_Skill
#--------------------------------------------------------------------------
# update_target
#--------------------------------------------------------------------------
alias mog45_update_target update_target
def update_target
if Input.trigger?(Input::C)
unless @actor.skill_can_use?(@skill.id)
$game_system.se_play($data_system.buzzer_se)
return
end
if @target_window.index == -1
used = false
for i in $game_party.actors
used |= i.skill_effect(@actor, @skill)
end
end
if @target_window.index <= -2
target = $game_party.actors[@target_window.index + 10]
used = target.skill_effect(@actor, @skill)
end
if @target_window.index >= 0
target = $game_party.actors[@target_window.index]
used = target.skill_effect(@actor, @skill)
end
if used
$game_system.se_play(@skill.menu_se)
tp_cost = MOG::TP_COST[@skill.id]
if tp_cost != nil
@actor.tp -= tp_cost
else
@actor.sp -= @skill.sp_cost
end
@status_window.refresh
@skill_window.refresh
@target_window.refresh
if $game_party.all_dead?
$scene = Scene_Gameover.new
return
end
if @skill.common_event_id > 0
$game_temp.common_event_id = @skill.common_event_id
$scene = Scene_Map.new
return
end
end
unless used
$game_system.se_play($data_system.buzzer_se)
end
return
end
mog45_update_target
end
end
$mog_rgss_TP_System = true#_______________________________________________________________________________
# MOG - C Hud 1.0 (Classic Hud)
#_______________________________________________________________________________
# By Moghunter
# http://www.atelier-rgss.com
#_______________________________________________________________________________
# Hud estilo clássico.
#
# ARQUIVOS NECESSÁRIOS
#
# C_Layout
# C_Exp_Meter
# C_Layout
# C_HP_Meter
# C_SP_Meter
# Hud_HP_Number
# Hud_SP_Number
# Hud_Exp_Number
#
# Deixe as imagens na pasta Windowskins
#_______________________________________________________________________________
module MOG
#Posição geral da HUD
CHUD_X = 0
CHUD_Y = 0
#Posição do layout
C_LAYOUT_X = 0
C_LAYOUT_Y = 0
#Posição do numero de HP
C_HP_NUMBER_X = -5
C_HP_NUMBER_Y = 12
#Posição do medidor de HP
C_HP_METER_X = 19
C_HP_METER_Y = 17
#Posição do numero de SP
C_SP_NUMBER_X = 100
C_SP_NUMBER_Y = 28
#Posição do medidor de SP
C_SP_METER_X = 19
C_SP_METER_Y = 32
#Posição posição do level
C_LEVEL_X = 3
C_LEVEL_Y = 53
#Posição posição do medidor de exp
C_LEVEL_METER_X = 19
C_LEVEL_METER_Y = 45
#Posição dos ícones de status
C_STATES_X = 180
C_STATES_Y = -2
#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 que desativa a HUD
DISABLE_C_HUD_SWITCH = 50
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[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
@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) / 6
y = ($game_player.real_y - $game_map.display_y) / 6
if x < @oc_range_x and x > CHUD_X - 6 and
y > CHUD_Y - 6 and y < @oc_range_y and
@hp_number_sprite.opacity > 150
@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