Aldeia RPG

Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Suporte ao desenvolvimento de jogos


    Aula 10 - Complementos

    MickeyRocknn
    MickeyRocknn
    Iniciante
    Iniciante


    Mensagens : 71
    Créditos : 9

    Aula 10 - Complementos Empty Aula 10 - Complementos

    Mensagem por MickeyRocknn Sáb Abr 28, 2012 1:30 pm

    Vi Esta Aula No Aprendiz RPG É Vou Disponibilizar Aqui. Criador: Lucaswf1

    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.


    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 #
    ###################
    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:


    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:


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


    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!

    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:


    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


    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:


    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


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


    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


    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!

      Data/hora atual: Sex Mar 29, 2024 3:45 am