Example #1
0
        /// <summary>
        /// Load an opening book into memory.
        /// </summary>
        /// <param name="player">
        /// The player to play.
        /// </param>
        public static void LoadOpeningBook(Player player)
        {
            XmlDocument xmldoc = new XmlDocument();

            // xmldoc.Load(@"d:\ob6.xml");
            xmldoc.Load(@"d:\OpeningBook.xml");

            // xmldoc.Load(@"d:\OpeningBook_16plys_146027.xml");
            int intScanMove = ScanPly(player, (XmlElement)xmldoc.SelectSingleNode("OpeningBook"));
            if (intScanMove != 0)
            {
                RecordHash(Board.HashCodeA, Board.HashCodeB, (byte)(intScanMove >> 8 & 0xff), (byte)(intScanMove & 0xff), Move.MoveNames.Standard, player.Colour);
            }
        }
Example #2
0
 public static object RenderPiece(SizeF SquareSize, Player.PlayerColourNames player, Piece.PieceNames name)
 {
     var size = SquareSize;
     var scale_w = size.Width / (float) PieceRenderer.Size.Width;
     var scale_h = size.Height / (float) PieceRenderer.Size.Height;
     UIGraphics.BeginImageContextWithOptions (size, false, 0);
     try {
         using (var graphics = UIGraphics.GetCurrentContext ()) {
             graphics.ScaleCTM (scale_w, scale_h);
             PieceRenderer.Render (graphics, player, name);
             return UIGraphics.GetImageFromCurrentImageContext ();
         }
     } finally {
         UIGraphics.EndImageContext ();
     }
 }
Example #3
0
		public static void Render (RenderTarget c, Player.PlayerColourNames player, Piece.PieceNames name)
		{
			target = c;

			var color = player == Player.PlayerColourNames.White ? White : Black;
			var main = color;
			var alternate = player != Player.PlayerColourNames.White ? White : Black;


			var white = White;
			var black = Black;

			switch (name) {
			case Piece.PieceNames.Bishop:
				RenderBishop (c, main, alternate, white, black);
				break;
			case Piece.PieceNames.King:
				if (player == Player.PlayerColourNames.White)
					RenderWhiteKing (c, main, alternate, white, black);
				else
					RenderBlackKing (c, main, alternate, white, black);
				break;
			case Piece.PieceNames.Knight:
				RenderKnight (c, player, main, alternate, white, black);
				break;
			case Piece.PieceNames.Pawn:
				RenderPawn (c, main, alternate, white, black);
				break;
			case Piece.PieceNames.Queen:
				if (player == Player.PlayerColourNames.White)
					RenderWhiteQueen (c, white, black);
				else
					RenderBlackQueen (c);
				break;
			case Piece.PieceNames.Rook:
				if (player == Player.PlayerColourNames.White)
					RenderWhiteRook (c, white, black);
				else
					RenderBlackRook (c);
				break;
			}
		}
Example #4
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Piece"/> class.
        /// </summary>
        /// <param name="name">
        /// The piece name e.g. bishop, queen.
        /// </param>
        /// <param name="player">
        /// The player that owns the piece.
        /// </param>
        /// <param name="file">
        /// Board file that the piece starts on.
        /// </param>
        /// <param name="rank">
        /// Board rank that the piece starts on.
        /// </param>
        /// <param name="identifier">
        /// Piece identifier.
        /// </param>
        public Piece(PieceNames name, Player player, int file, int rank, PieceIdentifierCodes identifier)
        {
            this.LastMoveTurnNo = -1;
            this.IsInPlay = true;
            Square square = Board.GetSquare(file, rank);

            this.Player = player;
            this.StartLocation = this.Square = square;
            square.Piece = this;
            this.IdentifierCode = identifier;

            switch (name)
            {
                case PieceNames.Pawn:
                    this.Top = new PiecePawn(this);
                    break;

                case PieceNames.Bishop:
                    this.Top = new PieceBishop(this);
                    break;

                case PieceNames.Knight:
                    this.Top = new PieceKnight(this);
                    break;

                case PieceNames.Rook:
                    this.Top = new PieceRook(this);
                    break;

                case PieceNames.Queen:
                    this.Top = new PieceQueen(this);
                    break;

                case PieceNames.King:
                    this.Top = new PieceKing(this);
                    break;
            }
        }
Example #5
0
		public static void RenderKnight (RenderTarget c, Player.PlayerColourNames player, Color main, Color alternate, Color white, Color black)
		{	
			SetFillColor (main);
			SetStrokeColor (black);
			MoveTo (22f, 10f);
			AddCurveToPoint (32.5f, 11f, 38.5f, 18f, 38f, 39f);
			AddLineToPoint (15f, 39f);
			AddCurveToPoint (15f, 30f, 25f, 32.5f, 23f, 18f);
			FillAndStrokePath ();

			SetFillColor (main);
			SetStrokeColor (black);
			MoveTo (24f, 18f);
			AddCurveToPoint (24.38f, 20.91f, 18.45f, 25.37f, 16f, 27f);
			AddCurveToPoint (13f, 29f, 13.18f, 31.34f, 11f, 31f);
			AddCurveToPoint (9.958f, 30.06f, 12.41f, 27.96f, 11f, 28f);
			AddCurveToPoint (10f, 28f, 11.19f, 29.23f, 10f, 30f);
			AddCurveToPoint (9f, 30f, 5.997f, 31f, 6f, 26f);
			AddCurveToPoint (6f, 24f, 12f, 14f, 12f, 14f);
			AddCurveToPoint (12f, 14f, 13.89f, 12.1f, 14f, 10.5f);
			AddCurveToPoint (13.27f, 9.506f, 13.5f, 8.5f, 13.5f, 7.5f);
			AddCurveToPoint (14.5f, 6.5f, 16.5f, 10f, 16.5f, 10f);
			AddLineToPoint (18.5f, 10f);
			AddCurveToPoint (18.5f, 10f, 19.28f, 8.008f, 21f, 7f);
			AddCurveToPoint (22f, 7f, 22f, 10f, 22f, 10f);
			FillAndStrokePath ();

			SetFillColor (main);
			SetStrokeColor (alternate);
			MoveTo (9.5f, 25.5f);
			AddCurveToPoint (9.5f, 25.77614f, 9.276142f, 26f, 9f, 26f);
			AddCurveToPoint (8.723858f, 26f, 8.5f, 25.77614f, 8.5f, 25.5f);
			AddCurveToPoint (8.5f, 25.22386f, 8.723858f, 25f, 9f, 25f);
			AddCurveToPoint (9.276142f, 25f, 9.5f, 25.22386f, 9.5f, 25.5f);
			ClosePath ();
			MoveTo (9.5f, 25.5f);
			FillAndStrokePath ();

			SetMatrix (0.866f, 0.5f, -0.5f, 0.866f, 9.693f, -5.173f);
			SetFillColor (black);
			SetStrokeColor (alternate);
			MoveTo (15f, 15.5f);
			AddCurveToPoint (15f, 16.32843f, 14.77614f, 17f, 14.5f, 17f);
			AddCurveToPoint (14.22386f, 17f, 14f, 16.32843f, 14f, 15.5f);
			AddCurveToPoint (14f, 14.67157f, 14.22386f, 14f, 14.5f, 14f);
			AddCurveToPoint (14.77614f, 14f, 15f, 14.67157f, 15f, 15.5f);
			ClosePath ();
			MoveTo (15f, 15.5f);
			FillAndStrokePath ();

			if (player == Player.PlayerColourNames.Black) {
				SetFillColor (white);
				MoveTo (24.55f, 10.4f);
				AddLineToPoint (24.1f, 11.85f);
				AddLineToPoint (24.6f, 12f);
				AddCurveToPoint (27.75f, 13f, 30.25f, 14.49f, 32.5f, 18.75f);
				AddCurveToPoint (34.75f, 23.01f, 35.75f, 29.06f, 35.25f, 39f);
				AddLineToPoint (35.2f, 39.5f);
				AddLineToPoint (37.45f, 39.5f);
				AddLineToPoint (37.5f, 39f);
				AddCurveToPoint (38f, 28.94f, 36.62f, 22.15f, 34.25f, 17.66f);
				AddCurveToPoint (31.88f, 13.17f, 28.46f, 11.02f, 25.06f, 10.5f);
				AddLineToPoint (24.55f, 10.4f);
				ClosePath ();
				MoveTo (24.55f, 10.4f);
				FillPath ();
			}
		}
Example #6
0
        /// <summary>
        /// The line threatened by.
        /// </summary>
        /// <param name="player">
        /// The player.
        /// </param>
        /// <param name="squares">
        /// The squares.
        /// </param>
        /// <param name="squareStart">
        /// The square start.
        /// </param>
        /// <param name="offset">
        /// The offset.
        /// </param>
        public static void LineThreatenedBy(Player player, Squares squares, Square squareStart, int offset)
        {
            int intOrdinal = squareStart.Ordinal;
            Square square;

            intOrdinal += offset;
            while ((square = GetSquare(intOrdinal)) != null)
            {
                if (square.Piece == null)
                {
                    squares.Add(square);
                }
                else if (square.Piece.Player.Colour != player.Colour && square.Piece.IsCapturable)
                {
                    squares.Add(square);
                    break;
                }
                else
                {
                    break;
                }

                intOrdinal += offset;
            }
        }
Example #7
0
        /// <summary>
        /// The append piece path.
        /// </summary>
        /// <param name="moves">
        /// The moves.
        /// </param>
        /// <param name="piece">
        /// The piece.
        /// </param>
        /// <param name="player">
        /// The player.
        /// </param>
        /// <param name="offset">
        /// The offset.
        /// </param>
        /// <param name="movesType">
        /// The moves type.
        /// </param>
        public static void AppendPiecePath(
            Moves moves, Piece piece, Player player, int offset, Moves.MoveListNames movesType)
        {
            int intOrdinal = piece.Square.Ordinal;
            Square square;

            intOrdinal += offset;
            while ((square = GetSquare(intOrdinal)) != null)
            {
                if (square.Piece == null)
                {
                    if (movesType == Moves.MoveListNames.All)
                    {
                        moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, square, null, 0, 0);
                    }
                }
                else if (square.Piece.Player.Colour != player.Colour && square.Piece.IsCapturable)
                {
                    moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, square, square.Piece, 0, 0);
                    break;
                }
                else
                {
                    break;
                }

                intOrdinal += offset;
            }
        }
Example #8
0
        /// <summary>
        /// Gets the cheapest piece defending this square.
        /// </summary>
        /// <param name="player">
        /// Defending player who pieces should be listed.
        /// </param>
        /// <returns>
        /// List of pieces.
        /// </returns>
        public Piece CheapestPieceDefendingThisSquare(Player player)
        {
            Piece piece;
            Piece pieceBest = null;

            // Pawn
            piece = Board.GetPiece(this.Ordinal - player.PawnAttackLeftOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - player.PawnAttackRightOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            // Knight
            piece = Board.GetPiece(this.Ordinal + 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal + 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal + 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal + 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            // Bishop & Queen
            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 15);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Bishop:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 17);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Bishop:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -15);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Bishop:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -17);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Bishop:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            // Rook & Queen
            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 1);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Rook:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -1);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Rook:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 16);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Rook:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -16);
            if (piece != null)
            {
                switch (piece.Name)
                {
                    case Piece.PieceNames.Rook:
                        return piece;
                    case Piece.PieceNames.Queen:
                        pieceBest = piece;
                        break;
                }
            }

            if (pieceBest != null)
            {
                return pieceBest; // This means a queen was found, but not a Bishop or Rook
            }

            // King!
            piece = Board.GetPiece(this.Ordinal + 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal + 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal + 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal - 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            piece = Board.GetPiece(this.Ordinal + 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece;
            }

            return null;
        }
Example #9
0
        /// <summary>
        /// Returns a list of player's pieces attacking this square.
        /// </summary>
        /// <param name="player">
        /// Player who owns the attacking pieces that you want to find.
        /// </param>
        /// <returns>
        /// List of pieces.
        /// </returns>
        public Pieces PlayersPiecesAttackingThisSquare(Player player)
        {
            Piece piece;
            Pieces pieces = new Pieces();

            // Pawn
            piece = Board.GetPiece(this.Ordinal - player.PawnAttackLeftOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - player.PawnAttackRightOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            // Knight
            piece = Board.GetPiece(this.Ordinal + 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal + 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal + 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal + 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            // Bishop & Queen
            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 15)) != null)
            {
                pieces.Add(piece);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 17)) != null)
            {
                pieces.Add(piece);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -15)) != null)
            {
                pieces.Add(piece);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -17)) != null)
            {
                pieces.Add(piece);
            }

            // Rook & Queen
            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 1)) != null)
            {
                pieces.Add(piece);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -1)) != null)
            {
                pieces.Add(piece);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 16)) != null)
            {
                pieces.Add(piece);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -16)) != null)
            {
                pieces.Add(piece);
            }

            // King!
            piece = Board.GetPiece(this.Ordinal + 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal + 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal + 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal - 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            piece = Board.GetPiece(this.Ordinal + 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                pieces.Add(piece);
            }

            return pieces;
        }
Example #10
0
        /// <summary>
        /// Record a hash new hash entry in the hash table.
        /// </summary>
        /// <param name="hashCodeA">
        /// Hash Code for Board position A
        /// </param>
        /// <param name="hashCodeB">
        /// Hash Code for Board position B
        /// </param>
        /// <param name="from">
        /// From square ordinal.
        /// </param>
        /// <param name="to">
        /// To square ordinal.
        /// </param>
        /// <param name="moveName">
        /// The move name.
        /// </param>
        /// <param name="colour">
        /// The player colour.
        /// </param>
        private static unsafe void RecordHash(ulong hashCodeA, ulong hashCodeB, byte from, byte to, Move.MoveNames moveName, Player.PlayerColourNames colour)
        {
            if (colour == Player.PlayerColourNames.Black)
            {
                hashCodeA |= 0x1;
                hashCodeB |= 0x1;
            }
            else
            {
                hashCodeA &= 0xFFFFFFFFFFFFFFFE;
                hashCodeB &= 0xFFFFFFFFFFFFFFFE;
            }

            fixed (HashEntry* phashBase = &HashTableEntries[0])
            {
                HashEntry* phashEntry = phashBase;
                phashEntry += (uint)(hashCodeA % HashTableSize);

                phashEntry->HashCodeA = hashCodeA;
                phashEntry->HashCodeB = hashCodeB;
                phashEntry->From = from;
                phashEntry->To = to;
                phashEntry->MoveName = moveName;
            }
        }
Example #11
0
        /// <summary>
        /// The probe opening book (hash table) for best move for the specied board position (hash code).
        /// </summary>
        /// <param name="hashCodeA">
        /// The hash code for board position A.
        /// </param>
        /// <param name="hashCodeB">
        /// The hash code for board position B.
        /// </param>
        /// <param name="colour">
        /// The player colour.
        /// </param>
        /// <returns>
        /// The best move in the opening book (hash table) or null if there is no opening book entry for the specified board position.
        /// </returns>
        private static unsafe Move ProbeForBestMove(ulong hashCodeA, ulong hashCodeB, Player.PlayerColourNames colour)
        {
            if (colour == Player.PlayerColourNames.Black)
            {
                hashCodeA |= 0x1;
                hashCodeB |= 0x1;
            }
            else
            {
                hashCodeA &= 0xFFFFFFFFFFFFFFFE;
                hashCodeB &= 0xFFFFFFFFFFFFFFFE;
            }

            fixed (HashEntry* phashBase = &HashTableEntries[0])
            {
                HashEntry* phashEntry = phashBase;
                phashEntry += (uint)(hashCodeA % HashTableSize);

                if (phashEntry->HashCodeA == hashCodeA && phashEntry->HashCodeB == hashCodeB)
                {
                    return new Move(0, 0, phashEntry->MoveName, Board.GetPiece(phashEntry->From), Board.GetSquare(phashEntry->From), Board.GetSquare(phashEntry->To), null, 0, 0);
                }
            }

            return NotFoundInHashTable;
        }
Example #12
0
 /// <summary>
 /// The search for best move in opening book.
 /// </summary>
 /// <param name="boardHashCodeA">
 /// The board hash code a.
 /// </param>
 /// <param name="boardHashCodeB">
 /// The board hash code b.
 /// </param>
 /// <param name="colour">
 /// The colour.
 /// </param>
 /// <returns>
 /// The best move from the opening book.
 /// </returns>
 public static Move SearchForGoodMove(ulong boardHashCodeA, ulong boardHashCodeB, Player.PlayerColourNames colour)
 {
     return ProbeForBestMove(boardHashCodeA, boardHashCodeB, colour);
 }
Example #13
0
        static public bool DoesPieceAttackSquare(Square square, Player player, out Piece attackingPiece)
        {
            attackingPiece = null;
            Piece piece;
            piece = Board.GetPiece(square.Ordinal - player.PawnAttackLeftOffset);
            if (piece != null && piece.Name == _pieceType && piece.Player.Colour == player.Colour)
            {
                attackingPiece = piece;
                return true;
            }

            piece = Board.GetPiece(square.Ordinal - player.PawnAttackRightOffset);
            if (piece != null && piece.Name == _pieceType && piece.Player.Colour == player.Colour)
            {
                attackingPiece = piece;
                return true;
            }
            return false;
        }
Example #14
0
 public static bool DoesPieceAttackSquare(Square square, Player player, out Piece attackingPiece)
 {
     return Piece.DoesLeaperPieceTypeAttackSquare(square, player, _pieceType, moveVectors, out attackingPiece);
 }
Example #15
0
 public static bool CanPlayerPieceNameAttackSquare(Square square, Player player, Piece.PieceNames PieceName, out Piece attackingPiece)
 {
     attackingPiece = null;
     switch (PieceName)
     {
         case PieceNames.Bishop:
             return PieceBishop.DoesPieceAttackSquare(square, player,out attackingPiece);
         case PieceNames.King:
             return PieceKing.DoesPieceAttackSquare(square, player, out attackingPiece);
         case PieceNames.Knight:
             return PieceKnight.DoesPieceAttackSquare(square, player, out attackingPiece);
         case PieceNames.Pawn:
             return PiecePawn.DoesPieceAttackSquare(square, player, out attackingPiece);
         case PieceNames.Queen:
             return PieceQueen.DoesPieceAttackSquare(square, player, out attackingPiece);
         case PieceNames.Rook:
             return PieceRook.DoesPieceAttackSquare(square, player, out attackingPiece);
     }
     return false;
 }
Example #16
0
        /// <summary>
        /// Load opening book (hash table )
        /// </summary>
        /// <param name="player">
        /// The player.
        /// </param>
        /// <param name="xmlnodeParent">
        /// The xmlnode parent.
        /// </param>
        /// <returns>
        /// The move score.
        /// </returns>
        private static int ScanPly(Player player, XmlElement xmlnodeParent)
        {
            int intReturnScore = 0;
            int intReturnMove = 0;

            foreach (XmlElement xmlnodeMove in xmlnodeParent.ChildNodes)
            {
                Move.MoveNames movename = xmlnodeMove.GetAttribute("N") == null ? Move.MoveNames.Standard : Move.MoveNameFromString(xmlnodeMove.GetAttribute("N"));
                Square from = Board.GetSquare(xmlnodeMove.GetAttribute("F"));
                Square to = Board.GetSquare(xmlnodeMove.GetAttribute("T"));
                Piece piece = from.Piece;

                int intScore = Convert.ToInt32(xmlnodeMove.GetAttribute(player.Colour == Player.PlayerColourNames.White ? "W" : "B"));
                if (intScore > intReturnScore)
                {
                    intReturnScore = intScore;
                    intReturnMove = from.Ordinal << 8 | to.Ordinal;
                }

                Move moveUndo = piece.Move(movename, to);

                int intScanMove = ScanPly(player.OpposingPlayer, xmlnodeMove);
                if (intScanMove != 0)
                {
                    RecordHash(Board.HashCodeA, Board.HashCodeB, (byte)(intScanMove >> 8 & 0xff), (byte)(intScanMove & 0xff), movename, player.OpposingPlayer.Colour);
                }

                Move.Undo(moveUndo);
            }

            return intReturnMove;
        }
Example #17
0
 public static bool DoesLeaperPieceTypeAttackSquare(Square square, Player player, PieceNames pieceName, int[] vector, out Piece attackingPiece)
 {
     Piece piece;
     attackingPiece = null;
     for (int i = 0; i < vector.Length; i++)
     {
         piece = Board.GetPiece(square.Ordinal + vector[i]);
         if (piece != null && piece.Name == pieceName && piece.Player.Colour == player.Colour)
         {
             attackingPiece = piece;
             return true;
         }
     }
     return false;
 }
Example #18
0
 /// <summary>
 /// Appends a list of moves of all the pieces that are attacking this square.
 /// </summary>
 /// <param name="moves">
 /// Moves of pieces that are attacking this square.
 /// </param>
 /// <param name="player">
 /// Player whose turn it is
 /// </param>
 public void AttackersMoveList(Moves moves, Player player)
 {
     foreach (Piece p in player.Pieces)
     {
         if (p.CanAttackSquare(this))
             moves.Add(0, 0, Move.MoveNames.Standard, p, p.Square, this, this.Piece, 0, 0);
     }
 }
Example #19
0
        /// <summary>
        /// Determines whether the specified player can attack this square.
        /// </summary>
        /// <param name="player">
        /// The player being tested.
        /// </param>
        /// <returns>
        /// True if player can move a piece to this square.
        /// </returns>
        public bool PlayerCanAttackSquare(Player player)
        {
            Piece piece;

            // Pawn
            piece = Board.GetPiece(this.Ordinal - player.PawnAttackLeftOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - player.PawnAttackRightOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            // Knight
            piece = Board.GetPiece(this.Ordinal + 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal + 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal + 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal + 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            // Bishop & Queen
            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 15) != null)
            {
                return true;
            }

            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 17) != null)
            {
                return true;
            }

            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -15) != null)
            {
                return true;
            }

            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -17) != null)
            {
                return true;
            }

            // Rook & Queen
            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 1) != null)
            {
                return true;
            }

            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -1) != null)
            {
                return true;
            }

            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 16) != null)
            {
                return true;
            }

            if (Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -16) != null)
            {
                return true;
            }

            // King!
            piece = Board.GetPiece(this.Ordinal + 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal + 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal + 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal - 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            piece = Board.GetPiece(this.Ordinal + 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return true;
            }

            return false;
        }
Example #20
0
        /// <summary>
        /// Returns a list of player's pieces attacking this square.
        /// </summary>
        /// <param name="player">
        /// Player who owns the attacking pieces that you want to find.
        /// </param>
        /// <returns>
        /// List of pieces.
        /// </returns>
        public Pieces PlayersPiecesAttackingThisSquare(Player player)
        {
            Pieces pieces = new Pieces();

            foreach (Piece p in player.Pieces)
            {
                if (p.CanAttackSquare(this))
                    pieces.Add(p);
            }

            return pieces;
        }
Example #21
0
        /// <summary>
        /// Appends a list of moves of all the pieces that are attacking this square.
        /// </summary>
        /// <param name="moves">
        /// Moves of pieces that are attacking this square.
        /// </param>
        /// <param name="player">
        /// Player whose turn it is
        /// </param>
        public void AttackersMoveList(Moves moves, Player player)
        {
            Piece piece;

            // Pawn
            piece = Board.GetPiece(this.Ordinal - player.PawnAttackLeftOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                moves.Add(
                    0,
                    0,
                    Move.MoveNames.Standard,
                    Board.GetPiece(this.Ordinal - player.PawnAttackLeftOffset),
                    Board.GetSquare(this.Ordinal - player.PawnAttackLeftOffset),
                    this,
                    this.Piece,
                    0,
                    0);
            }

            piece = Board.GetPiece(this.Ordinal - player.PawnAttackRightOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                moves.Add(
                    0,
                    0,
                    Move.MoveNames.Standard,
                    Board.GetPiece(this.Ordinal - player.PawnAttackRightOffset),
                    Board.GetSquare(this.Ordinal - player.PawnAttackRightOffset),
                    this,
                    this.Piece,
                    0,
                    0);
            }

            // Knight
            piece = Board.GetPiece(this.Ordinal + 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal + 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal + 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal + 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            // Bishop & Queen
            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 15)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 17)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -15)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -17)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            // Rook & Queen
            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 1)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -1)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 16)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            if ((piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -16)) != null)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            // King!
            piece = Board.GetPiece(this.Ordinal + 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal + 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal + 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal - 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }

            piece = Board.GetPiece(this.Ordinal + 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                moves.Add(0, 0, Move.MoveNames.Standard, piece, piece.Square, this, this.Piece, 0, 0);
            }
        }
Example #22
0
        /// <summary>
        /// Determines whether the specified player can attack this square.
        /// </summary>
        /// <param name="player">
        /// The player being tested. (
        /// </param>
        /// <returns>
        /// True if player can move a piece to this square.
        /// </returns>
        public bool PlayerCanAttackSquare(Player player)
        {

            foreach (Piece.PieceNames pieceName in player.PieceTypes())
            {
                if (Piece.CanPlayerPieceNameAttackSquare(this, player, pieceName))
                    return true;
            }

            return false;
        }
Example #23
0
        /// <summary>
        /// Calculates defense points for the player on this square. Returns the value of the cheapest piece defending the square.
        /// If no pieces are defending, then returns a high value (15,000).
        /// </summary>
        /// <param name="player">
        /// The defending player.
        /// </param>
        /// <returns>
        /// Defense points.
        /// </returns>
        public int DefencePointsForPlayer(Player player)
        {
            Piece piece;
            int value = 0;
            int bestValue = 0;

            // Pawn
            piece = Board.GetPiece(this.Ordinal - player.PawnAttackLeftOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - player.PawnAttackRightOffset);
            if (piece != null && piece.Name == Piece.PieceNames.Pawn && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            // Knight
            piece = Board.GetPiece(this.Ordinal + 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal + 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 33);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 18);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal + 14);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal + 31);
            if (piece != null && piece.Name == Piece.PieceNames.Knight && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            // Bishop & Queen
            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 15);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, 17);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -15);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Bishop, this, -17);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            // Rook & Queen
            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 1);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -1);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, 16);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            piece = Board.LinesFirstPiece(player.Colour, Piece.PieceNames.Rook, this, -16);
            value = piece != null ? piece.Value : 0;
            if (value > 0 && value < 9000)
            {
                return value;
            }

            if (value > 0)
            {
                bestValue = value;
            }

            if (bestValue > 0)
            {
                return bestValue; // This means a queen was found, but not a Bishop or Rook
            }

            // King!
            piece = Board.GetPiece(this.Ordinal + 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal + 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal + 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 16);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 17);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal - 1);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            piece = Board.GetPiece(this.Ordinal + 15);
            if (piece != null && piece.Name == Piece.PieceNames.King && piece.Player.Colour == player.Colour)
            {
                return piece.Value;
            }

            return 15000;
        }
Example #24
0
        /// <summary>
        /// Calculates defense points for the player on this square. Returns the value of the cheapest piece defending the square.
        /// If no pieces are defending, then returns a high value (15,000).
        /// </summary>
        /// <param name="player">
        /// The defending player.
        /// </param>
        /// <returns>
        /// Defense points.
        /// </returns>
        public int DefencePointsForPlayer(Player player)
        {

            Piece piece;

            foreach (Piece.PieceNames pieceName in player.PieceTypes())
            {
                if (Piece.CanPlayerPieceNameAttackSquare(this, player, pieceName, out piece))
                    return piece.Value;
            }
            return 15000;
        }
Example #25
0
        /// <summary>
        /// The lines first piece.
        /// </summary>
        /// <param name="colour">
        /// The colour.
        /// </param>
        /// <param name="pieceName">
        /// The piece name.
        /// </param>
        /// <param name="squareStart">
        /// The square start.
        /// </param>
        /// <param name="offset">
        /// The offset.
        /// </param>
        /// <returns>
        /// The first piece on the line, or null.
        /// </returns>
        public static Piece LinesFirstPiece(
            Player.PlayerColourNames colour, Piece.PieceNames pieceName, Square squareStart, int offset)
        {
            int intOrdinal = squareStart.Ordinal;
            Square square;

            intOrdinal += offset;
            while ((square = GetSquare(intOrdinal)) != null)
            {
                if (square.Piece == null)
                {
                }
                else if (square.Piece.Player.Colour != colour)
                {
                    return null;
                }
                else if (square.Piece.Name == pieceName || square.Piece.Name == Piece.PieceNames.Queen)
                {
                    return square.Piece;
                }
                else
                {
                    return null;
                }

                intOrdinal += offset;
            }

            return null;
        }
Example #26
0
        /// <summary>
        /// Gets the cheapest piece defending this square.
        /// </summary>
        /// <param name="player">
        /// Defending player who pieces should be listed.
        /// </param>
        /// <returns>
        /// List of pieces.
        /// </returns>
        public Piece CheapestPieceDefendingThisSquare(Player player)
        {
            Piece piece;

            foreach (Piece.PieceNames pieceName in player.PieceTypes())
            {
                if (Piece.CanPlayerPieceNameAttackSquare(this, player, pieceName, out piece))
                    return piece;
            }
            return null;
        }
Example #27
0
        /// <summary>
        /// Calculates a positional penalty score for a single open line to a square (usually the king square), in a specified direction.
        /// </summary>
        /// <param name="colour">
        /// The player's colour.
        /// </param>
        /// <param name="squareStart">
        /// The square piece (king) is on.
        /// </param>
        /// <param name="directionOffset">
        /// The direction offset.
        /// </param>
        /// <returns>
        /// The open line penalty.
        /// </returns>
        public static int OpenLinePenalty(Player.PlayerColourNames colour, Square squareStart, int directionOffset)
        {
            int intOrdinal = squareStart.Ordinal;
            int intSquareCount = 0;
            int intPenalty = 0;
            Square square;

            intOrdinal += directionOffset;

            while (intSquareCount <= 2
                   &&
                   ((square = GetSquare(intOrdinal)) != null
                    &&
                    (square.Piece == null
                     || (square.Piece.Name != Piece.PieceNames.Pawn && square.Piece.Name != Piece.PieceNames.Rook)
                     || square.Piece.Player.Colour != colour)))
            {
                intPenalty += 75;
                intSquareCount++;
                intOrdinal += directionOffset;
            }

            return intPenalty;
        }
Example #28
0
 /// <summary>
 ///  static method to determine if a square is attacked by this piece
 /// </summary>
 /// <param name="square"></param>
 /// <param name="player"></param>
 /// <returns></returns>
 /// 
 static public bool DoesPieceAttackSquare(Square square, Player player)
 {
     return Piece.DoesLeaperPieceTypeAttackSquare(square, player, _pieceType, moveVectors);
 }