Rpg Lab
Você é membro? Logue-se agora!

Se não for, registre-se agora também ^^
Não perca esta chance, faça parte deste forum e ajude a melhorá-lo
cada vez mais!


Atenciosamente: Admin do Forum RPG Lab.

Rpg Lab

RPG não é hobbie...é um estilo de vida!
 
InícioPortal RPG LabCalendárioFAQBuscarMembrosGruposRegistrar-seConectar-se
Conectar-se
Nome de usuário:
Senha:
Conexão automática: 
:: Esqueci minha senha
Membro do Mês | RPG Lab - Setembro

Paulo_Soldera - Parabéns pela sua colaboração com o forum!

Membro do Mês - Setembro

Últimos assuntos
» VAMOS REVIVER O FORUM!
Qui Jun 28, 2012 9:44 pm por Final League

» Hey, pra que isso ?
Sex Dez 30, 2011 6:49 pm por kauan

» Alguem ai tem um DS?
Ter Out 20, 2009 5:53 pm por kauan

» Parabens Jutsoo!
Ter Out 20, 2009 5:51 pm por kauan

» Membro do Mês de Setembro - Paulo_Soldera!
Sex Set 04, 2009 6:02 pm por Alessandro_Trigger

» Andamento do SSN
Sex Ago 21, 2009 7:50 pm por Paulo Soldera

» Pack de animações
Sab Ago 08, 2009 7:53 pm por Yoshi

» Personagens do rtp com efeito transparente
Sab Ago 08, 2009 1:51 pm por Yoshi

» Pack com uns 300 efeitos sonoros
Sab Ago 08, 2009 1:49 pm por Yoshi

Estatísticas
Temos 150 usuários registrados
O último usuário registrado atende pelo nome de xxhitmontop

Os nossos membros postaram um total de 714 mensagens em 143 assuntos
Top dos mais postadores
Alessandro_Trigger
 
kauan
 
Duvidoso
 
felipehenrique
 
Kurosaki-kun
 
Yoshi
 
Paulo Soldera
 
Snake Death
 
dodoop
 
ammy
 

Compartilhe | 
 

 [Aula-LB]Guia prático rápido de RGSS e RGSS2

Ir em baixo 
AutorMensagem
Alessandro_Trigger
Administrador
avatar

Número de Mensagens : 207
Data de inscrição : 15/03/2009
Idade : 25

Mochila
-:
Mensagem do Membro: RPG lab! RPG não é hobbie...é um estilo de vida!

MensagemAssunto: [Aula-LB]Guia prático rápido de RGSS e RGSS2   Sab Maio 09, 2009 1:18 pm

Sérei de tutoriais que ensinam a prgramar em RGSS e RGSS2.
Aulas de LB - Reino RPG.
Créditos totalmente a ele.




Este tutorial é baseado no tutorial "Ruby em Vinte Minutos" da "ruby-land.org". ( http://www.ruby-lang.org/pt/documentacao/ruby-em-vinte-minutos/ )
Várias modificações foram feitas para adaptar ao RGSS/RGSS2. Espero que gostem!




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!

Uma Máquina Calculadora gratuita


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.

As Breves e Repetitivas Vidas de um Método


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.

[size=18pt]Tudo em Sequencia[/size]

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

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!





Scripts RGSS2 for RPG Maker VX by LB is licensed under a
Creative Commons Atribuição-Uso Não-Comercial-Compartilhamento pela mesma Licença 2.5 Brasil License.
Permissions beyond the scope of this license may be available at ReinoRPG.com

_________________

Voltar ao Topo Ir em baixo
Ver perfil do usuário http://rpglab.forumeiros.com
 
[Aula-LB]Guia prático rápido de RGSS e RGSS2
Voltar ao Topo 
Página 1 de 1
 Tópicos similares
-
» 1º Aula de Script - Colocar um aviso ao iniciar o jogo
» Aulas de Pixel Art do Leonardo - Aula 1 - Criação de chars - Cabelo
» #01 Aula Sonoplasta Basico.
» [VIDEO AULA] Sistema de Rank com PHP + Mysql
» [Aula/Tutorial] Sistema de Ferreiro

Permissão deste fórum:Você não pode responder aos tópicos neste fórum
Rpg Lab :: Mundo RPG Maker - XP/VX :: Programação Geral :: Programação RGSS-
Ir para: