WEBVTT

00:11.790 --> 00:18.090
Esta conferencia se extiende sobre la última conferencia al mover a nuestros personajes hacia una

00:18.090 --> 00:23.050
meta, donde luego se detendrán. Para hacer esto, necesitará una ubicación de objetivo.

00:23.050 --> 00:30.640
He creado un cubo simple haciendo clic derecho, Objeto 3D> Cubo y luego posicionándolo en algún lugar

00:30.640 --> 00:31.760
del entorno.

00:32.050 --> 00:36.970
Para empezar, vamos a conseguir que uno de los personajes avance hacia la meta.

00:36.970 --> 00:43.780
Por lo tanto, seleccione los personajes que están en la escena y asegúrese de eliminar el guión que ya

00:43.960 --> 00:45.640
está adjunto a ellos.

00:45.640 --> 00:49.540
Ahora vamos a crear un nuevo archivo C # llamado MoveToGoal.

00:49.570 --> 00:53.380
Es un poco diferente al código Move que escribimos antes,

00:53.710 --> 01:02.320
pero aún necesitamos calcular con vectores y, en la parte superior, comenzar agregando un flotante para la velocidad y lo tengo configurado

01:02.350 --> 01:04.170
en 1. 0.

01:04.290 --> 01:09.120
De hecho, podría configurarlo en 2 para que las cosas vayan un poco más rápido esta vez.

01:09.340 --> 01:13.490
Luego tengo una transformación pública expuesta llamada 'objetivo' que

01:13.490 --> 01:20.520
ahora está cambiando desde el código anterior. Antes, teníamos objetivo como vector.

01:20.710 --> 01:30.430
Ahora es una posición en el medio ambiente. Dentro de nuestro LateUpdate, necesitamos calcular la dirección.

01:30.430 --> 01:38.230
Este es el vector entre la posición del objetivo y la posición del personaje. Para hacer eso, simplemente menos a dónde

01:38.230 --> 01:41.350
vamos (por lo tanto,

01:41.350 --> 01:47.050
la posición de la meta) menos dónde estamos actualmente.

01:47.590 --> 01:52.150
Así que esto es "hacia dónde vamos" y esto es "hacia dónde estamos".

01:52.240 --> 01:53.790
Tiene que estar en ese orden.

01:53.830 --> 01:58.930
Si los cambia al otro lado, su vector estará orientado en la

01:58.960 --> 02:03.340
dirección opuesta y su personaje seguirá el mismo vector ...

02:03.380 --> 02:06.580
o al menos a lo largo del mismo tipo de línea hacia

02:06.710 --> 02:08.890
su objetivo, pero viajará en la dirección opuesta.

02:09.020 --> 02:14.940
Si alguna vez sucede eso, entonces sabe que tiene estas dos cosas en el camino equivocado.

02:15.020 --> 02:21.710
Una vez que haya calculado el nuevo vector para viajar, utilice nuevamente su Traductor y coloque el vector que calculó

02:21.710 --> 02:23.740
en el interior, multiplique por velocidad

02:23.810 --> 02:27.080
y multiplique por Tiempo. deltaTime.

02:27.080 --> 02:29.680
Entonces todavía estamos viajando a lo largo de un

02:29.720 --> 02:31.840
vector, pero esta vez lo hemos calculado.

02:31.910 --> 02:34.880
Así que guarde eso, vuelva a la Unidad.

02:34.880 --> 02:41.870
Ahora querrás tomar uno de tus personajes y arrastrar y soltar ese guión del proyecto sobre ellos.

02:41.930 --> 02:48.350
Aquí puede ver que tengo el script MoveToGoal adjunto y he configurado la velocidad a 2 (bueno, el código lo hizo de

02:48.350 --> 02:49.240
todos modos).

02:49.340 --> 02:54.380
Agarra tu cubo y asegúrate de arrastrarlo y soltarlo como la posición del objetivo.

02:54.380 --> 02:57.860
Ahora presiona Reproducir y mira lo que sucede.

02:58.100 --> 03:04.190
Entonces, tu personaje ha calculado la dirección que debe seguir y llegará a la

03:05.090 --> 03:06.440
ubicación de la

03:06.950 --> 03:14.840
meta y luego dejará de moverse, pero está nervioso. La razón es porque todavía estás dentro de ese ciclo de actualización pidiéndole que

03:14.840 --> 03:18.100
calcule la dirección hacia la meta y avance hacia ella.

03:19.120 --> 03:28.180
Ahora, en la mayoría de los casos, no conseguirás que tu personaje aparezca en la ubicación exacta de tu objetivo y, por lo

03:28.180 --> 03:34.650
tanto, debes tener algún tipo de cálculo 'lo suficientemente cerca es lo suficientemente bueno' incluido.

03:35.490 --> 03:37.730
Justo antes de hacer eso, quiero mostrarte algo.

03:37.750 --> 03:45.000
Si movemos a nuestro personaje aquí y presionamos Reproducir, calculará un nuevo vector para la meta y

03:45.000 --> 03:46.890
avanzará hacia la meta.

03:46.890 --> 03:51.410
Ahora, para detener esa inquietud que ocurre cuando llegan a la meta, regrese

03:51.780 --> 03:57.220
al código y queremos poner algo en la actualización aquí para probar si hemos alcanzado nuestra meta.

03:57.270 --> 04:03.900
Si hemos alcanzado nuestro objetivo, entonces no queremos seguir calculando el vector hacia él y avanzando

04:03.900 --> 04:04.980
hacia él.

04:05.010 --> 04:12.880
Entonces puedes hacerlo probando la longitud de la dirección. Ya has calculado este vector y ¿puedes recordar cómo se

04:13.050 --> 04:17.940
llama, la longitud de un vector? Es la magnitud.

04:17.940 --> 04:30.560
Entonces podemos decir 'if (dirección. magnitud> 5) luego avance hacia la

04:30.770 --> 04:32.820
meta.

04:32.960 --> 04:36.170
Así que guarde eso y vamos a verlo.

04:36.170 --> 04:42.160
Entonces, cada vez que se repite y se calcula la dirección, se vuelve cada vez más

04:42.170 --> 04:48.930
corto, el vector en sí mismo. No permanece establecido en el vector original. Aunque todavía está en

04:49.220 --> 04:51.510
la misma dirección, será más corto.

04:52.480 --> 04:54.330
Así que ahora puedes ver que se movió.

04:54.340 --> 05:00.400
pero no muy lejos y eso es porque una distancia de 5 es aproximadamente esa distancia

05:00.400 --> 05:06.640
en este caso, porque estos son pequeños personajes bastante pequeños y tendrás que asumir la responsabilidad

05:06.910 --> 05:11.240
de comprobar la escala que está ocurriendo en tu mundo.

05:11.350 --> 05:18.240
Así que volvamos aquí y hagamos esto 1 y ejecútelo de nuevo.

05:23.540 --> 05:29.770
Ok, entonces debe estar a una distancia de 1 del cubo y si hacemos clic en el cubo y observamos el que creé, puedes

05:29.770 --> 05:33.320
ver que la escala es 0. 2) Eso hace que ese cubo (en términos mundiales) tenga unos 20 cm de ancho.

05:33.400 --> 05:37.000
Cuando un cubo tiene el tamaño 1, que es su tamaño predeterminado, eso sería 1 mx 1 mx 1 m en

05:37.000 --> 05:45.840
el mundo de Unity y, por lo tanto, puede imaginar que 5 de esos cubos encajarían en ese espacio allí, para esa distancia de 5 desde antes. Ahora puedes ver que todavía es

05:45.840 --> 05:48.850
bastante grande, si

05:48.850 --> 05:55.570
quieres que tu personaje esté justo encima de la

05:55.570 --> 05:58.670
ubicación de la meta.

05:58.690 --> 06:04.270
Entonces, intentemos una vez más con un valor

06:04.270 --> 06:05.020
menor.

06:05.020 --> 06:14.100
Regrese a MoveToGoal y cambiaremos esto a 0. 2f.

06:14.100 --> 06:14.100
Guarda eso y ejecútalo de nuevo y el personaje debería estar muy cerca del objetivo en este caso y puedes ver que lo está, así que eso es bastante aceptable.

06:14.240 --> 06:17.510
Voy

06:18.040 --> 06:22.120
a mover este

06:22.180 --> 06:27.080
valor de 0.

06:27.220 --> 06:34.510
1 arriba, así que hagamos esta 'precisión de flotación pública' porque es la precisión que estamos dispuestos a llevar a un objetivo cercano. Vamos a ponerlo

06:34.840 --> 06:42.930
a 0. 01f.

06:42.930 --> 06:42.930
Así que lo haremos muy cerca y luego aquí abajo, pondremos precisión ...

06:43.120 --> 06:49.730
como eso.

06:49.730 --> 06:49.730
Muy bien, así que guárdelo y volveremos y lo ejecutaremos y solo veremos si eso hace alguna diferencia con esa precisión tan estricta.

06:49.930 --> 06:58.780
Eso es bastante bueno.

06:59.540 --> 07:01.060
Lo que quiero mostrarte es algo que hará que tu personaje siga inquieto con este código en particular.

07:01.280 --> 07:07.510
Cambiemos la velocidad a cinco con esa precisión realmente ajustada y corramos de nuevo Ok, por lo que el personaje tembló antes de que

07:07.510 --> 07:08.560
finalmente alcanzara esa precisión.

07:08.980 --> 07:15.500
Lo que está sucediendo aquí es que llegó a la meta, superó la marca, recalcula la dirección de regreso a la meta, sobrepasa la marca y termina rebotando de esta manera porque su

07:18.940 --> 07:19.210
5

07:19.220 --> 07:23.820
velocidad aquí la empuja sobre la meta y luego empuja sobre el objetivo y empujarlo sobre el objetivo de esa manera también.

07:24.020 --> 07:30.680
En este caso tuvimos suerte de que eventualmente se moviera a una

07:30.680 --> 07:40.110
posición que pudiera alcanzar esa precisión, pero a veces no entrarás con esa precisión y obtendrás un

07:40.110 --> 07:44.760
comportamiento realmente extraño en lo que respecta al

07:44.760 --> 07:46.210
personaje bailando.

07:46.440 --> 07:53.100
El

07:53.100 --> 08:03.310
punto de gol.

08:03.420 --> 08:07.470
Eso se debe a que nunca está llegando allí dentro de su precisión.

08:07.470 --> 08:13.440
Entonces, si obtienes eso, solo juega con tus valores de precisión hasta que los hayas elevado lo

08:13.440 --> 08:19.170
suficiente como para evitar que eso suceda, de lo contrario tendrás que reducir la velocidad a

08:19.380 --> 08:21.920
la que atacan tu posición de objetivo.

08:22.290 --> 08:25.360
Voy a volver a poner esta precisión en 1 para este y

08:25.380 --> 08:27.310
luego para el otro personaje ...

08:27.360 --> 08:32.130
pongamos el mismo código y dejémoslo con la velocidad predeterminada, pero

08:32.130 --> 08:37.680
establezcamos la precisión en 0. 1 en lugar de 1.

08:37.740 --> 08:43.350
También necesitamos establecer el cubo en la ubicación de la meta para este tipo aquí y ahora

08:43.650 --> 08:50.450
si presionas Reproducir, se moverán hacia la posición de meta. Como actualmente lo tenemos funcionando, se deslizarán desde su posición

08:50.450 --> 08:55.460
actual hasta la posición de meta, pero no giran y miran en la dirección en

08:55.460 --> 08:57.410
la que viajan, y eso

08:57.410 --> 09:01.060
sería una buena adición para que un personaje haga eso .

09:01.960 --> 09:10.150
En los viejos tiempos, teníamos que calcular los ángulos entre los vectores y de qué lado estaban los

09:10.150 --> 09:16.000
vectores, en relación con los otros vectores, para descubrir cómo cambiar tu

09:16.000 --> 09:16.790
personaje.

09:17.020 --> 09:20.810
Ahora tenemos esta gran función llamada LookAt that Unity tiene que

09:20.830 --> 09:26.590
hace todo ese trabajo duro por nosotros y voy a ponerla en la función de Inicio para que

09:26.590 --> 09:30.480
nuestro personaje primero gire y mire hacia dónde está a punto de ir.

09:30.670 --> 09:37.710
Ese método o función se llama LookAt y lo agrega al final de la transformación y luego le

09:37.710 --> 09:44.080
da la posición de meta que desea que vea su personaje y se moverá y mirará

09:44.080 --> 09:45.360
en esa dirección.

09:45.370 --> 09:54.190
Ahora, en este punto, si lo ejecuto, porque hemos cambiado la orientación del personaje, este Traductor no funcionará correctamente y solo guardaremos

09:54.700 --> 10:00.610
esto y volveremos y echaremos un vistazo rápido a lo que obtienes y yo

10:00.610 --> 10:03.010
' Te mostraré cómo solucionarlo.

10:03.010 --> 10:09.070
Así que ahí tenemos esto y puedes ver que los personajes tienden a arquearse hacia

10:09.070 --> 10:14.990
él y este personaje simplemente girará en espiral hasta que se acerque lo suficiente.

10:15.040 --> 10:23.560
Lo que sucede allí es que ahora que estos personajes ya no están (0,0,0) rotación aquí

10:23.560 --> 10:26.280
arriba en la transformación.

10:26.290 --> 10:31.600
Si ha estado siguiendo y ha cambiado la rotación de sus personajes, probablemente no podría descubrir qué

10:31.600 --> 10:33.450
estaba mal con su código

10:33.460 --> 10:35.560
y este es el problema exacto.

10:35.560 --> 10:42.340
Entonces, en su MoveToGoal, lo que quiere hacer en su Traductor es 'traducir' su

10:42.370 --> 10:49.360
personaje a lo largo de este vector en 'espacio mundial' en lugar de 'espacio local'.

10:49.360 --> 10:56.890
Ahora, si guardas eso y corres, verás que tus personajes se vuelven hacia su objetivo

10:57.370 --> 11:03.070
y luego viajan hacia él. En la escena, tengo estas líneas rojas que habrías visto y

11:03.100 --> 11:08.280
que dibujan los vectores del código con una depuración. DrawRay que dibuja un rayo

11:08.410 --> 11:14.300
desde la posición en una dirección particular y luego le da un color.

11:14.320 --> 11:17.370
Esto es realmente útil para depurar para ver qué está pasando.

11:17.380 --> 11:24.730
Así que acabo de incluir eso, para que pueda usarlo en su propio código para ver qué vectores están haciendo

11:24.730 --> 11:26.770
qué y hacia dónde apuntan.

11:26.770 --> 11:29.810
Muy bien, esa es la manera fácil de hacer un LookAt.

11:30.010 --> 11:37.210
Es posible que hayas notado en este punto, si lo ejecutamos nuevamente y agarras el cubo y en la escena

11:37.210 --> 11:43.570
lo mueves, verás que los personajes responden a su ubicación de forma natural, debido a lo que

11:43.570 --> 11:45.460
hay en esa actualización.

11:45.490 --> 11:50.590
Tenga en cuenta que LookAt no se está actualizando y eso es porque todavía está en la función Inicio.

11:50.590 --> 11:59.380
Entonces, si cambiamos ese LookAt aquí y nos aseguramos de volver a calcularlo cada vez dentro de nuestra Actualización, los

12:00.010 --> 12:08.830
personajes siempre estarán mirando ese cubo y luego lo que podrías hacer es obtener un guión de conducción para que puedas

12:08.860 --> 12:16.620
manejar ese cubo con el teclas de flecha y los personajes se moverían donde quiera que vaya.
