Você usará o seu endereço de e-mail para login.
As senhas devem ter pelo menos 6 caracteres de comprimento.
Digite sua senha novamente para confirmação.
Aula 5: Janelas Base
www.mundorpgmaker.comThis work is licensed under a Creative Commons Atribuição-Uso não-comercial-Compartilhamento pela mesma licença 3.0 Unported License.
5.0 - O que são windows?
Falaremos nessa aula sobre as importantes Windows.Windows são a segunda parte gráfica mais importante do RGSS. Elas exibem informações, esclarecem coisas, sem elas eu creio que nenhum jogo de RPG Maker XP seria o que é.Ainda está em dúvida do que é uma window?Olhe então uma window bem simples, e tenho certeza de que se lembrará(essa window é de VX):
Para criar uma window , declaramos uma classe. que represente essa window.Cada window do jogo tem sua própria declaração de classe.As windows tem essencialmente 2 métodos essenciais, que quase nunca devem faltar quando você for declará-las:
initialize
Eu havia comentado sobre este método na aula passada. No caso das windows, esse método serve para que a window seja inicializada e exibida pela primeira vez na tela do jogo.Esse método deve seguir algumas convenções, sobre as quais irei falar na parte prática.É importante frizar:as windows são exibidas automaticamente quando criadas(ou seja, quando um objeto da janela for criado).
refresh
Método que atualiza a parte estritamente gráfica da window sempre que for necessário, imprimindo textos, imagens, ou qualquer coisa que a window possua.
5.1 - Fazendo nossa primeira window
Iremos fazer passo a passo nossa primeira window. Ela exibirá apenas um texto simples, de nossa escolha.Para isso, crie um novo projeto para nossa window, sem deletar todos os scripts dessa vez. Depos crie uma página acima de Main, onde iremos digitar o código da window.Aqui vai a screen dela, apesar de que já mostrei várias vezes(desculpa por ser de VX, mas a nossa ficara muito parecida):
Começemos então com nossa declaração de classe:
classWindow_ShowText<Window_Base end
Chamamos nossa window de Window_ShowText, pois ela exibe um texto.Mas ops, espera aí, tem algo aí que não vimos ainda, correto?Sim, essa coisa que ainda não vimos é < Window_Base.Essa parte do código representa um conceito muito importante do RGSS: a herança.Como assim?Irei então dar um exemplo nada a ver.Suponha que temos uma classe chamada "Animal". Nessa classe, temos métodos que todos os animais também terão, por exemplo, o método "viver".Suponha também que queremos criar uma classe "Raposa"(homenagem ao Lumina =D).A classe raposa teria características da classe "Animal", ou melhor a raposa é um animal, ou melhor ainda, a raposa herda a classe animal ou, triplamente melhor ainda, Raposa < Animal.
Depois de toda essa analogia você deve ter entendido essa notação, correto?Quando colocamos < Window_Base, queremos dizer que nossa window é uma Window_Base. A classe Window_Base contém métodos comuns a todas as windows, assim como a classe Animal tem o método "viver" comum a todos os animais. Dizer que uma classe herda alguma coisa é o mesmo que dizer que uma classe tem uma superclasse(no caso do exemplo, a superclasse é Animal).Todas as window do jogo DEVEM ter essa notação, caso contrário não irão funcionar corretamente.
[lohan]
Esquecer de dizer que uma window é uma Window_Base é um erro que fará com que a window não funcione corretamente.
Depois de declarar nossa window, fazemos então o nosso método initialize:
classWindow_ShowText<Window_Base def initialize super(0,0,200,64) endend
Temos como primeira linha super(0, 0, 200, 64).Eu havia dito que nossa window herda Window_Base e, quando isso acontece, podemos chamar métodos da superclasse(por isso o comando se chama super).Por exemplo, no método initialize da nossa window chamamos o método initialize da Window_Base com o super.Entre parênteses temos os parâmetros para inicializar a window.São eles: posição x(no caso zero), posição y(no caso zero), largura(no caso 200) e altura(no caso 64).Então nossa window ficará na posição 0, 0 da tela e terá largura 200 e 64.Todos os valores estão medidos em pixels.
Com isso, nossa window já foi configurada.Para testar ela, devemos criar um objeto dela.Para isso, crie um evento e adicione um comando de eventos com isso:
window =Window_ShowText.new
Depois disso, teste o evento com o comando de script que você colocou.Irá aparecer isso(desculpas por ser de VX de novo):
Nossa window está basicamente pronta. Só falta uma coisa: fazer com que ela exiba o texto.Para isso, devemos declarar o método refresh, que atualiza e mostra as coisas que estão dentro da window.
5.2 - Terminando nossa window
Antes de tudo, devemos criar o conteúdo da nossa window.Para imprimirmos algo dentro da window(ou seja, no seu conteúdo), devemos criá-lo.Criando o conteúdo, nossa window fica assim:
classWindow_ShowText<Window_Base def initialize super(0,0,200,64) self.contents =Bitmap.new(width -32, height -32) endend
contents é uma variável da nossa window.Usando o self, dizemos que o contéudo pertence a window.Criamos o conteúdo como um Bitmap:Bitmaps servem para exibir coisas na tela, como textos.Ao criar o bitmap, especificamos o tamanho dele.No caso, ele tem largura igual a largura da janela menos 32 e tem altura igual a altura da janela menos 32. Caso não tenha entendido, não precisa essencialmente entender: basta apenas saber que toda window deverá conter essa linha.
Por motivos estéticos, o conteúdo sempre deve ter tamanho width - 32, height -32.
Depois de colocar o código que cria o conteúdo, iremos criar nosso método refresh, que irá desenhar o texto no conteúdo:
classWindow_ShowText<Window_Base def initialize super(0,0,200,64) @contents=Bitmap.new(width -32, height -32) end def refresh self.contents.clear self.contents.draw_text(0,0,100,32,"Texto") endend
Nosso método refresh primeiro limpa os gráficos do conteúdo.Isso é necessário pois, se o refresh fosse chamado muitas vezes, o texto seria impresso em cima dele mesmo várias vezes, quando o correto é que o texto desapareça e depois seja impresso de novo.Depois, chamamos o método draw_text do nosso conteúdo.O método draw_text imprime o texto no conteúdo.Como parâmetros necessários para o método draw_text, passamos a coordenada x e y do conteúdo(no caso zero e zero) em que o texto será impresso.Passamos também a largura máxima que o texto pode ter e passamos também sua altura(no caso, 100 e 32).E , por último , passamos o texto que será impresso.No caso, o texto impresso será "Texto".
Como declarar o refresh não o chama, devemos chamar o refresh no método initialize, para que o texto seja chamado imediatamente quando a window for criada:
classWindow_ShowText<Window_Base def initialize super(0,0,200,64) self.contents =Bitmap.new(width -32, height -32) refresh end def refresh self.contents.clear self.contents.draw_text(0,0,100,32,"Texto") endend
Depois de tudo isso, nossa window ficará assim:
Observe que a window desaparece com o tempo.Isso acontece por um motivo sobre o qual irei falar provavelmente na aula que vem.Irei ensinar também a fazer com que ela não desapareça, e fique como uma HUD.
Para imprimir o texto uma linha abaixo, apenas mude a coordenada y do texto.
Por motivos estéticos, todo e qualquer texto deve ter altura de 24 ou 32.
5.2 - Imprimindo coisas mais interessantes na window
Podemos mostrar muito mais coisas nas windows, como o nome do primeiro personagem do grupo, dentre outras coisas.A classe Window_Base contém muitos métodos interessantes, como podemos ver:(OBS:eu tirei esse código dos scripts que já existem no RGSS.O Window_Base fica logo bem acima do Main)
#==============================================================================# Window_Base#------------------------------------------------------------------------------# Esta classe é para todos as janelas do jogo#==============================================================================classWindow_Base<Window #-------------------------------------------------------------------------- # Inicialização dos Objetos # # x : coordenada x da janela # y : coordenada y da janela # width : largura da janela # height : altura da janela #-------------------------------------------------------------------------- def initialize(x, y, width, height) super() @windowskin_name= $game_system.windowskin_name self.windowskin = RPG::Cache.windowskin(@windowskin_name) self.x = x self.y = y self.width = width self.height = height self.z =100 end #-------------------------------------------------------------------------- # Exibição #-------------------------------------------------------------------------- def dispose # Exibir se um bitmap for definido ifself.contents !=nil self.contents.dispose end super end #-------------------------------------------------------------------------- # Selcionar Cor do Texto # # n : número da cor do texto (0-7) # (Se quiser alterar, utilize o mesmo padrão (R, G, B, o último é a Gama) #-------------------------------------------------------------------------- def text_color(n) case n when0 returnColor.new(255, 255, 255, 255) when1 returnColor.new(128, 128, 255, 255) when2 returnColor.new(255, 128, 128, 255) when3 returnColor.new(128, 255, 128, 255) when4 returnColor.new(128, 255, 255, 255) when5 returnColor.new(255, 128, 255, 255) when6 returnColor.new(255, 255, 128, 255) when7 returnColor.new(192, 192, 192, 255) else normal_color end end #-------------------------------------------------------------------------- # Definir cor normal do texto (neste caso branca) #-------------------------------------------------------------------------- def normal_color returnColor.new(255, 255, 255, 255) end #-------------------------------------------------------------------------- # Desabilitar Cor do Texto #-------------------------------------------------------------------------- def disabled_color returnColor.new(255, 255, 255, 128) end #-------------------------------------------------------------------------- # Definir Cor do Texto do Sistema #-------------------------------------------------------------------------- def system_color returnColor.new(192, 224, 255, 255) end #-------------------------------------------------------------------------- # Definir Cor do Texto do Crítico (neste caso amarela) #-------------------------------------------------------------------------- def crisis_color returnColor.new(255, 255, 64, 255) end #-------------------------------------------------------------------------- # Difinir Cor do Texto do Dano (neste caso vermelha) #-------------------------------------------------------------------------- def knockout_color returnColor.new(255, 64, 0) end #-------------------------------------------------------------------------- # Atualização do Frame #-------------------------------------------------------------------------- def update super # Resetar se uma Windowskin for alterada if $game_system.windowskin_name !=@windowskin_name @windowskin_name= $game_system.windowskin_name self.windowskin = RPG::Cache.windowskin(@windowskin_name) end end #-------------------------------------------------------------------------- # Desenhar Gráfico # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y #-------------------------------------------------------------------------- def draw_actor_graphic(actor, x, y) bitmap = RPG::Cache.character(actor.character_name, actor.character_hue) cw = bitmap.width /4 ch = bitmap.height /4 src_rect =Rect.new(0, 0, cw, ch) self.contents.blt(x - cw /2, y - ch, bitmap, src_rect) end #-------------------------------------------------------------------------- # Desenhar Nome # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y #-------------------------------------------------------------------------- def draw_actor_name(actor, x, y) self.contents.font.color = normal_color self.contents.draw_text(x, y, 120, 32, actor.name) end #-------------------------------------------------------------------------- # Desenhar Classe # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y #-------------------------------------------------------------------------- def draw_actor_class(actor, x, y) self.contents.font.color = normal_color self.contents.draw_text(x, y, 236, 32, actor.class_name) end #-------------------------------------------------------------------------- # Desenhar Nível # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y #-------------------------------------------------------------------------- def draw_actor_level(actor, x, y) self.contents.font.color = system_color self.contents.draw_text(x, y, 32, 32, "Lv") self.contents.font.color = normal_color self.contents.draw_text(x +32, y, 24, 32, actor.level.to_s, 2) end #-------------------------------------------------------------------------- # Criar String de Status para Desenhar # # actor : Herói # width : Desenhar o comprimento # need_normal : Quer seja, ou não [Normal], need= verdadeiro ou falso #-------------------------------------------------------------------------- def make_battler_state_text(battler, width, need_normal) # Selecionar comrpimento dos Colchetes brackets_width =self.contents.text_size("[]").width # Criar um string de Status para texto text ="" for i in battler.states if $data_states[i].rating >=1 if text =="" text = $data_states[i].name else new_text = text +"/"+ $data_states[i].name text_width =self.contents.text_size(new_text).width if text_width > width - brackets_width break end text = new_text end end end # Caso esteja vazio o string de texto, tornar isto Normal if text =="" if need_normal text ="[Normal]" end else # Anexar Colchetes text ="["+ text +"]" end # Retornar string de texto return text end #-------------------------------------------------------------------------- # Desenhar Status # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y # width : Desenhar o comprimento #-------------------------------------------------------------------------- def draw_actor_state(actor, x, y, width =120) text = make_battler_state_text(actor, width, true) self.contents.font.color = actor.hp ==0? knockout_color : normal_color self.contents.draw_text(x, y, width, 32, text) end #-------------------------------------------------------------------------- # Desenhar EXP # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y #-------------------------------------------------------------------------- def draw_actor_exp(actor, x, y) self.contents.font.color = system_color self.contents.draw_text(x, y, 24, 32, "E") self.contents.font.color = normal_color self.contents.draw_text(x +24, y, 84, 32, actor.exp_s, 2) self.contents.draw_text(x +108, y, 12, 32, "/", 1) self.contents.draw_text(x +120, y, 84, 32, actor.next_exp_s) end #-------------------------------------------------------------------------- # Desenhar HP # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y # width : Desenhar comprimento #-------------------------------------------------------------------------- def draw_actor_hp(actor, x, y, width =144) # Desenhar string de texto do HP self.contents.font.color = system_color self.contents.draw_text(x, y, 32, 32, $data_system.words.hp) # Calcular se há espaço para o HP Max if width -32>=108 hp_x = x + width -108 flag =true elsif width -32>=48 hp_x = x + width -48 flag =false end # Desenhar HP self.contents.font.color = actor.hp ==0? knockout_color : actor.hp <= actor.maxhp /4? crisis_color : normal_color self.contents.draw_text(hp_x, y, 48, 32, actor.hp.to_s, 2) # Desenhar HP Max if flag self.contents.font.color = normal_color self.contents.draw_text(hp_x +48, y, 12, 32, "/", 1) self.contents.draw_text(hp_x +60, y, 48, 32, actor.maxhp.to_s) end end #-------------------------------------------------------------------------- # Desenhar MP # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y # width : Desenhar comprimento #-------------------------------------------------------------------------- def draw_actor_sp(actor, x, y, width =144) # Desenhar o string de texto do MP self.contents.font.color = system_color self.contents.draw_text(x, y, 32, 32, $data_system.words.sp) # Calcular se há espaço para o MP Max if width -32>=108 sp_x = x + width -108 flag =true elsif width -32>=48 sp_x = x + width -48 flag =false end # Desenhar MP self.contents.font.color = actor.sp ==0? knockout_color : actor.sp <= actor.maxsp /4? crisis_color : normal_color self.contents.draw_text(sp_x, y, 48, 32, actor.sp.to_s, 2) # Desenhar MP Max if flag self.contents.font.color = normal_color self.contents.draw_text(sp_x +48, y, 12, 32, "/", 1) self.contents.draw_text(sp_x +60, y, 48, 32, actor.maxsp.to_s) end end #-------------------------------------------------------------------------- # Desenhar Parâmetro # # actor : Herói # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y # width : Desenhar comprimento # type : tipo de parâmetro (0-6) #-------------------------------------------------------------------------- def draw_actor_parameter(actor, x, y, type) case type when0 parameter_name = $data_system.words.atk parameter_value = actor.atk when1 parameter_name = $data_system.words.pdef parameter_value = actor.pdef when2 parameter_name = $data_system.words.mdef parameter_value = actor.mdef when3 parameter_name = $data_system.words.str parameter_value = actor.str when4 parameter_name = $data_system.words.dex parameter_value = actor.dex when5 parameter_name = $data_system.words.agi parameter_value = actor.agi when6 parameter_name = $data_system.words.int parameter_value = actor.int end self.contents.font.color = system_color self.contents.draw_text(x, y, 120, 32, parameter_name) self.contents.font.color = normal_color self.contents.draw_text(x +120, y, 36, 32, parameter_value.to_s, 2) end #-------------------------------------------------------------------------- # Desenhar Nome do Item # # item : Item # x : Desenhar a partir da coordenada x # y : Desenhar a partir da coordenada y #-------------------------------------------------------------------------- def draw_item_name(item, x, y) if item ==nil return end bitmap = RPG::Cache.icon(item.icon_name) self.contents.blt(x, y +4, bitmap, Rect.new(0, 0, 24, 24)) self.contents.font.color = normal_color self.contents.draw_text(x +28, y, 212, 32, item.name) endend
Aqui vai alguns métodos interessantes, que você irá usar no dever de casa:
draw_actor_name(actor, x, y)
Imprime o nome do personagem especificado, nas coordenadas x e y especificadas. A array $game_party.actors contém todos os personagens do grupo, que podem ser usados nesse método.Exemplo de uso:
classWindow_ShowText<Window_Base def initialize super(0,0,200,64) self.contents =Bitmap.new(width -32, height -32) refresh end def refresh self.contents.clear draw_actor_name($game_party.actors[0],0,0) endend
draw_actor_level(actor, x, y)
Imprime o nível do personagem especificado, nas coordenadas x e y especificadas. A array $game_party.actors contém todos os personagens do grupo, que podem ser usados nesse método.O modo de usar é o mesmo modo de se usar o draw_actor_name.
draw_actor_graphic(actor, x, y)
Imprime o gráfico de character do personagem especificado, nas coordenadas x e y especificadas. A array $game_party.actors contém todos os personagens do grupo, que podem ser usados nesse método.O modo de usar é o mesmo modo de se usar o draw_actor_name.
draw_actor_exp(actor, x, y) , draw_actor_hp(actor, x, y) e draw_actor_sp(actor, x, y)
Imprime o exp, o hp e o sp do personagem especificado, respectivamente, nas coordenadas x e y especificadas. A array $game_party.actors contém todos os personagens do grupo, que podem ser usados nesse método.O modo de usar é o mesmo modo de se usar o draw_actor_name.
5.3 - Conclusão
Então pessoal, espero que tenham gostado dessa quinta aula.Eu creio que ela é a mais difícil de todas até agora e, por isso, estou a disposição de qualquer dúvida, basta postar aqui no tópico.A seguir tem o dever que é bastante interessante para fazer, caso tenha entendido a aula. Na próxima aula, iremos fazer windows selecionáveis(tipo aquela em que se selciona "Novo Jogo", "Continuar"), e confesso que irá complicar a história bastante.Até.
5.4 - Dever de casa
Faça uma window que use todos os métodos de que falei na seção "5.2 - Imprimindo coisas mais interessantes nas windows".
