‫Olá e bem-vindo.
‫Nesta palestra, vamos implementar nossas próprias funções de membro de classe, mover plataforma e
‫girar plataforma.
‫Vamos ver como podemos configurá-los para que possam receber argumentos.
‫E isso vai nos ajudar a organizar um pouco nosso código.
‫Vamos mergulhar e ver como isso funciona.
‫Então, até agora, usamos as funções C++ que já foram criadas para nós.
‫Estamos usando take-los e podemos jogar em termos de escrita de suas funcionalidades.
‫E também estamos usando funções que outras pessoas escreveram para nós.
‫Nós os chamamos como obter localização ativa e obter nome.
‫Agora, como podemos criar novas funções próprias para ajudar a organizar nosso código e manter essas funções pequenas
‫e tudo muito mais legível?
‫Bem, já temos os blocos de construção básicos no lugar, chegando ao final da seção.
‫Entendemos muito mais sobre a sintaxe C++.
‫Então, o que eu quero fazer é essencialmente criar uma nova função na plataforma móvel que nos permita
‫ter apenas entrada, digamos, chamar a plataforma móvel.
‫Por que eu quero fazer isso?
‫Bem, porque ser capaz de fazer uma chamada de função como esta chamada MOVE Platform, isso realmente mostra o
‫que estamos tentando fazer no momento.
‫Temos muitas coisas acontecendo em tecnologia e não estou totalmente claro por que estamos fazendo todas essas coisas se eu for
‫dar uma olhada nele, se entrei em tecnologia e vi uma função que diz Move platform , bem, de repente eu
‫tenho o contexto para o que todas essas coisas deveriam estar fazendo, e eu não preciso de um
‫único comentário para me dizer o que está acontecendo.
‫Isso será particularmente útil quando adicionarmos à mistura a possibilidade de girar a plataforma
‫também.
‫Então, como definimos funções de declaração?
‫Bem, o aspecto da declaração é feito no cabeçalho do arquivo.
‫É aí que basicamente dizemos que vamos ao C++, teremos uma função que se parecerá
‫com isso.
‫E então no C++ é onde realmente definimos a função.
‫Damos-lhe o corpo, dizemos-lhe exactamente para C++.
‫É assim que a função funciona.
‫E vamos dar uma olhada em como podemos fazer isso.
‫Temos alguns exemplos de funções e temos muito em jogo, temos tecnologia.
‫E é um bom momento para olharmos para as diferentes seções que temos em um arquivo de cabeçalho.
‫Temos público e protegido sendo mencionado aqui e público sendo mencionado novamente.
‫Agora, o que isso significa?
‫Essas palavras-chave com dois pontos no final basicamente definem uma seção de acessibilidade.
‫Essas funções, de onde podem ser acessadas.
‫Nós vimos mais na segurança normal.
‫Esta é uma função que estamos chamando em um vetor F, mas estamos chamando-a de outra classe, não de dentro
‫de um vetor F.
‫Portanto, isso significa que a acessibilidade dessa função precisa ser pública.
‫Agora vamos deixar de lado protegido só por um minuto porque aí fica um pouco mais complicado.
‫Mas há outro tipo de palavra-chave que podemos usar, que é privada.
‫Então, vou adicionar após take, vou adicionar o aviso de palavra-chave privada de que não recuo essas
‫seções e vamos colocar dois pontos no final.
‫E isso significa que tudo o que vem depois até a próxima seção, a próxima
‫palavra-chave que eu coloco aqui, será privada.
‫Então isso significa que pegamos todas essas variáveis e dissemos, Ei, nenhuma outra classe tem permissão para tocar
‫nelas.
‫E essa é geralmente a melhor prática que não fizemos até agora, porque eu não queria deixar as
‫coisas um pouco confusas demais para você.
‫Mas as variáveis nas classes geralmente devem ser da sua conta.
‫É um dos principais inquilinos da programação orientada a objetos que deixamos as classes para gerenciar suas
‫próprias variáveis, e só as acessamos usando funções que a classe denota como públicas.
‫Então, o que vamos fazer aqui é adicionar mais algumas funções privadas aqui porque não
‫queremos que algo como Move Platform seja chamado de fora da classe.
‫Queremos que seja gerenciado por nossa própria função de tecnologia.
‫Então, como definimos uma função privada?
‫Bem, nós o colocamos em uma seção privada.
‫Então, temos nossa palavra-chave privada aqui.
‫Vou colocá-lo depois de nossas variáveis, no entanto, e começamos com o tipo de retorno.
‫E se nossa função não retornar nada, apenas digitamos void para indicar que não há retorno saindo
‫desta função.
‫Em seguida, damos a ele um nome de função.
‫Então, tivemos que mover a plataforma era o que queríamos e então damos alguns parênteses para indicar que esta é uma função que abrimos e
‫fechamos parênteses e depois um ponto e vírgula para terminar a linha e dizer, ok, é
‫isso.
‫Essa é a função que quero declarar aqui no arquivo de cabeçalho e tudo o que faz.
‫Ele diz Esta é a forma da função.
‫Este é o retorno.
‫Isso é o que os parâmetros são necessários e o nome e a qual classe ele pertence.
‫Agora, para realmente dar uma implementação, temos que defini-la no arquivo C++.
‫Então vamos lá.
‫E no final do arquivo, fora das chaves, é aqui que fazemos.
‫Começamos novamente com o tipo de retorno.
‫Então isso será nulo porque estamos dentro de um arquivo C++, não estamos dentro das chaves de uma
‫classe.
‫Temos que usar o operador de resolução de escopo para dizer que estamos tentando definir uma função de dentro da classe de
‫plataforma móvel.
‫Então digitamos o nome da classe, que é uma plataforma móvel, lembrando que existe um prefixo para dizer que
‫é um ator.
‫Em seguida, usamos dois pontos, dois pontos, o operador de resolução de escopo e, em seguida, usamos o nome
‫da função que estamos definindo, que é a plataforma MOVE.
‫E então usamos o mesmo conjunto de parâmetros que usamos no arquivo de cabeçalho.
‫Neste caso, tínhamos um conjunto vazio de parâmetros, então temos apenas os parênteses.
‫E então, em vez de colocar um ponto e vírgula no final desta linha em uma nova linha, colocamos uma
‫chave de abertura e uma chave de fechamento correspondente.
‫E entre essas chaves onde colocamos o código da nossa função, fantástico.
‫Então, o que eu quero fazer agora é tentar dizer, bem, toda essa funcionalidade que temos aqui e, na verdade,
‫vou excluir os comentários porque não precisamos mais deles.
‫Eles eram o pseudocódigo que usamos para implementar isso, mas agora meio que serviu ao seu propósito.
‫Entendemos o que as linhas de código estão fazendo.
‫Eu vou tirar tudo, menos a função de plataforma de movimentação, copiá-la e colá-la em nossa
‫função de plataforma MOVE.
‫Portanto, isso deve funcionar praticamente da mesma forma, porque quando entramos em tecnologia, chamamos de plataforma de movimento e
‫ele executa o mesmo código.
‫Exceto que agora nós o agrupamos em uma função e torna mais fácil para nós ler e potencialmente reutilizar
‫no futuro.
‫Mas se você fizer isso, você notará que há um problema.
‫Estamos acessando o Delta time e esse é um parâmetro ao qual não temos mais acesso porque era um parâmetro passado para
‫a tecnologia.
‫Então, se queremos nos apossar disso, precisamos ter um parâmetro em nossa função.
‫Então, quando definimos parâmetros, temos que fazer isso em dois lugares.
‫Assim como quando definimos a função, voltamos ao arquivo de cabeçalho e entre os
‫parênteses da nossa função da plataforma MOVE.
‫É aqui que dizemos quais parâmetros queremos e é exatamente como definir uma variável.
‫Você precisa dar um tipo e um nome.
‫Então, vamos dizer que será um tipo float e podemos chamá-lo de tempo Delta.
‫Não precisa ser o mesmo nome.
‫Poderíamos chamar assim.
‫Poderíamos chamar de tempo.
‫Mas é mais fácil dar o mesmo nome porque assim fica óbvio para quem lê o que deve ser
‫passado aqui.
‫Em seguida, no arquivo C++, precisamos corresponder à lista de parâmetros.
‫Então, novamente, você pode fazer isso copiando e colando ou digitando.
‫Se você digitar, certifique-se de não cometer erros de digitação porque o compilador reclamará.
‫Então vamos ter um float chamado Delta Time passado como um parâmetro ou definido como um parâmetro para mover
‫a plataforma, mas na verdade não o passamos como um argumento para mover a plataforma no tick.
‫E você verá que eu tenho uma pequena linha ondulada vermelha aqui arquivo muito, muito.
‫Ele diz que há muito poucos argumentos na chamada da função porque eu o defini no arquivo
‫de cabeçalho e agora no C++, além de exigir um parâmetro do tipo float.
‫Então eu devo fornecer esse parâmetro.
‫Então, vou me certificar de que esse é o parâmetro que estou fornecendo.
‫O valor que estou fornecendo vem da variável Delta time ou do parâmetro Delta time do tick.
‫Então, estamos encadeando o valor, o valor é passado para o tick, depois é passado
‫para a plataforma de movimentação e termina em um parâmetro na função da plataforma MOVE, onde pode ser usado para executar e mover a funcionalidade
‫da plataforma.
‫Então eu gostaria que você criasse sua própria função de plataforma de rotação que vamos chamar do TIC.
‫Então você vai adicioná-lo ao arquivo de cabeçalho como fizemos para nossa função de plataforma MOVE.
‫Vamos adicioná-lo ao arquivo C++ da mesma maneira.
‫Portanto, pegue suas dicas da maneira como fizemos para essas funções e chame-as da função tick.
‫Certifique-se de passar no tempo Delta e de definir quaisquer parâmetros para permitir que você passe o
‫tempo Delta e implemente o corpo da plataforma Rotate para que ela desconecte uma mensagem.
‫Na verdade, ainda não vai rodar a plataforma, mas como um espaço reservado para garantir que isso seja realmente
‫chamado de mensagem de log usando o log da interface do usuário sobre o qual aprendemos.
‫Pause o vídeo e vá em frente.
‫OK.
‫Bem vindo de volta.
‫Então, vamos começar no arquivo de cabeçalho e faremos basicamente o mesmo que fizemos para nossa
‫plataforma MOVE.
‫Vamos colocá-lo em uma seção privada para que seja acessível apenas dentro de nossa classe.
‫Vou dar-lhe um tipo de retorno void, vamos chamá-lo de plataforma rotativa.
‫Vamos abrir a lista de parâmetros.
‫E nele vamos colocar um parâmetro que terá o tipo float,
‫vamos chamá-lo de tempo Delta e fechar os parâmetros e terminar com um ponto e vírgula.
‫Agora, a maior parte do que fazemos no arquivo C++ é exatamente o mesmo que no cabeçalho do arquivo.
‫Então, na verdade, vou copiar esta linha, ir até o arquivo C++ e mostrar o que é diferente.
‫Então, eu vou para uma nova linha vazia no final do arquivo, colá-la, e então o que é diferente é que aqui
‫precisamos do operador de resolução de escopo e do nome da classe.
‫Então vamos ter uma plataforma móvel, dois pontos, dois pontos plataforma rotativa.
‫Então temos a lista de parâmetros e não precisamos do ponto e vírgula no final.
‫Portanto, remova o ponto e vírgula, adicione uma nova linha e ataque as chaves em vez de uma nova linha entre
‫essas duas chaves.
‫Então, o que queremos fazer aqui é imprimir uma mensagem de log.
‫Então eu vou digitar você log, aperte enter.
‫Será apenas uma mensagem de exibição simples.
‫E no texto vou colocar o nome da nossa plataforma.
‫Então vai ser por cento s, então vamos digitar ponto giratório, ponto, ponto, e então eu vou
‫passar o nome.
‫Agora podemos colocar isso em uma variável, mas como é uma linha bem curta
‫aqui, vou digitar star, get name e depois colocar os parênteses para que estejamos chamando essencialmente aqui chamando o get
‫name.
‫Essa é a expressão que se apodera da string.
‫E então estamos convertendo esse resultado para colocar em nossa mensagem de log.
‫Então, de todas as nossas plataformas, espero ver que a rotação seja impressa, mas isso só acontecerá se eu realmente
‫chamar isso de tecnologia.
‫Então vamos para a função tick depois que a plataforma MOVE pode adicionar uma nova linha e chamar a plataforma de rotação.
‫E precisamos ver.
‫Quando abro os parênteses, isso me dá uma dica de que preciso passar um argumento para o tempo Delta.
‫Então, novamente, vamos passar a mesma variável de tempo Delta daqui.
‫E como eu disse, os nomes aqui não precisam ser os mesmos.
‫Portanto, esse tempo delta precisa corresponder ao tempo Delta dentro da tecnologia.
‫Mas podemos optar por chamar a variável dentro da data da plataforma de rotação.
‫E em qualquer lugar que o usemos na plataforma de rotação, teríamos que usar ADT, o nome do parâmetro, e
‫o argumento pode ser basicamente diferente.
‫Então, vamos pular para o Unreal e clicar em compilar porque fizemos algumas alterações no arquivo de cabeçalho.
‫A compilação será um pouco mais longa do que quando acabamos de alterar o arquivo C++ e, uma vez concluída
‫a compilação, vamos em frente e clicar em play e abrir o log de saída.
‫E você pode ver que de fato estamos exibindo mensagens de log sobre cada uma das plataformas rotativas.
‫Portanto, parece que nossa função está efetivamente sendo chamada em tecnologia.
‫Coisas boas.
‫Agora entendemos como criar nossas próprias funções que são membros de uma classe.
‫É uma ferramenta muito útil para reutilizar um código, mas também para organizá-lo como no Blueprint.
‫Vejo você na próxima palestra.