WEBVTT

00:03.900 --> 00:10.890
En la clase anterior, añadimos un vector a nuestros cerdos y conseguimos que saltaran durante toda la longitud

00:10.890 --> 00:11.910
de ese vector.

00:12.060 --> 00:16.470
Ahora haremos que se muevan hacia el lugar de la meta.

00:16.470 --> 00:22.950
Por lo tanto, primero tenemos que calcular cuál es el vector hacia la ubicación de la meta.

00:23.070 --> 00:30.690
Y la forma de hacerlo es obtener las coordenadas de la meta y restarle las coordenadas del

00:30.690 --> 00:34.920
cerdo, lo que te dará el vector del cerdo a la meta.

00:34.920 --> 00:39.510
Así que vamos a abrir nuestro movimiento, que está en los dos cerdos.

00:39.510 --> 00:41.580
Aquí tenemos el objetivo.

00:41.610 --> 00:50.910
Ahora vamos a calcular también un vector tres, que será la dirección en la que vamos a viajar.

00:50.940 --> 00:57.990
Nos desharemos de esta traducción a partir de aquí, y en su lugar diremos realmente esa dirección.

01:00.050 --> 01:09.500
Es igual a la posición del punto de transformación de la meta menos la posición del punto de transformación de los cerdos.

01:09.500 --> 01:11.420
Y ese es el objeto en el que está este código.

01:11.420 --> 01:16.580
Así que transforma la posición del punto y eso nos dará nuestra dirección.

01:16.580 --> 01:17.030
De acuerdo.

01:17.030 --> 01:22.640
Entonces lo que hacemos es saltar por dirección.

01:22.640 --> 01:35.090
Así que si lo ponemos aquí abajo y ponemos que esta posición de punto de transformación es igual a esta posición de punto de transformación, y por supuesto no necesitas poner

01:35.540 --> 01:40.040
esto aquí porque también podrías ponerlo aquí arriba.

01:40.040 --> 01:45.020
Es algo que me queda de todos mis años de programar esto.

01:45.290 --> 01:50.000
Así que este punto transforma la posición del punto más la dirección.

01:50.000 --> 01:59.540
Ahora esta línea aquí es lo mismo que ir este punto transformar traducir.

02:00.770 --> 02:01.820
Dirección.

02:03.020 --> 02:07.880
Así que estas dos cosas son equivalentes, pero vamos a utilizar esta posición aquí arriba.

02:08.390 --> 02:08.870
De acuerdo.

02:08.870 --> 02:15.770
Así que guardemos eso y echemos un vistazo a lo que obtenemos para que los cerdos salten a la ubicación

02:15.770 --> 02:16.670
de la meta.

02:16.940 --> 02:18.950
Así que vamos a pulsar el play.

02:20.810 --> 02:22.120
Y ahí están.

02:22.400 --> 02:25.790
Así que en realidad ambos están encima del otro en este momento.

02:25.790 --> 02:29.450
Permítanme moverlos para que puedan ver que ambos están en ese lugar.

02:30.620 --> 02:36.470
Ahora bien, normalmente cuando tienes un personaje de inteligencia artificial y quieres que se mueva hacia un

02:36.470 --> 02:39.380
lugar de destino, no salta inmediatamente hacia allí.

02:39.380 --> 02:42.930
Se abren paso poco a poco por aquí.

02:42.950 --> 02:47.180
Así que lo que voy a hacer con estos dos cerdos, sólo voy a moverlos hacia fuera.

02:47.180 --> 02:51.580
Así que están en un lugar diferente de cada uno de ellos.

02:51.590 --> 02:59.030
Ahora vamos a volver a nuestro código MOVE y vamos a bajar en la actualización y hacer esta una actualización

02:59.030 --> 03:04.640
tardía porque queremos que sea la última cosa que se calcula.

03:04.670 --> 03:10.520
Normalmente se pone este tipo de movimiento en una actualización tardía porque ocurrirá después de cualquier física,

03:10.850 --> 03:15.980
cosas que estén pasando o animaciones, y que en este caso no tenemos, pero es una buena práctica ponerlo en

03:15.980 --> 03:17.560
una actualización tardía.

03:17.570 --> 03:25.550
Así que esta línea aquí que está moviendo nuestro cerdo, sólo voy a cortar eso de ahí y lo pondremos en nuestra actualización

03:25.550 --> 03:28.890
tardía para que se ejecute una y otra vez.

03:28.910 --> 03:35.630
Ahora, el problema es que la primera vez que esto se ejecuta va a saltar el cerdo directamente a la ubicación de la meta.

03:35.630 --> 03:42.860
Pero queremos que sólo dé pequeños pasos de esta dirección, no todo el vector de dirección.

03:42.860 --> 03:49.100
Y puedes hacerlo eligiendo una pequeña sección de la misma para poder reducirla multiplicando

03:49.100 --> 03:51.020
por algo así.

03:51.020 --> 03:56.510
0. 01 f el vector de dirección seguirá apuntando en la misma dirección.

03:56.510 --> 03:57.950
Simplemente se acorta.

03:57.950 --> 04:03.710
Así que en lugar de un gran salto, habrá que dar muchos pequeños saltos a medida que avancemos.

04:03.740 --> 04:10.790
Ok, entonces con ese cambio hecho, vamos a guardar esto volverá a Unity y habrá dos observaciones aquí

04:10.790 --> 04:13.310
que usted tendrá que considerar.

04:13.460 --> 04:15.560
Así que vamos a pulsar el play.

04:16.900 --> 04:17.280
De acuerdo.

04:17.320 --> 04:19.180
Así que ahí están nuestros cerdos.

04:19.720 --> 04:20.850
Ahora, esa es la primera.

04:20.860 --> 04:29.440
Obviamente, estamos añadiendo la dirección o un pequeño vector que apunta en la misma dirección que la dirección.

04:29.440 --> 04:32.020
Y sigue sumando y sigue sumando y sigue sumando.

04:32.020 --> 04:37.930
Así que sigue avanzando porque no le decimos cuándo parar.

04:37.930 --> 04:39.330
Eso está bien por el momento.

04:39.340 --> 04:50.980
Otra cosa, sin embargo, si tenemos este cerdo aquí, por ejemplo, y luego presionamos el play, entonces ambos cerdos

04:50.980 --> 04:54.940
van a llegar a la meta al mismo tiempo.

04:54.940 --> 04:56.080
¿Qué hay de malo en eso?

04:56.080 --> 05:03.220
Bueno, este cerdo obviamente va a tener que trabajar mucho más duro, es decir, ir más rápido para llegar allí, mientras que este

05:03.220 --> 05:04.540
puede ir más lento.

05:04.540 --> 05:13.180
Pero nosotros porque estamos multiplicando por 0. 01 la longitud de este vector en pequeños bits y este vector

05:13.180 --> 05:20.230
en pequeños bits, luego 0. 01 de este vector va a ser mucho más largo que 0. 01 de esto.

05:20.230 --> 05:26.710
Así que todavía va a hacer 100 iteraciones antes de llegar a la meta para ambos.

05:26.710 --> 05:33.220
Así que todavía están haciendo la misma cantidad de bucles de actualización en lugar de moverse a una velocidad consistente,

05:33.220 --> 05:39.010
porque si fueran a una velocidad consistente, este cerdo realmente llegaría allí antes que este cerdo.

05:39.010 --> 05:41.710
Bien, entonces, ¿cómo solucionamos estos dos problemas?

05:42.010 --> 05:44.050
Nos ocuparemos de la velocidad.

05:44.050 --> 05:47.110
En primer lugar, vamos a abrir nuestro código MOVE.

05:47.140 --> 05:55.510
Ahora, en lugar de sumar la dirección multiplicada por 0. 01, que reduce la dirección a la 100ª parte de su tamaño, y por lo

05:55.510 --> 06:00.760
tanto para ambos cerdos, va a ser un tipo de vector de longitud diferente.

06:00.970 --> 06:02.470
Lo normalizamos.

06:02.470 --> 06:11.410
Ahora normalizar un vector es reducirlo a una longitud de uno mantiene la misma dirección, pero va a ser consistentemente

06:11.410 --> 06:13.270
una longitud de uno.

06:13.270 --> 06:22.870
Así que vamos dirección punto normalizado y que devolverá una versión normalizada o una longitud de una dirección.

06:22.870 --> 06:24.490
Bien, guardemos esto.

06:24.490 --> 06:31.090
Cuando ejecutamos esto ahora vas a encontrar que se moverán a la misma velocidad.

06:31.630 --> 06:37.000
Así que eso significa que los cerdos más cercanos van a alcanzar esa meta primero.

06:38.270 --> 06:38.690
Vaya.

06:38.690 --> 06:39.800
Y muy rápido.

06:40.000 --> 06:40.720
De acuerdo.

06:41.180 --> 06:43.670
Debido a la longitud de uno que estamos añadiendo.

06:43.670 --> 06:45.920
Así que podemos frenar un poco eso.

06:45.950 --> 06:53.120
Lo que voy a hacer para que sea aún más consistente aquí es en realidad vamos a subir y añadir otra

06:53.120 --> 06:57.610
línea aquí para que tengas un vector tres velocidad.

06:57.620 --> 07:03.980
Ahora la velocidad va a ser básicamente nuestro vector de dirección y su longitud.

07:03.980 --> 07:10.790
Así que tomaremos esta dirección normalizada aquí y haremos que la velocidad sea igual a eso.

07:11.060 --> 07:17.300
Y entonces podemos multiplicarlo por un factor de velocidad como este.

07:17.300 --> 07:22.040
Y el factor de velocidad podríamos definirlo en la parte superior para ralentizar las cosas.

07:22.040 --> 07:24.200
Bien, pongamos aquí arriba.

07:24.200 --> 07:32.080
La velocidad de flotación es igual a 0. 0 5fk.

07:32.150 --> 07:38.000
Así que eso hará que esta longitud de uno más pequeño, pero consistentemente más pequeño para ambos picos.

07:38.000 --> 07:40.940
Y luego añadiremos la velocidad aquí.

07:41.540 --> 07:43.010
Así que guarda eso.

07:43.130 --> 07:48.680
Asegurémonos de que tengo un punto y coma en eso y ejecutémoslo de nuevo.

07:48.680 --> 07:54.770
Así que los cerdos deberían ser más lentos pero seguir moviéndose al mismo ritmo.

07:57.320 --> 07:57.490
De acuerdo.

07:57.680 --> 07:58.260
Y lo son.

07:58.280 --> 08:01.130
Y este cerdo llega primero a la meta.

08:01.820 --> 08:02.900
Y.

08:04.220 --> 08:04.610
Eso.

08:06.270 --> 08:07.470
Bien, genial.

08:07.470 --> 08:09.370
Así que eso es lo primero.

08:09.390 --> 08:18.630
La otra cosa es hacer esto más consistente una actualización, cualquier bucle de actualización no es una cantidad fija de tiempo en este

08:18.630 --> 08:19.290
caso.

08:19.320 --> 08:19.480
De acuerdo.

08:19.500 --> 08:20.820
Hay hay una actualización fija.

08:20.820 --> 08:21.210
Claro que sí.

08:21.210 --> 08:24.810
Pero queremos que esto sea consistente y suave.

08:24.810 --> 08:34.140
Así que también multiplicamos esto por el tiempo punto delta, que es la cantidad de tiempo que ha pasado desde

08:34.140 --> 08:37.140
que se produjo el último cuadro.

08:37.140 --> 08:43.380
Y eso realmente suavizará su velocidad y tendrá en cuenta que puede haber actualizaciones más

08:43.380 --> 08:45.390
rápidas que se produzcan.

08:45.450 --> 08:50.820
Así que con eso en su lugar, probablemente también encontrarás, porque has multiplicado por esto, que tu velocidad

08:50.820 --> 08:56.100
va a bajar considerablemente y puede que necesites cambiar este valor de velocidad, ¿verdad?

08:56.100 --> 08:59.220
Así que vamos a pulsar el play y ver dónde estamos.

08:59.270 --> 09:01.350
Tenemos que acelerar esto.

09:01.350 --> 09:07.260
También verás que mientras hacemos esto, los cerdos se hunden en el suelo.

09:07.260 --> 09:13.050
Ahora, la razón por la que están haciendo eso y se están moviendo ahora sólo muy, muy lento, es

09:13.050 --> 09:18.240
que el vector desde el cerdo a nuestra meta es en realidad ligeramente hacia abajo.

09:18.240 --> 09:24.300
Por lo tanto, cuando este cerdo realmente golpea aquí, en realidad va hacia abajo y a través de la tierra

09:24.300 --> 09:30.330
y por ahí debido a la naturaleza 3D de este, si desea mantener el cerdo en el plano, entonces usted podría

09:30.330 --> 09:35.460
levantar la posición de la meta para tener la misma posición y como el cerdo.

09:35.460 --> 09:37.110
Y lo veremos en un minuto.

09:37.110 --> 09:39.930
Aceleremos estos cerdos.

09:39.930 --> 09:46.770
Así que si ponemos dos aquí en su lugar y pulsamos play, entonces lo haremos.

09:51.040 --> 09:53.140
Testigo de ese cerdo que se esconde.

09:53.170 --> 09:55.310
Está bien, pero se mueven mucho más suave.

09:55.330 --> 09:59.530
Así que ahora si cogemos uno de los cerdos, echemos un vistazo a la altura.

09:59.560 --> 10:00.520
El cerdo está encendido.

10:00.520 --> 10:03.460
Es como 0. 862.

10:03.550 --> 10:14.350
Si consigues la ubicación de la meta y la pones a 0. 862 y luego ejecutar esto de nuevo, usted encontrará que porque no hay diferencia

10:14.350 --> 10:19.210
en la altura de los cerdos no va a ir a través del suelo.

10:19.210 --> 10:21.010
Se va a quedar en el avión.

10:21.550 --> 10:21.970
De acuerdo.

10:21.970 --> 10:25.240
Con eso funcionando, dejaremos este vídeo aquí cuando volvamos.

10:25.240 --> 10:31.060
En el próximo vídeo, abordaremos el tema de conseguir que el cerdo se detenga en la meta.
