[Autor: Anderson Porto]
Introdução
Para hoje eu preparei uma aula diferente, alguns dos comandos que vou apresentar não são conhecidos por muita gente, outros, os scripters estão carecas de saber. Para iniciar, um conteúdo básico.

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]Herança
Até agora, todas as nossas classes foram criadas no modo:
class <nome da classe>
Se você olhar pelos scripts do rmxp, vai notar que em alguns pontos você vai encontrar isso:
class <nome da classe> “<” <nome de outra classe>
Isso é o nosso recurso dessa 1ª parte da aula, em várias linguagens, para não dizer todas, as linguagens orientadas a objetos, é possível se utilizar das heranças para economizar tempo e linhas de programação.
Qual o objetivo? O objetivo de utilizar essa ferramenta é injetar dentro de uma classe os métodos de outra, vamos a um exemplo prático:

Código:

###################
# Lampada Base    #
###################
class Lampada_Base
  #Construtor
  def initialize
    @estado = false
  end
  #Acender
  def acender
    @estado = true
  end
  #Apagar
  def desligar
    @estado = false
  end
  #Esta ligada?
  def esta_ligada?
    return true if @estado
    return false
  end
end


Acho que no nível em que vocês estão já conseguem perceber como essa classe funciona certo? O atributo @estado é que determina se a lâmpada está ou não ligada, como da pra ver, @estado é um objeto do tipo booleano, só assume então, true ou false.
Vejamos agora outro exemplo:

Código:

class Lampada_Dimmer
  #Construtor
  def initialize
    @estado = false
    @nivel = 0
  end
  #Acender
  def acender
    @estado = true
  end
  #Apagar
  def desligar
    @estado = false
  end
  #Aumentar Intensidade
  def aumentar_intensidade
    @nivel += 1 if @nivel < 10
  end
  #Diminuir Intensidade
  def diminuir_intensidade
    @nivel -= 1 if @nivel < 10
  end
  #Esta ligada?
  def esta_ligada?
    return true if @estado
    return false
  end
  #qual a intensidade?
  def intensidade
    return @nivel
  end
end


O que eu quero mostrar aqui é, veja que as duas classes são muito parecidas, em ambas eu usei o atributo @estado, a diferença é que a 1ª lâmpada é mais simples, só acende e apaga e a 2ª ainda pode aumentar e diminuir o nível, mas ambas tem métodos iguais. Assim então eu posso utilizar o modelo de herança na classe mais complexa e assim a classe Lampada_Dimmer fica:

Código:

class Lampada_Dimmer < Lampada_Base
  #Construtor
  def initialize
    @estado = false
    @nivel = 0
  end
  #Aumentar Intensidade
  def aumentar_intensidade
    @nivel += 1 if @nivel < 10
  end
  #Diminuir Intensidade
  def diminuir_intensidade
    @nivel -= 1 if @nivel < 10
  end
  #qual a intensidade?
  def intensidade
    return @nivel
  end
end


Note que todos os métodos que as classes tinham em comum foram retirados, o único que ficou foi o construtor que eu adicionei uma nova informação. Nesses casos dizemos que a classe Lampada_Dimmer é filha da classe Lampada_Base. Teste por você mesmo, faça um evento no seu mapa e em chamar script, coloque:
lampada = Lampada_Dimmer.new
lampada.acender
p lampada.esta_ligada?

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem] Note que estou usando métodos que nós retiramos da classe Lampada_Dimmer, o que aconteceu é que nós injetamos nela todos os métodos da classe que é “pai dela” e por isso eles estão la, mesmo sem nós os digitarmos!
Para usar esse recurso, lembre-se que o nome dos atributos tem que ser iguais!

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]Permissões
Este conteúdo é mais para fins de curiosidade.
Quando eu comecei a estudar Java, percebi que tinha uma coisa um tanto básica que não estava visível no rgss, por isso eu corri atrás e descobri como usar, porém nossos scripts são de código aberto e por isso não precisamos desse recurso, mas aprendê-lo não tira pedaço.
O que é isso? Um dos recursos da programação orientada a objetos é o poder de limitar o uso de métodos e atributos em outras classes, ou seja, eu posso proibir que um método seja alterado em outra classe!

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]Como usar?
Basicamente são 3 comandos: public, private e protected.
>public: esse modo é o utilizado em todos os métodos por “default”(padrão), significa que qualquer classe pode utilizar ele.
>private: esse modo serve para bloquear um método de ser utilizado em outras classes, sendo assim, ele só pode ser usado na própria classe que foi criado.
>protected: é como o private, porém, todas as classes “filhas” daquela, podem utilizar o método em questão.
Para usar esses comandos, basta colocálos por blocos, ou seja, quando você escrever public, todos os métodos abaixo dele serão búblicos até que um novo nome seja colocado, vamos a um exemplo:

Código:

class Lampada_Base
  #Construtor
  public
  def initialize
    @estado = false
  end
  protected
  #Acender
  def acender
    @estado = true
  end
  #Apagar
  def desligar
    @estado = false
  end
  private
  #Esta ligada?
  def esta_ligada?
    return true if @estado
    return false
  end
end


Nossa classe Lampada_Base recebeu agora os nossos atributos, do modo que eu classifiquei os métodos temos:
initialize > public
acender > protected
desligar > protected
esta_ligada? > private
Seguindo essa lógica, você poderá criar uma lâmpada usando o Lampada_Base.new pois o initialize é publico (coloquei público o construtor, porém, os construtores devem ser deixados públicos, ou você não poderá criar instâncias da classe)
Os métodos para acender e desligar ficaram do tipo protected e assim, eu não posso usar La no meu mapa o comando:
lampada = Lampada_Base.new
lampada.acender
Se fizer isso vai gerar um erro. Porém, se você rodar a classe Lampada_Dimmer e tentar usar o método dentro dela vai conseguir, mas não conseguirá isso também.
lampada = Lampada_Dimmer.new
lampada.acender
Já com o método esta_ligada?, ele só pode ser usado dentro da classe Lampada_Base

Você também pode estabelecer métodos públicos, privados e protegidos declarando eles no fim da classe, ou seja:

Código:

class Lampada_Base
  #Construtor
  def initialize
    @estado = false
  end
  #Acender
  def acender
    @estado = true
  end
  #Apagar
  def desligar
    @estado = false
  end
  #Esta ligada?
  def esta_ligada?
    return true if @estado
    return false
  end
  public :initialize
  protected :acender, :desligar
  private :esta_ligada?
end


[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]O XOR
Xor é um operador lógico como o or e o and, eu só uso esse comando em Java e não consegui usá-lo escrevendo xor, mas você pode usá-lo simbolicamente com um ^. Ele é um "ou" exclusivo, ou seja, para que seja verdadeira a proposição, você precisa que uma e apenas uma das premissas estejam válidas, exemplos..:
true or false é true
false or false é false
true or true é true

Agora usando o xor
true ^true é false
false ^false é false
true ^false é true

Basicamente, quando você usa “if a || b”, quer dizer, se a for verdade ou b for verdade faça o que tem a seguir, no xor fica, “if a ^b”, que equivale dizer: se, ou a for verdade, ou b for verdade, faça... Entenderam???

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]O then
Este comando serve para economizar linhas do script, veja o código abaixo.
if 1 + 1 == 2
p “eu sei somar!”
end
Idiota né, mas vamos la, a condição diz que se 1 + 1 for 2 então mostra na tela “eu sei somar!”. Sempre que você quiser fazer apenas uma coisa dentro da condição, ou seja, eu só quero mostrar uma mensagem e mais nada, você pode escrever isso tudo em uma linha, desse jeito:
if 1 + 1 == 2 then p“eu sei somar!” end
Note que eu liguei a condição ao comando com o then e por fim, finalizei com o end. É um comando simples, mas bem interessante. Lembrando que esse código pode ser escrito da forma:
p "eu sei somar!" if 1 + 1 == 2

[Tens de ter uma conta e sessão iniciada para poderes visualizar esta imagem]O hash
Hash é como um array, só que mais bem elaborado. Ele funciona como um banco de dados, associando um dado a outro. Criar um hash é como criar um array, mas ao invés de usar [], você usa {}, a diferença maior é que em um array você tem posições e a cada posição tem um dado, no hash você coloca o dado e a posição.

Comparando
No array:
lista = []
lista[0] = 6
lista[10] = 2
p lista #vai imprimir na tela: [6,nil,nil,nil,nil,nil,nil,nil,nil,nil,2]

No hash
lista = {}
lista[0] = 6
lista[10] = 2
p lista #vai imprimir na tela: {0=>6,10=>2}

As diferenças não param por ai, em um hash, você pode associar strings como posição!
lista = {}
lista[0] = 6
lista[10] = 2
lista[“ola”] = 45
Você pode associar até uma classe!
lista[Scene_Map] = “q legal isso!”

Basicamente, você pode colocar qualquer coisa dentro de um hash e para acessar os dados, use exatamente como em uma array, coloque o nome do objeto, seguido de um [], dentro do [] coloque o endereço do dado dentro do hash (pode ser qualquer coisa e não só números como no array). Você pode criar um array e colocar dados da forma: {endereço=>valor,endereço=>valor,...} ou também: {endereço1, valor1, endereço2, valor2}. Essa é uma bela ferramenta que vocês podem usar e abusar!