Clase Buscaminas

En esta clase trabajaremos la parte de la lógica del juego, donde ubicaremos el tipo de color de nuestro tablero, la posición de las minas.

De igual forma daremos la estructura de la imagen en la cual vamos a jugar.


using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace BuscaMinas
{
    class MapaMinas
    {
        Celda[,] mapa;
        //9 >= mina. 1,2,3,4,5,6,7,8 = minas adyacentes. 0 = casilla vacía y sin minas adyacentes.
        int nMinas;
        int casillasVistas = 0;
        int ancho;
        int alto;
        bool primerclick = true;
        PointF posicion;
        int anchoCelda = 22;
        int altoCelda = 22;
        internal MapaMinas() { }
        internal MapaMinas(int ancho, int alto, int numeroMinas, PointF posicion)
        {
            mapa = new Celda[alto, ancho];
            nMinas = numeroMinas;
            if (nMinas >= mapa.Length)
                throw new ArgumentOutOfRangeException("Debe haber al menos una casilla libre de minas");
            this.posicion = posicion;

            this.ancho = mapa.GetLength(1);
            this.alto = mapa.GetLength(0);
        }

        internal void DibujarCuadricula(System.Drawing.Graphics g)
        {

   //Aqui definimos los colores del tablero del buscaminas
            Pen lapizAzul = new Pen(Color.Blue, 1.0f);
            Pen lapizRojo = new Pen(Color.Red, 1.0f);
            Pen lapizNegro = new Pen(Color.Black, 1.0f);
            Pen lapizlima = new Pen(Color.Green, 1.0f);
            Pen lapiz = lapizNegro;


            Brush brushMina = Brushes.Blue;
            Brush brush = Brushes.BlueViolet;
            Brush brushLima = Brushes.PaleGoldenrod;
            Brush brushTexto = Brushes.Black;
            List<object> fig = imgMap();
            int[] ex = (int[])fig[0];
            int[] ey = (int[])fig[1];
            //Aqui inhabilitamos los espacios que no son de juego
            for (int i = 0; i < ex.Length; i++)
            {
                int auxy = ex[i];
                int auxx = ey[i];
                mapa[auxy, auxx].Visible = false;
            }
            //Aqui definimos las casillas que van a ser visibles en el juego
            for (int i = 0; i < alto; i++)
            {
                for (int j = 0; j < ancho; j++)
                {
                 
                    if (mapa[i, j].Visible == true)
                    {
                        int valor = mapa[i, j].Valor;

                        lapiz = lapizAzul;
                        switch (valor)
                        {
                            case 0:
                                break;
                            case 9:
                                g.FillRectangle(brushMina, j * anchoCelda + posicion.X, i * altoCelda + posicion.Y, anchoCelda, altoCelda);
                                break;
                            default:
                                g.DrawString(valor.ToString(), new Font("Calibri", 8), brushTexto, j * anchoCelda + posicion.X, i * altoCelda + posicion.Y);
                                break;
                        }
                    }
                    else
                    {
                        int reg = 0;
                        int auxy = 0, auxx = 0;
                        for (int id = 0; id < ex.Length; id++)
                        {
                            auxy = ey[id];
                            auxx = ex[id];
                            if (auxy == j && auxx == i)
                            {
                                g.FillRectangle(brushLima, j * anchoCelda + posicion.X, i * altoCelda + posicion.Y, anchoCelda, altoCelda);
                                reg++;
                            }
                        }
                        if (reg == 0) {
                            g.FillRectangle(brush, j * anchoCelda + posicion.X, i * altoCelda + posicion.Y, anchoCelda, altoCelda);
                        }
                     
                    }
                }
            }

            //Aqui dibujamos las lineas horizontales del tablero de juego
            for (int i = 0; i <= alto; i++)
            {
                g.DrawLine(lapizNegro, posicion.X, altoCelda * i + posicion.Y, anchoCelda * ancho + posicion.X, altoCelda * i + posicion.Y);
            }

            //Aqui dibujamos las lineas verticales del tablero de juego
            for (int i = 0; i <= ancho; i++)
            {
                g.DrawLine(lapizNegro, anchoCelda * i + posicion.X, posicion.Y, anchoCelda * i + posicion.X, altoCelda * alto + posicion.Y);
            }
         
           

         
        }

        private void ColocarMinas(int xInicial, int yInicial)
        {
            //Aqui hacemos el proceso de generar minas de manera aleatoria
            Point[] puntosMinas = new Point[nMinas];
            Random r = new Random();

            Point puntoIn = new Point(xInicial, yInicial);
            List<object> fig = imgMap();
            int[] ex = (int[])fig[1];
            int[] ey = (int[])fig[0];
            int ind = 0;
            for (int i = 0; i < nMinas; i++)
            {
                Point p = new Point();

                do
                {
                       int aux1 = r.Next(0, mapa.GetLength(1));
                       int aux2 = r.Next(0, mapa.GetLength(0));
                       int control = 0;
                       for (ind = 0; ind < ex.Length; ind++) {
                           if (aux1 == ex[ind] && aux2 == ey[ind]) {
                               control++;
                           }
                       }
                       if (control == 0) {
                           p.X = aux1;
                           p.Y = aux2;
                       }
                 
                } while (Contiene(puntosMinas, p) ^ p == puntoIn);

                puntosMinas[i] = p;
            }


            //Aqui ponemos los numeros de referencia para que el usuario pueda determinar donde hay mina
            for (int i = 0; i < puntosMinas.Length; i++)
            {
             
                mapa[puntosMinas[i].Y, puntosMinas[i].X].Valor = 9;

                if (puntosMinas[i].Y + 1 < alto)
                    if (mapa[puntosMinas[i].Y + 1, puntosMinas[i].X].Valor < 9)
                        mapa[puntosMinas[i].Y + 1, puntosMinas[i].X].Valor++;

                if (puntosMinas[i].X + 1 < ancho)
                    if (mapa[puntosMinas[i].Y, puntosMinas[i].X + 1].Valor < 9)
                        mapa[puntosMinas[i].Y, puntosMinas[i].X + 1].Valor++;

                if (puntosMinas[i].Y - 1 >= 0)
                    if (mapa[puntosMinas[i].Y - 1, puntosMinas[i].X].Valor < 9)
                        mapa[puntosMinas[i].Y - 1, puntosMinas[i].X].Valor++;

                if (puntosMinas[i].X - 1 >= 0)
                    if (mapa[puntosMinas[i].Y, puntosMinas[i].X - 1].Valor < 9)
                        mapa[puntosMinas[i].Y, puntosMinas[i].X - 1].Valor++;

                if (puntosMinas[i].Y + 1 < alto && puntosMinas[i].X + 1 < ancho)
                    if (mapa[puntosMinas[i].Y + 1, puntosMinas[i].X + 1].Valor < 9)
                        mapa[puntosMinas[i].Y + 1, puntosMinas[i].X + 1].Valor++;

                if (puntosMinas[i].Y + 1 < alto && puntosMinas[i].X - 1 >= 0)
                    if (mapa[puntosMinas[i].Y + 1, puntosMinas[i].X - 1].Valor < 9)
                        mapa[puntosMinas[i].Y + 1, puntosMinas[i].X - 1].Valor++;

                if (puntosMinas[i].Y - 1 >= 0 && puntosMinas[i].X - 1 >= 0)
                    if (mapa[puntosMinas[i].Y - 1, puntosMinas[i].X - 1].Valor < 9)
                        mapa[puntosMinas[i].Y - 1, puntosMinas[i].X - 1].Valor++;

                if (puntosMinas[i].Y - 1 >= 0 && puntosMinas[i].X + 1 < ancho)
                    if (mapa[puntosMinas[i].Y - 1, puntosMinas[i].X + 1].Valor < 9)
                        mapa[puntosMinas[i].Y - 1, puntosMinas[i].X + 1].Valor++;
            }

        }

        private bool Contiene(Point[] conjunto, Point elemento)
        {
            for (int i = 0; i < conjunto.Length; i++)
            {
                if (conjunto[i].X == elemento.X && conjunto[i].Y == elemento.Y)
                    return true;
            }

            return false;
        }

        internal bool DestaparCelda(int x, int y)
        {
//Destapa las celdas cliqueadas, si es la primera vez que se carga el juego se ejecuta el metodo Colocar minas si no ignora
//el condicional if (primerclick) y empieza a validar si hay mina y las pocisiones que hay a lado
            if (primerclick)
            {
                ColocarMinas(x, y);
                primerclick = false;
            }

            if (x < ancho && y < alto && x >= 0 && y >= 0 && mapa[y, x].Visible == false)
            {
                if (mapa[y, x].Valor >= 9)
                {
                    casillasVistas++;
                    return true;
                }

                DescubrirArea(x, y);

                casillasVistas=0;

                for (int i = 0; i < alto; i++)
                {
                    for (int j = 0; j < ancho; j++)
                    {
                        if (mapa[i, j].Visible == true)
                        {
                            casillasVistas++;
                        }
                    }
                }
                //mapa[y, x].Visible = true;

            }
            return false;
        }

        private void DescubrirArea(int x, int y)
        {
            //Si la casilla esta tapada
            if (mapa[y, x].Visible == false)
            {
                //Descubre la casilla
                mapa[y, x].Visible = true;
                //casillasVistas++;

                //Si no hay minas cercanas
                if (mapa[y, x].Valor == 0)
                {
                    //Recorre las casillas cercanas y tambien las ejecuta
                    for (int f2 = Math.Max(0, x - 1); f2 < Math.Min(ancho, x + 2); f2++)
                    {
                        for (int c2 = Math.Max(0, y - 1); c2 < Math.Min(alto, y + 2); c2++)
                        {
                            DescubrirArea(f2, c2);
                        }
                    }
                }
            }
        }

        internal void HacerTodoVisible()
        {
            for (int i = 0; i < alto; i++)
            {
                for (int j = 0; j < ancho; j++)
                {
                    mapa[i, j].Visible = true;
                }
            }
        }

        internal Celda[,] Casillas
        {
            get { return mapa; }
        }

        internal PointF Posicion
        {
            get { return posicion; }
        }

        internal int AnchoCelda
        {
            get { return anchoCelda; }
        }

        internal int AltoCelda
        {
            get { return altoCelda; }
        }

        internal int Ancho
        {
            get { return ancho; }
        }

        internal int Alto
        {
            get { return alto; }
        }

        internal int CasillasVistas
        {
            get { return casillasVistas; }
        }

        public List<Object> imgMap() {
// Aqui dibujamos las letras haciendo una tabulacion en los campos
            List<object>ls= new List<object>();
            int[]ejex={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,                   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1                  ,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,               3,3,3,3,3,3,3,3,3,3,3,3,3,3,          4,4,4,4,4,4,4,4,4,4,4,4,4,              5,5,5,5,5,5,5,5,5,5,5,5,             6,6,6,6,6,6,6,6,6,6,6,           7,7,7,7,7,7,7,7,7,7              ,8,8,8,8,8,8,8,8,8,8           ,9,9,9,9,9,9,9,9,9,9,        10,10,10,10,10,10,10,10,10,10         ,11,11,11,11,11,11,11,11,11,11        ,12,12,12,12,12,12,12,12,12,12,12,        13,13,13,13,13,13,13,13,13,13,13,13,         14,14,14,14,14,14,14,14,14,14,14,14,14,               15,15,15,15,15,15,15,15,15,15,15,15,            16,16,16,16,16,16,16,16,16,16,16,16,              17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,                  18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,             19,19};
            int[]ejey={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,         0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,       0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,      0,1,2,3,7,8,9,10,11,12,13,14,18,19    ,0,1,2,3,8,9,10,11,12,13,14,18,19,      0,1,2,3,9,10,11,12,13,14,18,19,      0,1,2,3,10,11,12,13,14,18,19    ,0,1,2,3,11,12,13,14,18,19,       0,1,2,3,7,12,13,14,18,19,      0,1,2,3,7,8,13,14,18,19,     0,1,2,3,7,8,9,14,18,19,               0,1,2,3,7,8,9,10,18,19,                0,1,2,3,7,8,9,10,11,18,19                ,0,1,2,3,7,8,9,10,11,12,18,19,               0,1,2,3,7,8,9,10,11,12,13,18,19,                      0,3,7,8,9,10,11,12,13,14,18,19,                 0,3,7,8,9,10,11,12,13,14,18,19,                   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,                            0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,                       0,19};
            ls.Add(ejex);
            ls.Add(ejey);
            return ls;
        }

        internal bool bandera(int x, int y, System.Drawing.Graphics g)
        {
            Brush brushLima = Brushes.DarkSlateBlue;
            //g.FillRectangle(brushLima, y * anchoCelda + x, x * altoCelda + y, anchoCelda, altoCelda);
            return false;
        }


    }
     
}