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);

                        }                      

                    }

            }

        }

Graficando un tablero de ajedrez en WPF.

Que tal, buen día,  el día de hoy graficaremos un tablero de ajedrez en WPF.

1.- Crear un proyecto en WPF.





2.- Crear un control de usuario para un tablero de ajedrez.

Aquí les pongo el código en XAML.

<UserControl x:Class="WPFChessProject.ChessBoard"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

             mc:Ignorable="d"

             d:DesignHeight="800" d:DesignWidth="800">

    <Grid x:Name="grdPrincipal">

        <StackPanel x:Name="stkBoard">

           

        </StackPanel>

    </Grid>

</UserControl>

Ahora construiremos nuestro tablero.

Primero que nada, lo que necesitamos es definir el color de las piezas blancas y de las piezas negras, por lo que necesitamos dos propiedades de tipo color.

public Color colorOfWhitePiece { get; set; }

public Color ColorOfBlackPiece { get; set; }

También es necesario tener el conjunto de casillas agrupadas.

public List<StackPanel> Boxs { get; set; }

Aquí las agrupamos en una lista de StackPanels que nos permitirán mostrar cualquier objeto derivado de la clase UIElement, esto con el fin de que si el proyecto crece se podrán crear controles como piezas de ajedrez para simular una partida de ajedrez.

El control StackPanel es un contenedor que nos permite tener una serie de controles derivados con el fin de hacer uso de los mismos.

En los controles de WPF, en los contenedores se cuenta con la propiedad Childrens, que es una lista de UIElement que son los objetos que se graficaran en nuestra pantalla.

Una vez que tenemos declaradas nuestras propiedades, es necesario crear e implementar un método que nos permita renderear nuestro tablero de ajedrez.

        public void RenderBoard()

        {

            StackPanel box;

            bool isWhite = true;

            for (int i = 0; i < 8; i++)

            {

                StackPanel rowBoxes = new StackPanel();

                rowBoxes.Orientation = Orientation.Horizontal;

                for (int j = 0; j < 8; j++)

                {

                    box = new StackPanel();

                    box.Width = this.Width / 8;

                    box.Height = this.Height / 8;

                    if (isWhite)

                    {

                        box.Background = new SolidColorBrush(ColorOfWhitePiece);

                        isWhite = false;

                    }

                    else

                    {

                        box.Background = new SolidColorBrush(ColorOfBlackPiece);

                        isWhite = true;

                    }

                    rowBoxes.Children.Add(box);

                    Boxs.Add(box);

                }

                if (isWhite)

                    isWhite = false;

                else

                    isWhite = true;

                this.stkBoard.Children.Add(rowBoxes);

            }

        }

En el método RenderBoard creamos dos variables locales, una variable representa una casilla de nuestro tablero de ajedrez y otra variable booleana   que nos permite saber si la casilla es color blanco o negro según el ajedrez.

StackPanel box;

bool isWhite = true;

También tenemos dos ciclos for que nos permiten recorrer el tablero de ajedrez

            for (int i = 0; i < 8; i++)

            {

                StackPanel rowBoxes = new StackPanel();

                rowBoxes.Orientation = Orientation.Horizontal;

                for (int j = 0; j < 8; j++)

                {

                    box = new StackPanel();

                    box.Width = this.Width / 8;

                    box.Height = this.Height / 8;

Las dos primeras lineas representan una fila de un tablero de ajedrez con ocho columnas

StackPanel rowBoxes = new StackPanel();

rowBoxes.Orientation = Orientation.Horizontal;

en las primeras líneas del segundo for tenemos la instancia de una casilla de ajedrez y la asignación de ancho y alto.

                    box = new StackPanel();

                    box.Width = this.Width / 8;

                    box.Height = this.Height / 8;

la condicional nos indica cuando tenemos que graficar una casilla blanca o negra

                                   if (isWhite)

                    {

                        box.Background = new SolidColorBrush(ColorOfWhitePiece);

                        isWhite = false;

                    }

                    else

                    {

                        box.Background = new SolidColorBrush(ColorOfBlackPiece);

                        isWhite = true;

                    }

        

Terminando el for de las columnas, lo que necesitamos es cambiar el color de nuestra bandera booleana que nos indica de qué color es la casilla.

Después de esto, solo basta agregar la fila de casillas a nuestra stack panel stkBoard

  if (isWhite)

                    isWhite = false;

                else

                    isWhite = true;

                this.stkBoard.Children.Add(rowBoxes);

aquí les dejo todo el codigo fuente del user control.

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.Windows;  
 using System.Windows.Controls;  
 using System.Windows.Data;  
 using System.Windows.Documents;  
 using System.Windows.Input;  
 using System.Windows.Media;  
 using System.Windows.Media.Imaging;  
 using System.Windows.Navigation;  
 using System.Windows.Shapes;  
 namespace WPFChessProject  
 {  
   /// <summary>  
   /// Lógica de interacción para ChessBoard.xaml  
   /// </summary>  
   public partial class ChessBoard : UserControl  
   {  
     public List<StackPanel> Boxs { get; set; }  
     public Color ColorOfWhitePiece { get; set; }  
     public Color ColorOfBlackPiece { get; set; }  
     public ChessBoard(Color pieceWhiteColor,Color pieceBlackColor,double width, double height)  
     {  
       InitializeComponent();  
       Boxs = new List<StackPanel>();  
       this.Width = width;  
       this.Height = height;  
       stkBoard.Orientation = Orientation.Vertical;  
       this.ColorOfWhitePiece = pieceWhiteColor;  
       this.ColorOfBlackPiece = pieceBlackColor;  
       RenderBoard();  
     }  
     public void RenderBoard()  
     {  
       StackPanel box;  
       bool isWhite = true;  
       for (int i = 0; i < 8; i++)  
       {  
         StackPanel rowBoxes = new StackPanel();  
         rowBoxes.Orientation = Orientation.Horizontal;  
         for (int j = 0; j < 8; j++)  
         {  
           box = new StackPanel();  
           box.Width = this.Width / 8;  
           box.Height = this.Height / 8;  
           if (isWhite)  
           {  
             box.Background = new SolidColorBrush(ColorOfWhitePiece);  
             isWhite = false;  
           }  
           else  
           {  
             box.Background = new SolidColorBrush(ColorOfBlackPiece);  
             isWhite = true;  
           }  
           rowBoxes.Children.Add(box);  
           Boxs.Add(box);  
         }  
         if (isWhite)  
           isWhite = false;  
         else  
           isWhite = true;  
         this.stkBoard.Children.Add(rowBoxes);  
       }  
     }  
   }  
 }  

3.- Consumir el Control de usuario.

ahora en nuestra aplicación principal del proyecto tendremos que instanciar nuestro tablero, les muestro el XAML de la aplicación principal.

 <Window x:Class="WPFChessProject.MainWindow"  
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
     Title="MainWindow" Height="350" Width="525">  
   <Grid x:Name="grdPrincipal">  
   </Grid>  
 </Window>  

Ahora veamos el codebehind:

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.Windows;  
 using System.Windows.Controls;  
 using System.Windows.Data;  
 using System.Windows.Documents;  
 using System.Windows.Input;  
 using System.Windows.Media;  
 using System.Windows.Media.Imaging;  
 using System.Windows.Navigation;  
 using System.Windows.Shapes;  
 namespace WPFChessProject  
 {  
   /// <summary>  
   /// Lógica de interacción para MainWindow.xaml  
   /// </summary>  
   public partial class MainWindow : Window  
   {  
     public MainWindow()  
     {  
       InitializeComponent();  
       ChessBoard chessBoard = new ChessBoard(Colors.Green, Colors.Black,400,400);  
       grdPrincipal.Children.Add(chessBoard);  
     }  
   }  
 }  

Básicamente consiste en crear una instancia de ChessBoard y agregarlo al gridPrincipal y listo.

4.- Ejecutar la aplicación.:

Y así lucirá nuestro tablero de ajedrez ;)

Que pasen buen día, buena vibra 

Graficando un tablero de ajedrez

Que tal, en esta ocasión vamos a trabajar en la graficacion de un simple tablero de ajedrez en c sharp.

1.- Primero que nada necesitamos crear un nuevo proyecto de tipo windows form


2.- Ahora en nuestra forma, agregamos un MenuStrip


3.- Implementación del código necesario para graficar un tablero de ajedrez.


        public void DibujarTableroDeAjedrez(Form forma)
        {
            bool blanco = true;
            int anchoCuadricula = 30;
            int x = 40, y = 40;
            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    if (blanco)
                    {
                        FxTools.GraficarCuadro(forma, Color.FromArgb(0, 255, 0), x, y, anchoCuadricula);
                        blanco = false;
                    }
                    else
                    {
                        FxTools.GraficarCuadro(forma, Color.FromArgb(0, 0, 0), x, y, anchoCuadricula);
                        blanco = true;
                    }
                    x +=31;
                }
                if (blanco)
                    blanco = false;
                else
                    blanco = true;
                x = 40;
                y += 31;
            }
        }

//-----------------------------------------------------------------------------------------------------------
este es el código necesario para graficar un tablero de ajedrez, como ven, tenemos de una bandera que nos servirá cuando pintar un cuadro de color blanco y cuando no, tenemos un ancho de cuadricula, que por defecto es 30 (por fines didácticos se estableció hardcode los valores de "anchoCuadricula", "x" y de "y".

Contamos con dos bucles que nos servirán para recorrer la cuadricula, la dimensión de un tablero de ajedrez es de 8 x 8, que nos da un total de 64 casillas.

en cada casilla se establecerá un color, ya sea blanco o negro, todo esto va a depender de la bandera "blanco", para obtener el color blanco, lo podemos obtener de varias formas, en esta ocasión se obtiene por medio del método estático  FromArgb de la clase Color


En el caso de graficar el color, para el color blanco se opta poner el color verde (0,255,0) y en el caso de las casillas oscuras, el color negro (0,0,0)


4.- creando la clase FxTools e implementando el metodo GraficarCuadro



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;


namespace EjemploBlog
{
    class FxTools
    {
        public static void GraficarCuadro(Form forma, Color color, int x, int y, int ancho)
        {


            SolidBrush solidBrush = new SolidBrush(color);
            Graphics g = forma.CreateGraphics();
            g.FillRectangle(solidBrush, x, y, ancho, ancho);
        }
    }
}


5.- accesando al metodo DibujarTableroDeAjedrez(Form forma)


Ya para terminar con este ejemplo, vamos a mandarlo llamar de nuestro MenuStrip:



        private void tableroDeAjedrezToolStripMenuItem_Click(object sender, EventArgs e)
        {
            DibujarTableroDeAjedrez(this);
        }



6.- el programa en tiempo de ejecución