Reto 5: Menú del juego

Pong/core/src/com/mygdx/Pong/AbstractScreen.java

@@ -7,7 +7,7 @@
 //reescalar, pausar, resumir...) menos con dispose, para liberar los recursos hay que llamar a dispose manualmente
 
 public class AbstractScreen implements Screen { // Pantalla abstracta de la cual heredan las demas pantallas.
-	private Main main; // Necesario en el futuro para pasar de una pantalla a otra.
+	protected Main main; // Necesario en el futuro para pasar de una pantalla a otra.
 
 	public AbstractScreen(Main main) {
 		this.main = main;

Pong/core/src/com/mygdx/Pong/Ball.java

@@ -1,6 +1,7 @@
 package com.mygdx.Pong;
 
 import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.audio.Sound;
 import com.badlogic.gdx.graphics.Texture;
 import com.badlogic.gdx.graphics.g2d.SpriteBatch;
 import com.badlogic.gdx.math.Rectangle;
@@ -12,13 +13,15 @@ public class Ball { // Esta clase representa la bola del pong
 	private Rectangle bordes; // Objeto que nos determinará la posición de la bola y permite detectar colisiones con otros rectangulos.
 	private int direccionX, direccionY; // Permite invertir la dirección de la bola en el eje x e y respectivamente
 	private float posicionOriginalX, posicionOriginalY; // Guarda la posición original de la bola cuando esta se crea.
+	private Sound sonido; // Sonido cuando colisiona con las palas
 
 	public Ball(float x, float y) {
 		texture = new Texture(Gdx.files.internal("bola.png"));
 		bordes = new Rectangle(x, y, texture.getWidth(), texture.getHeight());
 		direccionX = direccionY = 1; // Lo ponemos a 1 los dos para que se mueva al inicio hacia arriba a la derecha
 		posicionOriginalX = x;
 		posicionOriginalY = y;
+		sonido = Gdx.audio.newSound(Gdx.files.internal("golpe.ogg"));
 	}
 
 	public void draw(SpriteBatch batch) { // Permite dibujar la bola para que la visualice el usuario.
@@ -29,8 +32,10 @@ public void update(Paddle Lpaddle, Paddle Rpaddle) {
 		float delta = Gdx.graphics.getDeltaTime(); // Número de segundos desde el anterior fotograma.
 		if(choqueConParedes())
 			direccionY = direccionY * -1; // Cambiamos la dirección en el eje y
-		if(choqueConPalas(Lpaddle.getBordes(), Rpaddle.getBordes()))
+		if(choqueConPalas(Lpaddle.getBordes(), Rpaddle.getBordes())) {
 			direccionX = direccionX * -1; // Cambiamos la dirección en el eje x
+			sonido.play(); // Reproducimos el sonido
+		}
 
 		bordes.x = bordes.x + SPEED * delta * direccionX; 
 		bordes.y = bordes.y + SPEED * delta * direccionY;

Pong/core/src/com/mygdx/Pong/Button.java

@@ -0,0 +1,53 @@
+package com.mygdx.Pong;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+import com.badlogic.gdx.math.Rectangle;
+
+
+public abstract class Button { // Clase abstracta que representa un botón cuyo comportamiento sera diferente dependiendo de los distintos tipos de botones que se tengan
+	protected Texture texture; // Textura del botón. Se asigna en el hijo
+	protected Rectangle bordes; // El rectangulo que establece la posición, altura y anchura del botón
+
+	protected float xMinima; // Estos atributos sirven para poner las coordenadas para pulsar el botón.
+	protected float yMinima;
+	protected float xMaxima;
+	protected float yMaxima;
+
+	public Button(int x, int y) {
+		Texture textura = new Texture(Gdx.files.internal("BotonExit.png")); // Para poner el ancho y alto de los botones. Suponemos que todos serán igual
+		bordes = new Rectangle(x, y, textura.getWidth(), textura.getHeight());
+
+		// Permite asignar los bordes del botón para su correcto funcionamiento.
+		xMinima = bordes.x;
+		yMaxima = Gdx.graphics.getHeight() - bordes.y;
+		xMaxima = bordes.x + bordes.width;
+		yMinima = Gdx.graphics.getHeight() - (bordes.y + bordes.height);
+	}
+
+	public void draw(SpriteBatch batch) {
+		batch.draw(texture, bordes.x, bordes.y, bordes.width, bordes.height);
+	}
+
+	public void update() {
+		if(sePulsaElBoton())
+			funcionamiento();
+	}
+	private boolean sePulsaElBoton() { // Esta función privada sirve para comprobar si se pulsa el botón.
+		return Gdx.input.isTouched() && Gdx.input.getX() >= xMinima && Gdx.input.getX() <= xMaxima && // Devuelve true si se pulsa dentro de los límites
+			   Gdx.input.getY() >= yMinima && Gdx.input.getY() <= yMaxima;
+	}
+
+	protected abstract void funcionamiento(); // Método que implementarán las clases hijas y contendrá el comportamiento deseado
+
+	// Getters and Setters ------------------------------------------------------------------------
+
+	public Rectangle getBordes() {
+		return bordes;
+	}
+
+	public void setBordes(Rectangle bordes) {
+		this.bordes = bordes;
+	}
+}

Pong/core/src/com/mygdx/Pong/ButtonExit.java

@@ -0,0 +1,17 @@
+package com.mygdx.Pong;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Texture;
+
+public class ButtonExit extends Button { // Botón que permitirá salir del juego
+
+	public ButtonExit(int x, int y) {
+		super(x, y);
+		texture = new Texture(Gdx.files.internal("BotonExit.png")); // Se asigna textura. Muy importante!!
+	}
+
+	@Override
+	protected void funcionamiento() {
+		Gdx.app.exit(); // Cierra la aplicación
+	}
+}

Pong/core/src/com/mygdx/Pong/ButtonPlay.java

@@ -0,0 +1,17 @@
+package com.mygdx.Pong;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Texture;
+
+public class ButtonPlay extends Button { // Botón que permitira iniciar el Pong
+
+	public ButtonPlay(int x, int y) {
+		super(x, y);
+		texture = new Texture(Gdx.files.internal("BotonPlay.png")); // Se asigna textura. Muy importante!!
+	}
+
+	@Override
+	protected void funcionamiento() {
+		Screens.juego.setScreen(Screens.GAMESCREEN); // Se asigna la pantalla de juego
+	}
+}

Pong/core/src/com/mygdx/Pong/GameScreen.java

@@ -1,6 +1,7 @@
 package com.mygdx.Pong;
 
 import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.Input.Keys;
 import com.badlogic.gdx.Preferences;
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.graphics.GL20;
@@ -19,11 +20,13 @@ public class GameScreen extends AbstractScreen { // Pantalla principal del juego
 
 	public GameScreen(Main main) {
 		super(main);
+		preferencias = Gdx.app.getPreferences("-_PreferenciasPong_-"); // Abrimos el fichero, y si no está creado se genera vacio automáticamente.
+		puntuacionMaxima = preferencias.getInteger("puntuacionMaxima"); // Se extrae el valor del campo "puntuacionMaxima"
 	}
 
 	@Override
 	public void show() { // Método que se llama cuando se establece esta pantalla como actual
-		batch = new SpriteBatch();
+		batch = main.getBatch();
 		texture = new Texture(Gdx.files.internal("pongcampo.png"));
 		Texture textureBola = new Texture(Gdx.files.internal("bola.png")); // Cogemos la textura para calcular el alto y ancho de la bola y centrarla en la pantalla
 		ball = new Ball(Gdx.graphics.getWidth() / 2 - textureBola.getWidth() / 2, Gdx.graphics.getHeight() / 2 - textureBola.getHeight() / 2);
@@ -32,8 +35,6 @@ public void show() { // Método que se llama cuando se establece esta pantalla c
 		Rpaddle = new RightPaddle(Gdx.graphics.getWidth() - 100, Gdx.graphics.getHeight() / 2 - texturePala.getHeight() / 2, ball);
 		font = new BitmapFont(Gdx.files.internal("ubuntu.fnt"), Gdx.files.internal("ubuntu.png"), false); // Creamos la fuente a partir de la imagen y el fichero de configuración de la font
 		font.setColor(Color.ORANGE); // La ponemos a color naranja.
-		preferencias = Gdx.app.getPreferences("-_PreferenciasPong_-"); // Abrimos el fichero, y si no está creado se genera vacio automáticamente.
-		puntuacionMaxima = preferencias.getInteger("puntuacionMaxima"); // Se extrae el valor del campo "puntuacionMaxima"
 		puntuacion = 0;
 	}
 
@@ -51,6 +52,8 @@ public void render(float delta) { // Método que permite actualizar los valores
 		Rpaddle.update(); // Actualizamos los valores de la pala derecha, para que se mueva en la pantalla.
 		ball.update(Lpaddle, Rpaddle); // Permite que la bola se mueva, y al pasarle las dos palas podemos detectar la colisión con ellas.
 
+		salirMenu(); // Permite salir al menú principal
+
 		batch.begin(); // Aqui se comienza a dibujar
 		batch.draw(texture, 0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight()); // Pintamos el fondo de pantalla
 		ball.draw(batch); // Pintamos la bola
@@ -73,12 +76,20 @@ public void render(float delta) { // Método que permite actualizar los valores
 		ball.comprobarPosicionBola(); // Colocamos la bola en su posicion si se sale del escenario.
 	}
 
+	private void salirMenu() {
+		if(Gdx.input.isKeyPressed(Keys.ESCAPE) || Gdx.input.isKeyPressed(Keys.BACK)) // Si se pulsa el botón "escape" en PC o "Back" en android
+			Screens.juego.setScreen(Screens.MAINSCREEN); // Volvemos al menú principal
+	}
+
+	@Override
+	public void hide() { // Método que se ejecuta cuando se oculta esta pantalla
+		font.dispose();
+		texture.dispose();
+	}
+
 	@Override
 	public void dispose() { // Método para eliminar recursos
 		preferencias.putInteger("puntuacionMaxima", puntuacionMaxima); // Guardamos en el fichero el valor de la puntuación máxima.
 		preferencias.flush(); // Automaticamente guarda todo lo introducido en el fichero.
-		font.dispose();
-		texture.dispose();
-		batch.dispose();
 	}
 }

Pong/core/src/com/mygdx/Pong/Main.java

@@ -1,6 +1,8 @@
 package com.mygdx.Pong;
 
 import com.badlogic.gdx.Game;
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
 
 /*AplicationListener es una interfaz que proporciona metodos que se llaman cada vez que es necesario
 * crear, pausar, continuar, renderizar o destruir una aplicacion, nos permite ademas manejar los graficos
@@ -12,16 +14,25 @@
 
 // Main es la clase principal de nuestro juego, es decir, es la primera que se llama cuando se ejecuta.
 public class Main extends Game {
-	public AbstractScreen GAMESCREEN; // Pantalla principal del juego
+	private SpriteBatch batch; // "Grupo de Sprites (imagenes)" nos permite dibujar rectagulos como referencias a texturas, es necesario para mostrar todo por pantalla.
 
 	@Override
 	public void create () { // Método que se llama cuando se ejecuta el juego
-		GAMESCREEN = new GameScreen(this);
-		setScreen(GAMESCREEN); // Establecemos GAMESCREEN como nuestra pantalla principal
+		batch = new SpriteBatch();
+		Gdx.input.setCatchBackKey(true); // Bloquea el boton "Back" de android para que se tenga que salir del juego usando el boton "Exit"
+		Screens.juego = this;
+		Screens.GAMESCREEN = new GameScreen(this); // Se inicializan las pantallas
+		Screens.MAINSCREEN = new MainScreen(this);
+		setScreen(Screens.MAINSCREEN); // Establecemos MAINSCREEN como nuestra pantalla principal
 	}
 
 	@Override
 	public void dispose() { // Método para eliminar recursos.
-		GAMESCREEN.dispose();
+		batch.dispose();
+		Screens.GAMESCREEN.dispose();
+	}
+
+	public SpriteBatch getBatch() {
+		return batch;
 	}
 }

Pong/core/src/com/mygdx/Pong/MainScreen.java

@@ -0,0 +1,44 @@
+package com.mygdx.Pong;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.GL20;
+import com.badlogic.gdx.graphics.Texture;
+import com.badlogic.gdx.graphics.g2d.SpriteBatch;
+
+public class MainScreen extends AbstractScreen { // Pantalla del menú principal del juego.
+	public SpriteBatch batch; // "Grupo de Sprites (imagenes)" nos permite dibujar rectagulos como referencias a texturas, es necesario para mostrar todo por pantalla.
+	private Button exit;
+	private Button play;
+
+	public MainScreen(Main main) {
+		super(main);
+	}
+
+	@Override
+	public void show() { // Método que se llama cuando se establece esta pantalla como actual
+		batch = main.getBatch();
+		Texture texture = new Texture(Gdx.files.internal("BotonExit.png")); // Cogemos la textura del botón para usar su ancho y alto
+		int centroY = Gdx.graphics.getHeight() / 2 - texture.getHeight() / 2; // Centro en el eje x de la pantalla centrando el botón
+		int centroX = Gdx.graphics.getWidth() / 2 - texture.getWidth() / 2; // Centro en el eje y de la pantalla centrando el botón
+		exit = new ButtonExit(centroX, centroY - 50);
+		play = new ButtonPlay(centroX, centroY + 50);
+	}
+
+	@Override
+	public void render(float delta) { // Método que permite actualizar los valores del juego y dibujar el juego para que lo vea el usuario.
+		//Gdx es una clase con la que podemos acceder a variables que hacen referencia a todos los subsitemas, como son graficos, audio, ficheros, entrada y aplicaciones
+		// gl es una variable de tipo GL, nos permite acceder a metodos de GL10, GL11 y GL20
+		//En este caso glClearColor es un bucle (game loop) que establecera el fondo de la pantalla negro (0,0,0) con transparencia 1
+		Gdx.gl.glClearColor(0, 0, 0, 1);
+		Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); // Despues de la funcion anterior es necesario ejecutar esta, para que se lleve a cabo
+
+		exit.update(); // Comprobamos que se pulsan los botones
+		play.update();
+
+		batch.begin();
+		exit.draw(batch); // Dibujamos el botón exit
+		play.draw(batch); // Dibujamos el botón play
+		batch.end();
+	}
+
+}

Pong/core/src/com/mygdx/Pong/Screens.java

@@ -0,0 +1,7 @@
+package com.mygdx.Pong;
+
+public final class Screens { // Clase que tiene las distintas pantallas del juego para poder acceder a ellas desde cualquier clase
+	public static Main juego; // Objeto de la clase principal del juego. Nos sirve para cambiar de una pantalla a otra
+	public static AbstractScreen GAMESCREEN; // Pantalla de juego
+	public static AbstractScreen MAINSCREEN; // Pantalla del menú
+}