Tutorial RPG Maker XPâ - devmakers.org · Introdução 10 O Editor de Scripts 11 Lógica de...
Transcript of Tutorial RPG Maker XPâ - devmakers.org · Introdução 10 O Editor de Scripts 11 Lógica de...
Conhecendo Os Scripts RGSS
Tutorial RPG Maker XP Tutorial RPG Maker XP
Por Marcelo Cavaco ([email protected])
Conhecendo os Scripts Conhecendo os Scripts
Tutorial por Marcelo Cavaco ([email protected])
1
Conhecendo Os Scripts RGSS
Considera÷‰es Iniciais Devido à falta de tutoriais a respeito desta ferramenta de criação de jogos, decidi aplicar um
pouco de meu tempo e o meu pequeno conhecimento do assunto para mudar este quadro. Estou
fazendo isso por vontade própria e com o intuito de ajudar. Espero conseguir neste tutorial...
Por favor, me avisem se existirem erros (podem existir erros de português, sobre o RPG Maker
XP, erros de tradução ou qualquer coisa). Todos os erros serão corrigidos.
Este tutorial não é um guia para solucionar problemas. Se você não consegue executar o
aplicativo, não será aqui que seu problema será solucionado. Este tutorial é de nível Avançado.
Um bom conhecimento no RPG Maker é necessário para utiliza-lo.
O Maker utilizado neste tutorial é uma versão em inglês, mas TODOS os nomes em inglês têm
sua tradução entre parênteses. Não conheço nem utilizo versões em português. Não conheço
quem traduziu outras versões e podem existir diferenças entre as traduções. Fiz curso de “Inglês
Técnico I” e “Inglês Técnico II” e acho que a tradução deve estar razoável e coerente com a
realidade, apesar disso, podem ocorrer erros. Por favor, me avisem caso encontrem algum.
Não estou aqui querendo afirmar nada sobre nada nem ninguém. Não quero ofender nenhum
leitor, ou o visinho, ou o cachorro do visinho, ou o papagaio de qualquer um que seja. Não estou
tentando provar nada. Não sou “guru” do RPG Maker XP. Portanto, tenham paciência...
E me desculpem por qualquer tipo de transtorno e muito obrigado aos que me ajudaram e
incentivaram.
Fora isso, boa leitura...
Tutorial por Marcelo Cavaco ([email protected])
2
Conhecendo Os Scripts RGSS
Agradecimentos Creio que sem ajuda ninguém é nada... Mesmo os seres mais arrogantes da face da terra, que
negam receber qualquer forma de ajuda, um dia tiveram que receber a ajuda de alguém. Mesmo
que esta tenha sido há muito tempo atrás quando o médico ajudou esta pessoa a nascer... Mas
vamos parar de enrolar e vamos ao que interessa.
Agradeço à:
Minha família, por me criar e aturar...
Meus amigos de RPG, por jogarem comigo...
Colegas de RPG Maker XP, por tirarem muitas de minhas dúvidas...
Aos que me ajudaram neste tutorial, demonstro aqui minha gratidão, agradecendo à:
phylomortis.com pela excelente pagina da internet sobre o tema;
Se faltar alguém, faça o favor de me avisar. A memória às vezes (várias vezes) falha...
Tutorial por Marcelo Cavaco ([email protected])
3
Conhecendo Os Scripts RGSS
Sum–rio Tutorial RPG Maker XP 1
Considerações Iniciais 2
Agradecimentos 3
Sumário 4
Como Utilizar este Tutorial 9
Começando 10
Introdução 10
O Editor de Scripts 11
Lógica de Programação 16
Introdução 16
Lógica 16
Seqüência Lógica 16
Instruções ou Expressões 17
Algoritimo 18
Diagrama de Bloco 19
Operadores Relacionais 20
Operadores Lógicos 22
Operações Lógicas 24
SE ... SENÃO / IF ... ELSE 26
Enquanto ou Até que x, Processar (While ou Loop) 27
A Lógica 28
Tutorial por Marcelo Cavaco ([email protected])
4
Conhecendo Os Scripts RGSS
A Sintaxe do Ruby 30
Sintaxe e Expressões 31 Identificadores / Variáveis 31 Comentários 31 Palavras Reservadas 32 Expressões 33
Variáveis e Constantes 34 Variáveis Globais 34 Variáveis de Instância 35 Variáveis Locais 35 Constantes 36 Pseudo Variáveis 37
Expressões Literais 38 Números Literais 38 Strings Literais 39
Notações de barra invertida 39 Expression Substitution 40
Array’s 41 Hash 42 Expressões de Range (Faixa) 42 Symbols 43
Operadores RGSS 44 Operadores de redefinição (métodos) 45 Operadores sem redefinição (controle de estruturas) 45 And (e) 46 Or (ou) 46 Not (negação) 47 (?) Operador Condicinal 47
Controle Estrutural 48 Condições 48
IF 48 if (Outra opção) 49 unless 50 unless (Outra opção) 50 case 51
Tutorial por Marcelo Cavaco ([email protected])
5
Conhecendo Os Scripts RGSS
Repetições 52 while 52 while (Outra opção) 53 until 53 until (Outra opção) 54 for 54 break 55 next 56
Method Exit (Método de Saída) 57 Return 57
Definindo Classes e Métodos 58 Definição de Classes (Class) 58 Definição de Módulos (Module) 60 Definição de Métodos (Method) 61 Operações de Definição (Definition Operations) 63
alias (aliás) 63
Scripts RGSS Standard 64
Listagem de Scripts RGSS Padrão 64 Arrow_Actor 65 Arrow_Base 65 Arrow_Enemy 65 Game_Actor 65 Game_Actors 65 Game_BattleAction 65 Game_Battler 66 Game_Character 66 Game_CommonEvent 66 Game_Enemy 66 Game_Event 66 Game_Map 67 Game_Party 67 Game_Picture 67 Game_Player 67 Game_Screen 67 Game_SelfSwitches 68 Game_Switches 68 Game_System 68 Game_Troop 68 Game_Variables 68
Tutorial por Marcelo Cavaco ([email protected])
6
Conhecendo Os Scripts RGSS
Interpreter 69 Scene_Battle 69 Scene_Debug 69 Scene_End 69 Scene_Equip 69 Scene_File 70 Scene_Gameover 70 Scene_Item 70 Scene_Load 70 Scene_Map 70 Scene_Menu 71 Scene_Name 71 Scene_Save 71 Scene_Shop 71 Scene_Skill 71 Scene_Status 71 Scene_Title 72 Sprite_Battler 72 Sprite_Character 72 Sprite_Picture 72 Sprite_Timer 72 Spriteset_Battle 72 Spriteset_Map 73 Window_Base 73 Window_BattleResult 73 Window_BattleStatus 73 Window_Command 73 Window_DebugLeft 74 Window_DebugRight 74 Window_Gold 74 Window_Help 74 Window_InputNumber 74 Window_Item 75 Window_MenuStatus 75 Window_Message 75 Window_NameEdit 75 Window_NameInput 75 Window_PartyCommand 75 Window_PlayTime 76 Window_SaveFile 76 Window_Selectable 76
Tutorial por Marcelo Cavaco ([email protected])
7
Conhecendo Os Scripts RGSS
Window_ShopBuy 76 Window_ShopCommand 76 Window_ShopNumber 76 Window_ShopSell 77 Window_ShopStatus 77 Window_Skill 77 Window_SkillStatus 77 Window_Status 77 Window_Steps 77 Window_Target 78
Entendendo as Classes e Métodos 79
Introdução 79
Orientação a Obejtos 79
Criando um Script 84
Introdução 84
Scene_Tutorial 84 O Editor de Scripts 84 Planejando da Cena 87 Entendendo As Classes 88
class Window_TutorialCommand 88 class Window_Tela1 89 class Window_Tela2 90 class Scene_Tutorial 91
O Código do Script 92 Testando o Script 101
Conclusão 105
Tutorial por Marcelo Cavaco ([email protected])
8
Conhecendo Os Scripts RGSS
Como Utilizar este Tutorial
Para aproveitar da melhor forma possível este tutorial, devemos saber para que ele serve. Este
documento é onde estaremos vendo diversos recursos dos scripts RGSS do RPG Maker XP.
Existem imagens de telas onde setas e círculos vermelhos indicam pontos importantes. Estas
setas e círculos vermelhos não são parte da tela e não aparecem no aplicativo. Elas foram
adicionadas neste tutorial apenas com o objetivo de auxiliar o leitor a localizar pontos
importantes na tela.
Este tutorial é de nível avançado. Só é aconselhável à leitura deste tutorial após se certificar de
que já conhece completamente os recursos do RPG Maker, além de noções de lógica de
programação, estruturação de dados e orientação a objetos.
Após a leitura deste documento, podemos passar para o próximo tutorial da série chamado
“Scripts Avançados no RPG Maker XP”.
Podem vir a surgir novos tutoriais, sendo que a lista pode aumentar... Só o tempo dirá o que está
por vir...
Tutorial por Marcelo Cavaco ([email protected])
9
Conhecendo Os Scripts RGSS
Come÷ando
Introdução
Uma pesquisa realizada em setembro de 2003 pela gamedev.net (um importante site para
programadores de jogos) revelou que a grande maioria dos jogos (72%) é desenvolvida com o
auxílio de uma linguagem de script.
Embora as linguagens de script não sejam definidas muito precisamente, elas apresentam um
conjunto de características comuns típicas. Em geral, as linguagens de script são linguagens
interpretadas, têm “tipagem” dinâmica, gerência automática de memória, e fornecem facilidades
para construção de estruturas de dados dinâmicas e manipulação de cadeias de caracteres.
Tipicamente, essas linguagens funcionam acopladas a programas hospedeiros implementados em
linguagens compiladas tradicionais como C e C++ (No caso do RPG Maker XP o Ruby). Uma
outra característica importante de linguagens de script é que elas devem ser seguras, não sendo
possível acessar serviços não autorizados do programa hospedeiro. A combinação dessas
características resulta numa excelente ferramenta para o desenvolvimento de jogos.
Acoplar uma linguagem de script em um jogo traz vários benefícios. A linguagem de script pode
ser usada para efetivamente implementar o script do jogo, para definir objetos e seus
comportamentos, para gerenciar os algoritimos de inteligência artificial e controlar os
personagens, e ainda para tratar os eventos de entrada e descrever a interface com o usuário.
Uma linguagem de script também desempenha um papel importante nas etapas de prototipação,
teste, depuração e análise de adequação do jogo. A escolha de uma linguagem de script simples
permite ainda que seja dado a roteiristas e artistas acesso programável ao jogo, a fim de que
eles que possam experimentar novas idéias e variações. Esses profissionais conduzem a maior
parte do desenvolvimento real do jogo, mas não são em geral programadores profissionais e não
estão familiarizados com técnicas sofisticadas de programação.
Tutorial por Marcelo Cavaco ([email protected])
10
Conhecendo Os Scripts RGSS
O Editor de Scripts
Para começarmos a criar scripts em nosso projeto, devemos conhecer o editor de scripts. Além
disso, é bastante recomendável um conhecimento básico de lógica de programação e orientação
a objetos.
Agora, vamos fazer uma rápida análise da tela do editor de scripts do RPG Maker XP e logo
depois vamos conhecer um pouco de lógica.
Com o projeto aberto, podemos abrir o editor de scripts de diversas formas. Podemos utilizar a
tecla de atalho “F11”, ou podemos clicar no ícone da barra de ferramentas, ou ir pelo menu
“Tools/Script Editor” (“Ferramentas/Editor de Scripts”). Observe a figura 01.
Figura 01Abrindo a tela do editor de scripts.
Tutorial por Marcelo Cavaco ([email protected])
11
Conhecendo Os Scripts RGSS Na tela que se abrirá podemos ver que já existem vários scripts prontos. Observe a figura 02.
Figura 02Tela do editor de scripts.
Tutorial por Marcelo Cavaco ([email protected])
12
Conhecendo Os Scripts RGSS Note que na tela do editor de scripts as expressões e códigos aparecem em diversas cores. Cada
cor representa um tipo de texto. Isso é extremamente útil para facilitar o entendimento dos
scripts. As cores são:
• Azul: O azul é utlizado representar as palavras reservadas do RGSS, ou simplesmente
sintaxe do RGSS, como o def, class, end, when, if, case, dentre outros.
• Vermelho: O vermelho representa números literais nas expressões e códigos, como 1, 2,
3, 5, dentre outros.
• Azul Claro: O azul mais claro representa operadores e operandos em seu código. Como
=,||, + , * , dentre outros. Além disso, representa operadores condicionais, parenteses e
colchetes.
• Verde: O verde representa os comentários. Os comentários não são interpretados pelo
RPG Maker e são ignorados.
• Roxo: O roxo representa uma cadeia de caracteres ou elementos do texto (String) em
seu código.
Tutorial por Marcelo Cavaco ([email protected])
13
Conhecendo Os Scripts RGSS O editor de Scripts do RPG maker XP possui busca de texto, comando para substituir um texto
por outro e busca por linhas. Todos este comandos podem ser acessados por teclas de atalho.
Vejamos a lista de comandos e suas respectivas teclas de atalho:
Cut (Recortar) : Ctrl+X
Copy (Copiar) : Ctrl+C
Paste (Colar) : Ctrl+V
Undo (Voltar) : Ctrl+Z
Find (Procurar) : Ctrl+F
Replace (Subistiruir) : Ctrl+H
Jump (pular para a linha) : Ctrl+G
Zoom IN/OUT (Aumentar/Diminuir) : Ctrl+botão do meio do mouse
Estas opções podem ainda ser acessadas através de um menu pop up que é apresentado quando
clicamos com o botão direito do mouse na tela principal do editor. Observe a figura 03.
Figura 03
Menu pop up da tela principal do editor de scripts.
Tutorial por Marcelo Cavaco ([email protected])
14
Conhecendo Os Scripts RGSS No lado esquerdo da tela existe uma listagem com todos os scripts de nosso projeto. Esta
listagem também possui comandos específicos. Todos este comandos podem ser acessados por
teclas de atalho. Vejamos a lista de comandos e suas respectivas teclas de atalho:
Cut (Recortar) : Ctrl+X
Copy (Copiar) : Ctrl+C
Paste (Colar) : Ctrl+V
Undo (Voltar) : Ctrl+Z
Insert (Adicionar) : Ins
Delete (Excluir) : Del
Searsh All (Busca Total) : Control+Shft+F
Estas opções podem ainda ser acessadas através de um menu pop up que é apresentado quando
clicamos com o botão direito do mouse na listagem de scripts do editor. Observe a figura 04.
Figura 04
Menu pop up da listagem de scripts.
Como foi dito anteriormente muitas pessoas conduzem a maior parte do desenvolvimento real do
jogo através de scripts, mas não são em geral programadores profissionais e não estão
familiarizados com técnicas sofisticadas de programação. Portanto vamos conhecer um pouco
mais sobre lógica de programação antes de continuar.
Tutorial por Marcelo Cavaco ([email protected])
15
Conhecendo Os Scripts RGSS
L‡gica de Programa÷‘o
Introdução
Antes de começar a mexer no editor visto no capítulo anterior, vamos aprender um pouco de
lógica de programação e algoritimos. Isso pode parecer desnecessário, mas para a criação de um
bom código (e sem lag’s) é necessário saber programar corretamente. Veremos alguns segredos
de lógica de programação nos próximos capítulos.
Lógica
A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento
de sistemas e programas (incluindo jogos), ela permite definir a seqüência lógica para o
desenvolvimento.
Então o que é lógica?
Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo.
Seqüência Lógica
Estes pensamentos podem ser descritos como uma seqüência de instruções, que devem ser
seguidas para se cumprir uma determinada tarefa. Seqüência Lógica são passos executados até
atingir um objetivo ou solução de um problema.
Tutorial por Marcelo Cavaco ([email protected])
16
Conhecendo Os Scripts RGSS
Instruções ou Expressões
Na linguagem comum, entende-se por instruções ou expressões “um conjunto de regras ou
normas definidas para a realização ou emprego de algo”. Em informática, porém, instrução é a
informação que indica a um computador uma ação elementar a executar. Convém ressaltar que
uma ordem isolada não permite realizar o processo completo, para isso é necessário um conjunto
de instruções colocadas em ordem seqüencial lógica.
Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em prática uma
série de instruções: descascar as batatas, bater os ovos, fritar as batatas, etc... É evidente que
essas instruções tem que ser executadas em uma ordem adequada (não se pode descascar as
batatas depois de fritá-las). Dessa maneira, uma instrução tomada em separado não tem muito
sentido. Para obtermos o resultado esperado, precisamos colocar em prática o conjunto de todas
as instruções, na ordem correta. Instruções são um conjunto de regras ou normas definidas para
a realização ou emprego de algo. Em informática, é o que indica a um computador uma ação
elementar a executar.
Nos scripts, trabalharemos com muitas instruções e expressões que juntas e em uma
determinada ordem, darão forma ao nosso jogo.
Tutorial por Marcelo Cavaco ([email protected])
17
Conhecendo Os Scripts RGSS
Algoritimo
Um algoritimo é formalmente uma seqüência finita de passos que levam a execução de uma
tarefa. Podemos pensar em algoritimo como uma receita, uma seqüência de instruções que dão
cabo de uma meta específica.
Estas tarefas não podem ser redundantes nem subjetivas na sua definição, devem ser claras e
precisas. Como exemplos de algoritimos podemos citar os algoritimos das operações básicas
(adição, multiplicação, divisão e subtração) de números reais decimais. Outros exemplos seriam
os manuais de aparelhos eletrônicos, como um videocassete, que explicam passo-a-passo como,
por exemplo, gravar uma imagem ou filme.
Até mesmo as coisas mais simples, podem ser descritas por seqüências lógicas. Por exemplo:
“Chupar uma bala”.
1. Pegar a bala;
2. Retirar o papel;
3. Chupar a bala;
4. Jogar o papel no lixo;
Isso é um algoritimo. De forma genérica, podemos dizer que algoritimo são as expressões de
scripts em sua forma bruta. Seria o código resumido e sem “sintaxe”, possuindo apenas a lógica.
Tutorial por Marcelo Cavaco ([email protected])
18
Conhecendo Os Scripts RGSS
Diagrama de Bloco
O diagrama de blocos é uma forma padronizada e eficaz para representar os passos lógicos de
um determinado processamento ou algoritimo. Com o diagrama podemos definir uma seqüência
de símbolos, com significado bem definido, portanto, sua principal função é a de facilitar a
visualização dos passos de um algoritimo. Os blocos mais comuns são:
Veja que no exemplo da bala seguimos uma seqüência lógica com informações diretas.
Tutorial por Marcelo Cavaco ([email protected])
19
Conhecendo Os Scripts RGSS
Operadores Relacionais
Os operadores relacionais são utilizados para comparar string de caracteres e números. Os
valores a serem comparados podem ser caracteres ou variáveis. Estes operadores sempre
retornam valores lógicos (verdadeiro ou falso / true ou false). Para estabelecer prioridades no
que diz respeito a qual operação executar primeiro, utilize os parênteses.
Os operadores relacionais são:
Exemplo:
Tendo duas variáveis A = 5 e B = 3, os resultados das expressões seriam:
Tutorial por Marcelo Cavaco ([email protected])
20
Conhecendo Os Scripts RGSS O símbolo utilizado para comparação entre expressões seria:
Veremos mais exemplos de como utilizar este símbolo mais a diante.
Tutorial por Marcelo Cavaco ([email protected])
21
Conhecendo Os Scripts RGSS
Operadores Lógicos
Os operadores lógicos servem para combinar resultados de expressões, retornando se o
resultado final é verdadeiro ou falso. Os operadores lógicos são:
E / AND Uma expressão AND (E) é verdadeira se todas as condições forem verdadeiras
OU / OR Uma expressão OR (OU) é verdadeira se pelo menos uma condição for verdadeira
NOT Uma expressão NOT (NÃO) inverte o valor da expressão ou condição, se verdadeira
inverte para falsa e vice-versa.
A tabela abaixo mostra todos os valores possíveis criados pelos três operadores lógicos (AND, OR
e NOT).
Tutorial por Marcelo Cavaco ([email protected])
22
Conhecendo Os Scripts RGSS Exemplo 1:
Suponha que temos três variáveis A = 5, B = 8 e C =1.
Os resultados das expressões seriam:
Exemplo 2:
Tendo as variáveis SALARIO, IR e SALLIQ, e considerando os valores abaixo. Informe se as
expressões são verdadeiras ou falsas.
o
Tutorial por Marcelo Cavaco (marceloca
23
Verdadeir
Falsoo
VerdadeirConhecendo Os Scripts RGSS
Operações Lógicas
Operações Lógicas são utilizadas quando se torna necessário tomar decisões em um diagrama de
bloco. Num diagrama de bloco, toda decisão terá sempre como resposta o resultado
VERDADEIRO ou FALSO.
Como no exemplo do algoritimo “CHUPAR UMA BALA”. Imaginemos que algumas pessoas não
gostem de chupar bala de morango, neste caso teremos que modificar o algoritimo para:
1. Pegar a bala;
2. A bala é de morango?
• Se sim, não chupe a bala;
• Se não, continue com o algoritimo;
3. Retirar o papel;
4. Chupar a bala;
5. Jogar o papel no lixo;
Tutorial por Marcelo Cavaco ([email protected])
24
Conhecendo Os Scripts RGSS Exemplo:
Algoritimo “Chupar Bala” utilizando diagrama de Blocos.
Note que desta vez utilizamos o símbolo para comparação entre expressões.
Tutorial por Marcelo Cavaco ([email protected])
25
Conhecendo Os Scripts RGSS
SE ... SENÃO / IF ... ELSE
Os comandos de decisão ou desvio fazem parte das técnicas de programação que conduzem a
estruturas de programas que não são totalmente seqüenciais. Com as instruções de SALTO ou
DESVIO pode-se fazer com que o programa proceda de uma forma ou de outra, de acordo com
as decisões lógicas tomadas em função dos dados ou resultados anteriores. As principais
estruturas de decisão são: “Se” e “Se / Senão.
Exemplo 1:
SE MÉDIA < 5.0 ENTÃO ALUNO REPROVADO
FIMSE
Exemplo 2:
SE MÉDIA >= 5.0 ENTÃO ALUNO APROVADO
SENÃO ALUNO REPROVADO
FIMSE
Em diagrama, as expressões do exemplo 2 ficariam organizadas assim:
Tutorial por Marcelo Cavaco ([email protected])
26
Conhecendo Os Scripts RGSS
Enquanto ou Até que x, Processar (While ou Loop)
Neste caso, o bloco de operações será executado enquanto a condição x for verdadeira. O teste
da condição será sempre realizado no inicio, ou no fim da repetição, dependendo do comando
utilizado e da linguagem de programação utilizada. Enquanto a condição for verdadeira o
processo se repete. Podemos utilizar essa estrutura para trabalharmos com contadores.
Em diagrama de bloco a estrutura é a seguinte:
Tutorial por Marcelo Cavaco ([email protected])
27
Conhecendo Os Scripts RGSS
A Lógica
Expressões SE e ENQUANTO sempre usarão operadores lógicos. A lógica de programação deve
ser desenvolvida com estes operadores de forma bem estruturada, para assim, criarmos
programas menores e mais rápidos. Vamos ver um exemplo de algoritimo utilizando os conceitos
de lógica que vimos anteriormente.
Exemplo (Média de Notas):
PROGRAMA MEDIA_FINAL
VARIÁVEL NOTA1, NOTA2, NOTA3, NOTA4, MEDIA
VARIÁVEL NOME = “”
INICIO
LER (NOME)
LER (NOTA1, NOTA2, NOTA3, NOTA4)
MEDIA := (NOTA1 + NOTA2 + NOTA3 + NOTA4) / 4
SE MEDIA>=6 ENTÃO
ESCREVER (‘APROVADO!’)
SENÃO
ESCREVER (‘REPROVADO!’)
FIM DO SE
ESCREVER (NOME, MEDIA)
FIM.
Este algoritimo é um bom exercício de lógica, mas ainda podemos transformá-lo em uma
estrutura de blocos.
Tutorial por Marcelo Cavaco ([email protected])
28
Conhecendo Os Scripts RGSS
Agora, vejamos um exemplo de bloco estruturado.
Exemplo (Média de Notas):
simMédia >= 6.0
????
Escreva Reprovado
não
Fim
Escreva Nome e Média
Escreva Aprovado
MEDIA := (NOTA1 + NOTA2 + NOTA3 + NOTA4) / 4
Ler Nota 4
Ler Nota 3
Ler Nota 2
Ler Nota 1
Ler Nome
Inicio
Tutorial por Marcelo Cavaco ([email protected])
29
Conhecendo Os Scripts RGSS
A Sintaxe do Ruby Quando você tiver certeza de que conhece algoritimo e lógica de programação, está na hora de
passar para o estudo de uma linguagem de programação. Estaremos agora vendo os detalhes da
linguagem Ruby, principalmente a parte relacionada com RGSS.
Os scripts RGSS se baseiam numa linguagem de programação chamada Ruby. A sigla RGSS
significa “Ruby Game Scripting System”, que pode ser traduzida como “Sistema de Script de Jogo
Ruby”. Como podemos ver, os scripts são uma extensão ou “pseudópode” do Ruby.
Ruby é uma linguagem que trata sua sintaxe de forma “case-sensitive”. O que seria uma
linguagem case_sensitive? É uma linguagem que diferencia as letras maiúsculas das minúsculas,
ou seja, se você digitar algo minúsculo e depois for usar, lembre-se de que deve digitar
minúsculo novamente.
Exemplo:
Se você criar uma variável chamada “vida_do_heroi” e, mais tarde, se você digitar
“Vida_do_Heroi” vai ocorrer um erro, pois estas duas variáveis são totalmente diferentes para o
Ruby.
Variáveis, identificadores, sintaxe, espaços em branco e comentários podem ser colocadas em
qualquer lugar da tela destinada aos scripts. Outra característica peculiar é que as expressões
não precisam ser escritas numa mesma linha, ou seja, podemos criar comandos em duas ou mais
linhas. Utilizando este recurso sabiamente, o código pode ficar mais limpo e fácil de entender.
Nos próximos capítulos veremos a sintaxe e expressões básicas dos Scripts RGSS. Será mostrado
um resumo dos principais comandos e alguns exemplos. Qualquer semelhança com o arquivo de
ajuda do RPG Maker XP não é uma mera coincidência. Os próximos capítulos foram realmente
baseados nos arquivos de ajuda do RPG Maker, portanto, se quiser mais detalhes sobre algo,
basta abrir o Help (Ajuda) do aplicativo.
Tutorial por Marcelo Cavaco ([email protected])
30
Conhecendo Os Scripts RGSS
Sintaxe e Expressões
Identificadores / Variáveis
Um identificador ou variável Ruby deve começar por um caractere alfanumérico ou o símbolo
underscore (_). Não há limite de tamanho, contanto que sejam utilizados apenas caracteres
alfanuméricos ou o símbolo underscore (_).
Exemplos:
ruby_simples
vida_do_heroi
É aconselhável declarar as variáveis apenas com letras minúsculas. Não que seja errado usar
maiúsculas, mas é força do costume de muitos programadores.
Comentários
Qualquer coisa que comece com um sustenido (#) é considerado como um comentário. Os
comentários servem para escrevermos lembretes, dar dicas para outros programadores que
foram ler nosso código, impedir que uma linha seja executada (sem apagá-la), dentre outros...
Exemplos:
# esta é uma linha de comentário
# vida_do_herói = 500
# vida_do_herói = 1000
Os comentários não são executados nem interpretados pelo aplicativo e aparecem no editor de
scripts com uma coloração esverdeada.
Tutorial por Marcelo Cavaco ([email protected])
31
Conhecendo Os Scripts RGSS
Palavras Reservadas
As palavras reservadas são palavras que fazem parte da sintaxe básica do Ruby. Estas palavras
não podem ser usadas como variáveis ou nomes de classe, ou algo semelhante. Estas palavras
foram reservadas para uso exclusivo do Ruby, mas se for utilizado o prefixo '$' ou '@' elas não
são consideradas reservadas.
As palavras reservadas, quando usadas, farão apenas o que elas foram programadas para fazer.
Não adianta querer tentar criar uma variável utilizando o nome de uma palavra reservada. No
editor de scripts, estas palavras sempre aparecem com a coloração azulada.
As palavras reservadas são:
BEGIN class ensure nil self when END def false not super while alias defined? for or then yield and do if redo true begin else in rescue undef break elsif module retry unless case end next return until
Estas são as palavras reservadas encontradas no RGSS do RPG Maker XP.
Tutorial por Marcelo Cavaco ([email protected])
32
Conhecendo Os Scripts RGSS
Expressões
O termo expressões serve para tudo aquilo formado por variáveis e comandos literais (números,
textos, dentre outros) incluindo operações, controle de estruturas, chamada de métodos, classes,
cálculos, mudança de valor de variáveis. Tudo isso é considerado como uma expressão.
Uma coleção de expressões é considerada como um programa. Expressões podem ser separadas
umas das outras pelo símbolo de ponto e virgula (;) ou por quebras de linha ([Enter]).
Uma expressão pode utilizar várias linhas, bastando pressionar a tecla [Enter] e continuar na
linha seguinte. As expressões, ainda podem ser agrupadas com parênteses. Expressões
agrupadas são efetuadas antes do resto da expressão.
Exemplos:
true
(1+2)*3
Actor()
if teste then ok else erro end
Tutorial por Marcelo Cavaco ([email protected])
33
Conhecendo Os Scripts RGSS
Variáveis e Constantes
Variáveis são ponteiros para áreas da memória, onde podem ser armazenados valores. Variáveis
e constantes são exatamente a mesma coisa dentro do Ruby. Elas têm a mesma característica e
funcionam da mesma forma. A única diferença é que as constantes são como variáveis que não
devem ter seu valor modificado. Então, como saberemos como diferenciar uma variável de uma
constante, já que elas funcionam de forma igual? Neste caso costuma-se criar variáveis apenas
com letras minúsculas e as constantes com letras maiúsculas.
O caractere inicial de uma variável define o seu tipo (variável global, variável de instância,
variável local). Normalmente uma variável é um nome alfanumérico, exceto pelo primeiro
caractere que pode ser de outro tipo e ainda pode ter underscore (_).
Muitas variáveis built-in começam com '$' + um caractere (veja Variáveis Built-In).
Variáveis e constantes apontam para um objeto específico. Adicionar valor a uma variável, nada
mais é do que criar novos ponteiros para novos objetos. Isso não cria novos objetos.
Em Ruby, tudo são objetos, pois ela é uma linguagem orientada a obejtos.
Variáveis Globais
Variáveis que possuam o prefixo '$' são variáveis globais e podem ser referenciadas de qualquer
parte do programa. Este tipo de variável não necessita ser declarado. Quando referenciado, o
valor das variáveis globais não iniciadas equivale a nil.
Exemplo:
$actor
Tutorial por Marcelo Cavaco ([email protected])
34
Conhecendo Os Scripts RGSS
Variáveis de Instância
Variáveis que começam com o prefixo '@' são variáveis de instância. As variáveis de instância
são variáveis que podem ser acessadas por qualquer método de sua classe ou sub-classe. Estas
variáveis não podem ser acessadas por outras classes diretamente. Quando referenciado, o valor
das variáveis de instância não iniciadas equivale a nil.
Exemplo:
@actor
Variáveis Locais
As variáveis locais e identificadores começam com caracteres alfanuméricos minúsculos ou com o
símbolo '_' (underscore). Este tipo de variável só pode ser usado ou acessado no método onde foi
criado.
O escopo de variáveis locais se estende entre outras estruturas como as classes, modules e
definições de métodos (def). Neste caso, uma classe, por exemplo, é considerada como uma
variável local. Quando referenciado, o valor das variáveis locais não iniciadas equivale a uma
chamada de método sem nenhum argumento. Caso não exista um método de mesmo nome, um
erro é gerado.
Exemplo:
actor
Tutorial por Marcelo Cavaco ([email protected])
35
Conhecendo Os Scripts RGSS
Constantes
Identificadores ou “variáveis” com letra maiúscula são constantes. A definição e iniciação
dependem da aplicação. Constantes não podem ser definidas como métodos. Acesso a constantes
não iniciadas gera um erro de exceção conhecido como “NameError”.
Exemplo:
ACTOR
Uma constante criada numa classe pode ser referenciada por classes e módulos herdados. Para
acessar as constantes externamente utiliza o operador '::'.
Exemplos:
class Actors
ACTOR1 = 'Arshes'
ACTOR2 = 'Teste de Constante'
end
class Ator < Actors
heroi1 = ACTOR1 # heroi1 = "Arshes"
heroi2 = ACTOR2 # heroi2 = "Teste de Constante"
end
heroi1 = Actors::ACTOR1 # heroi1 = "Arshes"
heroi2 = Actors::ACTOR2 # heroi2 = "Teste de Constante"
Tutorial por Marcelo Cavaco ([email protected])
36
Conhecendo Os Scripts RGSS
Pseudo Variáveis
Aparte das variáveis comuns existe um tipo especial de variável que são conhecidas como Pseudo
Variáveis. O valor destas variáveis não pode ser modificado. Ao tentar adicionar algum valor a
uma variável deste tipo ocorrerá um erro de sintaxe.
As Pseudo Variáveis são:
self
Constituído pelo método ou classe atual.
nil
Instância do NilClass class. Significa nulo. Quando algo não foi iniciado.
true
Instância do TrueClass class. Significa verdadeiro.
false
Instância do FalseClass class. Significa falso.
Tutorial por Marcelo Cavaco ([email protected])
37
Conhecendo Os Scripts RGSS
Expressões Literais
Em programas Ruby, os valores podem ser expressos diretamente, seja ele o valor 1 ou a string
“Olá mundo!”, são conhecidos como expressões literais.
Números Literais
Números literais podem usar o símbolo underscore (_). O interpretador Ruby ignora estes
símbolos. Isso é bastante útil quando usado como separador em grandes números. Contudo, se
este símbolo for usado após um número literal, vai ocorrer um erro.
1_000_000_000 # => 1000000000
0xffff_ffff # => 0xffffffff
Os tipos de números literais são:
123 ou 0d123 é um número inteiro decimal.
-123 é um número inteiro (com sinal).
123.45 é um número com ponto flutuante.
Número com ponto flutuante que iniciem com o ponto não são considerados pelo interpretador do
Ruby. Eles devem ser escritos com 0 (zero) na frente (exemplo : 0.1).
1.2e-3 é um número com ponto flutuante.
0xffff é um número inteiro hexadecimal.
0b1011 é um número binário inteiro.
0377 ou 0o377 é um número octogonal inteiro.
Tutorial por Marcelo Cavaco ([email protected])
38
Conhecendo Os Scripts RGSS
Strings Literais
Expressões com uma cadeia de caracteres são conhecidas como Strings. Existem duas formas de
se criar uma string (cadeia de caracteres). São elas:
"Esta é uma string\n"
'Esta também é uma string'
Note que podemos utilizar a aspas simples ou aspas dupla. As aspas duplas permitem que sejam
usados comandos extras como notações de “barra invertida” e “substituição de expressões”. As
aspas simples não podem conter nenhuma destas opções (exceto por \' and \\). Strings com um
espaço em branco entre si são tratadas como uma única string.
Exemplo:
texto = "test" "ando" # texto = "testando"
Notações de barra invertida \t equivale a um “tab” (0x09)
\n equivale a um “newline” (0x0a) (nova linha)
\r equivale a um “carriage return” (0x0d) (retorno de carro, ou seja, inicio de linha)
\f equivale a um “form feed” (0x0c)
\s equivale a um “whitespace” (0x20) (espaço em branco)
\nnn equivale a um “caractere em valor octogonal nnn” (n = 0-7)
\xnn equivale a um “caractere em valor hexagonal nn” (n = 0-9, a-f)
Tutorial por Marcelo Cavaco ([email protected])
39
Conhecendo Os Scripts RGSS
Expression Substitution
Em strings com aspas dupla e em expressões regulares, o termo "#{expressão}" é usado num
contexto de substituição. Em expressões com variáveis começando com $ ou com @ a expreção é
substituída pelo valor da variável.
Se quiser evitar que o Ruby tente efetuar uma substituição, adicione uma barra invertida na
frente da expressão.
Exemplos:
$variavel = "RUBY"
nome = "meu nome é #{$variavel}" # nome = "meu nome é RUBY"
nome = "meu nome é \#{$variavel}" # nome = "meu nome é #{$variavel}"
Lembra-se de que as strings com aspas simples não interpretam os comandos extras.
nome = 'meu nome é #{$variavel}' # nome = "meu nome é #{$variavel}"
Tutorial por Marcelo Cavaco ([email protected])
40
Conhecendo Os Scripts RGSS
Array’s
Objeto que retorna um vetor contendo o resultado de cada expressão. Array é uma instância da
classe Array. O valor inicial de um array em Ruby é 0 (zero).
Exemplo: [1, 2, 3]
Syntaxe: '[' expr ',' ... ']'
Suponha que você tenha o seguinte array:
ary = [0, 1, 2, 3]
Se quisermos adicionar os valores "a", "b", "c" removendo o se gundo e o terceiro valor do array,
podemos usar a seguinte expressão:
ary[1, 2] = ["a", "b", "c"]
vetor = ary # vetor = [0, "a", "b", "c", 3]
Para adicionarmos o valor 99 removendo o valor “b”, podemos usar a seguinte expressão:
ary[2, 1] = 99
vetor = ary # vetor = [0, "a", 99, "c", 3]
Para inserirmos o valor “xyz” sem remover nenhum valor, podemos usar a seguinte expressão:
ary[1, 0] = ["xyz"]
vetor = ary # vetor = [0, "xyz", "a", 99, "c", 3]
a = [1, 2]
b = [8, 9]
c = a + b # c = [1, 2, 8, 9]
p a # => [1, 2] (sem mudanças)
p b # => [8, 9] (sem mudanças aqui também)
Tutorial por Marcelo Cavaco ([email protected])
41
Conhecendo Os Scripts RGSS
Hash
Retorna um objeto do tipo Hash que mapeia cada valor resultante em uma chave. Hash é uma
instância da classe Hash. Podemos dizer, de forma muito grosseira, que um Hash é um conjunto
de vários vetores dentro de outro vetor.
Exemplo:
{1=>2, 2=>4, 3=>6}
Syntaxe:
'{' expr '=>' expr ',' ... '}'
'{' expr ',' expr ',' ... '}'
Expressões de Range (Faixa)
Se uma expressão de faixa aparecer numa expressão de condição, retornará o objeto range da
expressão 1 até a expressão 2. Os objetos do tipo range são instâncias da classe Range. Objetos
do tipo Range são separados pelo operador ‘..’
Exemplo 1:
1 .. 20
Exemplo 2:
for i in 0...10
#faz qualquer coisa
end
Syntaxe:
expr1 '..' expr2
expr1 '...' expr2
Tutorial por Marcelo Cavaco ([email protected])
42
Conhecendo Os Scripts RGSS
Symbols
Retorna o símbolo correspondente a uma string. Objetos Symbols são instâncias da classe
Symbol. Estes são os únicos objetos que retornam o mesmo objeto sempre que são chamados.
Exemplo:
:class
:lvar
:method
:$gvar
:@ivar
:+
Syntaxe:
':' identifier
':' variable name
':' operator
Tutorial por Marcelo Cavaco ([email protected])
43
Conhecendo Os Scripts RGSS
Operadores RGSS
Com os operadores iremos efetuar nossos cálculos, operações de comparação, mudança de
valores, dentre outros... Os operadores podem ser usados em expressões literais e em conjunto
com outros comandos e/ou operadores.
Os operadores têm uma determinada prioridade de execução. As operações podem ser
agrupadas com parênteses para mudar a ordem de prioridade de execução dos operadores
Exemplo:
1+2*3/4
A linguagem de programação Ruby possui os seguintes operadores:
Alto ::
[]
**
-(unary) +(unary) ! ~
* / %
+ -
<< >>
&
| ^
> >= < <=
<=> == === != =~ !~
&&
||
.. ...
?:(conditional operator)
=(+=, -= ... )
not
Baixo and or
Tutorial por Marcelo Cavaco ([email protected])
44
Conhecendo Os Scripts RGSS O “Alto” e “Baixo” define o nível de prioridade e, conseqüentemente, execução dos operadores.
Por exemplo, "&&" tem prioridade maior que "||", então ele é interpretado da seguinte forma:
a && b || c # => (a && b) || c
a || b && c # => a || (b && c)
Operadores de redefinição (métodos)
Operadores de redefinição, quando usados, alteram o valor da expressão ou do comando de
comparação em questão. Os valores são modificados e armazenados (temporariamente ou não).
+@ e -@ representa o mesmo que os operadores + and -. Suponha que você tenha uma variável
“a” com o valor 1 e a variável “b” com o valor 2. Se você criar a expressão a = b, a variável “a”
terá seu valor redefinido para 2.
Os operadores de redefinição:
| ^ & <=> == === =~ > >= < <= << >>
+ - * / % ** ~ +@ -@ [] []= `
A atribuição de valor pode ser feita diretamente, a si mesmo ou através de uma atribuição
múltipla. Veremos várias expressões com diversas formas de atribuição mais adiante.
Operadores sem redefinição (controle de estruturas)
São os operadores que não alteram os valores das expressões, portanto só servem para serem
usados em determinados tipos de expressões. Combinação de operadores de redefinição com os
operadores sem redefinição criam operadores sem redefinição. Como exemplo, temos: (!=) ou
(!~).
Os operadores sem redefinição:
= ?: .. ... ! not && and || or ::
Tutorial por Marcelo Cavaco ([email protected])
45
Conhecendo Os Scripts RGSS
And (e)
Este operador avalia primeiramente o lado esquerdo da expressão, se o resultado for verdadeiro,
avalia o lado direito. Tem a mesma função que && e é um operador de baixa prioridade.
Exemplo:
teste && set
teste and set
Sintaxe:
expr '&&' expr
expr and expr
Or (ou)
Este operador avalia primeiramente o lado esquerdo da expressão, se o resultado for verdadeiro,
avalia o lado direito. Tem a mesma função que || e é um operador de baixa prioridade.
Exemplo:
vida || morte
vida or morte
Sintaxe:
expr '||' expr
expr or expr
Tutorial por Marcelo Cavaco ([email protected])
46
Conhecendo Os Scripts RGSS
Not (negação)
Se o valor da expressão for “True”, retorna “False”, se o valor da expressão for “False”, retorna
“True”. Este operador funciona como uma negação comum.
Exemplo:
! teste
not teste
t != teste
Sintaxe:
'!' expr
not expr
(?) Operador Condicinal
Retorna expr2 ou expr3 dependendo do resultado da expr1. O seu funcionamento é idêntico a:
if expr1 then expr2 else expr3 end
Exemplo:
teste == 1 ? teste1 : teste2
Sintaxe:
expr1 ? expr2 : expr3
Tutorial por Marcelo Cavaco ([email protected])
47
Conhecendo Os Scripts RGSS
Controle Estrutural
Ao contrário do que acontece na linguagem C, as estruturas do controle no Ruby são expressões
que retornam valor. Expressões de controle estrutural são formadas pelos comandos que definem
o funcionamento básico de seu código. Estes controles podem conter If’s, Case, Loop’s,
Exception, dentre outros...
Condições
IF
if --- then --- elsif --- else --- end
Se uma expressão condicional for avaliada como verdadeira, executa a expressão do then.
Cláusulas múltiplas de elsif podem ser especificadas. Quando todas as clausulas If e Elsif forem
falsas, a expressão else, caso exista, é executado. If retorna o valor da última expressão avaliada
na cláusula da expressão condicional (ou na cláusula else). Se não houver nenhuma cláusula else
e nenhuma expressão condicional for verdadeira, retorna nil. Valores falsos e o nil são false. Tudo
mais, incluindo cadeia de caracteres vazias, é verdadeiro.
Exemplo 1:
if age <= 1 then
print "Recem nascido\n"
elsif age <= 12 then
print "Criança\n"
elsif age <= 18 then
print "Adolescente\n"
else
print "Adulto\n"
end
Tutorial por Marcelo Cavaco ([email protected])
48
Conhecendo Os Scripts RGSS exemplo 2:
sexo = if actor.sexo == "M" then "masculino" else "feminino" end
Sintaxe:
if expr [then]
expr ...
[elsif expr [then]
expr ... ]
...
[else
expr ... ]
end
if (Outra opção)
Avalia e retorna o resultado da expressão à esquerda da clausula If se a expressão da direita for
verdadeira. Se a condição não tiver resultado possível, retorna nil.
Exemplo:
print "debug\n" if $DEBUG
Syntax:
expr if expr
Tutorial por Marcelo Cavaco ([email protected])
49
Conhecendo Os Scripts RGSS
unless
O comando unless funciona de forma contrária ao if, Se a condição for falsa, avalia a expressão
inicial. O comando elsif não pode ser usado com unless.
Exemplo:
unless tem_filho?
compra_cerveja
else
compra_leite
end
Sintaxe:
unless expr [then]
expr ...
[else
expr ... ]
end
unless (Outra opção) Avalia e retorna o resultado da expressão da esquerda se a condição da direita for falsa. Se a
condição não tiver resultado possível, retorna nil.
Exemplo:
print "stop\n" unless valid(passwd)
Sintaxe:
expr unless expr
Tutorial por Marcelo Cavaco ([email protected])
50
Conhecendo Os Scripts RGSS
case
A expressão case funciona através da comparação das clausulas when com a expressão do case.
Quando a clausula when comparada com a expressão case retorna true, as expressões do when
são executadas.
A expressão case retorna a último valor avaliado na clausula when ou na clausula else. Se a
condição não tiver resultado possível, retorna nil.
Exemplo:
case $idade
when 0 .. 2
"bêbe"
when 3 .. 12
"criança"
when 13 .. 18
"adolescente"
else
"adulto"
end
Sintaxe:
case expr
[when expr [, expr] ... [then]
expr ..]..
[else
expr ..]
end
Tutorial por Marcelo Cavaco ([email protected])
51
Conhecendo Os Scripts RGSS
Repetições
while
Executa repetidamente as instruções até que a condição de parada seja alcançada. A expressão
while retorna nil. Opcionalmente, podemos fazer uma expressão while retornar um valor ligado à
expressão break.
Example:
ary = [0,2,4,8,16,32,64,128,256,512,1024]
i = 0
while i < ary.length
print ary[i]
i += 1
end
Syntax:
while expr [do]
...
end
A expressão while afeta o escopo das variáveis locais.
Tutorial por Marcelo Cavaco ([email protected])
52
Conhecendo Os Scripts RGSS
while (Outra opção)
Em alguns casos desejamos executar algo enquanto esperamos que outra coisa aconteça. Neste
caso a expressão é executada primeiro e depois é verificada a condição.
A expressão while retorna nil. Opcionalmente, podemos fazer uma expressão while retornar um
valor ligado à expressão break.
Exemplo:
sleep(60) while io_not_ready?
Sintaxe:
expr while expr
until
Repete várias vezes as expressões até que a condição de parada seja alcançada. until retorna nil.
Opcionalmente, podemos fazer uma expressão until retornar um valor ligado à expressão break.
Exemplo:
until f.eof?
print f.gets
end
Sintaxe:
until expr [do]
...
end
Tutorial por Marcelo Cavaco ([email protected])
53
Conhecendo Os Scripts RGSS
until (Outra opção)
Em alguns casos desejamos executar algo enquanto esperamos que outra coisa aconteça. Neste
caso a expressão é executada primeiro e depois é verificada a condição. A expressão until retorna
nil. Opcionalmente, podemos fazer uma expressão until retornar um valor ligado à expressão
break.
Exemplo:
print(f.gets) until f.eof?
Sintaxe:
expr until expr
for
A estrutura de repetição for é uma das mais utilizada nos scripts, juntamente com o while. A
expressão for retorna o valor do método each para cada objeto especificado no in.
Exemplo:
for i in [1, 2, 3]
print i*2, "\n"
end
Sintaxe:
for lhs ... in expr [do]
expr ..
end
Podemos repetir a execução das expressões de cada objeto de forma semelhante a:
(expr).each '{' '|' lhs..'|' expr .. '}'
A expressão for não afeta o escopo das variáveis locais.
Tutorial por Marcelo Cavaco ([email protected])
54
Conhecendo Os Scripts RGSS
break
Expressão utilizada quando se deseja sair de uma repetição, incluindo while, until, for e a
expressão do tipo iterator. Este comando retorna o valor nil. Se algum argumento for
especificado, o retorno será o valor deste argumento.
Diferente da linguagem de programação C, a expressão break só pode ser usada em repetições
(em C ele pode ser usado em expressões case).
Exemplo:
i = 0
while i < 3
print i, "\n"
break
end
Sintaxe:
break [expr]
Tutorial por Marcelo Cavaco ([email protected])
55
Conhecendo Os Scripts RGSS
next
A expressão next pula para a próxima iteração dentro da repetição. Em uma expressão do tipo
iterator, o next é uma forma de sair ou terminar a chamada.
A expressão next retorna nil. Se algum argumento for especificado, o retorno será o valor deste
argumento.
Exemplo:
str.each_line do |line|
next if line.empty?
print line
end
Sintaxe:
next [expr]
Tutorial por Marcelo Cavaco ([email protected])
56
Conhecendo Os Scripts RGSS
Method Exit (Método de Saída)
return
Força a saída de um método retornando o valor especificado. Se dois ou mais valores forem
especificados, o método de retorno considera que o valor retornado é um array. Se a expressão
de retorno não existir, o valor retornado é nil.
Exemplo:
return 12
return 1,2,3
Sintaxe:
return [expr[',' expr ... ]]
Tutorial por Marcelo Cavaco ([email protected])
57
Conhecendo Os Scripts RGSS
Definindo Classes e Métodos
Definição de Classes (Class)
Exemplo:
class Teste < Super
def test
:
end
:
end
Sintaxe:
class identificador ['<' classe_mãe ]
expr ..
end
Este comando define (cria) uma classe. Costuma-se criar nomes de classes com a primeira letra
em maiúsculo.
A definição de classes ocorre com a associação desta a um identificador que podemos utilizar em
nosso código. Em Ruby, classes e objetos são instâncias da classe Class.
Tutorial por Marcelo Cavaco ([email protected])
58
Conhecendo Os Scripts RGSS Quando uma classe já está definida (criada) ainda é possível criar uma classe com o mesmo
nome. Neste caso, a segunda definição de classe terá todo o seu código adicionado na primeira
definição.
Exemplo:
class Teste < Array
def tentando
end
end
class Teste
def outro_teste
end
end
Numa definição de classe, o identificador self refere-se a esta classe.
A definição de classes funciona inteiramente sobre o modelo de orientação a objetos. Isto inclui
relacionamentos do tipo herança.
Exemplo:
class Heroi
class Equipamento
end
end
O retorno de uma classe é o resultado da última expressão executada. Se esta expressão não
possui valor de retorno, a classe retorna nil.
Tutorial por Marcelo Cavaco ([email protected])
59
Conhecendo Os Scripts RGSS
Definição de Módulos (Module)
Este comando define (cria) um módulo. Costuma-se criar nomes de módulos com a primeira letra
em maiúsculo.
A definição de módulos ocorre com a associação deste a um identificador que podemos utilizar
em nosso código. Em Ruby, classes e objetos são instâncias da classe Class.
Exemplo:
module Teste
def testando
:
end
:
end
Sintaxe:
module identificador
expr ..
end
Quando um módulo já está definido (criado) ainda é possível criar um módulo com o mesmo
nome. Neste caso, a segunda definição do módulo terá todo o seu código adicionado na primeira
definição.
O retorno de um módulo é o resultado da última expressão executada. Se esta expressão não
possui valor de retorno, o módulo retorna nil.
Tutorial por Marcelo Cavaco ([email protected])
60
Conhecendo Os Scripts RGSS
Definição de Métodos (def)
Para criarmos um método usamos a expressão def. Esta expressão cria um método de classe ou
módulo. Se os métodos forem definidos na classe mãe, todos os filhos poderão usa-los. O
funcionamento dos métodos é semelhante ao das funções que existem em outras linguagens de
programação.
Nome de métodos podem possuir caracteres normais ou operadores de redefinição (==, +, -,).
Exemplo:
def fatorial(n)
if n == 1 then
1
else
n * fatorial (n-1)
end
end
Sintaxe:
def nome_do_método ['(' [arg ['=' default]] ... [',' '*' arg] ')']
expr ..
[rescue [error_type,..] [then]
expr ..]..
[ensure
expr ..]
end
Tutorial por Marcelo Cavaco ([email protected])
61
Conhecendo Os Scripts RGSS Quando uma expressão possui argumentos, na chamada do método temos que passar valores a
estes argumentos. Caso não sejam passados, o valor do argumento omitido recebe o valor
padrão. A execução desta expressão ocorre normalmente utilizando o valor padrão.
Argumentos que tenham o símbolo (*) imediatamente antes do nome, irá armazenar todos os
argumentos subseqüentes num vetor (array).
Exemplos:
# Método sem argumentos
def teste
end
# Método com argumentos
def teste(arg, arg2)
# Método com argumento de valor padrão nil
def teste(arg = nil)
# Todos os exemplos de argumentos incluindo vetor
def teste(arg, arg2 = 10, arg3 = nil, *rest)
# Método do tipo operador
def ==(outro)
def +(outro)
def *(outro)
A ordem de definição dos argumentos dos métodos deve ser seguida na hora de chamar o
método.
Tutorial por Marcelo Cavaco ([email protected])
62
Conhecendo Os Scripts RGSS
Operações de Definição (Definition Operations)
alias (aliás)
Só é possível criar sinônimos do tipo alias para métodos ou variáveis globais. Esta expressão cria
um identificador que aponta para o método especificado. Expressões do tipo objeto.método não
são permitidas.
Exemplo:
alias teste testeantigo
alias : teste : testeantigo
Sintaxe:
alias método_novo método_velho
Este comando é útil para modificar um método antigo ou adicionar novos comandos a ele.
Sempre retorna nil.
Mais exemplos:
# Definindo o método "teste"
def teste
"teste"
end
# Definindo um sinônimo
alias :_novo_teste :teste
# teste redefinido
def teste
_novo_teste * 2
end
p teste # => "testeteste"
Tutorial por Marcelo Cavaco ([email protected])
63
Conhecendo Os Scripts RGSS
Scripts RGSS Standard
Antes de criarmos nossos scripts vamos saber resumidamente para que servem cada um dos
scripts padrões no próximo capítulo.
Listagem de Scripts RGSS Padrão
Vamos então à listagem padrão dos scripts RGSS. Estes scripts são essenciais para o bom
funcionamento de qualquer jogo. Mas em muitos casos esta lista pode ser modificada.
Ao instalar o aplicativo, apenas estes scripts estarão disponíveis, mas isso não impede que novos
scripts sejam adicionados ou que eles sejam removidos.
A estrutura dos próximos capítulos é a seguinte:
1. Nome da classe em negrito;
2. Herança em letras pequenas;
3. Descrição em letras normais;
As palavras em itálico sevem para fazer referência a uma classe, objeto, variável, indicador, ou
qualquer comando dos scripts RGSS.
Tutorial por Marcelo Cavaco ([email protected])
64
Conhecendo Os Scripts RGSS
Arrow_Actor Herança: Arrow_Base
Descrição: Esta classe serve para definir o comportamento do cursor quando aponta para um
actor durante a batalha.
Arrow_Base Herança: Sprite
Descrição: Esta classe controla o comportamento do cusror de alvo usado nas batalhas. As
classes Arrow_Actor e Arrow_Enemy herdam todas as funcionalidades desta classe.
Arrow_Enemy Herança: Arrow_Base
Descrição: Esta classe define o comportamento do cursor ao apontar para um dos inimigos
durante a batalha.
Game_Actor Herança: Game_Battler
Descrição: Esta classe define um ator, com todos os elementos e dados típicos tais como o nível,
o equipamento, e a progressão da habilidade (Database). Esta classe faz referências às variáveis
globais $game_actors e $game_party (variáveis do tipo array ou vetores).
Game_Actors Herança: Nenhuma
Descrição: Esta classe existe meramente para simplificar questões relacionadas à manipulação
dos dados da variável global $game_actors (variável do tipo array ou vetor).
Game_BattleAction Herança: Nenhuma
Descrição: Esta classe descreve propriedades de uma ação da batalha e possui métodos usados
em determinar a validade e o escopo de uma ação da batalha, além de possuir os métodos que
decidem qual o último alvo ou qual é o alvo aleatório para ações forçadas durante a batalha.
Tutorial por Marcelo Cavaco ([email protected])
65
Conhecendo Os Scripts RGSS
Game_Battler Herança: Nenhuma
Descrição: Esta classe descreve um "battler", isto é, uma figura de um ator ou de um monstro, e
tudo que poderia lhe acontecer durante a batalha. Observe que estes objetos do tipo "battler"
são membros distintos e diferentes da classe actors. Isto torna mais fácil a aplicação de efeitos
temporários.
Game_Character Herança: Nenhuma
Descrição: Esta classe determina o comportamento dos “hero sprite” (figuras do herói) e “event
sprites” (figuras de eventos) no mapa, incluindo o movimento, definindo tipos diferentes de
movimento para eventos, e garantindo o correto funcionamento do movimento para as rotas
criadas com o “Define Route” (Definição de Rota) e as rotas criadas com o comando “Move
Event” (Mover Evento).
Game_CommonEvent Herança: Nenhuma
Descrição: Esta classe possui métodos e indicadores para trabalharmos com informações de
eventos comuns, tais como a lista de comandos do evento, seu trigger (gatilho), e seu swtich
(interruptor do gatilho). Esta classe possui também o código para manter o funcionamento
eventos comuns que sejam processos paralelos.
Game_Enemy Herança: Game_Battler
Descrição: Esta classe define um inimigo, contendo seus estados, ações, tesouro e resistências.
Contem também o código para decidir que ação o monster deve fazer.
Game_Event Herança: Game_Character
Descrição: Esta classe possui informações sobre um evento do mapa, além de métodos para
verificar se um evento foi executado.
Tutorial por Marcelo Cavaco ([email protected])
66
Conhecendo Os Scripts RGSS
Game_Map Herança: Nenhuma
Descrição: Esta classe possui informações sobre o mapa atual, incluindo seus tileset, a sua
passabilidade, névoa, panorama, fundo da batalha e eventos.
Game_Party Herança: Nenhuma
Descrição: Esta classe possui os métodos que tratam do grupo como um todo, além de métodos
para tratar cada membro do grupo individualmente. Estes métodos incluem aqueles para ganhar
ou perder dinheiro, adicionar e remover membros do grupo, e alguns métodos úteis para
batalhas.
Game_Picture Herança: Nenhuma
Descrição: Esta classe possui informações sobre uma imagem qualquer e contem métodos para
mostrar, mover, girar e apagar imagens.
Game_Player Herança: Game_Character
Descrição: Esta classe calcula a posição relativa do herói em relação ao centro do mapa, evento
que provoca decisões relativas ao jogador, além de possuir métodos para tratar a contagem de
passos e a contagem de passos restantes para uma batalha.
Game_Screen Herança: Nenhuma
Descrição: Esta classe possuiu informações e métodos para controle da tela do jogo, e controle
do mapa, tal como o tempo se passa, como a tela pisca e como a tela se movimenta (efeito de
terremoto).
Tutorial por Marcelo Cavaco ([email protected])
67
Conhecendo Os Scripts RGSS
Game_SelfSwitches Herança: Nenhuma
Descrição: Esta classe controla os “Local Switchs” (Interruptores Locais) associados aos eventos
além de possuir os métodos para ajustar e iniciar os valores dos interruptores locais.
Game_Switches Herança: Nenhuma
Descrição: Esta classe controla os switchs (interruptores) do jogo e possui métodos para atribuir
e iniciar os switchs (interruptores).
Game_System Herança: Nenhuma
Descrição: Esta classe possui informações sobre o sistema de jogo, tal como “battle event
interpreter”, informações sobre o evento de mapa ou de batalha em execução, a quantidade de
tempo restante no temporizador, se os menus “saving” (registrar o jogo), “main menu” (menu
principal) e “encounters” (encontros) estão desabilitados, etc... A maioria dos métodos desta
classe tratam do processamento dos sons.
Game_Troop Herança: Nenhuma
Descrição: Esta classe possui informações sobre o grupo de monstros que está em batalha, além
de possuir métodos para configurar os grupos de monstros e para determinar um alvo aleatório
para um monstro.
Game_Variables Herança: Nenhuma
Descrição: Esta classe possui as variáveis do jogo além de ter métodos para atribuir e iniciar os
dados das variáveis.
Tutorial por Marcelo Cavaco ([email protected])
68
Conhecendo Os Scripts RGSS
Interpreter Herança: Nenhuma
Descrição: Esta classe possui métodos que executam os comandos dos eventos incorporados.
Cada evento executando representa uma instância desta classe.
Scene_Battle Herança: Nenhuma
Descrição: Esta é a classe principal do sistema da batalha. Para facilitar o entendimento desta
classe, o código do sistema da batalha é dividido em Phases (fases). Estas fases são:
Fase 1: Inicio da fase de batalha;
Fase 2: Fase de comandos do grupo de heróis;
Fase 3: Fase de comandos individuais;
Fase 4: Fase principal;
Fase 5: Fase da vitória;
Scene_Debug Herança: Nenhuma
Descrição: Esta classe representa a tela de depuração do jogo que é aberta quando se pressiona
a tecla F9 durante um “test play” (Teste de Jogo).
Scene_End Herança: Nenhuma
Descrição: Esta classe controla o menu que aparece quando você seleciona a opção “End Game”
(Fim de Jogo) do menu principal.
Scene_Equip Herança: Nenhuma
Descrição: Esta classe controla a tela de equipamentos e todas as janelas contidas nela.
Tutorial por Marcelo Cavaco ([email protected])
69
Conhecendo Os Scripts RGSS
Scene_File Herança: Nenhuma
Descrição: Esta classe controla os elementos da seleção de arquivo utilizados ao se registrar
(save) e carregar (load) um arquivo da memória. Existem duas classes que são heranças desta,
Scene_Save e Scene_Load, que controlam elemetos específicos do registro (save) e
carregamento (load) respectivamente.
Scene_Gameover Herança: Nenhuma
Descrição: Esta classe controla os elementos da tela de fim de jogo (Gameover Screen).
Scene_Item Herança: Nenhuma
Descrição: Esta classe controla a seleção dos itens de menu do menu principal. Note que um
processo seperado garante que o menu de itens apareça quando o comando da batalha "item" é
selecionado.
Scene_Load Herança: Scene_File
Descrição: Esta classe garante que o processo de seleção de arquivos inicie apenas uma vez o
arquivo de jogo e da forma correta.
Scene_Map Herança: Nenhuma
Descrição: Esta classe garante que os elementos relacionados ao mapa como a janela da
mensagem e a chamada dos vários menus que podem mudar a cena (scene). Além disso, esta
classe é responsável pelo processamento dos gráficos dos eventos do mapa, que são asegurados
pela classe de Game_Map e por seus objetos.
Tutorial por Marcelo Cavaco ([email protected])
70
Conhecendo Os Scripts RGSS
Scene_Menu Herança: Nenhuma
Descrição: Esta classe atualiza o menu principal do jogo, processa as entradas do usuário no
menu de comando e a seleção de personagens do menu de estatísticas.
Scene_Name Herança: Nenhuma
Descrição: Esta classe controla a tela "Enter Hero Name" (Digitar Nome do Herói). Este tela pode
ser chamada através dos comandos de eventos.
Scene_Save Herança: Scene_File
Descrição: Esta classe controla a forma de seleção dos arquivos a serem gravados garantindo
que seja utilizado apenas um arquivo por vez.
Scene_Shop Herança: Nenhuma
Descrição: Esta classe controla as telas de lojas e as suas sub-telas, além de responder às
opções escolhidas pelo usuário.
Scene_Skill Herança: Nenhuma
Descrição: Esta classe controla as janelas e garante a correta utilização e seleção das habilidades
dentro do menu principal. Note que a seleção de habilidades na batalha é controlada pela classe
Scene_Battle.
Scene_Status Herança: Nenhuma
Descrição: Esta classe possui as janelas de estatísitcas do herói e podem ser acessadas através
do menu principal do jogo.
Tutorial por Marcelo Cavaco ([email protected])
71
Conhecendo Os Scripts RGSS
Scene_Title Herança: Nenhuma
Descrição: Esta classe controla a tela de inicio do jogo.
Sprite_Battler Herança: Sprite
Descrição: Esta classe proporciona mudanças gráficas nas imagens de batalha, tais como
atualizar a tela se a imagem estiver é visível, fazer a tela picar como um flash antes de atacar e
mostrar os danos causados durante a batalha.
Sprite_Character Herança: Sprite
Descrição: Esta classe proporciona mudanças gráficas nas imagens do personagem (character),
tais como atualizar a tela se a imagem estiver visível, fazer a tela picar como um flash antes de
atacar e mostrar os danos causados durante a batalha.
Sprite_Picture Herança: Sprite
Descrição: Esta classe controla as alterações em imagens durante o jogo.
Sprite_Timer Herança: Sprite
Descrição: Esta classe atualiza o gráfico de tempo.
Spriteset_Battle Herança: Nenhuma
Descrição: Esta classe controla todos os sprites (grupos de imagens) usados na classe de
Scene_Battle, tal como os inimigos, os atores, o fundo da batalha, e todas as imagens que estão
sendo mostradas.
Tutorial por Marcelo Cavaco ([email protected])
72
Conhecendo Os Scripts RGSS
Spriteset_Map Herança: Nenhuma
Descrição: Esta classe contem os sprites (grupo de imagens) usados na classe Scene_Map, tal
como o tileset, o panorama, a névoa, o tempo e as figuras.
Window_Base Herança: Window
Descrição: Esta é a classe principal das janelas. Todas as outras classes de janela herdam desta
classe. Ela possui métodos úteis que podem ser chamads em diversas janelas. Se você deseja
adicionar um método que você irá usar em muitas janelas durante todo o seu jogo, você deve
adicionr este método nesta classe.
Window_BattleResult Herança: Window_Base
Descrição: Esta é a classe da janela que aparece quando você vence uma batalha. Ela mostra a
quantidade de experiência e dinheiro adquirido. Em alguns casos itens são deixados pelos
monstros. Estes istens são mostrados nesta tela também.
Window_BattleStatus Herança: Window_Base
Descrição: Esta é a classe da janela que mostra os pontos de vida (HP), os pontos de habilidade
(SP) e o estado dos heróis durante a batalha.
Window_Command Herança: Window_Selectable
Descrição: Esta janela mostra uma lista de comandos. Ao contrário das outras classes que
herdam de Window_Base, esta herda de Window_Selectable e é projetada para ser o mais
flexível possível, permitindo que uma janela seja construída fácilmente toda vez que você quiser
que o jogador escolha uma opção entre vários comandos disponíveis.
Tutorial por Marcelo Cavaco ([email protected])
73
Conhecendo Os Scripts RGSS
Window_DebugLeft Herança: Window_Selectable
Descrição: Esta janela mostra grupos de dez swtichs e variables (interruptores e variáveis) que o
usuário pode escolher e modificar durante o teste de seu projeto. Quando o usuário escolhe um
grupo do lado esquerdo na tela, o lado direito da tela mostra dez switchs ou variable
(interruptores ou variáveis) individuais para serem modificados.
Window_DebugRight Herança: Window_Selectable
Descrição: Esta janela mostra dez switchs ou variable (interruptores ou variáveis) individuais
dependendo do grupo escolhido no lado esquerdo da tela. Pressionando a tecla [Enter] é possível
alterar o valor dos switchs (interruptores), além de diversas operações com variable (variáveis)
estarem disponíveis.
Window_Gold Herança: Window_Base
Descrição: Esta janela mostra a quantidade ouro disponível naquele momento. Esta tela é
apresentada no menu, nas lojas e quando o comando "\g" é utilizado nas mensagens de texto.
Window_Help Herança: Window_Base
Descrição: Esta tela é apresentada em várias situaçãoes diferentes, como na tela de itens, na
tela de habilidades, equipamentos, dentre outros. Serve para apresentar um texto descritivo
sobre uma determinada situação. Na batalha serve para mostrar os nomes dos personagens e
dos inimigos.
Window_InputNumber Herança: Window_Base
Descrição: Esta é a janela para entrada de números. Ela é apresentada quando o comando de
evento "Input Number" (Entrar/Digitar Número) é utilizado.
Tutorial por Marcelo Cavaco ([email protected])
74
Conhecendo Os Scripts RGSS
Window_Item Herança: Window_Selectable
Descrição: Esta janela mostra a lista de itens do grupo de personagens. É apresentada toda vez
que a opção Item (itens) do menu principal é selecionada.
Window_MenuStatus Herança: Window_Selectable
Descrição: Esta janela mostra o nome, o nível, os pontos de vida (HP), os pontos de habilidade
(SP), e o estado de cada personagem do grupo. Esta janela herda de Window_Selectable e não
de Window_Base pois determinados comandos de menu requerem que uma opção esteja
selecionada.
Window_Message Herança: Window_Selectable
Descrição: Esta é a janela principal de mensagens mostrada quando o comando de evento "Show
Message" (Mostrar Mensagem) é usado.
Window_NameEdit Herança: Window_Base
Descrição: Esta janela mostra o nome original do jogador, enquanto possibilita a alteração do
nome antigo através da escolha de um novo nome. Os novos nomes devem ser predefinidos e o
jogador não pode criar um novo.
Window_NameInput Herança: Window_Base
Descrição: Esta janela é a janela onde o jogador realmente cria um novo nome. Não precisa ser
um nome pré-determinado. O jogador escolhe as letras para o nome da maneira que quiser.
Window_PartyCommand Herança: Window_Selectable
Descrição: Esta janela mostra as opções Fight (Lutar) ou Flee (Fugir) no inicio de cada turno.
Tutorial por Marcelo Cavaco ([email protected])
75
Conhecendo Os Scripts RGSS
Window_PlayTime Herança: Window_Base
Descrição: Esta janela mostra quanto tempo de jogo já se passou no menu principal do jogo.
Window_SaveFile Herança: Window_Base
Descrição: Esta janela mostra o estado de um arquivo salvo individualmente nas cenas
scene_save ou scene_load.
Window_Selectable Herança: Window_Base
Descrição: Esta é a classe básica para a maioria das janelas que permitem que você selecione
alguma opção na tela. É bastante flexível, a ponto de aceitar opções divididas em linhas e/ou em
colunas.
Window_ShopBuy Herança: Window_Selectable
Descrição: Esta janela mostra os itens disponíveis para serem comprados quando é selecionada a
opção Buy (compra) na tela principal das lojas, ou seja, na tela Window_ShopCommand.
Window_ShopCommand Herança: Window_Selectable
Descrição: Esta janela mostra as opções Buy (Comprar), Sell (Vender), and Exit (Sair) quando
uma tela de loja é aberta.
Window_ShopNumber Herança: Window_ShopNumber
Descrição: Esta tela aparece quando um item é comprado ou vendido, para que possamos indicar
a quantidade de itens que desejamos.
Tutorial por Marcelo Cavaco ([email protected])
76
Conhecendo Os Scripts RGSS
Window_ShopSell Herança: Window_Selectable
Descrição: Esta tela mostra os itens disponíveis que podem ser vendidos quando é selecionada a
opção Sell (venda) na tela principal das lojas, ou seja, na tela Window_ShopCommand.
Window_ShopStatus Herança: Window_Base
Descrição: Quando é selecionado um item para comprar numa loja, esta tela mostra a
quantidade disponível deste mesmo item no inventário do grupo. Ela mostra também a mudança
de poder ou defesa (dependendo do item) para cada personagem que pode utilizar aquele item.
Window_Skill Herança: Window_Selectable
Descrição: Esta janela mostra a lista de habilidades do personagem e pode ser usado no menu ou
durante uma batalha.
Window_SkillStatus Herança: Window_Base
Descrição: Esta janela aparece em cima da janela de seleção de habilidades. Ela mostra o nome,
o estado, os pontos de vida (HP) e os ponstos de habilidade SP do personagem usando esta
habilidade.
Window_Status Herança: Window_Base
Descrição: Esta habilidade mostra o estado do personagem no menu principal.
Window_Steps Herança: Window_Base
Descrição: Esta janela mostra no menu principal quantos passos foram dados pelos heróis.
Tutorial por Marcelo Cavaco ([email protected])
77
Conhecendo Os Scripts RGSS
Window_Target Herança: Window_Selectable
Descrição: Esta tela é apresentada quando um item ou habilidade precisa de um alvo. Esta tela
não é utilizada durante uma batalha.
Tutorial por Marcelo Cavaco ([email protected])
78
Conhecendo Os Scripts RGSS
Entendendo as Classes e M◊todos
Introdução
Muito bem... Já vimos muita coisa. Sabemos tudo sobre a sintaxe e os comandos (eu espero),
mas ainda está meio confuso este negócio chamado “orienteção a obejtos”. Que bixo é este? O
que siginifica orientação a objetos? É o que veremos agora...
Orientação a Obejtos
Um objeto é a instância de uma classe. Traduzindo isso para português, uma classe e um objeto
são exatamente a mesma coisa, mas quando está no papel (ou na tela do computador) é
chamado de classe e quando está sendo executado pelo programa é objeto.
Vejamos um exemplo de classe:
class Musica
def initialize(nome, artista, duracao)
@nome = nome
@artista = artista
@duracao = duracao
end
end
Aqui, criamos a classe Musica. Note que criamos dentro desta classe um método chamado
initialize. Este é um método especial do Ruby. Quando executamos o comando Musica.new para
criarmos o objeto Musica na memória, o Ruby cria um objeto não inicializado e logo depois
chama o método initialize passando os parâmetros especificados no new.
Tutorial por Marcelo Cavaco ([email protected])
79
Conhecendo Os Scripts RGSS Na classe música têmos três parâmetros. Estes parâmetros adicionam valores a variáveis de
instância. Estas variáveis podem ser acessadas por qualquer método de nossa classe Musica ou
sub-classe.
Vamos voltar à nossa classe e criar mais um método. Ela deve ficar assim:
class Musica
def initialize(nome, artista, duracao)
@nome = nome
@artista = artista
@duracao = duracao
end
def to_s
return "Música: #{@nome}-#{@artista} (#{@duracao})"
end
end
Aqui, estamos pedindo para nosso novo método (chamado to_s) para retornar um valor no
formato String que seja composto pelo nome da música (nome), nome do artista (artista) e a
duração da música (duracao).
Agora, nossa classe já faz alguma coisa de útil. Vamos ver um código típico onde utilizarêmos a
nossa classe e seus métodos.
minha_musica = Musica.new(“Track01”, “Fulano”, “05:00 minutos”)
print minha_musica.to_s
O resultado disso será:
"Música: Track01-Fulano (05:00 minutos)".
Tutorial por Marcelo Cavaco ([email protected])
80
Conhecendo Os Scripts RGSS Já criamos a classe Musica, mas que tal criarmos um Karaoke? Esta classe deve ser bastante
semelhante à classe Musica, não acha? Precisariamos de apenas uma mudança. Esta mudança
deve possibilitar que a letra da música apareça. Então fica fácil criarmos a classe Karaoke. Basta
copiarmos nossa classe e colocarmos outro nome nela. Depois criamos a variável @letra. Certo?
Errado!
Nunca duplique um código (utilizando os famosos Crtl+C e Ctrl+V) numa linguagem orientada a
obejtos. Para fazermos nossa classe Karaoke do modo correto devemos utilizar as “heranças”.
Primeiro, nós devemos criar a classe Karaoke herdando as caracteristicas da classe Musica.
class Karaoke < Musica
def initialize(nome, artista, duracao, letra)
super(nome, artista, duracao)
@letra = letra
end
end
Note que na inicialização, temos quatro parametros agora. Numa herança, todas as variáveis da
classe mãe funcionam com se tivessem sido declaradas na classe filha. O mesmo acontece com
os métodos, portanto já podemos utilizar o método to_s. Qual seria o resultado deste comando?
meu_karaoke = Karaoke.new(“Track99”, “Ciclano”, “02:30 minutos”, “la la la... laa, laa... la, la”)
print meu_karaoke.to_s
O resultado disso será:
"Música: Track99-Ciclano (02:30 minutos)".
Onde foi parar o valor da variável letra??? A variável letra não apreceu, pois numa herança, os
métodos são herdados exatamente como foram definidos na classe mãe. Na classe mãe não
mandamos a variável letra aparecer, lembra?
Tutorial por Marcelo Cavaco ([email protected])
81
Conhecendo Os Scripts RGSS Para resolver este problema temos que redefenir o método to_s. Nossa classe deve ficar assim:
class Karaoke < Musica
def initialize(nome, artista, duracao, letra)
super(nome, artista, duracao)
@letra = letra
end
def to_s
return "Karaoke: #{@nome}-#{@artista} (#{@duracao}) [#{@letra}]"
end
end
Pronto! Agora, nosso retorno será:
"Karaoke: Track99-Ciclano (02:30 minutos) [la la la... laa, laa... la, la]".
Note que os métodos das classes que criamos foram usadas sem problema nenhum. Isso ocorre,
pois os métodos criados são públicos por definição.
Se não indicarmos nada, os métodos serão públicos, mas ainda podemos deixá-los como
protegidos ou no modo privado. Uma das formas de se fazer isso é assim:
class MinhaClasse
public :metodo1, :metodo4
protected :metodo3
private :metodo4
end
Tutorial por Marcelo Cavaco ([email protected])
82
Conhecendo Os Scripts RGSS Outra forma seria esta:
class MinhaClasse
def metodo1 # o padrão é 'public'
#...
end
protected # os métodos subsequentes serão 'protected'
def metodo2 # vai ser 'protected'
#...
end
private # os métodos subsequentes serão 'private'
def metodo3 # vai ser 'private'
#...
end
public # os métodos subsequentes serão 'public'
def metodo4 # e este vai ser 'public'
#...
end
end
Os métodos public (públicos) podem ser chamados por qualquer um e não existe controle de
acesso. Os métodos são públicos por definição (à exceção de inicialize, que é sempre private).
Os métodos protected (protegidos) podem ser chamados somente por objetos da classe atual e
de suas sub-classes. O escopo de utilização é mantido “dentro da família”, ou seja, classe mãe e
suas classes filhas.
Os métodos private (confidenciais) não podem ser chamados por outra classe que não seja ela
mesma ou a classe que seja descendente direto desta classe.
Este é o básico da orientação a objetos. Agora, podemos criar nosso primeiro script.
Tutorial por Marcelo Cavaco ([email protected])
83
Conhecendo Os Scripts RGSS
Criando um Script
Introdução
Agora nós já conhecemos lógica de programação, a sintaxe básica dos scripts RGSS, os scripts
RGSS padrões e o funcionamento básico de uma linguagem OOP. Com esta base, temos
conhecimento para criar o nosso primeiro script.
Se você está lendo este tutorial, com certeza já deve ter uma boa base nos recursos do RPG
Maker XP. Por causa disso, este capítulo irá detalhar apenas os casos referentes aos scripts.
Caso você não tenha conhecimentos básicos, este capítulo pode parecer complexo e de difícil
entendimento. Portanto, só continue a leitura se você tem certeza que conhece bem o aplicativo.
Scene_Tutorial
O Editor de Scripts
Aqui, vamos ver como criar uma scene completa, com tela de help (ajuda), tela de comandos,
telas secundárias, dentre outras coisas. E qual o motivo para estudarmos sobre a criação de uma
scene? Bem... Exitem muitas scene’s num jogo criado no RPG Maker, portanto, se você deseja
personalisar seu jogo, é inprescendível ter um conhecimento no funcionamento das scene’s.
Primeiro crie um novo projeto. Depois vamos abrir o editor de scripts RGSS. Caso não se lembre
como fazer isso, tente usar a tecla de atalho F11.
No lado esquerdo da tela temos a lista de todos os scripts padrões (aqueles que já vimos no
capítulo anterior). Desca a tela até encontrar o script com nome de Main (Principal).
Tutorial por Marcelo Cavaco ([email protected])
84
Conhecendo Os Scripts RGSS Clique com o botão direito do mouse em cima do Main.
Um menu pop up deve aparecer conforme podemos observar na figura 05.
Figura 05
Menu pop up do editor de scripts.
Selecione a opção Insert (Inserir). Uma tela em branco deve aparecer. Selecione a opção criada e
dê um nome para ela. Exemplo: Scene_Tutorial_Script.
Agora podemos digitar nossas expressões e códigos do script. Observe na figura 06 como a tela
deve ficar.
Tutorial por Marcelo Cavaco ([email protected])
85
Conhecendo Os Scripts RGSS
Figura 06Script do tutorial.
Antes de começarmos a encher nossa tela de expressões e códigos, vamos entender uma scene.
Toda cena com janelas é uma scene. As janelas são criadas separadamente, ou seja, cada janela
é uma classe diferente. A scene também eu uma classe, mas ela fica responsável apenas por
controlar o que cada janela faz.
Resumindo:
Classe da Scene: Define e controla as janelas.
Classes das Janleas: Define a aparência das janelas.
Tutorial por Marcelo Cavaco ([email protected])
86
Conhecendo Os Scripts RGSS
Planejando da Cena
Antes de chegarmos ao código, vamos pensar em como será nossa scene. Podemos criar uma
cena onde em cima fica a tela de help (ajuda), depois uma tela de comandos e por último duas
telas diferentes para aprendermos a usar diversos comandos.
Nossas janelas devem ser utilizadas através de variáveis. Vamos criar uma variável para cada
janela. A primeira janela será representada pela variável @help_window onde mostrarêmos
textos descritivos sobre a nossa scene. A segunda janela será representada pela variável
@command_window responsável pelas opções principais de scene, depois terêmos a terceira
janela representada pela variável @tela1_window e a quarta janela que será representada pela
variável @tela2_window onde irêmos testar a iteração entre as janelas.
Só com variáveis que a nossa scene sonsegue manipular as janelas. Em nosso exemplo, a scene
irá manipular quatro janelas e, portanto, terêmos que ter quatro variáveis deste tipo, sendo uma
variável para cada janela.
A cena utiliza as variáveis para manipular as janelas atravé do método main da classe da scene.
Lá é onde as variáveis referentes às janelas são instanciadas e usadas pela primeira vez.
Em outros métodos da scene, as variáveis de janelas são usadas novamente toda vez que
desejamos efetuar alguma operação com janelas.
Tutorial por Marcelo Cavaco ([email protected])
87
Conhecendo Os Scripts RGSS
Entendendo As Classes
Agora que já sabemos que nossas classes de janelas serão usadas através de variáveis, devemos
saber como será o funcionamento das janelas e da scene. É batante simples. A classe scene
possuirá métodos para controlar toda a iteração entre as janelas, cursores, opções e
informações. A classe scene só não irá controlar o formato das janelas.
Cada janela é uma classe que terá dentro de si métodos para definir como será o seu formato,
tamanho, cor, estilo, skin, dentre outras coisas.
Agora, vamos ver cada classe resumidamente.
class Window_TutorialCommand
A variável @command_window deve ser do tipo de nossa janela de comando com as opções
principais de nossa scene. Nome de exemplo para esta janela: Window_TutorialCommand.
# classe Window_TutorialCommand class Window_TutorialCommand < Window_Selectable # método initialize def initialize ... # incializa a classe end # método draw_item(index) def draw_item(index) ... # desenhando o texto na janela end # método refresh def refresh ... # atualizando desenhos e textos da janela end # método update_help def update_help ... # muda o texto do help end end # fim da classe
Tutorial por Marcelo Cavaco ([email protected])
88
Conhecendo Os Scripts RGSS
class Window_Tela1
A variável @tela1_window deve ser do tipo de nossa primeira janela de informações. Aqui,
podemos criar uma tela onde o jogador irá ver algumas informações, mas não iteragir. Note que
nesta janela só vamos mostrar dados, ou seja, não vamos selecionar nada. Por causa disso, esta
janela vai herdar de Window_Base ao invés de Window_Selectable.
Nome de exemplo para esta janela: Window_Tela1.
# classe Window_Tela1 class Window_Tela1 < Window_Base # método initialize def initialize ... # incializa a classe end # método refresh def refresh ... # atualizando desenhos e textos da janela end end # fim da classe
Tutorial por Marcelo Cavaco ([email protected])
89
Conhecendo Os Scripts RGSS
class Window_Tela2
A variável @tela2_window deve ser do tipo de nossa segunda janela de informações. Aqui irêmos
efetuar operações, ou seja, será necessário selecionar opções. Por causa disso, esta janela vai
herdar de Window_Selectable.
Nome de exemplo para esta janela: Window_Tela2.
# classe Window_Tela2 class Window_Tela2 < Window_Selectable # método initialize def initialize ... # incializa a classe end # método draw_item(index) def draw_item(index) ... # desenhando o texto na janela end # método refresh def refresh ... # atualizando desenhos e textos da janela end # método update_help def update_help ... # muda o texto do help end end # fim da classe
Tutorial por Marcelo Cavaco ([email protected])
90
Conhecendo Os Scripts RGSS
class Scene_Tutorial
Ainda terêmos a scene que será responsável por controlar todas as nossas janelas. Na classe
Scene_Tutorial é onde devem existir as variáveis referentes às janelas. No main elas são
instânciadas. Exemplo: @command_window = Window_TutorialCommand.new
Nome de exemplo para esta classe: Scene_Tutorial.
# Scene_Tutorial class Scene_Tutorial # método main def main ... # método com expressões executadas por tempo indefinido até que a scene seja fechada end # método update def update ... # atualiza todas as janelas e verifica o tratamento dos comandos end # método update_command def update_command ... # checa se uma tecla foi pressionada na tela de comando principal end # método update def update_command_tela2 ... # checa se uma tecla foi pressionada na tela de comando da janela Window_Tela2 end end # fim da classe
Tutorial por Marcelo Cavaco ([email protected])
91
Conhecendo Os Scripts RGSS
O Código do Script
Agora, finalmente, vamos ao código!
#------------------------------------------------------------------------------ # Window_TutorialCommand # * janela de comando que herda de Window_Selectable #------------------------------------------------------------------------------ class Window_TutorialCommand < Window_Selectable #------------------------------------------------------------------------------ # método initialize da janela Window_TutorialCommand #------------------------------------------------------------------------------ def initialize # incializa a classe mãe super(0, 64, 640, 64) # configura a área disponível para uso da janela self.contents = Bitmap.new(width - 32, height - 32) # configura a fonte da janela self.contents.font.name = $fontface # configura o tamanho da fonte da janela self.contents.font.size = $fontsize # vetor com opções de comando da janela @commands = ["Tela 01", "Tela 02", "Voltar para o Mapa"] # indicando quantos itens queremos na tela de comando # itens igual ao total de valores no vetor @commands @item_max = @commands.size # indicando quantas colunas queremos na tela de comando # colunas igual ao número de itens @column_max = @item_max # redesenhando a janela refresh # indicando a posição inicial do cursor ao abrir a janela self.index = 0 # indicando a posição da janela no eixo Z self.z=50 end # fim do método initialize da classe Window_TutorialCommand #------------------------------------------------------------------------------ # método draw_item da janela Window_TutorialCommand #------------------------------------------------------------------------------ def draw_item(index) # index representa a coluna onde o texto vai ser digitado # calculando a posição x do texto x = 4 + index * (640/@column_max) # calculando o tamanho do texto w = (640/@column_max)-32 # indicando a cor do texto self.contents.font.color = normal_color
Tutorial por Marcelo Cavaco ([email protected])
92
Conhecendo Os Scripts RGSS # desenhando o texto na janela self.contents.draw_text(x, 0, w, 32, @commands[index]) end # fim do método draw_item(index) da classe Window_TutorialCommand #------------------------------------------------------------------------------ # método refresh da janela Window_TutorialCommand #------------------------------------------------------------------------------ def refresh # limpando toda a janela self.contents.clear # indicando a skin da janela @windowskin_name = $game_system.windowskin_name self.windowskin = RPG::Cache.windowskin(@windowskin_name) # desenhandoa listagem de itens for i in 0...@item_max draw_item(i) end # atualizando otexto da tela de help (ajuda) update_help end # fim do método refresh da classe Window_TutorialCommand #------------------------------------------------------------------------------ # método update_help da janela Window_TutorialCommand #------------------------------------------------------------------------------ def update_help # se a janela ativa não tiver help, retorna sem dar erro return if @help_window.nil? # se a janela atual estiver ativa... if self.active == true if self.index == 0 # se a posição do cursor for 0 (zero) na janela atual... # então muda o texto de help para "Abre a Tela 01." @help_window.set_text("Abre a Tela 01.") elsif self.index == 1 # se a posição do cursor for 1 (um) na janela atual... # então muda o texto de help para "Abre a Tela 02." @help_window.set_text("Abre a Tela 02.") elsif self.index == 2 # se a posição do cursor for 2 (dois) na janela atual... # então muda o texto de help para "Fecha a Scene." @help_window.set_text("Fecha a Scene.") end # fim do if self.index == xxx end # fim do if self.active == true end # fim do método update_help da classe Window_TutorialCommand end # fim da classe Window_TutorialCommand #------------------------------------------------------------------------------ # Fim da classe Window_TutorialCommand #------------------------------------------------------------------------------
Tutorial por Marcelo Cavaco ([email protected])
93
Conhecendo Os Scripts RGSS #------------------------------------------------------------------------------ # Window_Tela1 # * janela normal que herda de Window_Base #------------------------------------------------------------------------------ class Window_Tela1 < Window_Base #------------------------------------------------------------------------------ # método initialize da janela Window_Tela1 #------------------------------------------------------------------------------ def initialize # incializa a classe mãe super(0, 128, 640, 352) # configura a área disponível para uso da janela self.contents = Bitmap.new(width - 32, height - 32) # configura a fonte da janela self.contents.font.name = $fontface # configura o tamanho da fonte da janela self.contents.font.size = $fontsize # redesenhando a janela refresh # indicando a posição da janela no eixo Z self.z=50 end # fim do método initialize da classe Window_Tela1 #------------------------------------------------------------------------------ # método refresh da janela Window_Tela1 #------------------------------------------------------------------------------ def refresh # limpando toda a janela self.contents.clear # indicando a skin da janela @windowskin_name = $game_system.windowskin_name self.windowskin = RPG::Cache.windowskin(@windowskin_name) # indicando a cor do texto self.contents.font.color = normal_color # cria variável com ponteiro para o primeiro actor (heroi) actor = $game_party.actors[0] # desenhando os diversos tipos de textos na janela self.contents.draw_text(4 , 32 * 0, 640, 32, "Nome: " + actor.name) # desenhando o nome self.contents.draw_text(4 , 32 * 1, 640, 32, "Classe: " + actor.class_name + " (nível " + actor.level.to_s + ")") # desenhando a classe e nível self.contents.draw_text(4 , 32 * 3, 640, 32, "Opções modificadas na tela 2:") # desenhando texto self.contents.draw_text(4+32, 32 * 4, 640, 32, "Variável [0001] : " + $game_variables[1].to_s) # desenhando valor de variável self.contents.draw_text(4+32, 32 * 5, 640, 32, "Variável [0002] : " + $game_variables[2].to_s) # desenhando valor de variável self.contents.draw_text(4+32, 32 * 6, 640, 32, "Variável [0003] : " + $game_variables[3].to_s) # desenhando valor de variável self.contents.draw_text(4+32, 32 * 7, 640, 32, "Switches [0001] : " + $game_switches[1].to_s) # desenhando valor de swtich self.contents.draw_text(4+32, 32 * 8, 640, 32, "Switches [0002] : " + $game_switches[2].to_s) # desenhando valor de swtich self.contents.draw_text(4+32, 32 * 9, 640, 32, "Switches [0003] : " + $game_switches[3].to_s) # desenhando valor de swtich # desenhando os diversos tipos de informação sobre o herói draw_actor_graphic (actor, 364, 32 * 1.6) # desenhando o chaset draw_actor_hp (actor, 396, 32 * 0, 172) # desenhando o HP
Tutorial por Marcelo Cavaco ([email protected])
94
draw_actor_sp (actor, 396, 32 * 1, 172) # desenhando o SP
Conhecendo Os Scripts RGSS draw_actor_parameter(actor, 396, 32 * 3, 0) # desenhando atributos draw_actor_parameter(actor, 396, 32 * 4, 1) # desenhando atributos draw_actor_parameter(actor, 396, 32 * 5, 2) # desenhando atributos draw_actor_parameter(actor, 396, 32 * 6, 3) # desenhando atributos draw_actor_parameter(actor, 396, 32 * 7, 4) # desenhando atributos draw_actor_parameter(actor, 396, 32 * 8, 5) # desenhando atributos draw_actor_parameter(actor, 396, 32 * 9, 6) # desenhando atributos end # fim do método refresh da classe Window_Tela1 end # fim da classe Window_Tela1 #------------------------------------------------------------------------------ # Fim da classe Window_Tela1 #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # Window_Tela2 # * janela de comando que herda de Window_Selectable #------------------------------------------------------------------------------ class Window_Tela2 < Window_Selectable #------------------------------------------------------------------------------ # método initialize da janela Window_Tela2 #------------------------------------------------------------------------------ def initialize # incializa a classe mãe super(0, 128, 640, 352) # configura a área disponível para uso da janela self.contents = Bitmap.new(width - 32, height - 32) # configura a fonte da janela self.contents.font.name = $fontface # configura o tamanho da fonte da janela self.contents.font.size = $fontsize # indicando quantos itens queremos na tela de comando @item_max = 10 # indicando quantas colunas queremos na tela de comando @column_max = 1 # variáveis temporárias usadas no vetor com opções de comando s1 = "Variable: [0001] += 1" s2 = "Variable: [0001] -= 1" s3 = "Variable: [0002] += 15" s4 = "Variable: [0002] -= 15" s5 = "Variable: [0002] *= 2" s6 = "Switch: [0001] = ON" s7 = "Switch: [0001] = OFF" s8 = "Switch: [0002] = ON / OFF" s9 = "Variable: [0003] = Variable: [0001] * Variable: [0002]" s10 = "Switch: [0003] = not Switch: [0002]" # vetor com opções de comando da janela @commands = [s1,s2,s3,s4,s5,s6,s7,s8,s9,s10] # redesenhando a janela refresh # indicando a posição inicial do cursor ao abrir a janela
Tutorial por Marcelo Cavaco ([email protected])
95
self.index = 0
Conhecendo Os Scripts RGSS # indicando a posição da janela no eixo Z self.z=50 end # fim do método initialize da classe Window_Tela2 #------------------------------------------------------------------------------ # método draw_item(index) da janela Window_Tela2 #------------------------------------------------------------------------------ def draw_item(index) # index representa a linha onde o texto vai ser digitado # calculando a posição y do texto y = index * 32 # indicando a cor do texto self.contents.font.color = normal_color # desenhando o texto na janela self.contents.draw_text(4, y, 640, 32, @commands[index].to_s) end # fim do método draw_item(index) da classe Window_Tela2 #------------------------------------------------------------------------------ # método refresh da janela Window_Tela2 #------------------------------------------------------------------------------ def refresh # limpando toda a janela self.contents.clear # indicando a skin da janela @windowskin_name = $game_system.windowskin_name self.windowskin = RPG::Cache.windowskin(@windowskin_name) # desenhandoa listagem de itens for i in 0...@item_max draw_item(i) end # atualizando otexto da tela de help (ajuda) update_help end # fim do método refresh da classe Window_Tela2 #------------------------------------------------------------------------------ # método update_help da janela Window_Tela2 #------------------------------------------------------------------------------ def update_help # se a janela ativa não tiver help, retorna sem dar erro return if @help_window.nil? if self.active == true # se a janela atual estiver ativa... # atualiza o texto da janela de help com a opção selecionada @help_window.set_text("opção selecionada : " + @commands[index]) end # fim do if self.active == true end # fim do método update_help da classe Window_Tela2 end # fim da classe Window_Tela2 #------------------------------------------------------------------------------ # Fim da classe Window_Tela2
Tutorial por Marcelo Cavaco ([email protected])
96
#------------------------------------------------------------------------------
Conhecendo Os Scripts RGSS #------------------------------------------------------------------------------ # Scene_Tutorial # * Classe que vai controlar nossas janelas #------------------------------------------------------------------------------ class Scene_Tutorial #------------------------------------------------------------------------------ # método main executado toda vez que iniciamos o objeto # (Scene_Tutorial.New) #------------------------------------------------------------------------------ def main # definindo uma variável para nossa janela de help # não foi necessário criar esta janela, pois usamos # a janela de help padrão dos Scripts RGSS @help_window = Window_Help.new # informando que queremos a janela de help ativada @help_window.active = true # informando que queremos a janela de help visível @help_window.visible = true # definindo uma variável para nossa janela de comandos principais @command_window = Window_TutorialCommand.new # associando a janela de help à nossa janela de comandos @command_window.help_window = @help_window # informando que queremos a janela de comandos ativada @command_window.active = true # informando que queremos a janela de comandos visível @command_window.visible = true # definindo uma variável para nossa janela chamada Tela 01 # a janela "Tela 01" não usa a janela de help @tela1_window = Window_Tela1.new # informando que queremos a janela chamada Tela 01 desativada @tela1_window.active = false # informando que queremos a janela chamada Tela 01 visível @tela1_window.visible = true # definindo uma variável para nossa janela chamada Tela 02 @tela2_window = Window_Tela2.new # associando a janela de help à nossa janela "Tela 02" @tela2_window.help_window = @help_window # informando que queremos a janela chamada Tela 02 desativada @tela2_window.active = false # informando que queremos a janela chamada Tela 02 invisível @tela2_window.visible = false # executa a transição da tela Graphics.transition loop do # atualiza os gráficos Graphics.update # atualiza as entradas Input.update # atualiza scene indefinidamente até que a scene seja fechada update if $scene != self # se sair desta scene,
Tutorial por Marcelo Cavaco ([email protected])
97
# para de executar este código
Conhecendo Os Scripts RGSS break end # fim do if $scene != self end # fim do comando loop do # finaliza os gráficos e imagens Graphics.freeze # fecha todas as janelas que criamos nesta scene @help_window.dispose @command_window.dispose @tela1_window.dispose @tela2_window .dispose end # fim do método main da classe Scene_Tutorial #------------------------------------------------------------------------------ # método update da classe Scene_Tutorial #------------------------------------------------------------------------------ def update # atualiza todas as janelas que criamos nesta scene @help_window.update @command_window.update @tela1_window.update @tela2_window .update if @command_window.active # se a janela @command_window estiver ativa # atualiza os comandos da janela @command_window update_command elsif @tela2_window.active # se a janela @tela2_windowestiver ativa # atualiza os comandos da janela @tela2_window update_command_tela2 end # fim do if @command_window.active end # fim do método update da classe Scene_Tutorial #------------------------------------------------------------------------------ # método update_command da classe Scene_Tutorial #------------------------------------------------------------------------------ def update_command #verifica a tecla pressionada if Input.trigger?(Input::B) # se a tecla dgitada por [esc] ou X # toca som de cancelar $game_system.se_play($data_system.cancel_se) # e volta para o mapa de jogo $scene = Scene_Map.new elsif Input.trigger?(Input::C) # se a tecla digitada por [enter] ou C # toca som de decisão $game_system.se_play($data_system.decision_se) case @command_window.index # verifica em que posição esta o cursor when 0
Tutorial por Marcelo Cavaco ([email protected])
98
# se o cursor estiver na posição 0 (zero)
Conhecendo Os Scripts RGSS @command_window.active = true # ativa a janela @command_window @help_window.active = false # desativa a janela @help_window @help_window.visible = true # torna a janela @help_window visível @tela1_window.active = false # desativa a janela @tela1_window @tela1_window.visible = true # torna a janela @tela1_window visível @tela2_window.active = false # desativa a janela @tela2_window @tela2_window.visible = false # torna a janela @tela2_window invisível @tela1_window.refresh # redefine a janela @tela1_window when 1 # se o cursor estiver na posição 1 (um) @command_window.active = false # ativa a janela @command_window @help_window.active = true # ativa a janela @help_window @help_window.visible = true # torna a janela @help_window visível @tela1_window.active = false # desativa a janela @tela1_window @tela1_window.visible = false # torna a janela @tela1_window invisível @tela2_window.active = true # ativa a janela @tela2_window @tela2_window.visible = true # torna a janela @tela2_window visível when 2 # se o cursor estiver na posição 2 (dois) # toca som de cancelar $game_system.se_play($data_system.cancel_se) # e volta para o mapa de jogo $scene = Scene_Map.new end # fim do case @command_window.index end # fim do if Input.trigger? end # fim do método update_command da classe Scene_Tutorial #------------------------------------------------------------------------------ # método update da classe Scene_Tutorial #------------------------------------------------------------------------------ def update_command_tela2 #verifica a tecla pressionada if Input.trigger?(Input::B) # se a tecla dgitada por [esc] ou X # toca som de cancelar $game_system.se_play($data_system.cancel_se) @command_window.active = true # ativa a janela @command_window @help_window.active = true # ativa a janela @command_window @help_window.visible = true # torna a janela @help_window visível @tela1_window.active = false # desativa a janela @command_window @tela1_window.visible = false # torna a janela @tela1_window invisível
Tutorial por Marcelo Cavaco ([email protected])
99
@tela2_window.active = false # desativa a janela @command_window
Conhecendo Os Scripts RGSS @tela2_window.visible = true # torna a janela @tela2_window visível elsif Input.trigger?(Input::C) # se a tecla dgitada por [enter] ou C # toca som de decisão $game_system.se_play($data_system.decision_se) case @tela2_window.index # verifica em que posição esta o cursor when 0 # se o cursor estiver na posição 0 (zero) # variável 1 recebe +1 em seu valor $game_variables[1] += 1 when 1 # se o cursor estiver na posição 1 (um) # variável 1 recebe -1 em seu valor $game_variables[1] -= 1 when 2 # se o cursor estiver na posição 2 (dois) # variável 2 recebe +15 em seu valor $game_variables[2] += 15 when 3 # se o cursor estiver na posição 3 (três) # variável 2 recebe -15 em seu valor $game_variables[2] -= 15 when 4 # se o cursor estiver na posição 4 (quatro) # variável 2 recebe *2 em seu valor $game_variables[2] *= 2 when 5 # se o cursor estiver na posição 5 (cinco) # switch 1 fica ON $game_switches[1] = true when 6 # se o cursor estiver na posição 6 (seis) # switch 1 fica OFF $game_switches[1] = false when 7 # se o cursor estiver na posição 7 (sete) # switch 2 muda de valor entre ON e OFF $game_switches[2] = (not $game_switches[2]) when 8 # se o cursor estiver na posição 8 (oito) # variável 3 recebe o valor da variável 1 * variável 2 $game_variables[3] = $game_variables[1] * $game_variables[2] when 9 # se o cursor estiver na posição 9 (nove) # switch 3 fica com valor oposto do Switch 2 $game_switches[3] = (not $game_switches[2]) end # fim do case @tela2_window.index end # if Input.trigger? end # fim do método update_command_tela2 da classe Scene_Tutorial end # fim da classe Scene_Tutorial #------------------------------------------------------------------------------ # Fim da classe Scene_Tutorial #------------------------------------------------------------------------------
Tutorial por Marcelo Cavaco ([email protected])
100
Conhecendo Os Scripts RGSS
Testando o Script
Chegou a hora dos testes. Crie um novo evento no mapa. Deixe-o como “Action Key” (Tecla de
Ação). Escolha uma imagem para este evento, para podermos visualizá-lo no mapa. Abra a
terceira aba de comando e selecione o comando de evento chamado “Call Script” (Rodar/Chamar
Script). Na tela que irá se abrir digite “$scene = Scene_Tutorial.new” sem as aspas. A tela deste
comando deve ficar semelhante à figura 07.
Figura 07Evento para chamar o Script.
Com este comando estarêmos instanciando a classe Scene_Tutorial na memória, ou seja,
estarêmos criando o obejto Scene_Tutorial.
A tela de evento deve ficar semelhante à figura 08.
Tutorial por Marcelo Cavaco ([email protected])
101
Conhecendo Os Scripts RGSS
Figura 08Evento para chamar o Script.
Depois de criar o evento, clique em OK e aperte F12 para iniciar o teste de nosso jogo. Se
aproxime do evento que acabamos de criar e pressione a tecla [Enter] ou “C”. Se tudo estiver
correto, a scene que criamos deve aparecer na tela.
Observe as figuras 09 e 10 para ver nosso script em funcionamento.
Tutorial por Marcelo Cavaco ([email protected])
102
Conhecendo Os Scripts RGSS
Figura 09
Testando o Script.
Tutorial por Marcelo Cavaco ([email protected])
103
Conhecendo Os Scripts RGSS
Figura 10
Testando o Script.
Tutorial por Marcelo Cavaco ([email protected])
104
Conhecendo Os Scripts RGSS
Conclus‘o
O objetivo deste tutorial é apenas mostrar alguns dos recursos avançados dos Scripts RGSS
disponíveis no RPG Maker XP.
Este tutorial iniciou nossa caminhada no mundo dos scripts, agora vamos nos aprofundar ainda
mais neste assunto. Estamos apenas começando a conhecer esta maravilhosa ferramenta do RPG
Maker XP.
O nome do próximo tutorial é “Recursos Avançados de Scripts do RPG Maker XP”. Nele iremos
conhecer mais profundamente alguns dos recursos mais avançados do editor de scripts e
veremos toda a potencialidade que podemos ter em nossas mãos.
O autor deste tutorial é Marcelo Cavaco, formado em Processamento de Dados pela Faculdade
Rui Barbosa e formado em Engenharia de Produção pela Unibahia. Já trabalhou 6 anos como
analista de sistemas e agora trabalha como engenheiro e responsável pelo setor de informática
da Sengin – Serviços de Engenharia de Instrumentação Ltda (www.sengin.com.br) desde 2004.
Qualquer dúvida, crítica, sugestão, reclamação, comentário ou algo semelhante, favor mandar
um e-mail para [email protected] ou se preferir mande um scrapt (recado) no meu
Orkut.
Está na hora de avançar para o tutorial: “Recursos Avançados dos Scripts do RPG Maker XP ”.
Tutorial por Marcelo Cavaco ([email protected])
105