Destrinchando Os Scripts RGSS

Destrinchando os Scripts RGSS
Tutorial RPG Maker XP
Tutorial RPG Maker XP

1 Edio
Criado em maro de 2007.
Por Marcelo Cavaco (marcelocavaco@click21.com.br)

1
Tutorial por Marcelo Cavaco (marcelocavaco@click21.com.br)
Consideraes Iniciais
Devido falta de tutoriais a respeito desta ferramenta de criao 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 prpria e com o intuito de ajudar. Espero conseguir neste tutorial...
Este tutorial destinado a quem deseja conhecer um pouco mais sobre os Scripts RGSS do RPG
Maker XP. Este tutorial no um guia para solucionar problemas. Se voc no consegue
executar o aplicativo, procure pela FAQ do RPG Maker XP . L, muitos problemas e erros de
execuo so esclarecidos. Este tutorial de nvel avanado. Um conhecimento bsico
necessrio para utiliza-lo.
O Maker utilizado neste tutorial uma verso em ingls, mas TODOS os nomes em ingls tm
sua traduo entre parnteses. No conheo nem utilizo verses em portugus.
No conheo
quem traduziu outras verses e podem existir diferenas entre as tradues. Fiz curso de "Ingls
Tcnico I" e "Ingls Tcnico II" e acho que a traduo deve estar razovel e coerente com a
realidade, apesar disso, podem ocorrer erros. Por favor, me avisem caso encontrem algum.
importante salientar que alguns exemplos dos captulos iniciais so genricos e utilizam sintaxe
especfica do Ruby e talvez no funcionem no RGSS do RPG Maker XP . Apenas os comandos do
captulo "Sintaxe RGSS" em diante so inteiramente do RPG Maker XP.
No estou aqui querendo afirmar nada sobre nada nem ningum. No quero ofender nenhum
leitor, ou o vizinho, ou o cachorro do vizinho, ou o papagaio de qualquer um que seja. No estou
tentando provar nada. No sou "guru" do RPG Maker XP. Portanto, tenham pacincia...
E me desculpem por qualquer tipo de transtorno e muito obrigado aos que me ajudaram e
incentivaram.
Fora isso, boa leitura...
2
Cavaco's Creations
Voc pode copiar, distribuir, exibir, executar ou criar obras derivadas sob as seguintes condies:
Atribuio: Voc deve dar crdito ao autor original, da forma especificada pelo
autor ou licenciante.
Uso No-Comercial: Voc no pode utilizar esta obra com finalidades comerciais.
Compartilhamento pela mesma Licena: Se voc alterar, transformar, ou criar

outra obra com base nesta, voc somente poder distribuir a obra resultante sob
uma licena idntica a esta.
Para cada novo uso ou distribuio, voc deve deixar claro os termos da licena desta obra.
Qualquer uma destas condies podem ser renunciadas, desde que voc obtenha permisso do
autor. Qualquer direito de uso legtimo (ou "fair use") concedido por lei, ou qualquer outro direito
protegido pela legislao local, no so em hiptese alguma afetados pelo disposto acima.
Este um sumrio para leigos da Licena Jurdica (que pode ser obtida na ntegra em
http://www.4shared.com/file/11081399/19b3184f/Licena_de_Uso.html).
Termo de exonerao de responsabilidade
Esta Licena Simplificada no uma licena propriamente dita. Ela apenas uma referncia til
para entender a Licena Jurdica (a licena integral). Ela uma expresso dos seus termos-chave
que pode ser compreendida por qualquer pessoa. A Licena Simplifica em si no tem valor legal e
seu contedo no aparece na licena integral. A Cavaco's Creations no um escritrio de
advocacia e no presta servios jurdicos. A distribuio, exibio ou incluso de links para esta
Licena Simplificada no estabelece qualquer relao advocatcia.
3
Agradecimentos
Creio que sem ajuda ningum 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 algum. Mesmo
que esta tenha sido h muito tempo atrs quando o mdico ajudou esta pessoa a nascer... Mas
vamos parar de enrolar e vamos ao que interessa.
Agradeo :
Minha famlia, por me criar e aturar...
Meus amigos de RPG, por jogarem comigo...
Colegas de RPG Maker XP, por tirarem muitas de minhas dvidas...
Se faltar algum, faa o favor de me avisar. A memria s vezes (vrias vezes) falha...
4
Sumrio
Tutorial RPG Maker XP...............................................................1
Consideraes Iniciais................................................................ 2
Cavaco's Creations..................................................................... 3
Agradecimentos......................................................................... 4
Sumrio................................................................................... 5
ndice de Ilustraes.................................................................. 8
Como Utilizar este Tutorial.......................................................... 9
Comeando............................................................................. 10
Programando com RGSS........................................................... 11
Introduo............................................................................................ 11
O Ruby.................................................................................................12
O RGSS................................................................................................ 12
O Editor de Scripts................................................................................. 13
Teste dos Exemplos............................................................................... 18
Variveis.............................................................................................. 18
Operadores........................................................................................... 19
Operadores de atribuio de valores........................................................................... 19
Operadores de comparao de valores........................................................................ 20
Operadores de validao de comando......................................................................... 20
Expresses Literais................................................................................ 20
Arrays.................................................................................................. 23
Matrizes................................................................................................24
Estruturas de Controle............................................................................25
Indicaes Condicionais IF......................................................................................... 25
Condio CASE........................................................................................................ 30
Comando de repetio (loop) FOR.............................................................................. 35
Comando de repetio (loop) While/Do..While.............................................................. 38
5

Orientao a Objetos com RGSS................................................ 39
Introduo ........................................................................................... 39
Funes................................................................................................39
Sintaxe Bsica de uma Classe..................................................................43
Criando a Classe Carrinho de Compras......................................................47
A Classe e as Variveis Locais..................................................................54
A Classe e as Variveis de Instncia......................................................... 55
A Classe e as Variveis de Classe ............................................................ 57
A Classe e as Variveis Globais ............................................................... 58
A Classe e as Constantes ....................................................................... 59
Sugestes para Nomes de Variveis e Classes........................................... 60
Sintaxe RGSS.......................................................................... 61
Actors ($data_actors).............................................................................62
Actor ($game_actors).............................................................................63
Armor ($data_armors)............................................................................64
Classes ($data_classes)..........................................................................65
Common Events ($data_common_events)................................................ 66
Enemies ($data_enemies).......................................................................67
Item ($data_items)................................................................................68
Skill ($data_skills)................................................................................. 69
States ($data_states).............................................................................70
Wearpon ($data_weapons)..................................................................... 72
Classes Bsicas do RGSS...........................................................73

Introduo............................................................................................ 73
Detalhes da Classe Window..................................................................... 74
Construtor.............................................................................................................. 74
Mtodos.................................................................................................................. 74
Propriedades........................................................................................................... 75
Exemplos................................................................................................................ 77
6

Detalhes da Classe Bitmap...................................................................... 78
Construtor.............................................................................................................. 78
Mtodos.................................................................................................................. 78
Propriedades........................................................................................................... 79
Detalhes da Classe Sprite........................................................................80

Construtor.............................................................................................................. 80
Mtodos.................................................................................................................. 80
Propriedades........................................................................................................... 81
Detalhes da Classe Plane........................................................................ 83

Construtor.............................................................................................................. 83
Mtodos.................................................................................................................. 83
Propriedades........................................................................................................... 83
Um Script Realmente til.......................................................... 85

Introduo............................................................................................ 85
Criando o Esqueleto de uma Janela.......................................................... 85
Adicionando Contedo numa Janela..........................................................87
Controlando a Janela Atravs da Scene_Map............................................. 90
Concluso............................................................................... 92
7
ndice de Ilustraes
Figura 1: Abrindo a tela do editor de scripts...................................................................................... 13
Figura 2: Tela do editor de scripts................................................................................................... 14
Figura 3: Menu pop up da tela principal do editor de scripts................................................................. 16
Figura 4: Menu pop up da listagem de scripts.................................................................................... 17
Figura 5: Esqueleto de uma janela................................................................................................... 86
Figura 6: Janela preenchida com texto e imagem atravs mtodo Refresh............................................. 88
Figura 7: Evento que chama o script................................................................................................ 91
8
Como Utilizar este Tutorial

Para aproveitar da melhor forma possvel este tutorial, devemos saber para que ele serve. Este
documento onde estaremos vendo diversos recursos dos scripts RGSS do RPG Maker XP.
Este tutorial de nvel avanado. S aconselhvel leitura deste tutorial aps se certificar de
que j conhece completamente os recursos do RPG Maker, alm de noes de lgica de
programao, estruturao de dados e orientao a objetos.
Aps a leitura deste documento, podemos passar para o prximo tutorial da srie chamado:
"Criando um Menu com RGSS"
Para complementar o estudo da programao e desenvolvimento de jogos, aconselho a
leitura dos seguintes tutoriais:
a) "Conhecendo os Scripts do RPG Maker XP"
b) "Desenvolvimento de Jogos"
c) "Programao Orientada a Objetos"
9
Comeando
Como todo programador, chega uma hora onde voc vai quere procurar por algo mais. A
curiosidade algo bom (se for bem administrada). Para sanar esta busca por conhecimento e
curiosidade, vamos nos aprofundar um pouco mais no mundo do RGSS utilizando a Programao
Orientada a Objeto (POO).
O objetivo deste tutorial no explicar conceitos da orientao a objetos. Caso deseje conhecer
mais sobre este assunto procure pelo tutorial "Programao Orientada a Objetos". Apesar disso,
importante conhecer as siglas e sua noo fundamental. No caso do RGSS ele possui bastante
recursos de POO.
claro que tambm vamos fazer uma "reciclagem" no estudo de RGSS. Nos captulos iniciais
desta obra, vamos revisar resumidamente alguns conceitos bsicos que j foram abordados em
outros tutoriais. A primeira coisa que vamos rever a sintaxe bsica, para posteriormente
vermos como que funciona a lgica de orientao a objetos utilizando o RGSS e por ltimo um
exemplo prtico.
10
Programando com RGSS

Introduo
Inicialmente, vamos rever alguns conceitos bsicos.
Uma linguagem o conjunto de regras para se definir um programa. No caso do RMXP a
linguagem utilizada a RGSS que baseada no RUBY. Portanto, podemos dizer que, de certa
forma, os "comandos" do RUBY funcionam em RGSS (o inverso pode no acontecer).
Comandos: so ordens inerentes ao programa, servem para aplicar ordens comuns ou de
funcionalidade da linguagem. Um exemplo de comando seria o "Print".
Valores so tudo aquilo que atribudo a alguma coisa. Em programao, no existem comandos
e variveis sem valores (as vezes os valores so parmetros internos da linguagem). No
comando Print "Ol Mundo"; o "Ol Mundo" um valor.
Sintaxe a forma semntica de dar valores e/ou executar um comando, ou seja, como se
escreve os comandos aplicando valores da forma que ela exige. Ocorrer um erro sempre que a
maneira correta de se escrever esteja errada ou os valores sejam aplicados de forma errada.
Essa semntica quem coordena a linguagem.
Exemplo de comando: rand(1,5);
Para o comando rand funcionar os valores devem estar dentro de parentes, sendo o primeiro
numero a menor ocorrncia separado por virgula da maior ocorrncia, essa a semntica do
comando rand, alguns "parmetros" so obrigatrios e outros no.
Script ou Programa um conjunto de sintaxes que executam uma ou mais tarefas.
Rotina uma seqncia de scripts que geram resultados para outros scripts.
11

O Ruby
O Ruby uma linguagem de programao orientada objeto. No ocidente, poucos ouviram falar
do Ruby, mas no Japo se espalhou como fogo j que alcana a linguagem Python em
popularidade. Que faz o Ruby assim popular? O Ruby possui as melhores caractersticas das
melhores lnguas de programao em um nico lugar.
O RGSS
RGSS significa "Ruby Game Scripting System" que em portugus quer dizer "sistema Ruby de
scripting de jogo".
A diferena entre o Ruby e o RGSS que RGSS deve ser visto como uma linguagem de "Script"
com alguns recursos da linguagem, enquanto que o Ruby uma linguagem de programao
completa. Com o Ruby, se voc quiser mostrar uma figura na tela, voc no pode apenas usar a
mesma sintaxe que voc se usou no RGSS do RPG Maker XP. Voc teria que codificar toda essa
funo.
Exemplo de cdigo em RGSS para mostrar um retrato:
image = Sprite.new
image.bitmap = RPG::Cache.picture(nome da imagem)
S so necessrias 2 linhas para mostrar uma figura na tela. Isso ocorre pois no RMXP usamos
uma classe interna j programado pelo RPG MAKER XP de "Sprite" (nao disponvel no editor do
Script). Alm disso usamos o mdulo "RPG" (tambm no encontrado no editor do script). Estas
classes e cdigos j esto incorporadas nativamente no maker. Por ter vrias classes j prontas,
criar um script no RPG Maker XP fica fcil.
Isto significa que RGSS menos complicado do que o ruby, porque a operao de baixo nvel
escondida pelo RPG MAKER XP (operao de baixo nvel significa codificar uma rotina para ler um
arquivo, iniciar um arquivo, mostrar o arquivo na tela, etc...). No temos que criar classes que
controlas as figuras. Basta usarmos a que j existe.
12

O Editor de Scripts
Para comearmos a criar scripts em nosso projeto, devemos conhecer o editor de scripts do RPG
Maker. Alm disso, bastante recomendvel um conhecimento bsico de lgica de programao,
orientao a objetos e desenvolvimento de jogos (aconselhamos a leitura dos tutoriais
"Desenvolvimento de Jogos" e "Programao Orientada a Objetos").
Agora, vamos fazer uma rpida anlise da tela do editor de scripts do RPG Maker XP e logo
depois vamos conhecer um pouco de lgica.
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 1.
Figura 1: Abrindo a tela do editor de scripts.
13

Na tela que se abrir podemos ver que j existem vrios scripts prontos. Observe a figura 2.
Figura 2: Tela do editor de scripts.
14

Note que na tela do editor de scripts, as expresses e cdigos aparecem em diversas cores. Cada
cor representa um tipo de texto. Isso extremamente til para facilitar o entendimento dos
scripts. As cores so:
Azul: O azul utilizado representar as palavras reservadas do RGSS, ou simplesmente

sintaxe do RGSS, como os comandos def, class, end, when, if, case, dentre outros.
Vermelho: O vermelho representa nmeros literais nas expresses e cdigos, como 1, 2,

3, 5, dentre outros.
Azul Claro: O azul mais claro representa operadores e operandos em seu cdigo. Como
=,||, + , * , dentre outros. Alm disso, representa operadores condicionais, parnteses e
colchetes.
Verde: O verde representa os comentrios. Os comentrios no so interpretados pelo

RPG Maker e so ignorados.
Roxo: O roxo representa uma cadeia de caracteres ou elementos do texto (String) em

seu cdigo.
15

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:
a) Cut (Recortar) : Ctrl+X
b) Copy (Copiar) : Ctrl+C
c) Paste (Colar) : Ctrl+V
d) Undo (Voltar) : Ctrl+Z
e) Find (Procurar) : Ctrl+F
f) Replace (Subistiruir) : Ctrl+H
g) Jump (pular para a linha) : Ctrl+G
h) Zoom IN/OUT (Aumentar/Diminuir) : Ctrl+"boto do meio do mouse"
Estas opes podem ainda ser acessadas atravs de um menu pop up que apresentado quando
clicamos com o boto direito do mouse na tela principal do editor. Observe a figura 3.
Figura 3: Menu pop up da tela principal do editor de scripts.
16

No lado esquerdo da tela existe uma listagem com todos os scripts de nosso projeto. Esta
listagem tambm possui comandos especficos que podem ser acessados por teclas de atalho.
Vejamos a lista de comandos e suas respectivas teclas de atalho:
a) Cut (Recortar) : Ctrl+X
b) Copy (Copiar) : Ctrl+C
c) Paste (Colar) : Ctrl+V
d) Undo (Voltar) : Ctrl+Z
e) Insert (Adicionar) : Ins
f) Delete (Excluir) : Del
g) Searsh All (Busca Completa) : Control+Shift+F
Estas opes podem ainda ser acessadas atravs de um menu pop up que apresentado quando
clicamos com o boto direito do mouse na listagem de scripts do editor. Observe a figura 04.
Figura 4: Menu pop up da listagem de scripts.
Como foi dito anteriormente muitas pessoas conduzem a maior parte do desenvolvimento real do
jogo atravs de scripts, mas estas pessoas no so (na maioria das vezes) programadores
profissionais e no esto familiarizados com tcnicas sofisticadas de programao. Portanto
vamos conhecer um pouco mais sobre lgica de programao antes de continuar.
17

Teste dos Exemplos
Para testar os exemplos faa o seguinte: Crie um novo Script acima do Main, e d o nome
"testes_simples". Deixe de preguia e comece a digitar o cdigo (eu disse DIGITAR, no copie e
cole, pois assim no se aprende nada).
Faa um evento chamado "evento_script" no seu mapa. de preferncia faa evento que seja um
character imvel que quando acionado (apertando o boto [Enter] ou "C") o heri interage com
ele. Nesse evento chame a opo de "executar script", e escreva os comandos necessrios para
nosso teste. Estes comandos sero diferentes para cada exemplo que iremos ver a partir de
agora.
Variveis
Varivel uma representao de um valor, ou seja, se varivel = 15545545515554658, sempre
que manipularmos o "varivel" o mesmo que operar o numero 15545545515554658.
Existem vrios tipos de variveis. As mais comuns e mais usadas so:
a) String - Comporta letras e nmeros;
b) Integer - Comporta nmeros;
c) Boolean - Comporta 0 e 1, true e false, sim e no;
d) Array - Comporta vrias variveis;
e) Constante - Comporta tudo, porm seu valor fixo.
No Ruby, as variveis possuem escopo. Este escopo muda de acordo com o prefixo utilizado.
Vejamos alguns exemplos:
a) minha_var = varivel local;
b) @minha_var = varivel pblica (de instncia);
c) $minha_var = varivel global;
d) MINHA_VAR = Constante.
18

Variveis locais servem para resolver problemas rpidos, como nomes ou nmeros que s sero
alterados ali mesmo.
Variveis pblicas servem para toda a classe que a declarou, podendo ser alterada em qualquer
procedimento da classe.
Variveis globais so geralmente declaradas no incio da execuo do programa, servindo como
base para classes e outras vars.
Constantes s so declaradas no caso de valores imutveis, ou seja, que no necessitam ser
mudados.
Operadores
Os operadores servem tanto para atribuir como para comparar valores em nossos cdigos.
Observe a lista completa dos operadores do RGSS logo abaixo.
Operadores de atribuio de valores

= atribui um valor a uma varivel
+= atribui a soma dos dois valores
-= atribui a subtrao dos dois valores
/= atribui a diviso dos dois valores
*= atribui a multiplicao dos dois valores
%= atribui a resto de uma diviso dos dois valores
++ soma 1 no valor;
-- subtrai 1 no valor;
19

Operadores de comparao de valores
== compara se ambos valores so iguais.
=== compara se ambos valores so realmente iguais (lembra do 0 como false).
!= compara se ambos valores so diferentes.
!== compara se ambos valores so realmente diferentes (lembra do 0 como false).
<= compara se o primeiro valor menor
>= compara se o primeiro valor maior
Operadores de validao de comando

! -> no existe.
&& -> e (ambos)
|| -> ou (um ou outro)
Expresses Literais
O valor literal das variveis pode (e deve) ser dividido em tipos. Os tipo mais comuns e usados
so: Primitivos, Compostos e Especiais.
Os tipo primitivos de variveis so: Boolean (true/false), Integer (inteiros i.e. 1234567890), Float
(no inteiros i.e. 1.5 0.3333...), String (em geral so textos que podem conter letras, nmeros
ou caracteres especiais).
Os tipo compostos so: Array (vetores), Objeto (instancias de classes).
Um dos tipos especiais o NULL.
No h mistrios nos tipos de valores primitivos, como Integer e Float, talvez tenha nos Boolean
e nas String, ento vamos revisar este dois ltimos.
20

Um boleano um valor comparativo de verdadeiro (True) ou falso (False). Um comando que
exija um valor Boolean ou uma varivel booleana, s vai aceitar essas 2 entradas. Internamente,
esta varivel tratada como 1 (True) e 0 (False), mas o resultado final no do tipo Integer. Um
valor False no um valor NULL (nulo), embora muitas vezes alguns comandos retornem Null
como False (0).
J a String um valor essencialmente alfanumrico. Uma String aceita qualquer valor em
formato texto contendo qualquer caractere. Existem dois tipos de Strings e a diferena delas est
na forma que ela declarada. Dependendo da declarao sabemos se a String puramente texto
ou uma expresso. Um texto puro identificado pelas aspas simples ('). Isso quer dizer que o
texto dentro de aspas simples so textos mesmo que seja um texto s com nmeros. Uma
expresso representada pelas aspas duplas (") e podem ser simples textos ou variveis, mas o
valor final ser sempre uma texto.
Em strings com aspas dupla e em expresses regulares, o termo "#{expresso}" usado num
contexto de substituio. Em expresses com variveis comeando com $ ou com @ a expresso
substituda pelo valor da varivel.
Se quiser evitar que o Ruby tente efetuar uma substituio, adicione uma barra invertida na
frente da expresso.
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 no interpretam os comandos extras.

nome = 'meu nome #{$variavel}'
# nome = "meu nome #{$variavel}"
Se uma sintaxe determina que o valor a ser inserido deve ser um integer e voc colocar um
literal do tipo string, a operao vai dar erro ou retornar um valor inesperado (possvelmente um
boolean, Nil ou um NULL). Por isso importante conhecer os tipos, e quando usar.
21

Observe estes exemplos:
var = 10 # tipo integer
nova = var
nova = &var
Neste caso, a varivel "nova" ter o mesmo valor que "var" que 10. Note que "nova" ser uma
varivel e "var" ser outra varivel. Tudo que eu fizer em uma no far efeito nenhum na outra.
Essa atribuio pode ser ruim, ou gerar Duplicatas que s aumentam o cdigo ou geram lags no
programa j que "nova" nada mais que um clone de "var". Para resolver isso, podemos usar o
smbolo & (comumente chamado de "i comercial"). Na terceira linha a varivel "nova" no ser
uma duplicada de "var", e sim "nova" ser um 2 nome para "var". A varivel "nova" ser apenas
um ponteiro para a mesma posio de memria da varivel "var". Se eu alterar o valor de "var"
em qualquer parte do script o valor de "nova" ser alterado tambm, e vice-versa. Em POO, a
varivel "nova" pode ser considerada um objeto de "var".
22

Arrays
Objeto que retorna um vetor contendo o resultado de cada expresso. Array uma instncia 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 segundo e o terceiro valor deste
array, podemos usar a seguinte expresso:
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 expresso:
ary[2, 1] = 99
vetor = ary # vetor = [0, "a", 99, "c", 3]
Para inserirmos o valor "xyz" depois do zero e antes do "a" sem remover nenhum valor, podemos
usar a seguinte expresso:
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]
print a
# => [1, 2]
(sem mudanas)
print b
# => [8, 9]
(sem mudanas aqui tambm)
23

Matrizes
So as famosas Matrizes, mas chamam-se de Hashes pelo Ruby. Um Hash um valor composto
onde atribudo um ndice a um valor;
Exemplo:
usuarios = {'nome'=>'Raven'}
usuarios['nome'] = 'Raven'
# forma estendida
# forma simplificada
Os dois exemplos so exatamente iguais, mas recomendvel que use a forma simplificada. A
varivel "usuario" se tornou um array assim que atribumos um ndice ('nome') e para esse ndice
atribumos um valor ('Raven').
# a Sada de "usuario" ser
Array(
'nome' => 'Raven'
)
Vamos agora acrescentar outros ndices para a mesmo array.

usuarios['telefone'] = '555-55-55'
usuarios['estado'] = 'SP'
usuarios += {'telefone'=>'555-55-55', 'estado' => 'SP'}
A sada de usuario agora ficar:

Array(
'nome' => 'Raven';
'telefone' => '555-55-55';
'estado' => 'SP';
)
Observe que usamos o operador '=>'. Esse um indicador de ndice diferente de um operador de
comparao maior igual (>=). Este comando diz que a String antes dele ndice do valor aps
ele. O valor pode ser de qualquer tipo, mas o ndice s pode ser String ou Integer. Isso muito
til, para associar todas as referencias de um nico propsito numa s varivel. Os objetos so
muito parecido com Arrays, diferindo apenas por possurem mtodos e seu indicador de ndice
o '->' ao invs de '=>'. Um objeto um conjunto de funes que o constitui e nele o ndice pode
ser uma varivel ou mesmo uma funo, mas esta uma outra histria que veremos mais tarde.
24

Estruturas de Controle
Outro ponto fundamental para compreendermos RGSS o entendimento das estruturas de
controle. Elas so os "caminhos" que nosso cdigo percorre para efetuar uma determinada
tarefa. As estruturas de controle, so basicamente os If Else, For, While e Case. Como este
captulo uma reviso do bsico, vamos ver apenas como funcionam.
Indicaes Condicionais IF
Nessa seo vamos ver como usar as indicaes de condies como o "IF". O conceito bsico
igual a qualquer outra linguagem. Sempre que utilizarmos uma condio em RGSS preciso ficar
atento sintaxe. Uma condio sempre construda com dois operadores conforme podemos
observar logo abaixo:
if minha_varivel == 0
if minha_varivel = 0
# Comando Correto
# Comando Errado
O If compara e se a comparao for verdadeira ele executa o seu contedo (no caso do RGSS at
o prximo "end" aparecer). O IF usa os operadores de comparao de valores e comandos para
isso, ele pode vir ou no acompanhado do Else que a parte que ser executada caso a
comparao no seja verdadeira.
bastante comum um cdigo possuir varias comparaes que nem sempre so iguais. Por este
motivo existem algumas outras formas de fazer comparaes sem o If..Else. Normalmente
quando queremos atribuir um valor a uma varivel se o valor de uma outra for X e um outro
valor for Y, podemos fazer a comparao e a atribuio toda numa nica linha.
Geralmente utilizamos este cdigo:
if( var1 == 2)
var2 = " dois";
else
var2 = " algum valor diferente de 2";
end
25

Mas eventualmente, podemos usarmos o seguinte cdigo:
var2 = (var1==2)? " dois" : " algum valor diferente de 2";
Os dois cdigos funcionam de forma idntica, a traduo do segundo cdigo seria: "se
comparado" (var1 == 2) se sim var2 "igual" (=) " dois" se no var2 "igual" (=) " algum
valor diferente de 2");
Vamos ver um exemplo mais complexo de condio IF. Volte no script "testes_simples" e digite:
class If_Statement_1
@@a_class_variable=10
def initialize
@@a_class_variable+=1
a_local_variable=13
if @@a_class_variable==a_local_variable
print "Isso, somos iguais!"
else
print "Droga, no igual!"
end
end
end
Depois abra o evento "evento_script" e exclua todo o seu contedo para depois digitar as
seguintes linhas no comando de evento "executar script":
If_Statement_1.new
If_Statement_1.new
If_Statement_1.new
If_Statement_1.new
Se voc instanciar 4 vezes essa classe voc ter a mensagem "Isso, somos iguais!" apenas na
terceira janela. Adicionamos 1 nossa varivel de classe (inicialmente com valor 10) a cada vez
que chamamos a classe, e condicionamos a checar se nossa varivel de classe igual a nossa
varivel local (com valor 13). Ento o processo que o RMXP faz o seguinte:
26

Primeira vez
@@a_class_variable=10+1 --> obtemos 11.
a_local_variable=13
Condio "IF" para comparar se as 2 so iguais (no so). A rotina ir executar os

parmetros escritos no "ELSE" que mostra a mensagem de "Droga, no igual!".
Segunda vez
a_local_variable=13
Condio "IF" para comparar se as 2 so iguais (ainda no so). A rotina ir executar os

parmetros escritos no "ELSE" que mostra a mensagem de "Droga, no igual!".
Terceira vez
a_local_variable=13
Condio "IF" para comparar se as 2 so iguais (agora so). A rotina ir executar os

parmetros escritos logo abaixo do IF at encontrar um Else ou um END. No nosso caso a
mensagem "Isso, somos iguais!" ser mostrada.
Quarta vez
a_local_variable=13
Condio "IF" para comparar se as 2 so iguais (no so mais). A rotina ir executar os

parmetros escritos no "ELSE" que mostra a mensagem de "Droga, no igual!", e no
ser igual daqui pra frente.
Existem outras formas de IF. Veja alguns exemplos destas outras formas:
if @@a_class_variable==a_local_variable then print "Isso" else print "Droga" end
if @@a_class_variable==a_local_variable ? print "Isso": print "Droga" end
print "Isso" if @@a_class_variable==a_local_variable
27

As 3 formas imprimem "Isso" se a condio for verdadeira, e s as 2 primeiras tem condio para
"else". Voc pode usar "ELSE IF" para adicionar condies e no h limites para esse uso de
condicionais. Vejamos outro exemplo. Volte no script "testes_simples" e digite:
def initialize
a_local_variable=13
print "Somos Iguais !"
elsif @@a_class_variable==12
print "Somos iguais a 12 !"
elsif @@a_class_variable != a_local_variable
print "No somos iguais !"
end
end
end
If_Statement_2.new
If_Statement_2.new
If_Statement_2.new
If_Statement_2.new
Execute o evento ("evento_script").
Um detalhe importante que "elsif" no um "Else if". usando um "Else IF" voc fora o
programa a tomar somente uma daquelas decises, nunca duas ou mais. No exemplo acima,
usamos "elsif", o que permite a execuo de duas condies. Quando @@a_class_variable for
igual a 12, ns veremos 2 mensagens, que sero: "Somos iguais a 12 !" e "No somos iguais !".
Note que se a condio do IF for verdadeira, a rotina no vai executar nenhuma outra parte do IF
(elsif). Caso deseje executar alguma verificao mesmo quando a condio do IF for verdadeira,
teremos que reescrever nosso comando.
28

Vejamos um exemplo. Volte no script "testes_simples" e digite:
def initialize
a_local_variable=13
print "Somos Iguais !"
end
if @@a_class_variable==12
print "Sou Igual a 12 !"
end
if @@a_class_variable != a_local_variable
print "Somos Diferentes !"
end
end
end
If_Statement_3.new
If_Statement_3.new
If_Statement_3.new
If_Statement_3.new
Perceba que quando @@a_class_variable for igual a 12, duas mensagens iro aparecer "Sou
Igual a 12 !" e seguidamente "Somos Diferentes !". Muitas fezes voc vai precisar de um numero
grande de "else if". Para a maior praticidade existe a condio "case" que veremos a seguir.
29

Condio CASE
Outra forma de se fazer uma estrutura de controle semelhante ao If utilizando o comando
CASE. A condio CASE usada para checar o contedo de uma determinada varivel, e listar
um grupo de aes para cada valor que voc queira. Este comando usado muito em Scenes e
Menus no RMXP. Vejamos um exemplo:
case var
when 0
var = " zero"
when 1
var = " 1"
when 2
var = " 2"
else
var = "qualquer outro valor"
end
A varivel (var) anunciada no Case vai ser comparada a cada 'When' que ele tiver, se ele
encontrar algo que corresponda ao case em When ele ira executar tudo que tiver na linha abaixo
at o prximo when, o comando Else para que o comando execute tais instrues quando o
valor de var no coincida com nenhum When.
Agora, vamos ver um exemplo completo para testarmos. Volte no script "testes_simples" e
digite:
class Case_Statement_1
def initialize
case @@a_class_variable
when 1
print "sou 1"
when 2
print "sou 2"
when 3
print "sou 3"
else
print "Quem eu sou?"
end
end
end
30

Case_Statement_1.new
Neste caso verificamos a varivel @@a_class_variable, quando seu valor for 1 (When 1) ele ir
executar os comandos at o prximo When, se for qualquer outro valor e casar com a condio
"When" ele ira executar apenas ela. Se nenhum When for verdadeiro, executa o Else. Podemos
tambm condensar a escrita do cdigo acima de uma forma mais simples. Volte no script
"testes_simples" e digite:
def initialize
when 1: print "Sou 1"
else print "Quem eu sou ?"
end
end
end
O funcionamento deste cdigo exatamente igual ao anterior.
31

Alm disso ainda podemos considerar uma "rea" para o case. Uma rea definida por um
numero inicial e um numero final e tudo o que tivermos entre eles. aqui vai um exemplo de
"rea" ou "Range".
Volte no script "testes_simples" e digite:
def initialize
print @@a_class_variable
when 1..3: print "eu sou entre de 1 e 3"
end
end
end
Teste e depois acrescente mais alguns Case_Statement_3.new e faa o teste para verificar seus
efeitos.
32

Podemos tambm usar uma lista especifica de eventos no case. Veja o exemplo abaixo:
def initialize
print @@a_class_variable
when 1,3: print "Posso ser 1 ou 3"
end
end
end
Neste exemplo, o programa checa se o valor encontrado dentro de @@a_class_variable um dos
listados em "when". Portanto, a virgula o mesmo que dizer "OU".
33

Lembre que voc pode usar tanto nmeros (Integers), como textos (Strings), dessa forma:
@@a_class_variable="a"
def initialize
@@a_class_variable.next!
when "b": print "Sou B"
when "c": print "Sou C"
when "d": print "Sou D"
end
end
end
Neste exemplo, ns usamos o comando ".next", ele usado para incrementar nossa string,
fazendo ela seguir para o prximo caractere lgico, dependendo do caractere encontrado a
extrema direita da string.
Exemplo:
a_string="ab" a_string.next! --> a_string agora "ac"
Outro exemplo:
another_string="name102" another_string.next! --> another_string agora "name103"
34

Comando de repetio (loop) FOR
O comando for, serve para replicar comandos a partir de um numero de ocorrncias.
for i in 1..10
##comandos
end
O que ele vai fazer atribuir varivel "i" um valor crescente de um em um partindo do 1 e
terminando em 10, e a cada vez que ele adicionar um ele executar novamente os comandos
dentro do FOR.
IMPORTANTE:
O FOR mantm os resultados anteriores, mesmo que voc quebre a repetio no meio, os valores
de variveis e ponteiros atribudos dentro do FOR, permanecem o mesmo. Ateno tambm aos
pontos entre os nmeros (..). Os pontos (..) quando vem em dupla significam que a seqncia
ser efetuada de 1 a 10, ou seja, a repetio inclui o 1 e o 10. Caso deseje, possvel usar 3
pontos (...) que significa significa que a repetio ser apenas a seqncia ENTRE eles, ou seja,
a repetio da seqncia ser feita usando o intervalo de 2 a 9.
Agora, vamos ver um exemplo completo para testarmos. Volte no script "testes_simples" e
digite:
class For_Loop_Sample
def initialize
a_local_variable=0
for i in 1..10
a_local_variable+=1
print a_local_variable
end
end
end
35

For_Loop_Sample.new
Note que no testes, a rotina ir adicionar 1 "a_local_variable" e imprimir o seu contedo 10
vezes de 1 a 10, incluindo o 1 e o 10. Lembra das regras de rea? As mesmas regras so
aplicadas aqui, ento se voc escrever "0...10" no lugar de "1..10", voc ter exatamente o
mesmo resultado, s que de 2 a 9.
A varivel "i" pode ser usada para criar condies para nosso For..Loop, ou podemos usa-la como
referencia ou ndice (index) de um vertor. vejamos um exemplo. Volte no script "testes_simples"
e digite:
class For_Loop_Sample2
def initialize
for i in 1..4
print $game_actors[i].name
end
end
end
For_Loop_Sample2.new
Para que este exemplo funcione, preciso que voc defina 4 personagens no DataBase (banco de
dados). Depois de se certificar que existe 4 (quatro) personagens no Database (banco de dados)
execute o evento ("evento_script").
36

O que deve acontecer no teste o seguinte:
Primeira Volta
i=1 --> Pedimos para exibir o nome do heri de ID#1 (i uma varivel, $game_actors[i].name
o mesmo que $game_actors[1].name)
Segunda Volta
Terceira Volta
Quarta Volta
Este comando muito usado no RMXP, principalmente em Window_MenuStatus, onde listado
os dados dos heris. Devemos lembrar que voc pode usar a variveis conforme podemos ver no
nosso prximo exemplo.
class For_Loop_Sample3
def initialize
a_loacal_variable=1
another_local_variable=4
for i in a_loacal_variable..another_local_variable
print $game_actors[i].name
end
end
end
37

For_Loop_Sample3.new
Execute o evento ("evento_script"). O resultado ser o mesmo da classe For_Loop_Sample2
Alm de valores numricos o "for" aceita tambm vetores, ou seja Arrays. Dessa forma o for
executara o looping (repetio) para cada ndice do Array.
Comando de repetio (loop) While/Do..While

O comando "While" equivale ao "For" e parecido com o ciclo do RM2k/2k3 e com o comando
"do while" de outras linguagens. O "While" vai executar o conjunto de comandos enquanto a
condio for verdadeira ou encontrar um "Break".
Observao: Assim como o "For", o "While" e o "do" mantm os resultados anteriores.
38
Orientao a Objetos com RGSS

Introduo
Como j foi dito anteriormente, o objetivo deste tutorial no explicar os conceitos de POO. Caso
deseje conhecer mais sobre este assunto procure pelo tutorial "Programao Orientada a
Objetos". Vamos apenas ver o que se refere ao RGSS com nfase em POO.
Funes
Sem os mtodos no existe POO. Uma funo/mtodo um conjunto de comandos que juntos
geram um retorno. As funo devem funcionar por si s, sem depender de outras funes. Assim
dita o POO, mas nem sempre isso verdade. Alguns objetos servem exatamente para
automatizar outros objetos, ou seja, servem para "modularizar" o cdigo.
Quando criar uma funo e quando apenas escrever cdigo procedural/seqencial? Sempre que
uma parte da sua programao ficou repetitiva demais, e toda hora voc tem que duplicar os
comandos mudando apenas alguns parmetros hora de usar POO (objetos e funes).
A sintaxe de uma funo a seguinte:
executor_da_funcao Nome_da_funo(parmetros), conjunto de rotinas e finalizao do funo.
No RGSS algo assim:
def Nome_da_Funo(parmetros)
# Conjunto de Rotinas e Comandos
end
39

O "DEF" serve para indicar que ser criado uma funo. O nome pode ser qualquer coisa. Utilize
nomes que indiquem o objetivo da funo. Os parmetros so as variveis e/ou valores que
sero utilizados pela funo.
def funcao_carrinho_de_compras( produto, preo )
produto_com_desconto = preo - 100
print "O produto " + produto + " custava " + preo + ". Com desconto custa " + produto_com_desconto
end
print funcao_carrinho_de_compras('bola', 200)
Execute o evento ("evento_script"). Uma tela deve aparecer (comando print) com o seguinte
retorno: "O produto bola custava 200. Com desconto custa 100"
A funo chama-se funcao_carrinho_de_compras, e os parmetros so "produto" e "preo". A
rotina dar um desconto sobre o preo informado de "-100", e exibir o nome do produto com o
preo novo. Note que para que ele faa a conta corretamente o valor de "preo" deve ser um
Integer.
Podemos fazer uma funo auxiliar para checar se o valor informado na varivel "preo" um
Integer. As boas prticas de programao nos diz que sempre bom colocar um comentrio no
inicio da funo, informado quais os parmetros e seus tipos, alguns parmetros podem ser
opcionais.
40

# Funo funcao_carrinho_de_compras2(produto,preo,[checar=true])
# produto Tipo : string
# preo Tipo : int
# checar Tipo : Boolean [opicional]
def funcao_carrinho_de_compras2(produto,preo,checar=false)
if(checar)
if(Gettype(preo) != integer)
return false;
exit;
end
end
produto_com_desconto = preo - 100;
return "O produto " + produto + " custava " + preo + ". Com desconto custa " + produto_com_desconto
print funcao_carrinho_de_compras2('bola', 200, true)
retorno: "O produto bola custava 200. Com desconto custa 100".
Note no cabealho da funo as linhas de comentrio. L esto todas as informaes relevantes
da funo, incluindo uma descrio de parmetros. Toda vez que um parmetro tive um valor
previamente determinado, ela opcional. Neste exemplo a varivel opcional "checar" que tem
o valor padro definido como True. Quando usarmos esta funo, se atribuirmos um valor ao 3
parmetro que no seja True ele no vai fazer a checagem de tipo. Se no passarmos valor
nenhum, a rotina checar o tipo.
41

Existe uma outra maneira de executar esta funo. Volte no evento "evento_script" e exclua todo
o seu contedo para depois digitar as seguintes linhas no comando de evento "executar script":
produto = Funcao_carrinho_de_compras2('Boneca', 200, false)
print produto
retorno: "O produto Boneca custava 200. Com desconto custa 100"
Observe que existem vrias formas de se usar esta funo. No ltimo teste a funo no ir
checar o tipo do segundo parmetro (que o "preco"), pois o terceiro parmetro (aquele
opcional) est definido como FALSE. Se o terceiro parmetro no for declarado a rotina vai
checar o tipo da varivel "preco".
O resultado est sendo armazenado numa varivel chamada "produto", para ser usada
posteriormente, ou seja, o valor de retorno armazenado na varivel "produto" ser apresentado
na tela pelo comando print.
Uma das vantagens da orientao a objeto a modularizao, ou seja, reutilizao de cdigo.
Essa funo por enquanto est pequena, mas imagine uma funo grande com vrios
parmetros. Ela se tornaria confusa. O que podemos fazer transformar essa funo enorme em
varias funes menores. justamente a que entra a orientao a objetos.
Um objeto nada mais do que uma "Coletnea de Funes". Num objeto as funes so
chamadas de Mtodos e elas so agrupadas por rotinas. Juntas, as funes/mtodos compem
um nico objeto.
No caso do carrinho de compras ele pode ser um objeto. Assim qualquer coisa que quisermos
fazer dentro do carrinho de compras estaria dentro desse objeto (classe). Mas antes de
continuarmos com a criao de uma classe Carrinho_de_compras, vamos exercitar nosso
conhecimento com algo mais simples.
42

Sintaxe Bsica de uma Classe
Agora o momento de construirmos um cdigo bsico, a fim vermos a sintaxe de uma classe. A
funo que criamos anteriormente (Carrinho_de_compras), pode muito bem ser colocada numa
classe, mas antes de fazermos isso, vamos ver exemplos mais simples. Podemos comear por
um comando de simples execuo, vamos imprimir na tela simplesmente a frase "Ola Mundo!"
utilizando classes ao invs de funes.
class Imprimindo_Frase
def initialize
print "Ola Mundo!"
end
end
Imprimindo_Frase.new
Execute o evento ("evento_script"). Ao testar aparecer uma tela popup dizendo "Ol Mundo!".
Agora vamos explicar o que fizemos:
1
class Imprimindo_Frase
def initialize
print "Ola Mundo!"
4
5
end
end
Linha 1: Ns definimos uma nova classe chamada Imprimindo_Frase

Linha 2: Criamos o mtodo construtor chamado initialize
Linha 3: Adicionamos o comando print para ser executado pelo mtodo initialize
Linha 4: Encerramos o mtodo "initialize" com a palavra "END".
Linha 5: Encerramos a classe "Imprimindo_Frase" com a palavra "END".
43

O mtodo "initialize" o mtodo padro executado toda a vez que a classe instanciada
(chamada)
pelo
comando
".new".
Ento,
quando
voc
diz
ao
script
comando
Imprimindo_Frase.new, voc diz ao RPG Maker XP criar uma nova instancia desta classe (um
novo objeto). Com a mensagem ".new" voc diz para a classe executar todo o mtodo construtor
da classe chamado "initialize".
Tudo que definimos fechado com a palavra END. Isto aplica-se aos muitos comandos no Ruby.
Por isso sempre indente seu cdigo.
Outra forma de chamarmos nossa classe assim:
meu_objeto = Imprimindo_Frase.new
Isto retorna o mesmo resultado, mas aqui ns criamos uma varivel chamada "meu_objeto" que
equivale classe "Imprimindo_Frase". Este recurso til quando queremos chamar diversos
mtodos da mesma classe em vrias ocasies diferente. Por enquanto este no o nosso caso.
Agora, volte no script "testes_simples" e digite:
class Imprimindo_Frase2
attr_accessor : cumprimento
attr_accessor : nome
def initialize(cumprimento, nome)
@cumprimento=cumprimento
@nome=nome
end
def say
print @cumprimento + " " + @nome
end
end
44

message1 = Imprimindo_Frase2.new("Ol", "StrayED")
message2 = Imprimindo_Frase2.new("Ol", "Raven")
print message1.name
print message2.name
message1.say
message2.say
Execute o evento ("evento_script"). Note que ao testar, a primeira janela indicar o nome dado
ao objeto "message1", a segunda janela far o mesmo para "message2". Ento, as outras duas
janelas pop-up vo "imprimir" a frase completa. O que fizemos foi criar 2 objetos, "message1" e
"message2" da classe Imprimindo_Frase2. Um objeto no interfere com o outro, mesmo sendo
instancias da mesma classe (Imprimindo_Frase2).
Vamos analisar o funcionamento deste evento. Os comandos que adicionamos foram os
seguintes:
1
message1 = Imprimindo_Frase2.new("Ol", "StrayED")
message2 = Imprimindo_Frase2.new("Ol", "Raven")
print message1.name
print message2.name
message1.say
message2.say
Na linha 1 criamos aqui um novo objeto chamado "message1" que uma instancia de
"Imprimindo_Frase2". Feito isso voc pode executar tudo que estiver dentro da classe
"Imprimindo_Frase2". Uma vez que adicionamos parmetros no "initialize", somos obrigados a
enviar estes argumentos no momento que que criamos a classe ou ocorrer um erro.
Na linha 2 fizemos o mesmo da linha 1 com "message2".
45

Na linha 3 usamos o comando "print" para exibir os nomes guardados dentro de nosso objeto
"message1". Podemos acessar os argumentos do objeto (propriedades da classe) usando o nome
do atributo que definimos com ATTR logo no inicio da classe.
Na linha 5 enviamos uma mensagem ("say") ao nosso objeto "message1". Estamos dizendo para
"message1" para executar o mtodo "say". Ento "message1" ir retornar em nosso objeto as
aes definidas no mtodo e exibir na tela o resultado do comando "print".
Est na hora de voltar para o nosso "Carrinho de Compras".
46

Criando a Classe Carrinho de Compras
Agora, podemos finalmente voltar ao nosso exemplo de carrinho de compras que estvamos
trabalhando anteriormente.
# Inicio da classe Carrinho_de_compras
class Carrinho_de_compras
def checar_preco(preco)
if(Gettype(preco) != integer)
return false
else
return true
end
end
def desconto(preo, desconto)
produto_com_desconto = preco - desconto;
return produto_com_desconto
end
def meu_carrinho(produto,preco)
print produto + " custa " + preco
end
end
# Fim da classe Carrinho_de_compras
seguintes linhas no comando de evento "executar script" (sem os comentrios):
meu_objeto = Carrinho_de_compras.new
# forma de declarao de objeto do RGSS
meu_objeto->Meu_carrinho('bola',200)
# estou acessando um mtodo do objeto criado
meu_objeto->desconto(200,100)
# estou acessando um mtodo do objeto criado
Execute o evento ("evento_script"). Observe que aparecer uma janela com o retorno "bola custa
200" e logo depois aparecer outra janela com o retorno "100".
47

Ainda existe o mtodo checar_preco que por enquanto no foi utilizado. Uma forma de se chamar
este mtodo a seguinte:
Carrinho_de_compras::checar_preco(200)
Claro que este objeto no tem muita utilidade, mas serve como exemplo. Note como as diversas
aes de nossa classe foram divididas em etapas (em mtodos). Cada mtodo faz uma coisa sem
necessariamente precisar da outra. O mtodo "checar_preco" verifica se o valor de seu
parmetro um Integer. J o mtodo "desconto", pega o primeiro parmetro e subtrai o
segundo, retornando o resultado da operao. Para finalizar, o mtodo "meu_carrinho" apenas
exibe na tela a seguinte string: "1 parmetro custa 2 parmetro".
Mesmo que esta classe esteja bem simples, ela serve para treinarmos a declarao e construo
da classe e dos mtodos. Antes de avanarmos, vamos analisar cuidadosamente cada uma das
linhas do exemplo:
1
meu_objeto = Carrinho_de_compras.new
meu_objeto->Meu_carrinho('bola',200)
meu_objeto->desconto(200,100)
Carrinho_de_compras::checar_preco(200)
A 1 linha declara um novo objeto na varivel "meu_objeto". Agora, esta varivel possui todas os
atributos e todos os mtodos (funes) da classe. Este acesso pode ser feito atravs do '->' ou
diretamente pelo '::'. As duas formas funcionam de forma semelhante, mas a 2 s vai funcionar
se o mtodo declarado, no depender de nenhum outro. No exemplo acima, nenhuma
funo/mtodo depende da outra, por isso tanto faz acessar os mtodos via '->' ou '::'. A sintaxe
dos quatro pontos (::) serve para que possamos executar um mtodo de uma classe sem
precisar instanci-la (o que economiza, espao e processamento). A sintaxe simples
NOMEDACLASSE::MTODODACLASSE, assim podemos acessar qualquer mtodo independente
que a classe possui.
A 2 linha, executa o mtodo que d um desconto no preo do produto (resultado da subtrao
dos parmetros).
48

A 3 linha imprimir direto na sada padro a String "bola custa 200".
A 4 linha retorna apenas se o preo Integer ou no.
Ainda podemos melhorar esta classe para funcionar de acordo com alguns conceitos do POO.
Vejamos
um
exemplo.
Volte
no
script
"testes_simples",
exclua
as
linhas
da
classe
Carrinho_de_compras. Esta classe deve ser excluda pois vamos reescrev-la de uma forma
melhorada. Depois de excluir as linhas da classe Carrinho_de_compras comece a digitar
novamente as seguintes linhas:
@produto = []
def inicialize(produto,preco)
@produto[nome] = produto
@produto[preco] = preco
@produto[desconto] = 0
@produto[preco_desc] = preco
end
# por enquanto o desconto zero.
def checar_preco(preco)
if(Gettype(preco) != integer)
return false
else
return true
end
end
def desconto(desconto=0)
if(@checar_preco()== true)
@produto[desconto] = desconto
end
def meu_carrinho(produto)
@produto[preco_desc] = @produto[preco] - @produto[desconto]
print "O " + @produto[produto] + " custa " + @produto[preco] + " e com desconto sai por " + @produto[preco_desc]
end
end
Note que agora temos um mtodo conhecido como "construtor". No caso do Ruby, todo
construtor deve se chamar "inicialize".
49

O mtodo inicialize ser executado assim que o objeto for criado (instanciado na memria). A
varivel "produto" encontra-se fora dos mtodos e dentro da classe. Ela uma varivel que pode
ser acessada em todos os mtodos.
Se os mtodos usarem o parmetro self, no possvel chamar os mtodos diretamente via "::".
Note que apesar da classe ficar maior, a declarao ficou menor e sem parmetros repetidos.
Agora abra o evento "evento_script" e exclua todo o seu contedo para depois digitar as
meu_objeto = Carrinho_de_compras('Bola',200).new
meu_objeto->desconto(50)
meu_objeto->meu_carrinho('Bola')
Na linha 1, declaramos o objeto com 2 parmetros. Estes parmetros so obrigatrios pois agora
temos um construtor (mtodo chamado inicialize). Este mtodo vai "cadastrar" em um array
associativo, o produto, o seu valor, o desconto (inicialmente zero) e o preo com desconto
(inicialmente igual ao preo sem desconto).
Na segunda linha, temos o mtodo desconto o qual vai "cadastrar" um valor de desconto em
nosso vetor (array).
Na terceira, indicamos o que queremos no carrinho (a bola). Como esse mtodo esta programado
para imprimir ele vai "printar" na tela: "Bola custa 200 e com desconto sai por 150"
Claro que esse no o melhor carrinho de compras que j existiu, pois ele nem adiciona novos
itens, mas serve para iniciarmos nosso aprendizado na criao e uso de uma classe.
50

Vamos ver agora como criar uma classe carrinho de compras realmente til. O que seria
necessrio numa classe de carrinho de compras? Ela deve ter um mtodo para adicionar
produtos, remover produtos, limpar todo o carrinho de compras e listar tudo que tem dentro do
carrinho de compras. Alm destes mtodos, ainda podemos criar outros para suporte ou auxlio.
Volte no script "testes_simples", exclua as linhas da classe Carrinho_de_compras. Esta classe
deve ser excluda pois vamos reescrev-la de uma forma melhorada. Depois de excluir as linhas
da classe Carrinho_de_compras comece a digitar novamente as seguintes linhas:

@nome= []
@preco= []
@desconto= []
@total_produto=0
def inicialize()
@total_produto = 0
@nome.clear
@preco.clear
@desconto.clear
end
def adicionar_produto(nome,preco,desconto=0)
if @nome.include?(nome) then
print "O produto " + nome + " j existe no carrinho de compras."
else
@total_produto = @total_produto + 1
@nome.push nome
@preco.push preco
@desconto.push desconto
print "O produto " + nome + " foi adicionado ao carrinho de compras."
end
end
# Continua na prxima folha...
51

def remover_produto(nome)
posicao=0
if @nome.include?(nome) then
posicao = @nome.index(nome)
@nome.delete_at(posicao)
@preco .delete_at(posicao)
@desconto .delete_at(posicao)
@total_produto = @total_produto - 1
print "O produto " + nome + " foi removido do carrinho de compras."
else
print "O produto " + nome + " no existe no carrinho de compras."
end
end
def remover_tudo()
@total_produto = 0
@nome.clear
@preco.clear
@desconto.clear
print "O carrinho de compras foi zerado."
end
def listar_tudo(produto)
nLoop = 0
if @total_produto<=0 then
print "O carrinho de compras est vazio."
else
for nLoop in 0..@total_produto
print @nome[nLoop] + " custa " + @preco[nLoop] + ". Com desconto sai por " + (@preco[nLoop] - @desconto[nLoop])
end
end
end
end
52

meu_objeto = Carrinho_de_compras().new
meu_objeto.adicionar_produto('Bola',100)
meu_objeto.adicionar_produto('Lpis',50,4)
meu_objeto.adicionar_produto('Bola',90)
meu_objeto.adicionar_produto('Camisa',10,1)
meu_objeto.remover_produto('Papel')
meu_objeto.remover_produto('Lapis')
meu_objeto.listar_tudo()
meu_objeto.remover_tudo()
meu_objeto.listar_tudo()
Ao executar o evento iremos ter os seguintes retornos:
"O produto Bola foi adicionado ao carrinho de compras." (comando da linha 2 do evento).
"O produto Lpis foi adicionado ao carrinho de compras." (comando da linha 3 do evento).
"O produto Bola j existe no carrinho de compras." (comando da linha 4 do evento).
"O produto Camisa foi adicionado ao carrinho de compras." (comando da linha 5 do evento).
"O produto Papel no existe no carrinho de compras." (comando da linha 6 do evento).
"O produto Lpis foi removido do carrinho de compras." (comando da linha 7 do evento).
"Bola custa 200. Com desconto sai por 200" (comando da linha 8 do evento).
"Camisa custa 10. Com desconto sai por 9" (comando da linha 8 do evento).
"O carrinho de compras foi zerado." (comando da linha 9 do evento).
"O carrinho de compras est vazio." (comando da linha 10 do evento).
claro que ainda podemos fazer mais... Podemos incluir um controle da quantidade de produtos,
ou seja, algumas pessoas podem querer comprar 10 lpis ou 5 bolas, mas isso deixaremos para
depois. Por enquanto nossa classe est bem simples, mas ela nos permitiu entender um pouco de
RGSS. Todo este conhecimento ser usado nos jogos criados no RPG Maker XP, mas antes de
criarmos classes para nosso jogo ainda temos que entender as variveis locais, variveis de
instncia e variveis globais e os seus respectivos escopos nas classes. Isso muito importante
quando precisamos manipular diversas classes com diversas variveis ao mesmo tempo.
53

A Classe e as Variveis Locais
Vamos entender um pouco sobre o "escopo" das variveis locais. Uma varivel local sempre
iniciada com uma letra minscula, usualmente a varivel toda escrita em minscula. Uma
varivel local s existir dentro do mtodo em que foi criada. No exemplo seguinte vamos criar 2
(duas) variveis locais que s existem em seus mtodos, e uma no interfere na outra.
class Local_Variable
def method_1
local_variable=2
print local_variable
end
def method_2
local_variable=4
print local_variable
end
end
$teste = Local_Variable.new
$teste.method_1()
$teste.method_2()
Teste o jogo, e v "conversar" com o seu evento, aparecer uma mensagem numa janela popup,
com o resultado do objeto.
Note que, os 2 (dois) mtodos executam operaes com variveis de mesmo nome
(local_variable). O primeiro mtodo retornar o valor 2, que foi o valor que atribumos no
method_1, e assim que voc fechar a janela aparecer o retorno do segundo mtodo que ser o
valor 4, pois no method_2 atribumos 4 varivel.
54

A Classe e as Variveis de Instncia
Uma varivel de instancia sempre iniciada com o caractere @ e deve ser criada dentro de um
mtodo. Uma varivel desse tipo, pode ser utilizada em qualquer mtodo que pertena mesma
classe. No prximo exemplo a varivel de instancia criada no mtodo_1 tem valor 2, e nos a
mudamos o valor para 4 no mtodo_2. Uma varivel de Instancia uma varivel global para a
sua prpria classe.
Agora vamos ao exemplo. Volte no script "testes_simples" e digite:
class Instance_Variable
@instance_variable = 0
def method_1
@instance_variable=2
end
def method_2
@instance_variable=4
end
def method_3
@instance_variable += 1
end
end
$teste = Instance_Variable.new
$teste.method_1()
print $teste.instance_variable
$teste.method_2()
$teste.method_3()
55

O primeiro retorno ser o valor 2 que atribumos no method_1, e assim que voc fechar a janela
aparecer o segundo valor que 4, pois no method_2 atribumos 4 varivel. No method_3
acrescentados +1 ao valor da varivel, assim o terceiro retorno em tela ser o valor 5. Note que
o retorno dos dois primeiros prints semelhante ao exemplo anterior.
Qual a diferena do primeiro exemplo para o segundo?
Se voc tentar criar um "method_3" no primeiro exemplo, vai ocorrer um erro. Isso ocorre
porque no primeiro exemplo a varivel possui um escopo local (s existe dentro do mtodo), por
isso no possvel acess-la em outros mtodos. Com uma varivel de instancia, voc pode
alterar o valor dela e utiliz-la em qualquer um dos mtodos da classe sem precisar declar-la
novamente.
Vamos fazer um outro teste. Abra o evento "evento_script" e exclua todo o seu contedo para
depois digitar as seguintes linhas no comando de evento "executar script":
$teste.method_1()
$teste.method_3()
$teste.method_2()
Observe o funcionamento da soma. Mais tarde tente declarar apenas o method_3 no
"evento_script". Abra o evento "evento_script" e exclua todo o seu contedo para depois digitar
as seguintes linhas no comando de evento "executar script":
$teste.method_3()
Observe a mensagem gerada. Para alguns casos devemos usar as variveis de classe que o
prximo tpico de nosso estudo.
56

A Classe e as Variveis de Classe
Uma varivel de Classe sempre se inicia com dois smbolos de @ (@@) e pode ser criada em
qualquer local da classe. O mais recomendado que elas sejam criadas antes dos mtodos (def)
e depois do nome da classe. A Varivel de classe compartilhada por todo o objeto, portanto
todos os mtodos e classes que a compe podem utiliz-la. O interessante que esta varivel
no "zerada" no momento da instanciao de um novo objeto. No exemplo seguinte criamos
uma classe que conta o numero de objetos criados a partir dele.
class Class_Variable
@@class_variable=0
def initialize
@@class_variable += 1
end
end
Depois abra o evento chamado "evento_script" e exclua todo o seu contedo para depois digitar
$teste = Class_Variable.new
print $teste.class_variable
Neste exemplo, quando voc acionar o evento ele vai imprimir 1, e cada vez que voc acionar o
evento continuar imprimindo 1. Agora, vamos fazer outro teste. Abra o evento chamado
"evento_script" e exclua todo o seu contedo para depois digitar as seguintes linhas no comando
de evento "executar script":
Neste exemplo, quando voc acionar o evento ele vai imprimir 1 e logo depois vai imprimir 2.
57

A Classe e as Variveis Globais
Uma varivel global existe em qualquer parte do programa, uma vez criada, ela pode ser usada
em qualquer parte de qualquer classe, mtodo ou funo existente no programa, No seguinte
exemplo, vamos criar uma varivel global e uma classe. Logo depois vamos adicionar mais 1
atravs desta classe.
$global_variable=0
class Global_Variable
def initialize
$global_variable+=1
end
end
Depois abra o evento chamado "evento_script" e exclua todo o seu contedo para depois digitar
$teste = Global_Variable.new
print $teste.global_variable
Neste exemplo, cada vez que voc acionar seu evento o valor vai aumentar o numero em mais 1.
Isso quer dizer que a varivel se mantm acessvel em qualquer lugar de seu projeto, mas ainda
sim ela deve ser declarada em algum momento para existir.
58

A Classe e as Constantes
Uma constante como se fosse um continer, que contm certo valor, e cujo valor no pode ser
alterado. Por conveno, uma constante sempre escrita com letras maisculas. Em Ruby
possvel modificar os valores das constantes, mas no aconselhvel fazer isso. Toda Constante
uma global, e deve ser declarada preferencialmente antes do inicio da classe. No exemplo
seguinte, vamos criar 3 classes para mostrar como as constantes so usadas.
UMA_CONSTANTE=100
class Constant_Test_1
OUTRA_CONSTANTE=50
def initialize
print OUTRA_CONSTANTE
print UMA_CONSTANTE
end
end
def initialize
print Constant_Test_1::OUTRA_CONSTANTE
print UMA_CONSTANTE
end
end
UMA_CONSTANTE+=1
def initialize
print UMA_CONSTANTE
end
end
Primeiro ns criamos uma constante global chamada "UMA_CONSTANTE" onde o valor "100"
armazenado.
Na
primeira
classe
(Constant_Test_1)
criamos
uma
outra
constante
chamada
"OUTRA_CONSTANTE" e atribumos o valor "50".
59

Na segunda classe acessamos a varivel "OUTRA_CONSTANTE" da primeira classe atravs dos 4
pontos (::). Na terceira classe e na ltima, nos adicionamos +1 a UMA_CONSTANTE.
Para testar abra o evento chamado "evento_script" e exclua todo o seu contedo para depois
digitar as seguintes linhas no comando de evento "executar script":
Constant_Test_1.new
Constant_Test_2.new
Constant_Test_3.new
Constant_Test_1.new
Ao executar o evento, ir aparecer na tela uma janela popup retornando o valor 50
(OUTRA_CONSTANTE) e logo depois aparecer outra retornando o valor 100 (UMA_CONSTANTE).
Estas duas janelas popup so Constant_Test_1, mas em nosso evento a classe Constant_Test_2
chamada logo depois de Constant_Test_1, ento aparecer mais uma janela popup retornando
o valor 50 (OUTRA_CONSTANTE) e logo depois aparecer outra retornando o valor 100
(UMA_CONSTANTE). Depois, Constant_Test_3 chamada e uma janela popup aparecer com o
valor 101. Em suma uma Constante funciona exatamente como uma varivel global.
Sugestes para Nomes de Variveis e Classes

Variveis
Constantes e
Locais
Globais
de Instancia
de Classe
Nome de Classes
name
$debug
@name
@@total
PI
fishAndChips
$CUSTOMER
@point_1
@@symtab
FeetPerMile
x_axis
$_
@X
@@N
String
thx1138
$plan9
@_
@@x_pos
MyClass
_26
$Global
@plan9
@@SINGLE
Jazz_Song
60
Sintaxe RGSS
Agora que j vimos o bsico do RGSS vamos dar uma olhadinha em alguns recursos que foram
criados especificamente para o RPG Maker, ou seja, j existem nos Scripts RGSS.
Os recursos que iremos ver so as seguintes variveis globais: $data_actors, $game_actors,
$data_armors,
$data_classes,
$data_common_events,
$data_enemies,
$data_items,
$data_skills, $data_states e $data_weapons.

Cada uma destas variveis globais na verdade um vetor (array). Existem outras variveis
globais, mas algumas so mais usadas que outras no Maker e portanto no veremos todas.
Estas variveis so realmente teis para a criao de um RPG. No momento em que estivermos
criando scripts para nosso jogo, muito importante conhec-las para tirarmos maior proveito de
suas funcionalidades.
61

Actors ($data_actors)
Tipo: Vetor da classe RPG::Actor (Somente Leitura)
Funo: Este vetor possui dados e caractersticas dos diversos heris de seu jogo. Voc pode
utilizar os dados deste vetor de forma individual para cada um dos heris utilizando o ndice.
Exemplo de Cdigo: $data_actors[id].name
Atributos:
id
name
class_id
initial_level
exp_basis
exp_inflation
character_name
character_hue
battler_name
battler_hue
weapon_id
weapon_fix
armor1_id
armor1_fix
armor2_id
armor2_fix
armor3_id
armor3_fix
armor4_id
armor4_fix
parameters[status_id, level]
62

Actor ($game_actors)
Tipo: Objeto Game_Actors
Funo: Este objeto possui informaes sobre os caracteres. Alguns deles so carregados
automaticamente do Database (base de dados), quando alguma mudana ocorre no jogo, tal
como o HP atual, o SP e equipamento atual.
Exemplo de Cdigo: $game_actors[id].maxhp
Atributos:
hp
maxhp
sp
maxsp
level
exp
str
dex
agi
int
atk
pdef
mdef
eva
63

Armor ($data_armors)
Tipo: Vetor da classe RPG::Armor (Somente Leitura)
Funo: Este vetor possui os dados para os itens de defesa (armor) declarados no Database
(base de dados). Voc pode utilizar os dados deste vetor de forma individual para cada um dos
itens utilizando o ndice.
Exemplo de Cdigo: $data_armors[id].name
Atributos:
id
name
icon_name
description
kind
auto_state_id
price
pdef
mdef
eva
str_plus
dex_plus
agi_plus
int_plus
guard_element_set[id]
guard_state_set[id]
64

Classes ($data_classes)
Tipo: Vetor da classe RPG::Class (Somente Leitura)
Funo: Este vetor possui os dados das classes de personagens de seu jogo. Voc pode utilizar
os dados deste vetor de forma individual para cada uma das classes utilizando o ndice.
Exemplo de Cdigo: $data_classes[id].name
Atributos:
id
name
position
weapon_set
armor_set
state_ranks
element_rank
learnings[level,skill_id]
65

Common Events ($data_common_events)
Tipo: Vetor da classe RPG::CommonEvent (Somente Leitura)
Funo: Este vetor possui os dados dos eventos comuns declarados no Database (base de
dados). Voc pode manipular o Trigger (Gatilho) e o "Trigger Switch" (Gatilho de Interruptor)
normalmente, mas os comandos de eventos s podero ser manipulados em um outro objeto.
Exemplo de Cdigo: $data_common_events[id].name
Atributos:
id
name
trigger
switch_id
66

Enemies ($data_enemies)
Tipo: Vetor da classe RPG::Enemy (Somente Leitura)
Funo: Este vetor possui os dados dos monstros de seu jogo. Voc pode utilizar os dados deste
vetor de forma individual para cada um dos monstros utilizando o ndice.
Exemplo de Cdigo: $data_enemies[id].maxhp
Atributos:
name
maxhp
maxsp
str
dex
agi
int
atk
pdef
mdef
animation1_id
animation2_id
exp
gold
item_id
weapon_id
armor_id
treasure_prob
battler_name
battler_hue
67

Item ($data_items)
Tipo: Vetor da classe RPG::Item (Somente Leitura)
Funo: Este vetor possui os dados dos itens de seu jogo. Voc pode utilizar os dados deste
vetor de forma individual para cada um dos itens utilizando o ndice.
Exemplo de Cdigo: $data_items[id].occasion
Atributos:
name
occasion
icon_name
description
price
common_event_id
scope
consumable
68

Skill ($data_skills)
Tipo: Vetor da classe RPG::Skill (Somente Leitura)
Funo: Este vetor possui os dados das habilidades do seu jogo. Voc pode utilizar os dados
deste vetor de forma individual para cada uma das habilidades utilizando o ndice.
Exemplo de Cdigo: $data_skills[id].icon_name
Atributos:
name
icon_name
description
scope
occasion
animation1_id
animation2_id
common_event_id
sp_cost
power
atk_f
eva_f
str_f
dex_f
agi_f
int_f
hit
pdef_f
mdef_f
variance
element_set[id]
plus_state_set[id]
minus_state_set[id]
69

States ($data_states)
Tipo: Vetor da classe RPG::State (Somente Leitura)
Funo: Este vetor possui os dados dos "status effects" (efeitos dos estados) do seu jogo. Voc
pode utilizar os dados deste vetor de forma individual para cada um dos "status effects" (efeitos
dos estados) utilizando o ndice.
Exemplo de Cdigo: $data_states[id].animation_id
Atributos:
name
animation_id
restriction
nonresistance
zero_hp
cant_get_exp
cant_evade
slip_damage
rating
hit_rate
maxhp_rate
maxsp_rate
str_rate
dex_rate
agi_rate
int_rate
atk_rate
pdef_rate
mdef_rate
eva
battle_only
hold_turn
shock_release_prob
70

auto_release_prob
plus_state_set[id]
minus_state_set[id]
guard_element_set[id]
71

Wearpon ($data_weapons)
Tipo: Vetor da classe RPG::Weapon (Somente Leitura)
Funo: Este vetor possui os dados das armas criadas no Database (Base de Dados) do seu
jogo. Voc pode utilizar os dados deste vetor de forma individual para cada uma das armas
utilizando o ndice.
Exemplo de Cdigo: $data_weapons[id].icon_name
Atributos:
name
icon_name
description
animation1_id
animation2_id
price
atk
pdef
mdef
str_plus
dex_plus
agi_plus
int_plus
plus_state_set[id]
minus_state_set[id]
element_set[id]
72
Classes Bsicas do RGSS

Introduo
Este captulo ir abordar uma das necessidades mais bsicas que um programador RGSS
encontra quando est criando seus primeiros scripts. Se voc um programador experiente e j
tentou criar algum tipo de script j deve ter passado por isso no comeo. E se voc esta iniciando
no assunto, com certeza ir perceber o quanto este captulo essencial. Estou falando das
janelas RGSS. Em muitos locais de um jogo criado com o RPG Maker XP existem janelas. Elas
esto na tela de ttulo; o menu um conjunto de vrias janelas; a batalha tambm utiliza
janelas; quando se est salvando, ou carregando um jogo salvo, existem vrias janelas; at para
sair do jogo voc passa por uma srie de janelas. Esto, as janelas so muito importantes e este
ser o foco deste captulo. Veremos o passo a passo da criao de uma janela bem bsica,
utilizando RGSS. Vamos tentar criar aqui uma janela que pode ser apresentada (ou no) ao
usurio sempre que um item for adquirido.
Antes de iniciarmos a construo de nossas classe, vamos planejar um pouco. Ns podemos criar
uma janela pequena (no precisa ocupar a tela toda). Pode ser uma janela com apenas duas
linhas. Na primeira linha podemos por o texto "Adquiriu:" e na segunda linha podemos por uma
imagem ou o cone do item. Logo depois podemos mostrar o nome do item adquirido.
Como vamos criar uma janela devemos entender as funes da classe window, mas no s isso
que devemos conhecer. Como ns vamos mostrar uma imagem na janela importante
conhecermos a classe bitmap, sprite e plane. Estas so as classes que trabalham com imagens e,
portanto, vamos estuda-las antes de criarmos a nossa primeira janela.
E lembre-se: O planejamento prvio muito importante para evitar re-trabalho e complicaes
futuras no desenvolvimento de qualquer tipo de sistema, incluindo scripts de jogos.
Qualquer semelhana dos prximos captulos com o arquivo de ajuda do Rpg Maker NO uma
coincidncia. Eles foram baseados no "help" do RPG Maker XP.
73

Detalhes da Classe Window
Antes de construirmos nossa primeira janela vamos ver os detalhes de algumas propriedades e
mtodos que j existem na classe window e que vamos usar futuramente. A classe window a
classe bsica para todas as janelas que iremos criar. Sempre que criarmos uma janelas devemos
cri-la como herana da window_base ou da window_selectable, que, por sua vez, herda da
classe window. Por causa disso bastante importante conhecermos os recursos da classe
window.
Construtor
Window.new([viewport])
Cria um objeto da classe window. Voc pode especificar uma janela de visualizao (viewport)
quando necessrio.
Mtodos
viewport
Retorna uma janela de visualizao (viewport) que foi especificada no mtodo construtor.
dispose
Descarrega (remove) a janela. Se ela j foi descarregada, nada acontece.
disposed?
Retorna TRUE se a janela foi descarregada e FALSE se ela ainda existe.
update
Atualiza o cursor e as animaes grficas que esto na janela. Por padro, este mtodo
chamado uma vez por frame (quadro de atualizao de tempo).
74

Propriedades
Windowskin(<nomedoarquivo>)
Refere-se ao Bitmap usado como WindowSkin. Com este comando mudamos a Skin (Pele) de
nossa janela.
Contents
Refere-se ao Bitmap usado no contedo da janela
Stretch(=true,=false)
O modo de exibio do fundo. Se for TRUE, expande o grfico de fundo, se for FALSE, usa o
modo tile (lado a lado). O valor padro TRUE.
cursor_rect
O Cursor (no caso de janelas c/ seleo).
active(=true,=false)
Estado do Cursor. Se TRUE, o cursor fica ativo e piscando. Se FALSE, o cursor fica inativo e
esttico na tela.
visible (=true,=false)
Estado da janela. Se for TRUE a janela est visvel e se for FALSE a janela est invisvel.
Pause(=true,=false)
Pausa a iterao com alguns tipos de janela. Exemplo: O smbolo de seta que aparece nas
janelas de mensagem, esperando que o jogador aperte o boto.
x
a coordenada X da Janela.
y
A coordenada X da Janela.
75

width
Valor da largura da janela.
height
Valor da altura da janela.
z
Valor da coordenada Z da janela. Quanto maior o seu valor, mais acima a janela exibida. Se
vrios objetos compartilharem o mesmo Z, o mais recente criado que ser mostrado por cima.
ox
Valor da coordenada X do ponto inicial do contedo da janela. Mude este valor para rolar o
contedo da janela na horizontal.
oy
Valor da coordenada Y do ponto inicial do contedo da janela. Mude este valor para rolar o
contedo da janela na Vertical.
opacity
Valor da transparncia da janela e varia de 0 a 255. Valores fora do padro so automaticamente
corrigidos. 255 indica que a janela ser totalmente transparente (resultado semelhante
invisvel).
back_opacity
Valor da transparncia do fundo da janela e varia de 0 a 255. Valores fora do padro so
automaticamente corrigidos. 255 indica que o fundo da janela ser totalmente transparente.
contents_opacity
Valor da transparncia do contedo da janela e varia de 0 a 255. Valores fora do padro so
automaticamente corrigidos. 255 indica que o contedo da janela ser totalmente transparente.
76

Exemplos
Dentro da classe
self.x = 200 # Seta a posio X da janela em 200
Fora da Classe
@janela = Window_Janela.new()
@janela.x = 200 # Seta a posio da instancia da janela em 200
77

Detalhes da Classe Bitmap
Em muitas ocasies iremos precisar desenhas imagens, cones e figuras numa janela. Por causa
disso, importante conhecermos o funcionamento da classe bitmap e algumas de suas
funcionalidades.
Construtor
Bitmap.new(<nomedoarquivo>)
Carrega um arquivo de imagem especificado em <nomedoarquivo> e cria um objeto bitmap. Ele
automaticamente procura arquivos includos no RTP e em arquivos criptografados. A extenso do
arquivo pode ser omitida (no necessria).
Bitmap.new( <largura><, altura> )
Cria um objeto bitmap com o tamanho especificado em largura e altura.
Mtodos
dispose
Descarrega (remove) o bitmap. Se ele j foi descarregado, nada acontece.
disposed?
Retorna TRUE se o bitmap foi descarregado e FALSE se ele ainda existe.
width
Retorna a largura do bitmap.
height
Retorna a altura do bitmap.
rect
Retorna o "retngulo" do bitmap.
78

blt(x, y, src_bitmap, src_rect[, transparencia])
Cria uma cpia da imagem especificada em src_bitmap do src_rect para as coordenadas
especificadas (x e y). A transparncia um parmetro opcional.
stretch_blt(dest_rect, src_bitmap, src_rect[, transparencia])
Cria uma cpia redimensionada da imagem especificada em src_bitmap do src_rect para o
dest_rect (retngulo de destino).
fill_rect(x, y,largura, altura, cor) ou fill_rect(rect, cor)
Preenche o bitmap (x, y, largura, altura) ou o retngulo do bitmap (rect) com uma cor.
clear
Limpa o bitmap.
hue_change(hue)
Desloca a palheta de cores do bitmap com 360 graus de giro. Este processo consome tempo.
Utilizar vrios comandos hue_change causam perda de cor. Alm disso, alguns erros podem
acontecer devido a problemas de converso.
draw_text(x,y,largura,altura,str[, alinhamento]) ou draw_text(rect,str[, alinhamento])
Escreve um texto (str) num bitmap (x, y, largura, altura) ou num retngulo (rect). Se a
quantidade de letras exceder o tamanho estipulado na largura, o texto automaticamente ser
reduzido de tamanho. O Alinhamento possui 3 posies, sendo 0 o equivalente esquerda, 1
equivale ao centro e 2 equivale ao texto alinhado direita. O padro, ele 0. Caso no seja
passado nenhum valor para o alinhamento, o texto ser alinhado esquerda.
Propriedades
font (=nomedafonte)
A fonte usada no desenho do texto.
79

Detalhes da Classe Sprite
A classe Sprite o comando bsico usado para mostrar qualquer imagem na tela do jogo.
Construtor
Sprite.new([viewport])
Cria um objeto da classe Sprite. Voc pode especificar uma janela de visualizao (viewport)
quando necessrio.
Mtodos
viewport
Retorna uma janela de visualizao (viewport) que foi especificada no mtodo construtor.
dispose
Descarrega (remove) o Sprite. Se ele j foi descarregado, nada acontece.
disposed?
Retorna TRUE se o Sprite foi descarregado e FALSE se ele ainda existe.
update
Atualiza o flash (efeito de piscamento) dos Sprite's que esto na tela. Por padro, este mtodo
chamado uma vez por frame (quadro de atualizao de tempo). No necessrio chamar este
mtodo se o flash no for utilizado no Sprite.
flash(cor, duracao)
Inicia o "efeito de piscamento" do Sprite. O parmetro durao indica o nmero de frames
(quadros) que ir durar o "piscamento". Se no for especificado uma cor no parmetro "cor", o
sprite ir desaparecer no final.
80

Propriedades
bitmap
Refere-se ao Bitmap usado no Sprite.
visible
a visibilidade do Sprite. Se for TRUE, o Sprite est visvel. Se for FALSE, o Sprite est invisvel.
x , y, z
So as coordenadas do Sprite. No caso da z, quanto maior o seu valor, mais alto ela est, ou
seja, mais acima dos outros Sprites estar.
ox , oy
Coordenadas de incio do Sprite. Quando alteradas, movimentam o bitmap dentro do Sprite e se
um Viewport for declarado, movimentar o Sprite dentro do Viewport.
zoom_x , zoom_y
Nveis de zoom do Sprite. 1.0 denota o tamanho atual. O zoom pode ser alterado por valores
decimais, de 0.1.
angle
o ngulo de rotao do Sprite. Especificar ngulos maiores que 360 acontece uma rotao
anti-horrio. Rotacionar um Sprite consome tempo de processamento. Evite usar muita rotao
ao mesmo tempo.
mirror
Flag responsvel pela inverso horizontal do Sprite. Se TRUE, o Sprite ser desenhado invertido.
bush_depth
Determina a cor de pixel que mostrada semi-transparente.
opacity
Transparncia do Sprite. Varia de 0 a 255, sendo que 0 totalmente transparente e 255
totalmente opaco.
81

blend_type
Efeitos de cor (0: normal, 1: adio, 2: subtrao).
color
a cor a ser misturada com o Sprite.
tone
a tonalidade da cor do Sprite.
82

Detalhes da Classe Plane
A classe Plane se parece com a classe Sprite, porm ela "cola" lado a lado o Bitmap que ela
contem, esparramando-o pela tela. usada para panoramas e Fogs.
Construtor
Plane.new([viewport])
Cria um objeto da classe Plane. Voc pode especificar uma janela de visualizao (Viewport)
quando necessrio.
Mtodos
viewport
Retorna uma janela de visualizao (Viewport) que foi especificada no mtodo construtor.
dispose
Descarrega (remove) o Plane. Se ele j foi descarregado, nada acontece.
disposed?
Retorna TRUE se o Plane foi descarregado e FALSE se ele ainda existe.
Propriedades
bitmap
Refere-se ao Bitmap usado no Plane.
visible
a visibilidade do Plane. Se for TRUE, o Plane est visvel. Se for FALSE, o Plane est invisvel.
z
Quanto maior o seu valor, mais alto ela est, ou seja, mais acima dos outros Planes estar.
83

ox , oy
Coordenadas de incio do Plane. Quando alteradas, movimentam o Bitmap dentro do Plane.
zoom_x , zoom_y
Nveis de zoom do Plane. 1.0 denota o tamanho atual. O zoom pode ser alterado por valores
decimais, de 0.1.
opacity
Transparncia do plane. Varia de 0 a 255, sendo que 0 totalmente transparente e 255
totalmente opaco.
blend_type
Efeitos de cor (0: normal, 1: adio, 2: subtrao).
color
a cor a ser misturada com o sprite.
tone
a tonalidade da cor do sprite.
84
Um Script Realmente til

Introduo
A primeira coisa que devemos saber sobre a criao de janelas em RGSS a sua finalidade. A
janela pode servir para diversos fins. Pode ser uma janela simples, que mostrar informaes, ou
pode ser uma janela com algum grau de interao, onde o usurio pode escolher aes ou
opes. Estes dois tipos de janelas se diferenciam apenas pela classe na qual herdam. Se
quisermos criar uma janela simples, nossa janela herdar de Window_Base. Se quisermos criar
uma janela com opes de seleo, ela herdar de Window_Selectable.
Criando o Esqueleto de uma Janela

Neste primeiro exemplo, vamos criar uma janela simples e, portanto, nossa janela ir herdar de
Window_Base, pois vamos mostrar apenas uma informao em tela. O bsico que qualquer
janela deve ter um mtodo construtor, outro mtodo para limpar seu contedo e outro para
atualizar o contedo. Uma janela com apenas estes mtodos ser apenas uma caixa na tela.
Podemos dizer que ser apenas um "esqueleto" de uma janela. Vejamos um exemplo:
class Window_ItemGet < Window_Base
attr_accessor :type # Comentrio 3
attr_accessor :id # Comentrio 4
def initialize(type, id)
super(220, 180, 220, 96) # Comentrio 1
self.contents = Bitmap.new(width - 32, height - 32)
self.back_opacity = 255
self.contents.font.name = "Arial"
self.contents.font.size = 18
@type = type
@id = id
refresh # Comentrio 2
end
def refresh
self.contents.clear
end
def update
super
end
end
85

A figura 5 mostra como ficar a nossa janela "esqueleto" caso seja feito um teste neste
momento.
Figura 5: Esqueleto de uma janela.
Em nosso exemplo, o mtodo construtor (initialize) necessita de 2 (dois) parmetros. Um servir

para dizer o tipo de item que desejamos mostrar em tela e o outro servir para sabermos o ID do
item. O primeiro comando do mtodo initilize deve ser a chamada do comando super (comentrio
nmero 1 do cdigo). O comando super necessita de 4 (quatro) parmetros. Estes parmetros
so, da esquerda para a direita: coordenada X do pixel superior esquerdo da janela, coordenada
Y do pixel superior esquerdo da janela, a largura da janela em pixels e por ltimo a altura da
janela em pixels.
Outra coisa importante que o ltimo comando do initilize deve ser a chamada do mtodo que
atualiza a janela (comentrio nmero 2 do cdigo). Assim, quando a janela for iniciada, o
contedo dela ser totalmente limpo, ou seja, ser uma janela vazia.
Observe tambm que o tipo (varivel type) e o ID so variveis "attr_accessors" (comentrio 3 e
4 do cdigo). Isso possibilita o acesso destes valores fora da classe sem que sejam criados
mtodos para ler ou gravar valores nelas. Isso ser importante quando chegarmos na classe de
Scene_Map que veremos mais adiante.
86

Adicionando Contedo numa Janela
O prximo passo adicionar informao na janela. Para fazermos isso devemos colocar algum
cdigo no mtodo Refresh. Observe o cdigo abaixo:
def refresh
self.contents.clear
self.contents.font.color = normal_color
self.contents.draw_text(4, 0, 180, 32, "Adquiriu:")
if @type == 1
self.draw_item_name($data_items[@id], 4, 32)
end
if @type == 2
self.draw_item_name($data_weapons[@id], 4, 32)
end
if @type == 3
self.draw_item_name($data_armors[@id], 4, 32)
end
end
O primeiro comando que devemos por na maioria dos mtodos Refresh limpar a janela. Logo
depois devemos dizer a cor do texto que ser escrito na janela.
Outra coisa que queremos por em nossa janela o texto "Adquiriu:" na primeira linha. Para
escrever qualquer coisa na janela devemos usar o mtodo self.contents.draw_text. Este mtodo
encontra-se na classe Window. Nossa janela herda de Window_Base, que por sua vez herda de
Window. Por isso podemos usar o draw_text normalmente. Este mtodo necessita de 5 (cinco)
parmetros. Estes parmetros so, da esquerda para a direita: coordenada X dentro do bitmap
da janela onde o texto ser impresso, coordenada Y dentro do bitmap da janela onde o texto
ser impresso, a largura do espao reservado para o texto, a altura do espao reservado para o
texto e o texto propriamente dito.
As prximas linhas de cdigo iro verificar o valor da varivel type e efetuar comandos diferentes
para cada valor. Se o tipo for 1, devemos imprimir em tela um item. Se o tipo for 2, devemos
imprimir em tela uma arma. Se o tipo for 3, devemos imprimir em tela um item de defesa.
87

Vamos supor que existe uma espada chamada "Espada do Script". Se testarmos nosso script com
esta espada o retorno ser semelhante com o que podemos observar na figura 6.
Figura 6: Janela preenchida com texto e imagem atravs mtodo Refresh.
O prximo passo adicionar nossa janela na classe Scene_Map. Devemos fazer isso para que
nossa janela aparea toda vez que o nosso heri conseguir um item. A alterao ser no mtodo
main da classe Scene_Map. Este mtodo j existe e j possui cdigo. No devemos excluir
nenhuma linha. Para nossa janela funcionar devemos apenas adicionar os comandos que ir
controlar a nossa janela. As linhas adicionadas esto em vermelho. Observe o cdigo abaixo:
attr_accessor :item_acquired
# --------------------def main
# Comentrio 5
@spriteset = Spriteset_Map.new
@message_window = Window_Message.new
@acquire_window = Window_ItemGet.new(1, 0)
# Comentrio 1
@acquire_window.visible = false
# Comentrio 2
@itemdelay = -1
# Comentrio 3
@item_acquired = [0, 0]
# Comentrio 4
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@spriteset.dispose
@message_window.dispose
@acquire_window.dispose
# Comentrio 6
if $scene.is_a?(Scene_Title)
Graphics.transition
Graphics.freeze
end
end
88

Uma coisa nova nesta classe a varivel de instncia @acquire_window (comentrio nmero 1
do cdigo). Esta varivel ser por onde vamos manipular a nossa janela.
No desejamos que a janela fique aberta para sempre. Ela deve ficar aberta apenas quando o
heri adquirir um item, portanto a visibilidade da janela , por padro, FALSE (invisvel).
Fazemos isto atravs do comando "@acquire_window.visible = false" (comentrio nmero 2 do
cdigo).
A varivel de instncia "@itemdelay" (comentrio nmero 3 do cdigo) ser usada mais tarde e
por enquanto o valor dela deve ser "-1".
A varivel de instncia "@item_acquired" ser usada para retornar o tipo (varivel type) e o ID
do item para a janela que criamos (comentrio nmero 4 do cdigo).
Iremos precisar modificar este vetor (array) em outras classes e portanto devemos utilizar mais
uma vez o "attr_accessor" (comentrio nmero 5 do cdigo). Por ltimo, a janela deve sair da
tela quando no for mais necessria. Para tanto usamos o comando dispose (comentrio nmero
6 do cdigo) no final do mtodo main.
89

Controlando a Janela Atravs da Scene_Map
Para gerenciar (mostrar, esconder, atualizar, dentre outras aes) a nossa janela de forma
correta no mapa, o mtodo Update da classe Scene_Map deve ser modificado. As mudanas
esto na cor vermelha no cdigo abaixo:
def update
loop do
$game_map.update
$game_system.map_interpreter.update
$game_player.update
$game_system.update
$game_screen.update
unless $game_temp.player_transferring
break
end
transfer_player
if $game_temp.transition_processing
break
end
end
@spriteset.update
if @itemdelay > 0
@itemdelay -= 1
end
# Comentrio 2
if @itemdelay == 0 # Comentrio 3
@itemdelay = -1
@acquire_window.visible = false
@item_acquired[0] = 0
@item_acquired[1] = 0
end
@message_window.update
if @item_acquired[0] != 0 && @item_acquired[1] != 0 && @itemdelay < 0 # Comentrio 1
@acquire_window.type = @item_acquired[0]
@acquire_window.id = @item_acquired[1]
@acquire_window.refresh
@acquire_window.visible = true
@itemdelay = 125
end
[...]
end
90

Estas alteraes controlam o funcionamento da abertura da janela e fazem com que ela se feche
automaticamente depois de alguns segundos.
Ainda devemos criar um evento com alguns comandos para chamar a nossa janela. Observe na
figura 7 um exemplo de como o nosso evento pode ser criado.
Figura 7: Evento que chama o script.
Quando este evento executado, o cdigo do comentrio nmero 1 do script chamado,

atualizando e mostrando a janela. Logo abaixo, existe uma linha que ajusta o tempo que a janela
ficar visvel (@itemdelay = 125). Isso significa que a janela deve permanecer visvel 125
frames. Os comandos do comentrio nmero 2 fazem com que a varivel @itemdelay tenha seu
valor reduzido em 1 a cada frame (quadro). Os comandos do comentrio nmero 3 fazem a
janela ficar invisvel e restaura o valor padro da varivel @itemdelay que -1. Logo depois o
tipo (varivel type) e o ID do item adquirido so zerados (recebem o valor zero), para esperar
pela prxima vez em que a janela da aquisio do item seja necessria.
Dependendo de onde voc deseja mostrar a janela de item adquirido, outras Scenes devem ser
modificadas. As etapas acima geralmente podem ser aplicadas para qualquer janela de
informao que voc queira fazer. Janelas onde o usurio deve selecionar um comando (janelas
que herdem de Window_Selectable) so um pouco mais complicadas, mas isso no problema
para ns que j vimos o tutorial anterior chamado "Conhecendo os Scripts do RPG Maker XP".
Neste tutorial trabalhamos com 2 janelas que herdam de Window_Base normais e uma que herda
de Window_Selectabe. Caso voc ainda no conhea este tutorial, tente ler ele agora, para se
aprofundar um pouco mais. Tenho certeza que ser n mnimo interessante rever alguns
comandos...
91
Concluso
O objetivo deste tutorial apenas mostrar alguns dos recursos dos Scripts RGSS disponveis no
RPG Maker XP.
Este tutorial nos leva a mais um passo em nossa longa caminhada no mundo dos scripts.
Estamos apenas cada vez mais dominando esta maravilhosa ferramenta (Scripts RGSS) do RPG
Maker XP.
O nome do prximo tutorial "Criando um Menu com RGSS". Nele iremos conhecer mais
profundamente alguns dos recursos mais avanados dos scripts e veremos toda a potencialidade
que podemos ter em nossas mos. No final do tutorial teremos um menu novo e totalmente
personalizado.
O autor deste tutorial Marcelo Cavaco, formado em Processamento de Dados pela Faculdade
Rui Barbosa e formado em Engenharia de Produo pela Unibahia. J trabalhou como Analista de
Sistemas e Engenheiro e sempre teve um hobby, o RPG, seja o jogo convencional, ou os RPGs
eletrnicos. Agora, uma pequena parte de todo este conhecimento pde ser conferido neste
material.
Qualquer dvida, crtica, sugesto, reclamao, comentrio ou algo semelhante, favor mandar
um e-mail para marcelocavaco@click21.com.br.
Est na hora de avanar para o tutorial:
"Criando um Menu com RGSS".
92

Destrinchando Os Scripts RGSS

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Destrinchando Os Scripts RGSS

Загружено:

Авторское право:

Доступные форматы

Destrinchando os Scripts RGSS

Tutorial RPG Maker XP

Tutorial RPG Maker XP