Para trabajar con eventos de entrada, libGDX tiene una clase llamada InputProcessor. Esta clase está controlada por libGDX en la entrada y
funciona igual que ApplicationAdapter: es una clase con eventos. Escribimos el código de los eventos y dejamos que libGDX los llame cuando lo considere
oportuno. Nosotros no comprobamos si se está pulsando una tecla, dejamos que libGDX sea quien nos notifique de que se ha pulsado una tecla.
Esto diferencia al sistema que hemos visto en el vídeo anterior, polling, en que si no se está pulsando esa tecla no se ejecuta ese código y
el juego funciona más rápido. En el caso del InputProcessor lo que se hará es que los eventos se desatarán en hilos independientes para que no molesten al
código principal. Lo primero que voy a hacer es crear el procesador de entrada, y esto es una cosa que debe ir en una clase independiente,
por ejemplo Procesador. Mi procesador de entrada debe implementar InputProcessor. Es una interfaz, así que me obliga a implementar todos sus métodos.
Hay un montón de métodos, vamos a verlos poco a poco. Unos son down y otros son up. Los down se usan cuando empezamos a pulsar o tocar la pantalla,
y los up se usan cuando dejamos de hacerlo. Por ejemplo, keyDown es el evento que se dispara cuando empezamos a pulsar una tecla, por ejemplo cuando hacemos “K”,
y dejamos la “K” pulsada pero no soltamos el dedo. Al soltar el dedo se dispara keyUp. Así podemos detectar cuando empezamos a pulsar y dejamos de pulsar.
Esto nos puede servir para hacer un juego en el que queremos que el personaje avance mientras pulsamos la tecla Derecha y que cuando la soltemos deje de avanzar.
Aquí le decimos que empiece a moverse, y aquí le decimos que termine. Del mismo modo con touchDown y touchUp podemos hacer lo mismo pero con el dedo.
touchDown se dispara cuando pulsamos el dedo, y touchUp cuando lo levantamos. Tenemos otros métodos interesantes como mouseMoved, que nos dice cuándo se está
moviendo el ratón. Con esto podemos comproabr si el ratón está moviendose. Este no se dispara en móviles porque el móvil no sabe donde está nuestro dedo salvo
que lo toquemos. Tenemos otros como touchDragged, para detectar cuando estamos arrastrando el ratón o el dedo por pantalla, de modo que podamos seguir un
movimiento o hacer un gesto, o lo que sea. O keyTyped que detecta cuando hemos pulsado un caracter, como la A o la B. De modo que si estamos escribiendo letras
podamos detectarlo más rápido. Como veis tienen un montón de parámetros, por eso no me quiero meter de golpe con ello porque son muchos, pero vamos a empezar
por los que tienen que ver con el touch, que es lo que nos interesa. Antes que nada voy a eliminar esto, y como no me interesan muchos voy a cambiar
InputProcessor por InputAdapter. ¿Por qué? Porque como ApplicationAdapter, InputAdapter y cualquier adaptador lo que hace es que implementa
la interfaz por nosotros, es decir, sigue siendo un Processor, pero sin implementar los métodos que no vayamos a implementar, y esto es muy cómodo.
Que queremos usar TouchDown, pues lo usamos. Que queremos usar TouchUp, lo usamos. Que no vamos a usar KeyDown, lo dejamos ahí y no se usa.
Una característica importante que quizás os estéis preguntando sobre los métodos de InputProcessor es por qué todos devuelven booleanos. Esto es porque
el booleano dice si hemos hecho algo en este método, de modo que si devolvemos falso lo que le decimos es que no hemos hecho nada. Y eso está bien porque
si libGDX tiene otro procesador que atender, puede determinar si, si no hemos hecho nada, use su propio código para procesar el evento, o que lo abandone
o que llame a otro procesador… siempre que vayamos a hacer código en el touch, o en el key o donde sea que lo vayamos a hacer, hay que devolver true para
indicar a libGDX que hemos procesado ese evento. TouchDown y TouchUp. Tienen cuatro parámetros aquí. Los dos los mismos además.
screenX y screenY os dicen dónde hemos tocado. pointer, indica con qué dedo hemos tocado. Diréis ¿con qué dedo? Pues sí, porque los móviles son todos
hoy en día multitouch, y podéis pulsar con varios dedos a la vez, por ejemplo para hacer el gesto de zoom. O para hacer cualquier otro gesto,
pero normalmente aceptan 4 o 5 dedos sin problema. Cuando pulsemos la pantalla con un dedo, ese dedo será el 0, y si mientras mantenemos pulsado el 0
pulsamos con otro dedo, ese será el dedo 1, y así hasta que llegue al límite, que cada pantalla tiene el suyo propio, porque no todas son pantallas buenas.
En el caso de escritorio, si tenemos un ratón, button nos devuelve con qué botón del ratón hemos hecho clic, como el izquierdo o el derecho.
Por poner esto a prueba yo lo que voy a hacer es decirle “has tocado en la posición (screenX, screenY)”, y “has usado el dedo (pointer) y el botón (button)”.
Como he tratado mi evento en cierto modo, simplemente devuelvo verdadero para que sepa que he hecho cosas. Lo único que nos queda es conectarlo con el juego principal.
