Пример #1
0
        public bool EliminarGruposCompletos()
        {
            bool elimino = false;

            List <Celda> celdasABorrar = new List <Celda>();

            for (int i = 0; i < FILAS; i++)
            {
                for (int j = 0; j < COL; j++)
                {
                    Celda        c       = new Celda(i, j, _tablero[i, j]);
                    List <Celda> vecinas = ObtenerCeldasVecinas(c);

                    //PASO LA CELDA ACTUAL Y A SUS VECINAS A LA LISTA A BORRAR
                    for (int k = 0; k < vecinas.Count; k++)
                    {
                        if (!celdasABorrar.Contains(vecinas[k]))
                        {
                            celdasABorrar.Add(vecinas[k]);
                        }
                    }
                }
            }

            if (celdasABorrar.Count > 2)
            {
                elimino = true;
            }

            //UNA VEZ QUE OBTENGO LA LISTA DE CELDAS A BORRAR LAS BORRO DEL TABLERO
            foreach (Celda unaCelda in celdasABorrar)
            {
                _tablero[unaCelda.Fila, unaCelda.Columna] = 0;
            }

            //EL DISTINC NO VA A HACER FALTA YA QUE CELDAS A BORRAR SE COARGA SI NO CONTIENE vecinas[k]
            //  List<Celda> celdas = listaRetorno.Distinct(new MiComparador()).ToList();

            this._celdasEliminadas += celdasABorrar.Count;

            //    MessageBox.Show("Celdas eliminadas = " + celdasABorrar.Count);

            return(elimino);
        }
Пример #2
0
        private List <Celda> ObtenerCeldasVecinas(Celda c)
        {
            List <Celda> celdasABorrar = new List <Celda>();


            int fila    = c.Fila;
            int columna = c.Columna;


            //////////////////////---------////////
            ////-------NORTE Y SUR---------//////////
            //////////////////////---------////////
            List <Celda> lista = new List <Celda>();

            lista.Add(c);

            //ME FIJO HACIA EL NORTE
            if (EsCeldaValida(fila - 1, columna))
            {    //COMPARACION DEL COLOR CON LA CELDA ACTUAL
                if (_tablero[fila, columna] == _tablero[fila - 1, columna])
                {
                    lista.Add(new Celda(fila - 1, columna, _tablero[fila - 1, columna]));
                }
            }
            ///Y LO CONECTO CON EL SUR
            if (EsCeldaValida(fila + 1, columna))
            {
                if (_tablero[fila, columna] == _tablero[fila + 1, columna])
                {
                    lista.Add(new Celda(fila + 1, columna, _tablero[fila + 1, columna]));
                }
            }

            //ENTONCES COMPRUEBO SI HAY MAS DE 2
            //SI HAY MAS DE 2 LAS AGREGO A LA LISTA DE CELDAS A BORRAR
            if (lista.Count > 2)
            {
                for (int i = 0; i < lista.Count; i++)
                {
                    celdasABorrar.Add(lista[i]);
                }
            }

            ///////////////////////////////////
            //////OESTE Y ESTE////////////////
            ///////////////////////////////////
            List <Celda> listaOesteEste = new List <Celda>();

            listaOesteEste.Add(c);

            /////----------ME FIJO HACIA EL OESTE------------
            if (EsCeldaValida(fila, columna - 1))
            {
                if (_tablero[fila, columna] == _tablero[fila, columna - 1])
                {
                    listaOesteEste.Add(new Celda(fila, columna - 1, _tablero[fila, columna - 1]));
                }
            }

            /////--------------ME FIJO HACIA EL ESTE---------------
            if (EsCeldaValida(fila, columna + 1))
            {
                if (_tablero[fila, columna] == _tablero[fila, columna + 1])
                {
                    listaOesteEste.Add(new Celda(fila, columna + 1, _tablero[fila, columna + 1]));
                }
            }

            if (listaOesteEste.Count > 2)
            {
                for (int i = 0; i < listaOesteEste.Count; i++)
                {
                    celdasABorrar.Add(listaOesteEste[i]);
                }
            }

            //////////////////////////////////////
            ///------NOROESTE - SURESTE-----------
            //////////////////////////////////////
            List <Celda> listaNorOesteSurEste = new List <Celda>();

            listaNorOesteSurEste.Add(c);
            //ME FIJO HACIA EL NOROESTE
            if (EsCeldaValida(fila - 1, columna - 1))
            {
                if (_tablero[fila, columna] == _tablero[fila - 1, columna - 1])
                {
                    listaNorOesteSurEste.Add(new Celda(fila - 1, columna - 1, _tablero[fila - 1, columna - 1]));
                }
            }

            //ME FIJO HACIA EL SURESTE
            if (EsCeldaValida(fila + 1, columna + 1))
            {
                if (_tablero[fila, columna] == _tablero[fila + 1, columna + 1])
                {
                    listaNorOesteSurEste.Add(new Celda(fila + 1, columna + 1, _tablero[fila + 1, columna + 1]));
                }
            }

            if (listaNorOesteSurEste.Count > 2)
            {
                for (int i = 0; i < listaNorOesteSurEste.Count; i++)
                {
                    celdasABorrar.Add(listaNorOesteSurEste[i]);
                }
            }

            //// /////////////////////////////////////
            //----------SUROESTE - NORESTE
            //////////////////////////////////////////
            List <Celda> listaSurOesteNorEste = new List <Celda>();

            listaSurOesteNorEste.Add(c);

            //ME FIJO HACIA EL SUROESTE
            if (EsCeldaValida(fila + 1, columna - 1))
            {
                if (_tablero[fila, columna] == _tablero[fila + 1, columna - 1])
                {
                    listaSurOesteNorEste.Add(new Celda(fila + 1, columna - 1, _tablero[fila + 1, columna - 1]));
                }
            }

            //ME FIJO HACIA EL NORESTE
            if (EsCeldaValida(fila - 1, columna + 1))
            {
                if (_tablero[fila, columna] == _tablero[fila - 1, columna + 1])
                {
                    listaSurOesteNorEste.Add(new Celda(fila - 1, columna + 1, _tablero[fila - 1, columna + 1]));
                }
            }


            if (listaSurOesteNorEste.Count > 2)
            {
                for (int i = 0; i < listaSurOesteNorEste.Count; i++)
                {
                    celdasABorrar.Add(listaSurOesteNorEste[i]);
                }
            }

            //SE BORRAN CUANDO TENGO TODAS LAS QUE TENGO QUE BORRAR REUNIDAS,
            //YA QUE SI POR EJ BORRO UNA FILA, SI POR EJEMPLO ESA FILA FORMARA UNA CRUZ
            //SI YO BORRO LA FILA A LA COLUMNA LE QUEDAN 2 Y NO PODRIA BORRARSE DESPUES
            return(celdasABorrar);
        }