MogHunter Advanced Battle HUD

[Mithos]

siccome ho visto che Lupius si è preso la briga di "smontare" la megaDemo di Moghunter per postare singolarmante gli script e siccome ne utilizzo uno nel mio progetto ho pensato di dargli una mano, postando per lui lo script relativo al Battle Hud.

 

Quindi ecco a voi:

 

MOGHUNTER ADVANCED BATTLE HUD

Descrizione

Questo script modifica l' Hud di battaglia, aggiungendo la possibilità di inserire un volto ai personaggi, che "reagirà" durante gli scontri, come quando attacchiamo o veniamo attaccati ed un cursore che indica i nemici attualmente selezionati.

 

Autore

MOGHUNTER

Allegati

Saranno necessarie quattro immagini, da inserire nella cartella Graphic/System.

Eccoli qui:

http://img834.imageshack.us/img834/1926/battlecursor.png

Questo andrà nominato Battle_Cursor. Indicherà i nemici attualmente selezionati.

http://img266.imageshack.us/img266/3579/battlehudlayout.png

Quest' altro andrà nominato Battle_Hud_Layout. Sarà L'Hud vero e proprio. Nel quadrato verranno inserite le icone relative agli stati.

http://img545.imageshack.us/img545/2403/battlehudnumber.png

Questo andrà nominato Battle_Hud_Number. Saranno i numeri posti sulla barra dell' Hud ed indicherà il valore numerico di HP, MP e HP.

http://img15.imageshack.us/img15/4633/battlehudmeter.png

Infine questo andrà nominato Battle_Hud_Meter. Sarà il gradiente che riempe le tre barre dell' Hud.

 

Istruzioni per l'uso

Per inserire i face dei personaggi, dovrete creare un immagine che riproduce il face del personaggio per 5 volte. Non sono importanti le dimensioni (lo script ritaglierà automaticamente le 5 immagini) ma devono avere tutte la stessa immagine.

Le immagini rappresenteraano nell' ordine:

PG Normale

PG Curato (o Buff positivi)

PG Attacco

PG Colpito

PG Morto

NB. I Faceset così creati dovranno essere importati nella cartella Graphic/Battler e andrà nominato con il nome del PG in questione. (Attenzione: è Case Sensitive)

Esempi:

http://img22.imageshack.us/img22/8879/evalg.png

Questo Faceset è inserito nella Demo da MogHunter stesso.

http://img594.imageshack.us/img594/8185/sonyav.png

Questo invece, l'ho creato appositamente per il mio progetto. Per quanto di dimensioni diverse, si adatta perfettamente allo script.

 

Script

 

if false# Set true to enable the script
  
#==============================================================================
# ■ +++ MOG - Master HUD (v1.3) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com
#==============================================================================
# - Sistema de hud baseado em imagens que possui todas as carácteristicas
#   básicas necessárias em um projeto.
#==============================================================================
# CUSTOMIZAÇÃO
#
# - Basta criar as imagens de sua hud em um editor de imagem e após 
# isso configure a posição das imagens no editor de script.
#==============================================================================
# Para ativar ou desativar a HUD use o comando abaixo.
#
# $game_system.hud_visible = true
#
#==============================================================================
# ● Histórico (Version History)
#==============================================================================
# v 1.3 - Melhoria no sistema de dispose de imagens.
#==============================================================================
module MOG_HUD
  #Posição geral da HUD
  HUD = [0,330]
  #Posição do Medidor de HP
  HP_METER = [105,14]
  #Posição do numero de HP
  HP_NUMBER = [110,14]
  #Posição do Medidor de MP
  MP_METER = [65,33] 
  #Posição do numero de MP
  MP_NUMBER = [70,33] 
  #Posição do medidor de EXP 
  EXP_METER = [37,55]
  #Posição do Level.
  EXP_NUMBER = [45,9]
  #Posição do layout.
  LAYOUT = [5,10]
  #Posição da face.
  FACE = [5,-15]
  #Posição das condições.
  STATES = [340,50]
  #Prioridade da hud na tela.
  HUD_Z = 105
end

#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_System

  attr_accessor :hud_visible  

  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------        
  alias active_hud_initialize initialize
  def initialize
      active_hud_initialize
      @hud_visible = false
  end  
end

#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● now_exp
  #--------------------------------------------------------------------------      
  def now_exp
      return current_level_exp
  end
  #--------------------------------------------------------------------------
  # ● next_exp
  #--------------------------------------------------------------------------          
  def next_exp
    return next_level_exp
  end
end

#===============================================================================
# ■ RPG_FileTest 
#===============================================================================
module RPG_FileTest
  
  #--------------------------------------------------------------------------
  # ● RPG_FileTest.system_exist?
  #--------------------------------------------------------------------------
  def RPG_FileTest.system_exist?(filename)
      return Cache.system(filename) rescue return false
  end  
  
end

#==============================================================================
# ■ Hud
#==============================================================================
class Hud 
  include MOG_HUD
  
  #--------------------------------------------------------------------------
  # ● Initialize
  #--------------------------------------------------------------------------
  def initialize
      @actor = $game_party.members[0]
      dispose
      return if @actor == nil
      @pre_leader_id = $game_party.members[0].id
      create_layout
      create_face
      create_state
      create_hp   
      create_mp    
      create_level
      update_visible    
  end
  
  #--------------------------------------------------------------------------
  # ●  refresh_actor
  #--------------------------------------------------------------------------  
  def refresh_actor
      dispose
      initialize
  end
  
  #--------------------------------------------------------------------------
  # ●  create_layout
  #--------------------------------------------------------------------------   
  def create_layout
      @layout_sprite = Sprite.new
      @layout_sprite.bitmap = Cache.system("Hud_Layout")
      @layout_sprite.z = HUD_Z
      @layout_sprite.x = HUD[0] + LAYOUT[0]
      @layout_sprite.y = HUD[1] + LAYOUT[1]   
  end
  
  #--------------------------------------------------------------------------
  # ● create_face
  #--------------------------------------------------------------------------      
  def create_face    
      image_name = "Hud_Face" + @actor.id.to_s
      unless RPG_FileTest.system_exist?(image_name)
         image_name = ""
      end  
      @face_image = Cache.system(image_name)
      @face_sprite = Sprite.new
      @face_sprite.bitmap = Bitmap.new(@face_image.width,@face_image.height)
      @face_cw = @face_image.width
      @face_ch = @face_image.height 
      @face_src_rect_back = Rect.new(0, 0,@face_cw , @face_ch)
      @face_sprite.bitmap.blt(0,0, @face_image, @face_src_rect_back)      
      @face_sprite.z = 1 + HUD_Z
      @face_sprite.x = HUD[0] + FACE[0]
      @face_sprite.y = HUD[1] + FACE[1]        
  end
  
  #--------------------------------------------------------------------------
  # ● create_state
  #--------------------------------------------------------------------------    
  def create_state
      @states_max = 0
      @states = Sprite.new 
      @states.bitmap = Bitmap.new(72,24)
      @states_x = -1
      @states_y = 0
      @states_f = false
      @states_max = 0
      @states.x = HUD[0] + STATES[0]
      @states.y = @states_y + HUD[1] + STATES[1]
      @states.z = 3 + HUD_Z
      states_refresh
  end
  
  #--------------------------------------------------------------------------
  # ●  create_hp 
  #--------------------------------------------------------------------------  
  def create_hp 
      @hp = @actor.hp
      @hp_old = @actor.hp
      @hp_ref = @hp_old
      @hp_refresh = false
      #Number SP ----
      @hp_number_image = Cache.system("Hud_HP_Number")
      @hp_number_sprite = Sprite.new
      @hp_number_sprite.bitmap = Bitmap.new(@hp_number_image.width,@hp_number_image.height)
      @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   
      #Meter HP -----
      @hp_image = Cache.system("Hud_HP_Meter")
      @hp_range = @hp_image.width 
      @hp_height = @hp_image.height 
      @hp_width = @hp_range  * @actor.hp / @actor.mhp 
      @hp_width_old = @hp_width    
      @hp_sprite = Sprite.new
      @hp_sprite.bitmap = Bitmap.new(@hp_image.width,@hp_image.height)
      @hp_sprite.z = 2 + HUD_Z
      @hp_sprite.x = HUD[0] + HP_METER[0]
      @hp_sprite.y = HUD[1] + HP_METER[1]
      hp_flow_update
      hp_number_refresh    
  end
  
  #--------------------------------------------------------------------------
  # ●  create_mp
  #--------------------------------------------------------------------------  
  def create_mp
      @sp = @actor.mp
      @sp_old = @actor.mp
      @sp_ref = @sp_old 
      @sp_refresh = false 
      #Number SP -----
      @sp_number_image = Cache.system("Hud_MP_Number")
      @sp_number_sprite = Sprite.new
      @sp_number_sprite.bitmap = Bitmap.new(@sp_number_image.width,@sp_number_image.height)
      @sp_number_sprite.z = 153
      @sp_number_sprite.x = HUD[0] + MP_NUMBER[0]
      @sp_number_sprite.y = HUD[1] + MP_NUMBER[1]
      @sp_im_cw = @sp_number_image.width / 10
      @sp_im_ch = @sp_number_image.height  
      #Meter SP -----
      @sp_image = Cache.system("Hud_MP_Meter")
      @sp_range = @sp_image.width
      @sp_height = @sp_image.height
      @sp_width = @sp_range  * @actor.mp / @actor.mmp        
      @sp_width_old = @sp_width
      @sp_sprite = Sprite.new
      @sp_sprite.bitmap = Bitmap.new(@sp_image.width,@sp_image.height)
      @sp_sprite.z = 2 + HUD_Z
      @sp_sprite.x = HUD[0] + MP_METER[0]
      @sp_sprite.y = HUD[1] + MP_METER[1]
      mp_flow_update
      mp_number_refresh      
  end  
    
  #--------------------------------------------------------------------------
  # ● create_level
  #--------------------------------------------------------------------------
   def create_level
       @level = @actor.level 
       @exp = @actor.exp
       @level_image = Cache.system("Hud_Exp_Meter")
       @level_sprite = Sprite.new   
       @level_sprite.bitmap = Bitmap.new(@level_image.width,@level_image.height)       
       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_sprite.bitmap.blt(0,0, @level_image, @level_src_rect_back)      
       @level_sprite.z = 2 + HUD_Z
       @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_sprite = Sprite.new
       @level_number_sprite.bitmap = Bitmap.new(@level_number_image.width,@level_number_image.height)
       @level_number_sprite.z = HUD_Z + 3
       @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_update
  end  
     
  #--------------------------------------------------------------------------
  # ●  Dispose
  #--------------------------------------------------------------------------
  def dispose
      return if @layout_sprite == nil
      #Hp Number Dispose
      @hp_number_sprite.bitmap.dispose
      @hp_number_sprite.dispose
      #HP Meter Dispose
      @hp_sprite.bitmap.dispose
      @hp_sprite.dispose
      #MP Number Dispose
      @sp_number_sprite.bitmap.dispose
      @sp_number_sprite.dispose
      #MP Meter Dispose
      @sp_sprite.bitmap.dispose
      @sp_sprite.dispose
      #States Dispose
      @states.bitmap.dispose
      @states.dispose
      #Level Meter Dispose
      @level_sprite.bitmap.dispose
      @level_sprite.dispose
      #Level Number Dispose
      @level_number_sprite.bitmap.dispose
      @level_number_sprite.dispose
      #Layout Dispose
      @layout_sprite.bitmap.dispose
      @layout_sprite.dispose
      @layout_sprite = nil
      #Face Dispose
      @face_sprite.bitmap.dispose
      @face_sprite.dispose
      #Dispose Images
      @hp_number_image.dispose
      @hp_image.dispose
      @sp_number_image.dispose
      @sp_image.dispose
      @level_image.dispose
      @level_number_image.dispose
      @face_image.dispose    
  end
  #--------------------------------------------------------------------------
  # ● Update Visible
  #--------------------------------------------------------------------------
  def update_visible
      #Visible
      if $game_message.visible or $game_system.hud_visible == false
         vis = false
      else
         vis = true
      end  
      @hp_number_sprite.visible = vis
      @hp_sprite.visible = vis
      @sp_number_sprite.visible = vis
      @sp_sprite.visible = vis
      @states.visible = vis
      @level_sprite.visible = vis
      @level_number_sprite.visible = vis
      @layout_sprite.visible = vis
      @face_sprite.visible = vis   
  end
  
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  def update
      if @actor == nil
         refresh_actor if $game_party.members[0] != nil
         return 
      end  
      update_visible
      hp_number_update if @hp_old != @actor.hp
      hp_number_refresh if @hp_refresh or @actor.hp == 0 
      mp_number_update if @sp_old != @actor.mp
      mp_number_refresh if @sp_refresh
      level_update if @level != @actor.level
      exp_update if @exp != @actor.exp
      states_refresh
      hp_flow_update
      mp_flow_update
      refresh_actor if can_refresh_hud?      
   end
   
  #--------------------------------------------------------------------------
  # ● States Refresh
  #--------------------------------------------------------------------------
  def states_refresh
      return if @states_x == @actor.states.size
      @states_x = @actor.states.size
      @states.bitmap.clear
      return if @actor.states.size  == 0
      @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 
                 icon.dispose
           end
      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_number_text = @hp.abs.to_s.split(//)
      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, 0, @im_cw, @im_ch)
         @hp_number_sprite.bitmap.blt(@im_cw *  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.mhp  
          #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(0, 0,@hp_width_old, @hp_height)
          @hp_sprite.bitmap.blt(0,0, @hp_image, @hp_src_rect_old)       
          end        
      #HP Real------------------------------------
      @hp_src_rect = Rect.new(0, 0,@hp_width, @hp_height)
      @hp_sprite.bitmap.blt(0,0, @hp_image, @hp_src_rect)          
  end
    
  #--------------------------------------------------------------------------
  # ● Mp_number_update
  #--------------------------------------------------------------------------
  def mp_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 @sp >= @actor.mp
          @sp_old = @actor.mp 
          @sp = @actor.mp   
          @sp_ref = 0         
       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 @sp <= @actor.mp
          @sp_old = @actor.mp 
          @sp = @actor.mp   
          @sp_ref = 0         
        end          
    end     
  end 
  
  #--------------------------------------------------------------------------
  # ● Mp_number_refresh
  #--------------------------------------------------------------------------
  def mp_number_refresh 
      @sp_number_sprite.bitmap.clear
      @s = @actor.mp * 100 / @actor.mmp
      @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 
         @sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, 0, @sp_im_cw, @sp_im_ch)
         @sp_number_sprite.bitmap.blt(@sp_im_cw *  r, 0, @sp_number_image, @sp_src_rect)        
      end  
      @sp_refresh = false if @sp == @actor.mp
   end       
   
  #--------------------------------------------------------------------------
  # ● Mp Flow Update
  #--------------------------------------------------------------------------
  def mp_flow_update
      @sp_sprite.bitmap.clear
      @sp_width = @sp_range  * @actor.mp / @actor.mmp 
          #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(0, 0,@sp_width_old, @sp_height)
          @sp_sprite.bitmap.blt(0,0, @sp_image, @sp_src_rect_old) 
          end
      #SP Real------------------------------------
      @sp_src_rect = Rect.new(0, 0,@sp_width, @sp_height)
      @sp_sprite.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(//)
      ex = 0
      for r in 0..@level_number_text.size - 1
         ex += 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_sprite.bitmap.blt(@level_im_cw *  r, 0, @level_number_image, @level_src_rect)        
      end       
      @level = @actor.level
      cx = ex * (@level_im_cw / 2)
      @level_number_sprite.x = HUD[0] + EXP_NUMBER[0] - cx
      hp_number_refresh 
      mp_number_refresh 
  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_sprite.bitmap.blt(0,0, @level_image, @level_src_rect_back)  
      @exp = @actor.exp
  end
    
  #--------------------------------------------------------------------------
  # ● Can Refresh Hud
  #--------------------------------------------------------------------------    
  def can_refresh_hud?
      if $game_party.members[0] == nil
         return true if @pre_leader_id != nil
      elsif $game_party.members[0] != nil   
         return true if @pre_leader_id == nil
         return true if @pre_leader_id != $game_party.members[0].id 
      end  
      return false
  end  
    
end

#==============================================================================
# ■ Spriteset_Map
#==============================================================================
class Spriteset_Map
  
  #--------------------------------------------------------------------------
  # ● initialize  
  #--------------------------------------------------------------------------
  alias mog_hud_initialize initialize 
  def initialize  
      @hud = Hud.new
      mog_hud_initialize
  end
  
  #--------------------------------------------------------------------------
  # ● dispose
  #--------------------------------------------------------------------------
  alias mog_hud_dispose dispose
  def dispose    
      @hud.dispose
      mog_hud_dispose
  end
  
  #--------------------------------------------------------------------------
  # ● update   
  #--------------------------------------------------------------------------
  alias mog_hud_update update
  def update   
      @hud.update
      mog_hud_update
  end

end   

$mog_rgss3_master_hud = true

end

 

 

Bugs e Conflitti Noti

N/A

Logicamente non sarà compatibile con altri script che influenzano l' HUD

Altri dettagli

Ecco il risultato finale:

http://img202.imageshack.us/img202/4219/immaginefpn.jpg

La barra AT in basso fa parte di un ulteriore Add On.

Edited May 9, 2013 by Mithos

[Guardian of Irael]

Ah ottimo pure i face adattabili con grandezze diverse! ^ ^

 

Basta che vi parlate e non postate doppioni! XD

^ ^