Proyecto de ajedrez parte 1 Acertijo de las 8 reinas.

Que tal.

Buscando en mis archivos cuando era estudiante, me topé con una serie de proyectos que en su momento me costaron mucho tiempo y no tienen las mejores de las prácticas y sobre todo algunas materias recruzadas.

El día de hoy veremos un proyecto que  me toco realizar en estructura de datos.

Este proyecto se trata del acertijo de las 8 reinas y el acertijo del caballo.

Comencé primero por el acertijo de las reinas, de pronto no podía escribir nada, sentía que diseñar clases basados en el ajedrez, debían de estar bien diseñadas, al menos pretendía hacerlo de una manera más estructurada y con más infraestructura.

Podemos ver a simple vista, que una pieza de ajedrez puede moverse regida por ciertos movimientos con restricción a la pieza que se va a mover.

Los peones avanzan hacia adelante.

Las torres se mueven en línea recta, de manera vertical u horizontal, no pueden saltar piezas.

Los alfiles se mueven de forma diagonal, al igual que las torres no pueden brincar piezas.

Los caballos, se mueven en forma de L, ellos sí que saltan a las piezas.

Reina, se mueve para done quiera menos de forma de L y no puede saltar piezas.

El rey se mueve para cualquier dirección pero solo un movimiento.

Hasta aquí todo sencillo, nada más que las reglas básicas del ajedrez.

Cuando sumamos la complejidad de que un peón puede convertirse en cualquier pieza.

Me recordó bastante al patrón de estrategia.

Podemos notar que un movimiento es un comportamiento y deducimos que una pieza de ajedrez podría moverse a cualquier lado de acuerdo a su movimiento actual y su condición.

Quise intentar diseñar todo este tipo de reglas.

Aquí podrán observar la estructura de clases.

Aquí les dejo la implantación del acertijo de las 8 reinas:

         public void Insertar8Reinas( bool[] prenglones, bool[] pcolumnas,Reina reina,ref             int numeroSoluciones,int nReinas)

        {  

            int renglon = 0, columna = 0;

            bool[] lrenglones = (bool[])prenglones.Clone();

            bool[] lcolumnas = (bool[])pcolumnas.Clone();

            if (comparaBooleanos.ComparaArreglo(prenglones))

            {

                tableros[numeroSoluciones] = new TableroAjedrez();

                numeroSoluciones++;

                return;

                            

            }

            else

            {

                           

                    renglon = comparaBooleanos.TomaCualquierDelArreglo(prenglones);

                    lrenglones[renglon] = true;

                    while (!comparaBooleanos.ComparaArreglo(lcolumnas))

                    {

                       

                        columna = comparaBooleanos.TomaCualquierDelArreglo(lcolumnas);

                        if (columna == -1)

                            return;

                        lcolumnas[columna] = true;

                        reina.X = renglon;

                        reina.Y = columna;

                        if (reina.SePuedeInsertar(reina, this))

                        {

                            tablero[renglon, columna] = reina;

                            Console.SetCursorPosition(renglon, columna);

                            Console.WriteLine("R");

                            Thread.Sleep(500);

                            pcolumnas[columna] = true;

                            this.Insertar8Reinas(lrenglones,pcolumnas,reina,ref                                          numeroSoluciones, ++nReinas);

                            nReinas--;

                            pcolumnas[columna] = false;

                            //prenglones[renglon] = true;

                            tablero[renglon, columna] = null;

                            Console.SetCursorPosition(renglon, columna);

                            Console.WriteLine(" ");

                            Thread.Sleep(500);

                        }                      

                    }

            }

        }