conhecendo os scripts do rpg maker xp

Transcrição

DEGFDEGF Conhecendo Os Scripts RGSS GFDEGFDE
Tutorial RPG Maker XP

Tutorial RPG Maker XP
Por Marcelo Cavaco ([email protected])
Conhecendo os Scripts
Conhecendo os Scripts
1
Tutorial por Marcelo Cavaco ([email protected])
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...
2
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...
3
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
4
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
Expression Substitution
Array’s
39
40
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
Condições
IF
if (Outra opção)
unless
unless (Outra opção)
case
48
48
48
49
50
50
51
5
Repetições
52
while
while (Outra opção)
until
until (Outra opção)
for
break
next
Method Exit (Método de Saída)
52
53
53
54
54
55
56
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)
Scripts RGSS Standard
Listagem de Scripts RGSS Padrão
63
64
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
6
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
7
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
class Window_Tela1
class Window_Tela2
class Scene_Tutorial
O Código do Script
88
89
90
91
92
Testando o Script
Conclusão
101
105
8
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...
9
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.
10
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 01
Abrindo a tela do editor de scripts.
11
Na tela que se abrirá podemos ver que já existem vários scripts prontos. Observe a figura 02.
Figura 02
Tela do editor de scripts.
12
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.
13
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.
14
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.
15
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.
16
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.
17
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.
18
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.
19
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:
20
O símbolo utilizado para comparação entre expressões seria:
Veremos mais exemplos de como utilizar este símbolo mais a diante.
21
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).
22
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.
Verdadeiro
Falso
Verdadeiro
23
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;
24
Exemplo:
Algoritimo “Chupar Bala” utilizando diagrama de Blocos.
Note que desta vez utilizamos o símbolo para comparação entre expressões.
25
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:
26
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:
27
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.
28
Agora, vejamos um exemplo de bloco estruturado.
Exemplo (Média de Notas):
Inicio
Ler Nome
Ler Nota 1
Ler Nota 2
Ler Nota 3
Ler Nota 4
MEDIA := (NOTA1 + NOTA2 + NOTA3 + NOTA4) / 4
Média
>= 6.0
????
sim
Escreva
Aprovado
não
Escreva
Reprovado
Escreva
Nome e Média
Fim
29
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.
30
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.
31
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
not
and
undef
return
class
super
do
break
until
ensure
while
if
elsif
nil
alias
redo
module
self
defined?
true
retry
when
for
begin
unless
END
or
else
case
def
then
in
end
false
yield
rescue
next
Estas são as palavras reservadas encontradas no RGSS do RPG Maker XP.
32
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
33
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
34
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
35
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"
36
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.
37
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.
38
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)
39
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}"
40
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]
pa
# => [1, 2]
(sem mudanças)
pb
# => [8, 9]
(sem mudanças aqui também)
41
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
42
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
43
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
44
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 ::
45
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
46
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
47
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
48
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
49
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
50
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
51
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.
52
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
53
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.
54
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]
55
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]
56
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 ... ]]
57
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.
58
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.
59
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.
60
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
61
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.
62
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"
63
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.
64
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.
65
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.
66
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).
67
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.
68
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.
69
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.
70
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.
71
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.
72
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
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.
73
Window_DebugLeft
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
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
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
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
Descrição: Esta é a janela para entrada de números. Ela é apresentada quando o comando de
evento "Input Number" (Entrar/Digitar Número) é utilizado.
74
Window_Item
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
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
Descrição: Esta é a janela principal de mensagens mostrada quando o comando de evento "Show
Message" (Mostrar Mensagem) é usado.
Window_NameEdit
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
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
Descrição: Esta janela mostra as opções Fight (Lutar) ou Flee (Fugir) no inicio de cada turno.
75
Window_PlayTime
Descrição: Esta janela mostra quanto tempo de jogo já se passou no menu principal do jogo.
Window_SaveFile
Descrição: Esta janela mostra o estado de um arquivo salvo individualmente nas cenas
scene_save ou scene_load.
Window_Selectable
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
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
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.
76
Window_ShopSell
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
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
Descrição: Esta janela mostra a lista de habilidades do personagem e pode ser usado no menu ou
durante uma batalha.
Window_SkillStatus
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
Descrição: Esta habilidade mostra o estado do personagem no menu principal.
Window_Steps
Descrição: Esta janela mostra no menu principal quantos passos foram dados pelos heróis.
77
Window_Target
Descrição: Esta tela é apresentada quando um item ou habilidade precisa de um alvo. Esta tela
não é utilizada durante uma batalha.
78
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.
79
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)".
80
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?
81
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
82
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.
83
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).
84
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.
85
Figura 06
Script 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.
86
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.
87
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
88
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
def initialize
end
# método refresh
def refresh
end
end # fim da classe
89
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
def initialize
end
# método draw_item(index)
def draw_item(index)
... # desenhando o texto na janela
end
# método refresh
def refresh
end
# método update_help
def update_help
... # muda o texto do help
end
end # fim da classe
90
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
# 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
91
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
92
# 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
#------------------------------------------------------------------------------
93
#-----------------------------------------------------------------------------# Window_Tela1
# * janela normal que herda de Window_Base
#-----------------------------------------------------------------------------class Window_Tela1 < Window_Base
#-----------------------------------------------------------------------------# método initialize da janela Window_Tela1
#-----------------------------------------------------------------------------def initialize
super(0, 128, 640, 352)
refresh
self.z=50
end # fim do método initialize da classe Window_Tela1
#-----------------------------------------------------------------------------# método refresh da janela Window_Tela1
#-----------------------------------------------------------------------------def refresh
self.contents.clear
# 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
, 32 * 1, 640, 32, "Classe: " + actor.class_name + " (nível " + actor.level.to_s + ")") # desenhando a classe e nível
, 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 * 7, 640, 32, "Switches [0001] : " + $game_switches[1].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
draw_actor_sp
(actor, 396, 32 * 1, 172) # desenhando o SP
94
draw_actor_parameter(actor, 396, 32 * 3, 0) # 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
super(0, 128, 640, 352)
# 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]
refresh
# indicando a posição inicial do cursor ao abrir a janela
self.index = 0
95
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
# 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
self.contents.clear
# 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
#------------------------------------------------------------------------------
96
#-----------------------------------------------------------------------------# 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,
# para de executar este código
97
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
# se o cursor estiver na posição 0 (zero)
98
@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.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
@tela2_window.active = true # ativa a janela @tela2_window
when 2
# se o cursor estiver na posição 2 (dois)
# 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
@command_window.active = true # ativa a janela @command_window
@help_window.active = true # ativa a janela @command_window
@tela1_window.active = false # desativa a janela @command_window
@tela2_window.active = false # desativa a janela @command_window
99
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
#------------------------------------------------------------------------------
100
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 07
Evento 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.
101
Figura 08
Evento 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.
102
Figura 09
Testando o Script.
103
Figura 10
Testando o Script.
104
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 ”.
105

conhecendo os scripts do rpg maker xp

Transcrição

Documentos relacionados

Janes / Cascais

Ficha técnica do Sibelius (formato PDF, 125 KB)

Roteiro de Instalação do Teraterm

English Day - Faculdade de Tecnologia de Carapicuíba

baixar o PDF - Giuliano Bertoti

Proteção social

Sunny Design para Auto consumo Estimado Cliente, A SMA

CONFIGURAÇÃO DO OUTLOOK EXPRESS

Tutorial para criar senha de acesso ao curso no Moodle

Baixar o arquivo