Chaos Project

#_______________________________________________________________________________
# MOG - C Hud 2.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
#_______________________________________________________________________________
# HISTÓRICO
# 30/12/2010 (v2.0) -> Melhor codificação e compatibilidade.
#_______________________________________________________________________________
module MOG_C_HUD
    #Posição geral da HUD 
    HUD_POS = [0,0]
    #Posição do numero de HP
    HP_NUMBER_POS = [120,5]
    #Posição do medidor de HP
    HP_METER_POS = [140,5]
    #Posição do numero de SP
    SP_NUMBER_POS = [80,25]
    #Posição do medidor de SP
    SP_METER_POS = [100,25]
    #Posição posição do level
    LEVEL_POS = [55,0]  #Posição posição do medidor de exp
    LEVEL_METER_POS = [72,47]
    #Posição dos ícones de status
    STATES_POS = [460,0]
    #Deixar a HUD opaco caso o herói estiver em cima da HUD.
    FADE = true
    #Tamanho planejado da hud, isso influência no sensor do FADE.
    HUD_SIZE = [420,64]
    #Switch que desativa a HUD
    DISABLE_C_HUD_SWITCH = 5
    #Prioridade da hud. (Z)
    HUD_PRIORITY = 5000
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_C_HUD
  
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport)
      super(viewport) 
      @actor = $game_player.battler #$game_party.actors[0] 
      return if @actor == nil
      setup
      create_layout 
      create_hp_number 
      create_hp_meter
      create_sp_number
      create_sp_meter
      create_level_number
      create_level_meter
      create_state
      update_visible 
      sp_flow_update
      sp_number_refresh         
      hp_flow_update
      hp_number_refresh   
  end
 
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup
      @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 = HUD_SIZE[0]
      hud_size_y = HUD_SIZE[1]
      @oc_range_x = hud_size_x + HUD_POS[0]
      @oc_range_y = hud_size_y + HUD_POS[1] 
  end  
    
  #--------------------------------------------------------------------------
  # * Create Layout  
  #--------------------------------------------------------------------------  
  def create_layout  
      @layout_sprite = Sprite.new
      @layout_sprite.bitmap = RPG::Cache.windowskin("C_Layout")
      @layout_sprite.z = 1 + HUD_PRIORITY
      @layout_sprite.x = HUD_POS[0]
      @layout_sprite.y = HUD_POS[1]     
  end  
  
  #--------------------------------------------------------------------------
  # * Create HP Number  
  #--------------------------------------------------------------------------  
  def create_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 = 3 + HUD_PRIORITY 
      @hp_number_sprite.x = HUD_POS[0] + HP_NUMBER_POS[0]
      @hp_number_sprite.y = HUD_POS[1] + HP_NUMBER_POS[1]
      @im_cw = @hp_number_image.width / 10
      @im_ch = @hp_number_image.height / 2    
      @hp_src_rect = Rect.new(@im_cw,0, @im_cw, @im_ch)
      @hp_number_text = @actor.hp.abs.to_s.split(//)
      lowhp2 = @actor.maxhp * 30 / 100
      if @actor.hp < lowhp2
         @health2 = @im_ch 
      else
         @health2 = 0
      end
      @hp_health = @health2
      for r in 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        
  end  
  
  #--------------------------------------------------------------------------
  # * Create HP Meter
  #--------------------------------------------------------------------------    
  def create_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 = 2 + HUD_PRIORITY
      @hp_sprite.x = HUD_POS[0] + HP_METER_POS[0]
      @hp_sprite.y = HUD_POS[1] + HP_METER_POS[1]  
  end

  #--------------------------------------------------------------------------
  # * Create SP Number
  #--------------------------------------------------------------------------      
  def create_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 = 3 + HUD_PRIORITY
      @sp_number_sprite.x = HUD_POS[0] + SP_NUMBER_POS[0]
      @sp_number_sprite.y = HUD_POS[1] + SP_NUMBER_POS[1]
      @sp_im_cw = @sp_number_image.width / 10
      @sp_im_ch = @sp_number_image.height / 2    
      @sp_src_rect = Rect.new(@sp_im_cw,0, @sp_im_cw, @sp_im_ch)
      @sp_number_text = @actor.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           
  end  
  
  #--------------------------------------------------------------------------
  # * Create SP Meter
  #--------------------------------------------------------------------------        
  def create_sp_meter
      @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 = 2 + HUD_PRIORITY
      @sp_sprite.x = HUD_POS[0] + SP_METER_POS[0]
      @sp_sprite.y = HUD_POS[1] + SP_METER_POS[1]  
  end  
  
  #--------------------------------------------------------------------------
  # * Create Level Number
  #--------------------------------------------------------------------------          
  def create_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 = 3 + HUD_PRIORITY
      @level_number_sprite.x = HUD_POS[0] + LEVEL_POS[0]
      @level_number_sprite.y = HUD_POS[1] + LEVEL_POS[1]
      @level_im_cw = @level_number_image.width / 10
      @level_im_ch = @level_number_image.height     
      @level_number_text = @actor.level.abs.to_s.split(//)
      for r in 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        
  end  
  
  #--------------------------------------------------------------------------
  # * Create Level Meter
  #--------------------------------------------------------------------------          
  def create_level_meter
      @level_image = RPG::Cache.windowskin("C_Exp_Meter")
      @level_bitmap = Bitmap.new(@level_image.width,@level_image.height)
      @level_sprite = Sprite.new   
      rate = @actor.now_exp.to_f / @actor.next_exp
      rate = 1 if @actor.next_exp == 0
      @level_cw = @level_image.width * rate 
      @level_cw = @level_image.width if @actor.level == 99
      @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 = 2 + HUD_PRIORITY
      @level_sprite.x = HUD_POS[0] + LEVEL_METER_POS[0]
      @level_sprite.y = HUD_POS[1] + LEVEL_METER_POS[1]    
   end  
    
  #--------------------------------------------------------------------------
  # * Create State
  #--------------------------------------------------------------------------             
  def create_state
       @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 = HUD_POS[0] + STATES_POS[0]
       @states.y = HUD_POS[1] + STATES_POS[1]
       @states.z = 4 + HUD_PRIORITY              
   end  
  
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose 
      return if @actor == nil
      #Layout Dispose
      @layout_sprite.bitmap.dispose
      @layout_sprite.dispose
      #Hp Number Dispose
      @hp_number_sprite.bitmap.dispose
      @hp_number_sprite.dispose
      @hp_number_bitmap.dispose
      #HP Meter Dispose
      @hp_sprite.bitmap.dispose
      @hp_sprite.dispose
      @hp_bitmap.dispose
      #SP Number Dispose
      @sp_number_sprite.bitmap.dispose
      @sp_number_sprite.dispose
      @sp_number_bitmap.dispose
      #SP Meter Dispose
      @sp_sprite.bitmap.dispose
      @sp_sprite.dispose
      @sp_bitmap.dispose
      #Level Number Dispose
      @level_number_sprite.bitmap.dispose
      @level_number_sprite.dispose
      @level_number_bitmap.dispose
      #Level Meter Dispose
      @level_sprite.bitmap.dispose
      @level_sprite.dispose
      @level_bitmap.dispose
      #States Dispose
      @states.bitmap.dispose
      @states.dispose
      @states = nil
      super
  end  
  
  #--------------------------------------------------------------------------
  # * Updade
  #--------------------------------------------------------------------------
  def update
      super
       return if @actor == nil
       @actor = $game_player.battler if @actor != $game_player.battler
       update_visible
       hp_number_update if @hp_old != @actor.hp
       hp_number_refresh if @hp_refresh == true or @actor.hp == 0 
       sp_number_update if @sp_old != @actor.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
       update_fade if FADE == true
       update_states
  end
  
  #--------------------------------------------------------------------------
  # * update fade
  #--------------------------------------------------------------------------
  def update_fade 
      x = ($game_player.real_x - $game_map.display_x) / 4
      y = ($game_player.real_y - $game_map.display_y) / 4
      if x < @oc_range_x and x > HUD_POS[0] - 5 and
         y > HUD_POS[1] - 5 and y < @oc_range_y and
           @hp_number_sprite.opacity > 120
           @hp_number_sprite.opacity -= 10
           @hp_sprite.opacity -= 10
           @sp_number_sprite.opacity -= 10
           @sp_sprite.opacity -= 10
           @states.opacity -= 10
           @level_sprite.opacity -= 10
           @level_number_sprite.opacity -= 10
           @layout_sprite.opacity -= 10
      elsif @hp_number_sprite.opacity < 255
           @hp_number_sprite.opacity += 10
           @hp_sprite.opacity += 10
           @sp_number_sprite.opacity += 10
           @sp_sprite.opacity += 10
           @states.opacity += 10
           @level_sprite.opacity += 10
           @level_number_sprite.opacity += 10
           @layout_sprite.opacity += 10
     end
  end     
  
  #--------------------------------------------------------------------------
  # * Update States
  #--------------------------------------------------------------------------
  def update_states
      @states.x = HUD_POS[0] + STATES_POS[0]
      @states.y = HUD_POS[1] + STATES_POS[1]
      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
  
  #--------------------------------------------------------------------------
  # * update_visible
  #--------------------------------------------------------------------------
  def update_visible
      if $game_switches[DISABLE_C_HUD_SWITCH] == true
         hud_visible = false
      else  
         hud_visible = true
      end  
      @layout_sprite.visible = hud_visible
      @hp_number_sprite.visible = hud_visible
      @hp_sprite.visible = hud_visible
      @sp_number_sprite.visible = hud_visible
      @sp_sprite.visible = hud_visible
      @level_number_sprite.visible = hud_visible
      @states.visible = hud_visible
  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    
      rate = @actor.now_exp.to_f / @actor.next_exp
      rate = 1 if @actor.next_exp == 0
      @level_cw = @level_image.width * rate 
      @level_cw = @level_image.width if @actor.level == 99
      @level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
      @level_bitmap.blt(0,0, @level_image, @level_src_rect_back)  
      @exp = @actor.exp
  end     
end  

#===============================================================================
# ** Spriteset_Map
#===============================================================================
class Spriteset_Map
  
  #--------------------------------------------------------------------------
  # * initialize
  #--------------------------------------------------------------------------
  alias mog_chud_initialize initialize
  def initialize
      @cthud = C_Hud.new(@viewport3)    
      mog_chud_initialize 
  end
   
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  alias mog_chud_dispose dispose
  def dispose
      mog_chud_dispose
      @cthud.dispose
  end  
    
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias mog_chud_update update
  def update
      mog_chud_update
      @cthud.update
  end      
end    

$mog_rgssxp_c_hud = true

#_______________________________________________________________________________
# MOG - C Hud 2.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
#_______________________________________________________________________________
# HISTÓRICO
# 30/12/2010 (v2.0) -> Melhor codificação e compatibilidade.
#_______________________________________________________________________________
module MOG_C_HUD
    #Posição geral da HUD 
    HUD_POS = [0,0]
    #Posição do numero de HP
    HP_NUMBER_POS = [120,5]
    #Posição do medidor de HP
    HP_METER_POS = [140,5]
    #Posição do numero de SP
    SP_NUMBER_POS = [80,25]
    #Posição do medidor de SP
    SP_METER_POS = [100,25]
    #Posição posição do level
    LEVEL_POS = [55,0]  #Posição posição do medidor de exp
    LEVEL_METER_POS = [72,47]
    #Posição dos ícones de status
    STATES_POS = [460,0]
    #Deixar a HUD opaco caso o herói estiver em cima da HUD.
    FADE = true
    #Tamanho planejado da hud, isso influência no sensor do FADE.
    HUD_SIZE = [420,64]
    #Switch que desativa a HUD
    DISABLE_C_HUD_SWITCH = 5
    #Prioridade da hud. (Z)
    HUD_PRIORITY = 5000
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
  attr_reader :need_dispose
  include MOG_C_HUD
  
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport)
      super(viewport) 
      @actor = $game_player.battler #$game_party.actors[0] 
      @need_dispose = false
      return if @actor == nil
      setup
      create_layout 
      create_hp_number 
      create_hp_meter
      create_sp_number
      create_sp_meter
      create_level_number
      create_level_meter
      create_state
      update_visible 
      sp_flow_update
      sp_number_refresh         
      hp_flow_update
      hp_number_refresh   
  end
 
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup
      @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 = HUD_SIZE[0]
      hud_size_y = HUD_SIZE[1]
      @oc_range_x = hud_size_x + HUD_POS[0]
      @oc_range_y = hud_size_y + HUD_POS[1] 
  end  
    
  #--------------------------------------------------------------------------
  # * Create Layout  
  #--------------------------------------------------------------------------  
  def create_layout  
      @layout_sprite = Sprite.new
      @layout_sprite.bitmap = RPG::Cache.windowskin("C_Layout")
      @layout_sprite.z = 1 + HUD_PRIORITY
      @layout_sprite.x = HUD_POS[0]
      @layout_sprite.y = HUD_POS[1]     
  end  
  
  #--------------------------------------------------------------------------
  # * Create HP Number  
  #--------------------------------------------------------------------------  
  def create_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 = 3 + HUD_PRIORITY 
      @hp_number_sprite.x = HUD_POS[0] + HP_NUMBER_POS[0]
      @hp_number_sprite.y = HUD_POS[1] + HP_NUMBER_POS[1]
      @im_cw = @hp_number_image.width / 10
      @im_ch = @hp_number_image.height / 2    
      @hp_src_rect = Rect.new(@im_cw,0, @im_cw, @im_ch)
      @hp_number_text = @actor.hp.abs.to_s.split(//)
      lowhp2 = @actor.maxhp * 30 / 100
      if @actor.hp < lowhp2
         @health2 = @im_ch 
      else
         @health2 = 0
      end
      @hp_health = @health2
      for r in 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        
  end  
  
  #--------------------------------------------------------------------------
  # * Create HP Meter
  #--------------------------------------------------------------------------    
  def create_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 = 2 + HUD_PRIORITY
      @hp_sprite.x = HUD_POS[0] + HP_METER_POS[0]
      @hp_sprite.y = HUD_POS[1] + HP_METER_POS[1]  
  end

  #--------------------------------------------------------------------------
  # * Create SP Number
  #--------------------------------------------------------------------------      
  def create_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 = 3 + HUD_PRIORITY
      @sp_number_sprite.x = HUD_POS[0] + SP_NUMBER_POS[0]
      @sp_number_sprite.y = HUD_POS[1] + SP_NUMBER_POS[1]
      @sp_im_cw = @sp_number_image.width / 10
      @sp_im_ch = @sp_number_image.height / 2    
      @sp_src_rect = Rect.new(@sp_im_cw,0, @sp_im_cw, @sp_im_ch)
      @sp_number_text = @actor.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           
  end  
  
  #--------------------------------------------------------------------------
  # * Create SP Meter
  #--------------------------------------------------------------------------        
  def create_sp_meter
      @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 = 2 + HUD_PRIORITY
      @sp_sprite.x = HUD_POS[0] + SP_METER_POS[0]
      @sp_sprite.y = HUD_POS[1] + SP_METER_POS[1]  
  end  
  
  #--------------------------------------------------------------------------
  # * Create Level Number
  #--------------------------------------------------------------------------          
  def create_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 = 3 + HUD_PRIORITY
      @level_number_sprite.x = HUD_POS[0] + LEVEL_POS[0]
      @level_number_sprite.y = HUD_POS[1] + LEVEL_POS[1]
      @level_im_cw = @level_number_image.width / 10
      @level_im_ch = @level_number_image.height     
      @level_number_text = @actor.level.abs.to_s.split(//)
      for r in 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        
  end  
  
  #--------------------------------------------------------------------------
  # * Create Level Meter
  #--------------------------------------------------------------------------          
  def create_level_meter
      @level_image = RPG::Cache.windowskin("C_Exp_Meter")
      @level_bitmap = Bitmap.new(@level_image.width,@level_image.height)
      @level_sprite = Sprite.new   
      rate = @actor.now_exp.to_f / @actor.next_exp
      rate = 1 if @actor.next_exp == 0
      @level_cw = @level_image.width * rate 
      @level_cw = @level_image.width if @actor.level == 99
      @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 = 2 + HUD_PRIORITY
      @level_sprite.x = HUD_POS[0] + LEVEL_METER_POS[0]
      @level_sprite.y = HUD_POS[1] + LEVEL_METER_POS[1]    
   end  
    
  #--------------------------------------------------------------------------
  # * Create State
  #--------------------------------------------------------------------------             
  def create_state
       @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 = HUD_POS[0] + STATES_POS[0]
       @states.y = HUD_POS[1] + STATES_POS[1]
       @states.z = 4 + HUD_PRIORITY              
   end  
  
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose 
      return if @actor == nil
      #Layout Dispose
      @layout_sprite.bitmap.dispose
      @layout_sprite.dispose
      #Hp Number Dispose
      @hp_number_sprite.bitmap.dispose
      @hp_number_sprite.dispose
      @hp_number_bitmap.dispose
      #HP Meter Dispose
      @hp_sprite.bitmap.dispose
      @hp_sprite.dispose
      @hp_bitmap.dispose
      #SP Number Dispose
      @sp_number_sprite.bitmap.dispose
      @sp_number_sprite.dispose
      @sp_number_bitmap.dispose
      #SP Meter Dispose
      @sp_sprite.bitmap.dispose
      @sp_sprite.dispose
      @sp_bitmap.dispose
      #Level Number Dispose
      @level_number_sprite.bitmap.dispose
      @level_number_sprite.dispose
      @level_number_bitmap.dispose
      #Level Meter Dispose
      @level_sprite.bitmap.dispose
      @level_sprite.dispose
      @level_bitmap.dispose
      #States Dispose
      @states.bitmap.dispose
      @states.dispose
      @states = nil
      super
  end  
  
  #--------------------------------------------------------------------------
  # * Updade
  #--------------------------------------------------------------------------
  def update
      super
       return if @actor == nil
       if @actor != $game_player.battler
         @need_dispose = true
         return
       end
       update_visible
       hp_number_update if @hp_old != @actor.hp
       hp_number_refresh if @hp_refresh == true or @actor.hp == 0 
       sp_number_update if @sp_old != @actor.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
       update_fade if FADE == true
       update_states
  end
  
  #--------------------------------------------------------------------------
  # * update fade
  #--------------------------------------------------------------------------
  def update_fade 
      x = ($game_player.real_x - $game_map.display_x) / 4
      y = ($game_player.real_y - $game_map.display_y) / 4
      if x < @oc_range_x and x > HUD_POS[0] - 5 and
         y > HUD_POS[1] - 5 and y < @oc_range_y and
           @hp_number_sprite.opacity > 120
           @hp_number_sprite.opacity -= 10
           @hp_sprite.opacity -= 10
           @sp_number_sprite.opacity -= 10
           @sp_sprite.opacity -= 10
           @states.opacity -= 10
           @level_sprite.opacity -= 10
           @level_number_sprite.opacity -= 10
           @layout_sprite.opacity -= 10
      elsif @hp_number_sprite.opacity < 255
           @hp_number_sprite.opacity += 10
           @hp_sprite.opacity += 10
           @sp_number_sprite.opacity += 10
           @sp_sprite.opacity += 10
           @states.opacity += 10
           @level_sprite.opacity += 10
           @level_number_sprite.opacity += 10
           @layout_sprite.opacity += 10
     end
  end     
  
  #--------------------------------------------------------------------------
  # * Update States
  #--------------------------------------------------------------------------
  def update_states
      @states.x = HUD_POS[0] + STATES_POS[0]
      @states.y = HUD_POS[1] + STATES_POS[1]
      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
  
  #--------------------------------------------------------------------------
  # * update_visible
  #--------------------------------------------------------------------------
  def update_visible
      if $game_switches[DISABLE_C_HUD_SWITCH] == true
         hud_visible = false
      else  
         hud_visible = true
      end  
      @layout_sprite.visible = hud_visible
      @hp_number_sprite.visible = hud_visible
      @hp_sprite.visible = hud_visible
      @sp_number_sprite.visible = hud_visible
      @sp_sprite.visible = hud_visible
      @level_number_sprite.visible = hud_visible
      @states.visible = hud_visible
  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    
      rate = @actor.now_exp.to_f / @actor.next_exp
      rate = 1 if @actor.next_exp == 0
      @level_cw = @level_image.width * rate 
      @level_cw = @level_image.width if @actor.level == 99
      @level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
      @level_bitmap.blt(0,0, @level_image, @level_src_rect_back)  
      @exp = @actor.exp
  end     
end  

#===============================================================================
# ** Spriteset_Map
#===============================================================================
class Spriteset_Map
  
  #--------------------------------------------------------------------------
  # * initialize
  #--------------------------------------------------------------------------
  alias mog_chud_initialize initialize
  def initialize
      @cthud = C_Hud.new(@viewport3)    
      mog_chud_initialize 
  end
   
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  alias mog_chud_dispose dispose
  def dispose
      mog_chud_dispose
      @cthud.dispose
  end  
    
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias mog_chud_update update
  def update
      mog_chud_update
      @cthud.update
      if @cthud.need_dispose
        @cthud.dispose
        @cthud = C_Hud.new(@viewport3) 
      end
  end      
end    

$mog_rgssxp_c_hud = true