#================================================= =============================
# +++ MOG - ADVANCED BATTLE HUD (v1.6) +++
#================================================= =============================
# By Moghunter
#
http://www.atelier-rgss.com/
#================================================= =============================
# Sistema de hud avançado de batalha.
#================================================= =============================
#================================================= =============================
# ● Histórico (Version History)
#================================================= =============================
# v 1.6 - Corrigido o erro quando o MP ou TP maximo é iguál a zero.
# v 1.5 - Corrigido a animação da face quando uma skill tem a função charge.
# v 1.4 - Corrigido o erro de crash randômico. (relativo a dispose de imagem.)
# v 1.3 - Script 100% independente do sistema de AT System.
# - Correção da posição inicial da janela de Fuga.
# - Correção da posição do cursor nos aliados quando a face está
# desabilitada.
# v 1.2 - Corrigido a prioridade das condições.
# v 1.1 - Corrigido o glitch inicial da prioridade da face.
# v 1.0 - Primeiro lançamento.
#================================================= =============================
#================================================= =============================
# ■ - FACE ANIMADAS DOS PERSONAGENS - (Opcional)
#================================================= =============================
# 1 - Grave as imagens das faces dos personagens na pasta.
#
# GRAPHICS/BATTLERS/
#
# 2 - Nomeie a imagem com o mesmo nome do personagem. (EG - Hertor.png)
# 3 - A largura da imagem deverá ser dividido por 5. (A escolha do tamanho
# da face é livre desde que a lagura dividido pela altura seja igual a 5 )
#
#================================================= =============================
#================================================= =============================
# ■ BATTLE HUD SETTING
#================================================= =============================
module MOG_BATTLE_HUD
# Ativar Battlers dos personagens em faces, deixe desativado em caso de haver
# outros scripts que usam battlers dos personagens em seu projeto.
BATTLER_FACE_ENABLE = false
#Definição geral da posição da HUD.
HUD_POSITION = [5,315]
#Definição da posição da face
FACE_POSITION = [60,30]
#Definição da posição do numero de HP.
HP_NUMBER_POSITION = [85,28]
#Definição da posição do medidor de HP.
HP_METER_POSITION = [27,37]
#Definição da posição do numero de MP.
MP_NUMBER_POSITION = [101,46]
#Definição da posição do medidor de MP.
MP_METER_POSITION = [43,55]
#Definição da posição do numero de TP.
TP_NUMBER_POSITION = [85,64]
#Definição da posição do medidor de TP.
TP_METER_POSITION = [27,73]
#Definição da posição das condições
STATES_POSITION = [5,1]
#Definição da posição do comando de batalha.
COMMAND_POSITION = [0,-145]
#Definição da posição do espaço da HUD entre os membros do grupo.
MEMBERS_SPACE = [136,0]
#Definição da prioridade da HUD.
BATTLE_HUD_Z = 50
#Definição da velocidade de animação dos medidores.
METER_FLOW_SPEED = 2
#Ativa o layout mais limpo nas janelas de item e skill.
ITEM_SKILL_WINDOWS_CLEAN_STYLE = true
#Definição da opacidade das janelas.
ITEM_SKILL_WINDOW_OPACITY = 0
end
#================================================= =============================
# ■ CURSOR SETTING
#================================================= =============================
module MOG_BATTLE_CURSOR
#Definição da posição do cursor em relação ao alvo.
CURSOR_POSITION = [-45, -16]
#Definição da posição do nome do alvo.
CURSOR_NAME_POSITION = [-10, 35]
#Ativar efeito deslizar.
CURSOR_SLIDE_EFFECT = true
#Ativar animação de levitação.
CURSOR_FLOAT_EFFECT = true
end
if MOG_BATTLE_HUD::BATTLER_FACE_ENABLE #BATTLER_FACE SYSTEM START
#================================================= =============================
# ■ Game_Actor
#================================================= =============================
class Game_Actor < Game_Battler
attr_accessor :battler_face
attr_accessor :screen_x
attr_accessor :screen_y
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_battle_hud_initialize setup
def setup(actor_id)
mog_battle_hud_initialize(actor_id)
battler_sprite_setup
end
#--------------------------------------------------------------------------
# ● Battler Sprite Setup
#--------------------------------------------------------------------------
def battler_sprite_setup
@battler_face = [0,0,0]
@battler_name = @name
@screen_x = 0
@screen_y = 0
end
#--------------------------------------------------------------------------
# ● Use Sprite?
#--------------------------------------------------------------------------
def use_sprite?
return true
end
#--------------------------------------------------------------------------
# ● Screen Z
#--------------------------------------------------------------------------
def screen_z
return MOG_BATTLE_HUD::BATTLE_HUD_Z + 4
end
#------------------------------------------------------------------------
# ● Screen X
#------------------------------------------------------------------------
def screen_x
return FACE_POSITION[0] + HUD_POSITION[0] + (MEMBERS_SPACE[0] * index)
end
#------------------------------------------------------------------------
# ● Screen Y
#------------------------------------------------------------------------
def screen_y
return FACE_POSITION[1] + HUD_POSITION[1] + (MEMBERS_SPACE[1] * index)
end
end
#================================================= =============================
# ■ Sprite_Battler
#================================================= =============================
class Sprite_Battler < Sprite_Base
include MOG_BATTLE_HUD
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_battle_hud_initialize initialize
def initialize(viewport, battler = nil)
battle_hud_setup
mog_battle_hud_initialize(viewport, battler)
end
#--------------------------------------------------------------------------
# ● Battle Hud Setup
#--------------------------------------------------------------------------
def battle_hud_setup
@old_face_index = 0
end
#--------------------------------------------------------------------------
# ● Dispose
#--------------------------------------------------------------------------
alias mog_battle_hud_dispose dispose
def dispose
mog_battle_hud_dispose
if @f_im != nil
@f_im.dispose
end
end
#--------------------------------------------------------------------------
# ● Update Bitmap
#--------------------------------------------------------------------------
alias mog_battle_hud_update_bitmap update_bitmap
def update_bitmap
if @battler.is_a?(Game_Actor)
create_actor_battler
update_actor_battler
return
end
mog_battle_hud_update_bitmap
end
#--------------------------------------------------------------------------
# ● Create Actor Battler
#--------------------------------------------------------------------------
def create_actor_battler
return if self.bitmap != nil
@f_im = Cache.battler(@battler.battler_name, 0)
@f_cw = @f_im.width / 5
@f_ch = @f_im.height
self.bitmap = Bitmap.new(@f_cw,@f_ch)
x = FACE_POSITION[0] + HUD_POSITION[0] + (MEMBERS_SPACE[0] * @battler.index)
y = FACE_POSITION[1] + HUD_POSITION[1] + (MEMBERS_SPACE[1] * @battler.index)
@org_pos = [x,y]
@battler.battler_face = [0,0,0]
@battler_visible = true
@low_hp = @battler.mhp * 30 / 100
self.z = @battler.screen_z + 100
make_face(true)
end
#--------------------------------------------------------------------------
# ● Face Base Setting
#--------------------------------------------------------------------------
def face_base_setting
self.x = @org_pos[0]
self.y = @org_pos[1]
self.z = @battler.screen_z
self.zoom_x = 1
self.zoom_y = 1
self.mirror = false
end
#--------------------------------------------------------------------------
# ● Check Base Face
#--------------------------------------------------------------------------
def check_base_face(reset)
face_base_setting
return if @battler.battler_face[2] > 0
@battler.battler_face = [0,0,0] if reset and @battler.battler_face[1] != 2
@battler.battler_face[0] = 3 if @battler.hp < @low_hp
@battler.battler_face[0] = 4 if @battler.hp == 0
end
#--------------------------------------------------------------------------
# ● Make Face
#--------------------------------------------------------------------------
def make_face(reset = false)
self.bitmap.clear
check_base_face(reset)
src_rect_back = Rect.new(@f_cw * @battler.battler_face[0], 0, @f_cw, @f_ch)
self.bitmap.blt(0,0, @f_im, src_rect_back)
@old_face_index = @battler.battler_face[0]
end
#--------------------------------------------------------------------------
# ● Update Actor Battler
#--------------------------------------------------------------------------
def update_actor_battler
return if self.bitmap == nil
update_face_effect
update_face_reset_time
update_face_z
make_face if @old_face_index != @battler.battler_face[0]
end
#--------------------------------------------------------------------------
# ● Update Face Z
#--------------------------------------------------------------------------
def update_face_z
self.z = @battler.screen_z + BATTLE_HUD_Z rescue 100
end
#--------------------------------------------------------------------------
# ● Update Face Reset Time
#--------------------------------------------------------------------------
def update_face_reset_time
return if @battler.battler_face[2] == 0
@battler.battler_face[2] -= 1
if @battler.battler_face[2] == 0 or
(@battler.hp < @low_hp and @battler.battler_face[0] == 0)
make_face(true)
end
end
#--------------------------------------------------------------------------
# ● Update Face Effect
#--------------------------------------------------------------------------
def update_face_effect
return if @battler.battler_face[2] == 0
case @battler.battler_face[1]
when 0
face_damage
when 1..2
face_heal
when 3
face_action
end
end
#--------------------------------------------------------------------------
# ● Face Damage
#--------------------------------------------------------------------------
def face_damage
self.x = (@org_pos[0] - (@battler.battler_face[2] /2)) + rand(@battler.battler_face[2])
end
#--------------------------------------------------------------------------
# ● Face Heal
#--------------------------------------------------------------------------
def face_heal
case @battler.battler_face[2]
when 20..40
self.zoom_x += 0.01
self.zoom_y = self.zoom_x
when 0..20
self.zoom_x -= 0.01
self.zoom_y = self.zoom_x
end
end
#--------------------------------------------------------------------------
# ● Face Action
#--------------------------------------------------------------------------
def face_action
case @battler.battler_face[2]
when 25..50
self.zoom_x += 0.01
self.zoom_y = self.zoom_x
self.mirror = true
when 0..25
self.zoom_x -= 0.01
self.zoom_y = self.zoom_x
self.mirror = false
end
self.zoom_x = self.zoom_x > 1.5 ? self.zoom_x = 1.5 : self.zoom_x < 1 ? 1 : self.zoom_x
self.zoom_y = self.zoom_y > 1.5 ? self.zoom_y = 1.5 : self.zoom_y < 1 ? 1 : self.zoom_y
end
#--------------------------------------------------------------------------
# ● Update Position
#--------------------------------------------------------------------------
alias mog_battle_hud_update_position update_position
def update_position
return if @battle.is_a?(Game_Actor)
mog_battle_hud_update_position
end
#--------------------------------------------------------------------------
# ● Update Collapse
#--------------------------------------------------------------------------
alias mog_battle_hud_update_collapse update_collapse
def update_collapse
return if @battler.is_a?(Game_Actor)
mog_battle_hud_update_collapse
end
#--------------------------------------------------------------------------
# ● Update Instant Collapse
#--------------------------------------------------------------------------
alias mog_battle_hud_update_instant_collapse update_instant_collapse
def update_instant_collapse
return if @battler.is_a?(Game_Actor)
mog_battle_hud_update_instant_collapse
end
end
#================================================= =============================
# ■ Battle Manager
#================================================= =============================
class << BattleManager
#--------------------------------------------------------------------------
# ● Battle End
#--------------------------------------------------------------------------
alias mog_battle_hud_battle_process_victory process_victory
def process_victory
execute_face_effect
mog_battle_hud_battle_process_victory
end
#--------------------------------------------------------------------------
# ● Prepare
#--------------------------------------------------------------------------
def execute_face_effect
for i in $game_party.members
if i.hp > 0
i.battler_face = [1,2,40]
end
end
end
end
#================================================= =============================
# ■ Game Action
#================================================= =============================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● Show Animations
#--------------------------------------------------------------------------
alias mog_battle_hud_show_animation show_animation
def show_animation(targets, animation_id)
# execute_battle_cry(2, @subject.current_action.item.id, @subject)
make_face_action_battle
mog_battle_hud_show_animation(targets, animation_id)
end
#--------------------------------------------------------------------------
# ● Make Face Action
#--------------------------------------------------------------------------
def make_face_action_battle
return if !@subject.is_a?(Game_Actor)
@subject.battler_face = [2,3,50]
end
end
#================================================= =============================
# ■ Game Battler
#================================================= =============================
class Game_Battler < Game_BattlerBase
#--------------------------------------------------------------------------
# ● Item Apply
#--------------------------------------------------------------------------
alias mog_battle_hud_item_apply item_apply
def item_apply(user, item)
old_hp = self.hp
old_mp = self.mp
mog_battle_hud_item_apply(user, item)
check_face_effect(old_hp,old_mp) if can_check_face_effect?(old_hp,old_mp)
end
#--------------------------------------------------------------------------
# ● Check Face Effect
#--------------------------------------------------------------------------
def check_face_effect(old_hp,old_mp)
if self.hp > old_hp or self.mp > old_mp
self.battler_face = [1,1,40]
elsif self.hp < old_hp
self.battler_face = [3,0,40]
end
end
#--------------------------------------------------------------------------
# ● Added New State
#--------------------------------------------------------------------------
alias mog_battle_hud_add_new_state add_new_state
def add_new_state(state_id)
mog_battle_hud_add_new_state(state_id)
if self.is_a?(Game_Actor)
self.battler_face = [1,1,40] if $data_states[state_id].note =~ /<Good State>/
self.battler_face = [3,0,40] if $data_states[state_id].note =~ /<Bad State>/
end
end
#--------------------------------------------------------------------------
# ● Regenerate HP
#--------------------------------------------------------------------------
alias mog_battle_hud_regenerate_hp regenerate_hp
def regenerate_hp
old_hp = self.hp
old_mp = self.mp
mog_battle_hud_regenerate_hp
check_face_effect(old_hp,old_mp) if can_check_face_effect?(old_hp,old_mp)
end
#--------------------------------------------------------------------------
# ● Regenerate MP
#--------------------------------------------------------------------------
alias mog_battle_hud_regenerate_mp regenerate_mp
def regenerate_mp
old_hp = self.hp
old_mp = self.mp
mog_battle_hud_regenerate_mp
check_face_effect(old_hp,old_mp) if can_check_face_effect?(old_hp,old_mp)
end
#--------------------------------------------------------------------------
# ● Can Check Face Effect
#--------------------------------------------------------------------------
def can_check_face_effect?(old_hp,old_mp)
return false if self.is_a?(Game_Enemy)
return true if old_hp != self.hp
return true if old_mp != self.mp
return false
end
end
#================================================= =============================
# ■ Scene_Battle
#================================================= =============================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● Invoke Counter Attack
#--------------------------------------------------------------------------
alias mog_battle_hud_invoke_counter_attack invoke_counter_attack
def invoke_counter_attack(target, item)
mog_battle_hud_invoke_counter_attack(target, item)
if target.is_a?(Game_Actor) and target.battler_face[0] != 2
target.battler_face = [2,3,50]
end
end
#--------------------------------------------------------------------------
# ● Invoke Magic Reflection
#--------------------------------------------------------------------------
alias mog_battle_hud_invoke_magic_reflection invoke_magic_reflection
def invoke_magic_reflection(target, item)
mog_battle_hud_invoke_magic_reflection(target, item)
if target.is_a?(Game_Actor) and target.battler_face[0] != 2
target.battler_face = [2,3,50]
end
end
end
end #BATTLER FACE SYSTEM END --------------------------------------------------
#================================================= =============================
# ■ Battle_Hud
#================================================= =============================
class Battle_Hud
include MOG_BATTLE_HUD
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
def initialize(actor)
dispose
@actor = actor
@x = HUD_POSITION[0] + (MEMBERS_SPACE[0] * @actor.index)
@y = HUD_POSITION[1] + (MEMBERS_SPACE[1] * @actor.index)
pre_cache
create_layout
create_hp_number
create_hp_meter
create_mp_number
create_mp_meter
create_tp_number
create_tp_meter
create_states
end
#--------------------------------------------------------------------------
# ● Pre Cache
#--------------------------------------------------------------------------
def pre_cache
@number = Cache.system("Battle_Hud_Number")
@number_cw = @number.width / 10
@number_ch = @number.height / 4
@meter = Cache.system("Battle_Hud_Meter")
@meter_cw = @meter.width / 3
@meter_ch = @meter.height / 3
@icon = Cache.system("Iconset")
end
#--------------------------------------------------------------------------
# ● Create Layout
#--------------------------------------------------------------------------
def create_layout
@layout = Sprite.new
@layout.bitmap = Cache.system("Battle_Hud_Layout")
@layout.z = BATTLE_HUD_Z
@layout.x = @x
@layout.y = @y
end
#--------------------------------------------------------------------------
# ● Create HP Number
#--------------------------------------------------------------------------
def create_hp_number
@hp = @actor.hp
@hp_old = @actor.hp
@hp_ref = @hp_old
@hp_refresh = false
@hp_number = Sprite.new
@hp_number.bitmap = Bitmap.new((@number_cw * 6),@number_ch)
@hp_number.z = BATTLE_HUD_Z + 2
@hp_number.x = @x + HP_NUMBER_POSITION[0]
@hp_number.y = @y + HP_NUMBER_POSITION[1]
refresh_hp_number
end
#--------------------------------------------------------------------------
# ● Create HP Meter
#--------------------------------------------------------------------------
def create_hp_meter
@hp_meter = Sprite.new
@hp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
@hp_meter.z = BATTLE_HUD_Z + 1
@hp_meter.x = @x + HP_METER_POSITION[0]
@hp_meter.y = @y + HP_METER_POSITION[1]
@hp_flow = rand(@meter_cw * 2)
@hp_width_old = @meter_cw * @actor.hp / @actor.mhp
hp_flow_update
end
#--------------------------------------------------------------------------
# ● Hp Flow Update
#--------------------------------------------------------------------------
def hp_flow_update
@hp_meter.bitmap.clear
hp_width = @meter_cw * @actor.hp / @actor.mhp
#execute_damage_flow(hp_width)
hp_src_rect = Rect.new(@hp_flow, 0,hp_width, @meter_ch)
@hp_meter.bitmap.blt(0,0, @meter, hp_src_rect)
@hp_flow += METER_FLOW_SPEED
@hp_flow = 0 if @hp_flow >= @meter_cw * 2
end
#--------------------------------------------------------------------------
# ● Execute Damage Flow
#--------------------------------------------------------------------------
def execute_damage_flow(hp_width)
n = (@hp_width_old - hp_width).abs * 3 / 100
damage_flow = [[n, 2].min,0.5].max
@hp_width_old -= damage_flow
@hp_width_old = hp_width if @hp_width_old < hp_width
src_rect_old = Rect.new(@hp_flow, @meter_ch * 3,@hp_width_old, @meter_ch)
@hp_meter.bitmap.blt(0,0, @meter, src_rect_old)
end
#--------------------------------------------------------------------------
# ● Update HP Number
#--------------------------------------------------------------------------
def update_hp_number
@hp_refresh = true
n = 2 * (@actor.hp - @hp_old).abs / 100
hp_ref = [[n, 100].min,1].max
if @hp_old < @actor.hp
@hp += hp_ref
if @hp >= @actor.hp
@hp_old = @actor.hp
@hp = @actor.hp
@hp_ref = 0
end
elsif @hp_old > @actor.hp
@hp -= hp_ref
if @hp <= @actor.hp
@hp_old = @actor.hp
@hp = @actor.hp
@hp_ref = 0
end
end
end
#--------------------------------------------------------------------------
# ● Refresh HP Number
#--------------------------------------------------------------------------
def refresh_hp_number
@hp_number.bitmap.clear
number_value = @hp.abs.to_s.split(//)
hp_color = @hp < @actor.mhp * 30 / 100 ? @number_ch : 0
center_x = 0
for r in 0..number_value.size - 1
number_value_abs = number_value[r].to_i
src_rect = Rect.new(@number_cw * number_value_abs, hp_color, @number_cw, @number_ch)
@hp_number.bitmap.blt((@number_cw + 1) * r, 0, @number, src_rect)
center_x += 1
end
@hp_number.x = @x + HP_NUMBER_POSITION[0] - (center_x * (@number_cw + 1))
@hp_refresh = false if @hp == @actor.hp
end
#--------------------------------------------------------------------------
# ● Create MP Number
#--------------------------------------------------------------------------
def create_mp_number
@mp = @actor.mp
@mp_old = @actor.mp
@mp_ref = @mp_old
@mp_refresh = false
@mp_number = Sprite.new
@mp_number.bitmap = Bitmap.new((@number_cw * 6),@number_ch)
@mp_number.z = BATTLE_HUD_Z + 2
@mp_number.x = @x + MP_NUMBER_POSITION[0]
@mp_number.y = @y + MP_NUMBER_POSITION[1]
refresh_mp_number
end
#--------------------------------------------------------------------------
# ● Create MP Meter
#--------------------------------------------------------------------------
def create_mp_meter
@mp_meter = Sprite.new
@mp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
@mp_meter.z = BATTLE_HUD_Z + 1
@mp_meter.x = @x + MP_METER_POSITION[0]
@mp_meter.y = @y + MP_METER_POSITION[1]
@mp_flow = rand(@meter_cw * 2)
@mp_width_old = @meter_cw * @actor.mp / @actor.mmp rescue 0
mp_flow_update
end
#--------------------------------------------------------------------------
# ● Mp Flow Update
#--------------------------------------------------------------------------
def mp_flow_update
return if @actor.mmp == 0
@mp_meter.bitmap.clear
mp_width = @meter_cw * @actor.mp / @actor.mmp rescue 0
src_rect = Rect.new(@mp_flow, @meter_ch,mp_width, @meter_ch)
@mp_meter.bitmap.blt(0,0, @meter, src_rect)
@mp_flow += METER_FLOW_SPEED
@mp_flow = 0 if @mp_flow >= @meter_cw * 2
end
#--------------------------------------------------------------------------
# ● Update MP Number
#--------------------------------------------------------------------------
def update_mp_number
@mp_refresh = true
n = 2 * (@actor.mp - @mp_old).abs / 100
mp_ref = [[n, 100].min,1].max
if @mp_old < @actor.mp
@mp += mp_ref
if @mp >= @actor.mp
@mp_old = @actor.mp
@mp = @actor.mp
@mp_ref = 0
end
elsif @mp_old > @actor.mp
@mp -= mp_ref
if @mp <= @actor.mp
@mp_old = @actor.mp
@mp = @actor.mp
@mp_ref = 0
end
end
end
#--------------------------------------------------------------------------
# ● Refresh MP Number
#--------------------------------------------------------------------------
def refresh_mp_number
@mp_number.bitmap.clear
number_value = @mp.abs.to_s.split(//)
center_x = 0
for r in 0..number_value.size - 1
number_value_abs = number_value[r].to_i
src_rect = Rect.new(@number_cw * number_value_abs, @number_ch * 2, @number_cw, @number_ch)
@mp_number.bitmap.blt((@number_cw + 1) * r, 0, @number, src_rect)
center_x += 1
end
@mp_number.x = @x + MP_NUMBER_POSITION[0] - (center_x * (@number_cw + 1))
@mp_refresh = false if @mp == @actor.mp
end
#--------------------------------------------------------------------------
# ● Create TP Number
#--------------------------------------------------------------------------
def create_tp_number
@tp = @actor.tp
@tp_old = @actor.tp
@tp_ref = @tp_old
@tp_refresh = false
@tp_number = Sprite.new
@tp_number.bitmap = Bitmap.new((@number_cw * 6),@number_ch)
@tp_number.z = BATTLE_HUD_Z + 2
@tp_number.x = @x + TP_NUMBER_POSITION[0]
@tp_number.y = @y + TP_NUMBER_POSITION[1]
refresh_tp_number
end
#--------------------------------------------------------------------------
# ● Create TP Meter
#--------------------------------------------------------------------------
def create_tp_meter
@tp_meter = Sprite.new
@tp_meter.bitmap = Bitmap.new(@meter_cw,@meter_ch)
@tp_meter.z = BATTLE_HUD_Z + 1
@tp_meter.x = @x + TP_METER_POSITION[0]
@tp_meter.y = @y + TP_METER_POSITION[1]
@tp_flow = rand(@meter_cw * 2)
@tp_width_old = @meter_cw * @actor.tp / @actor.max_tp rescue 0
tp_flow_update
end
#--------------------------------------------------------------------------
# ● TP Flow Update
#--------------------------------------------------------------------------
def tp_flow_update
return if @actor.max_tp == 0
@tp_meter.bitmap.clear
tp_width = @meter_cw * @actor.tp / @actor.max_tp rescue 0
src_rect = Rect.new(@tp_flow, @meter_ch * 2,tp_width, @meter_ch)
@tp_meter.bitmap.blt(0,0, @meter, src_rect)
@tp_flow += METER_FLOW_SPEED
@tp_flow = 0 if @tp_flow >= @meter_cw * 2
end
#--------------------------------------------------------------------------
# ● Update TP Number
#--------------------------------------------------------------------------
def update_tp_number
@tp_refresh = true
n = 2 * (@actor.tp - @tp_old).abs / 100
tp_ref = [[n, 100].min,1].max
if @tp_old < @actor.tp
@tp += tp_ref
if @tp >= @actor.tp
@tp_old = @actor.tp
@tp = @actor.tp
@tp_ref = 0
end
elsif @tp_old > @actor.tp
@tp -= tp_ref
if @tp <= @actor.tp
@tp_old = @actor.tp
@tp = @actor.tp
@tp_ref = 0
end
end
end
#--------------------------------------------------------------------------
# ● Refresh TP Number
#--------------------------------------------------------------------------
def refresh_tp_number
@tp_number.bitmap.clear
number_value = @tp.truncate.to_s.split(//)
center_x = 0
for r in 0..number_value.size - 1
number_value_abs = number_value[r].to_i
src_rect = Rect.new(@number_cw * number_value_abs, @number_ch * 3, @number_cw, @number_ch)
@tp_number.bitmap.blt((@number_cw + 1) * r, 0, @number, src_rect)
center_x += 1
end
@tp_number.x = @x + TP_NUMBER_POSITION[0] - (center_x * (@number_cw + 1))
@tp_refresh = false if @tp == @actor.tp
end
#--------------------------------------------------------------------------
# ● Create_States
#--------------------------------------------------------------------------
def create_states
refresh_states
@status = Sprite.new
@status.bitmap = Bitmap.new(24,24)
@status.x = @x + STATES_POSITION[0]
@status.y = @y + STATES_POSITION[1]
@status_flow = -24
@states_speed = 50
@status.z = BATTLE_HUD_Z + 2
@old_states = @actor.states
flow_states
end
#--------------------------------------------------------------------------
# ● Flow_Status
#--------------------------------------------------------------------------
def flow_states
return if @actor.states.size == 0 and !@status.visible
@states_speed = 0
@status.bitmap.clear
src_rect = Rect.new(@status_flow,0, 24,24)
@status.bitmap.blt(0,0, @actor_status, src_rect)
@status.visible = @actor.states.size == 0 ? false : true
@status_flow += 1
@status_flow = -24 if @status_flow >= @states_size - 24
end
#--------------------------------------------------------------------------
# ● Refresh States
#--------------------------------------------------------------------------
def refresh_states
refresh_icon if @icon == nil or @icon.disposed?
@old_states = @actor.states
if @actor_status != nil
@actor_status.dispose
@actor_status = nil
end
@states_size = @actor.states.size > 0 ? (48 * @actor.states.size) : 24
@actor_status = Bitmap.new(@states_size,24)
index = 0
for i in @actor.states
rect = Rect.new(i.icon_index % 16 * 24, i.icon_index / 16 * 24, 24, 24)
@actor_status.blt(48 * index , 0, @icon, rect)
index += 1
end
end
#--------------------------------------------------------------------------
# ● Refresh Icon
#--------------------------------------------------------------------------
def refresh_icon
if @icon != nil
if !@icon.disposed?
@icon.dispose
end
@icon = nil
end
@icon = Cache.system("Iconset")
end
#--------------------------------------------------------------------------
# ● Dispose
#--------------------------------------------------------------------------
def dispose
return if @meter == nil
@meter.dispose
@meter = nil
@number.dispose
if @icon != nil
if !@icon.disposed?
@icon.dispose
end
@icon = nil
end
@layout.bitmap.dispose
@layout.dispose
@hp_number.bitmap.dispose
@hp_number.dispose
@hp_meter.bitmap.dispose
@hp_meter.dispose
@mp_number.bitmap.dispose
@mp_number.dispose
@mp_meter.bitmap.dispose
@mp_meter.dispose
@tp_number.bitmap.dispose
@tp_number.dispose
@tp_meter.bitmap.dispose
@tp_meter.dispose
@status.bitmap.dispose
@status.dispose
if @actor_status != nil
@actor_status.dispose
@actor_status = nil
end
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
def update
return if @meter == nil
update_hp_number if @hp_old != @actor.hp
refresh_hp_number if @hp_refresh
update_mp_number if @mp_old != @actor.mp
refresh_mp_number if @mp_refresh
update_tp_number if @tp_old != @actor.tp
refresh_tp_number if @tp_refresh
refresh_states if @old_states != @actor.states
hp_flow_update
tp_flow_update
mp_flow_update
flow_states
end
end
#================================================= =============================
# ■ Spriteset Battle
#================================================= =============================
class Spriteset_Battle
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_battle_hud_initialize initialize
def initialize
mog_battle_hud_initialize
create_battle_hud
end
#--------------------------------------------------------------------------
# ● Create Battle Hud
#--------------------------------------------------------------------------
def create_battle_hud
dispose_battle_hud
@battle_hud = []
for i in $game_party.members
@battle_hud.push(Battle_Hud.new(i))
end
end
#--------------------------------------------------------------------------
# ● Dispose
#--------------------------------------------------------------------------
alias mog_battle_hud_dispose dispose
def dispose
mog_battle_hud_dispose
dispose_battle_hud
end
#--------------------------------------------------------------------------
# ● Dispose Battle Hud
#--------------------------------------------------------------------------
def dispose_battle_hud
return if @battle_hud == nil
@battle_hud.each {|sprite| sprite.dispose }
@battle_hud.clear
@battle_hud = nil
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
alias mog_battle_hud_update update
def update
mog_battle_hud_update
update_battle_hud
end
#--------------------------------------------------------------------------
# ● Update Battle Hud
#--------------------------------------------------------------------------
def update_battle_hud
return if @battle_hud == nil
@battle_hud.each {|sprite| sprite.update }
end
end
#================================================= =============================
# ■ Game_Actor
#================================================= =============================
class Game_Actor < Game_Battler
include MOG_BATTLE_HUD
attr_accessor :hud_x
attr_accessor :hud_y
#--------------------------------------------------------------------------
# ● HUD X
#--------------------------------------------------------------------------
def hud_x
return HUD_POSITION[0] + (MEMBERS_SPACE[0] * index)
end
#--------------------------------------------------------------------------
# ● HUD Y
#--------------------------------------------------------------------------
def hud_y
return HUD_POSITION[1] + (MEMBERS_SPACE[1] * index)
end
end
#================================================= =============================
# ■ Scene Battle
#================================================= =============================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● Create Party Command Window
#--------------------------------------------------------------------------
alias mog_battle_hud_create_party_command_window create_party_command_window
def create_party_command_window
mog_battle_hud_create_party_command_window
set_party_window_position
end
#--------------------------------------------------------------------------
# ● Set Party Window Position
#--------------------------------------------------------------------------
def set_party_window_position
@party_command_window.viewport = nil
return if $mog_rgss3_at_system != nil
a_index = []
for actor in $game_party.alive_members
a_index = [actor.hud_x, actor.hud_y]
break
end
return if a_index.empty?
@party_command_window.x = MOG_BATTLE_HUD::COMMAND_POSITION[0] + a_index[0]
@party_command_window.y = MOG_BATTLE_HUD::COMMAND_POSITION[1] + a_index[1]
end
#--------------------------------------------------------------------------
# ● Set Party Window Position
#--------------------------------------------------------------------------
alias mog_battle_hud_start_party_command_selection start_party_command_selection
def start_party_command_selection
set_party_window_position
mog_battle_hud_start_party_command_selection
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
alias mog_battle_hud_update_basic update_basic
def update_basic
mog_battle_hud_update_basic
update_command_window_visible
end
#--------------------------------------------------------------------------
# ● Update Command Window Visible
#--------------------------------------------------------------------------
def update_command_window_visible
@status_window.visible = @status_window.active ? true : false
@actor_command_window.visible = @actor_command_window.active ? true : false
@skill_window.visible = @skill_window.active ? true : false
@item_window.visible = @item_window.active ? true : false
end
#--------------------------------------------------------------------------
# ● Start Actor Command Selection
#--------------------------------------------------------------------------
alias mog_battle_hud_start_actor_command_selection start_actor_command_selection
def start_actor_command_selection
mog_battle_hud_start_actor_command_selection
@actor_command_window.viewport = nil
@actor_command_window.x = MOG_BATTLE_HUD::COMMAND_POSITION[0] + $game_party.members[BattleManager.actor.index].hud_x
@actor_command_window.y = MOG_BATTLE_HUD::COMMAND_POSITION[1] + $game_party.members[BattleManager.actor.index].hud_y
@party_command_window.x = @actor_command_window.x
@party_command_window.y = @actor_command_window.y
end
end
#================================================= =============================
# ■ Game Temp
#================================================= =============================
class Game_Temp
attr_accessor :battle_cursor
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_battle_cursor_initialize initialize
def initialize
@battle_cursor = [0,0,true,""]
mog_battle_cursor_initialize
end
end
#================================================= =============================
# ■ Spriteset Battle
#================================================= =============================
class Spriteset_Battle
include MOG_BATTLE_CURSOR
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_battle_cursor_initialize initialize
def initialize
mog_battle_cursor_initialize
create_cursor
end
#--------------------------------------------------------------------------
# ● Create_Cursor
#--------------------------------------------------------------------------
def create_cursor
@cursor = Sprite.new
@cursor.bitmap = Cache.system("Battle_Cursor")
@cursor.z = 999
@cursor.visible = false
@cursor_new_x = -64
@cursor_new_y = -64
@cursor_float_y = 0
@cursor_float_duration = 0
@c_real_y = 0
@cursor_name = Sprite.new
@cursor_name.bitmap = Bitmap.new(120,32)
@cursor_name.z = @cursor.z + 1
@cursor_name.bitmap.font.size = 16
refresh_cursor_name
update_cursor_name
$game_temp.battle_cursor = [@cursor_new_x,@cursor_new_y,false]
end
#--------------------------------------------------------------------------
# ● Refresh Cursor Name
#--------------------------------------------------------------------------
def refresh_cursor_name
return if !(@cursor.x == $game_temp.battle_cursor[0] and
@cursor.y == @c_real_y)
@cursor_name_enemy = $game_temp.battle_cursor[3]
@cursor_name.bitmap.clear
@cursor_name.bitmap.draw_text(0,0,120,32,@cursor_n ame_enemy.to_s,1)
end
#--------------------------------------------------------------------------
# ● Dispose
#--------------------------------------------------------------------------
alias mog_battle_cursor_dispose dispose
def dispose
mog_battle_cursor_dispose
dispose_cursor
end
#--------------------------------------------------------------------------
# ● Dispose Cursor
#--------------------------------------------------------------------------
def dispose_cursor
@cursor.bitmap.dispose
@cursor.dispose
@cursor_name.bitmap.dispose
@cursor_name.dispose
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
alias mog_battle_cursor_update update
def update
mog_battle_cursor_update
update_battle_cursor
end
#--------------------------------------------------------------------------
# ● Update Battle Cursor
#--------------------------------------------------------------------------
def update_battle_cursor
return if @cursor == nil
@cursor.visible = $game_temp.battle_cursor[2]
update_cursor_name
if !@cursor.visible
@cursor.x = -64
@cursor.y = -64
@cursor.opacity = 0
update_cursor_name
return
end
@cursor.opacity += 15
update_cursor_float_effect
if CURSOR_SLIDE_EFFECT
update_cursor_slide_effect
else
@cursor.x = $game_temp.battle_cursor[0]
@cursor.y = $game_temp.battle_cursor[1]
end
end
#--------------------------------------------------------------------------
# ● Update Cursor Name
#--------------------------------------------------------------------------
def update_cursor_name
refresh_cursor_name if @cursor_name_enemy != $game_temp.battle_cursor[3]
@cursor_name.x = @cursor.x + CURSOR_NAME_POSITION[0]
@cursor_name.y = @cursor.y + CURSOR_NAME_POSITION[1]
@cursor_name.opacity = @cursor.opacity
@cursor_name.visible = @cursor.visible
end
#--------------------------------------------------------------------------
# ● Update Cursor Slide Effect
#--------------------------------------------------------------------------
def update_cursor_slide_effect
@cursor_new_x = $game_temp.battle_cursor[0]
@cursor_new_y = $game_temp.battle_cursor[1]
@cs_x = 5 + ((@cursor.x - @cursor_new_x).abs / 5)
@cs_y = 5 + ((@cursor.y - @cursor_new_y).abs / 5)
if @cursor.x > @cursor_new_x
@cursor.x -= @cs_x
@cursor.x = @cursor_new_x if @cursor.x < @cursor_new_x
elsif @cursor.x < @cursor_new_x
@cursor.x += @cs_x
@cursor.x = @cursor_new_x if @cursor.x > @cursor_new_x
end
@c_real_y = @cursor_new_y + @cursor_float_y
if @cursor.y > @cursor_new_y
@cursor.y -= @cs_y
@cursor.y = @c_real_y if @cursor.y < @c_real_y
elsif @cursor.y < @c_real_y
@cursor.y += @cs_y
@cursor.y = @c_real_y if @cursor.y > @c_real_y
end
end
#--------------------------------------------------------------------------
# ● Update Cursor Float Effect
#--------------------------------------------------------------------------
def update_cursor_float_effect
return if !CURSOR_FLOAT_EFFECT
@cursor_float_duration += 1
case @cursor_float_duration
when 0..20
@cursor_float_y += 1
when 21..40
@cursor_float_y -= 1
else
@cursor_float_y = 0
@cursor_float_duration = 0
end
end
end
#================================================= =============================
# ■ Window BattleStatus
#================================================= =============================
class Window_BattleStatus < Window_Selectable
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_battle_hud_initialize initialize
def initialize
mog_battle_hud_initialize
self.visible = false
end
#--------------------------------------------------------------------------
# ● Refresh
#--------------------------------------------------------------------------
alias mog_battle_hud_refresh refresh
def refresh
return
mog_battle_hud_refresh
end
end
#================================================= =============================
# ■ Scene Battle
#================================================= =============================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● Create Enemy Window
#--------------------------------------------------------------------------
def create_enemy_window
@enemy_window = Window_BattleEnemy_Cursor.new
@enemy_window.set_handler(
k, method(
n_enemy_ok))
@enemy_window.set_handler(:cancel, method(
n_enemy_cancel))
end
#--------------------------------------------------------------------------
# ● Create Actor Window
#--------------------------------------------------------------------------
def create_actor_window
@actor_window = Window_BattleActor_Cursor.new
@actor_window.set_handler(
k, method(
n_actor_ok))
@actor_window.set_handler(:cancel, method(
n_actor_cancel))
end
end
#================================================= =============================
# ■ Window Selectable Battle_Cursor
#================================================= =============================
class Window_Selectable_Battle_Cursor < Window_Base
attr_reader :index
#--------------------------------------------------------------------------
# ● Initialize
#-------------------------------------------------------------------------
def initialize(x, y, width, height)
super
@index = -1
@handler = {}
deactivate
end
#--------------------------------------------------------------------------
# ● Item Max
#--------------------------------------------------------------------------
def item_max
return 0
end
#--------------------------------------------------------------------------
# ● Active
#--------------------------------------------------------------------------
def active=(active)
super
end
#--------------------------------------------------------------------------
# ● Index
#--------------------------------------------------------------------------
def index=(index)
@index = index
end
#--------------------------------------------------------------------------
# ● Set Handler
#--------------------------------------------------------------------------
def set_handler(symbol, method)
@handler[symbol] = method
end
#--------------------------------------------------------------------------
# ● Handle?
#--------------------------------------------------------------------------
def handle?(symbol)
@handler.include?(symbol)
end
#--------------------------------------------------------------------------
# ● Call Handler
#--------------------------------------------------------------------------
def call_handler(symbol)
@handler[symbol].call if handle?(symbol)
end
#--------------------------------------------------------------------------
# ● Cursor Movable
#--------------------------------------------------------------------------
def cursor_movable?
active && open? && !@cursor_fix && !@cursor_all && item_max > 0
end
#--------------------------------------------------------------------------
# ● Cursor Down
#--------------------------------------------------------------------------
def cursor_down(wrap = false)
self.index += 1
check_index_limit
end
#--------------------------------------------------------------------------
# ● Cursor Right
#--------------------------------------------------------------------------
def cursor_right(wrap = false)
self.index += 1
check_index_limit
end
#--------------------------------------------------------------------------
# ● Cursor UP
#--------------------------------------------------------------------------
def cursor_up(wrap = false)
self.index -= 1
check_index_limit
end
#--------------------------------------------------------------------------
# ● Cursor Left
#--------------------------------------------------------------------------
def cursor_left(wrap = false)
self.index -= 1
check_index_limit(self.index)
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
def update
super
process_cursor_move
process_handling
end
#--------------------------------------------------------------------------
# ● Process Cursor Move
#--------------------------------------------------------------------------
def process_cursor_move
return unless cursor_movable?
last_index = @index
cursor_down (Input.trigger?(
OWN)) if Input.repeat?(
OWN)
cursor_up (Input.trigger?(:UP)) if Input.repeat?(:UP)
cursor_right(Input.trigger?(:RIGHT)) if Input.repeat?(:RIGHT)
cursor_left (Input.trigger?(:LEFT)) if Input.repeat?(:LEFT)
if @index != last_index
Sound.play_cursor
set_cursor_position(@index)
end
end
#--------------------------------------------------------------------------
# ● Process Handling
#--------------------------------------------------------------------------
def process_handling
return unless open? && active
return process_ok if ok_enabled? && Input.trigger?(:C)
return process_cancel if cancel_enabled? && Input.trigger?(:B)
end
#--------------------------------------------------------------------------
# ● OK Enabled
#--------------------------------------------------------------------------
def ok_enabled?
handle?(
k)
end
#--------------------------------------------------------------------------
# ● Cancel Enabled
#--------------------------------------------------------------------------
def cancel_enabled?
handle?(:cancel)
end
#--------------------------------------------------------------------------
# ● Process OK
#--------------------------------------------------------------------------
def process_ok
if current_item_enabled?
Sound.play_ok
Input.update
deactivate
call_ok_handler
else
Sound.play_buzzer
end
end
#--------------------------------------------------------------------------
# ● Call OK Handler
#--------------------------------------------------------------------------
def call_ok_handler
call_handler(
k)
end
#--------------------------------------------------------------------------
# ● Process Cancel
#--------------------------------------------------------------------------
def process_cancel
Sound.play_cancel
Input.update
deactivate
call_cancel_handler
end
#--------------------------------------------------------------------------
# ● Call Cancel Handler
#--------------------------------------------------------------------------
def call_cancel_handler
call_handler(:cancel)
end
#--------------------------------------------------------------------------
# ● Set Cursor Position
#--------------------------------------------------------------------------
def set_cursor_position(index)
end
#--------------------------------------------------------------------------
# ● Current Item Enabled?
#--------------------------------------------------------------------------
def current_item_enabled?
return true
end
#--------------------------------------------------------------------------
# ● Refresh
#--------------------------------------------------------------------------
def refresh
contents.clear
end
#--------------------------------------------------------------------------
# ● Show
#--------------------------------------------------------------------------
def show
set_cursor_position(self.index)
$game_temp.battle_cursor[2] = true
super
end
#--------------------------------------------------------------------------
# ● Hide
#--------------------------------------------------------------------------
def hide
$game_temp.battle_cursor[2] = false
super
end
#--------------------------------------------------------------------------
# ● Check Index Limit
#--------------------------------------------------------------------------
def check_index_limit(index = self.index)
self.index = index
self.index = 0 if self.index >= item_max
self.index = (item_max - 1) if self.index < 0
end
end
#================================================= =============================
# ■ Window_BattleEnemy
#================================================= =============================
class Window_BattleEnemy_Cursor < Window_Selectable_Battle_Cursor
include MOG_BATTLE_CURSOR
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
def initialize
super(-32, -32, 32, 32)
self.index = 0
self.visible = false
set_cursor_position(self.index)
end
#--------------------------------------------------------------------------
# ● Item Max
#--------------------------------------------------------------------------
def item_max
$game_troop.alive_members.size
end
#--------------------------------------------------------------------------
# ● Enemy
#--------------------------------------------------------------------------
def enemy
$game_troop.alive_members[self.index]
end
#--------------------------------------------------------------------------
# ● Set Cursor Position
#--------------------------------------------------------------------------
def set_cursor_position(index)
check_index_limit(index)
return if $game_troop.alive_members[self.index] == nil
$game_temp.battle_cursor[0] = $game_troop.alive_members[self.index].screen_x + CURSOR_POSITION[0]
$game_temp.battle_cursor[1] = $game_troop.alive_members[self.index].screen_y + CURSOR_POSITION[1]
$game_temp.battle_cursor[3] = $game_troop.alive_members[self.index].name
end
end
#================================================= =============================
# ■ Window_BattleActor Cursor
#================================================= =============================
class Window_BattleActor_Cursor < Window_Selectable_Battle_Cursor
include MOG_BATTLE_CURSOR
include MOG_BATTLE_HUD
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
def initialize
super(-32, -32, 32, 32)
self.index = 0
self.visible = true
set_cursor_position(self.index)
end
#--------------------------------------------------------------------------
# ● Item Max
#--------------------------------------------------------------------------
def item_max
$game_party.members.size
end
#--------------------------------------------------------------------------
# ● Set Cursor Position
#--------------------------------------------------------------------------
def set_cursor_position(index)
check_index_limit(index)
return if $game_party.members[self.index] == nil
screen_x = $game_party.members[self.index].screen_x rescue nil
screen_y = $game_party.members[self.index].screen_y rescue nil
if screen_x == nil or screen_y == nil
screen_x = $game_party.members[self.index].hud_x + (HP_NUMBER_POSITION[0] / 3) + 32
screen_y = $game_party.members[self.index].hud_y + (HP_NUMBER_POSITION[1] / 2) + 32
end
$game_temp.battle_cursor[0] = screen_x + CURSOR_POSITION[0]
$game_temp.battle_cursor[1] = screen_y + CURSOR_POSITION[1]
$game_temp.battle_cursor[3] = $game_party.members[self.index].name
end
end
$mog_rgss3_battle_hud = true
Хорошо!: 
Плохо!: 
Сообщение от Antberg
Ответить с цитированием
Социальные закладки