WEBVTT

00:11.500 --> 00:14.400
Además de girar un personaje y moverlo a lo largo de un

00:14.440 --> 00:20.230
vector establecido, también podemos girar el personaje y empujarlo en la dirección que está mirando (o a lo largo de uno de sus vectores locales).

00:20.980 --> 00:21.650
En

00:21.670 --> 00:29.950
Unity, un personaje tiene 3 vectores locales: z para adelante, y para arriba yx para derecha, independientemente de la rotación del personaje, podemos

00:29.950 --> 00:35.800
impulsar cualquiera de estos vectores locales con la función Traducir, especificando el movimiento en uno (o

00:35.830 --> 00:43.300
más ) de los ejes locales x, y y z. Para mover el personaje hacia adelante a una velocidad

00:43.300 --> 00:49.720
constante, modificaríamos solo su coordenada z. Para mover un personaje a la derecha a

00:49.780 --> 00:53.160
una velocidad constante, modificaríamos su coordenada x y para

00:53.170 --> 00:56.060
moverlo hacia arriba, modificaríamos su coordenada y.

00:56.100 --> 01:02.220
También puedes mover un personaje hacia atrás, hacia la izquierda y hacia abajo especificando una velocidad negativa.

01:02.410 --> 01:07.450
Si modifica la rotación de un eje mientras lo gira, el personaje se moverá en una dirección del

01:07.450 --> 01:08.400
mundo diferente, sin

01:08.500 --> 01:12.190
embargo, todavía se moverá a lo largo de su eje local especificado.

01:12.220 --> 01:17.980
Por ejemplo, si un personaje cambia de dirección mientras se lo empuja a lo largo de un eje z, se moverá alrededor

01:17.980 --> 01:18.910
del mundo, pero

01:19.090 --> 01:25.060
en relación con sí mismo, seguirá moviéndose a lo largo de su eje z, ya que es el eje de avance de

01:25.060 --> 01:29.020
los caracteres que ha cambiado en el rotación y no su velocidad de movimiento.

01:29.410 --> 01:31.950
Entonces, intentemos todo esto en un proyecto.

01:31.960 --> 01:38.530
Descargue el proyecto 'PushForward', que es el recurso que viene con esta conferencia y cuando lo abra,

01:38.530 --> 01:44.680
abra la escena de zombies (porque todo es mejor con zombies) y abra y eche

01:44.830 --> 01:51.490
un vistazo a lo que tiene allí . Si presiona Reproducir en este punto, notará que tiene un zombie animado que

01:51.490 --> 01:54.570
no va a ninguna parte ... rápido y

01:54.700 --> 01:57.440
con aspecto de cubo.

01:57.580 --> 02:02.500
Si usa las teclas de flecha, encontrará que puede rotar ese cubo y conducirlo.

02:02.500 --> 02:11.650
Este cubo será nuestro objetivo y al moverlo se nos permitirá ver la rotación de ese zombi y cómo vamos

02:11.650 --> 02:13.720
a empujarlo hacia adelante.

02:13.720 --> 02:20.170
Muy bien, entonces dejemos de jugar eso. El cubo en sí, si está interesado, tiene un código de

02:20.170 --> 02:27.780
'Unidad' y puede ver ese script y lo que hace, simplemente conduce el cubo. Nuevamente, lo empuja de la misma manera que lo

02:27.820 --> 02:34.130
estamos haciendo con nuestro personaje zombie y también tiene una rotación allí, pero ese no es

02:34.300 --> 02:36.750
el enfoque de esta lección.

02:36.850 --> 02:44.590
Estamos buscando mover al zombi, cambiar su dirección (por lo que siempre está mirando este cubo) y empujarlo a lo largo

02:44.590 --> 02:46.390
de su eje z.

02:46.390 --> 02:52.260
Ahora, si hace clic en el modelo en sí y observa, verá que su eje z está orientado hacia

02:52.410 --> 02:55.020
adelante y esto es lo que estamos empujando.

02:55.270 --> 03:03.120
Así que cree un nuevo archivo C # llamado 'MoveLocal'. En ese script, vas a agregar esto.

03:03.130 --> 03:06.250
Entonces es similar a lo que tuvimos en la conferencia anterior.

03:06.280 --> 03:12.720
Tenemos un 'objetivo' que pasaremos (ese será nuestro cubo) y tenemos una velocidad.

03:12.880 --> 03:19.690
Ahora deberá ajustar esta velocidad, en función de la animación y de si encaja con ella. A veces, si su velocidad es demasiado

03:19.690 --> 03:27.250
rápida o demasiado lenta para la animación en particular, el personaje se deslizará y hay

03:27.250 --> 03:33.190
muchas formas de solucionarlo, pero tampoco volveremos a profundizar tanto con la

03:33.220 --> 03:33.990
animación.

03:34.120 --> 03:34.430
Correcto.

03:34.450 --> 03:42.100
Entonces agregue eso y luego en la Actualización, tenemos una transformación. Mire para cambiar la dirección en la que estamos buscando

03:42.100 --> 03:49.180
a nuestro zombie, que será la posición de 'objetivo' y luego empujaremos al zombi a lo largo de su eje

03:49.180 --> 03:56.260
z usando nuestra velocidad y multiplicándolo por el tiempo. deltaTime.

03:56.290 --> 03:58.750
Ahora estoy haciendo esto en la Actualización y

03:58.840 --> 04:00.080
¿qué te dije antes?

04:00.100 --> 04:02.900
Siempre olvido poner LateUpdate, así que pongamos eso allí.

04:03.130 --> 04:04.750
Ahora guarda eso.

04:04.930 --> 04:10.550
Vuelve a Unity y quieres adjuntar ese 'MoveLocal' a Jill (Jill es el nombre

04:10.570 --> 04:18.280
de nuestro zombie) en el nivel más alto. Al buscar a Jill en el Inspector, ella tendrá una Transformación, un

04:18.280 --> 04:24.670
Animador y luego el guión que ha agregado allí. En el script, verás que el

04:24.670 --> 04:34.560
'objetivo' ha sido expuesto, así que toma tu cubo y arrastra y suelta eso como el objetivo de nivel superior.

04:34.600 --> 04:40.630
Ok, ahora presiona Play y ella comenzará a moverse hacia el cubo.

04:40.810 --> 04:51.950
Ahora, si alejamos esto, debido al LookAt, ella estará constantemente girando y mirando el cubo.

04:52.070 --> 04:57.470
Todos en esta escena están flotando sobre el suelo, pero

04:57.470 --> 05:05.030
puedes ajustar eso agarrando a tu personaje y conduciéndolo hacia el suelo y también agarrando

05:05.930 --> 05:09.100
tu cubo y conduciéndolo así.

05:09.100 --> 05:15.190
Ok, entonces ten otra jugada.

05:15.250 --> 05:20.570
Ahora puede ver que el personaje todavía está flotando un poco por encima del suelo y

05:20.860 --> 05:25.600
tenemos el mismo problema con el parpadeo que tuvimos en la conferencia anterior, donde

05:25.600 --> 05:30.760
el personaje alcanzará el punto objetivo y luego seguirá intentando llegar al punto objetivo. ,

05:30.760 --> 05:32.470
ligeramente sobrepasando y regresando

05:32.470 --> 05:35.800
e intercambiando direcciones, pero si aleja su cubo, se detendrá.

05:35.920 --> 05:37.490
Ahora todavía está

05:37.530 --> 05:45.640
flotando en el aire y esto resalta otro problema con este código en particular, que es que va a cambiar y

05:45.910 --> 05:50.750
mirar ese cubo, donde sea que esté.

05:50.830 --> 05:57.220
El LookAt no discrimina si el cubo está en el aire. Así que vamos a mover este cubo así y

05:57.220 --> 06:03.880
veamos cómo ese LookAt está moviendo el eje z, para que cambie y siempre esté orientado hacia el cubo.

06:03.880 --> 06:12.460
Si hacemos una pausa y miramos a Jill, verás que su eje z se está girando hacia nuestra posición de cubo y esto

06:12.490 --> 06:19.300
causará muchos problemas cuando comiences a mover objetos que realmente deberían permanecer en el suelo (como un humanoide)

06:19.300 --> 06:26.380
para mirar la posición de la meta que está en el espacio 3D y puede estar en el

06:26.470 --> 06:27.200
aire.

06:28.040 --> 06:36.230
Para recapitular sobre eso, lo que está haciendo LookAt es rotar su modelo para que el eje z apunte

06:36.230 --> 06:39.140
hacia la posición de la meta.

06:39.320 --> 06:42.410
Por lo tanto, no importa en qué parte

06:42.410 --> 06:50.060
del espacio 3D se ubique ese objetivo, orientará el modelo 3D, de modo que esté orientado en esa dirección y este es

06:50.240 --> 06:54.150
un problema real para los personajes que necesitan permanecer en tierra.

06:54.200 --> 07:01.550
En cambio, lo que queremos hacer es que nuestro personaje gire en la dirección del objeto, pero solo en

07:01.640 --> 07:10.310
el plano xy en el plano, de modo que el eje z se alinee con la posición del objeto en un eje

07:10.310 --> 07:14.570
vertical desde él, en exactamente la misma altura del personaje.

07:14.690 --> 07:21.420
Por lo tanto, necesitamos que el personaje realice un LookAt en un punto que esté en la misma y que el

07:21.530 --> 07:29.210
personaje, pero las mismas x y z que el objeto objetivo. Lograr esto en Unity es solo un

07:29.210 --> 07:36.620
pequeño ajuste a nuestro código MoveLocal. En lugar de realizar un LookAt en el objetivo (que es

07:36.710 --> 07:44.570
nuestro cubo por el que estamos pasando), calculamos una nueva posición de objetivo para mirar, que estará en la misma posición xyz del cubo,

07:44.570 --> 07:45.450
como puede

07:45.620 --> 07:49.900
ver aquí , pero su posición y es la misma que nuestro personaje.

07:50.060 --> 07:57.590
Luego usamos esta nueva posición que hemos calculado (que he llamado lookAtGoal y

07:57.650 --> 08:07.430
la usamos dentro de LookAt en su lugar. Entonces, una vez que haya actualizado su código, si lo guarda, regrese a

08:07.430 --> 08:15.110
Unity y ejecútelo, puede mover su cubo en altura (como puede ver aquí, mi cubo ya está flotando) y no afecta al

08:15.260 --> 08:16.930
zombie personaje en absoluto.

08:16.940 --> 08:24.070
Por lo tanto, se queda en tierra y, por lo tanto, su z no se gira hacia arriba.

08:24.080 --> 08:31.750
Se queda paralelo al suelo.

08:31.760 --> 08:37.280
Una última cosa para completar nuestro código es hacer que el zombie deje de moverse cuando llegue a la

08:37.280 --> 08:39.620
ubicación, para que no se sientan nerviosos.

08:39.620 --> 08:43.340
En primer lugar, necesitaremos agregar un valor de "precisión".

08:43.860 --> 08:46.870
Entonces, esto es muy similar al código que hemos hecho antes.

08:47.780 --> 08:50.710
Lo pondré a 1. 0f.

08:50.870 --> 08:54.610
en este caso y puedes ajustar eso más tarde.

08:54.770 --> 09:01.640
Luego, queremos probar la precisión antes de hacer un traductor, por lo que seguiremos buscando incluso si estamos lo

09:01.640 --> 09:10.760
suficientemente cerca, pero no nos acercaremos más. Entonces 'si' y en este caso, no tenemos una dirección. magnitud para usar como nuestra distancia a

09:10.760 --> 09:17.840
la meta porque nunca hemos calculado la dirección, por lo que esto es un poco

09:17.840 --> 09:20.270
diferente al código anterior.

09:20.270 --> 09:26.990
Pero lo que realmente viene con nuestros vectores es que podemos calcular la distancia entre 2 posiciones

09:27.290 --> 09:32.300
y podemos hacerlo con Vector3. Distancia y queremos encontrar

09:32.450 --> 09:41.060
la distancia entre nuestra ubicación actual (que es transformar. posición) y la posición de

09:41.120 --> 09:42.150
gol.

09:42.170 --> 09:46.740
Entonces gol. posición Así que

09:46.840 --> 09:57.130
esa es su declaración 'si' y allí queremos probar si la distancia es mayor que nuestra precisión,

09:57.190 --> 10:01.990
lo que nos permitirá seguir avanzando, de lo

10:02.110 --> 10:05.660
contrario no se ejecutará ese Traductor.

10:06.130 --> 10:13.060
Entonces, al resolver este Vector3. Distancia entre estas dos posiciones, es esencialmente lo

10:13.450 --> 10:20.350
mismo que encontrar la dirección (o el vector) entre esos dos valores quitando uno del otro y

10:20.350 --> 10:23.490
luego usando el. magnitud.

10:23.500 --> 10:29.470
Es el mismo cálculo, son solo diferentes formas de resolverlo. Entonces podría entrar aquí y calcular la dirección

10:29.470 --> 10:34.390
y obtener la magnitud de ese vector, o puede usar esta función de distancia.

10:34.510 --> 10:34.720
Correcto.

10:34.720 --> 10:44.310
Así que guárdelo y ahora volveremos a Unity y lo ejecutaremos ... y conducir ... conduzcamos un poco más cerca.

10:45.950 --> 10:53.000
Ahora todavía podemos ver, en este caso, que tenemos 'nerviosismo'.

10:53.170 --> 11:01.300
La razón es que nuestra distancia actual es calcularla entre la distancia del cubo real y la distancia del zombi, pero el

11:01.930 --> 11:04.500
zombi no está tratando de llegar a

11:04.500 --> 11:10.060
la posición del cubo, está tratando de llegar a la posición que está debajo del

11:10.240 --> 11:12.770
cubo en La misma altura.

11:13.030 --> 11:20.740
Por lo tanto, tiene muy pocas esperanzas (especialmente si este cubo está en el aire) para que esté

11:20.740 --> 11:25.180
cerca porque no se le permite moverse hacia arriba.

11:25.360 --> 11:32.260
Así que haremos un pequeño ajuste a nuestro código, de vuelta aquí. En lugar de tratar de obtener la distancia

11:32.800 --> 11:38.920
entre nuestro personaje y la posición del objetivo, lo que podría no ser posible porque esa

11:38.920 --> 11:44.190
posición del objetivo está en el aire, entonces solo queremos llegar desde el LookAt.

11:44.220 --> 11:51.780
Así que lo pondremos allí, guárdelo y regrese y corra.

11:51.820 --> 11:57.350
Ahora, cuando el zombi se acerque lo suficiente a nuestro cubo, dejará de moverse.

11:57.370 --> 12:01.960
Por supuesto, la animación todavía se está ejecutando, pero no

12:01.960 --> 12:10.000
estamos trabajando con eso en este momento y no importa cuán alto en el aire mueva esto y la

12:10.300 --> 12:19.660
distancia real entre estos dos, solo se trata de la distancia entre sí y esta posición aquí está a la misma altura.

12:19.690 --> 12:27.570
Así que ahora puedo conducir este cubo y el zombie aún lo seguirá pero permanecerá en tierra ...

12:29.470 --> 12:35.060
y cuando nos acerquemos lo suficiente, se detendrá.

12:35.070 --> 12:39.150
Así es como mueves un personaje a lo largo de su eje delantero.
