ArkaLlop - Clon del Arkanoid
Llop Site Home > JAVA > ArkaLlop > Partida
Partida:
Clase Partida package arkallop; import java.lang.*; import java.net.*; /** Título: ArkaLlop Descripción: Prácticas capítulo 11, ejercicio 4 Copyright: Copyright (c) 2005 Empresa: Casa_Llop @author Albert_Lobo @version 1.0 */ /** En cierto sentido, la clase más importante del juego. Es la encargada de relacionar correctamente las demás clases, y llevar cuenta de variables que deben poder ser accesibles en diferentes puntos del programa. */ public class Partida { /** Constante que representa el modo de juego de 'entrenamiento', en el que se termina el juego con sólo completar un nivel. */ public final static byte ENTRENAMIENTO = 0; /** Constante que representa el modo de juego de 'competición', en el que se termina el juego con al completar los 45 niveles. */ public final static byte COMPETICION = 1; /** Constante que representa una partida completada con éxito -se han completado los niveles necesarios. */ public final static byte VICTORIA = 2; /** Constante que representa una partida terminada en derrota -se han perdido todas las vidas. */ public final static byte DERROTA = 3; /** Constante que representa una partida sin terminar. */ public final static byte EN_CURSO = 4; // Variable que controla si hay pausa en el juego. private boolean pausa; // Variables para la puntuación, las vidas que quedan, la imagen de fondo para el juego, // el total de escenarios a completar para terminar el juego, el total de escenarios completados, // el escenario inicial de la partida, el resultado de la partida (una de las constantes de la clase), // y el modo de juego (de nuevo una constante de clase). private long puntuacion; private byte vidas; private byte fondoEscenario; private byte totalEscenarios; private byte escenarioActual; private byte escenarioInicial; private byte resultadoPartida; private byte modoJuego; // Los 'sprites' que intervendrán en el juego. private Pala pala; private Aliens aliens; private Nivel nivel; private Bola bola; private Bonos bonos; // Este applet. private ArkaLlop applet; // Variables que controlan si la partida aún no ha empezado, si se está cargando un nivel, // si se puede avanzar un nivel (atravesando la 'puerta transportadora' a la derecha de la pantalla // de juego), y si la partida ha finalizado ya. private boolean prePartida; private boolean cargandoNivel; private boolean puedeAvanzarNivel; private boolean finalizada; // Array para guardar los 45 escenarios para completar el juego en modo 'competición' // -no olvidemos que se puede empezar el juego desde cualquier escenario. private String escenario []; // Clase para gestionar el sonido en el juego. private Sonido sonido; // Clip de música de fondo durante la partida. private LlopClip musicaFondo; /** Constructor. @param nuevoApplet ArkaLlop Este applet. */ public Partida (ArkaLlop nuevoApplet) { // Inicializa la variable 'applet' y los 'sprites'. applet = nuevoApplet; pala = new Pala (this); aliens = new Aliens (this); bola = new Bola (this); nivel = new Nivel (this); bonos = new Bonos (this); // Establece las relaciones necesarias entre los 'sprites'. pala.setAliens (aliens); pala.setNivel (nivel); pala.setBonos (bonos); pala.setBolas (bola); aliens.setPala (pala); aliens.setNivel (nivel); aliens.setBonos (bonos); bola.setPala (pala); bola.setAliens (aliens); bola.setNivel (nivel); bola.setBonos (bonos); // Por defecto, el array de los escenarios comienza con el "1" y va hasta el "45". escenario = new String [ColeccionNiveles.TOTAL_NIVELES]; for (byte i = escenarioInicial; i < ColeccionNiveles.TOTAL_NIVELES; i++) escenario [i] = String.valueOf (i + 1); // Inicializar las variables. variablesPorDefecto (); setOpciones ((byte) 0, FondosPantalla.FONDO_0, COMPETICION); // Inicializamos el clip con la música de fondo, y la clase 'sonido'. musicaFondo = null; try { musicaFondo = LlopClip (new URL (applet.getCodeBase () + "jamaica sun.wav")); } catch (MalformedURLException e) { ArkaLlop.error ("URL '" + applet.getCodeBase () + "jamaica sun.wav' no válida."); } sonido = new Sonido (musicaFondo); } /** Inicializa las variables con valores por defecto. */ public void variablesPorDefecto () { pausa = true; // La partida está pausada, prePartida = true; // todavía no ha empezado; cargandoNivel = true; // el nivel está cargándose, puedeAvanzarNivel = false; // la puerta transportadora, cerrada; finalizada = false; // la partida no ha terminado, resultadoPartida = EN_CURSO; // está 'EN_CURSO'; puntuacion = 0; // la puntuación es 0, vidas = 2; // las vidas son 2, escenarioActual = 0; // y estamos en el primero de los escenarios (el 0). // Ponemos a los 'sprites' sus variables por defecto. varPorDefElementosJuego (); pala.variablesPorDefecto (); } /** Ajusta algunas de las variables de la bola, la pala, los aliens, y los bonos para preparar una nueva partida. */ public void varPorDefElementosJuego () { bola.variablesPorDefecto (); pala.limpia (); aliens.variablesPorDefecto (); bonos.variablesPorDefecto (); } /** Ajusta las variables 'escenarioInicial', 'fondoEscenario', y el modo de juego. @param nuevoEscenarioInicial byte Nuevo escenario inicial. @param nuevoFondoEscenario byte Nuevo fondo para la pantalla de juego -una constante de la clase 'FondosPantalla'. @param nuevoModoJuego byte Nuevo modo de juego -una de las constantes de esta clase. */ public void setOpciones (byte nuevoEscenarioInicial, byte nuevoFondoEscenario, byte nuevoModoJuego) { // Se rellena el array 'escenario' desde la primera posición hasta la última. // Empezamos a añadir escenarios desde el inicial hasta el tope (hay 45 niveles); si aún quedan // escenarios a añadir, metemos los que faltan empezando por el primero. byte i; byte j = 0; for (i = nuevoEscenarioInicial; i < ColeccionNiveles.TOTAL_NIVELES; i++) escenario [j++] = String.valueOf (i + 1); if (nuevoEscenarioInicial > 1) for (i = 0; i < nuevoEscenarioInicial; i++) escenario [j++] = String.valueOf (i + 1); escenarioInicial = nuevoEscenarioInicial; fondoEscenario = nuevoFondoEscenario; setModoJuego (nuevoModoJuego); } /** Reproduce un efecto sonoro. @param efecto byte Efecto sonoro a reproducir -una de las constantes de la clase 'Sonido'. */ public void suena (byte efecto) { sonido.efectoSonoro (efecto); } /** Hace sonar la música de fondo. */ public void playMusica () { sonido.playMusicaFondo (); } /** Detiene la música de fondo. */ public void stopMusica () { sonido.stopMusicaFondo (); } /** Devuelve los aliens. @return Aliens Aliens de esta partida */ public Aliens getAliens () { return aliens; } /** Devuelve la pala. @return Pala La pala de esta partida. */ public Pala getPala () { return pala; } /** Devuelve la bola. @return Bola La bola de esta partida. */ public Bola getBola () { return bola; } /** Devuelve el nivel. @return Nivel El nivel de esta partida. */ public Nivel getNivel () { return nivel; } /** Devuelve los bonos. @return Bonos Los bonos de esta partida. */ public Bonos getBonos () { return bonos; } /** Método utilizado al completar un nivel -rompiendo los ladrillos o a través de la puerta. */ public void completaNivel () { // Avanzamos uno en los escenarios, y cargamos el nivel. escenarioActual++; cargaNivel (); } /** Carga el nivel indicado por el 'escenarioActual'. */ public void cargaNivel () { // Ajustar las variables pertinentes. cargandoNivel = true; pausa = true; prePartida = true; // ¿Ha completado el juego? if (escenarioActual == totalEscenarios) { escenarioActual--; // No conviene tener un escenario fuera de los limites del array. terminaPartida (VICTORIA); // La partida termina en victoria para el jugador. suena (Sonido.JUEGO_COMPLETO); // Suena un alegre 'jingle'. return; } // En un segundo tendremos que ajustar algunas variables a sus valores por defecto, // cargar el nuevo nivel, ajustar un par de variables booleanas, y hacer sonar la pala cargándose. // Se descubre el pastel: el mensaje 'Cargando nivel' miente -la mayor parte del tiempo; el segundo // es sólo un rato para permitir que hipotéticos sucesos programados en las alarmas de los // 'sprites' se lleven a término. El método 'run ()' se completa en pocas milésimas. new java.util.Timer ().schedule (new java.util.TimerTask () { public void run () { varPorDefElementosJuego (); nivel.cargaNivel (ColeccionNiveles.getNivel (escenario [escenarioActual])); puedeAvanzarNivel = false; cargandoNivel = false; suena (Sonido.CARGA_PALA); } }, 1000); } /** Define el modo de juego. Hay 'COMPETICION' -en el que hay que atravesar los 45 niveles para completar el juego- y 'ENTRENAMIENTO' -en el que sólo hay que atravesar uno. @param nuevoModoJuego byte El modo de juego -una de las constantes de esta clase. */ public void setModoJuego (byte nuevoModoJuego) { modoJuego = nuevoModoJuego; if (modoJuego == COMPETICION) totalEscenarios = 45; else totalEscenarios = 1; } /** Devuelve el resultado de esta partida. Puede ser 'VICTORIA', 'DERROTA', o 'EN_CURSO'. @return byte El resultado de la partida -una de las constantes de esta clase. */ public byte getResultadoPartida () { return resultadoPartida; } /** Devuelve el número de vidas restantes. @return byte Vidas que le quedan al jugador en esta partida. */ public byte getVidas () { return vidas; } /** Devuelve el escenario inicial. @return byte Escenario inicial de la partida. */ public byte getEscenarioInicial () { return escenarioInicial; } /** Devuelve la constante que representa la imagen de fondo del juego. @return byte El escenario inicial -una de las constantes de la clase 'Fondos Pantalla'. */ public byte getFondoEscenario () { return fondoEscenario; } /** Devuelve el modo de juego. @return byte El modo de juego -una de las constantes de esta clase. */ public byte getModoJuego () { return modoJuego; } /** Suma una vida a las que había. */ public void ganaVida () { vidas++; } /** Además de quitar una vida, ajusta algunas variables de los 'sprites' y de la partida para preparar el juego para el siguiente intento. */ public void pierdeVida () { // Ajustar variables booleanas. pausa = true; prePartida = true; puedeAvanzarNivel = false; // Restar vida. vidas--; // Volver variables de 'sprites' a sus valores por defecto. aliens.variablesPorDefecto (); bola.variablesPorDefecto (); pala.variablesPorDefecto (); bonos.variablesPorDefecto (); // Sonar ruidillo de cargar la pala. suena (Sonido.CARGA_PALA); } /** Permite conocer si el juego está pausado. @return boolean 'true' o 'false' según el juego esté pausado o no. */ public boolean getPausa () { return pausa; } /** Define el estado de pausa del juego. @param partidaPausada boolean 'true' o 'false' según se quiera pausar o despausar el juego. */ public void setPausa (boolean partidaPausada) { pausa = partidaPausada; } /** Permite conocer si la partida aún no ha empezado. @return boolean 'true' o 'false' según la partida no haya empezado o sí. */ public boolean getPrePartida () { return prePartida; } /** Define el valor de 'prePartida'. @param esPrePartida boolean 'true' o 'false' según estemos entre partidas o no. */ public void setPrePartida (boolean esPrePartida) { prePartida = esPrePartida; } /** Permite saber si la partida ha terminado. @return boolean 'true' o 'false' según haya terminado la partida o no. */ public boolean getFinalizada () { return finalizada; } /** Permite saber si se está cargando un nuevo nivel. @return boolean 'true' o 'false' según se esté cargando el nivel o no. */ public boolean getCargandoNivel () { return cargandoNivel; } /** Sirve para sumar puntos a la puntuación. Esta es la tabla de puntuaciones: - Impactar ladrillo: 100 puntos. - Reventar ladrillo: 300 puntos. - Pillar un bono con la pala: 1000 puntos. - Impactar un bono con un tiro: 200 ó 400 según la potencia del tiro -normal o doble. - Reventar alien con una bola o de un tiro: 500 puntos. - Introducir un código de trampa: -10000 puntos (sí, puntuación negativa). @param puntos long Número de puntos que se sumarán a la puntuación. */ public void sumaPuntos (long puntos) { puntuacion += puntos; } /** Devuelve la puntuación. @return long Puntuación actual de la partida. */ public long getPuntuacion () { return puntuacion; } /** Devuelve el total de escenarios a completar para terminar el juego. Dependerá del modo de juego. @return byte Número de escenarios a completar para terminar el juego. */ public byte getTotalEscenarios () { return totalEscenarios; } /** Devuelve el escenario actual. @return byte Escenario en el que se encuentra el jugador. */ public byte getEscenarioActual () { return escenarioActual; } /** Devuelve el nombre del escenario actual. Corresponde a la 'llave' que se puede utilizar para conseguir un 'nivel' (uno de los arrays de bytes) de la 'Hashtable' de 'ColeccionNiveles'. @return String Cadena con el nombre identificador del escenario actual. */ public String getNombreEscenario () { return escenario [escenarioActual]; } /** Permite saber si la puerta teletransportadora al siguiente nivel ha sido abierta. @return boolean 'true' o 'false' según la puerta haya sido abierta, o esté cerrada. */ public boolean getPuedeAvanzarNivel () { return puedeAvanzarNivel; } /** Se llama a este método cuando la partida ha terminado, y se le indica si el jugador ha ganado o ha perdido. Además, añadimos a la pantalla de juego el botón que permite pasar a la pantalla de menú. @param nuevoResultadoPartida byte Resultado de la partida -una de las constantes de esta clase. */ public void terminaPartida (byte nuevoResultadoPartida) { pausa = finalizada = true; resultadoPartida = nuevoResultadoPartida; applet.anadeBotonFinPantalla (); } /** Cambia de la pantalla de juego a la pantalla de menú. */ public void cambioAMenu () { applet.cambioAMenu (); } /** Cambia de la pantalla de menú a la pantalla de juego. */ public void cambioAJuego () { applet.cambioAJuego (); } /** Absorbe un bono. @param tipoBono byte Tipo del bono absorbido -una de las constantes de la clase 'Bonos'. */ public void absorbeBono (byte tipoBono) { // Cada bono tiene un efecto diferente, y su propio efecto sonoro. switch (tipoBono) { case Bonos.ACELERA_BOLAS: bola.acelera (); suena (Sonido.BONO_ACELERA_DECELRA); break; case Bonos.DECELERA_BOLAS: bola.decelera (); suena (Sonido.BONO_ACELERA_DECELRA); break; case Bonos.TRES_BOLAS: bola.tripAlms(); suena (Sonido.BONO_TAMANO_BOLA); break; case Bonos.TAMANO_BOLAS: bola.cambiaTamano (); suena (Sonido.BONO_TAMANO_BOLA); break; case Bonos.DISPAROS_PALA: pala.cambiaDisparos (); suena (Sonido.BONO_TIRO); break; case Bonos.ANCHURA_PALA: pala.cambiaTamano (); suena (Sonido.BONO_TAMANO_PALA); break; case Bonos.IMAN_PALA: pala.cambiaImantacion (); suena (Sonido.BONO_IMAN); break; case Bonos.VIDA: vidas++; suena (Sonido.BONO_VIDA); break; case Bonos.SIGUIENTE_NIVEL: puedeAvanzarNivel = !puedeAvanzarNivel; suena (Sonido.BONO_NIVEL); } } /** Arranca los hilos de los 'sprites': la pala, los aliens, las bolas, y los bonos. */ public void arrancaHilosSprites () { pala.arrancaHilo (); aliens.arrancaHilo (); bola.arrancaHilo (); bonos.arrancaHilo (); } /** Genera un bono al azar, y lo sitúa donde estaba el ladrillo que acaba de reventar. Llama a la función homónima de la clase 'Bonos'. @param posXLadrillo byte Coordenada X (en el array) del ladrillo que acaba de petar. @param posYLadrillo byte Coordenada Y (en el array) del ladrillo que acaba de petar. */ public void generaBono (byte posLadrilloX, byte posLadrilloY) { bonos.generaBono (posLadrilloX, posLadrilloY); } /** Genera un alien. Lo que hace es llamar a la función homónima de la clase 'Aliens'. */ public void generaAlien () { aliens.generaAlien ((byte) (Math.random () * 3)); } }
¿Comentarios, sugerencias?: llopsite.at.yahoo.es | © 2005-07 Albert Lobo
Última actualización: 18-Feb-2007