MOG - Active Hud VX 1.2

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

#==============================================================================
# Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # * now_exp
  #--------------------------------------------------------------------------     
  def now_exp
      return @exp - @exp_list[@level]
  end
  #--------------------------------------------------------------------------
  # * next_exp
  #--------------------------------------------------------------------------         
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end
end

#==============================================================================
# Game_Temp
#==============================================================================
class Game_Temp
  attr_accessor :hud_face_type
  attr_accessor :hud_face_time
  attr_accessor :hud_face_time2
  attr_accessor :hud_face_refresh
  alias active_hud_initialize initialize
  def initialize
    active_hud_initialize
    @hud_face_type = 0
    @hud_face_time = 0
    @hud_face_time2 = 0
    @hud_face_refresh = false
  end   
end
#==============================================================================
# Active_Hud
#==============================================================================
class Active_Hud < Sprite 
  include MOG
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport)
    super(viewport)
    @actor = $game_party.members[0]
    return if @actor == nil
    create_layout   
    create_state
    create_hp 
    create_sp   
    create_level
    create_face
    update_visible   
  end
 
  #--------------------------------------------------------------------------
  # * create_layout
  #-------------------------------------------------------------------------- 
  def create_layout
    @layout_image = Cache.system("Hud_Layout")
    @layout_bitmap = Bitmap.new(@layout_image.width,@layout_image.height)
    @layout_sprite = Sprite.new
    @layout_sprite.bitmap = @layout_bitmap
    @layout_src_rect_back = Rect.new(0, 0,@layout_image.width, @layout_image.height)
    @layout_bitmap.blt(0,0, @layout_image, @layout_src_rect_back)     
    @layout_sprite.z = 150
    @layout_sprite.x = HUD[0] + LAYOUT[0]
    @layout_sprite.y = HUD[1] + LAYOUT[1] 
  end
 
  #--------------------------------------------------------------------------
  # * create_face
  #--------------------------------------------------------------------------     
  def create_face
    @face_image = Cache.system("Hud_Face")
    @face_bitmap = Bitmap.new(@face_image.width,@face_image.height)
    @face_sprite = Sprite.new
    @face_sprite.bitmap = @face_bitmap
    @face_cw = @face_bitmap.width / 5
    @face_ch = @face_bitmap.height
    @face_src_rect_back = Rect.new(@face_cw * $game_temp.hud_face_type, 0,@face_cw , @face_ch)
    @face_bitmap.blt(0,0, @face_image, @face_src_rect_back)     
    @face_sprite.z = 153
    @face_sprite.x = HUD[0] + FACE[0]
    @face_sprite.y = HUD[1] + FACE[1]       
    if @actor.hp < @actor.maxhp * @low_hp / 100
      $game_temp.hud_face_type = 4             
    else
      $game_temp.hud_face_type = 0
    end           
    $game_temp.hud_face_time = 10   
  end
 
  #--------------------------------------------------------------------------
  # * create_state
  #--------------------------------------------------------------------------   
  def create_state
    @states_max = 0
    @states = Sprite.new
    @states.bitmap = Bitmap.new(104,24)
    @states_x = @actor.states.size
    @states_y = 0
    @states_f = false
    @states_max = 0
    for i in @actor.states 
      unless @states_max > 3
      icon = Cache.system("Iconset")
      icon_index = i.icon_index
      rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      @states.bitmap.blt(24 * @states_max, 0, icon, rect)
      @states_max += 1
      end   
    end
    if STATES_POS_CHARACTER == true 
      @states.x = 5 -(13 * @states_x) + $game_player.screen_x
      @states.y = @states_y + $game_player.screen_y
    else
      @states.x = HUD[0] + STATES[0]
      @states.y = @states_y + HUD[1] + STATES[1]
    end
    @states.z = 153   
  end
 
  #--------------------------------------------------------------------------
  # * create_hp
  #-------------------------------------------------------------------------- 
  def create_hp
    @low_hp = LOWHP
    @hp = @actor.hp
    @hp_flow = 0
    @hp_damage_flow = 0 
    @hp_old = @actor.hp
    @hp_ref = @hp_old
    @hp_refresh = false   
    @hp_number_image = Cache.system("Hud_HP_Number")
    @hp_number_bitmap = Bitmap.new(@hp_number_image.width,@hp_number_image.height)
    @hp_number_sprite = Sprite.new
    @hp_number_sprite.bitmap = @hp_number_bitmap
    @hp_number_sprite.z = 153
    @hp_number_sprite.x = HUD[0] + HP_NUMBER[0]
    @hp_number_sprite.y = HUD[1] + HP_NUMBER[1]
    @im_cw = @hp_number_image.width / 10
    @im_ch = @hp_number_image.height / 2   
    @hp_src_rect = Rect.new(@im_cw,0, @im_cw, @im_ch)
    @hp_number_text = @actor.hp.abs.to_s.split(//)
      lowhp2 = @actor.maxhp * 30 / 100
      if @actor.hp < lowhp2
      @health2 = @im_ch
      else
      @health2 = 0
      end
      @hp_health = @health2
      for r in 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 
    #Number HP -----
    @hp_image = Cache.system("Hud_HP_Meter")
    @hp_bitmap = Bitmap.new(@hp_image.width,@hp_image.height)
    @hp_range = @hp_image.width / 3
    @hp_width = @hp_range  * @actor.hp / @actor.maxhp 
    @hp_height = @hp_image.height / 2
    @hp_width_old = @hp_width
    @hp_src_rect = Rect.new(@hp_range, 0, @hp_width, @hp_height)
    @hp_bitmap.blt(0,0, @hp_image, @hp_src_rect)
    @hp_sprite = Sprite.new
    @hp_sprite.bitmap = @hp_bitmap
    @hp_sprite.z = 152
    @hp_sprite.x = HUD[0] + HP_METER[0]
    @hp_sprite.y = HUD[1] + HP_METER[1]
    hp_flow_update
    hp_number_refresh   
  end
 
  #--------------------------------------------------------------------------
  # * create_sp
  #-------------------------------------------------------------------------- 
  def create_sp
      @low_sp = LOWHP
      @sp = @actor.mp
      @sp_old = @actor.mp
      @sp_ref = @sp_old
      @sp_refresh = false
      @sp_flow = 0
      @sp_damage_flow = 0   
      @sp_number_image = Cache.system("Hud_SP_Number")
      @sp_number_bitmap = Bitmap.new(@sp_number_image.width,@sp_number_image.height)
      @sp_number_sprite = Sprite.new
      @sp_number_sprite.bitmap = @sp_number_bitmap
      @sp_number_sprite.z = 153
      @sp_number_sprite.x = HUD[0] + SP_NUMBER[0]
      @sp_number_sprite.y = HUD[1] + SP_NUMBER[1]
      @sp_im_cw = @sp_number_image.width / 10
      @sp_im_ch = @sp_number_image.height / 2   
      @sp_src_rect = Rect.new(@sp_im_cw,0, @sp_im_cw, @sp_im_ch)
      @sp_number_text = @actor.mp.abs.to_s.split(//)
      for r in 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   
      #Number SP -----
      @sp_image = Cache.system("Hud_SP_Meter")
      @sp_bitmap = Bitmap.new(@sp_image.width,@sp_image.height)
      @sp_range = @sp_image.width / 3
      @sp_width = @sp_range  * @actor.mp / @actor.maxmp 
      @sp_height = @sp_image.height / 2
      @sp_width_old = @sp_width
      @sp_src_rect = Rect.new(@sp_range, 0, @sp_width, @sp_height)
      @sp_bitmap.blt(0,0, @sp_image, @sp_src_rect)
      @sp_sprite = Sprite.new
      @sp_sprite.bitmap = @sp_bitmap
      @sp_sprite.z = 152
      @sp_sprite.x = HUD[0] + SP_METER[0]
      @sp_sprite.y = HUD[1] + SP_METER[1]
      sp_flow_update
      sp_number_refresh   
  end 
   
  #--------------------------------------------------------------------------
  # * create_level
  #--------------------------------------------------------------------------
  def create_level
      @level = @actor.level
      @exp = @actor.exp
      @level_image = Cache.system("Hud_Exp_Meter")
      @level_bitmap = Bitmap.new(@level_image.width,@level_image.height)
      @level_sprite = Sprite.new 
      if @actor.next_exp != 0
          rate = @actor.now_exp.to_f / @actor.next_exp
      else
          rate = 1
      end
      if @actor.level < 99
          @level_cw = @level_image.width * rate
      else
          @level_cw = @level_image.width
      end     
      @level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
      @level_bitmap.blt(0,0, @level_image, @level_src_rect_back)
      @level_sprite.bitmap = @level_bitmap
      @level_sprite.z = 152
      @level_sprite.x = HUD[0] + EXP_METER[0]
      @level_sprite.y = HUD[1] + EXP_METER[1] 
      # Level Number -----
      @level_number_image = Cache.system("Hud_Exp_Number")
      @level_number_bitmap = Bitmap.new(@level_number_image.width,@level_number_image.height)
      @level_number_sprite = Sprite.new
      @level_number_sprite.bitmap = @level_number_bitmap
      @level_number_sprite.z = 153
      @level_number_sprite.x = HUD[0] + EXP_NUMBER[0]
      @level_number_sprite.y = HUD[1] + EXP_NUMBER[1]
      @level_im_cw = @level_number_image.width / 10
      @level_im_ch = @level_number_image.height   
      @level_number_text = @actor.level.abs.to_s.split(//)
      for r in 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 
   
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose   
    return if @actor == nil
    #Hp Number Dispose
    @hp_number_sprite.bitmap.dispose
    @hp_number_sprite.dispose
    @hp_number_bitmap.dispose
    #HP Meter Dispose
    @hp_sprite.bitmap.dispose
    @hp_sprite.dispose
    @hp_bitmap.dispose
    #SP Number Dispose
    @sp_number_sprite.bitmap.dispose
    @sp_number_sprite.dispose
    @sp_number_bitmap.dispose
    #SP Meter Dispose
    @sp_sprite.bitmap.dispose
    @sp_sprite.dispose
    @sp_bitmap.dispose
    #States Dispose
    @states.bitmap.dispose
    @states.dispose
    #Level Meter Dispose
    @level_sprite.bitmap.dispose
    @level_sprite.dispose
    @level_bitmap.dispose
    #Level Number Dispose
    @level_number_sprite.bitmap.dispose
    @level_number_sprite.dispose
    @level_number_bitmap.dispose
    #Layout Dispose
    @layout_sprite.bitmap.dispose
    @layout_sprite.dispose
    @layout_bitmap.dispose
    #Face Dispose
    @face_sprite.bitmap.dispose
    @face_sprite.dispose
    @face_bitmap.dispose
    super
  end
  #--------------------------------------------------------------------------
  # * Visible_on
  #--------------------------------------------------------------------------
  def update_visible
    #Visible
    if $game_switches[MOG::DISABLE_HUD_SWITCH] == true
        @hp_number_sprite.visible = false 
        @hp_sprite.visible = false 
        @sp_number_sprite.visible = false
        @sp_sprite.visible = false 
        @states.visible = false
        @level_sprite.visible = false
        @level_number_sprite.visible = false
        @layout_sprite.visible = false
        @face_sprite.visible = false
    else   
        @hp_number_sprite.visible = true
        @hp_sprite.visible = true   
        @sp_number_sprite.visible = true
        @sp_sprite.visible = true 
        @states.visible = true
        @level_sprite.visible = true
        @level_number_sprite.visible = true
        @layout_sprite.visible = true
        @face_sprite.visible = true
    end     
  end
 
  #--------------------------------------------------------------------------
  # * Updade
  #--------------------------------------------------------------------------
  def update
    super
    return if @actor == nil
    update_visible
    hp_number_update if @hp_old != @actor.hp
    hp_number_refresh if @hp_refresh == true or @actor.hp == 0
    sp_number_update if @sp_old != @actor.mp
    sp_number_refresh if @sp_refresh == true
    level_update if @level != @actor.level
    level_up_effect if @level_number_sprite.zoom_x > 1.00 
    exp_update if @exp != @actor.exp
    states_effect if @states.zoom_x > 1.00 
    face_chance if $game_temp.hud_face_refresh == true or $game_temp.hud_face_time == 1
    face_normal if $game_temp.hud_face_time2 == 1
    face_effect
    states_update
    hp_flow_update
    sp_flow_update
    $game_temp.hud_face_time -= 1 if $game_temp.hud_face_time > 0
    $game_temp.hud_face_time2 -= 1 if $game_temp.hud_face_time2 > 0
  end
 
  #--------------------------------------------------------------------------
  # * face_normal
  #--------------------------------------------------------------------------
  def face_normal
    $game_temp.hud_face_refresh = false
    if @actor.hp < @actor.maxhp * @low_hp / 100
      $game_temp.hud_face_type = 4
    else 
      $game_temp.hud_face_type = 0
    end
    $game_temp.hud_face_time2 = 0
    @face_sprite.bitmap.clear
    @face_src_rect_back = Rect.new(@face_cw * $game_temp.hud_face_type, 0,@face_cw , @face_ch)
    @face_bitmap.blt(0,0, @face_image, @face_src_rect_back) 
    @face_sprite.x = HUD[0] + FACE[0]
  end 
 
  #--------------------------------------------------------------------------
  # * Face Chance
  #--------------------------------------------------------------------------
  def face_chance   
    $game_temp.hud_face_refresh = false
    @face_sprite.bitmap.clear
    @face_src_rect_back = Rect.new(@face_cw * $game_temp.hud_face_type, 0,@face_cw , @face_ch)
    @face_bitmap.blt(0,0, @face_image, @face_src_rect_back)
    @face_sprite.x = HUD[0] + FACE[0]
  end
 
  #--------------------------------------------------------------------------
  # * Face Effect
  #--------------------------------------------------------------------------
  def face_effect
    if $game_temp.hud_face_type == 2
      @face_sprite.x = HUD[0] + FACE[0] + rand(10)
      if $game_temp.hud_face_time == 2
        if @actor.hp < @actor.maxhp * @low_hp / 100
            $game_temp.hud_face_type = 4
        else           
            $game_temp.hud_face_type = 0
        end
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * States_Update
  #--------------------------------------------------------------------------
  def states_update
    if STATES_POS_CHARACTER == true 
      @states.x = 5 -(13 * @states_x) + $game_player.screen_x
      @states.y = @states_y + $game_player.screen_y
    else
      @states.x = HUD[0] + STATES[0]
      @states.y = @states_y + HUD[1] + STATES[1]
    end
    if FLOAT_STATES == true
    if @states_f == false
        @states_y += 1
        @states_f = true if @states_y > 10
    else   
        @states_y -= 1
        @states_f = false if @states_y < -10             
      end 
    end
    @states.opacity = 155 + rand(100)
    if @states_x != @actor.states.size
        @states_x = @actor.states.size
        @states.bitmap.clear
        @states_max = 0
        for i in @actor.states
          unless @states_max > 3
            icon = Cache.system("Iconset")
            icon_index = i.icon_index
            rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
            @states.bitmap.blt(24 * @states_max, 0, icon, rect)
            @states_max += 1
          end
    end 
      @states.zoom_x = 2
      @states.zoom_y = 2
    end
  end
 
  #--------------------------------------------------------------------------
  # * States_Effect
  #--------------------------------------------------------------------------
  def states_effect
      @states.zoom_x -= 0.02
      @states.zoom_y -= 0.02
    if @states.zoom_x <= 1.00   
      @states.zoom_x = 1.00
      @states.zoom_y = 1.00
    end 
  end
 
  #--------------------------------------------------------------------------
  # * hp_number_update
  #--------------------------------------------------------------------------
  def hp_number_update
      @hp_refresh = true
      if @hp_old < @actor.hp
          @hp_ref = 5 * (@actor.hp - @hp_old) / 100
          @hp_ref = 1 if @hp_ref < 1
          @hp += @hp_ref   
          if $game_temp.hud_face_type != 1
              $game_temp.hud_face_type = 1
              $game_temp.hud_face_refresh = true
              @face_sprite.x = HUD[0] + FACE[0]
          end         
          if @hp >= @actor.hp
              @hp_old = @actor.hp
              @hp = @actor.hp 
              @hp_ref = 0
            if @actor.hp < @actor.maxhp * @low_hp / 100 and
                $game_temp.hud_face_type != 4
                $game_temp.hud_face_type = 4
                $game_temp.hud_face_time = 30             
            elsif $game_temp.hud_face_type != 0
                $game_temp.hud_face_type = 0
                $game_temp.hud_face_time = 30
            end 
          end 
           
        elsif @hp_old > @actor.hp 
          @hp_refresh = true
          @hp_ref = 5 * (@hp_old - @actor.hp) / 100
          @hp_ref = 1 if @hp_ref < 1
          @hp -= @hp_ref               
          if $game_temp.hud_face_type != 2
              $game_temp.hud_face_type = 2
              $game_temp.hud_face_refresh = true             
          end
          if @hp <= @actor.hp
              @hp_old = @actor.hp
              @hp = @actor.hp 
              @hp_ref = 0
            if $game_temp.hud_face_type != 0
                $game_temp.hud_face_time = 30
            end 
          end           
        end 
  end 
     
  #--------------------------------------------------------------------------
  # * hp_number_refresh
  #--------------------------------------------------------------------------
  def hp_number_refresh
      @hp_number_sprite.bitmap.clear
      @hp_number_text = @hp.abs.to_s.split(//)
      lowhp2 = @actor.maxhp * @low_hp / 100
      if @actor.hp < lowhp2
      @health2 = @im_ch
      else
      @health2 = 0
      end
      @hp_health = @health2
      for r in 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---------------------------------
          if @hp_width_old != @hp_width
          valor = (@hp_width_old - @hp_width) * 3 / 100
          valor = 0.5 if valor < 1                               
          @hp_width_old -= valor if @hp_width_old > @hp_width 
          if @hp_width_old < @hp_width
            @hp_width_old = @hp_width
          end     
          @hp_src_rect_old = Rect.new(@hp_flow, @hp_height,@hp_width_old, @hp_height)
          @hp_bitmap.blt(0,0, @hp_image, @hp_src_rect_old)     
          end
       
      #HP Real------------------------------------
      @hp_src_rect = Rect.new(@hp_flow, 0,@hp_width, @hp_height)
      @hp_bitmap.blt(0,0, @hp_image, @hp_src_rect)
         
      @hp_flow += 5 
      if @hp_flow >= @hp_image.width - @hp_range
        @hp_flow = 0 
      end
  end
   
  #--------------------------------------------------------------------------
  # * Sp_number_update
  #--------------------------------------------------------------------------
  def sp_number_update
    @sp_refresh = true
    if @sp_old < @actor.mp
      @sp_refresh = true
      @sp_ref = 5 * (@actor.mp - @sp_old) / 100
      @sp_ref = 1 if @sp_ref < 1
      @sp += @sp_ref 
          if $game_temp.hud_face_type != 1
              $game_temp.hud_face_type = 1
              $game_temp.hud_face_refresh = true
              @face_sprite.x = HUD[0] + FACE[0]
          end         
      if @sp >= @actor.mp
          @sp_old = @actor.mp
          @sp = @actor.mp 
          @sp_ref = 0
            if @actor.hp < @actor.maxmp * @low_hp / 100 and
                $game_temp.hud_face_type != 4
                $game_temp.hud_face_type = 4
                $game_temp.hud_face_time = 30             
            elsif $game_temp.hud_face_type != 0
                $game_temp.hud_face_type = 0
                $game_temp.hud_face_time = 30
            end         
      end 
    elsif @sp_old >= @actor.mp   
      @sp_ref = 5 * (@sp_old - @actor.mp) / 100
      @sp_ref = 1 if @sp_ref < 1
      @sp -= @sp_ref   
          if $game_temp.hud_face_type != 3
              $game_temp.hud_face_type = 3
              $game_temp.hud_face_refresh = true
          end     
      if @sp <= @actor.mp
          @sp_old = @actor.mp
          @sp = @actor.mp 
          @sp_ref = 0
            if @actor.hp < @actor.maxhp * @low_hp / 100 and
                $game_temp.hud_face_type != 4
                $game_temp.hud_face_type = 4
                $game_temp.hud_face_time = 35             
            elsif $game_temp.hud_face_type != 0
                $game_temp.hud_face_type = 0
                $game_temp.hud_face_time = 35
            end             
        end         
    end   
  end
 
  #--------------------------------------------------------------------------
  # * sp_number_refresh
  #--------------------------------------------------------------------------
  def sp_number_refresh
    @sp_number_sprite.bitmap.clear
    @s = @actor.mp * 100 / @actor.maxmp
    @sp_number_text = @sp.abs.to_s.split(//)
      for r in 0..@sp_number_text.size - 1       
        @sp_number_abs = @sp_number_text[r].to_i
        if @actor.mp <= @actor.maxmp * @low_sp / 100
        @sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, @sp_im_ch, @sp_im_cw, @sp_im_ch) 
        else 
        @sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, 0, @sp_im_cw, @sp_im_ch)
        end
      @sp_number_bitmap.blt(20 + ((@sp_im_cw - 7) *  r), 0, @sp_number_image, @sp_src_rect)       
    end 
    @sp_refresh = false if @sp == @actor.mp
  end     
 
  #--------------------------------------------------------------------------
  # * Sp Flow Update
  #--------------------------------------------------------------------------
  def sp_flow_update
      @sp_sprite.bitmap.clear
      @sp_width = @sp_range  * @actor.mp / @actor.maxmp
          #SP Damage---------------------------------
          if @sp_width_old != @sp_width
          valor = (@sp_width_old - @sp_width) * 3 / 100
          valor = 0.5 if valor < 1           
          @sp_width_old -= valor if @sp_width_old > @sp_width 
          if @sp_width_old < @sp_width
            @sp_width_old = @sp_width
          end     
          @sp_src_rect_old = Rect.new(@sp_flow, @sp_height,@sp_width_old, @sp_height)
          @sp_bitmap.blt(0,0, @sp_image, @sp_src_rect_old)
          end
      #SP Real------------------------------------
      @sp_src_rect = Rect.new(@sp_flow, 0,@sp_width, @sp_height)
      @sp_bitmap.blt(0,0, @sp_image, @sp_src_rect)
      @sp_flow += 5 
      if @sp_flow >= @sp_image.width - @sp_range
        @sp_flow = 0 
      end
    end 
   
  #--------------------------------------------------------------------------
  # * level_update
  #--------------------------------------------------------------------------
  def level_update
    @level_number_sprite.bitmap.clear
    @level_number_text = @actor.level.abs.to_s.split(//)
    for r in 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
    @level_number_sprite.zoom_x = 2
    @level_number_sprite.zoom_y = 2
  end
 
  #--------------------------------------------------------------------------
  # * level_update
  #--------------------------------------------------------------------------
  def level_up_effect
    @level_number_sprite.zoom_x -= 0.02
    @level_number_sprite.zoom_y -= 0.02
    if @level_number_sprite.zoom_x <= 1.00   
      @level_number_sprite.zoom_x = 1.00
      @level_number_sprite.zoom_y = 1.00
    end
  end 
 
  #--------------------------------------------------------------------------
  # * exp_update
  #--------------------------------------------------------------------------
  def exp_update
    @level_sprite.bitmap.clear   
    if @actor.next_exp != 0
      rate = @actor.now_exp.to_f / @actor.next_exp
    else
      rate = 1
    end
    if @actor.level < 99
      @level_cw = @level_image.width * rate
    else
      @level_cw = @level_image.width
    end     
    @level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
    @level_bitmap.blt(0,0, @level_image, @level_src_rect_back) 
    @exp = @actor.exp
  end 
end

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


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