[Aula RGSS] - Classes, Métodos e Variáveis.

1 - Introdução
Na aula anterior, vimos o básico do básico, mas já demos um passo para evoluir no RGSS.
Nesta aula aprenderemos sobre a importância da organização do script, as classes e suas variáveis.

2 - Organização

A organização de um script é muito importante para o próprio desenvolvedor deste. Um script bem organizado significa mais clareza na hora da edição.
Qual script você acha mais fácil de ler e de entender?

Código:

class Teste
def initialize
@a = 10
@b = 10
end
def lalala
....
if @a==10
@b=20
end
end
end

ou

Código:

class Teste
 
  #--------------------------------
  # Inicialização
  #--------------------------------
 
  def initialize
    # Váriavel a
    @a = 10
    # Váriavel b
    @b = 10
  end
 
  #--------------------------------
  # Lalala
  #--------------------------------
 
  def lalala
    ....
    if @a == 10
      @b = 20
    end
  end
 
end

Então! Não tenha medo (nem preguiça) de usar espaços (Ou a tecla TAB para um parágrafo mesmo) e comentários. Esse exemplo foi pequeno ainda imagina agora em um script de 1000 linhas.


3 - Variáveis

As variáveis servem para armazenar dados. Nada mais e nada menos que isso.

3.1 - Tipos de variáveis

Sim, as variáveis só tem essa função mesmo porém há diversos tipos de variáveis como por exemplo:
- Variáveis locais
- Variáveis Públicas
- Variáveis de classe
- Variáveis Globais

3.1.1 - Variáveis locais

Servem somente para ser lida naquele método não podendo ser acessadas em outros métodos das classes (Veja mais a frente o que é Método e Classe)
Ela é representada da seguinte maneira

Código:

variavel = valor

2.1.2 - Variáveis Públicas

Estas variáveis podem ser lidas e acessadas na classe que foi criada.
Ela é representada da seguinte maneira

Código:

@variavel = valor

3.1.3 - Variáveis de classe

Estas variáveis podem ser lidas e acessadas em todas as classes do MESMO TIPO.
Ela é representada da seguinte maneira

Código:

@@variavel = valor

2.1.4 - Variáveis Globais

Estas variáveis podem ser lidas e acessadas em qualquer local.
Ela é representada da seguinte maneira

Código:

$variavel = valor

2.1.5 - Diferença entre as classes

A diferença entre essas classes é a quantidade de memória usada para cada tipo e conseqí¼entemente altera no desempenho do script.
Portanto, não saia lotando um script com variaveis globais se elas não são utilizadas.

3 - Constantes

Constantes são INVARIíVEIS ou seja, elas são inciadas no editor de script e não podem ser alteradas em nenhum método porém podem ser lidas.
Elas sempre começam com letra maiuscula.

Código:

CONSTANTE = valor

4 - Classes e Métodos

Classes são todo e qualquer objeto dentro do RM.

4.1 - Classes mais utilizadas e suas funções:

4.1.1 - Integer (Números inteiros - Ex: 10, -110)
Utilizadas para fazer desde simples contas até loops (Veja mais a frente o que são loops)
Entre seus métodos(Veja item 4.2 para saber o que são métodos) podemos destacar o +(soma) -(subtração) *(multiplicação) /(divisão) **(Exponenciação) < (Menor que) <= (Menor igual que) > (Maior que) >= (maior ou igual que)

Código:

    # Soma
    p 10 + 10 # => 20
    p 10 + 2  # => 12
    # Subtração
    p 10 - 10 # => 0
    p 10 - 20 # => -10
    # Multiplicação
    p 10 * 10 # => 100
    p -2 * 10 # => -20
    # Divisão
    p 5 /  10  # => 0  # Este é um resultado interessante pois a classe Integer não aceita valores quebrados
    p 5 /  10.0 # => 0.5 # Neste caso foi usado um Float
    # Integer / Integer = Integer
    # Integer / Float = Float
    p 10 /  10  # => 1
    # Exponenciação
    p 10 ** 2  # => 100
    p 10 ** 10 # => 10000000000
    # Maior que
    p 10 > 2  # => true
    p 10 > 10  # => false
    p 10 >= 10 # => true
    # Menor que
    p 10 < 2  # => false
    p 10 < 10  # => false
    p 10 <= 10 # => true
    # .to_f (Transforma integer em Float)
    p 10.to_f  # => 10.0

4.1.2 - Float (Números fracionais - Ex: 10.0, -8.5746)
Utilizados para contas mais complexas. Métodos iguais ao da classe anterior.

Código:

    # Arredondamento
    p 10.4.round # => 10
    p 10.6.round # => 11
    # Arredondamento para menos
    p 10.4.truncate # => 10
    p 10.9.truncate # => 10
    p 10.0.truncate # => 10
    # Arredondamento para mais
    p 10.4.ceil # => 11
    p 10.9.ceil # => 11
    p 10.0.ceil # => 10

4.1.3 String (Textos - Ex: "Texto")
Utilizados para indicar texto.
Métodos mais comums

Código:

  a = "texto"
    b = "1000"
    # Métodos
    p a + b # => "texto1000"
    p a * 2 # => "textotexto"
    p a.upcase # => "TEXTO"
    a.upcase!
    p a # => "TEXTO" # Verifique que ele continua com letras maiusculas graças ao método .upcase!
    p a.downcase # => "texto"
    a.downcase!
    p a # => "texto" # Verifique que ele continua com letras minusculas graças ao método .downcase!
    p b.to_i # => 1000 # Torna o texto um numero inteiro

4.1.4 - Arrays e Hashs

As Arrays e Hashs tem a capacidade de armazenar inumeras váriáveis e são representadas da seguinte maneira:

Código:

# Array
    variavel_array = []
    # Hahs
    variavel_hash = {}

Elas armazenam diversas variáveis da seguinte maneira.

Código:

 variavel_array = []
    # variavel_array[indicador] = valor
    variavel_array[0] = "Texto"
    variavel_array[1] = 10
    p variavel_array[0] # => "Texto"
    p variavel_array[1] # => 10
    p variavel_array[2] # => nil (Classe nula do jogo, não representa nada)

Porém, os indicadores das arrays só podem ser Integers e não é o que acontece nas Hashes.

Código:

  variavel_array = []
    variavel_array["LALA"] = 10 # Causará um erro

Código:

variavel_hash = {}
    variavel_hash["LALA"] = 10 # Não ocorrerá erro

Nas hashes os indicadores podem ser qualquer classe existente no RPG Maker.

4.1.5 - Boolean

Representa o verdadeiro e o falso (true ou false) e são utilizadas na maioria das vezes em condições

4.2 - Métodos

Métodos são chamados para executar certa rotina que ocorre em uma classe.
Ex:

Código:

  classe Teste
   
      #----------------------------
      # O Método initialize acontece toda vez que a classe é criada
      #----------------------------
     
      def initialize
        @a = 10
      end
   
      #----------------------------
      # Ao chamar o método abaixo ele exibe o valor de A
      #----------------------------
     
      def valor_de_a
        p @a
      end
     
    end
   
    variavel = Teste.new
    variavel.valor_de_a # => 10

Os métodos também podem utilizar argumentos

Código:

  classe Teste
   
      #----------------------------
      # O Método initialize acontece toda vez que a classe é criada
      #----------------------------
     
      def initialize
        @a = 10
      end
   
      #----------------------------
      # Ao chamar o método abaixo ele exibe o valor de A + argumento
      #----------------------------
     
      def valor_de_a_mais_argumento(argumento)
        p @a + argumento
      end
     
      #----------------------------
      # Ao chamar o método abaixo ele exibe o valor de A + argumento
      # Caso não defina o argumento, ele será 0
      #----------------------------
     
      def valor_de_a_mais_argumento_indefinido(argumento=0)
        p @a + argumento
      end
     
    end
   
    variavel = Teste.new
    variavel.valor_de_a_mais_argumento(0)            # => 10 + 0 = 10
    variavel.valor_de_a_mais_argumento(10)            # => 10 + 10 = 20
    variavel.valor_de_a_mais_argumento_indefinido    # => 10 + 0 = 10
    variavel.valor_de_a_mais_argumento_indefinido(0)  # => 10 + 0 = 10
    variavel.valor_de_a_mais_argumento_indefinido(10) # => 10 + 10 = 20

5 - Procedimentos Comuns

5.1 - == (Igual) e != (Diferente)

O simbolo == compara duas coisas e retorna true se for igual e false se for diferente.

Código:

  a = 10
    p (a == 10) # => true
    p (a == 8) # => false
    p (a != 8) # => true
    p (a != 10) # => false

5.2 - if / elsif / else

if representa a condição se
exemplo:

Código:

  # Se isso for verdadeiro
    if true
      # Acontece isso
    # Se não for verdadeiro a primeira condição mas essa for
    elsif true
      # Acontece isso
    # Se nenhuma for verdadeiro
    else
      # Acontece isso
    end

Um exemplo mais detalhado

Código:

 
    a = 10
    b = 10
    c = 10
    # Se a for igual a b
    # VEJA QUE Usamos == pois não estamos definindo valor e sim comparando.
    if (a == b)
      p "a é igual a b"
    # Se a for igual a b
    elsif (b == c)
      p "b é igual a c mas a é diferente de b"
    else
      p "a é diferente de b que é diferente de c"
    end
    # Se a for igual a c
    if (a == c)
      p "a é igual a c
    end

Agora mude os valores de a e b e teste novemente. Viu!

5.3 - unless

Unless siginifica a menos que e representa o que acontece a menos que (condição):
Ex:

Código:

# Se não for verdade
    unless true
      # Acontece isso
    # Se for verdade
    else
      # Acontece isso
    end

Exemplos mais detalhados:

Código:

 a = 10
    # Se a não for igual a 10
    unless (a == 10)
      # Acontece isso
      p "a é diferente de 10"
    # Se for verdade
    else
      # Acontece isso
      p "a é igual de 10"
    end

5.4 - Loops
Loops executam uma sequencia de procedimentos repetidos várias vezes.

5.4.1 - break
Caso deseje parar o loop em qualquer ocasião use o comando break

5.4.2 - For / next
For é um dos vários tipos de loop que existe.
Teste esse exemplo para melhor entender.

Código:

# Para i sendo 0 até 10
      for i in 0..10
        p i # => 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
      end

Agora um exemplo mais avançado

Código:

      # Para i sendo 0 até 10
      for i in 0..10
        # Se i for igual a 2
        if i == 2
          # Pula esse item
          next
        end
        # Se i for igual a 7
        if i == 7
          # Termina o loop
          break
        end
        p i # => 0, 1, 3, 4, 5, 6
      end

5.4.3 - While
O while siginifica enquanto e representa um loop que acontece enquanto for verdadeiro.
Exemplos:

Código:

    # Enquanto for verdadeiro
      while true
        # Acontece isso
      end

O uso dele é variado e segue um exemplo mais complexo

Código:

  a = 0
      # Enquanto a for menor que 10
      while (a < 10)
        # Soma 1 a variavel a
        a += 1 # a += 1 é a mesma coisa que a = a + 1
        p a # => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
      end

5.4.4 - loop

O loop é um comando que acontece os eventos repetidamente até ser usado o break.

Código:

 loop do
        # Isso nunca vai parar de acontecer
      end

Um exemplo de uso

Código:

a = 10
      loop do
        # Isso nunca vai parar de acontecer
        a += 1
        # Se a for maior que 10
        if a > 10
          # Para o loop
          break
        end
      end

6 - Finalizando

Pronto, chega por essa aula. Espero vocês na próxima aula