7.0.0.PeAndroid-Actividad Juego (I)

7.0.0.- Programación en Android – Actividad Juego (I)

En este capítulo crearemos el “algoritmo” básico que emplearemos para nuestro juego. Este consiste básicamente en generar una cadena con una expresión matemática, a la cuál el usuario deberá de contestar para después ver si estaba en lo cierto.

Vamos a abandonar por un momento nuestro programa en Android, para crear un programa de ejemplo en Java, así veremos como funcionaría nuestro algoritmo constructor de expresiones, y posteriormente lo añadiremos a nuestra actividad en Android.

El algoritmo en sí es bastante sencillo, y sería aproximadamente como el siguiente organigrama:

Creamos en Eclipse o en el entorno que tengamos instalado un nuevo proyecto Java, dentro de este proyecto creamos una nueva clase, en la que marcaremos la opción de crear el método main (public static void main (String[] args)).

Creando una clase para crear expresiones

Ahora que tenemos la clase principal, vamos a crear una clase nueva, que será la clase que tendrá la estructura de datos, así como los métodos necesarios para crear una pregunta y almacenarla en memoria.

Esta nueva clase le llamamos ClasePregunta.

En esta clase añadimos una variable miembro, a la que llamaremos mRnd:

static Random mRnd = new Random();

Esta variable contendrá un generador de números aleatorios, que utilizaremos en la clase.

A continuación añadiremos una clase que llamaremos Pregunta, y que será una estructura con los datos necesarios referentes a cada pregunta:

protected static class Pregunta { //Esta cadena contendrá la fórmula a+b+...=x String mFormula; //Este valor indica si la formula es correcta o no. boolean mEsCorrecta; //Esta es la respuesta dada por el usuario boolean mRespuestaUsuario; //Esta es la cadena con el resultado correcto // Se utiliza para indicar como sería el resultado correcto // (En caso de que se respondiese correcto y no fuera así.no lo hubiese sido ya) String mFormulaCorrecta; }

A partir de aquí añadiremos un método, creaPreguntaSuma (int nivel, int cantidad), y que devolverá un objeto del tipo Pregunta.

protected static Pregunta creaPreguntaSuma(int nivel, int cantidad) { Pregunta prg = new Pregunta(); //+Código aquí.

Las variables que le pasamos como parámetros serán una para configurar un nivel de dificultad (nivel) y la otra para indicar la cantidad de operandos que queremos en nuestra fórmula (cantidad). También creamos un objeto de tipo Pregunta(), que será el que devuelva esta función y en dónde almacenaremos los valores creados.

Crearemos dos variables, una almacenará el total, y la otra será un operando con el que iremos trabajando en cada momento.

int op = 0; int total = 0;

No sería necesario inicializarlas ahora, ya que se van a inicializar posteriormente, pero...

Obtenemos el primer dígito y lo almacenamos:

//Obtenemos el primer dígito, a este no le añadimos el "+" op = generaNumero(nivel); prg.mFormula = Integer.toString(op); total = op;

Aquí vemos que estamos haciendo uso de un método auxiliar generaNumero(nivel). Este método lo que hace es devolvernos un número aleatorio, y que dependiendo del nivel que le indiquemos será más o menos complicado. Veamos el método:

private static int generaNumero(int nivel) { switch (nivel) { case 0: return mRnd.nextInt(10); case 1: return mRnd.nextInt(20) - 10; default: //En caso de que no se inicialize de las otras maneras. return mRnd.nextInt(10); } }

Después de tener el primer número u operando, debemos continuar con los siguientes según se hubiese indicado en el parámetro cantidad. Esto lo hacemos a través de un bucle for:

//Las demás las hacemos dentro del bucle,ya que aqui añadimos el + for (int iteracion = 0; iteracion < cantidad; iteracion++) { op = generaNumero(nivel); //Comprobamos si es positivo para añadir el "+" if (op >= 0) { //Si es mayor o igual a 0 añadimos el "+" prg.mFormula = prg.mFormula + " + " + Integer.toString(op); } else { //Al ser negativo ya añaden el "-" prg.mFormula = prg.mFormula + Integer.toString(op); } //Sumamos el total resultante total = total + op; }

Al finalizar el bucle, ya tenemos el total correcto en “total” y la cadena en “prg.mFormula”. Ahora procedemos a guardar el total correcto, en forma de cadena, por si se lo hay que enseñar al jugador:

//De momento salvamos la formula correcta: prg.mFormulaCorrecta = prg.mFormula + " = " + total;

Nos falta evaluar si tenemos que dar un resultado correcto o no, con el siguiente código estamos listos:

if (mRnd.nextBoolean()) { prg.mEsCorrecta = true; //Si es true generamos un valor correcto: //Que ya lo teníamos almacenado de antes prg.mFormula = prg.mFormulaCorrecta; } else { prg.mEsCorrecta = false; //En caso de ser false generamos un número falso, // añadiendo al total, cualquier numero distinto de 0: op = generaNumero(nivel); //Si es cero le sumamos uno (para que sea falso); if (op == 0) op = 1; prg.mFormula = prg.mFormula + " = " + (total + op); }

Y por último, para terminar este método, retornamos el objeto:

return prg;

Ya hemos terminado con el código para esta clase, se podría optimizar, variar y complicar más, pero de momento nos es suficiente para nuestros propósitos: que funcione.

Probando la clase

Para comprobar nuestra clase, vamos a añadir un poco código al programa, así que vamos al método main, y añadimos lo siguiente:

ClasePregunta.Pregunta[] lote = new ClasePregunta.Pregunta[10]; for (int t = 0; t < lote.length; t++) { lote[t] = ClasePregunta.creaPreguntaSuma(1, 2); System.out.println(lote[t].mFormula + " " + lote[t].mEsCorrecta + " " + lote[t].mFormulaCorrecta + " " + lote[t].mRespuestaUsuario); }

Como vemos, primero creamos un array de objetos de tipo lote, que contendrán 10 elementos. Después utilizando el método estático creaPreguntaSuma(int,int) inicializamos cada uno de los objetos del array. Despues damos salida por consola para ver el resultado.

Bien, ahora que ya tenemos la clase encargada de crear las expresiones funcionando, volveremos a nuestro proyecto en Android y continuaremos diseñando la “ActividadJuego”, pero eso quedará para el siguiente capítulo.

Ver. 1.0 – Revisión 09/05/2012