Descubre la Programación : Muestra

/**
  * Versión del conocido 2048 como demostración del uso de
  * arrays.
  */
int matriz[][]; // Array de 2 dimensiones que contiene los números
int puntos; // Puntos totales conseguidos
boolean gameOver = false;

/**
  * Esta función rellena el array con ceros
  */
void crea() {
  for ( int fila = 0 ; fila < 4 ; fila++ ) {
    for ( int columna = 0 ; columna < 4 ; columna++ ) {
      matriz[fila][columna] = 0;  
    }
  }
}

/**
  * Esta función determina si se puede seguir jugando o
  * no. Devuelve true si ya no se puede seguir jugando y
  * false en caso contrario.
  **/
boolean tableroBloqueado() {
  int nopciones = 0;
  // Busco y cuento las posiciones de las celdas vacías
  for ( int fila = 0 ; fila < 4 ; fila = fila + 1 ) {
    for ( int columna = 0 ; columna < 4 ; columna = columna + 1 ) {
      int nf = 0;
      int nc = 0;
      nf = fila+1;
      nc = columna;
      if (nf >= 0 && nf < 4 && nc >= 0 && nc < 4 && 
          (matriz[fila][columna] == matriz[nf][nc] || matriz[nf][nc] == 0)) {
        nopciones = nopciones + 1;
      }
      nf = fila-1;
      nc = columna;
      if (nf >= 0 && nf < 4 && nc >= 0 && nc < 4 && 
          (matriz[fila][columna] == matriz[nf][nc] || matriz[nf][nc] == 0)) {
        nopciones = nopciones + 1;
      }
      nf = fila;
      nc = columna+1;
      if (nf >= 0 && nf < 4 && nc >= 0 && nc < 4 && 
          (matriz[fila][columna] == matriz[nf][nc] || matriz[nf][nc] == 0)) {
        nopciones = nopciones + 1;
      }
      nf = fila;
      nc = columna-1;
      if (nf >= 0 && nf < 4 && nc >= 0 && nc < 4 && 
          (matriz[fila][columna] == matriz[nf][nc] || matriz[nf][nc] == 0)) {
        nopciones = nopciones + 1;
      }
    }
  }
  if (nopciones == 0) {
    return true;
  } else {
		return false;
  }
}

/**
  * Esta función busca las celdas que contienen un cero y 
  * rellena una de ellas con un 2 o un 4. Tanto la celda como
  * el número se eligen aleatoriamente.
  */
void nuevo() {
  int []numeros = {2,4};
  int [][]opciones = new int[16][2];
  int nopciones = 0;
  // Busco, guardo y cuento las posiciones de las celdas vacías
  for ( int fila = 0 ; fila < 4 ; fila++ ) {
    for ( int columna = 0 ; columna < 4 ; columna++ ) {
      if (matriz[fila][columna] == 0) {
        opciones[nopciones][0] = fila;
        opciones[nopciones][1] = columna;
        nopciones++;
      }
    }
  }
  // Si hay alguna celda vacía elijo una y coloco un 2 o un 4
  if (nopciones > 0) {
    int numero = round(random(100))%2;
    int r = round(random(100))%nopciones;
    int f = opciones[r][0];
    int c = opciones[r][1];
    matriz[f][c] = numeros[numero];
  }
}

/**
  * Esta función realiza el movimiento del tablero en la dirección
  * indicada por los valores de df y dc que son las componentes de
  * un vector que indica la dirección del desplazamiento. 
  * Por ejemplo, un desplazamiento hacia arriba se codifica con
  * los valores df=-1 y dc = 0 y uno a la derecha con df=0 y dc=1.
  *
  * Para hacer el movimiento hay que tener en cuenta que los
  * números se desplazan sólo si hay una casilla vacía en la
  * celda hacia donde deben moverse. Si hay un número y este es
  * igual entonces el número desplazado se suma al que había.
  * pero esto sólo se hace si detrás no hay otro número igual.
  * De este modo se consigue el efecto de apilado correcto pues
  * el algoritmo siempre comprueba la posibilidad de movimiento
  * recorriendo la matriz en el mismo sentido.
  * Según la dirección de movimiento es opuesta al sentido en
  * que se recorre la matriz pueden ser necesarios varios 
  * recorridos consecutivos pero de este modo nos ahorramos
  * codificar los cuatro casos por separado.
  *
  * Por último, es necesario llevar la cuenta de las celdas que
  * corresponden a números fusionados en esta jugada ya que esas
  * no deben volver a fusionarse hasta una próxima jugada.
  *
  * Devuelve true si se ha podido hacer algún movimiento y false
  * en caso contrario.
  */
boolean mueve(int df, int dc) {
  // Esta matriz auxiliar guarda las celdas que son el resultado de una fusión
  boolean [][]aux = new boolean[4][4];
  // Indica si en el recorrido se ha movido o fusionado alguna celda
  boolean cambio = false; 
  // Cuenta el número de movimientos o fusiones
  int cambios = 0;
  int puntosJugada = 0;
  do {
    cambio = false;
    for ( int fila = 0 ; fila < 4 ; fila++ ) {
      for ( int columna = 0 ; columna < 4 ; columna++ ) {
        // Si no hay nada pruebo con la siguiente celda
        if (matriz[fila][columna] == 0) continue;
        // nf y nc representan la posición destino de la ficha actual
        int nf = fila + df;
        int nc = columna + dc;
        // nf2 y nc2 representan la posición que está detras del destino
        int nf2 = nf + df;
        int nc2 = nc + dc;
        // Si la posición destino está fuera del tablero no vale
        if (nf < 0 || nf >= 4 || nc < 0 || nc >= 4) continue;
        // Si el destino está vacío muevo el número allí
        if (matriz[nf][nc] == 0) {
          // Copio el número y lo borro de donde estaba
          matriz[nf][nc] = matriz[fila][columna];
          matriz[fila][columna] = 0;
          // Es necesario mover también la celda del array auxiliar
          aux[nf][nc] = aux[fila][columna]; 
          cambio = true;
          cambios++;
        } else
        // Si el destino contiene un número igual y ninguno de los dos es el resultado de una fusión en esta misma jugada
        if (matriz[nf][nc] == matriz[fila][columna] &&
            aux[nf][nc] == false && aux[fila][columna] == false) {
          // Y además, detrás no hay otro número igual
          if (nf2 < 0 || nf2 >= 4 || nc2 < 0 || nc2 >= 4 ||
             (nf2 >= 0 && nf2 < 4 && nc2 >= 0 && nc2 < 4 && 
              matriz[nf][nc] != matriz[nf2][nc2]) ) {
            // Sumo los números y  borro el que se ha movido de donde estaba
            matriz[nf][nc] += matriz[fila][columna];
            matriz[fila][columna] = 0;
            // Indico que el número es resultado de una fusión en esta jugada
            aux[nf][nc] = true;
            puntosJugada += matriz[nf][nc];
            cambio = true;
            cambios++;
          }
        }
      }
    }
  } while (cambio);  
  // Aumento el contador de puntos global
  puntos += puntosJugada;
  // Si se ha producido algún cambio añado un número nuevo
  if (cambios > 0) {
    return true;
  } else {
    return false;
  }
}

/**
  * Función que calcula el logaritmo en base 2 de un número. 
  */
double log2(double x) {
  return log(x)/log(2);
}

/**
  * Función que dibuja el tablero y muestra los puntos conseguidos.
  * Utiliza un array inicializado directamente con los valores
  * correspondientes a los colores de las distintas celdas. 
  * Cada celda se pinta usando el color que ocupa la posición
  * correspondiente al logaritmo en base 2 del número que contiene
  * excepto las vacías que se pintan usando el color que ocupa
  * la posición 0.
  */
void dibuja() {  
  int [][]colores = {
    {255,223,192}, // Color celda vacía
    {247,207,160}, // Color celda con un 2
    {239,191,128}, // Color celda con un 4
    {231,175, 96},
    {223,159, 64},
    {215,143, 32},
    {207,127,  0},
    {199,111,  0}, // Color celda con un 128
    {191, 95,  0},
    {183, 79,  0},
    {180, 70,  0}, 
    {167, 47,  0} // Color celda con un 2048
  };
  background(239,231,218,1);
  stroke(127,92,0);
  strokeWeight(4);
  for ( int fila = 0 ; fila < 4 ; fila++ ) {
    for ( int columna = 0 ; columna < 4 ; columna++ ) {
      int numero = matriz[fila][columna];
      if (numero < 1024) {
        textSize(24);
      } else {
        textSize(20);
      }
      // c guarda el índice del color a usar según el contenido de la celda
      int c = 0;
      if (numero > 0) c = round(log2(numero));
      if (c > 11) c = 11;
      fill(colores[c][0], colores[c][1], colores[c][2]);
      rect(20+columna*70, 30+fila*70, 70, 70);
      if (numero > 0 ) {
			  fill(0);
        // w y h sirven para centrar el texto del número en la casilla
        int w = textWidth(matriz[fila][columna])/2;
        int h = 0;
        if ( numero < 1024) {
          h = 24/2;
        } else {
          h = 22/2;
        }
      	text(numero, 20+columna*70+35-w, 30+fila*70+35+h);
      }
    }
  }
  fill(116,84,0);
  textSize(16);
  text("Puntos totales: " + puntos, 20, 24);
}

/**
  * Esta función se ejecuta cada vez que se suelta una tecla.
  * Si la tecla es uno de los cursores (flechas izquierda,
  * derecha, arriba y abajo) realiza el movimiento correspondiente
  * del tablero.
  */
void onKeyReleased(String key) {
  boolean movido = false;
  switch (key) {
    case "left": 
      movido = mueve(0,-1);
      break;
    case "right": 
      movido = mueve(0,1);
      break;
    case "up": 
      movido = mueve(-1,0);
      break;
    case "down": 
      movido = mueve(1,0);
      break;
  }
  if (movido == true) {
    nuevo();
    dibuja();
  }
}

// Contador para el fundido que se hace al terminar el juego 
int t = 0;

void juego() {
  if (tableroBloqueado() == true) {
    if (t < 75) {
    	background(0,0,0,0.01);
      t++;
    }
    textSize(32);
    fill(255);
    text("Game Over!", 40, 180);    
    if (mousePressed) {
      t = 0;
      crea();
      nuevo();
      nuevo();
      dibuja();
    }
  }
}

void main() {
  matriz = new int[4][4];
  crea();
  nuevo();
  nuevo();
  dibuja();
  animate(juego);
}

Programado por jlaguna

5 votos 821 descargas 282 usos