Simplemente vamos a describir cada una de nuestras clases brevemente:

• Clase Juego: Es la única clase que contiene el main y es la encargada de iniciar el juego.

• Clase Pregunta: en ella se basa la estructura de todo el juego. En su constructor le pasamos como parámetros: la pregunta, la respuesta correcta, y las 4 posibles respuestas. Sólo contiene los métodos de acceso, para posteriormente poder acceder a estos parámetros desde cualquier clase.

• Clase Reproductor: implementa la interfaz ControllerListener. El constructor de esta clase tiene como parámetro la URL y es la encargada de crear el player y de añadirle el escuchador. En esta clase están implementados los métodos del manejo del evento (public synchronized void controllerUpdate(ControllerEvent event)) y también los de empezar y parar la reproducción.

Como sabemos el juego 50×15 consta de 15 preguntas, cada una de ellas con 1 nivel de dificultad mayor. En nuestro caso, hemos dividido las 15 preguntas en 3 niveles de dificultad; por ello tenemos 3 clases Nivel:

• Clase Nivel1, Clase Nivel2 yClase Nivel3

Estas 3 clases tienen la misma estructura: en ellas creamos 15 objetos de la clase Pregunta con distintos niveles de complejidad (dependiendo de la clase en la que estemos vamos aumentando el nivel de dificultad); y asignamos los objetos Pregunta creados a cada una de las posiciones del array que hemos denominado arrayPreg[]. Posteriormente, con el método rellenaArrayNx() lo que hacemos es seleccionar 5 preguntas del arrayPreg[] que no se repitan y guardarlo en un nuevo array denominado definitivasNx[]. Por lo tanto, lo que conseguimos con este método es 1 array con 5 preguntas de cada nivel. Posteriormente, en la clase PantallaPreg uniremos estos 3 arrays de 5 preguntas en un array denominado juntos[] que contendrá las 15 preguntas propuestas al jugador.

A continuación, describimos las clases relacionadas con las pantallas del juego:

Estas pantallas heredan de JFrame e implementan ActionListener; por lo tanto, en todas ellas manejamos los eventos provocados al pulsar los botones dentro del método: public void actionPerformed (ActionEvent e).

• Clase Pantalla1: Es la pantalla de introducción al juego; en ella podemos seleccionar ver la ayuda, comenzar el juego o salir.
• Clase PantallaAyuda: implementamos una nueva pantalla en la que vamos a mostrar la ayuda del juego. En este caso usamos el BorderLayout para organizar los componentes. Tenemos 2 paneles: uno para el TextArea con la ayuda y las 2 JLabel y otro para el botón de volver.

• Clase PantallaNombre: en ella creamos otra nueva pantalla que permite al jugador insertar su nombre. Destacamos el método dameNombre(), que devuelve el nombre del concursante, que será necesario para la siguiente pantalla del juego, que llamará al jugador por su nombre.

• Clase PantallaComenzar: en esta clase usamos el BoxLayout en filas (Y_AXIS) para colocar los componentes, en ella creamos otra nueva pantalla para desear suerte al jugador. En el constructor de la clase pasamos como parámetro el nombre del concursante introducido en la pantalla anterior y también una referencia de la clase Pantalla1 para poder ocultar esta ventana y visualizar solamente la pantalla actual.

• Clase PantallaFallar: en ella creamos otra ventana que aparecerá en el caso de que el jugador conteste incorrectamente una pregunta, en ella se informa al jugador del premio obtenido. Permite al jugador volver a jugar, salir del juego o ver los créditos. Si el jugador pulsa el botón de créditos aparecerá una ventana modal, en este caso se trata de un JOptionPane de información con nuestros nombres. Para obtener el dinero acumulado por el jugador llamamos a un método denominado calcularDinero()en el que pasamos como parámetro una variable denominada contador respuestas que es la que determina, el dinero correspondiente.

• Clase PantallaPlantarse: aparecerá otra nueva ventana cuando el jugador decida plantarse. Como dependiendo del número de pregunta en la que se encuentre el jugador se llevará mas o menos dinero, usamos el método dameDinero en el que pasamos como parámetro la variable numPregunta para así obtener el dinero en este caso.

• Clase PantallaGanar: Es la última pantalla del juego si el jugador es capaz de contestar correctamente la ronda de 15 preguntas propuestas. En este caso, el dinero acumulado por el jugador es fijo; será siempre de 300.000 euros. Sólo permite al jugador salir del juego.

CLASES PANTALLAS COMODINES:

Desde estas clases simplemente elaboramos la interfaz grafica de las pantallas correspondientes a cada comodín, utilizando Swing.

Los métodos que calculan el mensaje que aparecerá en cada pantalla se encuentran en la clase PantallaPreg, y es desde allí donde asignamos el valor de dichos mensajes a la etiqueta correspondiente mediante la llamada :

PantallaComodin50 comodin50=new PantallaComodin50(“Comodin 50:50″);

comodin50.etiqueta1.setText(comodin50_50(juntos[s-1].dameRespOk()));

Que se encuentra dentro del public void actionPerformed(ActionEvent e)

1. Creamos un objeto de PantallaComodinLlamada al que llamamos comodin50 para poder acceder a la etiqueta1

2. El método comodin50_50 devuelve un String , pasándole como parametro la respueta correcta.

3. Para acceder a la respuesta correcta llamamos al array juntos[nº pregunta].dameRespOk para que nos dé la respuesta correcta adecuada a la pregunta en la que está el jugador.

4. El String devuelto por el método comodin50_50 lo metemos en la etiqueta1 mediante el setText.

Los métodos principales de los comodines son los que devuelven el String correspondiente y son los siguientes:

o String comodin50_50(String respuestasOk){…}: devolverá la respuesta correcta y otra aleatoria entre las restantes mediante llamadas al Math.Random().Nos parece demasiado enrevesado explicar el código de todos los comodines…pero si a alguien le interesara alguno en particular no tendríamos inconveniente en explicar su funcionamiento.

o String calculaPorcentajes(String respuestasOk){ …}hemos elaborado el código de manera que siempre dé la respuesta correcta el porcentaje más alto, sin embargo, este no será siempre el mismo. Al igual que en el método anterior el Math.Random nos ayudó mucho para devolver el resto de los porcentajes. El objetivo era tener porcentajes aleatorios (siempre diferentes) pero de manera que la respuesta correcta siempre fuera mayor y que la suma d todos fuera 100. Se consiguió el objetivo.

o String comodinLlamada(String respuestasOk){…}: en este método simplemente introducimos 5 posibles respuestas . la resp3 siempre dará la correcta, la resp 4 no dará ninguna pista, y la resp1 resp2 y resp5 dará una respuesta con un 80% de posibilidades de ser la correcta. Esto dará lugar a posibles engaños. El hecho de que salga una respuesta u otra también esta controlado por tantos por ciento;

• Clase pantallaPreg: contiene lo siguiente:

o Implementación en el constructor de la interfaz grafica de la pantalla principal, la que estará visible durante la ronda de preguntas.

o public Pregunta[] dameArray(){…}: Método que devuelve el array juntos[ ] con las 15 preguntas de los 3 niveles que aparecerán a lo largo del juego

o Los 3 metodos antes citados: String comodin50_50(String respuestasOk){…}, String calculaPorcentajes(String respuestasOk){ …} y String comodinLlamada(String respuestasOk){…}

o public int dameNumPregunta(){}: sirve para poder averiguar en qué numero de pregunta se encuentra el jugador a cualquier altura del juego, lo necesitábamos dado que el numero va cambiando dentro del ActionPerformer y necesitábamos sacar fuera esa variable para poder utilizarla en otros métodos, como el siguiente.

o int dameDinero(int numPregunta){ Calcula el dinero por el que se juega en función de la pregunta en la que se encuentre (etiqueta de información)

o public String [] dameArrayInfo(){…}:Controla el mensaje de información que va variando en función de la pregunta en la que se encuentre .

o public URL dameCancionX(){…}devuelve una url para luego pasársela como parámetro en la clase Reproductor y así poder controlar que sonido queremos en cada momento. Funcionaria asi:

o public void actionPerformed(ActionEvent e){…}: desde este método se manejan todos los eventos durante la ronda de preguntas:

o qué pasa si pulsamos la respuesta correcta—siguiente preg + aplausos

o qué pasa si pulsamos la respuesta incorrecta—pantallaFallar

o qué pasa si pedimos algún comodín—pantallaComodinx + sonido

o qué pasa si pulsamos el plantarnos—pantallaPlantarse

o qué pasa si acertamos la pregunta 15—pantallaGanar + sonido

o desde aquí además de controlar que pase o no la pregunta siguiente, controlamos que el mensaje de información vaya cambiando o detalles como que los comodines una vez usados se deshabiliten.

Ya conocéis un poco más nuestro juego!!!! Si queréis verlo no tenéis  más que pedirlo!!!

1. Diagrama de clases:

Nuestro juego consta de 8 clases, que pasaremos a explicar brevemente:

• Una clase principal denominada Juego que contiene el método main, a partir de la cual manejamos el funcionamiento del juego; utilizando todos los métodos creados en las clases citadas a continuación.
• Una clase Pregunta formada por los atributos (pregunta, respuesta correcta, respuesta a, respuesta b, respuesta c, respuesta d), el constructor (en el que le pasamos como parámetros todos los atributos)y los métodos de acceso. Esta clase sirve para crear los objetos posteriormente en las clases Nivel1, Nivel2 y Nivel3.
• Tres clases denominadas Nivel1, Nivel2 y Nivel3 en las que creamos objetos Pregunta de distintas dificultades. Cada clase contiene un array de 15 objetos Pregunta de los cuales se seleccionarán 5 objetos que guardamos en otro array denominado definitivasNx (dependiendo de la clase en la que estemos). Una vez elegidos los 5 objetos en cada clase; pasamos a tener un array de 15, que serán las preguntas definitivas que aparecerán por la consola al empezar a jugar (este array, llamado juntos, está implementado en la clase Juego).
• Una clase Comodines en la que aparecen los 3 métodos correspondientes a los 3 comodines del juego implementados (comodín del público, comodín de la llamada, comodín 50:50). Estos comodines no son 100% fiables, es decir, en un gran porcentaje darán la respuesta correcta, pero pueden engañar al jugador.
• Una clase Operaciones que se encarga de calcular el dinero acumulado por el jugador y gestiona cúal será el premio obtenido dependiendo de si éste se planta o falla la respuesta.
• Una clase Pantallas donde implementamos las distintas pantallas que van saliendo desde el inicio hasta el final del juego por la consola; es decir desde la bienvenida hasta que el jugador acaba su partida.

2. Diagramas de funcionamiento:

Ahora pasamos a explicar los diferentes estados de nuestro juego:

• Estado 1: Pantalla de bienvenida al juego, con la opción de ver las reglas del juego (a través de Ayuda) o pasar al siguiente estado.
• Estado 2: Pantalla donde el jugador puede elegir entre comenzar la partida o salir.
• Estado 3: Pantalla en la que el jugador introduce su nombre.
  • Sub-estado 3.1: Se reproduce un mensaje deseando suerte al jugador.
• Estado 4: Comienzan la ronda de preguntas.
• Estado 5: Fin del juego; ya sea porque el jugador ha fallado la respuesta, se ha plantado o ha superado el juego al completo respondiendo correctamente a las 15 preguntas.

3. Diagrama de despliegue:

• El código fuente, necesario para generar el ejecutable se encuentra en la carpeta  /JUEGO/ del fichero 50×15.zip.
• Ejecutar el juego con java Juego.
• A esta memoria se puede acceder desde nuestro blog, con la siguiente url: http://mariayaurora.wordpress.com/

4. Cosas pendientes:

En cuanto a la algoritmia del juego, estamos trabajando aún en estas cuestiones:

• Controlar lo que introducimos por teclado en estos dos casos:
  • En las pantallas iniciales: Queremos que salga un mensaje de tipo “Valor incorrecto, introduzca otra letra válida”.Sin embargo, en la versión actual se nos va directamente al estado 4 antes citado.
  • Si nos encontramos en la ronda de preguntas únicamente se puede introducir a, b, c, d, p, c1, c2 y c3. En caso contrario, deberá aparecer otro mensaje del tipo “Valor incorrecto, introduzca un valor correcto” (de momento, lo interpreta como una respuesta incorrecta y se sale del juego)
• En el estado 2, la opción de salir todavía no funciona.
• Hemos seleccionado las 15 preguntas (diferenciando niveles de dificultad) aleatoriamente; esto puede provocar la repetición de preguntas en una misma ronda. Queremos evitar dichas repeticiones.

En cuanto a la interfaz gráfica estamos esperando dar la parte teórica en clase para introducirlo en el juego.

En un principio no nos asustamos demasiado…el ejercicio 0 prácticamente lo hizo el profesor dado que estábamos bastante perdidos con el Path, el jre….etc, no nos eran demasiado familiares estos conceptos, pero con las explicaciones “pareció”que nos quedó claro….aunque nunca se sabe cuando nos volverán a surgir dudas sobre estos temas.

Ejercicio 1: Sin problemas damos un repaso a los bucles, nos viene bastante bien para refrescar la memoria. En el punto 4 se nos ocurre comprobar si el número de veces que se imprime “Hello World!” es el correcto, ya que no nos fiamos mucho…pero obviamente no íbamos a contar uno por uno la frase, por lo tanto, usamos el siguiente código:

public class HelloWorld200{

public static void main(String[ ] args){

for(int i=1; i<201;i++)

System.out.println (“HelloWorld!!”+ ” ” +i);   }

}

De esta manera cada “HelloWorld!” aparece numerado y así, comprobamos que efectivamente lo imprimía 200 veces.

 Ejercicio 2: De momento va bien la cosa…nos ilusionamos porque parece que va saliendo algo (¿¿¿durará mucho la ilusión???…) LLegados al punto 5 hicimos el ejercicio tanto con el espacio extra y sin él, que era el objetivo.

Empieza lo serio…ya intuíamos que no duraría mucho la ilusión

Ejercicio 3: Comenzamos leyendo el enunciado y la verdad es que en un principio nos asustamos un poco, tanta teoría…..pero bueno, lo peor fue ver el código propuesto capturando excepciones, en fin….pensamos: ¡si no lo hemos dado! (bueno vale, nosotras sí porque somos repetidoras, pero vamos, está olvidado)

 Creemos que el mayor impedimento en estos ejercicios es que no entendemos el código propuesto, su funcionamiento… porque incluye sentencias que aunque nos resultan familiares, no controlamos lo suficiente. Por ejemplo: la captura y lanzamiento de excepciones, el System.out.write , el System.err.println(e),el significado de importar paquetes….cosas que posiblemente no tienen gran dificultad, pero nos son desconocidas.

A pesar de esto, intentaremos profundizar en estos temas, y lograr entender todos estos conceptos porque seguramente tendremos que aplicarlos en próximas prácticas, incluso en nuestro juego.

Una vez perdidas en el ejercicio 4, 5 y 6 decidimos pasar al 7 que es mas teórico y no fue mal, pero gracias a la ayuda de google, wikipedia, etc (aunque nuestro nivel de inglés deja mucho que desear) pero nos gustaría responder abiertamente a la última pregunta, la 9:

¿¿Crees que leer códigos de otros puede ser una buena manera de aprender a programar??

Indiscutiblemente ¡NO!, desde nuestro punto de vista la única forma de aprender a programar es empezar desde 0, es decir, no partir de un código ya escrito, porque como nos pasaba en ejercicios anteriores (en los que nos dabais el código de partida) te puedes encontrar con excepciones, Buffereader, paquetes, métodos desconocidos para nosotros etc. que dificulten la comprensión del programa y provocan nuestro bloqueo inmediato.

¿Vosotros que opinais? ¿Os sirven de ayuda?

Somos María y Aurora y esperamos que esto nos sirva para poder entender mejor dudillas de las prácticas, ejercicios de clase, el juego….bueno ya sabeis…que empezamos con muchas esperanzas y a ver como acaba la cosa.

 Ánimo!!!!!! y para los que estén en primera convocatoria…no abandoneis!!  jeje