‫Olá e bem-vindo.
‫Nesta palestra, vamos fazer nosso movimento, fazer alguns movimentos, marcando uma caixa de seleção.
‫Vamos permitir que ele se mova e se mova a uma velocidade constante.
‫E vamos fazer isso usando algumas funções de biblioteca desta vez de dentro.
‫Irreal.
‫Então vamos colocar todo o nosso conhecimento de head of files e includes à prova.
‫Vamos mergulhar e ver como funciona.
‫Então, a maneira como eu quero que esse movimento funcione é que ele se mova suavemente de onde começou para um deslocamento
‫de destino durante um período de um certo número de segundos.
‫Então, vamos precisar configurar isso adicionando algumas novas propriedades no arquivo de cabeçalho.
‫Então vamos começar adicionando uma seção privada ao cabeçalho do arquivo
‫e então vamos adicionar uma nova propriedade que será adicionada em qualquer lugar, que vai definir o deslocamento, o deslocamento de movimento.
‫Então, até onde esse motor deve se mover quando ativado.
‫Então, do jeito que vamos fazer isso, ele vai usar um vetor F e eu vou chamá-lo
‫de deslocamento de movimento para não dar um valor padrão.
‫Faremos isso no editor.
‫Em seguida, vou criar outra propriedade U que será novamente adicionada em qualquer lugar, que
‫será a quantidade de tempo necessária para mover para o destino.
‫Então vamos ter que ser um float, que é o tempo de movimento.
‫Vou definir isso em um valor padrão de, digamos, 4 segundos.
‫Agora, há mais uma coisa que eu quero colocar aqui, que é um
‫booleano por enquanto, que nos permitirá ativar o movimento para que ele desça quando ativarmos esse booleano.
‫Então vamos criar outra nova propriedade novamente, editar em qualquer lugar para que possamos adicioná-la mesmo enquanto estamos
‫jogando.
‫Este será um booleano dizendo que deve se mover e, por padrão, será definido como false.
‫Então, quando marcamos isso no editor, quando estamos jogando, ele vai e se move para o deslocamento de
‫movimento alvo.
‫Agora, anteriormente, quando tínhamos um componente móvel, fazíamos todos os passos manualmente.
‫Mas quero mostrar a você que, na verdade, há algumas funcionalidades incorporadas a serem feitas.
‫Muitos dos cálculos que precisamos estão embutidos no Unreal e há uma função chamada V interpret
‫constant também.
‫E o que é interessante nisso, vamos dar uma olhada nas observações.
‫Então interpole um vetor de um vetor atual para um vetor alvo usando um passo constante.
‫Isso significa que, com o tempo, vamos passar da corrente para o alvo a uma certa velocidade, e ele fará
‫isso constantemente, o que parece exatamente o que queremos.
‫Queremos mover de nossa localização atual para um local de deslocamento de destino a uma velocidade constante.
‫Agora você pode ver que você deu uma olhada na sintaxe para esta função.
‫Você pode ver que ele tem um tipo de retorno de vetor.
‫Então esse é o novo local que está interpolando.
‫Então ele tem duas entradas.
‫Nós temos um vetor F atual e não se preocupe com os outros símbolos em torno deste efeito por enquanto, apenas
‫o importante é que é um fator atual e então o alvo que queremos que ele alcance
‫eventualmente, então ele tem o Delta tempo, então ele usa isso para tornar a taxa de quadros de movimento independente e a velocidade de
‫interpolação.
‫Então, quão rápido devemos nos mover de nossa localização atual para o alvo?
‫Agora você notará que aqui na documentação ele realmente tem uma seção que diz incluir e isso informa a
‫linha de inclusão que você precisará em seu arquivo C++ para poder usar essa
‫função.
‫E como vimos no vídeo anterior, a linha de inclusão nos permite copiar as definições deste arquivo
‫em particular.
‫E uma das definições é a definição para esta função.
‫Então nos permite usar essa constante de interceptação V para agora o V na frente dessa função basicamente significa que
‫ela faz interpolação em vetores.
‫É por isso que é chamado de v interpret em oposição a outras funções de interpolação que também estão disponíveis
‫neste arquivo de biblioteca.
‫Então, vamos dar uma olhada em como nós o usaríamos.
‫Em primeiro lugar, vamos copiar a linha de inclusão da documentação e vamos para o nosso
‫ACP de movimentação, onde queremos implementar isso no corpo do componente tick.
‫Mas eles incluem nós não incluímos no corpo do componente tick.
‫Temos que fazer todas as inclusões no topo do arquivo.
‫Então é aí que eu vou colocar o meu.
‫Vou colocar o meu depois da inclusão de mover um ponto h.
‫Então vamos colocar e incluir para matemática barra irreal utilidade matemática dot h.
‫Agora o que podemos fazer é usar a função dentro do nosso componente tick.
‫Vamos nos livrar do código que já temos e compilar.
‫Porque estávamos usando isso para entender como chamar funções em outros atores.
‫E o que precisamos fazer é se você rolar para cima, você pode ver a maneira de chamar isso é f math dois pontos V
‫na constante de toque para.
‫Então, estamos fazendo esse operador de dois pontos que olha dentro da classe de matemática F, que organiza
‫todos esses utilitários de matemática.
‫Então vamos fazer a matemática F.
‫Cólon.
‫E aqui você pode ver um monte de autocompletar chegando para diferentes funções matemáticas incluídas nesse arquivo
‫de cabeçalho que acabamos de incluir neste arquivo.
‫Então você pode dar uma olhada, ver qualquer coisa interessante aqui.
‫Eu posso ver um monte de interpolação e interpolações circulares etc. mas queríamos que a constante de interpretação v para.
‫Podemos clicar em tab para concluir isso e, em seguida, abrir alguns parênteses e podemos ver os argumentos que
‫precisamos passar na corrente, o tempo delta alvo e a velocidade de interceptação.
‫Então vamos começar a criar algumas variáveis para armazenar algumas delas.
‫Então, antes de tudo, precisamos de um vetor F, que será nossa localização atual, e não vamos
‫definir isso ainda.
‫Então vamos ter um vetor F para o local alvo, e então vamos obter um float para a
‫velocidade.
‫E vamos ter que calcular cada um deles individualmente para descobrir como podemos fazer esse movimento
‫acontecer.
‫Portanto, a localização atual será relativamente simples.
‫Precisamos obter a localização atual do ator proprietário.
‫Então, como fazemos isso?
‫Vamos substituir este ponto e vírgula por um sinal de igual.
‫Então vamos fazer um par de parênteses get owner que vamos fazer Arrow.
‫Então, vamos chamar uma função no ator proprietário, e vamos obter a localização do ator e, em seguida, um par de parênteses e
‫um ponto e vírgula para terminá-lo.
‫Então, isso nos dá a localização atual do ator proprietário.
‫Agora, e quanto ao nosso local de destino?
‫Bem, sabemos que temos uma propriedade chamada Move Offset.
‫Então isso vai estar envolvido aqui.
‫Mas precisamos adicionar o local original a esse deslocamento de movimento.
‫Então, para isso, precisamos capturar o local original no início do jogo.
‫Então, precisamos de uma variável store in.
‫Então vamos aos nossos militares.
‫H E não vai ser uma edição em qualquer lugar.
‫Então, vou colocá-lo em propriedades de valor, será um vetor F chamado localização original.
‫Não vamos defini-lo para nada aqui que vamos analisar em nossos filmes.
‫CP Em Begin Play, remova esta linha de comentário e coloque nosso próprio código,
‫que será que o local original é igual para obter a seta de parênteses do proprietário, obter a localização do ator assim.
‫Agora que capturamos nossa localização original e começamos a jogar, podemos usá-la em tecnologia.
‫Então vá para tick e nós definimos nosso local de destino igual ao local original mais o deslocamento de deslocamento.
‫Então esse é o nosso local de destino.
‫E finalmente, em velocidade, bem, esta é essencialmente a distância que precisamos percorrer
‫dividida pelo tempo que precisamos percorrer.
‫Então, se temos um local de destino e temos um local original, precisamos encontrar a distância
‫entre esses dois, o que podemos fazer com uma coluna de vetor f, distância de dois pontos.
‫Em seguida, passamos para os parênteses, o local original e o local de destino.
‫Então isso nos dá a distância entre esses dois vetores.
‫E então vamos dividir isso pelo que temos e sair, chamado de tempo de movimento.
‫Então isso nos dá a velocidade na qual devemos nos mover.
‫E agora podemos usá-los como argumentos para nossa constante de interceptação V para.
‫Então, primeiro temos que fornecer a localização atual e, em seguida, a localização de destino.
‫Então vamos dizer que é o tempo Delta, que já é um parâmetro no componente tick.
‫Então, só precisamos passar por isso.
‫E então temos a velocidade de interceptação.
‫Então, vamos passar a velocidade como ponto e vírgula no final dessa linha.
‫E este é essencialmente o novo local.
‫Então vamos armazenar isso em um novo vetor variável chamado new location igual a this.
‫Frio.
‫Agora, precisamos fazer algo com esse novo local porque não adianta apenas
‫calcular, na verdade precisamos mover o ator para o novo local.
‫Então é isso que vamos fazer.
‫Vamos chamá-lo em get owner para que possamos fazer um get own.
‫Seta de parênteses.
‫E então vamos fazer uma locação de ator definida e vamos passar na nova localização assim e ter um ponto e vírgula
‫no final da linha.
‫Então vamos em frente e compilar isso e ver se funciona.
‫Então, se formos para a masmorra, selecione a parede que queremos mover.
‫Agora você pode ver que o componente movedor tem um deslocamento de deslocamento, que eu vou
‫querer fazer na direção Z, e acho que vou fazer -600.
‫E então o tempo de movimento, 4 segundos deve ser bom.
‫Então vamos salvar isso e depois apertar play e ver se ele se move.
‫Então não está se movendo.
‫E há um erro no log de saída dizendo que a mobilidade do ator foi definida como estática, e é por isso que ele
‫não pode se mover.
‫Portanto, se selecionarmos o ator novamente e observarmos suas configurações de mobilidade, você poderá ver as configurações de mobilidade do componente de malha estática,
‫então selecione o componente de malha estática e observe a mobilidade.
‫Você pode vê-lo definido para espécimes estáticos.
‫Não é permitido mexer.
‫Vamos mudar para móvel porque queremos que ele se mova.
‫E então vamos em frente e aperte o play.
‫Agora, você pode ver na escuridão que a guerra estava acontecendo, o que é perfeito.
‫Eu acho que temos um movimento em outro lugar como visto neste pilar aqui que também está tentando se mover.
‫Então não vamos fazer isso.
‫Vamos excluir o movimento, um componente que adicionamos lá apenas para teste.
‫E não deve nos dar erros no log de saída.
‫Se formos em frente na jogada de acerto agora, devemos ter aquela parede descendo até o local alvo.
‫Então, vamos desafiá-lo a fazê-lo mover-se com o booleano que criamos para sua propriedade.
‫Então você vai envolver o código em uma instrução if apropriada e o código apropriado para que
‫ele só mova a plataforma quando esse booleano for verdadeiro.
‫E então você vai recompilar o código e jogar uma ejeção usando F8 e então mudar o booleano e observar
‫o plat e ver se ele se move quando você verifica aquele booleano.
‫Então pause o vídeo e vá em frente.
‫OK.
‫Bem vindo de volta.
‫Então, vamos embrulhar esse componente de tecnologia em uma instrução if, não super, mas tudo o mais que vamos
‫fazer.
‫If deve mover e abrir alguns parênteses e mover todo esse código lembrando de recuar um nível porque estamos dentro dos parênteses
‫e queremos mostrar que isso só seria executado dentro da instrução if.
‫Facilite a leitura do controle de todos os Taft onze compilados e, em seguida, devemos ser capazes de
‫ir e pressionar play e pressionar F8 para ejetar se tivermos nosso mouse capturado.
‫E então vamos dar uma olhada no nosso contorno e vamos tentar encontrar a parede.
‫Ou podemos simplesmente clicar na cena e então vamos selecionar nosso mover um componente e verificar se deve mover e
‫eles vão, a parede começa a se mover quando isso acontece.
‫Coisas boas.
‫Vejo você na próxima palestra.