Aldeia RPG

Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Suporte ao desenvolvimento de jogos


    Aula 11 - Criando Uma HUD Parte 1

    MickeyRocknn
    MickeyRocknn
    Iniciante
    Iniciante


    Mensagens : 71
    Créditos : 9

    Aula 11 - Criando Uma HUD Parte 1 Empty Aula 11 - Criando Uma HUD Parte 1

    Mensagem por MickeyRocknn Sáb Abr 28, 2012 1:32 pm

    Vi Esta Aula No Aprendiz RPG É Vou Disponibilizar Aqui. Criador: Lucaswf1

    Introdução
    Seguindo nosso curso, iremos hoje entrar na reta final da 1ª parte de nossas aulas. Iremos hoje aprender a criar uma HUD, será uma aula prática, mas carregada de conceitos teóricos muico importantes, por isso, prestem atenção aos detalhes e divirtão-se criando as HUDs de vocês!


    ALIAS
    Aliás, precisamos conhecer o comando alias! Você ja deve ter visto esse comando em algum script, ele é muito comum e útil! A serventia dele é simples, injetar mais comandos em um método.
    O que seria isso?
    Você ja estudou na aula de scenes que é nescessário um loop para se atualizar constantemente os objetos de uma scene, além disso é preciso instanciar os objetos na scene para poder utilizá-los. Como iremos fazer uma HUD, nossa scene é a Scene_Map, ou seja, é uma scene que ja existe, ficaria muito complicado reescrevê-la por completo só para adicionar os comandos da HUD nela, por isso utilizamos o alias para tal fim.
    Como usar?
    Basta dentro de uma classe colocar o comando seguindo o modelo: alias nome_do_alias nome_do_método, sendo alias a declaração de um alias, nome_do_alias o nome que daremos a esse alias e nome_do_método o nome do método que vamos editar.
    Como utilizaremos ele em nossa hud, vamos mostrar um exemplo para o Scene_Map


    class Scene_Map #abre-se a classe que vamos editar
    alias test_update update #criamos o comando do alias
    def update #abrimos o método
    #Injetamos um código qualquer
    if Input.trigger?(Input::C)
    $scene = nil
    end
    test_update #vou explicar isso logo abaixo
    end #fechamento do método
    end #fechamento da classe


    Note que no fim do método eu usei o nome do alias que eu chamei de test_update, mas por que usar isso? Como você ja sabe, estamos injetando comandos no método update da classe Scene_Map, com isso não estamos reescrevendo e sim adicionando, ai pergunte-se, como o interpretador vai saber se os códigos que estou inserindo devem ficar no fim ou no início do bloco de comandos??? Simples, é só colocar o nome do alias dentro do método que você esta editando. Colocar o nome do alias é como mandar o interpretador executar o método original.
    Possibilidades de uso.
    Veja o exemplo abaixo, esse método foi retirado da classe Game_Actor do script de multi-slot do Guillaume777


    alias g7_ms_game_actor_equip equip
    def equip(equip_type, id)
    if @equip_type_force != nil then equip_type = @equip_type_force end
    #equip_type_force is used to bypass the
    #equip_type argument
    if self.equip_mode == 'STORE' then
    #store equipment for it to be restored after checking what the stats would
    self.equip_mode = nil
    @stored_armors = self.armor_ids.dup
    @stored_weapons = self.weapon_ids.dup
    saved_mode = 'STORE'
    elsif self.equip_mode == 'RESTORE'
    #restore equipment after preview of new equipment on stats
    self.equip_mode = nil
    self.restore(equip_type)
    return
    else #if equipping for real
    if self.enough_hands?(equip_type,id) != false then
    id = self.switch_items(equip_type,id) #switch item to be equiped to
    #fool players
    end
    end
    if self.enough_hands?(equip_type,id) == false then #if not enough hands
    id = 0 #then don't equip
    elsif self.equip_from_menu and self.cursed?(equip_type) then
    id = 0 #if cursed and player tried to remove it, do nothing
    elsif equip_type <= 4 #if the slot is one of the 5 basic one
    g7_ms_game_actor_equip(equip_type, id) #equip the good old way
    else
    equip_extra(equip_type,id) #equip in the new way
    end
    #fix in case there are no enough empty hands for all the equipped weapons
    if id != 0 then self.fix_handed_weapons(equip_type) end
    #this ensure that the next equiping will restore the original equipment
    if saved_mode == 'STORE' then self.equip_mode = 'RESTORE' end
    end


    Para vocês se guiarem, este é o método original para trocar equipamentos.


    def equip(equip_type, id)
    case equip_type
    when 0 # Armas
    if id == 0 or $game_party.weapon_number(id) > 0
    $game_party.gain_weapon(@weapon_id, 1)
    @weapon_id = id
    $game_party.lose_weapon(id, 1)
    end
    when 1 # Escudo
    if id == 0 or $game_party.armor_number(id) > 0
    update_auto_state($data_armors[@armor1_id], $data_armors[id])
    $game_party.gain_armor(@armor1_id, 1)
    @armor1_id = id
    $game_party.lose_armor(id, 1)
    end
    when 2 # Elmo
    if id == 0 or $game_party.armor_number(id) > 0
    update_auto_state($data_armors[@armor2_id], $data_armors[id])
    $game_party.gain_armor(@armor2_id, 1)
    @armor2_id = id
    $game_party.lose_armor(id, 1)
    end
    when 3 # Armadura
    if id == 0 or $game_party.armor_number(id) > 0
    update_auto_state($data_armors[@armor3_id], $data_armors[id])
    $game_party.gain_armor(@armor3_id, 1)
    @armor3_id = id
    $game_party.lose_armor(id, 1)
    end
    when 4 # Acessório
    if id == 0 or $game_party.armor_number(id) > 0
    update_auto_state($data_armors[@armor4_id], $data_armors[id])
    $game_party.gain_armor(@armor4_id, 1)
    @armor4_id = id
    $game_party.lose_armor(id, 1)
    end
    end
    end


    Note que o Guillaume777 teve a brilhante idéia de não reescrever o método e sim utilizar um alias! Mas onde ele executa o método original? Se você procurar com atenção, vai encontrar isso:
    elsif equip_type <= 4 #if the slot is one of the 5 basic one
    g7_ms_game_actor_equip(equip_type, id) #equip the good old way
    else
    Ou seja, o método original ficou embutido dentro daquele método monstruoso que ele criou, essa imagem vai simplificar o funcionamento desse tipo de função caso você ainda não tenha compreendido:


    Resumindo: quando aquela condição for verdadeira, ele vai executar o método de equipamento original.
    Com isso eu quero mostrar a vocês que os comandos originais podem ser usados em qualquer parte do alias, tudo depende da sua nescessidade. Note também que quando o método a ser editado possui parâmetros, esses parâmetros precisam aparecer ao se executar o método original e você precisa coloc-alos com os mesmos nomes.


    JANELAS
    Agora vamos ao que nos interessa! Basicamente uma janela é um objeto que herda as funções de janela e os métodos básicos da classe Window, além disso ela herda mais métodos da classe Window_Base(opcional, mas recomendado). Uma window possui um bitmap dentro de si, esse bitmap é que vai controlar o conteúdo da janela, é nele que desenhamos tudo o que queremos.
    Criando uma janela:
    É bem simples, vamos começar pelo nome da classe, como precisamos do modelo de herança, vamos cuidar essa parte:
    class Window_Hud < Window_Base #de praxe nomeamos a janela de Window_, depois usamos a herança "<" e colocamos a classe que se vai herdar, Window_Base. Se você for até essa classe, vai ver que ela herda elementos da classe Window e por isso ja vêm tudo imbutido: (avô(Window) > pai(Window_Base) > filha(Window_Hud)
    Dentro da classe, precisamos de um construtor do tipo initialize e nele estabelecemos as propriedades de uma janela, vamos a um modelo:
    class Window_Hud
    def initialize
    super( 0, 0, 200, 300)
    self.contents = Bitmap.new(width - 32, height - 32)

    refresh
    end
    end
    Óbviamente falta o método refresh, mas isso é para a próxima aula.
    Vamos entender o que ja foi mostrado:

    super( 0, 0, 200, 300)
    Esse comando vai especificar a posição e o tamanho da janela, sempre no modelo: super(posição x, posição y, largura, altura)
    Em geral usamos altura e largura em inglês ficando:
    width > largura
    height > altura
    Acostumem-se com os termos!

    self.contents = Bitmap.new(width - 32, height - 32)
    Esse é o comando que cria o bitmap dentro da janela, é um comando padrão e não deve ser alterado (claro que se quiser né). Esse comando cria uma instância da classe Bitmap passando por parâmetro a largura - 32 e a altura-32. Isso significa que a área "desenhável" da janela é um quadrado interno com bordas laterais de 16 píxels. Essas bordas são nescessárias Successful.


    São comandos especiais que você pode definir, eles são muito importantes e úteis, mas nem sempre nescessários, vou listar alguns:
    self.opacity = #opacidade da janela
    self.contents_opacity = #opacidade do conteúdo, isso deixa só o que for desenhado transparente
    self.back_opacity = #opacidade só do fundo deixando as bordas e o conteúdo visíveis
    self.z = #altera a posição z da janela, isso vai definir qual janela vai ficar na frente das outras
    self.contents.font.name = #esse comando define qual a fonte inicial dos textos da janela
    self.contents.font.size = #tamanho inicial dos textos da janela.
    self.windowskin = RPG::Cache.windowskin("nome da skin") #para alterar a windowskin (usar uma que não seja padrão)

    Além desses comandos, você pode alterar mais alguns dados, em geral os comandos abaio são utilizados apenas no método refresh
    self.x = #muda a posição x da janela
    self.y = #muda a posição y
    self.width = width #muda a largura da janela
    self.height = height #muda a altura
    self.visible = #ativa ou não a visibilidade da janela

    Obs.: Todas essas variáveis são attr_accessor podendo ser modificadas na scene que se esta usando a janela.

    refresh
    Esse é o método principal da janela, é nele que você irá colocar o que estará desenhado nela, mas isso é para a próxima aula Successful


    SEU DESAFIO
    Para a próxima aula você precisa ter sua HUD funcionando! Crie uma classe Window_Hud com o método initialize pronto, crie o método refresh, mas deixe-o em branco:
    def refresh

    end
    Após criar a janela, use os métodos alias e estabeleça dentro da Scene_Map uma instância da janela, ela deve ser um atributo (variável com @) para poder ser utilizada dentro da classe.
    Você vai precisar usar 2 alias
    1º deve modificar o método main, nele você vai criar o objeto @hud (exemplo), do mesmo modo que sempre faz, @hud = Window_Hud.new, nesse mesmo alias você tem que usar o método dispose da hud (ele vem pronto por causa das heranças) que é @hud.dispose, o problema nesse alias é que a ordem dos comandos (incluindo o comando que ativa o método original) dependem muito, se não colocar da forma certa vai dar erro. O 2º alias é no método update, nele vai chamar o método refresh da hud (para atualizá-la) @hud.refresh.
    Obs.: usa-se o dispose em todos os bitmaps e sprites pois se não usar, quando você muda de scene os objetos ficam na tela e ai fica um horror Successful
    Obs.: o método refresh da janela estará vazio e por isso ela vai ficar em branco.

    Não importa a posição que você fizer, mas sua janela deve aparecer na tela e não deve dar nenhum erro no jogo! Até a próxima aula para continuar-mos com noss HUD!

      Data/hora atual: Sex Abr 26, 2024 7:50 pm