ÍNDICE DE TÓPICOS
ÍNDICE DE TÓPICOS
Unidade 1 - Sintaxe
Unidade 1 - Sintaxe
ANTES DE COMEÇARANTES DE COMEÇAR 0303
o o O Ruby O Ruby o o O RGSSO RGSS o o ScriptsScripts o o O Editor de RGSSO Editor de RGSS o o SintaxeSintaxe o o RevisãoRevisão VARIÁVEISVARIÁVEIS 0606 o o IntroduçãoIntrodução o o TiposTipos o o ValoresValores OPERADORESOPERADORES 0909 o o IntroduçãoIntrodução o o UsoUso o
o Outras FormasOutras Formas
ESTRUTURA DE FLUXOESTRUTURA DE FLUXO 1313
o o IntroduçãoIntrodução o o CondicionaisCondicionais o o LoopingLooping o o OutrosOutros
CLASSES E MÉTODOSCLASSES E MÉTODOS 1818
o o IntroduçãoIntrodução o o ClassesClasses o o MódulosMódulos o o MétodosMétodos
Unidade 2 - Janelas
Unidade 2 - Janelas
ANTES DE COMEÇARANTES DE COMEÇAR 2525
o o IntroduçãoIntrodução o o IdentificaçãoIdentificação o o TiposTipos o o EstruturaEstrutura
MÃOS À OBRAMÃOS À OBRA 2727
o
o Criando uma janelaCriando uma janela
o
o Modificando a janelaModificando a janela
o
o Melhorando a janelaMelhorando a janela
COMANDOSCOMANDOS 3030
o
ÍNDICE DE TÓPICOS
ÍNDICE DE TÓPICOS
Unidade 1 - Sintaxe
Unidade 1 - Sintaxe
ANTES DE COMEÇARANTES DE COMEÇAR 0303
o o O Ruby O Ruby o o O RGSSO RGSS o o ScriptsScripts o o O Editor de RGSSO Editor de RGSS o o SintaxeSintaxe o o RevisãoRevisão VARIÁVEISVARIÁVEIS 0606 o o IntroduçãoIntrodução o o TiposTipos o o ValoresValores OPERADORESOPERADORES 0909 o o IntroduçãoIntrodução o o UsoUso o
o Outras FormasOutras Formas
ESTRUTURA DE FLUXOESTRUTURA DE FLUXO 1313
o o IntroduçãoIntrodução o o CondicionaisCondicionais o o LoopingLooping o o OutrosOutros
CLASSES E MÉTODOSCLASSES E MÉTODOS 1818
o o IntroduçãoIntrodução o o ClassesClasses o o MódulosMódulos o o MétodosMétodos
Unidade 2 - Janelas
Unidade 2 - Janelas
ANTES DE COMEÇARANTES DE COMEÇAR 2525
o o IntroduçãoIntrodução o o IdentificaçãoIdentificação o o TiposTipos o o EstruturaEstrutura
MÃOS À OBRAMÃOS À OBRA 2727
o
o Criando uma janelaCriando uma janela
o
o Modificando a janelaModificando a janela
o
o Melhorando a janelaMelhorando a janela
COMANDOSCOMANDOS 3030
o
o
o MétodosMétodos
o
Antes de Começar
1 - O Ruby
Ruby é uma linguagem de programação orientada a objeto. Foi criada pelo japonês Yukihiro Matsumoto.
Ela possui ótimas características que possibilitam os novatos aprenderem facilmente. Uma das é que existem as famosas variáveis, que aperfeiçoam a precisão de cada script, conduzindo várias funções. Basicamente todo script gira em torno de funções (métodos) e variáveis.
2 - O RGSS
O RGSS é uma derivada do Ruby, criado exclusivamente pela Enterbrain para o RPG Maker XP (no VX é o RGSS2, usa a mesma linguagem do RGSS, porém muda alguns métodos para
melhorar o desempenho, em resumo, apenas uma atualização). Siginifica Ruby Game Scripting System ou Sistema de Progamação Ruby para Jogos.
3 - Scripts
Os scripts são o que conhecemos por códigos que adicionam ou modificam o sistema padrão do RPG Maker. São eles que dão um toque especial ao jogo, mudando o sistema de batalha, menu, etc. Com eles é possível fazer qualquer sistema que você imaginar.
4 - O Editor de RGSS
Ele se localiza na parte de cima do programa, ou simplesmente apertando F11. É lá que está todos os scripts do jogo, na coluna a esquerda, e na coluna a direita o código em si.
5 - Sintaxe
Vamos começar entendo o básico do RGSS, sabendo identificar o que é uma variável, comentário, expressão, método, classe,...
Identificadores -> São espaços entre variáveis e métodos para deixar mais claro a idéia deles, por exemplo, não podemos escrever isto no RGSS: variável de palavras = "oi gente!", por isso os usamos para variáveis e métodos ficarem assim: variavel_de_palavras = "Oi gente!"
Comentários -> São códigos deixados com instruções ou qualquer texto dentro do script, eles não têm valor algum. Há duas formas de escrevermos um comentário:
a = 5 # declarei a variável a com o valor de 5
=begin olá pessoal,
usado em grandes instruções =end
Palavras Reservadas -> São palavras próprias da sintaxe do Ruby, não são nem variáveis nem métodos, são, por exemplo, verbos que orientam o que se deve fazer. Perceba que algumas
começam com letras minúsculas, isso deve ser respeitado, por no Ruby ‘x’ é diferente de ‘X’.
BEGIN class ensure nil self when END def false not super while alias defined? for or then yield and do if redo true
begin else in rescue undef break elsif module retry unless
case end next return until
No RGSS há várias opções de simplificação, para evitar gasto excessivo de linhas, aqui dois exemplos:
a, b = 10, 58 # a = 10 e b = 58
def alo_mensagem; print “alô”; end
6 –Revisão
O que é uma POO?
POO significa Programação orientada a objetos, ou seja, uma linguagem onde o objeto é o principal papel do código.
O que é um objeto?
Um objeto é uma coisa que representa algo, ou seja, uma variável que representa uma coisa.
Por exemplo, o menu possui janelas, como a de tempo, dinheiro, comando e dos personagens. Cada janela dessas é um objeto. A cena do menu é uma Scene que engloba e interage com esses objetos.
Para que o uso deles?
Bem, eles são o principal meio de interação, por exemplo, para criarmos uma janela, precisamos criar uma variável que a represente num outro script.
@variável = Window_Gold.new(50, 50) # criação da janela de
dinheiro. Usa-se o método „.new‟ e os argumentos caso necessário
entre parênteses.
Neste exemplo vimos que a variável @variável representa a janela de dinheiro. Quando se declara uma classe, deve-se sempre chamá-la com ‘.new’e o argumento em seguida (se necessário).
Um argumento é um valor pedido pela classe para ser usado em qualquer coisa, desde o seu tamanho, como posição X e Y. No caso da janela de dinheiro, os valores 50 e 50 representam a posição X e Y. Para ver porque, vá ao script Window_Gold e veja que no def initialize há isso:
def initialize(x, y) Os Métodos
Métodos são as principais estruturas do script. Eles dizem o que o script deve fazer, precisamos ser bem precisos nessa questão. Cada classe tem seu método, outras classes herdam métodos.
Herança
Herança nada mais é do que uma classe filha herdar métodos da mãe. Isso serve para não escrevermos tudo novamente para cada classe. Como é o caso da Window_Base, ela é a mãe de toda Window. Representamos a herança desse modo: Window_Qualquer < Window_Base. Lembrando que pode-se mudar a mãe, no caso foi só um exemplo. Pode-se por qualquer classe existente para ser mãe, outro exemplo é no VX, que há a Scene_Base, onde toda Scene herda os métodos dela.
Estrutura dos Scripts
Todo script, deve começar com a palavra class e acabar com o end.
class Exemplo end
Criamos uma classe, mas ela não tem nada, é claro. Vamos colocar alguma coisa.
class Exemplo def initialize @a = 5 aumentar(10) end def aumentar(valor) @a += valor end end
Neste exemplo, a classe tem 2 métodos, o initialize, que é o padrão (o seu nome nunca muda), que serve para inicializar. Nele há uma configuração, declaramos a variável @a como uma Integer, de valor 5, logo em seguida, chamamos o método aumentar, que necessita de um argumento. No def aumentar, o argumento é a variável valor, que como vemos, ela aumenta a variável @a em 10 (porque eu chamei o método aumentar com o argumento valor = 10).
Há uma confusão com iniciantes em RGSS, pelo fato de serem iguais os métodos e variáveis locais. Mas há diferenças. Quando chamamos um método, o chamamos sem nenhuma igualdade, apenas o seu nome e argumento, se ele possuir.
aumentar(500) # chamamos o método aumentar
aumentar = 500 # declaramos a variável aumentar como 500
O comando Print
Este comando é bem útil para quem está iniciando, pois nós quando começamos algo
queremos logo ver o resultado do nosso avanço, claro que ele não foi criado para isso, porém até mesmo os scripters profissionais usam comandos como esse para checar se a coisa
realmente aconteceu. Ele mostra uma caixinha de aviso com uma mensagem qualquer.
Usa-se ‘p’ ou ‘print’ mais a string, o texto. print “Olá”
Variáveis
1 - Introdução
Variáveis são como as variáveis dos eventos, elas acumulam valores que podemos alterar quando quisermos, ao contraio das switches, que só possuem dois valores (true/false) as variáveis possuem valores desde números e letras até classes, como o menu.
Elas assumem todos os valores de objetos no RGSS, e é com ela que fazemos a maior parte do trabalho.
2 - Tipos
Então, vamos primeiro demonstrar os tipos das variáveis e depois seus valores.
Existem 6 tipos de variáveis, as locais, de instância, de classe, globai s, constantes e pseudo-variáveis.
>> Variáveis Locais
São variáveis usadas para cálculos específicos e provisórios, dentro ou fora de classes somente, por exemplo:
a = 10
def qualquer_metodo a = "oi"
end
Neste exemplo, as variáveis "a" não são as mesmas. As variáveis locais começam apenas com letras minúsculas ou com underline (_).
>> Variáveis de Instância/Públicas
São usadas para uma classe toda, bem como todos os métodos dela, exemplo:
class Teste attr_accessor :variavel_x def initialize @variavel_x = "X" end end @a = Teste.new print @a.variavel_x
São iniciadas com o "@" no começo.
>> Variáveis de Classe
Estas são uma versão mais aprimorada das públicas, servem para uma classe e todos os métodos.
class T @@a = "a" def printer print @@a end end T.new.printer
Começam com "@@" antes da palavra. Vale lembrar que se eu coloco @@var = 12.21, então ela será assim para todo e qualquer método, o mesmo não acontece com as locais e públicas.
>> Constantes
São variáveis que utilizamos para certos cálculos ou coisas fixas, como o PI, nomes de personagens, tamanho de janelas, etc.
Pi = 3.1415
Nome_heroi = "Alex" Altura_Espaço = 24
É preciso notar que estas variáveis podem ser escritas de qualquer forma, desde que a
primeira letra seja maiúscula. Podem ser acessadas independentemente, ou seja, posso tanto acessá-las em uma classe como em outra. São também muito usadas em associação com módulos.
3 - Valores
Agora que sabemos o tipo das variáveis, vamos saber o que elas podem ser.
>> Numéricos
Integers => são números inteiros, ou seja, negativos e positivos, geralmente todo valor número que atribuímos a uma variável é um Integer. Ex:
@var = -195 $index = 658
Float => são números decimais, não há muito que falar sobre eles, são usados em cálculos mais complexos.
_var = 68.9 >> Strings
Strings são os famosos textos, como por exemplo, os textos "Novo Jogo, Continuar, Sair" da tela de título. São representados entre aspas e possuem uma tonalidade roxa. Ex:
Texto = "Olá mundo!"
@exemplo = "Me dá mais dinheiro!"
Arrays, conjuntos, matrizes ou vetores, são variáveis que podem possuir mais de um valor, sendo representados por colchetes e separadas por vírgulas. Geralmente se usa para organizar valores com algum tipo de identificação. Ex:
@array = [1,2,3]
$array_itens = [[4,5,6],789,321]
Array_Mista = ["Oi",-168,458.6,$data_actors.id]
Note que uma array pode ter vários tipos de valores, strings, integers, etc. Inclusive uma array dentro da mesma. Estudaremos mais sobre arrays numa aula dela mesma.
>> Hashes
Hashes são um tipo de arrays, porém mais organizadas, possuem valores fixos. Por exemplo, temos que nos referir a um valor para obtermos o que queremos. Ex:
hash = {1=>5.3,8=>4*2,"5+5"=>10}
Neste caso se quisermos chamar o valor 5.3, temos que referir o valor 1, hash[1] retornar esse valor. hash[8] retornará o valor 4*2 e hash["5+5"] retornará o valor 10. Note que as hashes são escritas com chaves e que também é possível ter arrays dentro delas e vice-versa.
>> Pseudo-Variáveis
São quatro pseudo-variáveis, são elas:
True => Valor positivo, quando ativo, é o contrário de false.
False => Valor negativo, quando ativo, é o contrário de true.
Self => Tem valor que retorna ao próprio remetente, por exemplo, em janelas (windows) é comum ver o self.
Nil => Valor inexistente, que geralmente não é declarado. Não é igual a zero (que existe).
São valores absolutos, true é o contrário de false, e vice-versa, se uma variável for declarada como true ela não será false, se for false, não estará true. Note que podemos mudar quando quisermos o valor dela. Self e Nil são pouco usadas, Self geralmente é usada em classes
genéricas como Windows, e Nil em qualquer script e função que desejar, porém seu uso é mais para garantir que o programa não dê erro ao usar uma variável inexistente (sem valor, não declarada).
Operadores
1 - Introdução
Operadores é o conjunto de símbolos que usamos para fazer operações com variáveis, seja de soma, multiplicação, condição, comparação, etc.
São alguns deles:
:: -> Módulo
[] -> Vetor
** -> Potência
* / % -> Multiplicação e Resto da divisão + - -> Soma e subtração
<< >> -> Deslocamento
> >= < <= -> Maior, maior ou igual, menor, menor ou igual <=> == === != =~ !~ -> Comparação && -> E || -> Ou .. ... -> Range ?: -> Operador de condição not -> Negação and or -> E, ou 2 - Uso
Operadores são usados em expressões, ou seja, qualquer conta que fizermos teremos que usar operadores, seja para igual variáveis, multiplicar, etc. Portanto é super importante a função de cada um.
Cada um tem seu uso de certa forma, vamos começar com o módulo:
:: => Este tem uma função de chamar o módulo, por exemplo:
module Math PI = 3.1415 end
Para chamarmos a constante Pi fazemos desta forma: Math::PI # 3.1415
[] => Serve para várias coisas:
@array[id], @hash[id] = X # Aqui serve para retornar o valor de uma ID duma array ou hash.
def args(args=[]) # Aqui ele cria um método que pode receber inúmeros valores como argumentos
return args end
+, -, *, / => São respectivamente os sinais de soma, subtração, multiplicação e divisão
@a + @b 10 – 5
9 * Math::Pi 85 / 5
|| ou or e && ou and => São operadores de inclusão e exclusão, geralmente usados em condições.
@a = true @b = false
if @a == true or @b == true then end if @a == false and @b == false then end Note que tanto faz usarmos or quanto || e end como &&.
not => Nega a variável em destaque, tento ou um valor boolean (true/false), númerico ou nulo.
if not $game_system.save_disabled? # Se o menu salvar NÃO estiver desabilitado
if not $game_actors[1].hp != 0 # Se o HP NÃO for diferente de zero
O not pode ser escrito com uma exclamação antes da variável:
if !$game_switches[52] # Se a switch 52 estiver OFF
>, >=, <, <=, == => Variáveis de comparação.
if a > b or c <= d # se a maior que b ou c menor/igual a d if 4 < x and z >= 10 # se 4 menor que x e z maior/igual a 10 if hp == maxhp # se hp for igual ao maxhp
.. ou ... => São valores range, ou seja, valores que vão de um número ao outro.
a = 1..20 # a tem os valores de 1 a 20 b = 0...20 # b tem os valores de 0 a 19 '..' pega todo os valores e '...' pega todos menos o último.
Há outras maneiras simplificadas de usarmos operadores, ex:
a = (10 > 5) # true b = (50*2 < 100) # false
if !(x > y and i == o) # se x>y e i==o então retorna o valor boolean, se essa expressão for true a condição será se for false (então...) e vice-versa
if x # if por padrão está implícito que é true, portanto não há necessidade de por == true
Estruturas de Fluxo
1 - Introdução
Vamos começar agora a estudar uma das partes mais críticas do Ruby, chama-se estrutura de controle ou de fluxo, primeiro tenha em mente que elas são a base e a estrutura de cada script. Basicamente todo script possui fluxo.
O que é esse tal de fluxo? Na verdade é o ciclo de tarefas que o script faz, ou seja, o trabalho que ele tem que fazer para se obter o que se deseja.
Por exemplo, usando condições é possível fazer inúmeras coisas, sem elas não seria tão simples fazer um script, funcionam da mesma forma que em eventos, aliás, eventos e script têm muito a ver, se você sabe programar bem em eventos, basta aprender a sintaxe do RGSS que você já está feito, eu garanto que o maior problema do RGSS não é a sintaxe, e sim a lógica, o uso do controle de fluxo.
É preciso ser objetivo no que quer para não enrolar o programa.
2 - Condicionais
São os controles mais conhecidos, o famoso if, unless e case. O if sabemos que é 'se', portanto acho que não tenho muito o que explicar.
if variavel (operador) variavel_2 # aqui ocorre o desejado
else
# caso não end
Duas coisas para ratificar, a primeira é esse else, ele serve para dar uma garantia que a
condição seja executada sempre, por exemplo, eu quero fazer uma condição onde se a variável nível do personagem >= 10, então colocar uma mensagem: Pode passar para a próxima área, caso não; Treine mais. Seria algo assim:
if nivel_personagem[1] >= 10 print "Pode passar"
else
print "Treine mais" end
Note que sempre vai dizer algo, pois o nível do personagem ou é igual ou menor/maior que dez. Neste caso é apenas um teste, não existe a variável nível_personagem, caso queira testar
na prática seria ‘$game_actors*1+.level’.
A outra coisa é que em Ruby usamos o end para finalizar a ação, este comando é muito útil, pois sabemos até onde a função vai atuar. Nesse caso a condição só quer saber o nível do personagem, portanto é bastante simples.
O if é bastante flexível, podemos usar o else, elsif, if simplificado e de uma linha. Vamos ver o elsif agora. if nível_personagem[1] == 5 # nível 5 elsif nível_personagem[1] == 6 # nível 6 ... end
O if simplificado é aquele que tem uma condição e excessão em uma linha apenas.
variavel_controle = switch ? true : false
Basicamente é uma condição assim:
variavel_controle = switch (ativada?) então true senão false Lembre que não há necessidade de por '== true' pois o if por padrão aceita o true.
E por fim o if de uma linha é um outro modo simplificado do if sem necessidade do end.
@debug = true if $DEBUG # é o mesmo que: if $DEBUG
@debug = true
end # que é igual a:
if $DEBUG then @debug = true end
O unless por sinal é o contrário do if, ou seja, resumidamente podemos falar que é uma condição que por padrão aceita false.
unless homem # se não for homem # mulher
else # homem end
O unless também pode ser escrito na forma simplificada.
$sexo = mulher unless homem
E por último o case. Esse é um if mais expansivo, ou seja, pega uma variável e faz análise dela para fazer determinada ação ao encontrar tal valor.
@var = rand(10) # valor aleatório de 1 a dez. case @var
# um, dois ou três when 4
# quatro else
# qualquer valor menos 1,2,3,4 end
Usamos when junto ao case, note também que o case requer um end no final para saber até onde vai o bloco de processamento.
3 –Looping
Estas estruturas tem o poder de dar infinitos laços aos comandos, até que certa condição seja alcançada. Temos três comandos aqui: while, until e for.
While é um lopping onde se faz determinada ação até enquanto ela está ainda dentro da condição, em outras palavras, enquanto a expressão estiver true, ela será executada. Ex:
@x = 1
while @x <= 10 # enquanto x for menor ou igual a 10 @x += 1 # x = x + 1
end
Neste código, a variável @x tem o valor 1 e ela será adicionada +1 ao seu valor enquanto for menor ou igual a 10, então vai parar assim que obter o valor 10.
Há também o while simplificado, que pode ser escrito desta forma:
@x = 1
@x1 += 1 while @x <= 10
O until é o contrário do while, ele faz a ação até que se obtenha o desejado, por exemplo, uma função chamada comer é criada, nela temos somente a lógica comer até agüentar, certo? Vamos expressar isso usando o until.
def esta_satisfeito? until comer >= 100
comer += 10 # adicionamos um valor a variável imaginária de porcentagem
end
return true # mostra que está end
O until pode ser escrito também na forma simplificada.
comer += 10 until comer >= 100
for i in 1..10
print “Oi, o valor é: #{i}”
end
Bem, antes de tudo, saiba que o comando #{var} serve para colocá-la em uma string, esse comando é bastante útil. Agora voltando ao for, este código faz com que se repita 10 vezes a
ação print “valor = i”.
A sintaxe dele é bastante simples:
for variável in valor_inicial(range)valor_final # fazer algo
end
Alguns exemplos do uso do for no RPG Maker:
for i in 0...@actor.skills.size skill = $data_skills[@actor.skills[i]] if skill != nil @data.push(skill) end end
Exemplo retirado da classe Window_Skill, ele faz o processamento de adição das habilidades de cada personagem. Basicamente faz a checagem de quantas habilidades o personagem tem (usando o método size) e depois cria uma array que armazena as habilidades.
for i in 1..@level for j in $data_classes[@class_id].learnings if j.level == i learn_skill(j.skill_id) end end end
Exemplo retirado da classe Game_Actor, aqui faz o cálculo para adicionar uma habilidade ao personagem atingir certo nível.
4 –Outros
Bom, temos mais comandos para mostrar, não são estruturas de repetição e nem condição, são o next, break e rescue.
Next é usado caso um valor não queira ser usado, em resumo seria algo como passar caso valor seja obtido.
array = [] for i in 1..20 next if i == 10 array.push(i)
end
print array # 12345678911121314151617181920
Bom, aqui está um simples código, ele vai adicionar a array valores de 1 a 20, porém quando for 10, não será computado, ele passará para 11 e assim em diante.
O break é parecido com o next, porém ele para quando o valor desejado for escrito.
array = [] for i in 1..20 break if i == 11 array.push(i) end print array # 12345678910
Rescue é usado para retornar uma expressão caso a primeira não exista, um exemplo é quando se usa uma font que não exista, assim uma segunda é colocada. No script Main, por exemplo:
$defaultfonttype = $fontface = $fontname = Font.default_name =
"Nao_Existe” rescue “Tahoma”
No exemplo acima, a font primária será a Não_Existe, como o nome diz, não irá ter, portanto irá retornar a font Tahoma.
Outro exemplo é usando windowskins, no Window_Base, logo no começo tem algo assim:
@windowskin_name = $game_system.windowskin_name
self.windowskin = RPG::Cache.windowskin(@windowskin_name)
Este código atribui a windowskin igual a do database, porém vamos modificar para uma inexistente.
self.windowskin = RPG::Cache.windowskin(“Não Existe”)
Se você testar, logo no começo irá dá um erro, pois não é possível encontrar o arquivo. Porém usando o rescue, este problema é sanado.
self.windowskin = RPG::Cache.windowskin(“Não Existe”) rescue
Classes e Métodos
1 –Introdução
Vamos começar a estudar as classes agora. Elas são os scripts em si, ou seja, qualquer script é uma classe, e não necessariamente precisa ser concreto para ser classe, uma janela é uma
classe assim como o Game_Actor é uma, o que classifica uma classe é o código ‘class’ mais o
nome dela.
O que é uma classe? Classe é algo meio difícil de explicar, um conceito primitivo, vou tentar ser o mais simples possível. Todo script que você adiciona é uma classe, um script pode ter várias classes, portanto, se eu quiser mexer na classe Scene_Item eu vou saber onde ir, pois lá na coluna da esquerda tem o nome da classe (nem sempre pode ser assim, pois o nome do script é opcional) e em seguida verei o código class Scene_Item.
Resumindo, classes são quaisquer scripts que se tem no editor, desde o Game_Temp ao Scene_Debug.
Já os métodos são funções que criamos para reduzir um trabalho repetivivo, são rotinas que podemos acessá-las sempre. Geralmente se associa métodos com classes, pois toda classe para funcionar tem que ter métodos, por isso é fundamental entender a relação desses dois.
2 –Classes
Para criarmos uma classe, basta adicionar o código class mais o nome dela. Note que não pode haver duas classes iguais, ou seja, se eu crio uma classe Scene_Map, não poderá haver uma outra.
class Scene_Teste end
A estrutura de uma classe é assim, mas como eu disse, uma classe tem que ter métodos para funcionar. Vamos adicionar um método qualquer a ela.
class Scene_Teste def metodo_qualquer
print “uma mensagenzinha.”
end # Fim do método end # Fim da classe
Duas coisas a se notar. Uma classe pode ter inúmeros métodos, e eu não posso chamar um método de uma classe em outra, a não ser que eu use a herança.
A herança consiste em herdar os métodos de uma classe para não ter que repeti-los. É o caso das Windows, as janelas. Repare que no começo de cada window, tem o nome da classe mais o sinal < Window_Base. Isso indica que a classe herdará todos os métodos da classe
O ‘super’ está sempre ligado a herança. Um bom exemplo é o das Windows. A estrutura delas começa sempre assim:
class Window_Jao < Window_Base def initialize
super(x, y, largura, altura) end
end
O super neste caso refere-se ao método initialize da Window_Base, que pede os 4 argumentos principais da janela, posição x e y, largura e altura.
O método deve estar dentro da classe para ser usado, qualquer método dentro da classe pode ser usado por ela.
3 –Módulos
Módulos são classes que servem como livros, ou seja, são consultados para valores constantes, cálculos, etc.
Um bom exemplo é o módulo Math, ele abrange muitas funções importantes, como o seno, cosseno, tangente e valores como o PI e a constante de Euler.
A diferença entre módulo e classe é que módulo é usado como referência e nunca pode ser alterado, já uma classe sim.
A classe pode ser um módulo, mas um módulo não pode ser uma classe.
module Exemplo
Variavel_base = 10 # constante end
print Exemplo::Variavel_base # 10
Quando usamos módulos dentro de uma classe, devemos incluí-lo usando o comando
‘include’.
Class Scene_Algo
include Exemplo # incluir o módulo exemplo end
4 –Métodos
Considero esta a parte mais importante do RGSS. Os métodos (ou funções) compõem a grande maioria do script, são eles que dão o efeito desejado através de algoritmos.
Eles são como funções que realizam determinada ação, por exemplo, a ação de somar, multiplicar, calcular porcentagem, calcular o salário, ganhar um item, adicionar um personagem ao grupo, etc.
Para criarmos um método, usamos o comando ‘def’ em seguida do nome e os argumentos, se
necessário. Lembre-se que também precisa de end no final.
def metodo_iniciante valor_1 = 15
valor_2 = 5
print valor_1 + valor_2 end
Aqui está um exemplo simples de um método, caso não tenham percebido, ele faz uma soma das variáveis e depois coloca o valor na mensagem.
Para chamar um método, simplesmente use o nome dele:
metodo_iniciante
Vou explicar agora a diferença entre um método com argumento e outro sem. Nesse exemplo que eu fiz, não há argumentos, ou seja, os valores são fixos, a não ser que eu modifique no próprio método. Mas e se eu quisesse escolher os números? Neste caso necessitaria de argumentos.
def metodo_iniciante(valor_1, valor_2) print valor_1 + valor_2
end
O argumento vem dentro de parênteses depois do nome do método, não precisa necessariamente ser um ou dois valores, podem ser vários, mas sempre separados por vírgulas.
No exemplo acima, é possível notar uma diferença entre o primeiro, pois neste o uso de argumentos foi ativado, fazendo com que o método funcione somente se eu der os valores requeridos.
Chamando métodos
Eu poderia chamar o método desta forma:
metodo_iniciante(15, 5) # valor 1, valor 2
Vamos ver agora os métodos na prática, usando um exemplo do RPG Maker.
def draw_actor_name(actor, x, y)
self.contents.font.color = normal_color
self.contents.draw_text(x, y, 120, 32, actor.name) end
Esse exemplo foi retirado da classe Window_Base.
O que ele faz é basicamente modificar a cor da font para normal (cor branca), depois escreve o
texto com o comando ‘draw_text’ (note que ele pede 5 argumentos). ‘actor.name’ é uma
seja, o texto deste método é apenas o nome do personagem. actor é uma variável qualquer, veja que há necessidade de argumentos pois se não tivesse, actor poderia ser qualquer personagem, nesse caso foi usado uma variável genérica para expressar a condição de qual herói, ele especifica qual é o personagem. Por exemplo, se eu quiser que escreva o nome do personagem na janela, seria só usar este método desta forma:
draw_actor_name($game_actors[1], 10, 0)
Atenção, este código funciona somente num script de janela, não adianta por em outro script ou apenas colar o código, pois ele é da Window_Base. $game_actors é uma classe que se refere aos personagens. Os outros dois valores são quaisquer, eles servem para saber onde colocar as coordenadas X e Y do texto.
Criando e modificando métodos
Geralmente nos scripts adicionais é comum que eles reescrevam alguns métodos das classes existentes, e só há dois tipos de formas para isso, ou reescrevendo o método por completo ou
usando o comando ‘alias’.
def calculo (valor_1, valor_2) print valor_1 + valor_2
end
Se eu quisesse, por exemplo, modificar este método para que faça uma média. Eu teria duas opções, a primeira seria reescrever o método por completo:
def calculo (valor_1, valor_2) print (valor_1 + valor_2) / 2 end
O método reescrito não é o mesmo que o anterior, portanto se eu quiser usar o método calculo, ele não será mais o primeiro.
Ou usando alias, que serve para modificar apenas uma parte do método. Este comando é bem útil quando se mexe com um monte de scripts.
alias novo_metodo velho_metodo
A sintaxe dele consiste em escrever o método reescrito e em seguida o que será modificado, é como se você tivesse colocando um novo método dentro do método antigo, porém ficando apenas o código.
alias calculo_novo calculo def calculo (valor_1, valor_2)
new_value = (valor_1 + valor_2) / 2
print “O valor é: “ + new_value
calculo_novo end
O que eu fiz foi criar uma nova variável que armazenará o valor do cálculo e depois deixar o print mais bonito, com uma mensagem mais o valor. Em seguida coloca-se o nome do novo método, que é o método que declaramos no alias.
Há também métodos que são chamados de privados, pois são variáveis de uma determinada classe, pertencendo somente a ela, porém podem ser acessadas e modificadas.
Existem três tipos dessas variáveis, são chamadas de Variáveis de instância pública, não são declaradas como variáveis normais nem chamadas como tais.
attr_reader: Declara uma variável apenas de leitura pela classe ou qualquer outra. attr_writer: Um tipo muito raro, declara uma variável apenas como um objeto a ser
modificado.
attr_accessor: Tipo mais comum, permite a uma variável ser lida e escrita quando
quiser.
Para declararmos uma variável dessas, temos que usar o prefiro attr_tipo mais ‘:’ e o nome,
por exemplo, nos scripts Game_ é bastante comum encontrarmos isto:
attr_reader :name # Nome
attr_reader :character_name # Nome do Herói attr_reader :character_hue # Cor do Herói attr_reader :class_id # ID da classe attr_reader :weapon_id # ID da Arma attr_reader :armor1_id # ID do Escudo attr_accessor :timer # Temporizador
attr_accessor :timer_working # Flag do processo de temporização attr_accessor :save_disabled # Desativar os Saves
Logo em seguida no método initialize, declara-se o valor da variável, String, Array, Integer, etc.
Para chamarmos elas, simplesmente colocamos o nome da classe mais o método, que é o próprio nome da variável.
$game_actors[1].name # Ash
$game_actors[5].character_name # 022-Hunter03
$game_system.save_disabled = true # Proibir salvar
Note que se eu colocar $game_actors[5].character_name = “021-Hunter02”vai dar erro pois é
uma variável de leitura, o mesmo não acontece se eu por ‘.name’ pois há um método na classe
Aprendendo RGSS
Unidade 2 - Introdução as Windows
Bem vindos a mais uma aula, nesta unidade vamos discutir e ensinar sobre as janelas (ou windows), que são basicamente aquelas caixinhas com a windowskin que aparecem nos menus.
O sonho de todo iniciante é logo ver modificações concretas nos scripts, e não somente a = 5; b = 10; c = a + b. Creio que começando com janelas já seja um bom início. Porque afinal o que nos motiva mais é o nosso progresso. Sem progresso, não há motivação. Estudamos RGSS não
para “saber” e sim para por em prática aquilo que queremos. Ou seja, estudamos uma
ANTES DE COMEÇAR
1 –Introdução
Todos nós sabemos o que são as janelas, certo? Bem, agora vamos começar a fala sobre elas.
As janelas são as caixinhas que o RPG Maker usa para escrever imagens, textos, gráficos, barras, etc. Basicamente, em todo canto que olhamos no jogo, há elas.
Seja no título, no menu, na batalha, por todo o lugar sempre tem uma janelinha. Por isso, já dá para ver o quanto importante é a sua função no jogo.
Uma janela pode ter o que quiser em seu conteúdo, não necessariamente textos e imagens, tudo é possível.
2 –Identificação
Bem, não acredito que seja um grande desafio identificar uma, basta olhar no seu script referente, por exemplo, no Scene_Menu, há cinco janelas. Como eu sei? Simples, olhando no menu dá para ver as janelas de opções (item, habilidades, etc), personagens (gráfico, nome, nível, etc), dinheiro, tempo de jogo e passos.
Mas para tirar a prova, vamos ver no script. Abra o editor (apertando F11) e vá ao script Scene_Menu.
No método initialize, logo vemos a variável @command_window sendo declarada como uma Window_Command (que é um tipo de janela). Caso não saiba, para criar uma janela, basta declarar uma variável com o tipo de janela mais o comando new. Um exemplo:
@variavel_de_janela = Window_Base.new(100, 150, 50, 70)
No exemplo acima, a variável @variavel_de_janela vai ser uma janela comum, e vai ter as características:
Posição X: 100 pixels Posição Y: 150 pixels Largura: 50 pixels Altura: 70 pixels
Se não souber, o que vem depois do método new são os argumentos, a Window_Base tem a necessidade de quatro argumentos, os quatro citados acima no exemplo, respectivamente. Veremos isso mais a frente com mais detalhes.
Como eu disse, são três tipos de janelas, a do exemplo é uma Window_Base, a do menu obviamente não é uma dessa, e sim uma Window_Command, por isso os argumentos são diferentes, apenas dois.
@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
Avançando na contagem, veremos os seguintes códigos mais abaixo:
@playtime_window = Window_PlayTime.new @steps_window = Window_Steps.new
@gold_window = Window_Gold.new
@status_window = Window_MenuStatus.new
Essas quatro janelas são as restantes, como vemos, são cinco janelas na cena do menu. Todas declaradas no método main, onde nos scripts Scene seguem esse padrão.
3 –Tipos
São três tipos de janela:
Window_Base Window_Command Window_Selectable
Qual a diferença entre elas? Bem, eu poderia dizer resumidamente que para uma coisa, temos uma, e para outra, temos outra, mas vamos com calma:
Window_Base: São as janelas mais comuns, não possuem escolhas e nem cursores,
usa-se quando se quer apenas demonstrar textos e imagens.
Window_Command: Essas janelas são as de escolhas, encontramos elas no menu e
tela de título, por exemplo. Se diferem da Window_Base por precisarem ser chamadas dentro de uma Scene, pela necessidade constante de atualização, visto que se
chamada apenas como uma janela, ficarão estáticas.
Window_Selectable: Provavelmente o tipo menos comum, são as janelas com
cursores, diferentes da Window_Command pois suportam uma lista grande, como por exemplo os itens e habilidades, além de apresentarem colunas.
4 –Estrutura
Agora, depois de uma longa introdução, vamos essa representação toda em scripts.
class Window_Exemplo < Window_Base def initialize
super(x, y, largura, altura) end
end
Bem, não há nada com essa janela, apenas o esqueleto. Porém podemos observar que uma janela é uma classe,e toda classe deve ser iniciada com o comando ‘class’.
Nesse exemplo, a herança é da classe Window_Base, ou seja, ela vai ter direito a todos os métodos da classe Window_Base. (Usa-se ‘<’ apóso nome da classe e em seguida a classe que
dará a herança, a ‘superclass’.)
Toda vez que tivemos uma herança, podemos usar o comando ‘super’, que serve para se
referir aos argumentos do mesmo método da superclass.
MÃOS À OBRA
1 –Criando uma Janela
Agora sim, vamos começar o que interessa. Abra o editor de RGSS e crie uma nova classe (ou script). Escreva o seguinte código.
class Window_Teste < Window_Base def initialize
super(200, 200, 120, 120)
self.contents = Bitmap.new(self.width-32, self.height-32) self.contents.draw_text(0,0,100,24, "Oi mundo!")
end
end
Crie um evento qualquer e vá ao comando Chamar Script, em seguida digite
Window_Teste.new e teste o jogo. Você verá uma pequena janela com o texto ‘Oi mundo!’
Bem, basicamente é assim que se cria uma janela, porém acho que você ainda não está contente só com isso, então, vamos lá sem medo!
A janela sumirá com o tempo, pois ficará estática e após atualizações do mapa, irá ser apagada. Para deixá-la fixa temos que declará-la na classe Scene_Map. Veremos isso mais adiante.
Agora explicando o código, o método contents serve para indicar o conteúdo total da janela, seja texto, imagem, etc. Devemos sempre começar declarando a variável self.contents como uma Bitmap. A classe Bitmap abrange todo o tipo de imagem e texto.
Tanto que o método draw_text, que serve para escrever o texto, é da classe Bitmap. Em resumo, tudo que aparecer na janela é um Bitmap.
Ele pede cinco argumentos, que são a posição x do texto, posição y do texto, largura limite do texto, altura limite do texto, e o texto (em string, ou seja, dentro de aspas).
Agora é a sua vez, tente modificar o texto, a altura e largura da janela!
2 –Modificando a Janela
Não podemos ficar só nessa besteirinha de olá mundo, vamos avançar mais agora.
Vamos começar criando um novo método para colocar tudo de útil nele, para evitar bagunça em um só método.
class Window_Teste < Window_Base def initialize
super(200, 200, 200, 100)
self.contents = Bitmap.new(self.width-32, self.height-32) desenhar_texto("Texto como parâmetro.")
end
def desenhar_texto(text)
self.contents.draw_text(0, 0, 180, 24, text) end
end
Bem, o que aconteceu foi que eu criei um novo método, desenhar_texto, e esse método pede um argumento, que é uma variável, no caso string. Vamos por algo a mais, embaixo do
self.contents coloque o código:
actor = $game_actors[1]
desenhar_texto("O HP do herói é: #{actor.hp}")
Agora teste o jogo. Veja que legal! Agora podemos colocar uma variável no texto. Para isso, basta usar o código #{var} dentro da string.
Tente agora usar o mesmo texto mudando o tipo para SP, agilidade, força, etc. Tente também colocar o valor de uma variável, que no caso seria: var = $game_variables[X], onde X é o ID dela.
3 –Melhorando a Janela
Agora vamos fazer uma coisa bem mais legal! Copie o código abaixo e teste-o.
class Window_Teste < Window_Base def initialize
super(200, 150, 200, 230)
self.contents = Bitmap.new(self.width-32, self.height-32) refresh end def refresh pos_y = 0 for i in 1..4 actor = $game_actors[i]
self.contents.draw_text(0, pos_y, 200, 24, "HP de #{actor.name} = #{actor.hp}")
pos_y += 20
self.contents.draw_text(0, pos_y, 200, 24, "SP de #{actor.name} = #{actor.sp}")
pos_y += 30 end
end end
Viu que legal? O comando ‘for’é muito útil para escrevermos repetidas vezes uma coisa, que
nesse caso foi o texto referente ao HP e MP dos personagens. Ele pega os valores de 1 a 4 e atribui a variável actor cada personagem, ou seja, a variável i terá os valores de 1 a 4 . E dentro do ‘for’, segue-se a sequência do exemplo anterior a esse. Outra coisa a se notar é a
presença de uma variável de espaçamento, pos_y, que é aumentada toda vez para evitar que cada texto fique por cima de outro.
Bom, agora é com você, use sua criatividade para fazer novas combinações e estilos de janela, usando o comando for e novos métodos.
Tente por exemplo, fazer o for com os nomes dos inimigos ($game_enemies[x].name), ou com itens ($data_items[x].name), enfim, consulte o arquivo Help do RGSS para ver os métodos dessas classes de dados.
COMANDOS
1 –Introdução
Não podemos ficar só nos textos e comandos simples, vamos partir para o lado mais
característico, os comandos das janelas. Eles são os responsáveis por deixá-las numa posição X/Y, aumentar/diminuir a largura, mudar a fonte do texto, mudar a opacidade, etc.
Já que vamos usar muito os comandos, vamos primeiro deixar a janela estática infinitamente no mapa. Para isso, usando a janela anterior, vá ao script Scene_Map, no def main, abaixo de @message_window escreva: @window_teste = Window_Teste.new –Mais embaixo, onde tiver @message_window.dispose, coloque @window_teste.dispose –E no def update, onde tiver @message_window.update, @window_teste.update.
Isso faz com que a janela fique parada lá no mapa, e suma quando a cena for outra.
2 –Métodos
dispose: Esse método remove a janela, causará um erro se ela já for apagada. Para
isso, recomenda-se usar o @janela.dispose unless @janela.disposed?
disposed?: Esse método retorna true se a janela foi apagada. update: Atualiza a janela e o seu conteúdo.
3 –Propriedades
windowskin: Muda a windowskin da janela.
o self.windowskin = RPG::Cache.windowskin(“nome da windowskin”)
contents: Refere-se a Bitmap, usada no conteúdo da janela. active: Alterna o cursor para Ligado/Desativado (true/false)
o self.active = true/false
visible: Alterna a visibilidade total da janela para Tudo/Nada (true/false)
o self.visible = true/false
x: Muda a posição x da janela.
o self.x = n
y: Muda a posição y da janela.
o self.y = n
width: Muda a largura da janela.
o self.width = n
height: Muda a altura da janela.
o self.height = n
z: Muda a prioridade da janela, quanto mais, maior a prioridade sobre outros objetos.
o self.z = n
opacity: Muda a opacidade da janela.
o self.opacity = n (0 <= n <= 255)
