Juego memorize

Bienvenid@ lector/a, en esta nueva entrada les dejare un pequeño juego para que se entretengan, se trata del juego de un juego de memorización, para que puedan jugarlo ustedes mismo o para que sus niños se entretengan un poco.

Primero que todo, ¿En qué consiste el juego?: El juego de memorización o "Memorize" es un proceso en el cual tienes que usar un proceso mental deliberado con el objetivo de almacenar en la memoria los artículos de recuerdos anteriores, en este caso memorizar pares de imágenes similares. 

Empezare desglosando un poco el código ya que en si es súper sencillo y rápido de explicar.

En primer lugar tendrás que crear una interfaz similar a esta en el formulario  Windows “Windows form”, en cual tiene como característica que su tamaño es de 800x600 pixeles, que equivale a una resolución relativamente agradable al ojo. Además de contar con un botón para comenzar un nuevo juego.

Imagen 1: Interfaz principal.

Explicación del código:

   1:          #region variables

   2:          private Button[] botones = new Button[16];

   3:          private Button botonAnt = new Button();

   4:          private PictureBox[] miniatura = new PictureBox[16];

   5:          private int parejas = 0;

   6:          private int contador = 1;

   7:          private int[] arr = new int[16];

   8:          private Random r = new Random();

   9:          private String[] rutas = null;

  10:          #endregion

Como toda aplicación las variables se encuentran en la cabecera del código, aquí se pueden apreciar arreglos de botones "botones" en el cual se almacenarán todos los botones que se utilizaran para mostrar las imágenes, el "botonAnt" se creara como referencia, y en "miniaturas" se creara un arreglo simulando un mapa donde estarán todas las imágenes implementadas a modo de saber en qué posición se encuentra cada una.

   1:          private void Form1_Load_1(object sender, EventArgs e)

   2:          {

   3:              rutas = Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "imagenes"));

   4:              this.crearBotones();

   5:              this.crearMiniatura();

   6:   

   7:          }

A continuación se encuentra la sección que se carga al iniciar el programa, aquí se seteará el origen de la fuente de imágenes a capturar, y se iniciaran los métodos de creación de botones en la interfaz y el posicionamiento de las miniatura en el mapa de arreglos.

   1:          //click de botones

   2:          private void boton_click(object sender, EventArgs e)

   3:          {

   4:              Button miboton = sender as Button;

   5:              miboton.BackgroundImage = miniatura[(int)miboton.Tag].Image;//sete de imagen a botn

   6:              verificacion(this.botonAnt, miboton);

   7:              this.botonAnt = miboton;//guarda el boton actual como el anterior

   8:   

   9:          }

Este evento de botón es de uso general, ya que todos los botones creados, es decir, todos los botones que se muestran en la interfaz grafia exceptuando el botón de nuevo juego utilizaran para capturar el evento de “click”. Este evento se encargara de mostrar la imagen correspondiente a la posición del botón.

   1:          //boton de reseteo (Nuevo Juego)

   2:          private void button1_Click(object sender, EventArgs e)

   3:          {

   4:   

   5:              this.arr = new int[16];

   6:              this.crearMiniatura();

   7:   

   8:              foreach (Control c in this.Controls)

   9:              {

  10:                  if (c is Button)

  11:                  {

  12:                      c.BackgroundImage = null;

  13:                      c.Enabled = true;

  14:                  }

  15:              }

  16:   

  17:          }

Este evento de botón tendrá como objetivo resetear el juego, por ende tendrá que cambiar las imágenes de posición y borrar las imágenes de los botones que estén visibles.

   1:          #region Crea botones

   2:          private void crearBotones()

   3:          {

   4:              int x0 = 80;

   5:              int y0 = 80;

   6:              int x = x0;

   7:              int y = y0;

   8:              int w = 100;

   9:              for (int i = 0; i < 16; i++)

  10:              {

  11:                  this.botones[i] = new Button();

  12:                  this.botones[i].Location = new Point(x, y);

  13:                  this.botones[i].Size = new Size(w, w);

  14:                  this.botones[i].BackColor = Color.Red;

  15:                  this.botones[i].Tag = i;

  16:                  this.botones[i].Click += new EventHandler(this.boton_click);

  17:                  this.Controls.Add(this.botones[i]);

  18:   

  19:                  x = x + w;

  20:                  if ((i + 1) % 4 == 0)

  21:                  {

  22:                      x = x0;

  23:                      y = y + w;

  24:                  }

  25:              }

  26:          }

  27:          #endregion

Este método en concreto tiene como función crear el arreglo de botones que serán visibles en nuestra interfaz, además de agregarlo a esta misma con el evento genérico asociado a cada botón creado.

   1:          #region crea miniaturas

   2:          private void crearMiniatura()

   3:          {

   4:   

   5:              this.genera_random_no_repetido();//invoco metodo que genera numeros randomicos sin repetirlos

   6:              int j = 0;

   7:              //recorre el arreglo con los numeros desordenados

   8:              foreach (int e in this.arr)

   9:              {

  10:                  this.miniatura[j] = new PictureBox();

  11:                  this.miniatura[j].Location = new Point(0, 0);

  12:                  this.miniatura[j].Size = new Size(20, 20);

  13:                  this.miniatura[j].SizeMode = PictureBoxSizeMode.StretchImage;

  14:                  this.miniatura[j].Tag = Path.GetFileName(rutas[e]); ;

  15:                  this.miniatura[j].Image = Image.FromFile(rutas[e]);

  16:                  j++;

  17:              }

  18:          }

  19:          #endregion

Este método tiene un objetivo similar al anterior pero este se encarga de sestear las imágenes en el arreglo de imágenes de tal forma que las imágenes se ordenen de forma aleatoria, sim embargo este orden se expresa en otro método el cual se encarga de realizar la “ordenación aleatoria” verificando que ninguna imagen se repita más de dos veces.

   1:          /**

   2:           *Método de verificacion, si hubo un ganador 

   3:           **/

   4:          private void verificacion(Button anterior, Button actual)

   5:          {

   6:   

   7:              if ((this.contador % 2 == 0) && (int)anterior.Tag != -1)

   8:              {

   9:                  //validacion si son imagenes iguales en este caso por nombre img1 = img1  (solo tomo el numero)

  10:                  if (this.miniatura[(int)anterior.Tag].Tag.ToString().Substring(3, 1) == this.miniatura[(int)actual.Tag].Tag.ToString().Substring(3, 1))

  11:                  {

  12:                      anterior.Enabled = false;//desactiva boton anterior

  13:                      actual.Enabled = false;//desactiva boton actual

  14:                      this.parejas++;

  15:                  }

  16:                  else//de lo contrario se muestra por medio segundo y se resetean las imagenes

  17:                  {

  18:                      Thread a = new Thread(() =>//se utiliza un hilo para que no se trabe el programa

  19:                      {

  20:                          actual.Invoke(new Action(() =>//se aplica una llamada a un metodo cuando se presiona el boton actual

  21:                          {

  22:                              Thread.Sleep(500);//espera de .5 seg

  23:                              anterior.BackgroundImage = null;//resetea imagen boton anterior

  24:                              actual.BackgroundImage = null;//resetea imagen boton actual

  25:                          }));

  26:   

  27:                      });

  28:                      a.Start();//se inicia el hilo

  29:                  }

  30:              }

  31:              //si el contador de parejas es igual a la mitad de la cantidad de miniaturas ganas

  32:              if (this.parejas == (this.miniatura.Length) / 2)

  33:              {

  34:                  MessageBox.Show("Ganaste");

  35:                  this.parejas = 0;

  36:                  this.contador = 1;

  37:                  return;

  38:              }

  39:              this.contador++;

  40:          }

Aquí se encuentra lo más importante del código final, ya que es aquí donde se procesa toda la lógica del juego, este método verifica que las imágenes (2 botones) contengan imágenes similares, si es este caso entonces los botones que contienen estas imágenes quedan inhabilitados para que no sea posible presionarlo nuevamente. Además de verificar que se haya completado el juego completo.

   1:          /**

   2:           * Metodo que genera numeros aleatorios sin repetir 

   3:           *

   4:           **/

   5:          private void genera_random_no_repetido()

   6:          {

   7:   

   8:              this.arr[0] = 0;

   9:              for (int i = 1; i < 16; i++)

  10:              {

  11:                  int num;

  12:                  do

  13:                  {

  14:                      num = r.Next(1, 16);

  15:                  } while (repetido(this.arr, num));

  16:                  this.arr[i] = num;

  17:   

  18:              }

  19:          }

Este proceso es el que se encarga de generar una matriz de números aleatorios en el cual se basara la muestra de imágenes al azar.

   1:          /**

   2:           *Método que verifica que los numeros que se ingresan al arreglo no esten repetidos

   3:           *

   4:           **/

   5:          private static bool repetido(int[] a, int r)

   6:          {

   7:              for (int i = 1; i < 16; i++)

   8:                  if (r == a[i])

   9:                      return true;

  10:              return false;

  11:          }

Este pequeño código pero no menos significativo es el encargado de que cada número realizado al azar no se repita más de dos veces dentro del arreglo de números aleatorio.

 Resultados

Imagen 2: Resultado final.

Imagen 3: Jugando.

APLICACIÓN DESARROLLADA CON VISUAL STUDIO 2015 COMMUNITY  

link de descarga: https://github.com/RobertCalbul/juego_memorize

Este sitio fue creado en primera instancia como un lugar donde ir acumulando información y/o apuntes que considere de utilidad para un futuro cercano, pero a medida que ha avanzado el tiempo este lugar se ha vuelto un punto de encuentro para muchas personas que se están iniciando en el mundo de la programación, es por eso que si estás leyendo esto estas invitado a participar en de esta comunidad que día a día va creciendo. Si estás dispuesto a cooperar te sugiero que dejes tus inquietudes, dudas o aportes en la caja de comentario de cualquiera de las entradas del blog o haciendo directamente desde el formulario de contacto que puede encontrar en la página de inicio y responderé a la brevedad.