Criando uma HUD por imagens PT 1/3 - RGSS3

[miguel8884]

Introdução

Fala galera, então eu vou essa aula de como fazer uma hud simples por imagens, e é claro, por script, meu pequeno conhecimento possibilita isso, então vamos começar!

Rects e blt

Para iniciar vou falar o básico sobre rects e blt, o que é um rect, seria uma seleção em uma parte da imagem que foi criada, para criarmos um rect, precisamos de alguns parâmetros, vou dizer quais são:

x = a posição x (horizontal) do rect que será criado na imagem
y = a posição y (vertical) do rect que será criado na imagem
width = a largura do rect na imagem
height = a altura do rect na imagem

Mas então, esses sã os parâmetros em um rect, mas ele sozinho não faz nada, precisamos que ele seja aplicado em algo, então vamos testar com o iconset, onde no método da window_base - draw_icon é utilizado para desenhar um ícone a partir de seu id!

Para começar, declare uma variável para representar o iconset:

var = Cache.system("Iconset")

após isso declare uma variável como um sprite e crie seu bitmap

@e = Sprite.new
@e.bitmap = Bitmap.new(544,416)

agora você pode ou declarar uma variável para conter o rect ou declarar ele no próprio blt!

@r = Rect.new(0,0,40,40)

ou

@e.bitmap.blt(0,0,i,@r)

quando fizer o blt, seus parâmetros são:

x = Posição x do blt
y = Posição y do blt
bitmap = O bitmap que será usado com imagem
rect = O rect que definirá as características da seleção
opacity(opcional) = A opacidade da seleção

Bem agora que já sabemos criar seleções nas imagens, vamos para o próximo passo!

Iniciado a HUD

Podemos fazer de duas formas pelo que eu conheço, mais podem existir mais! Pode-se criar um classe que faz a hud, o pode-se implanta-la na Scene_Map.

Para implanta-la na Scene_Map, precisará usar alias, para não substituir os métodos originais e bugar todo seu maker!

Eu vou implantar no Scene_Map para ficar mais fácil, pelo menos eu acho mais fácil, depois se eu for fazer uma segunda aula eu explico como fazer a partir de uma classe criada!

Então vamos começar...
Primeiro faremos assim:

class Scene_Map < Scene_Base

onde a classe Scene_Map recebe hierarquia da classe Scene_Base

depois apenas coloquem o end no fim

class Scene_Map < Scene_Base
end

Agora vamos preencher o código com os métodos base que vamos usar para criar a hud:

começo pelo "def start" seguido do end e o "def update" seguido do end e por fim "def terminate" seguido do end, nota, não coloque o super, se quiser saber o que acontece apenas coloque, uma dica, vai dar muito lag dependendo do pc!

Vai ficar assim:

class Scene_Map < Scene_Base
  def start
    
  end
  def update
    
  end
  def terminate
    
  end
end

Agora vamos criar o alias para não bugar, ou seja, para apenas modificarmos o método original e não substitui-lo.

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    gst_hud_start
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
  end
end

Como puderam ver, eu comentei já também, comentários são ótimos para não se perder, então se acostumem, em scripts grandes isso vai ajudar!

Agora eu criei o metodo "create_hud" e "dispose_hud", que vão ser responsável, um pela criação da hud, e o outro para apagar a hud:

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    gst_hud_start
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    
  end
end

bem agora o que iremos fazer, colocarei um module para as configurações da hud, como imagens e posição!

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
module HUD_Config
  #=============================================================================
  # Configurações
  #=============================================================================
  Clear_Speed = 5 # Velocidade com que a hud desaparece ao herói se aproximar #
  HP_IMG = "" # Imagem do HP na pasta system #
  HP_XY = [0,0] # Posição X e Y do hp #
  MP_IMG = "" # Imagem do MP na pasta system #
  MP_XY = [0,0] # Posição X e Y do mp #
  #=============================================================================
  # Fim das configurações
  #=============================================================================
end
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    gst_hud_start
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    
  end
end

Se observarem, eu coloquei uma configuração para velocidade que a HUD irá desaparecer quando o player se aproximar dela, isso eu vou abordar na segunda aula!

Eu vou colocar só o HP e o MP por serem os principais do herói, talvez coloque mais na segunda aula!

Bem agora temos realmente que começar a criar as imagens da hud.

Para começar eu vou declarar dois métodos, um para criar os sprites e o outro para criar os bitmaps, é só por questão de organização, você pode colocar todos num método só!

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
module HUD_Config
  #=============================================================================
  # Configurações
  #=============================================================================
  Clear_Speed = 5 # Velocidade com que a hud desaparece ao herói se aproximar #
  HP_IMG = "" # Imagem do HP na pasta system #
  HP_XY = [0,0] # Posição X e Y do hp #
  MP_IMG = "" # Imagem do MP na pasta system #
  MP_XY = [0,0] # Posição X e Y do mp #
  #=============================================================================
  # Fim das configurações
  #=============================================================================
end
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    gst_hud_start
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    
  end
  #=============================================================================
  # Cria os sprites
  #=============================================================================
  def create_sprites
    
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    
  end
end

Após isso, precisamos de um método que atualize as variáveis que vão conter o HP e o MP, para assim a hud estar sempre atualizada!

E ainda vamos precisar de um método que pegue o width e o height das imagens que vamos usar, para podermos diminuir ou amentá-los conforme a perda ou o ganho de HP.

Agora o último método que não faz parte da criação da imagem, vamos fazer o need_update?, que vão ser métodos para verificar se a hud precisa atualizar, assim, não ficará atualizando toda hora, e possivelmente reduz bastante o lag!

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
module HUD_Config
  #=============================================================================
  # Configurações
  #=============================================================================
  Clear_Speed = 5 # Velocidade com que a hud desaparece ao herói se aproximar #
  HP_IMG = "" # Imagem do HP na pasta system #
  HP_XY = [0,0] # Posição X e Y do hp #
  MP_IMG = "" # Imagem do MP na pasta system #
  MP_XY = [0,0] # Posição X e Y do mp #
  #=============================================================================
  # Fim das configurações
  #=============================================================================
end
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    gst_hud_start
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    
  end
  #=============================================================================
  # Cria os sprites
  #=============================================================================
  def create_sprites
    
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    
  end
  #=============================================================================
  # Atualiza as variáveis HP e MP
  #=============================================================================
  def update_variables
    
  end
  #=============================================================================
  # Pega o tamanho dos bitmaps
  #=============================================================================
  def get_bitmap_size
    
  end
  #=============================================================================
  # Verifica se o hp precisa atualizar
  #=============================================================================
  def hp_need_update?
    
  end
  #=============================================================================
  # Verifica se o mp precisa atualizar
  #=============================================================================
  def mp_need_update?
    
  end
end

Bem, agora que já temos quase tudo completo, vamos criar os últimos dois métodos, draw_hp e draw_mp, que vão "desenhar" a hud, eles vão apagar a hud quando for necessário o update, e desenha-la novamente, assim ela estará com o tamanho certo, e logo vão saber porque eu falei sobre os rects e blt!

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
module HUD_Config
  #=============================================================================
  # Configurações
  #=============================================================================
  Clear_Speed = 5 # Velocidade com que a hud desaparece ao herói se aproximar #
  HP_IMG = "" # Imagem do HP na pasta system #
  HP_XY = [0,0] # Posição X e Y do hp #
  MP_IMG = "" # Imagem do MP na pasta system #
  MP_XY = [0,0] # Posição X e Y do mp #
  #=============================================================================
  # Fim das configurações
  #=============================================================================
end
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    gst_hud_start
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    
  end
  #=============================================================================
  # Cria os sprites
  #=============================================================================
  def create_sprites
    
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    
  end
  #=============================================================================
  # Atualiza as variáveis HP e MP
  #=============================================================================
  def update_variables
    
  end
  #=============================================================================
  # Pega o tamanho dos bitmaps
  #=============================================================================
  def get_bitmap_size
    
  end
  #=============================================================================
  # Verifica se o hp precisa atualizar
  #=============================================================================
  def hp_need_update?
    
  end
  #=============================================================================
  # Verifica se o mp precisa atualizar
  #=============================================================================
  def mp_need_update?
    
  end
  #=============================================================================
  # Desenha o hp
  #=============================================================================
  def draw_hp
    
  end
  #=============================================================================
  # Desenha o mp
  #=============================================================================
  def draw_mp
    
  end
end

Agora temos todos os métodos criados, vamos organizar a ordem que eles vão ser executados!

o create_hud, vai ser o primeiro no start, o dispose_hud no terminate. No create_hud, colocaremos o create_sprites e o create_bitmaps, mas primeiro sprite, depois o bitmap! Agora colocams o get_bitmap_size, pois ele vai pegar o tamanho do bitmap criado! No start, coloque também, o update_variables. Agora colocaremos no create_hud, por fim, o draw_hp e draw_mp.

Agora, no start, antes de todos os métodos, coloque uma variável qualquer com esses dados:

@actor = $game_party.members[0]

Nela será atribuída os dados do herói da equipe número 1, já que a contagem começa no 0.

O código esta assim:

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
module HUD_Config
  #=============================================================================
  # Configurações
  #=============================================================================
  Clear_Speed = 5 # Velocidade com que a hud desaparece ao herói se aproximar #
  HP_IMG = "" # Imagem do HP na pasta system #
  HP_XY = [0,0] # Posição X e Y do hp #
  MP_IMG = "" # Imagem do MP na pasta system #
  MP_XY = [0,0] # Posição X e Y do mp #
  #=============================================================================
  # Fim das configurações
  #=============================================================================
end
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    @actor = $game_party.members[0]
    gst_hud_start
    update_variables
    create_hud
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
    update_variables
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
    dispose_hud
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    create_sprites
    create_bitmaps
    get_bitmap_size
    draw_hp
    draw_mp
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    
  end
  #=============================================================================
  # Cria os sprites
  #=============================================================================
  def create_sprites
    
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    
  end
  #=============================================================================
  # Atualiza as variáveis HP e MP
  #=============================================================================
  def update_variables
    
  end
  #=============================================================================
  # Pega o tamanho dos bitmaps
  #=============================================================================
  def get_bitmap_size
    
  end
  #=============================================================================
  # Verifica se o hp precisa atualizar
  #=============================================================================
  def hp_need_update?
    
  end
  #=============================================================================
  # Verifica se o mp precisa atualizar
  #=============================================================================
  def mp_need_update?
    
  end
  #=============================================================================
  # Desenha o hp
  #=============================================================================
  def draw_hp
    
  end
  #=============================================================================
  # Desenha o mp
  #=============================================================================
  def draw_mp
    
  end
end

Agora para começar, preencheremos o create_sprite e o create_bitmaps, você pode usar qualquer nome para as variáveis, mais eu fiz desse jeito:

def create_sprites
    @hp = Sprite.new
    @mp = Sprite.new
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    @hp.bitmap = Bitmap.new("Graphics/System/#{HUD_Config::HP_IMG}")
    @mp.bitmap = Bitmap.new("Graphics/System/#{HUD_Config::MP_IMG}")
  end

Bem agora, se você rodar o jogo, já poderá ver as imagens que selecionou aparecendo na tela, mas ainda não tem a posição correta, isso porque eu não coloquei no método para definir as posições de acordo com o decidido no module, então faremos isso agora:

#=============================================================================
  # Cria os sprites
  #=============================================================================
  def create_sprites
    @hp = Sprite.new
    @mp = Sprite.new
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    @hp.bitmap = Cache.system(HUD_Config::HP_IMG)
    @mp.bitmap = Cache.system(HUD_Config::MP_IMG)
    @hp.x = HUD_Config::HP_XY[0]
    @hp.y = HUD_Config::HP_XY[1]
    @mp.x = HUD_Config::MP_XY[0]
    @mp.y = HUD_Config::MP_XY[1]
  end

Bem, agora temos a posição definida e tudo mais, mas ainda precisamos fazer com que ela se apague ao sair da scene, então no método dispose_hud, colocaremos isso aqui:

@hp.bitmap.dispose
    @hp.dispose
    @mp.bitmap.dispose
    @mp.dispose

Eu costumo dar um dispose no bitmap também, mais é só para ter certeza!

Então temos quase tudo pronto, agora só precisamos fazer com que a HUD funcione hehe!
Mas para começo, precisamos fazer o método update_variables, ele é fundamental para o funcionamento da HUD. Eu fiz ele dessa forma, declarei quatro variáveis que irão conter o hp máximo e o hp atual, o mesmo para o mp, eu usei o @actor, aquela variável que declaramos no começo para conter as informações do herói, entã vejam como o método ficou:

def update_variables
    @actor_hp = @actor.hp
    @actor_mhp = @actor.mhp
    @actor_mp = @actor.mp
    @actor_mmp = @actor.mmp
  end

Bem, agora temos de preencher o método que pega o tamanho dos bitmaps, isso é bem simples também, é apenas você declarar duas variáveis para cada bitmap, uma vai conter o width e a outra vai conter o height,
eu fiz assim:

def get_bitmap_size
    @hpw = @hp.width
    @hph = @hp.height
    @mpw = @mp.width
    @mph = @mp.height
  end

Agora vamos fazer o método que verifica se é necessária a atualização da hud! Esse é bem fácil, apenas vamos fazer com que ele retorne true ou false se a hud precisa de atualização! Vamos fazer desse jeito, primeiro usaremos a função return, depois usaremos uma condição, pode ser o if ou  unless, mas eu prefiro o unless, então colocaremos "return true unless", então ele retorna verdadeiro a não ser que, agora você vai colocar a não ser que (unless) a variável @actor_hp seja igual a @actor.hp, ou seja, o método retorna verdadeiro a não ser que a variável que contém o hp do herói seja igual do próprio hp do herói, se você usar o if, precisará fazer diferente, porque se a varável que criamos para conter o hp do herói for diferente do próprio hp do herói, faremos isso tanto para o max_hp tanto para o hp:

def hp_need_update?
    return true unless @actor_hp == @actor.hp
    return true unless @actor_mhp == @actor.mhp
  end

O mesmo para o mp:

def mp_need_update?
    return true unless @actor_mp == @actor.mp
    return true unless @actor_mmp == @actor.mmp
  end

Eba! Enfim chegamos a último método, aquele que vai desenhar a hud e que usaremos o rect e o blt!
Primeiro coloque para a variável que contém a imagem ou do hp ou do mp seja limpa, ou seja, "@hp.bitmap.clear", depois vamos definir novamente o bitmap, ele vai ser como Bitmap.new só que com dois parâmetros, o primeiro igual ao width do bitmap e o segundo igual ao height. Agora, vamos definir duas variáveis locais, que vão dizer o tamanho do bitmap de acordo com o hp do herói, mas como?
Olhe aqui no código:

    @hp.bitmap.clear
    @hp.bitmap = Bitmap.new(@hpw,@hph)
    hpw = @hpw * @actor.hp / @actor.mhp
    hph = @hph

É uma simples conta matemática  !

Agora que vamos finalmente usar o rect, declare uma outra variável local que vai ser Rect.new, como aqueles parâmetros que eu disse no começo, mas aqui você vai colocar, nos dois primeiros, 0 e 0, e agora usar as duas variáveis locais hpw e hph, vaja o código

    rect = Rect.new(0,0,hpw,hph)

Agora faremos o blt no bitmap do hp, declare o blt como eu falei no começo, nele as posições x e y também ambas são 0, aí no bitmap, você vai colocar, Cache.system(HUD_Config::HP_IMG), mais claro, com o nome que usou no module, e no rect, o nome da variável que usou para criar o rect!

    @hp.bitmap.blt(0,0,Cache.system(HUD_Config::HP_IMG),rect)

Agora o hp está pronto, para o mp faça a mesma coisa, e está pronta nossa hud, ou pelo menos quase...

Aqui o código do draw_hp e o do draw_mp:

#=============================================================================
  # Desenha o hp
  #=============================================================================
  def draw_hp
    @hp.bitmap.clear
    @hp.bitmap = Bitmap.new(@hpw,@hph)
    hpw = @hpw * @actor.hp / @actor.mhp
    hph = @hph
    rect = Rect.new(0,0,hpw,hph)
    @hp.bitmap.blt(0,0,Cache.system(HUD_Config::HP_IMG),rect)
  end
  #=============================================================================
  # Desenha o mp
  #=============================================================================
  def draw_mp
    @mp.bitmap.clear
    @mp.bitmap = Bitmap.new(@mpw,@mph)
    mpw = @mpw * @actor.mp / @actor.mmp
    mph = @mph
    rect = Rect.new(0,0,mpw,mph)
    @mp.bitmap.blt(0,0,Cache.system(HUD_Config::MP_IMG),rect)
  end

Para terminar, agora coloque o método draw_hp no update, mas não coloque ele sozinho, coloque-o junto de uma condição, draw_hp if hp_need_update?, esse foi o método que criamos para verificar se a hud precisa atualizar, ou só o hp, agora com o draw_mp faça a mesma coisa, só que é claro que na condição coloque mp_need_update?

Bem agora terminamos tudo, pode testar que provavelmente vai estar funcionando, se não estiver, passe seu código e eu vejo o que pode estar de errado! Na próxima aula, vou mostrar alguns efeitos que podemos fazer para que a hud fique mais flexível!

Até mais, espero que tenham gostado da aula, e antes que eu me esqueça, aqui o código completo:

#===============================================================================
# Criand uma HUD
# CRM
#===============================================================================
module HUD_Config
  #=============================================================================
  # Configurações
  #=============================================================================
  Clear_Speed = 5 # Velocidade com que a hud desaparece ao herói se aproximar #
  HP_IMG = "HP" # Imagem do HP na pasta system #
  HP_XY = [0,0] # Posição X e Y do hp #
  MP_IMG = "MP" # Imagem do MP na pasta system #
  MP_XY = [0,30] # Posição X e Y do mp #
  #=============================================================================
  # Fim das configurações
  #=============================================================================
end
#===============================================================================
# Classe Scene_Map modificada para mostrar a HUD
#===============================================================================
class Scene_Map < Scene_Base
  alias gst_hud_start start
  alias gst_update update
  alias gst_hud_terminate terminate
  #=============================================================================
  # Metodo que inicia a classe
  #=============================================================================
  def start
    @actor = $game_party.members[0]
    gst_hud_start
    create_hud
    update_variables
  end
  #=============================================================================
  # Metodo que atualiza a classe
  #=============================================================================
  def update
    gst_update
    draw_hp if hp_need_update?
    draw_mp if mp_need_update?
  end
  #=============================================================================
  # Metodo que termina a classe
  #=============================================================================
  def terminate
    gst_hud_terminate
    dispose_hud
  end
  #=============================================================================
  # Metodo que cria todo conteúdo da hud
  #=============================================================================
  def create_hud
    create_sprites
    create_bitmaps
    get_bitmap_size
    draw_hp
    draw_mp
  end
  #=============================================================================
  # Metodo que apaga todo conteúdo da hud
  #=============================================================================
  def dispose_hud
    @hp.bitmap.dispose
    @hp.dispose
    @mp.bitmap.dispose
    @mp.dispose
  end
  #=============================================================================
  # Cria os sprites
  #=============================================================================
  def create_sprites
    @hp = Sprite.new
    @mp = Sprite.new
  end
  #=============================================================================
  # Cria os bitmaps
  #=============================================================================
  def create_bitmaps
    @hp.bitmap = Bitmap.new("Graphics/System/#{HUD_Config::HP_IMG}")
    @mp.bitmap = Bitmap.new("Graphics/System/#{HUD_Config::MP_IMG}")
    @hp.x = HUD_Config::HP_XY[0]
    @hp.y = HUD_Config::HP_XY[1]
    @mp.x = HUD_Config::MP_XY[0]
    @mp.y = HUD_Config::MP_XY[1]
  end
  #=============================================================================
  # Atualiza as variáveis HP e MP
  #=============================================================================
  def update_variables
    @actor_hp = @actor.hp
    @actor_mhp = @actor.mhp
    @actor_mp = @actor.mp
    @actor_mmp = @actor.mmp
  end
  #=============================================================================
  # Pega o tamanho dos bitmaps
  #=============================================================================
  def get_bitmap_size
    @hpw = @hp.width
    @hph = @hp.height
    @mpw = @mp.width
    @mph = @mp.height
  end
  #=============================================================================
  # Verifica se o hp precisa atualizar
  #=============================================================================
  def hp_need_update?
    return true unless @actor_hp == @actor.hp
    return true unless @actor_mhp == @actor.mhp
  end
  #=============================================================================
  # Verifica se o mp precisa atualizar
  #=============================================================================
  def mp_need_update?
    return true unless @actor_mp == @actor.mp
    return true unless @actor_mmp == @actor.mmp
  end
  #=============================================================================
  # Desenha o hp
  #=============================================================================
  def draw_hp
    @hp.bitmap.clear
    @hp.bitmap = Bitmap.new(@hpw,@hph)
    hpw = @hpw * @actor.hp / @actor.mhp
    hph = @hph
    rect = Rect.new(0,0,hpw,hph)
    @hp.bitmap.blt(0,0,Cache.system(HUD_Config::HP_IMG),rect)
  end
  #=============================================================================
  # Desenha o mp
  #=============================================================================
  def draw_mp
    @mp.bitmap.clear
    @mp.bitmap = Bitmap.new(@mpw,@mph)
    mpw = @mpw * @actor.mp / @actor.mmp
    mph = @mph
    rect = Rect.new(0,0,mpw,mph)
    @mp.bitmap.blt(0,0,Cache.system(HUD_Config::MP_IMG),rect)
  end
end

[Enter]

Oi Miguel, cara essa foi a melhor aula de HUD que eu já vi. Seu código está muito organizado. E me ajudou bastante para entender o funcionamento do RGSS. Pois até então, eu estava criando um script hud sem me preocupar em utilizar os métodos do Scene_Map e Scene_Base - o que me gerava várias dúvidas em relação ao funcionamento de métodos do tipo: update e dispose. Mas agora eu estudei bastante e entendi que o funcionamento se dá a partir do main da scene_base e por isso que o método update tem lógica, pois quem vai executar a script da hud é o main do Scene_base e o update dela vem depois de ter executado os métodos start das scenes. O que permite que os valores já imprimidos antigos possam ser comparados com os valores atuais(=novos) com a ajuda do update e substituidos e redesenhados com o auxilio de comandos como o clear.


Valeuuuuu!

Edit: E provavelmente o mesmo se aplica para todos os outros scripts, além de scenes, certo? Por isso é chamado de engine, para utilizarmos o seu próprio funcionamento(bibliotecas) e customiza-lo.. Agora tudo faz sentido!

[miguel8884]

Oi Miguel, cara essa foi a melhor aula de HUD que eu já vi. Seu código está muito organizado. E me ajudou bastante para entender o funcionamento do RGSS. Pois até então, eu estava criando um script hud sem me preocupar em utilizar os métodos do Scene_Map e Scene_Base - o que me gerava várias dúvidas em relação ao funcionamento de métodos do tipo: update e dispose. Mas agora eu estudei bastante e entendi que o funcionamento se dá a partir do main da scene_base e por isso que o método update tem lógica, pois quem vai executar a script da hud é o main do Scene_base e o update dela vem depois de ter executado os métodos start das scenes. O que permite que os valores já imprimidos antigos possam ser comparados com os valores atuais(=novos) com a ajuda do update e substituidos e redesenhados com o auxilio de comandos como o clear.


Valeuuuuu!

Edit: E provavelmente o mesmo se aplica para todos os outros scripts, além de scenes, certo? Por isso é chamado de engine, para utilizarmos o seu próprio funcionamento(bibliotecas) e customiza-lo.. Agora tudo faz sentido!

Sim exatamente isso. A biblioteca do maker é a base para todos os outros scripts que você faz.