WEBVTT

00:11.580 --> 00:17.770
La forma en que tenemos configurado nuestro personaje actual es usar el LookAt para girar hacia la ubicación objetivo,

00:17.910 --> 00:22.980
pero el problema con esto es que hace que tu personaje se mueva instantáneamente.

00:22.980 --> 00:31.120
En cambio, queremos introducir un método para que nuestro personaje gire lentamente hacia el objetivo.

00:31.260 --> 00:37.070
Para hacer eso, usaremos la interpolación lineal esférica o SLERP para abreviar y lo

00:37.320 --> 00:43.620
que hace es interpolar entre el vector que estamos enfrentando actualmente y la dirección en

00:43.620 --> 00:45.790
la que queremos estar.

00:45.930 --> 00:53.010
Lo hace durante un período de tiempo particular, de modo que puede girar un poco cada vez hasta llegar

00:53.010 --> 00:55.290
a la dirección de su meta.

00:55.290 --> 01:00.510
Comencemos a implementar esto en Unity. Así que vamos a modificar el proyecto anterior con

01:00.780 --> 01:03.300
el que terminamos dentro del script MoveLocal.

01:03.300 --> 01:12.380
Lo primero que necesitamos es un flotador para la velocidad de rotación, así que llamémoslo rotSpeed y lo pondré a 0. 5f.

01:12.460 --> 01:18.480
Lo más probable es que una vez que comience a mover a sus personajes, no querrá que la velocidad y la

01:18.480 --> 01:20.490
velocidad de rotación sean exactamente las mismas.

01:20.610 --> 01:27.020
Por lo tanto, tener dos valores diferentes funciona muy bien porque puede ajustar cualquiera de los dos. Por supuesto, en este caso, los tengo

01:27.030 --> 01:28.520
lo mismo.

01:28.540 --> 01:32.400
De hecho, podría bajar eso a 0. 1)

01:32.400 --> 01:39.660
Ahora, tenemos un lookAtGoal, pero también necesitamos calcular la dirección en la que queremos estar, así

01:39.660 --> 01:45.180
que volveremos a lo que teníamos originalmente y combinaremos estos dos.

01:45.180 --> 01:48.720
Entonces, queremos trabajar en nuestra dirección que debemos enfrentar.

01:48.720 --> 02:03.340
Por lo tanto, es una dirección de Vector3 y será igual a nuestro lookAtGoal menos nuestra posición actual.

02:03.390 --> 02:12.360
Ahora, el único otro cambio que tenemos que hacer es convertir este LookAt aquí en un slerp que usará la dirección

02:12.750 --> 02:14.070
como su rumbo.

02:14.310 --> 02:18.340
Así que elimine la línea LookAt y reemplácela con esto.

02:18.390 --> 02:26.850
El slerp está configurando la rotación de tu personaje, por lo tanto, estamos haciendo esto. transformar. rotación = en lugar

02:26.910 --> 02:35.220
de una posición o un Traductor y esto. La rotación se establece utilizando el método

02:35.310 --> 02:44.400
slerp que puede encontrar en la clase Quaternion. Quaternion es una estructura de datos compleja que mantiene una rotación y

02:45.030 --> 02:47.360
puede hacer todo tipo de cosas

02:47.370 --> 02:52.940
fantásticas, pero en este caso está girando un ángulo de mirar en una dirección a otra.

02:53.130 --> 02:57.920
Entonces el slerp mismo toma la rotación actual de tu personaje.

02:58.350 --> 03:07.350
Luego realiza una LookRotation en su dirección, por lo que la dirección es nuestro vector que calculamos que apunta hacia

03:07.350 --> 03:13.650
nuestra meta, pero no podemos hacer el slerp en el vector de dirección.

03:13.650 --> 03:18.750
Queremos hacer el slerp en el ángulo que tenemos que rotar, para llegar desde donde

03:18.750 --> 03:20.940
estamos mirando a la dirección particular.

03:20.940 --> 03:23.400
Entonces este Quaternion. LookRotation

03:23.400 --> 03:33.420
nos dará la rotación que debe ocurrir para estar orientados en 'dirección' y, por lo tanto, combinar estos dos

03:33.420 --> 03:36.130
y compararlos poco a poco,

03:36.180 --> 03:39.970
luego lentamente pasamos de uno a otro.

03:39.990 --> 03:46.650
Ahora, la velocidad a la que giramos es el tercer valor que pones dentro de este método y

03:46.650 --> 03:54.210
lo basamos en el mismo tipo de velocidades que usamos para mover un personaje hacia adelante, donde tenemos el tiempo delta

03:54.210 --> 03:57.120
multiplicado por nuestro tiempo de rotación .

03:57.120 --> 03:57.300
Correcto.

03:57.300 --> 04:03.210
Así que guardemos eso y entremos en Unity y veamos cómo funciona esto. Asegúrate de que tu personaje esté alejado

04:03.210 --> 04:11.420
de la meta, para que puedas ver cómo se produce el giro. Así que presiona Play y el personaje seguirá siendo empujado hacia adelante

04:11.750 --> 04:17.020
a lo largo de su vector hacia adelante, que es lo que queremos y, al mismo tiempo,

04:17.210 --> 04:22.700
ese slerp está operando para darle la vuelta a tu personaje y puedes ver aquí en la vista

04:22.700 --> 04:26.130
de escena que está comenzando a arco alrededor hacia allí.

04:26.140 --> 04:30.780
Ahora es un poco lento, esta velocidad de rotación, así que detengamos eso.

04:30.950 --> 04:31.950
Regrese a

04:31.970 --> 04:33.710
nuestro MoveLocal y aumente.

04:33.710 --> 04:40.940
Entonces, si ponemos eso para decir 4 y lo guardamos y luego lo ejecutamos nuevamente.

04:44.130 --> 04:53.280
Descubrimos que el personaje gira mucho más bruscamente y ahora podemos conducir nuestro cubo y el

04:53.280 --> 04:56.690
personaje girará y lo seguirá.

04:56.730 --> 05:02.700
Así es como mueve a su personaje hacia adelante y cómo realiza un slerp

05:02.700 --> 05:04.140
para que su

05:04.350 --> 05:12.420
personaje se oriente en la dirección correcta y solo en estos pocos videos, hemos cubierto casi todos los conceptos

05:12.420 --> 05:18.160
básicos que necesitará para obtener algunos comportamiento complejo que ocurre en los NPC.
