ÍNDICE DE TÓPICOS Unidade 1 - Sintaxe
ANTES DE COMEÇAR o O Ruby o O RGSS o Scripts o O Editor de RGSS o Sintaxe o Revisão VARIÁVEIS o Introdução o Tipos o Valores OPERADORES o Introdução o Uso o Outras Formas ESTRUTURA DE FLUXO o Introdução o Condicionais o Looping o Outros CLASSES E MÉTODOS o Introdução o Classes o Módulos o Métodos
03
06
09
13
18
Unidade 2 - Janelas
ANTES DE COMEÇAR o Introdução o Identificação o Tipos o Estrutura MÃOS À OBRA o Criando uma janela o Modificando a janela o Melhorando a janela COMANDOS o Introdução
25
27
30
ÍNDICE DE TÓPICOS Unidade 1 - Sintaxe
ANTES DE COMEÇAR o O Ruby o O RGSS o Scripts o O Editor de RGSS o Sintaxe o Revisão VARIÁVEIS o Introdução o Tipos o Valores OPERADORES o Introdução o Uso o Outras Formas ESTRUTURA DE FLUXO o Introdução o Condicionais o Looping o Outros CLASSES E MÉTODOS o Introdução o Classes o Módulos o Métodos
03
06
09
13
18
Unidade 2 - Janelas
ANTES DE COMEÇAR o Introdução o Identificação o Tipos o Estrutura MÃOS À OBRA o Criando uma janela o Modificando a janela o Melhorando a janela COMANDOS o Introdução
25
27
30
o o
Métodos Propriedades
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, este comentário é bem longo e
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 case
elsif end
module next
retry return
unless 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). O que é um argumento?
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). Variáveis locais e Métodos
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á”
p 10+15
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 pseudovariá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
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 =~
!~
-> -> -> -> -> -> ->
Comparação E Ou Range Operador de condição Negação E, ou
2 - Uso Operadores são usados em expressões, ou seja, qualquer conta que fi zermos 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 @b if if
= true = false @a == true or @b == true then end @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
>, >=, b or c = 10 if hp == maxhp
# se a maior que b ou c menor/igual a d # se 4 menor que x e z maior/igual a 10 # 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.
3 - Outras formas
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’.
Não é necessário o uso do else, apenas se você quiser.
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 when 1,2,3
# 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 = 100 Agora o for, talvez o comando mais conhecido. Ele faz determinada ação x vezes.
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
[email protected] 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 RPG::Cache.windowskin(@windowskin_name)
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 Window_Base.
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
variável da classe Game_Actor que representa o nome do personagem , que é o texto em si, ou
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 modifi cadas. 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 attr_reader attr_reader attr_reader attr_reader attr_reader
:name :character_name :character_hue :class_id :weapon_id :armor1_id
attr_accessor :timer attr_accessor :timer_working attr_accessor :save_disabled
# # # # # #
Nome Nome do Herói Cor do Herói ID da classe ID da Arma ID do Escudo
# Temporizador # Flag do processo de temporização # 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
Game_Actor que permite mudar de nome.
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
linguagem para obter o fim desejado.
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 Largura: 50 pixels
Posição Y: 150 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]) O primeiro argumento é a largura da janela, o segundo (uma array) são os comandos.
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 ‘
