Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Primeros pasos en Unity. Input System (parte 4) - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 13 de diciembre de 2025 por Alvaro H.

9 visualizaciones

Terminamos esta serie dedicada al Input System con un tercer método para trasladar las acciones a código. En este caso, con el componente Player Input

Más información Transcripción

Descargar la transcripción

Bueno, si seguimos vivos a estas alturas 00:00:07
vamos con el tercer método para 00:00:10
recibir las entradas del Input System 00:00:12
Este quizás es el que menos me gusta a mí 00:00:16
si bien es cierto que hay gente en Internet que lo usa 00:00:18
lo sé porque mis alumnos alguna vez me lo han puesto 00:00:21
y no sé por qué, porque yo no se lo he enseñado 00:00:24
y segundo, si es verdad que lo recomienda Unity 00:00:26
en el caso de juegos en los que haya múltiples jugadores 00:00:29
porque es verdad que tiene ciertas opciones que facilitan mucho 00:00:32
a la hora de crear multijugador 00:00:35
Pero bueno, vamos a ver cómo funciona. Este método, he cambiado un poco la distribución para tenerlo más a mano, porque este método utiliza un componente que es el PlayerInput. 00:00:37
Y de hecho, en el momento en el que lo pongamos, veremos que a nuestro personaje le aparece ese iconito indicando que tiene un PlayerInput. 00:00:50
Lo primero, le tenemos que vincular, igual que hicimos en el sistema anterior, un asset de entradas preconfigurado. 00:00:57
Bien, él ha cogido por defecto el que está como Project Wide, 00:01:03
pero vamos que podemos ponerle cualquiera. 00:01:07
Ahora mismo le ha arrastrado el que venía en Unity. 00:01:09
Y fijémonos que al ponerle el de Unity, reconoce los esquemas. 00:01:12
Entonces podemos decirle que utilice todos los esquemas o solo uno. 00:01:17
Bueno, y ¿veis lo que aparece aquí? Pues ahora entenderemos por qué. 00:01:21
Le voy a vincular con el mío. 00:01:25
Cuestiones. No me voy a detener mucho en cómo funciona el componente, 00:01:27
pero fijaros que tiene para vincular una cámara. 00:01:30
Y esto está pensado para, lo he dicho, juegos multijugador en el que tengamos varias cámaras funcionando 00:01:32
y entonces unos inputs funcionen con una cámara y otros con otros, por ejemplo, para el input system, 00:01:37
para que no haya conflictos. En fin, tiene muchas opciones, pero me quedaré con esto. 00:01:44
No voy a entrar mucho en detalle, pero sí que entendamos que un GameObject, 00:01:48
una vez que tiene el componente PlayerInput, podemos desde un script que tenga ese GameObject 00:01:54
llamar a las acciones de ese input asset 00:02:00
que acabamos de vincular. 00:02:03
¿Cómo? Pues bien, vemos que hay un sendMessages 00:02:05
que es básicamente todos los scripts 00:02:07
que tengan este objeto 00:02:09
pueden hacer uso de ese input. 00:02:11
Antes no, antes era el script que le habíamos vinculado. 00:02:14
Ahora no, ahora cualquier script. 00:02:16
Podemos incluso hacer un broadcastMessages 00:02:18
que significa no solo los scripts que tengan mi objeto, 00:02:20
sino los hijos de este objeto 00:02:22
también pueden hacer uso de este input asset 00:02:25
que tengo vinculado. 00:02:28
y tenemos el InboxUnityEvents 00:02:29
que lo veremos más adelante 00:02:32
que eso ya es hilar muy fino 00:02:33
pero quedémonos con el SendMessages 00:02:35
con lo cual le voy a poner un 00:02:37
un script 00:02:38
y fijémonos 00:02:39
esto es interesante 00:02:42
al poner SendMessages nos dice 00:02:43
qué mensajes 00:02:46
puede recibir desde un script 00:02:49
y de hecho nos aparece 00:02:51
las acciones que yo he creado en este input 00:02:52
vemos que pone 00:02:55
OnJump, OnWork, OnMove, OnCrouch 00:02:56
es decir, que ya nos está dando una pista 00:02:59
o por lo menos una chuleta de qué métodos podemos usar 00:03:02
de hecho si abro el script 00:03:06
y es quizá por lo que este sistema tiene sus fans 00:03:07
porque yo automáticamente ahora mismo ya puedo usar 00:03:11
los métodos que me aparecen aquí 00:03:14
en la chuleta, por ejemplo le puedo decir void 00:03:17
onJump y para que no le vea el print 00:03:20
salto 00:03:25
sin más, ya está 00:03:27
y como insisto que hemos hecho una especie de set message 00:03:29
es decir que cualquiera puede llamar a estos métodos 00:03:33
pues ya está, ya funciona 00:03:36
no necesito más, le doy a saltar 00:03:38
y ahí me aparece, salto 00:03:41
bien, esto está bien y nos vale para muchas cosas 00:03:43
pero ahora vamos a lo siguiente 00:03:46
que es necesito obtener los datos de esa entrada 00:03:47
vamos a usar la acción move 00:03:51
que era un vector2 para que veamos como puedo 00:03:54
obtener ese vector 2 de ese sistema de entrada. Entonces voy a ir 00:03:57
lo mismo, voy onMove 00:04:01
que es como se llamaba, recordemos que tenemos aquí una chuleta 00:04:04
onMove, lo puedo llamar. Pero 00:04:08
ahora sí que necesito recibir un valor en este 00:04:13
método. ¿De qué tipo? De tipo inputValue 00:04:17
voy a llamar value, por ejemplo. 00:04:20
por cierto que se nos ha añadido automáticamente la librería inputSystem 00:04:23
como hemos visto en cuanto hemos usado un inputValue 00:04:29
y ahora, si necesito una variable que recoja eso 00:04:31
pues voy a crear una variable de tipo vector2 00:04:35
y le voy a llamar myMove para no mezclarlo 00:04:38
y ahora en este método 00:04:40
que recoge el valor del joystick 00:04:45
le digo, oye pues myMove 00:04:47
es igual a ese valor que me has devuelto 00:04:49
que yo le he llamado value 00:04:52
y tiene un método llamado get 00:04:53
y entre menor que y mayor que le tenemos que decir 00:04:56
qué tipo de valor va a obtener 00:04:59
y en este caso es un vector2, correcto 00:05:00
entonces ahora mismo myMove 00:05:02
va a valer en todo momento lo que diga 00:05:04
el joystick 00:05:06
como sé que funciona 00:05:07
voy a crear un método para mover 00:05:09
movePlayer 00:05:14
y le voy a decir pues 00:05:16
lo de siempre, transform, translate 00:05:20
hacia adelante por lo que 00:05:22
diga 00:05:27
myMove en y y por time delta time, claro. Ahí está. Lo voy a duplicar porque voy a 00:05:29
decir que se mueve hacia la derecha por su valor en x. Recuerdo que myMove era un 00:05:37
vector 2 y va a tener un valor en y y un valor en x. Y lo gente, este método lo 00:05:45
tengo que llamar en algún sitio, es decir, en el update. Pues vamos a ver si hay suerte. 00:05:50
le doy al play, para adelante 00:05:59
para atrás, derecha 00:06:04
izquierda, bien 00:06:08
¿qué ocurre? que este sistema es un poco limitado, en el sentido de que 00:06:12
yo necesito saber cuando pulso algo, cuando lo estoy pulsando o cuando dejo de pulsarlo 00:06:17
igual que hacíamos en el primer sistema, que no se puede hacer 00:06:21
claro que se puede hacer, aquí todo se puede hacer, lo que pasa es que es un poco más rebuscado la forma de hacerlo 00:06:25
Lo vamos a ver para que sepamos que esa opción también existe. 00:06:29
Para ello tenemos que ir a Unity y cambiar aquí el comportamiento. 00:06:34
Teníamos en mandar mensajes o broadcast messages para que lo recoja cualquiera de nuestros hijos 00:06:39
y tenemos el Invoke Unity Events. 00:06:43
Entonces, si lo seleccionamos, veremos que hay una pestañita que nos dice eventos 00:06:47
e incluso tenemos eventos para cada mapa de acciones. 00:06:51
Si despliego el player, por ejemplo, veré que efectivamente hay todas las acciones que he creado 00:06:54
tendrá aquí su representación. Bien, si le doy un más 00:06:58
me está pidiendo un objeto y un script. Esto es muy parecido, por ejemplo, para lo que usábamos 00:07:02
para los botones. Voy a usarlo en el mismo script. 00:07:06
Necesito un método público al que le voy a llamar, por ejemplo, 00:07:11
walk, que no lo he usado hasta ahora. 00:07:20
Le voy a llamar walk callback. ¿Qué ocurre? 00:07:24
Este método que acabo de crear necesita 00:07:27
un callback de la clase 00:07:31
inputAction 00:07:37
inputActionCallbackContext 00:07:38
que le voy a llamar ctx, igual que usábamos 00:07:42
en el primer sistema, porque es la convención 00:07:44
para decirle un callback 00:07:46
y ahora le tengo que decir, voy a crear una variable 00:07:47
tipo float, para mi caminar 00:07:50
workValue 00:07:52
le voy a llamar, por ejemplo 00:07:54
y ahora, ¿qué hacemos 00:07:56
con este callback? 00:07:58
es muy parecido a como funcionaba el primer sistema 00:08:00
lo que pasa es que aquí, se lo tenemos que preguntar 00:08:02
le tenemos. Oye, si ese callback que estás llamando ha iniciado, es decir, han 00:08:04
empezado a mover el joystick, lo va a mandar a la consola 00:08:12
caminando. Si ese callback se sigue, voy a ponerle aquí iniciar 00:08:18
el camino. Si se está ejecutando, es decir, está PERFORMED, es decir, print caminando. Y si 00:08:30
ese callback ha dejado de usarse, print determinado. Conclusión. Al final el resultado es muy parecido 00:08:42
al que vimos en el primer sistema. He creado un método que va a retornar un callback y dentro 00:08:57
de ese método le tengo que preguntar en todo momento si ha empezado, si se está ejecutando 00:09:04
o si ha dejado de ejecutarse. Que esto, utilizando el playerInput 00:09:08
y utilizando el invokeUnityEvents, lo voy a vincular 00:09:12
voy a quitar este, que no, a la acción walk 00:09:16
le añado una nueva callbackContext 00:09:20
necesita un objeto. Bien. Como lo he usado en el mismo script 00:09:24
que tiene el objeto, lo puedo arrastrar. ¿Podría ponerlo en otro objeto 00:09:28
con otro script? por supuesto que sí 00:09:32
igual que cuando lo hacíamos con los botones 00:09:34
y aquí en las funciones 00:09:36
no sé si se llega a ver 00:09:38
para que se vea 00:09:39
ahí está 00:09:42
dynamic callback context, es decir 00:09:43
funciones que están esperando ese callback 00:09:46
ahí está, la que yo he creado 00:09:48
bueno, vamos a ver si funciona 00:09:49
no soy muy fan ni uso mucho este método 00:09:51
pero 00:09:54
debería funcionar 00:09:55
entonces si yo muevo el eje x 00:09:58
que es el que 00:09:59
Lo veis, lo estoy moviendo, con lo cual inicio el camino y estoy caminando, mientras siga 00:10:00
presionando va a seguir y es importante hacer lo que hicimos en el primer sistema, cuando 00:10:07
deje de mover el joystick decirle que deje de caminar, he terminado, ahí está. 00:10:10
Ya que los vinculé con los cursores, lo voy a probar con los cursores, pulso el cursor 00:10:19
de arriba y efectivamente estoy caminando, sigo pulsando el botón de arriba y cuando 00:10:23
suelto he terminado de caminar y lo mismo con el de abajo estoy caminando y he dejado de caminar 00:10:28
y es importante por ejemplo si esto lo fuésemos bien a vincular a un movimiento de nuestro 00:10:36
personaje pues work value por ejemplo y le digo si estoy caminando lo que usamos el primer sistema me 00:10:43
estoy moviendo? Pues walkValue vale, y esto es igual que en el primer 00:10:56
método. ctx.readValue, ¿de qué tipo? float. ¿Y qué pasa si dejo de moverme? Pues que 00:11:03
walkValue es igual a cero. Voy a quitar esto, 00:11:11
porque ahora ya, de hecho en el update lo voy a quitar, y le voy a decir en el update 00:11:21
muévete hacia adelante por lo que diga el walk value por por supuesto time delta time vamos a 00:11:32
comprobar que funciona está en el jugador desde el play y ahora en principio con los cursores que son 00:11:51
los que están vinculados a la acción walk debería caminar hacia delante y hacia atrás y además cuando 00:12:04
empieza me sale abajo el aviso de que efectivamente ha iniciado el camino ahí está y si me voy a su 00:12:11
inspector, veré que lo he vinculado con 00:12:21
un InvokeUnityEvents y dentro de los eventos, dentro 00:12:28
del mapa de acciones, efectivamente he vinculado el walk con 00:12:33
ese objeto que tiene ese script y ese método. 00:12:37
Este último sistema para movimientos o para acciones sencillas, la verdad 00:12:44
es que es muy práctico porque el código es muy sencillo porque solo hay que 00:12:47
ya tenemos disponible nuestros métodos, pero es verdad que cuando queremos algo 00:12:51
más elaborado, pues quizás complica un poquito más. 00:12:55
Pero no más que la primera forma. 00:12:58
A partir de aquí, insisto, parece complicado. 00:13:02
Primero porque son tres métodos y no tenemos que usar los tres. 00:13:05
Tenemos que elegir uno y emplearlo. 00:13:07
Y dos, es complicado la primera vez. 00:13:10
Luego ya, de tanto repetirlo, de tanto repetirlo 00:13:13
y sobre todo de copiar y pegar y copiar y pegar siempre el mismo código, 00:13:15
al final nos resulta cómodo. 00:13:18
Por no decir que, si somos listos, sabremos cómo reutilizar. 00:13:21
Mismo script. 00:13:25
Pues nada, elige a tu jugador. 00:13:26
Pues nada, elige tu favorito. 00:13:29
Idioma/s:
es
Materias:
Informática, Imagen y Sonido
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Autor/es:
Alvaro Holguera Gozalo
Subido por:
Alvaro H.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
9
Fecha:
13 de diciembre de 2025 - 10:26
Visibilidad:
Público
Centro:
CFP JOSÉ LUIS GARCI
Duración:
13′ 31″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
573.73 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid