Forums » RGSS

Aula 10: Complementos

    • 683 posts
    4 de junho de 2015 13h14min19s ART

    Imagem Postada

    Imagem Postada

    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.

    Imagem Postada


    Imagem Postada

    Herança
    Até agora, todas as nossas classes foram criadas no modo:
    class
    Se você olhar pelos scripts do rmxp, vai notar que em alguns pontos você vai encontrar isso:
    class “<”
    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:

    #################### Lampada Base    ####################classLampada_Base   #Construtor   def initialize     @estado=false   end   #Acender   def acender     @estado=true   end   #Apagar   def desligar     @estado=false   end   #Esta ligada?   def esta_ligada?     returntrueif@estado     returnfalse   endend

    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:

    classLampada_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+=1if@nivel<10   end   #Diminuir Intensidade   def diminuir_intensidade     @nivel-=1if@nivel<10   end   #Esta ligada?   def esta_ligada?     returntrueif@estado     returnfalse   end   #qual a intensidade?   def intensidade     return@nivel   endend

    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:

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

    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?
    Imagem Postada

    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!

    Imagem Postada


    Imagem Postada

    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!

    Imagem Postada

    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:

    classLampada_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?     returntrueif@estado     returnfalse   endend

    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:

    classLampada_Base   #Construtor   def initialize     @estado=false   end   #Acender   def acender     @estado=true   end   #Apagar   def desligar     @estado=false   end   #Esta ligada?   def esta_ligada?     returntrueif@estado     returnfalse   end   public:initialize   protected:acender,:desligar   private:esta_ligada?end

    Imagem Postada


    Imagem Postada

    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???

    Imagem Postada


    Imagem Postada

    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

    Imagem Postada


    Imagem Postada

    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!

    Imagem Postada


    Tags de busca

    • RGSS
    • Hash
    • xor
    • then