WEBVTT

00:00.050 --> 00:00.530
Hola a todos.

00:00.530 --> 00:01.460
Bienvenidos al video.

00:01.460 --> 00:05.900
En este video quiero mostrarte cómo hacer las animaciones de salto y caída.

00:05.900 --> 00:09.410
Y también quiero limpiar un poco más nuestro código.

00:09.410 --> 00:13.490
Así que primero hagamos las animaciones de salto y caída.

00:13.550 --> 00:21.020
Vamos a la ventana de animación, seleccionamos el animador y luego hacemos clic en Crear nuevo clip en la carpeta de animaciones.

00:21.020 --> 00:24.200
Necesitamos Player Jump.

00:26.510 --> 00:27.920
Y necesitamos uno más.

00:27.920 --> 00:30.830
Crear nuevo clip player.

00:31.070 --> 00:31.850
Hold.

00:32.510 --> 00:33.530
Muy bien.

00:33.560 --> 00:37.040
Ahora seleccionemos la carpeta de gráficos aquí.

00:37.580 --> 00:44.810
Ve al personaje principal, GUI virtual, y toma esta carpeta de animación, solo un sprite y colócalo aquí.

00:44.810 --> 00:48.380
La tasa de muestreo no es importante porque solo tenemos un fotograma aquí.

00:48.710 --> 00:50.990
Ahora seleccionemos jump.

00:52.510 --> 00:53.680
Y colócalo aquí.

00:53.680 --> 00:55.480
Esto será para la animación de salto.

00:55.750 --> 01:01.330
Ahora nuestro objetivo es alternar entre estas dos animaciones cuando el jugador sube o baja.

01:01.690 --> 01:06.910
Por suerte para nosotros eso es muy fácil de hacer y ya hicimos algo similar con el movimiento antes.

01:07.360 --> 01:12.010
Vamos al animador y podemos eliminar estos dos estados de animación.

01:12.010 --> 01:13.000
No los necesitamos.

01:13.000 --> 01:18.880
Y aquí vamos a crear un nuevo Blend Tree que voy a llamar Jump.

01:19.920 --> 01:20.880
Salto.

01:22.410 --> 01:23.250
Muy bien.

01:23.250 --> 01:25.290
Ahora entremos en este archivo de salto.

01:25.680 --> 01:26.610
Selecciona.

01:26.610 --> 01:28.950
Y aquí necesitamos un nuevo parámetro.

01:28.950 --> 01:31.080
No podemos usar la velocidad x para esto.

01:31.080 --> 01:33.480
Para este usaremos la velocidad y.

01:33.480 --> 01:39.210
Así que agregamos un parámetro float aquí y escribimos y velocity.

01:40.880 --> 01:45.290
Ahora vamos a parámetros y elegimos y velocity aquí.

01:45.560 --> 01:48.350
Y ahora necesitamos agregar dos campos de movimiento.

01:48.380 --> 01:49.670
Agregar campo de movimiento.

01:49.700 --> 01:50.840
Agregar campo de movimiento.

01:52.640 --> 01:55.580
Uno aquí será player fall.

01:55.700 --> 01:58.490
El segundo será player jump.

01:59.760 --> 02:05.280
Y desmarcamos automático en el umbral y ponemos -1 y 1.

02:05.730 --> 02:07.440
Así que ahora vamos a reproducir la animación.

02:07.440 --> 02:11.040
Y podemos ver que si la velocidad y es mayor que cero, salta.

02:11.190 --> 02:12.270
Si es menor que cero, cae.

02:12.420 --> 02:14.850
Y solo necesitamos actualizar este parámetro en el script.

02:15.450 --> 02:18.000
Eso es todo lo que necesitamos hacer.

02:19.980 --> 02:23.220
Vamos al jugador.

02:26.880 --> 02:28.890
Y actualicemos rápidamente este parámetro.

02:29.710 --> 02:36.880
En la animación, elegimos anim set float para la y.

02:36.880 --> 02:40.660
La velocidad será nuestra velocity.y.

02:41.260 --> 02:41.650
Por ahora.

02:41.650 --> 02:44.920
Solo vamos allí y asegurémonos de que funcione.

02:44.920 --> 02:46.930
Regresamos a Unity.

02:50.820 --> 02:51.930
Vamos a base layer.

02:51.930 --> 02:53.130
Haz clic en play.

02:55.920 --> 02:57.060
Y vemos que y velocity es cero.

02:58.140 --> 02:59.370
Ahora voy a intentar saltar.

02:59.370 --> 03:01.470
Y sí, estamos actualizando el valor.

03:01.530 --> 03:07.530
El único objetivo ahora es conectar estos dos estados aquí, igual que en el primer ejemplo.

03:07.530 --> 03:11.130
Pero esta vez la condición será más simple.

03:11.130 --> 03:14.460
Vamos a comprobar si está en el suelo o no.

03:14.850 --> 03:18.270
Y no necesitamos hacer mucho porque ya tenemos la comprobación de colisión.

03:18.270 --> 03:22.650
Solo necesitamos un parámetro bool que diga is grounded.

03:24.080 --> 03:26.150
Luego hacemos la transición de idle/move a jump/fall.

03:29.270 --> 03:32.000
La condición será is grounded true.

03:34.360 --> 03:38.680
Has exit time y transición en cero.

03:38.710 --> 03:40.600
Ahora hagamos la transición de regreso.

03:41.610 --> 03:42.900
Esta dirá is grounded true.

03:45.880 --> 03:46.270
True.

03:46.300 --> 03:47.140
Un segundo.

03:47.140 --> 03:48.700
Esto era is grounded false?

03:49.420 --> 03:50.440
Sí.

03:50.890 --> 03:53.350
Y si es true, volvemos a idle/move.

03:54.580 --> 03:54.910
Sí.

03:54.910 --> 03:55.270
Perdón.

03:55.270 --> 03:56.800
Espero no haberte confundido.

03:56.800 --> 03:58.720
Cuando vamos de idle a jump, is grounded false.

04:00.280 --> 04:05.170
Cuando vamos de jump/fall a idle/move, debe ser true.

04:05.200 --> 04:10.960
Transición en cero y exit time para transición inmediata entre animaciones.

04:11.970 --> 04:15.060
Ahora necesitamos actualizar este parámetro en el script también.

04:15.060 --> 04:20.010
Volvemos a los scripts y aquí escribimos anim set bool is grounded al booleano que tenemos.

04:26.960 --> 04:29.090
Ok, guardamos esto.

04:29.090 --> 04:31.040
Regresamos a Unity.

04:32.130 --> 04:33.660
Y probamos.

04:35.350 --> 04:39.160
Voy a saltar y la animación de salto y caída está ahí.

04:40.750 --> 04:42.160
Salto y caída.

04:42.190 --> 04:43.570
¡Qué genial es eso!

04:43.570 --> 04:44.590
Muy genial.

04:44.590 --> 04:45.310
Me encanta.

04:46.110 --> 04:48.240
Ahora volvamos al script del jugador.

04:48.240 --> 04:53.040
Aquí quiero mostrarte algunos trucos para que tu código sea más limpio.

04:53.040 --> 04:54.540
No es obligatorio.

04:54.540 --> 04:55.620
No tienes que hacerlo.

04:55.620 --> 04:56.640
Solo me gusta hacerlo.

04:56.640 --> 04:58.980
Y quiero mostrarte a qué me refiero.

04:59.370 --> 05:06.150
Por ejemplo, cuando tienes solo una línea de código en el método como aquí en jump, puedes quitar las llaves.

05:06.330 --> 05:08.910
Puedes escribir igual y mayor que.

05:19.100 --> 05:23.120
Eso es una expresión lambda.

05:23.120 --> 05:27.350
En resumen, es como decir que este método hará esto por nosotros.

05:27.350 --> 05:33.830
Así que velocity = new Vector2(velocity.x, jumpForce).

05:33.830 --> 05:37.070
Y funcionará igual que antes.

05:37.070 --> 05:40.400
Pero como solo tiene una línea, podemos escribirlo así.

05:40.400 --> 05:46.670
Y será más compacto, porque antes ocupaba mucho espacio y ahora solo esto y aún vemos qué hace la función.

05:51.950 --> 05:52.940
Así se hace.

05:52.940 --> 05:54.770
Y sigue funcionando.

05:54.950 --> 05:56.750
Probemos que funciona.

05:58.570 --> 06:00.100
Funciona igual que antes.

06:00.100 --> 06:00.760
Muy bien.

06:00.760 --> 06:04.420
Pero solo puedes hacer esto si tienes una línea de código.

06:04.420 --> 06:08.590
Si tienes más de una, necesitas llaves.

06:11.210 --> 06:14.840
Por ejemplo, debug log, otra línea de código.

06:18.190 --> 06:21.280
Así que así quiero dejarlo por ahora.

06:22.920 --> 06:29.550
Otro truco útil: si en el if solo tienes una línea, puedes quitar las llaves.

06:31.980 --> 06:34.830
Quita las llaves y asegúrate de no dejar espacios vacíos.

06:39.300 --> 06:42.060
Y funcionará igual que antes.

06:47.490 --> 06:53.040
Pero si tienes más de una línea, necesitas las llaves.

06:56.550 --> 06:58.800
Así de simple.

06:58.830 --> 07:04.350
También podríamos hacerlo aquí, pero luego agregaré otra comprobación de colisión, así que lo dejo con llaves.

07:08.190 --> 07:10.080
Para el movimiento también agregaremos cambios después.

07:13.560 --> 07:14.610
¡Listo!

07:14.610 --> 07:15.840
Nos vemos en el próximo video.