Guia prático de RGSS/RGSS2

Primeiro Programa

Abra o RPG Maker e inicie um novo projeto. Abra o Editor de Scripts e adicione um novo script acima de todos os outros. Nele escreva:

Código:

p "Olá Mundo!"

Dê OK e Teste o projeto. Olhe o resultado! Uma janela dizendo olá ao mundo!

[size=20pt]Uma Máquina Calculadora gratuita[/size]

Código:

p 3+2

Três mais dois. Suficientemente fácil. E então três vezes dois? Pode escrevê-lo:

Código:

p 3*2

De seguida vamos tentar três ao quadrado:

Código:

p 3**2

No RGSS ** é a forma de dizer potência de. Mas o que acontece quando queremos saber o inverso disto ou seja a raiz quadrada de algo?

Código:

p Math.sqrt(9)

Muito bem, o que aconteceu aqui atrás? Se disse “que estava a determinar a raiz quadrada de nove” então está correto. Mas vejamos as coisas com mais pormenor. Primeiro de tudo, o que é Math?

Módulos, Agrupar Código por Tópico

Math é um módulo nativo para funções matemáticas. Os módulos têm dois papeis no RGSS. Este é um desses papeis: agrupar métodos semelhantes em conjunto sobre um nome familiar. Math também contém métodos como sin() e tan().

Depois segue-se um ponto final. O que faz o ponto? O ponto final é como se identifica o receptor de uma mensagem. Qual é a mensagem? Neste caso é sqrt(9), o que significa chamar o método sqrt, uma abreviatura em língua inglesa para “square root (raiz quadrada)” com o parâmetro 9.

O resultado desta chamada de método é o valor 3.0. Se repararmos bem, o resultado não é apenas 3. Mas isso deve-se ao facto da raiz quadrada de um número na maioria dos casos não ser um inteiro e, assim sendo, o método retorna sempre um número de vírgula flutuante.

E se nos quisermos lembrar do resultado desta matemática toda? Podemos atribuir o resultado a uma variável.

Código:

a = 3 ** 2
p a
b = 4 ** 2
p b
p Math.sqrt(a+b)

Como calculadora isto é muito bom mas nós estamos a afastarmos-nos da mensagem mais tradicional Olá Mundo que os guias de iniciação normalmente focam portanto vamos voltar ao assunto.

E se quisermos dizer “Olá” varias vezes sem cansar os dedos? Temos que definir um método!

Código:

def h
  p "Olá Mundo!"
end

O código def h começa a definição do método. Diz ao Ruby que estamos a definir um método, cujo nome é h. A linha seguinte é o corpo do método, a mesma frase que vimos antes: p "Olá Mundo!". Finalmente, a última linha end diz ao Ruby que terminamos a definição do método.

[size=20pt]As Breves e Repetitivas Vidas de um Método[/size]

Agora tentemos usar o método algumas vezes:

Código:

h

h()

Bem, esta foi fácil. Chamar um método no RGSS é bem fácil. Se o método não tiver parâmetros é tudo o que precisamos. Podemos também colocar os parênteses vazios se desejarmos, porem estes não são necessários.

E se o que queremos é dizer ola a uma pessoa só, e não ao mundo inteiro? Para isso basta redefinir h para que aceite um nome como parâmetro:

Código:

def h(nome)
  p "Olá #{nome}!"
end

h("João")

Parece funcionar… mas vamos pausar um minuto para ver o que se passa aqui.

Reservando espaços numa String

O que significa a expressão #{nome}? É a forma de inserir alguma coisa numa string. Aquilo que se encontra entre chavetas transforma-se numa string (se já não o for) e é substituído naquele ponto da string. Podemos também usar isto para ter a certeza de que o nome de alguém se apresenta em letra maiúscula:

Código:

def h(nome = "Mundo")
  p "Olá #{nome.capitalize}!"
end

h("joão")

h

Podemos encontrar aqui um truque ou dois. Um deles é que estamos a chamar novamente o método sem recorrer aos parênteses. Se aquilo que estamos a fazer for óbvio então os parênteses são opcionais. O outro truque é o parâmetro Mundo usado por omissão. O que isto quer dizer é que “Se o nome não for fornecido, então usamos o nome por omissão Mundo”.

Evoluindo para um Anfitrião

E se quisermos criar um Anfitrião mais “sério”? Um que se lembre do nosso nome, nos dê as boas vindas e nos trate com o respeito devido? Podemos usar um objeto para esse efeito. Vamos então criar, a classe “Anfitrião”.

Código:

class Anfitriao
  def initialize(nome = "Mundo")
    @nome = nome
  end
  def diz_ola
    p "Olá #{@nome.capitalize}!"
  end
  def diz_adeus
    p "Adeus #{@nome.capitalize}, volte sempre."
  end
end

A nova palavra chave aqui é class. Esta define uma nova classe chamada Anfitrião e uma quantidade de métodos para essa classe. E o @nome ? É uma variável de instância e está disponível para todos os métodos da classe. Como podemos ver está a ser utilizada por diz_ola e diz_adeus.

Então como é que pomos a classe Anfitrião em movimento? Criamos um objecto.

Código:

h = Anfitriao.new("joão")

p h.diz_ola

p h.diz_adeus

Uma vez criado o objecto h, ele lembra sempre do nome, no caso João.

Por baixo da pele do objeto

As variáveis de instância escondem-se dentro do objeto. Em outras linguagens não estão assim tão bem escondidas, podem ser vistas quando se inspeciona o objeto, mas o RGSS é fiel aos bons costumes da programação orientada a objetos, mantendo os dados o mais privados possíveis.

Então, que métodos estão disponíveis para os objetos Anfitrião?

Código:

p Anfitriao.instance_methods

Bem. São muitos métodos. Nós só definimos dois métodos. O que é que aconteceu? Bem estes são todos os métodos para o objeto Anfitrião, uma lista completa, incluindo os que estão definidos nas classes superiores de Anfitrião. Se só quisermos listar unicamente os métodos definidos para a classe Anfitrião, podemos pedir-lhe que não inclua os métodos dos seus ancestrais passando-lhe o parâmetro false, que significa que não queremos os métodos definidos pelos seus ancestrais.

Código:

p Anfitriao.instance_methods(false)

Há mais coisas a explorar. Vejamos a que métodos pode responder o nosso objecto Anfitrião:

Código:

p h.respond_to?("nome")
p h.respond_to?("diz_ola")
p h.respond_to?("to_s")

Assim ficamos sabendo se h responde por diz_ola, e to_s (que significa “converter algo numa string”, um método que está definido por omissão para todos os objetos), mas que não reconhece nome como método.

Modificar classes - Nunca é demasiado tarde

E se quiser alterar o nome? O RGSS lhe oferece uma forma fácil de permitir o acesso às variáveis de um objeto.

Código:

class Anfritiao
  attr_accessor :nome
end

No RGSS, podemos voltar a abrir e alterar uma classe. Isso não altera os objetos já existentes, mas afeta os novos objetos que se crie. Assim vamos criar um novo objeto e vamos brincar com a sua propriedade nome.

Código:

h = Anfitriao.new("Pedro")
p h.respond_to?("nome")
p h.respond_to?("nome=")

h.diz_ola

h.nome = "ana"

h.diz_ola

O uso de attr_accessor determina que se tenha definido dois novos métodos: nome para obter o valor, e nome= para o alterar.

Saudar todos, MegaAnfitriao não nega a saudação a ninguém!

De qualquer modo este Anfitrião não é assim tão interessante, só pode trabalhar para uma pessoa de cada vez. O que se passaria se tivéssemos uma classe MegaAnfitriao que pudesse saudar o mundo inteiro, uma pessoa ou uma lista completa de pessoas?

Código:

class MegaAnfitriao
  attr_accessor :nomes

  # Criar o objecto
  def initialize(nomes = "Mundo")
    @nomes = nomes
  end

  # Dizer ola a todos
  def diz_ola
    if @nomes.respond_to?("each")
      # @nomes é uma lista de algum tipo,
      # assim podemos usar o each.
      @nomes.each do |nome|
        p "Ola #{nome}"
      end
    else
      p "Ola #{@nomes}"
    end
  end

  # Dizer adeus a todos
  def diz_adeus
    if @nomes.respond_to?("join")
      # Juntar os elementos à lista
      # usando a vírgula como separador
      p "Adeus #{@nomes.join(", ")}. Voltem em breve."
    else
      p "Adeus #{@nomes}. Volta em breve."
    end
  end

end


  mh = MegaAnfitriao.new
  mh.diz_ola
  mh.diz_adeus

  # Alterar o nome para "Diogo"
  mh.nomes = "Diogo"
  mh.diz_ola
  mh.diz_adeus

  # Alterar o nome para um vector de nomes
  mh.nomes = ["Alberto", "Beatriz", "Carlos", "David", "Ernesto"]
  mh.diz_ola
  mh.diz_adeus

Há uma série de coisas novas neste novo exemplo às quais podemos dar uma observação mais profunda. Podemos notar que algumas linhas começam com um sinal de cardinal(#). No RGSS, qualquer coisa após um sinal de cardinal é considerado um comentário e ignorado pelo interpretador. São chamados de Comentários, usados para dar notas o explicações.

Podemos notar que nosso método diz_ola tornou-se um pouco mais complexo:

Código:

  # Dizer ola a todos
  def diz_ola
    if @nomes.respond_to?("each")
      # @nomes é uma lista de algum tipo,
      # assim podemos usar o each.
      @nomes.each do |nome|
        p "Ola #{nome}"
      end
    else
      p "Ola #{@nomes}"
    end
  end

Ciclos e Voltas

Inicia-se com uma condição, perguntando se @names responde pelo método each, ou seja, se for uma lista de algum tipo. Sendo uma lista ele vai entrar em um loop. Loops são repetições de um bloco de código definido.

Código:

      @nomes.each do |nome|
        p "Ola #{nome}"
      end

Um loop é criado, repetindo o comando p para cada elemento da lista. Nesse loop em particular é usada uma segunda variável, nome, que armazena o valor atual da lista. Dessa forma nome receberá todos os elementos da lista, um de cada vez. Assim pode-se dizer "Olá" para todos eles, independente da quantidade.

Voltando à condição:

Se @nome não for uma lista, será dito "Olá" apenas uma vez, para esse nome.

Tudo em Sequencia

O método diz_adeus é parecido com o diz_ola, mas agora usa o comando join. Dentro da condição (se for uma lista), juntamos todos os elementos da lista, separando-os com virgula. Aparecerão em sequencia. Muito mais simples e bonito do que dizer "olá" para todos os elementos separadamente.

Código:

  # Dizer adeus a todos
  def diz_adeus
    if @nomes.respond_to?("join")
      # Juntar os elementos à lista
      # usando a vírgula como separador
      p "Adeus #{@nomes.join(", ")}. Voltem em breve."
    else
      p "Adeus #{@nomes}. Volta em breve."
    end
  end

LB = Por criar.
Mamber = Por disponibilizar.

Foi um prazer

Pronto, isto foi uma visita rápida ao mundo do Ruby. Existe muito para explorar, mas por enquanto ficaremos por aqui. Até mais!

Po, ta mt bom, só que eu nao entendo nada de scripts.

Zelos Wilder escreveu:Po, ta mt bom, só que eu nao entendo nada de scripts.

Eu tambem não entendo nada!!
Eu tinha decedido fazer o meu próprio Tutorial,mas como eu não sei nada sobre RGSS eu decedi pedir permissão para o LB!!
Creio eu que vou postar uma aula por dia.
Pode até ver que o template de postagem esta diferente de meu costume.

Mamber escreveu:

Zelos Wilder escreveu:Po, ta mt bom, só que eu nao entendo nada de scripts.

Eu tambem não entendo nada!!
Eu tinha decedido fazer o meu próprio Tutorial,mas como eu não sei nada sobre RGSS eu decedi pedir permissão para o LB!!
Creio eu que vou postar uma aula por dia.
Pode até ver que o template de postagem esta diferente de meu costume.

Ok, agora irei sair um pouco do fórum e voltarei lá para umas 21:15 , se voce ja tiver com os tópicos, darei o cargo.

Estou a procura de novos Tópicos!!
Mas creio eu que hoje não da para dar o cargo,já tenho que sair do Pc
Fiquei o dia enteiro