Para hacer que el botón pueda ser interactuado lo que tenemos que tener en cuenta es que los Stage son InputProcessor. Y diréis “no puede ser”, pero sí,
los Stage son de tipo InputAdapter, que a la vez son de tipo InputProcessor. Eso significa que lo que vimos hace muchos vídeos, dicho sea de paso,
de hacer un InputProcessor y asignarlo a la entrada lo podemos hacer con el Stage. Para ello me voy a venir a show, porque tiene que ser en show sólo para que
se ejecute cuando vamos a visualizar la pantalla, y ejecutar Gdx.input.setInputProcessor(), y le paso el Stage a un InputProcessor y se le asocia.
La ventaja de esto es que ya procesa todos los eventos que ocurran en la entrada con los actores, como cuando hemos hecho clic en un actor.
Cuando vayamos a quitar la pantalla acordaros de dejar de usar este Stage como InputProcessor, porque si no las cosas se pueden poner malas porque no vemos el Stage
pero sin embargo sigue tratando la entrada y eso puede dar algún que otro problema. A partir de ese momento como veis, cuando haga clic sobre mi botón,
va a funcionar correctamente y va a poder hacer cosas con él. Sólo que no hay mucho que hacer, no pasa nada. Podemos tirarnos horas pero no hace clic.
Eso es porque le tengo que dar un comportamiento, y es que tengo que rellenar el método addCaptureListener, que es el que sirve para agregar un listener
que se ejecuta cuando hemos “cambiado” de alguna forma el actor. Este código es simplemente hacer un copia y pega de estas dos clases y ya con ello se sobreescribe
el método changed() que es el que se ejecuta cuando hagamos clic en el botón. Podemos aprovechar este momento para pedirle a nuestro juego por la pantalla del
juego y todos felices. El único problema es como lo hacemos realmente. Necesitamos algo que nos permita cambiar de pantalla a pantalla, y para ello me voy a
venir al MainGame, y registrar cada una de las pantallas que tenemos creadas en nuestro juego. Por ejemplo… lo voy a hacer public porque no merece la pena,
con tener un puntero con el que acceder a GameOverScreen o a GameScreen… vamos a agregar otro puntero a GameOverScreen. Ahora lo que hago es que GameScreen
es nueva GameScreen y GameOverScreen es nueva GameOverScreen. Y ahora finalmente en vez de llamar a setScreen con una nueva pantalla lo hago con gameOver.
¿Cómo podríamos hacer esto de una forma más bonita? Podríamos crear una lista de pantallas, o un mapa que asocie una cadena de caracteres con un Screen
y así hacer algo como getScreen(“game”) o cosas así. O constantes. Hay muchas formas de hacer esto, lo que se os ocurra. Esta no es la mejor forma pero es una
forma que funciona y así no nos metemos en líos ahora, pero hay muchas formas de arreglar esto, usando numeritos para identificar cada pantalla, constantes,
lo que se os ocurra. Ahora sí. Queremos que cuando hemos tocado el botón se cambie por la pantalla de juego. Para eso, Game, como juego basado en pantallas
tiene un método llamado setScreen que puede que ya conozcáis, pero es que es público, lo podemos llamar en cualquier momento mientras le diga la pantalla
que quiero usar y con ello ya lo tengo listo. El único pero es que como Game se usa dentro de una clase anónima, es necesario que sea final,
por cómo está hecho Java, que requiere que una variable sea final si lo usamos en una clase anónima de las que hay dentro, pero bueno. Ignorando ese detalle,
si ahora pulso. Sirve para cambiar de pantalla. Lo único que queda es hacer que cuando pierdas vuelvas a la pantalla de GameOver, así que lo que voy a hacer es
que cuando mueres, en el GameScreen, ocurre un poco lo siguiente: este es el… ¿cuál es el método que se ejecuta cuando chocas? Sí. Este. El que imprime un GameOver.
Voy a hacer que cuando mueras, tras un segundo o dos segundos vayas a la pantalla de GameOver. Para ello lo que voy a hacer es agregar al stage una acción
que sirve para hacer animaciones. Las acciones son de muchos tipos: pueden ser una acción para animar el movimiento de algo o para animar la rotación,
o incluso para que se escale, o para que se ejecute código, y eso es lo que yo quiero: primero voy a aplicar una acción llamada delay para que
se espere un momento, y luego voy a hacer un run para que se ejecute el código que me deja cambiar de pantalla. Y como quiero que una acción
se ejecute tras otra voy a usar la acción sequence, que es una acción de acciones. Le puedo pasar dos acciones para que se ejecuten una junto a la otra.
Quiero que se ejecute la acción de esperar, para que puedas esperar 1 segundo y medio. Y después quiero que puedas saltar a la pantalla de GameOver,
así que sobreescribo el método que me pides que sobreescriba y simplemente pongo game.setScreen(game.gameOverScreen). En ese instante, cuando muramos,
un segundo y medio después, saltaremos a la pantalla de GameOver. Muy bien. Lo único que queda es repetir este mismo paso para construir una pantalla
de inicio igual que acabamos de hacer. No os vais a perder nada.
