1
00:00:04,370 --> 00:00:05,300
‫Olá e bem-vindo.

2
00:00:05,300 --> 00:00:10,190
‫Nesta palestra, vamos fazer nosso movimento, fazer alguns movimentos, marcando uma caixa de seleção.

3
00:00:10,190 --> 00:00:14,570
‫Vamos permitir que ele se mova e se mova a uma velocidade constante.

4
00:00:14,810 --> 00:00:19,370
‫E vamos fazer isso usando algumas funções de biblioteca desta vez de dentro.

5
00:00:19,370 --> 00:00:19,970
‫Irreal.

6
00:00:20,210 --> 00:00:24,860
‫Então vamos colocar todo o nosso conhecimento de head of files e includes à prova.

7
00:00:24,860 --> 00:00:26,510
‫Vamos mergulhar e ver como funciona.

8
00:00:27,470 --> 00:00:34,610
‫Então, a maneira como eu quero que esse movimento funcione é que ele se mova suavemente de onde começou para um deslocamento

9
00:00:34,610 --> 00:00:38,510
‫de destino durante um período de um certo número de segundos.

10
00:00:38,510 --> 00:00:43,610
‫Então, vamos precisar configurar isso adicionando algumas novas propriedades no arquivo de cabeçalho.

11
00:00:43,610 --> 00:00:48,950
‫Então vamos começar adicionando uma seção privada ao cabeçalho do arquivo

12
00:00:48,950 --> 00:00:58,850
‫e então vamos adicionar uma nova propriedade que será adicionada em qualquer lugar, que vai definir o deslocamento, o deslocamento de movimento.

13
00:00:59,090 --> 00:01:03,410
‫Então, até onde esse motor deve se mover quando ativado.

14
00:01:03,890 --> 00:01:08,570
‫Então, do jeito que vamos fazer isso, ele vai usar um vetor F e eu vou chamá-lo

15
00:01:08,600 --> 00:01:11,780
‫de deslocamento de movimento para não dar um valor padrão.

16
00:01:12,020 --> 00:01:13,400
‫Faremos isso no editor.

17
00:01:13,940 --> 00:01:19,310
‫Em seguida, vou criar outra propriedade U que será novamente adicionada em qualquer lugar, que

18
00:01:19,310 --> 00:01:23,780
‫será a quantidade de tempo necessária para mover para o destino.

19
00:01:24,140 --> 00:01:29,030
‫Então vamos ter que ser um float, que é o tempo de movimento.

20
00:01:29,830 --> 00:01:33,140
‫Vou definir isso em um valor padrão de, digamos, 4 segundos.

21
00:01:33,440 --> 00:01:39,680
‫Agora, há mais uma coisa que eu quero colocar aqui, que é um

22
00:01:39,680 --> 00:01:47,000
‫booleano por enquanto, que nos permitirá ativar o movimento para que ele desça quando ativarmos esse booleano.

23
00:01:47,000 --> 00:01:52,700
‫Então vamos criar outra nova propriedade novamente, editar em qualquer lugar para que possamos adicioná-la mesmo enquanto estamos

24
00:01:52,700 --> 00:01:53,360
‫jogando.

25
00:01:53,780 --> 00:02:00,860
‫Este será um booleano dizendo que deve se mover e, por padrão, será definido como false.

26
00:02:01,220 --> 00:02:07,640
‫Então, quando marcamos isso no editor, quando estamos jogando, ele vai e se move para o deslocamento de

27
00:02:07,640 --> 00:02:08,600
‫movimento alvo.

28
00:02:08,780 --> 00:02:13,310
‫Agora, anteriormente, quando tínhamos um componente móvel, fazíamos todos os passos manualmente.

29
00:02:13,310 --> 00:02:16,460
‫Mas quero mostrar a você que, na verdade, há algumas funcionalidades incorporadas a serem feitas.

30
00:02:16,460 --> 00:02:23,330
‫Muitos dos cálculos que precisamos estão embutidos no Unreal e há uma função chamada V interpret

31
00:02:23,330 --> 00:02:24,620
‫constant também.

32
00:02:24,830 --> 00:02:28,460
‫E o que é interessante nisso, vamos dar uma olhada nas observações.

33
00:02:28,460 --> 00:02:36,500
‫Então interpole um vetor de um vetor atual para um vetor alvo usando um passo constante.

34
00:02:36,890 --> 00:02:43,880
‫Isso significa que, com o tempo, vamos passar da corrente para o alvo a uma certa velocidade, e ele fará

35
00:02:43,880 --> 00:02:47,300
‫isso constantemente, o que parece exatamente o que queremos.

36
00:02:47,300 --> 00:02:52,160
‫Queremos mover de nossa localização atual para um local de deslocamento de destino a uma velocidade constante.

37
00:02:52,760 --> 00:02:57,140
‫Agora você pode ver que você deu uma olhada na sintaxe para esta função.

38
00:02:57,140 --> 00:02:59,990
‫Você pode ver que ele tem um tipo de retorno de vetor.

39
00:02:59,990 --> 00:03:03,380
‫Então esse é o novo local que está interpolando.

40
00:03:03,860 --> 00:03:06,590
‫Então ele tem duas entradas.

41
00:03:06,590 --> 00:03:14,540
‫Nós temos um vetor F atual e não se preocupe com os outros símbolos em torno deste efeito por enquanto, apenas

42
00:03:14,810 --> 00:03:21,650
‫o importante é que é um fator atual e então o alvo que queremos que ele alcance

43
00:03:22,250 --> 00:03:31,460
‫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

44
00:03:31,460 --> 00:03:32,120
‫interpolação.

45
00:03:32,120 --> 00:03:37,040
‫Então, quão rápido devemos nos mover de nossa localização atual para o alvo?

46
00:03:37,220 --> 00:03:45,500
‫Agora você notará que aqui na documentação ele realmente tem uma seção que diz incluir e isso informa a

47
00:03:45,500 --> 00:03:51,740
‫linha de inclusão que você precisará em seu arquivo C++ para poder usar essa

48
00:03:51,740 --> 00:03:52,220
‫função.

49
00:03:52,220 --> 00:04:00,770
‫E como vimos no vídeo anterior, a linha de inclusão nos permite copiar as definições deste arquivo

50
00:04:00,770 --> 00:04:02,240
‫em particular.

51
00:04:02,450 --> 00:04:05,930
‫E uma das definições é a definição para esta função.

52
00:04:05,930 --> 00:04:13,220
‫Então nos permite usar essa constante de interceptação V para agora o V na frente dessa função basicamente significa que

53
00:04:13,220 --> 00:04:15,110
‫ela faz interpolação em vetores.

54
00:04:15,110 --> 00:04:20,660
‫É por isso que é chamado de v interpret em oposição a outras funções de interpolação que também estão disponíveis

55
00:04:20,930 --> 00:04:22,220
‫neste arquivo de biblioteca.

56
00:04:22,490 --> 00:04:24,080
‫Então, vamos dar uma olhada em como nós o usaríamos.

57
00:04:24,080 --> 00:04:29,810
‫Em primeiro lugar, vamos copiar a linha de inclusão da documentação e vamos para o nosso

58
00:04:29,810 --> 00:04:34,280
‫ACP de movimentação, onde queremos implementar isso no corpo do componente tick.

59
00:04:34,700 --> 00:04:38,600
‫Mas eles incluem nós não incluímos no corpo do componente tick.

60
00:04:38,600 --> 00:04:41,630
‫Temos que fazer todas as inclusões no topo do arquivo.

61
00:04:42,170 --> 00:04:44,180
‫Então é aí que eu vou colocar o meu.

62
00:04:44,190 --> 00:04:47,620
‫Vou colocar o meu depois da inclusão de mover um ponto h.

63
00:04:47,630 --> 00:04:54,050
‫Então vamos colocar e incluir para matemática barra irreal utilidade matemática dot h.

64
00:04:54,830 --> 00:04:59,870
‫Agora o que podemos fazer é usar a função dentro do nosso componente tick.

65
00:04:59,870 --> 00:05:03,780
‫Vamos nos livrar do código que já temos e compilar.

66
00:05:04,020 --> 00:05:09,030
‫Porque estávamos usando isso para entender como chamar funções em outros atores.

67
00:05:10,230 --> 00:05:17,130
‫E o que precisamos fazer é se você rolar para cima, você pode ver a maneira de chamar isso é f math dois pontos V

68
00:05:17,130 --> 00:05:18,700
‫na constante de toque para.

69
00:05:18,750 --> 00:05:27,180
‫Então, estamos fazendo esse operador de dois pontos que olha dentro da classe de matemática F, que organiza

70
00:05:27,180 --> 00:05:29,880
‫todos esses utilitários de matemática.

71
00:05:30,360 --> 00:05:33,110
‫Então vamos fazer a matemática F.

72
00:05:33,330 --> 00:05:34,220
‫Cólon.

73
00:05:35,430 --> 00:05:41,370
‫E aqui você pode ver um monte de autocompletar chegando para diferentes funções matemáticas incluídas nesse arquivo

74
00:05:41,370 --> 00:05:44,580
‫de cabeçalho que acabamos de incluir neste arquivo.

75
00:05:44,790 --> 00:05:47,960
‫Então você pode dar uma olhada, ver qualquer coisa interessante aqui.

76
00:05:47,960 --> 00:05:55,580
‫Eu posso ver um monte de interpolação e interpolações circulares etc. mas queríamos que a constante de interpretação v para.

77
00:05:55,990 --> 00:06:03,390
‫Podemos clicar em tab para concluir isso e, em seguida, abrir alguns parênteses e podemos ver os argumentos que

78
00:06:03,390 --> 00:06:08,910
‫precisamos passar na corrente, o tempo delta alvo e a velocidade de interceptação.

79
00:06:09,330 --> 00:06:13,620
‫Então vamos começar a criar algumas variáveis para armazenar algumas delas.

80
00:06:14,310 --> 00:06:21,960
‫Então, antes de tudo, precisamos de um vetor F, que será nossa localização atual, e não vamos

81
00:06:21,960 --> 00:06:23,350
‫definir isso ainda.

82
00:06:23,370 --> 00:06:31,200
‫Então vamos ter um vetor F para o local alvo, e então vamos obter um float para a

83
00:06:31,200 --> 00:06:32,040
‫velocidade.

84
00:06:33,150 --> 00:06:38,070
‫E vamos ter que calcular cada um deles individualmente para descobrir como podemos fazer esse movimento

85
00:06:38,070 --> 00:06:38,460
‫acontecer.

86
00:06:38,640 --> 00:06:42,390
‫Portanto, a localização atual será relativamente simples.

87
00:06:42,420 --> 00:06:46,410
‫Precisamos obter a localização atual do ator proprietário.

88
00:06:46,440 --> 00:06:47,130
‫Então, como fazemos isso?

89
00:06:47,130 --> 00:06:50,070
‫Vamos substituir este ponto e vírgula por um sinal de igual.

90
00:06:50,460 --> 00:06:56,230
‫Então vamos fazer um par de parênteses get owner que vamos fazer Arrow.

91
00:06:56,370 --> 00:07:05,280
‫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

92
00:07:05,760 --> 00:07:08,310
‫um ponto e vírgula para terminá-lo.

93
00:07:08,640 --> 00:07:12,330
‫Então, isso nos dá a localização atual do ator proprietário.

94
00:07:12,870 --> 00:07:14,790
‫Agora, e quanto ao nosso local de destino?

95
00:07:15,030 --> 00:07:18,390
‫Bem, sabemos que temos uma propriedade chamada Move Offset.

96
00:07:18,780 --> 00:07:20,760
‫Então isso vai estar envolvido aqui.

97
00:07:21,120 --> 00:07:26,400
‫Mas precisamos adicionar o local original a esse deslocamento de movimento.

98
00:07:26,910 --> 00:07:32,580
‫Então, para isso, precisamos capturar o local original no início do jogo.

99
00:07:32,940 --> 00:07:34,830
‫Então, precisamos de uma variável store in.

100
00:07:34,830 --> 00:07:35,940
‫Então vamos aos nossos militares.

101
00:07:35,970 --> 00:07:38,970
‫H E não vai ser uma edição em qualquer lugar.

102
00:07:38,970 --> 00:07:46,320
‫Então, vou colocá-lo em propriedades de valor, será um vetor F chamado localização original.

103
00:07:47,280 --> 00:07:50,360
‫Não vamos defini-lo para nada aqui que vamos analisar em nossos filmes.

104
00:07:50,360 --> 00:07:57,630
‫CP Em Begin Play, remova esta linha de comentário e coloque nosso próprio código,

105
00:07:58,290 --> 00:08:08,610
‫que será que o local original é igual para obter a seta de parênteses do proprietário, obter a localização do ator assim.

106
00:08:08,850 --> 00:08:13,050
‫Agora que capturamos nossa localização original e começamos a jogar, podemos usá-la em tecnologia.

107
00:08:13,380 --> 00:08:21,840
‫Então vá para tick e nós definimos nosso local de destino igual ao local original mais o deslocamento de deslocamento.

108
00:08:21,840 --> 00:08:23,340
‫Então esse é o nosso local de destino.

109
00:08:23,880 --> 00:08:29,550
‫E finalmente, em velocidade, bem, esta é essencialmente a distância que precisamos percorrer

110
00:08:29,550 --> 00:08:32,550
‫dividida pelo tempo que precisamos percorrer.

111
00:08:32,580 --> 00:08:38,760
‫Então, se temos um local de destino e temos um local original, precisamos encontrar a distância

112
00:08:38,760 --> 00:08:44,970
‫entre esses dois, o que podemos fazer com uma coluna de vetor f, distância de dois pontos.

113
00:08:45,300 --> 00:08:54,450
‫Em seguida, passamos para os parênteses, o local original e o local de destino.

114
00:08:55,050 --> 00:08:58,230
‫Então isso nos dá a distância entre esses dois vetores.

115
00:08:58,230 --> 00:09:05,130
‫E então vamos dividir isso pelo que temos e sair, chamado de tempo de movimento.

116
00:09:05,850 --> 00:09:08,700
‫Então isso nos dá a velocidade na qual devemos nos mover.

117
00:09:09,360 --> 00:09:13,650
‫E agora podemos usá-los como argumentos para nossa constante de interceptação V para.

118
00:09:14,070 --> 00:09:20,430
‫Então, primeiro temos que fornecer a localização atual e, em seguida, a localização de destino.

119
00:09:21,210 --> 00:09:27,180
‫Então vamos dizer que é o tempo Delta, que já é um parâmetro no componente tick.

120
00:09:27,180 --> 00:09:28,530
‫Então, só precisamos passar por isso.

121
00:09:29,580 --> 00:09:31,800
‫E então temos a velocidade de interceptação.

122
00:09:31,890 --> 00:09:36,570
‫Então, vamos passar a velocidade como ponto e vírgula no final dessa linha.

123
00:09:37,230 --> 00:09:40,350
‫E este é essencialmente o novo local.

124
00:09:40,350 --> 00:09:49,110
‫Então vamos armazenar isso em um novo vetor variável chamado new location igual a this.

125
00:09:49,530 --> 00:09:49,890
‫Frio.

126
00:09:50,520 --> 00:09:54,270
‫Agora, precisamos fazer algo com esse novo local porque não adianta apenas

127
00:09:54,280 --> 00:09:57,720
‫calcular, na verdade precisamos mover o ator para o novo local.

128
00:09:58,380 --> 00:09:59,320
‫Então é isso que vamos fazer.

129
00:09:59,340 --> 00:10:03,690
‫Vamos chamá-lo em get owner para que possamos fazer um get own.

130
00:10:04,730 --> 00:10:06,380
‫Seta de parênteses.

131
00:10:06,770 --> 00:10:15,590
‫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

132
00:10:15,590 --> 00:10:17,510
‫no final da linha.

133
00:10:18,110 --> 00:10:20,720
‫Então vamos em frente e compilar isso e ver se funciona.

134
00:10:21,080 --> 00:10:24,470
‫Então, se formos para a masmorra, selecione a parede que queremos mover.

135
00:10:24,500 --> 00:10:30,530
‫Agora você pode ver que o componente movedor tem um deslocamento de deslocamento, que eu vou

136
00:10:30,530 --> 00:10:35,150
‫querer fazer na direção Z, e acho que vou fazer -600.

137
00:10:36,050 --> 00:10:38,780
‫E então o tempo de movimento, 4 segundos deve ser bom.

138
00:10:38,930 --> 00:10:42,860
‫Então vamos salvar isso e depois apertar play e ver se ele se move.

139
00:10:43,130 --> 00:10:43,960
‫Então não está se movendo.

140
00:10:44,000 --> 00:10:49,790
‫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

141
00:10:50,090 --> 00:10:51,110
‫não pode se mover.

142
00:10:51,470 --> 00:10:59,720
‫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,

143
00:10:59,720 --> 00:11:03,890
‫então selecione o componente de malha estática e observe a mobilidade.

144
00:11:03,890 --> 00:11:05,600
‫Você pode vê-lo definido para espécimes estáticos.

145
00:11:05,630 --> 00:11:06,470
‫Não é permitido mexer.

146
00:11:06,850 --> 00:11:09,980
‫Vamos mudar para móvel porque queremos que ele se mova.

147
00:11:10,370 --> 00:11:11,750
‫E então vamos em frente e aperte o play.

148
00:11:11,990 --> 00:11:18,120
‫Agora, você pode ver na escuridão que a guerra estava acontecendo, o que é perfeito.

149
00:11:18,170 --> 00:11:23,470
‫Eu acho que temos um movimento em outro lugar como visto neste pilar aqui que também está tentando se mover.

150
00:11:23,480 --> 00:11:24,470
‫Então não vamos fazer isso.

151
00:11:24,740 --> 00:11:28,810
‫Vamos excluir o movimento, um componente que adicionamos lá apenas para teste.

152
00:11:29,690 --> 00:11:32,480
‫E não deve nos dar erros no log de saída.

153
00:11:32,480 --> 00:11:38,270
‫Se formos em frente na jogada de acerto agora, devemos ter aquela parede descendo até o local alvo.

154
00:11:38,480 --> 00:11:42,850
‫Então, vamos desafiá-lo a fazê-lo mover-se com o booleano que criamos para sua propriedade.

155
00:11:42,860 --> 00:11:48,710
‫Então você vai envolver o código em uma instrução if apropriada e o código apropriado para que

156
00:11:48,710 --> 00:11:52,460
‫ele só mova a plataforma quando esse booleano for verdadeiro.

157
00:11:53,090 --> 00:11:58,490
‫E então você vai recompilar o código e jogar uma ejeção usando F8 e então mudar o booleano e observar

158
00:11:58,490 --> 00:12:02,390
‫o plat e ver se ele se move quando você verifica aquele booleano.

159
00:12:02,390 --> 00:12:04,160
‫Então pause o vídeo e vá em frente.

160
00:12:07,290 --> 00:12:07,710
‫OK.

161
00:12:07,710 --> 00:12:08,430
‫Bem vindo de volta.

162
00:12:08,460 --> 00:12:14,790
‫Então, vamos embrulhar esse componente de tecnologia em uma instrução if, não super, mas tudo o mais que vamos

163
00:12:14,790 --> 00:12:15,300
‫fazer.

164
00:12:15,300 --> 00:12:24,390
‫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

165
00:12:24,390 --> 00:12:29,550
‫e queremos mostrar que isso só seria executado dentro da instrução if.

166
00:12:29,550 --> 00:12:36,450
‫Facilite a leitura do controle de todos os Taft onze compilados e, em seguida, devemos ser capazes de

167
00:12:36,450 --> 00:12:42,060
‫ir e pressionar play e pressionar F8 para ejetar se tivermos nosso mouse capturado.

168
00:12:42,720 --> 00:12:49,110
‫E então vamos dar uma olhada no nosso contorno e vamos tentar encontrar a parede.

169
00:12:49,410 --> 00:12:56,310
‫Ou podemos simplesmente clicar na cena e então vamos selecionar nosso mover um componente e verificar se deve mover e

170
00:12:56,310 --> 00:13:00,300
‫eles vão, a parede começa a se mover quando isso acontece.

171
00:13:00,570 --> 00:13:01,290
‫Coisas boas.

172
00:13:01,290 --> 00:13:03,330
‫Vejo você na próxima palestra.