[Résolu] Activer/Désactivé un script

#_______________________________________________________________________________
# MOG - C Hud 1.0 (Classic Hud)     
#_______________________________________________________________________________
# By Moghunter
# http://www.atelier-rgss.com
#_______________________________________________________________________________
# Hud estilo clássico.
#
# ARQUIVOS NECESSÁRIOS
#
# C_Layout
# C_Exp_Meter
# C_Layout
# C_HP_Meter
# C_SP_Meter
# Hud_HP_Number
# Hud_SP_Number
# Hud_Exp_Number
#
# Deixe as imagens na pasta Windowskins
#_______________________________________________________________________________
module MOG
#Posição geral da HUD 
CHUD_X = 0
CHUD_Y = 0
#Posição do layout
C_LAYOUT_X = 0 
C_LAYOUT_Y = 0
#Posição do numero de HP
C_HP_NUMBER_X = 120
C_HP_NUMBER_Y = 5
#Posição do medidor de HP
C_HP_METER_X = 140
C_HP_METER_Y = 6
#Posição do numero de SP
C_SP_NUMBER_X = 80
C_SP_NUMBER_Y = 25
#Posição do medidor de SP
C_SP_METER_X = 100
C_SP_METER_Y = 25
#Posição posição do level
C_LEVEL_X = 55
C_LEVEL_Y = 0
#Posição posição do medidor de exp
C_LEVEL_METER_X = 72
C_LEVEL_METER_Y = 47
#Posição dos ícones de status
C_STATES_X = 460
C_STATES_Y = 0
#Deixar a HUD opaco caso o herói estiver em cima da HUD.
C_FADE = true
#Tamanho planejado da hud, isso influência no sensor do FADE.
C_HUD_SIZE_X = 420
C_HUD_SIZE_Y = 64
#Switch que desativa a HUD
DISABLE_C_HUD_SWITCH = 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
#==============================================================================
# C_Hud
#==============================================================================
class C_Hud < Sprite 
  include MOG
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport)
    super(viewport)
    @actor = $game_party.actors[0]
    return if @actor == nil
    @low_sp = 30
    @low_hp = 30
    @hp = @actor.hp
    @sp = @actor.sp
    @exp = @actor.exp
    @level = @actor.level
    @hp_old = @actor.hp
    @hp_ref = @hp_old
    @hp_refresh = false
    @sp_old = @actor.sp
    @sp_ref = @sp_old
    @sp_refresh = false
    hud_size_x = C_HUD_SIZE_X
    hud_size_y = C_HUD_SIZE_Y
    @oc_range_x = hud_size_x + CHUD_X
    @oc_range_y = hud_size_y + CHUD_Y   
    # Layout -------------------------------------------------------------------
    @layout_image = RPG::Cache.windowskin("C_Layout")
    @layout_bitmap = Bitmap.new(@layout_image.width,@layout_image.height)
    @layout_sprite = Sprite.new
    @layout_sprite.bitmap = @layout_bitmap
    @layout_src_rect_back = Rect.new(0, 0,@layout_image.width, @layout_image.height)
    @layout_bitmap.blt(0,0, @layout_image, @layout_src_rect_back)     
    @layout_sprite.z = 5001
    @layout_sprite.x = CHUD_X + C_LAYOUT_X
    @layout_sprite.y = CHUD_Y + C_LAYOUT_Y   
    # HP NUMBER ---------------------------------------------------------------------
    @hp_number_image = RPG::Cache.windowskin("Hud_HP_Number")
    @hp_number_bitmap = Bitmap.new(@hp_number_image.width,@hp_number_image.height)
    @hp_number_sprite = Sprite.new
    @hp_number_sprite.bitmap = @hp_number_bitmap
    @hp_number_sprite.z = 5003
    @hp_number_sprite.x = CHUD_X + C_HP_NUMBER_X
    @hp_number_sprite.y = CHUD_Y + C_HP_NUMBER_Y
    @im_cw = @hp_number_image.width / 10
    @im_ch = @hp_number_image.height / 2   
    @hp_src_rect = Rect.new(@im_cw,0, @im_cw, @im_ch)
    @hp_number_text = @actor.hp.abs.to_s.split(//)
      lowhp2 = @actor.maxhp * 30 / 100
      if @actor.hp < lowhp2
      @health2 = @im_ch
      else
      @health2 = 0
      end
      @hp_health = @health2
      for r in 0..@hp_number_text.size - 1       
        @hp_number_abs = @hp_number_text[r].to_i
        @hp_src_rect = Rect.new(@im_cw * @hp_number_abs, @hp_health, @im_cw, @im_ch)
        @hp_number_bitmap.blt(20 + ((@im_cw - 7) *  r), 0, @hp_number_image, @hp_src_rect)       
      end   
  #HP Meter
    @hp_flow = 0
    @hp_damage_flow = 0
    @hp_image = RPG::Cache.windowskin("C_HP_Meter")
    @hp_bitmap = Bitmap.new(@hp_image.width,@hp_image.height)
    @hp_range = @hp_image.width
    @hp_width = @hp_range  * @actor.hp / @actor.maxhp 
    @hp_height = @hp_image.height
    @hp_width_old = @hp_width
    @hp_src_rect = Rect.new(@hp_range, 0, @hp_width, @hp_height)
    @hp_bitmap.blt(0,0, @hp_image, @hp_src_rect)
    @hp_sprite = Sprite.new
    @hp_sprite.bitmap = @hp_bitmap
    @hp_sprite.z = 5002
    @hp_sprite.x = CHUD_X + C_HP_METER_X
    @hp_sprite.y = CHUD_Y + C_HP_METER_Y
    # SP Number ---------------------------------------------------------------------
    @sp_number_image = RPG::Cache.windowskin("Hud_SP_Number")
    @sp_number_bitmap = Bitmap.new(@sp_number_image.width,@sp_number_image.height)
    @sp_number_sprite = Sprite.new
    @sp_number_sprite.bitmap = @sp_number_bitmap
    @sp_number_sprite.z = 5003
    @sp_number_sprite.x = CHUD_X + C_SP_NUMBER_X
    @sp_number_sprite.y = CHUD_Y + C_SP_NUMBER_Y
    @sp_im_cw = @sp_number_image.width / 10
    @sp_im_ch = @sp_number_image.height / 2   
    @sp_src_rect = Rect.new(@sp_im_cw,0, @sp_im_cw, @sp_im_ch)
    @sp_number_text = @actor.sp.abs.to_s.split(//)
    for r in 0..@sp_number_text.size - 1
      @sp_number_abs = @sp_number_text[r].to_i
      @sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, 0, @sp_im_cw, @sp_im_ch)
      @sp_number_bitmap.blt(20 + ((@sp_im_cw - 7) *  r), 0, @sp_number_image, @sp_src_rect)       
    end       
    @sp_flow = 0
    @sp_damage_flow = 0
    @sp_image = RPG::Cache.windowskin("C_SP_Meter")
    @sp_bitmap = Bitmap.new(@sp_image.width,@sp_image.height)
    @sp_range = @sp_image.width
    @sp_width = @sp_range  * @actor.sp / @actor.maxsp 
    @sp_height = @sp_image.height
    @sp_width_old = @sp_width
    @sp_src_rect = Rect.new(@sp_range, 0, @sp_width, @sp_height)
    @sp_bitmap.blt(0,0, @sp_image, @sp_src_rect)
    @sp_sprite = Sprite.new
    @sp_sprite.bitmap = @sp_bitmap
    @sp_sprite.z = 5002
    @sp_sprite.x = CHUD_X + C_SP_METER_X
    @sp_sprite.y = CHUD_Y + C_SP_METER_Y
    # Level Number ---------------------------------------------------------------------
    @level_number_image = RPG::Cache.windowskin("Hud_Exp_Number")
    @level_number_bitmap = Bitmap.new(@level_number_image.width,@level_number_image.height)
    @level_number_sprite = Sprite.new
    @level_number_sprite.bitmap = @level_number_bitmap
    @level_number_sprite.z = 5003
    @level_number_sprite.x = CHUD_X + C_LEVEL_X
    @level_number_sprite.y = CHUD_Y + C_LEVEL_Y
    @level_im_cw = @level_number_image.width / 10
    @level_im_ch = @level_number_image.height   
    @level_number_text = @actor.level.abs.to_s.split(//)
    for r in 0..@level_number_text.size - 1
      @level_number_abs = @level_number_text[r].to_i
      @level_src_rect = Rect.new(@level_im_cw * @level_number_abs, 0, @level_im_cw, @level_im_ch)
      @level_number_bitmap.blt(13 + ((@level_im_cw - 12) *  r), 0, @level_number_image, @level_src_rect)       
    end 
    # Level Meter ---------------------------------------------------------------------
    @level_image = RPG::Cache.windowskin("C_Exp_Meter")
    @level_bitmap = Bitmap.new(@level_image.width,@level_image.height)
    @level_sprite = Sprite.new 
    if @actor.next_exp != 0
    rate = @actor.now_exp.to_f / @actor.next_exp
    else
    rate = 1
    end
    if @actor.level < 99
    @level_cw = @level_image.width * rate
    else
    @level_cw = @level_image.width
    end     
    @level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
    @level_bitmap.blt(0,0, @level_image, @level_src_rect_back)
    @level_sprite.bitmap = @level_bitmap
    @level_sprite.z = 5007
    @level_sprite.x = CHUD_X + C_LEVEL_METER_X
    @level_sprite.y = CHUD_Y + C_LEVEL_METER_Y 
    # States -------------------------------------------------------------------
    @states_max = 0
    @states = Sprite.new
    @states.bitmap = Bitmap.new(156,24)
    @states_x = @actor.states.size
    @states_y = 0
    @states_f = false
    sta = []
      for i in @actor.states
        unless @states_max > 5
          sta.push($data_states[i].name)
          image = RPG::Cache.icon(sta[@states_max])
          cw = image.width
          ch = image.height
          @states.bitmap.blt(26 * @states_max, 0, image, Rect.new(0, 0, cw, ch))
          @states_max += 1
        end
      end 
    @states.x = CHUD_X + C_STATES_X
    @states.y = CHUD_Y + C_STATES_Y
    @states.z = 5003   
    hud_visible_update   
    sp_flow_update
    sp_number_refresh       
    hp_flow_update
    hp_number_refresh 
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    return if @actor == nil
    #Layout Dispose
    @layout_sprite.bitmap.dispose
    @layout_sprite.bitmap = nil
    @layout_sprite.dispose
    @layout_sprite = nil   
    @layout_bitmap.dispose
    @layout_bitmap = nil
    #Hp Number Dispose
    @hp_number_sprite.bitmap.dispose
    @hp_number_sprite.bitmap = nil
    @hp_number_sprite.dispose
    @hp_number_sprite = nil
    @hp_number_bitmap.dispose
    @hp_number_bitmap = nil   
    #HP Meter Dispose
    @hp_sprite.bitmap.dispose
    @hp_sprite.bitmap = nil
    @hp_sprite.dispose
    @hp_sprite = nil 
    @hp_bitmap.dispose
    @hp_bitmap = nil 
    #SP Number Dispose
    @sp_number_sprite.bitmap.dispose
    @sp_number_sprite.bitmap = nil
    @sp_number_sprite.dispose
    @sp_number_sprite = nil
    @sp_number_bitmap.dispose
    @sp_number_bitmap = nil   
    #SP Meter Dispose
    @sp_sprite.bitmap.dispose
    @sp_sprite.bitmap = nil
    @sp_sprite.dispose
    @sp_sprite = nil   
    @sp_bitmap.dispose
    @sp_bitmap = nil   
    #Level Number Dispose
    @level_number_sprite.bitmap.dispose
    @level_number_sprite.bitmap = nil
    @level_number_sprite.dispose
    @level_number_sprite = nil   
    @level_number_bitmap.dispose
    @level_number_bitmap = nil 
    #Level Meter Dispose
    @level_sprite.bitmap.dispose
    @level_sprite.bitmap = nil
    @level_sprite.dispose
    @level_sprite = nil   
    @level_bitmap.dispose
    @level_bitmap = nil     
    #States Dispose
    @states.bitmap.dispose
    @states.bitmap = nil
    @states.dispose
    @states = nil   
  end 
  #--------------------------------------------------------------------------
  # * Updade
  #--------------------------------------------------------------------------
  def update
    return if @actor == nil
    hud_visible_update
    hp_number_update if @hp_old != @actor.hp
    hp_number_refresh if @hp_refresh == true or @actor.hp == 0
    sp_number_update if @sp_old != @actor.sp
    sp_number_refresh if @sp_refresh == true   
    level_update if @level != @actor.level   
    exp_update if @exp != @actor.exp
    hp_flow_update
    sp_flow_update
    fade_update if C_FADE == true
    states_update
  end
  #--------------------------------------------------------------------------
  # fade_update
  #--------------------------------------------------------------------------
  def fade_update
      x = ($game_player.real_x - $game_map.display_x) / 4
      y = ($game_player.real_y - $game_map.display_y) / 4
      if x < @oc_range_x and x > CHUD_X - 5 and
        y > CHUD_Y - 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   
  #--------------------------------------------------------------------------
  # * States_Update
  #--------------------------------------------------------------------------
  def states_update
      @states.x = CHUD_X + C_STATES_X
      @states.y = CHUD_Y + C_STATES_Y
    if @states_x != @actor.states.size
        @states_x = @actor.states.size
        @states.bitmap.clear
        @states_max = 0
        sta = []
        for i in @actor.states
          unless @states_max > 5
            sta.push($data_states[i].name)
            image = RPG::Cache.icon(sta[@states_max])
            cw = image.width
            ch = image.height
            @states.bitmap.blt(26 * @states_max, 0, image, Rect.new(0, 0, cw, ch))
            @states_max += 1
          end
        end 
      sta = nil
    end
  end
  #--------------------------------------------------------------------------
  # * hud_visible_update
  #--------------------------------------------------------------------------
  def hud_visible_update
      if $game_switches[MOG::DISABLE_C_HUD_SWITCH] == true
        @layout_sprite.visible = false
        @hp_number_sprite.visible = false
        @hp_sprite.visible = false
        @sp_number_sprite.visible = false
        @sp_sprite.visible = false
        @level_number_sprite.visible = false
        @states.visible = false
      else
        @layout_sprite.visible = true
        @hp_number_sprite.visible = true
        @hp_sprite.visible = true
        @sp_number_sprite.visible = true
        @sp_sprite.visible = true
        @level_number_sprite.visible = true
        @states.visible = true
      end 
  end
  #--------------------------------------------------------------------------
  # * hp_number_update
  #--------------------------------------------------------------------------
  def hp_number_update
      @hp_refresh = true
      if @hp_old < @actor.hp
          @hp_ref = 5 * (@actor.hp - @hp_old) / 100
          @hp_ref = 1 if @hp_ref < 1
          @hp += @hp_ref   
          if @hp >= @actor.hp
              @hp_old = @actor.hp
              @hp = @actor.hp 
              @hp_ref = 0
          end             
        elsif @hp_old > @actor.hp 
          @hp_refresh = true
          @hp_ref = 5 * (@hp_old - @actor.hp) / 100
          @hp_ref = 1 if @hp_ref < 1
          @hp -= @hp_ref               
          if @hp <= @actor.hp
              @hp_old = @actor.hp
              @hp = @actor.hp 
              @hp_ref = 0
          end           
        end 
  end   
  #--------------------------------------------------------------------------
  # * hp_number_refresh
  #--------------------------------------------------------------------------
  def hp_number_refresh
      @hp_number_sprite.bitmap.clear
      @hp = 0 if @actor.hp == 0
      @hp_number_text = @hp.abs.to_s.split(//)
      lowhp2 = @actor.maxhp * @low_hp / 100
      if @actor.hp < lowhp2
      @health2 = @im_ch
      else
      @health2 = 0
      end
      @hp_health = @health2
      for r in 0..@hp_number_text.size - 1       
        @hp_number_abs = @hp_number_text[r].to_i
        @hp_src_rect = Rect.new(@im_cw * @hp_number_abs, @hp_health, @im_cw, @im_ch)
        @hp_number_bitmap.blt(20 + ((@im_cw - 7) *  r), 0, @hp_number_image, @hp_src_rect)       
      end 
      @hp_refresh = false if @hp == @actor.hp
    end 
  #--------------------------------------------------------------------------
  # * Hp Flow Update
  #--------------------------------------------------------------------------
  def hp_flow_update
      @hp_sprite.bitmap.clear
      @hp_width = @hp_range  * @actor.hp / @actor.maxhp
          #HP Damage---------------------------------
          valor = (@hp_width_old - @hp_width) * 3 / 100
          valor = 0.5 if valor < 1         
          if @hp_width_old != @hp_width
          @hp_width_old -= valor if @hp_width_old > @hp_width
          @hp_width_old = 0 if @actor.hp == 0
          if @hp_width_old < @hp_width
            @hp_width_old = @hp_width
          end     
          @hp_src_rect_old = Rect.new(@hp_flow, 0,@hp_width_old, @hp_height)
          @hp_bitmap.blt(0,0, @hp_image, @hp_src_rect_old)     
          end
       
      #HP Real------------------------------------
      @hp_src_rect = Rect.new(@hp_flow, 0,@hp_width, @hp_height)
      @hp_bitmap.blt(0,0, @hp_image, @hp_src_rect)
  end         
  #--------------------------------------------------------------------------
  # * Sp_number_update
  #--------------------------------------------------------------------------
  def sp_number_update
    @sp_refresh = true
    if @sp_old < @actor.sp
      @sp_refresh = true
      @sp_ref = 5 * (@actor.sp - @sp_old) / 100
      @sp_ref = 1 if @sp_ref < 1
      @sp += @sp_ref 
      if @sp >= @actor.sp
          @sp_old = @actor.sp
          @sp = @actor.sp 
          @sp_ref = 0
      end 
    elsif @sp_old >= @actor.sp   
      @sp_ref = 5 * (@sp_old - @actor.sp) / 100
      @sp_ref = 1 if @sp_ref < 1
      @sp -= @sp_ref   
      if @sp <= @actor.sp
          @sp_old = @actor.sp
          @sp = @actor.sp 
          @sp_ref = 0
        end         
    end   
  end 
  #--------------------------------------------------------------------------
  # * sp_number_refresh
  #--------------------------------------------------------------------------
  def sp_number_refresh
    @sp_number_sprite.bitmap.clear
    @s = @actor.sp * 100 / @actor.maxsp
    @sp_number_text = @sp.abs.to_s.split(//)
      for r in 0..@sp_number_text.size - 1       
        @sp_number_abs = @sp_number_text[r].to_i
        if @actor.sp <= @actor.maxsp * @low_sp / 100
        @sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, @sp_im_ch, @sp_im_cw, @sp_im_ch) 
        else 
        @sp_src_rect = Rect.new(@sp_im_cw * @sp_number_abs, 0, @sp_im_cw, @sp_im_ch)
        end
      @sp_number_bitmap.blt(20 + ((@sp_im_cw - 7) *  r), 0, @sp_number_image, @sp_src_rect)       
    end 
    @sp_refresh = false if @sp == @actor.sp
  end   
  #--------------------------------------------------------------------------
  # * Sp Flow Update
  #--------------------------------------------------------------------------
  def sp_flow_update
      @sp_sprite.bitmap.clear
      @sp_width = @sp_range  * @actor.sp / @actor.maxsp
          #SP Damage---------------------------------
          if @sp_width_old != @sp_width
          valor = (@sp_width_old - @sp_width) * 3 / 100
          valor = 0.5 if valor < 1             
          @sp_width_old -= valor if @sp_width_old > @sp_width 
          if @sp_width_old < @sp_width
            @sp_width_old = @sp_width
          end     
          @sp_src_rect_old = Rect.new(@sp_flow, 0,@sp_width_old, @sp_height)
          @sp_bitmap.blt(0,0, @sp_image, @sp_src_rect_old)
          end
      #SP Real------------------------------------
      @sp_src_rect = Rect.new(@sp_flow, 0,@sp_width, @sp_height)
      @sp_bitmap.blt(0,0, @sp_image, @sp_src_rect)
    end 
  #--------------------------------------------------------------------------
  # * level_update
  #--------------------------------------------------------------------------
  def level_update
    @level_number_sprite.bitmap.clear
    @level_number_text = @actor.level.abs.to_s.split(//)
    for r in 0..@level_number_text.size - 1
      @level_number_abs = @level_number_text[r].to_i
      @level_src_rect = Rect.new(@level_im_cw * @level_number_abs, 0, @level_im_cw, @level_im_ch)
      @level_number_bitmap.blt(13 + ((@level_im_cw - 12) *  r), 0, @level_number_image, @level_src_rect)       
    end     
    @level = @actor.level
  end 
  #--------------------------------------------------------------------------
  # * exp_update
  #--------------------------------------------------------------------------
  def exp_update
    @level_sprite.bitmap.clear   
    if @actor.next_exp != 0
    rate = @actor.now_exp.to_f / @actor.next_exp
    else
    rate = 1
    end
    if @actor.level < 99
    @level_cw = @level_image.width * rate
    else
    @level_cw = @level_image.width
    end     
    @level_src_rect_back = Rect.new(0, 0,@level_cw, @level_image.height)
    @level_bitmap.blt(0,0, @level_image, @level_src_rect_back) 
    @exp = @actor.exp
  end   
 
end 
#===============================================================================
# Scene_Map
#===============================================================================
class Scene_Map 
  alias chud_main main
#--------------------------------------------------------------------------
# Main
#--------------------------------------------------------------------------
  def main
      @c_viewport = Viewport.new(0, 0, 640, 480)
      @c_viewport.z = 9999   
      @chud = C_Hud.new(@c_viewport)
    chud_main   
      @chud.dispose
      @chud = nil
      @c_viewport.dispose
      @c_viewport = nil
  end 
#--------------------------------------------------------------------------
# Update
#--------------------------------------------------------------------------   
  alias chud_update update
  def update
    chud_update
    @chud.update
  end 
end

$mog_rgss_c_hud = true