public static bool MovePiece(ChessBoard board, byte sourceIndex, byte destinationIndex) { ChessPiece piece = board.pieces[sourceIndex]; //Do the actual move ChessEngine.MoveContent(board, sourceIndex, destinationIndex, ChessPieceType.Queen); PieceValidMoves.GenerateValidMoves(board); //If there is a check in place and still check if (piece.PieceColor == ChessPieceColor.White) { if (board.whiteInCheck) { //Invalid Move -> undo last move ChessEngine.MoveContent(board, destinationIndex, sourceIndex, ChessPieceType.Queen); PieceValidMoves.GenerateValidMoves(board); return false; } } else if (board.blackInCheck) { //Invalid Move -> undo last move ChessEngine.MoveContent(board, destinationIndex, sourceIndex, ChessPieceType.Queen); PieceValidMoves.GenerateValidMoves(board); return false; } return true; }
/// <summary> /// The constructor. /// </summary> /// <param name="board">The board in which the square is located.</param> /// <param name="location">The location of the square.</param> /// <param name="color">The color of the square.</param> /// <param name="piece">The Chess piece that is on the square.</param> public Square(ChessBoard board, Location location, ChessColor color, ChessPiece piece = null) { this.Board = board; this.Location = location; this.Color = color; this.Piece = piece; }
/// <summary> /// Evaluates a board. The number of point is greater than 0 if white is in advantage, less than 0 if black is. /// </summary> /// <param name="pBoard"> Board.</param> /// <param name="piPiecesCount"> Number of each pieces</param> /// <param name="posInfo"> Information about pieces position</param> /// <param name="iWhiteKingPos"> Position of the white king</param> /// <param name="iBlackKingPos"> Position of the black king</param> /// <param name="bWhiteCastle"> White has castled</param> /// <param name="bBlackCastle"> Black has castled</param> /// <param name="iMoveCountDelta"> Number of possible white move - Number of possible black move</param> /// <returns> /// Points /// </returns> public virtual int Points(ChessBoard.PieceE[] pBoard, int[] piPiecesCount, ChessBoard.PosInfoS posInfo, int iWhiteKingPos, int iBlackKingPos, bool bWhiteCastle, bool bBlackCastle, int iMoveCountDelta) { int iRetVal = 0; for (int iIndex = 0; iIndex < piPiecesCount.Length; iIndex++) { iRetVal += s_piPiecePoint[iIndex] * piPiecesCount[iIndex]; } if (pBoard[12] == ChessBoard.PieceE.Pawn) { iRetVal -= 4; } if (pBoard[52] == (ChessBoard.PieceE.Pawn | ChessBoard.PieceE.Black)) { iRetVal += 4; } if (bWhiteCastle) { iRetVal += 10; } if (bBlackCastle) { iRetVal -= 10; } iRetVal += iMoveCountDelta; iRetVal += posInfo.m_iAttackedPieces * 2; //iRetVal += posInfo.m_iAttackedPos + posInfo.m_iAttackedPieces * 2 + posInfo.m_iPiecesDefending * 2; return(iRetVal); }
public ChessBoard(ChessBoard board) { Score = board.Score; EndGamePhase = board.EndGamePhase; WhoseMove = board.WhoseMove; MoveCount = board.MoveCount; FiftyMove = board.FiftyMove; RepeatedMove = board.RepeatedMove; blackCastled = board.blackCastled; blackInCheck = board.blackInCheck; blackInMate = board.blackInMate; whiteCastled = board.whiteCastled; whiteInCheck = board.whiteInCheck; whiteInMate = board.whiteInMate; staleMate = board.staleMate; EnPassantColor = board.EnPassantColor; EnPassantPosition = board.EnPassantPosition; InsufficientMaterial = board.InsufficientMaterial; LastMove = new MoveContent(board.LastMove); pieces = new ChessPiece[64]; for (byte x = 0; x < 64; ++x) { if (board.pieces[x] != null) { pieces[x] = new ChessPiece(board.pieces[x]); } } }
public void SearchEngine() { var board = new ChessBoard(); ChessBoard.MovePosS bestMove; int iPremCount; int iCacheHit; int iMaxDepth; board.FindBestMove( new SearchEngine.SearchMode( new BoardEvaluationUtil().BoardEvaluators[0], new BoardEvaluationUtil().BoardEvaluators[0], SrcChess2.SearchEngine.SearchMode.OptionE.UseAlphaBeta, SrcChess2.SearchEngine.SearchMode.ThreadingModeE.DifferentThreadForSearch, 2, 15, SrcChess2.SearchEngine.SearchMode.RandomModeE.Off ), ChessBoard.PlayerColorE.Black, out bestMove, out iPremCount, out iCacheHit, out iMaxDepth); Console.WriteLine(bestMove.StartPos + @" " + bestMove.EndPos); }
static void Main(string[] args) { Board = new ChessBoard(); Board.GameEnded += (b, w) => { Winner = w; }; while (!Board.GameOver) { Draw(); Console.SetCursorPosition(40, 22); Console.Write("From: "); string from = Console.ReadLine(); Console.SetCursorPosition(40, 23); Console.Write("To: "); string to = Console.ReadLine(); Console.SetCursorPosition(40, 21); try { if (!Board[from].To(Board[to])) { Console.Write("Invalid move."); Console.ReadLine(); } } catch { Console.Write("Invalid move."); Console.ReadLine(); } } Draw(); Console.SetCursorPosition(40, 22); Console.Write("Game Over: "); Console.Write((Winner == ChessWinner.StaleMate ? "Stalemate" : Winner.ToString() + " won") + "!"); Console.ReadLine(); }
protected override Int32 Evaluate(ChessBoard myBoard, ChessPiece turn, Int16 depth) { IncrementSearchCount(); var materialValue = (turn == ChessPiece.White ? 1 : -1) * myBoard.GetMaterialValue(this.ChessPieceRelativeValues, depth); var positionalValue = (turn == ChessPiece.White ? 1 : -1) * myBoard.GetPositionalValue(); return MaterialFactor * materialValue + PositionalFactor * positionalValue; }
public void Stage(ChessBoard b) { b.Set("a2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a5", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("b4", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); }
public void Stage(ChessBoard b) { b.Set("d5", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Queen }); b.Set("g7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("h7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); }
public void Stage(ChessBoard b) { b.Set("a7", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h7", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook }); b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.King }); b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King }); }
public void Stage(ChessBoard b) { b.Set("a1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("c1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("d1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("e1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("f1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("g1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("c2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("d2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("e2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("f2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("g2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("c3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("d3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("e3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("f3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("g3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h3", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("c4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("d4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("e4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("f4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("g4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("b7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("c7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("d7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("e7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("f7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("g7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("h7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("a8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook }); b.Set("b8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Knight }); b.Set("c8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Bishop }); b.Set("e8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.King }); b.Set("d8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Queen }); b.Set("f8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Bishop }); b.Set("g8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Knight }); b.Set("h8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook }); }
public void Stage(ChessBoard b) { b.Set("d4", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Bishop }); b.Set("e5", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a1", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook }); b.Set("h8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook }); }
public void TurnColor() { var board = new ChessBoard(); Console.WriteLine(board.CurrentMoveColor); board.DoMove(new ChessBoard.MovePosS() { EndPos = 17, StartPos = 9 }); Console.WriteLine(board.CurrentMoveColor); }
internal static bool CheckForMate(ChessPieceColor whosTurn, ChessBoard chessBoard) { SearchMove.SearchForMate(whosTurn, chessBoard, ref chessBoard.blackInMate, ref chessBoard.whiteInMate, ref chessBoard.staleMate); if (chessBoard.blackInMate || chessBoard.whiteInMate || chessBoard.staleMate) { return true; } return false; }
public void Turn() { var board = new ChessBoard(); var piece = board[17]; Console.WriteLine(piece.ToString()); board.DoMove(new ChessBoard.MovePosS() { EndPos = 17, StartPos = 9 }); piece = board[17]; Console.WriteLine(piece.ToString()); }
public static int rateMaterial(bool isWhite, ChessBoard c) { int counter = 0; int numBishops = 0; BitboardLayer[] dict = c.getDict(isWhite); for (int j = 0; j <= pieceIndex.KING; j++) { foreach (int i in dict[j].getTrueIndicies()) { if (j != pieceIndex.BISHOP) counter += pieceVals[j]; else numBishops++; } } if (numBishops >= 2) counter += 300 * numBishops; else counter += 250 * numBishops; return (int)(counter * 1.75); }
public static bool GetBishopMoveList( ChessBoard board, ChessBoardSquare selSquare, List<sMove> listRetBoardPos ) { // left-up - diagonal GetStraightMoveList( board, selSquare, listRetBoardPos, MoveDirectionType.eDirection_Move_LeftUp_Diagonal ); // left-down - diagonal GetStraightMoveList( board, selSquare, listRetBoardPos, MoveDirectionType.eDirection_Move_LeftDown_Diagonal ); // right-up - diagonal GetStraightMoveList( board, selSquare, listRetBoardPos, MoveDirectionType.eDirection_Move_RightUp_Diagonal ); // right-down - diagonal GetStraightMoveList( board, selSquare, listRetBoardPos, MoveDirectionType.eDirection_Move_RightDown_Diagonal ); if( listRetBoardPos.Count > 0 ) return true; return false; }
public static int quickRating(bool isWhite, ChessBoard c, int possibleMoves, int depth) { //designed for sorting for alphabeta //for these purposes, we care less about moves that increase moveability or attack //hopefully int counter = 0; int material = rateMaterial(isWhite, c); counter += material; counter += ratePositional(isWhite, c, material); isWhite = !isWhite; material = rateMaterial(isWhite, c); counter -= material; counter -= ratePositional(isWhite, c, material); return counter; }
public void Stage(ChessBoard b) { b.Set("b1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Knight }); b.Set("g1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Knight }); b.Set("a2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("c2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("d2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("e2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("f2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("g2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Knight }); b.Set("g8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Knight }); }
public static void EngineMove(ChessBoard board) { if (CheckForMate(board.WhoseMove, board)) { return; } System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch(); watch.Start(); //If there is no playbook move search for the best move MoveContent bestMove = SearchMove.AlphaBetaRoot(board, Constants.ply); ChessEngine.MoveContent(board, bestMove.MovingPiecePrimary.SrcPosition, bestMove.MovingPiecePrimary.DstPosition, ChessPieceType.Queen); PieceValidMoves.GenerateValidMoves(board); Evaluation.EvaluateBoardScore(board); System.Diagnostics.Debug.WriteLine("Engine Move Time: " + watch.ElapsedTicks); }
public static bool IsValidMove(ChessBoard board, byte sourceIndex, byte destinationIndex) { ChessPiece piece = board.pieces[sourceIndex]; if (piece == null) { return false; } foreach (byte bs in piece.ValidMoves) { if (bs == destinationIndex) { return true; } } if (destinationIndex == board.EnPassantPosition) { return true; } return false; }
public void Stage(ChessBoard b) { b.Set("a2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("b2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("g2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("h2", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Pawn }); b.Set("a1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook }); b.Set("h1", new ChessPiece() { Player = PlayerTypeEnum.White, Type = PieceTypeEnum.Rook }); b.Set("a7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("b7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("g7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("h7", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Pawn }); b.Set("a8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook }); b.Set("h8", new ChessPiece() { Player = PlayerTypeEnum.Black, Type = PieceTypeEnum.Rook }); }
public static int rateAttack(bool isWhite, ChessBoard c) { BitboardLayer[] dict = c.getDict(isWhite); BitboardLayer attackedSqs = c.getAllAttackedSq(isWhite); int counter = 0; for (int j = 0; j <= pieceIndex.KING; j++) //don't include king { foreach (int i in dict[j].getTrueIndicies()) { if (attackedSqs.trueAtIndex(i)) { switch (j) { case pieceIndex.PAWN: counter -= 64; break; case pieceIndex.ROOK: counter -= 500; break; case pieceIndex.KNIGHT: counter -= 300; break; case pieceIndex.BISHOP: counter -= 300; break; case pieceIndex.QUEEN: counter -= 900; break; case pieceIndex.KING: counter -= 200; break; } } } } return (int)(counter * .5); }
protected override Int32 Evaluate(ChessBoard myBoard, ChessPiece turn, Int16 depth) { //bool canMove; IncrementSearchCount(); var materialValue = myBoard.GetMaterialValue(this.ChessPieceRelativeValues, depth); var positionalValue = myBoard.GetPositionalValue(); /* TBD!! if (!canMove) { if (turn == this.MySuit) { // I am mated or stale mated return myBoard.InCheck(turn) ? -WonScore : StaleMateScore; } else { // Opponent is mated or stale mated return myBoard.InCheck(turn) ? WonScore : StaleMateScore; } }*/ return MaterialFactor * materialValue + PositionalFactor * positionalValue; }
/// <summary> /// Find the best move for a player using alpha-beta in a secondary thread /// </summary> /// <param name="board"> Chess board</param> /// <param name="searchMode"> Search mode</param> /// <param name="ePlayer"> Color doing the move</param> /// <param name="iThreadId"> Thread Id (0-n)</param> /// <param name="moveList"> List of move to try</param> /// <param name="posInfoWhite"> Information about pieces attacks for the white</param> /// <param name="posInfoBlack"> Information about pieces attacks for the black</param> /// <param name="iTotalMoveCount"> Total number of moves</param> /// <param name="iAlpha"> Alpha bound</param> /// <param name="iBeta"> Beta bound</param> /// <returns> /// Points /// </returns> private AlphaBetaResult FindBestMoveUsingAlphaBetaAsync(ChessBoard board, SearchMode searchMode, ChessBoard.PlayerE ePlayer, int iThreadId, List <Move> moveList, ChessBoard.PosInfoS posInfoWhite, ChessBoard.PosInfoS posInfoBlack, int iTotalMoveCount, int iAlpha, int iBeta) { AlphaBetaResult resRetVal; DateTime dtTimeOut; int iDepth; int iPermCountAtLevel; int iPoint; int iBestMoveIndex; int iDepthLimit; int[] arrPoints; System.Threading.ThreadPriority eThreadPriority; TransTable transTable; bool bTimeOut; bool bIterativeDepthFirst; resRetVal = new AlphaBetaResult(); eThreadPriority = System.Threading.Thread.CurrentThread.Priority; System.Threading.Thread.CurrentThread.Priority = System.Threading.ThreadPriority.BelowNormal; if ((searchMode.m_eOption & SearchMode.OptionE.UseTransTable) != 0) { transTable = TransTable.GetTransTable(iThreadId); transTable.Reset(); } else { transTable = null; } bIterativeDepthFirst = (searchMode.m_eOption.HasFlag(SearchMode.OptionE.UseIterativeDepthSearch)); resRetVal.movePosBest.StartPos = 255; resRetVal.movePosBest.EndPos = 255; resRetVal.movePosBest.OriginalPiece = ChessBoard.PieceE.None; resRetVal.movePosBest.Type = Move.TypeE.Normal; try { resRetVal.iPermCount = 0; if (searchMode.m_iSearchDepth == 0 || bIterativeDepthFirst) { dtTimeOut = (bIterativeDepthFirst) ? DateTime.MaxValue : DateTime.Now + TimeSpan.FromSeconds(searchMode.m_iTimeOutInSec); iDepthLimit = (bIterativeDepthFirst) ? searchMode.m_iSearchDepth : 999; iDepth = 1; resRetVal.iPts = FindBestMoveUsingAlphaBetaAtDepth(board, searchMode, ePlayer, moveList, posInfoWhite, posInfoBlack, iTotalMoveCount, iDepth, iAlpha, iBeta, transTable, DateTime.MaxValue, out iPermCountAtLevel, out iBestMoveIndex, out bTimeOut, out arrPoints); if (iBestMoveIndex != -1) { resRetVal.movePosBest = moveList[iBestMoveIndex]; } resRetVal.iPermCount += iPermCountAtLevel; resRetVal.iMaxDepth = iDepth; while (DateTime.Now < dtTimeOut && !m_bCancelSearch && !bTimeOut && iDepth < iDepthLimit) { moveList = SortMoveList(moveList, arrPoints); iDepth++; iPoint = FindBestMoveUsingAlphaBetaAtDepth(board, searchMode, ePlayer, moveList, posInfoWhite, posInfoBlack, iTotalMoveCount, iDepth, iAlpha, iBeta, transTable, dtTimeOut, out iPermCountAtLevel, out iBestMoveIndex, out bTimeOut, out arrPoints); if (!bTimeOut) { if (iBestMoveIndex != -1) { resRetVal.movePosBest = moveList[iBestMoveIndex]; } resRetVal.iPermCount += iPermCountAtLevel; resRetVal.iMaxDepth = iDepth; resRetVal.iPts = iPoint; } } } else { resRetVal.iMaxDepth = searchMode.m_iSearchDepth; resRetVal.iPts = FindBestMoveUsingAlphaBetaAtDepth(board, searchMode, ePlayer, moveList, posInfoWhite, posInfoBlack, iTotalMoveCount, resRetVal.iMaxDepth, iAlpha, iBeta, transTable, DateTime.MaxValue, out resRetVal.iPermCount, out iBestMoveIndex, out bTimeOut, out arrPoints); if (iBestMoveIndex != -1) { resRetVal.movePosBest = moveList[iBestMoveIndex]; } } } finally { System.Threading.Thread.CurrentThread.Priority = eThreadPriority; } return(resRetVal); }
public ChessMove GetNextMove(ChessBoard currentBoard) { _isGetNextMoveCall = true; _currentBoard = currentBoard.Clone(); if (this.IsHuman) { _waitForPlayerEvent.Reset(); _waitForPlayerEvent.WaitOne(); } else { StartAiInTimedThread(UvsChess.Gui.Preferences.Time); } return _moveToReturn; }
internal static int Sort(ChessBoard s2, ChessBoard s1) { return (s1.Score).CompareTo(s2.Score); }
void Start() { CB = GameObject.Find("棋盘").GetComponent <ChessBoard>(); }
public static int CalculateOthers(ChessBoard cb) { var score = 0; long piece; var whites = cb.Pieces[White][All]; var whitePawns = cb.Pieces[White][Pawn]; var blacks = cb.Pieces[Black][All]; var blackPawns = cb.Pieces[Black][Pawn]; var whitePawnAttacks = cb.Attacks[White][Pawn]; var blackPawnAttacks = cb.Attacks[Black][Pawn]; // side to move score += ColorFactor[cb.ColorToMove] * EvalConstants.SideToMoveBonus; // WHITE ROOK if (cb.Pieces[White][Rook] != 0) { piece = cb.Pieces[White][Rook]; // rook battery (same file) if (BitOperations.PopCount((ulong)piece) == 2) { if ((BitOperations.TrailingZeroCount(piece) & 7) == ((63 - BitOperations.LeadingZeroCount((ulong)piece)) & 7)) { score += EvalConstants.OtherScores[EvalConstants.IxRookBattery]; } } // rook on 7th, king on 8th if (cb.KingIndex[Black] >= 56 && (piece & Bitboard.Rank7) != 0) { score += BitOperations.PopCount((ulong)(piece & Bitboard.Rank7)) * EvalConstants.OtherScores[EvalConstants.IxRook7ThRank]; } // prison if ((piece & Bitboard.Rank1) != 0) { var trapped = piece & EvalConstants.RookPrison[cb.KingIndex[White]]; if (trapped != 0) { if ((((trapped << 8) | (trapped << 16)) & whitePawns) != 0) { score += EvalConstants.OtherScores[EvalConstants.IxRookTrapped]; } } } // rook on open-file (no pawns) and semi-open-file (no friendly pawns) while (piece != 0) { if ((whitePawns & Bitboard.GetFile(piece)) == 0) { if ((blackPawns & Bitboard.GetFile(piece)) == 0) { score += EvalConstants.OtherScores[EvalConstants.IxRookFileOpen]; } else if ((blackPawns & blackPawnAttacks & Bitboard.GetFile(piece)) == 0) { score += EvalConstants.OtherScores[EvalConstants.IxRookFileSemiOpenIsolated]; } else { score += EvalConstants.OtherScores[EvalConstants.IxRookFileSemiOpen]; } } piece &= piece - 1; } } // BLACK ROOK if (cb.Pieces[Black][Rook] != 0) { piece = cb.Pieces[Black][Rook]; // rook battery (same file) if (BitOperations.PopCount((ulong)piece) == 2) { if ((BitOperations.TrailingZeroCount(piece) & 7) == ((63 - BitOperations.LeadingZeroCount((ulong)piece)) & 7)) { score -= EvalConstants.OtherScores[EvalConstants.IxRookBattery]; } } // rook on 2nd, king on 1st if (cb.KingIndex[White] <= 7 && (piece & Bitboard.Rank2) != 0) { score -= BitOperations.PopCount((ulong)(piece & Bitboard.Rank2)) * EvalConstants.OtherScores[EvalConstants.IxRook7ThRank]; } // prison if ((piece & Bitboard.Rank8) != 0) { var trapped = piece & EvalConstants.RookPrison[cb.KingIndex[Black]]; if (trapped != 0) { if (((Util.RightTripleShift(trapped, 8) | Util.RightTripleShift(trapped, 16)) & blackPawns) != 0) { score -= EvalConstants.OtherScores[EvalConstants.IxRookTrapped]; } } } // rook on open-file (no pawns) and semi-open-file (no friendly pawns) while (piece != 0) { // TODO JITWatch unpredictable branch if ((blackPawns & Bitboard.GetFile(piece)) == 0) { if ((whitePawns & Bitboard.GetFile(piece)) == 0) { score -= EvalConstants.OtherScores[EvalConstants.IxRookFileOpen]; } else if ((whitePawns & whitePawnAttacks & Bitboard.GetFile(piece)) == 0) { score -= EvalConstants.OtherScores[EvalConstants.IxRookFileSemiOpenIsolated]; } else { score -= EvalConstants.OtherScores[EvalConstants.IxRookFileSemiOpen]; } } piece &= piece - 1; } } // WHITE BISHOP if (cb.Pieces[White][Bishop] != 0) { // bishop outpost: protected by a pawn, cannot be attacked by enemy pawns piece = cb.Pieces[White][Bishop] & cb.PassedPawnsAndOutposts & whitePawnAttacks; if (piece != 0) { score += BitOperations.PopCount((ulong)piece) * EvalConstants.OtherScores[EvalConstants.IxOutpost]; } piece = cb.Pieces[White][Bishop]; if ((piece & Bitboard.WhiteSquares) != 0) { // pawns on same color as bishop score += EvalConstants.BishopPawn[ BitOperations.PopCount((ulong)(whitePawns & Bitboard.WhiteSquares))]; // attacking center squares if (BitOperations.PopCount((ulong)(cb.Attacks[White][Bishop] & Bitboard.E4D5)) == 2) { score += EvalConstants.OtherScores[EvalConstants.IxBishopLong]; } } if ((piece & Bitboard.BlackSquares) != 0) { // pawns on same color as bishop score += EvalConstants.BishopPawn[ BitOperations.PopCount((ulong)(whitePawns & Bitboard.BlackSquares))]; // attacking center squares if (BitOperations.PopCount((ulong)(cb.Attacks[White][Bishop] & Bitboard.D4E5)) == 2) { score += EvalConstants.OtherScores[EvalConstants.IxBishopLong]; } } // prison piece &= Bitboard.Rank2; while (piece != 0) { if (BitOperations.PopCount( (ulong)(EvalConstants.BishopPrison[BitOperations.TrailingZeroCount(piece)] & blackPawns)) == 2) { score += EvalConstants.OtherScores[EvalConstants.IxBishopPrison]; } piece &= piece - 1; } } // BLACK BISHOP if (cb.Pieces[Black][Bishop] != 0) { // bishop outpost: protected by a pawn, cannot be attacked by enemy pawns piece = cb.Pieces[Black][Bishop] & cb.PassedPawnsAndOutposts & blackPawnAttacks; if (piece != 0) { score -= BitOperations.PopCount((ulong)piece) * EvalConstants.OtherScores[EvalConstants.IxOutpost]; } piece = cb.Pieces[Black][Bishop]; if ((piece & Bitboard.WhiteSquares) != 0) { // penalty for many pawns on same color as bishop score -= EvalConstants.BishopPawn[ BitOperations.PopCount((ulong)(blackPawns & Bitboard.WhiteSquares))]; // bonus for attacking center squares if (BitOperations.PopCount((ulong)(cb.Attacks[Black][Bishop] & Bitboard.E4D5)) == 2) { score -= EvalConstants.OtherScores[EvalConstants.IxBishopLong]; } } if ((piece & Bitboard.BlackSquares) != 0) { // penalty for many pawns on same color as bishop score -= EvalConstants.BishopPawn[ BitOperations.PopCount((ulong)(blackPawns & Bitboard.BlackSquares))]; // bonus for attacking center squares if (BitOperations.PopCount((ulong)(cb.Attacks[Black][Bishop] & Bitboard.D4E5)) == 2) { score -= EvalConstants.OtherScores[EvalConstants.IxBishopLong]; } } // prison piece &= Bitboard.Rank7; while (piece != 0) { if (BitOperations.PopCount( (ulong)(EvalConstants.BishopPrison[BitOperations.TrailingZeroCount(piece)] & whitePawns)) == 2) { score -= EvalConstants.OtherScores[EvalConstants.IxBishopPrison]; } piece &= piece - 1; } } // pieces supporting our pawns piece = (whitePawns << 8) & whites; while (piece != 0) { score += EvalConstants.PawnBlockage[Util.RightTripleShift(BitOperations.TrailingZeroCount(piece), 3)]; piece &= piece - 1; } piece = Util.RightTripleShift(blackPawns, 8) & blacks; while (piece != 0) { score -= EvalConstants.PawnBlockage[7 - BitOperations.TrailingZeroCount(piece) / 8]; piece &= piece - 1; } // knight outpost: protected by a pawn, cannot be attacked by enemy pawns piece = cb.Pieces[White][Knight] & cb.PassedPawnsAndOutposts & whitePawnAttacks; if (piece != 0) { score += BitOperations.PopCount((ulong)piece) * EvalConstants.OtherScores[EvalConstants.IxOutpost]; } piece = cb.Pieces[Black][Knight] & cb.PassedPawnsAndOutposts & blackPawnAttacks; if (piece != 0) { score -= BitOperations.PopCount((ulong)piece) * EvalConstants.OtherScores[EvalConstants.IxOutpost]; } // pinned-pieces if (cb.PinnedPieces != 0) { piece = cb.PinnedPieces & whites; while (piece != 0) { score += EvalConstants.Pinned[cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)]]; piece &= piece - 1; } piece = cb.PinnedPieces & blacks; while (piece != 0) { score -= EvalConstants.Pinned[cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)]]; piece &= piece - 1; } } // discovered-pieces if (cb.DiscoveredPieces != 0) { piece = cb.DiscoveredPieces & whites; while (piece != 0) { score += EvalConstants.Discovered[cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)]]; piece &= piece - 1; } piece = cb.DiscoveredPieces & blacks; while (piece != 0) { score -= EvalConstants.Discovered[cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)]]; piece &= piece - 1; } } if (cb.CastlingRights == 0) { return(score); } score += BitOperations.PopCount((ulong)(cb.CastlingRights & 12)) * EvalConstants.OtherScores[EvalConstants.IxCastling]; score -= BitOperations.PopCount((ulong)(cb.CastlingRights & 3)) * EvalConstants.OtherScores[EvalConstants.IxCastling]; return(score); }
public void OnEachMoveStart(ChessBoard chessBoard) { moveTimeRecorder = new TimeRecorder(); }
/// <summary> /// Alpha Beta pruning function. /// </summary> /// <param name="board"> Chess board</param> /// <param name="ePlayer"> Color doing the move</param> /// <param name="iDepth"> Actual search depth</param> /// <param name="iAlpha"> Alpha limit</param> /// <param name="iBeta"> Beta limit</param> /// <param name="iWhiteMoveCount"> Number of moves white can do</param> /// <param name="iBlackMoveCount"> Number of moves black can do</param> /// <param name="abInfo"> Supplemental information</param> /// <returns> /// Points to give for this move or Int32.MinValue for timed out /// </returns> private int AlphaBeta(ChessBoard board, ChessBoard.PlayerE ePlayer, int iDepth, int iAlpha, int iBeta, int iWhiteMoveCount, int iBlackMoveCount, AlphaBetaInfo abInfo) { int iRetVal; List <Move> moveList; int iPts; int iMoveCount; ChessBoard.PosInfoS posInfo; TransEntryTypeE eType = TransEntryTypeE.Alpha; ChessBoard.BoardStateMaskE eBoardExtraInfo; ChessBoard.RepeatResultE eResult; if (abInfo.m_dtTimeOut != DateTime.MaxValue && DateTime.Now >= abInfo.m_dtTimeOut) { iRetVal = Int32.MinValue; // Time out! } else if (board.IsEnoughPieceForCheckMate()) { eBoardExtraInfo = board.ComputeBoardExtraInfo(ePlayer, true); iRetVal = (abInfo.m_transTable != null) ? abInfo.m_transTable.ProbeEntry(board.CurrentZobristKey, eBoardExtraInfo, iDepth, iAlpha, iBeta) : Int32.MaxValue; if (iRetVal == Int32.MaxValue) { if (iDepth == 0 || m_bCancelSearch) { iRetVal = board.Points(abInfo.m_searchMode, ePlayer, abInfo.m_iMaxDepth - iDepth, iWhiteMoveCount - iBlackMoveCount, abInfo.m_posInfoWhite, abInfo.m_posInfoBlack); if (ePlayer == ChessBoard.PlayerE.Black) { iRetVal = -iRetVal; } abInfo.m_iPermCount++; if (abInfo.m_transTable != null) { abInfo.m_transTable.RecordEntry(board.CurrentZobristKey, eBoardExtraInfo, iDepth, iRetVal, TransEntryTypeE.Exact); } } else { moveList = board.EnumMoveList(ePlayer, true, out posInfo); iMoveCount = moveList.Count; if (ePlayer == ChessBoard.PlayerE.White) { iWhiteMoveCount = iMoveCount; abInfo.m_posInfoWhite = posInfo; } else { iBlackMoveCount = iMoveCount; abInfo.m_posInfoBlack = posInfo; } if (iMoveCount == 0) { if (board.IsCheck(ePlayer)) { iRetVal = -1000000 - iDepth; } else { iRetVal = 0; // Draw } if (abInfo.m_transTable != null) { abInfo.m_transTable.RecordEntry(board.CurrentZobristKey, eBoardExtraInfo, iDepth, iRetVal, TransEntryTypeE.Exact); } } else { iRetVal = iAlpha; foreach (Move move in moveList) { eResult = board.DoMoveNoLog(move); abInfo.m_arrMove[iDepth - 1] = move; if (eResult == ChessBoard.RepeatResultE.NoRepeat) { iPts = -AlphaBeta(board, (ePlayer == ChessBoard.PlayerE.Black) ? ChessBoard.PlayerE.White : ChessBoard.PlayerE.Black, iDepth - 1, -iBeta, -iRetVal, iWhiteMoveCount, iBlackMoveCount, abInfo); } else { iPts = 0; } board.UndoMoveNoLog(move); if (iPts == Int32.MinValue) { iRetVal = iPts; break; } else { if (iPts > iRetVal) { iRetVal = iPts; eType = TransEntryTypeE.Exact; } if (iRetVal >= iBeta) { iRetVal = iBeta; eType = TransEntryTypeE.Beta; break; } } } if (abInfo.m_transTable != null && iRetVal != Int32.MinValue) { abInfo.m_transTable.RecordEntry(board.CurrentZobristKey, eBoardExtraInfo, iDepth, iRetVal, eType); } } } } } else { iRetVal = 0; } return(iRetVal); }
public void update(unitControler self, Environment env) { if (((BasicControler)self).traget == null) { Debug.Log("basic ai 的 upate"); ChessBoard map = (ChessBoard)env; int[] position = map.getPosFor(self);//拿到自己的坐標 int posx = position[0]; int posy = position[1]; bool solve = false; if (((BasicControler)self).data.Remote) { if (((BasicControler)self).playerNo % 2 == 0) { Debug.Log("path1"); for (int y = 4; y < 8; y++)//先判斷和自己同一行的角色 { if (map.board[y, posx] != null && ((BasicControler)map.board[y, posx]).playerNo != 0) { ((BasicControler)self).traget = map.board[y, posx]; solve = true; break; } } //不行的話再從前到後依次掃描 for (int y = 4; y < 8; y++) { for (int x = 0; x < 5; x++) { if (map.board[y, x] != null && ((BasicControler)map.board[y, x]).playerNo != 0) { ((BasicControler)self).traget = map.board[y, x]; solve = true; break; } } if (solve) { break; } } } else if (((BasicControler)self).playerNo % 2 == 1) { Debug.Log("path2"); for (int y = 3; y >= 0; y--)//先判斷和自己同一行的角色 { if (map.board[y, posx] != null && ((BasicControler)map.board[y, posx]).playerNo != 1) { ((BasicControler)self).traget = map.board[y, posx]; solve = true; break; } } //不行的話再從前到後依次掃描 for (int y = 3; y >= 0; y--) { for (int x = 0; x < 5; x++) { if (map.board[y, x] != null && ((BasicControler)map.board[y, x]).playerNo != 1) { ((BasicControler)self).traget = map.board[y, x]; solve = true; break; } } if (solve) { break; } } } } else { if (((BasicControler)self).playerNo % 2 == 0) { Debug.Log("path3"); for (int y = 4; y < 8; y++) { if (map.board[y, posx] != null && ((BasicControler)map.board[y, posx]).playerNo != 0) { ((BasicControler)self).traget = map.board[y, posx]; solve = true; break; } for (int x = 0; x < 5; x++) { if (map.board[y, x] != null && ((BasicControler)map.board[y, x]).playerNo != 0) { ((BasicControler)self).traget = map.board[y, x]; solve = true; break; } } if (solve) { break; } } } else if (((BasicControler)self).playerNo % 2 == 1) { Debug.Log("path4 objname:" + ((BasicControler)self).gameObject.name); for (int y = 3; y >= 0; y--) { if (map.board[y, posx] != null && ((BasicControler)map.board[y, posx]).playerNo != 1) { ((BasicControler)self).traget = map.board[y, posx]; solve = true; break; } for (int x = 0; x < 5; x++) { if (map.board[y, x] != null && ((BasicControler)map.board[y, x]).playerNo != 1) { ((BasicControler)self).traget = map.board[y, x]; solve = true; break; } } if (solve) { break; } } } } } }
public IEnumerable <ChessPiece> GetChecking(ChessBoard board, ChessPosition pos) { return(board.ProtectedBy(pos, Owner == PlayerColor.White ? PlayerColor.Black : PlayerColor.White)); }
public King(Color color, ChessBoard board, Match match) : base(color, board) { _match = match; }
private void IntializeChessBoard() { _chessBoard = new ChessBoard(); _chessBoard.Pieces = new List <ChessPiece>(); //first set _chessBoard.Pieces.Add(new ChessPiece { Id = 1, Position = 1, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.ROOK }); _chessBoard.Pieces.Add(new ChessPiece { Id = 2, Position = 2, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.KNIGHT }); _chessBoard.Pieces.Add(new ChessPiece { Id = 3, Position = 3, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.BISHOP }); _chessBoard.Pieces.Add(new ChessPiece { Id = 4, Position = 4, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.KING }); _chessBoard.Pieces.Add(new ChessPiece { Id = 5, Position = 5, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.QUEEN }); _chessBoard.Pieces.Add(new ChessPiece { Id = 6, Position = 6, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.BISHOP }); _chessBoard.Pieces.Add(new ChessPiece { Id = 7, Position = 7, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.KNIGHT }); _chessBoard.Pieces.Add(new ChessPiece { Id = 8, Position = 8, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.ROOK }); for (int soliderId = 9; soliderId < 17; soliderId++) { _chessBoard.Pieces.Add(new ChessPiece { Id = soliderId, Position = soliderId, SetType = PIECE_TYPE.BLACK, Name = PIECE_NAME.SOLDIER }); } //second set _chessBoard.Pieces.Add(new ChessPiece { Id = 57, Position = 57, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.ROOK }); _chessBoard.Pieces.Add(new ChessPiece { Id = 58, Position = 58, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.KNIGHT }); _chessBoard.Pieces.Add(new ChessPiece { Id = 59, Position = 59, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.BISHOP }); _chessBoard.Pieces.Add(new ChessPiece { Id = 60, Position = 60, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.KING }); _chessBoard.Pieces.Add(new ChessPiece { Id = 61, Position = 61, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.QUEEN }); _chessBoard.Pieces.Add(new ChessPiece { Id = 62, Position = 62, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.BISHOP }); _chessBoard.Pieces.Add(new ChessPiece { Id = 63, Position = 63, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.KNIGHT }); _chessBoard.Pieces.Add(new ChessPiece { Id = 64, Position = 64, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.ROOK }); for (int soliderId = 56; soliderId > 48; soliderId--) { _chessBoard.Pieces.Add(new ChessPiece { Id = soliderId, Position = soliderId, SetType = PIECE_TYPE.WHITE, Name = PIECE_NAME.SOLDIER }); } }
public Tower(ChessBoard chessBoard, Color color) : base(chessBoard, color) { }
public void InitialBoardState2() { ChessBoard b = new ChessBoard(); var currentPlayer = b.CurrentPlayer; currentPlayer.Should().Be(1, "Player 1 should be the first to make a move"); var stalemate = b.IsStalemate; stalemate.Should().BeFalse("there should not be a stalement at the beginning of the game"); var checkmate = b.IsCheckmate; checkmate.Should().BeFalse("there should not be a checkmate at the beginning of the game"); var check = b.IsCheck; check.Should().BeFalse("there should not be a check at the beginning of the game"); var drawCounter = b.DrawCounter; drawCounter.Should().Be(0, "draws should not have happened at the beginning of the game"); var moveHistory = b.MoveHistory; moveHistory.Should().BeEmpty("no moves should have been made yet"); var isFinished = b.IsFinished; isFinished.Should().BeFalse("the game should not be finished at the beginning"); var currentAdvantage = b.CurrentAdvantage; currentAdvantage.Player.Should().Be(0, "no player should have an advantage at the beginning of the game"); currentAdvantage.Advantage.Should().Be(0, "no player should have an advantage at the beginning of the game"); char[] columns = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' }; foreach (var column in columns) { var pawnWhite = b.GetPieceAtPosition(Pos(string.Format("{0}2", column))); var pawnBlack = b.GetPieceAtPosition(Pos(string.Format("{0}7", column))); pawnWhite.PieceType.Should().Be(ChessPieceType.Pawn, "pieces in row 2 should be pawns at the beginning of the game"); pawnBlack.PieceType.Should().Be(ChessPieceType.Pawn, "pieces in row 7 should be pawns at the beginning of the game"); if (column == 'a') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Rook, string.Format("piece at ({0},1) should be a rook at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Rook, string.Format("piece at ({0},8) should be a rook at the beginning of the game", column)); } else if (column == 'b') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Knight, string.Format("piece at ({0},1) should be a knight at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Knight, string.Format("piece at ({0},8) should be a knight at the beginning of the game", column)); } else if (column == 'c') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Bishop, string.Format("piece at ({0},1) should be a bishop at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Bishop, string.Format("piece at ({0},8) should be a bishop at the beginning of the game", column)); } else if (column == 'd') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Queen, string.Format("piece at ({0},1) should be a queen at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Queen, string.Format("piece at ({0},8) should be a queen at the beginning of the game", column)); } else if (column == 'e') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.King, string.Format("piece at ({0},1) should be a King at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.King, string.Format("piece at ({0},8) should be a King at the beginning of the game", column)); } else if (column == 'f') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Bishop, string.Format("piece at ({0},1) should be a Bishop at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Bishop, string.Format("piece at ({0},8) should be a Bishop at the beginning of the game", column)); } else if (column == 'g') { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Knight, string.Format("piece at ({0},1) should be a knight at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Knight, string.Format("piece at ({0},8) should be a knight at the beginning of the game", column)); } else { var pieceWhite = b.GetPieceAtPosition(Pos(string.Format("{0}1", column))); var pieceBlack = b.GetPieceAtPosition(Pos(string.Format("{0}8", column))); pieceWhite.PieceType.Should().Be(ChessPieceType.Rook, string.Format("piece at ({0},1) should be a rook at the beginning of the game", column)); pieceBlack.PieceType.Should().Be(ChessPieceType.Rook, string.Format("piece at ({0},8) should be a rook at the beginning of the game", column)); } } }
public void SetUp() { _chessBoard = new ChessBoard(); _queen = new Queen(PieceColor.Black, _chessBoard); _chessBoard.ResetBoard(); }
public void InitialBoardState() { ChessBoard b = new ChessBoard(); // Check row 1 b.GetPieceAtPosition(Pos("a1")).PieceType.Should().Be(ChessPieceType.Rook, "piece is a Rook"); b.GetPieceAtPosition(Pos("a1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("b1")).PieceType.Should().Be(ChessPieceType.Knight, "piece is a Knight"); b.GetPieceAtPosition(Pos("b1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("c1")).PieceType.Should().Be(ChessPieceType.Bishop, "piece is a Bishop"); b.GetPieceAtPosition(Pos("c1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("d1")).PieceType.Should().Be(ChessPieceType.Queen, "piece is a Queen"); b.GetPieceAtPosition(Pos("d1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("e1")).PieceType.Should().Be(ChessPieceType.King, "piece is a King"); b.GetPieceAtPosition(Pos("e1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("f1")).PieceType.Should().Be(ChessPieceType.Bishop, "piece is a Bishop"); b.GetPieceAtPosition(Pos("f1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("g1")).PieceType.Should().Be(ChessPieceType.Knight, "piece is a Knight"); b.GetPieceAtPosition(Pos("g1")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("h1")).PieceType.Should().Be(ChessPieceType.Rook, "piece is a Rook"); b.GetPieceAtPosition(Pos("h1")).Player.Should().Be(1, "piece is white"); // Check row 2 b.GetPieceAtPosition(Pos("a2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("a2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("b2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("b2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("c2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("c2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("d2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("d2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("e2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("e2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("f2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("f2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("g2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("g2")).Player.Should().Be(1, "piece is white"); b.GetPieceAtPosition(Pos("h2")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("h2")).Player.Should().Be(1, "piece is white"); // Check row 3 b.GetPieceAtPosition(Pos("a3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("b3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("c3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("d3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("e3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("f3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("g3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("h3")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); // Check row 4 b.GetPieceAtPosition(Pos("a4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("b4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("c4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("d4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("e4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("f4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("g4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("h4")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); // Check row 5 b.GetPieceAtPosition(Pos("a5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("b5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("c5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("d5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("e5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("f5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("g5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("h5")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); // Check row 6 b.GetPieceAtPosition(Pos("a6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("b6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("c6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("d6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("e6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("f6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("g6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); b.GetPieceAtPosition(Pos("h6")).PieceType.Should().Be(ChessPieceType.Empty, "space is Empty"); // Check row 7 b.GetPieceAtPosition(Pos("a7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("a7")).Player.Should().Be(2); b.GetPieceAtPosition(Pos("b7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("b7")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("c7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("c7")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("d7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("d7")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("e7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("e7")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("f7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("f7")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("g7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("g7")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("h7")).PieceType.Should().Be(ChessPieceType.Pawn, "piece is a Pawn"); b.GetPieceAtPosition(Pos("h7")).Player.Should().Be(2, "piece is black"); // Check row 8 b.GetPieceAtPosition(Pos("a8")).PieceType.Should().Be(ChessPieceType.Rook, "piece is a Rook"); b.GetPieceAtPosition(Pos("a8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("b8")).PieceType.Should().Be(ChessPieceType.Knight, "piece is a Knight"); b.GetPieceAtPosition(Pos("b8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("c8")).PieceType.Should().Be(ChessPieceType.Bishop, "piece is a Bishop"); b.GetPieceAtPosition(Pos("c8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("d8")).PieceType.Should().Be(ChessPieceType.Queen, "piece is a Queen"); b.GetPieceAtPosition(Pos("d8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("e8")).PieceType.Should().Be(ChessPieceType.King, "piece is a King"); b.GetPieceAtPosition(Pos("e8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("f8")).PieceType.Should().Be(ChessPieceType.Bishop, "piece is a Bishop"); b.GetPieceAtPosition(Pos("f8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("g8")).PieceType.Should().Be(ChessPieceType.Knight, "piece is a Knight"); b.GetPieceAtPosition(Pos("g8")).Player.Should().Be(2, "piece is black"); b.GetPieceAtPosition(Pos("h8")).PieceType.Should().Be(ChessPieceType.Rook, "piece is a Rook"); b.GetPieceAtPosition(Pos("h8")).Player.Should().Be(2, "piece is black"); // Player 1 moves first b.CurrentPlayer.Should().Be(1, "Player 1 moves first"); // Score should be 0 - 0 b.CurrentAdvantage.Should().Be(Advantage(0, 0), "score should be tied at 0"); }
/// <summary> /// Find the best move for a player using alpha-beta /// </summary> /// <param name="board"> Chess board</param> /// <param name="searchMode"> Search mode</param> /// <param name="ePlayer"> Player doing the move</param> /// <param name="moveList"> Move list</param> /// <param name="arrIndex"> Order of evaluation of the moves</param> /// <param name="posInfo"> Information about pieces attacks</param> /// <param name="moveBest"> Best move found</param> /// <param name="iPermCount"> Total permutation evaluated</param> /// <param name="iCacheHit"> Number of moves found in the translation table cache</param> /// <param name="iMaxDepth"> Maximum depth to use</param> /// <returns> /// true if a move has been found /// </returns> protected override bool FindBestMove(ChessBoard board, SearchMode searchMode, ChessBoard.PlayerE ePlayer, List <Move> moveList, int[] arrIndex, ChessBoard.PosInfoS posInfo, ref Move moveBest, out int iPermCount, out int iCacheHit, out int iMaxDepth) { bool bRetVal = false; bool bMultipleThread; bool bUseTransTable; ChessBoard[] arrBoard; Task <AlphaBetaResult>[] taskArray; List <Move>[] arrMoveList; AlphaBetaResult alphaBetaRes; ChessBoard.PosInfoS posInfoWhite; ChessBoard.PosInfoS posInfoBlack; int iAlpha; int iBeta; int iThreadCount; //TODO Enable transposition table when bug on 3 repetition move draw will be found. if (ePlayer == ChessBoard.PlayerE.White) { posInfoWhite = posInfo; posInfoBlack = ChessBoard.s_posInfoNull; } else { posInfoWhite = ChessBoard.s_posInfoNull; posInfoBlack = posInfo; } searchMode.m_eOption &= ~SearchMode.OptionE.UseTransTable; bUseTransTable = (searchMode.m_eOption.HasFlag(SearchMode.OptionE.UseTransTable)); iCacheHit = 0; iMaxDepth = 0; iPermCount = 0; iAlpha = -10000000; iBeta = +10000000; bMultipleThread = (searchMode.m_eThreadingMode == SearchMode.ThreadingModeE.OnePerProcessorForSearch); iThreadCount = System.Environment.ProcessorCount; if (bMultipleThread && iThreadCount < 2) { bMultipleThread = false; // No reason to go with multi-threading if only one processor } if (bMultipleThread) { arrBoard = new ChessBoard[iThreadCount]; arrMoveList = new List <Move> [iThreadCount]; taskArray = new Task <AlphaBetaResult> [iThreadCount]; for (int iIndex = 0; iIndex < iThreadCount; iIndex++) { arrBoard[iIndex] = board.Clone(); arrMoveList[iIndex] = new List <Move>(moveList.Count / iThreadCount + 1); for (int iStep = iIndex; iStep < moveList.Count; iStep += iThreadCount) { arrMoveList[iIndex].Add(moveList[arrIndex[iStep]]); } } for (int iIndex = 0; iIndex < iThreadCount; iIndex++) { taskArray[iIndex] = Task <AlphaBetaResult> .Factory.StartNew((param) => { int iStep = (int)param; return(FindBestMoveUsingAlphaBetaAsync(arrBoard[iStep], searchMode, ePlayer, iStep, arrMoveList[iStep], posInfoWhite, posInfoBlack, moveList.Count, iAlpha, iBeta)); }, iIndex); } iMaxDepth = 999; for (int iStep = 0; iStep < iThreadCount; iStep++) { alphaBetaRes = taskArray[iStep].Result; if (alphaBetaRes.movePosBest.StartPos != 255) { iPermCount += alphaBetaRes.iPermCount; iMaxDepth = Math.Min(iMaxDepth, alphaBetaRes.iMaxDepth); if (bUseTransTable) { iCacheHit += TransTable.GetTransTable(iStep).CacheHit; } if (alphaBetaRes.iPts > iAlpha) { iAlpha = alphaBetaRes.iPts; moveBest = alphaBetaRes.movePosBest; bRetVal = true; } } } if (iMaxDepth == 999) { iMaxDepth = -1; } } else { ChessBoard chessBoardTmp; List <Move> moveListTmp; chessBoardTmp = board.Clone(); moveListTmp = new List <Move>(moveList.Count); for (int iIndex = 0; iIndex < moveList.Count; iIndex++) { moveListTmp.Add(moveList[arrIndex[iIndex]]); } alphaBetaRes = FindBestMoveUsingAlphaBetaAsync(chessBoardTmp, searchMode, ePlayer, 0, // ThreadId moveListTmp, posInfoWhite, posInfoBlack, moveList.Count, iAlpha, iBeta); iPermCount = alphaBetaRes.iPermCount; iMaxDepth = alphaBetaRes.iMaxDepth; if (alphaBetaRes.movePosBest.StartPos != 255) { if (bUseTransTable) { iCacheHit += TransTable.GetTransTable(0).CacheHit; } moveBest = alphaBetaRes.movePosBest; bRetVal = true; } } return(bRetVal); }
private void InputChessPiece(Piece piece, char colum, int line) { ChessBoard.InputPiece(piece, new ChessPosition(colum, line).toPosition()); Pieces.Add(piece); }
public void MakePlay(Position origin, Position destiny) { Piece p = Move(origin, destiny); bool promo = false; Piece promoAux = null; //Special Move - Promotion if (ChessBoard.Piece(destiny) is Pawn && (destiny.Line == 0 || destiny.Line == 7)) { Console.WriteLine("Chose your Promotion:\nb\tn\tq\tt"); char chose = char.Parse(Console.ReadLine()); Piece promoPiece = null; switch (chose) { case 'b': promoPiece = new Bishop(ChessBoard, ChessBoard.Piece(destiny).Color); break; case 'n': promoPiece = new Knight(ChessBoard, ChessBoard.Piece(destiny).Color); break; case 'q': promoPiece = new Queen(ChessBoard, ChessBoard.Piece(destiny).Color); break; case 't': promoPiece = new Tower(ChessBoard, ChessBoard.Piece(destiny).Color); break; } Pieces.Remove(ChessBoard.Piece(destiny)); ChessBoard.OutputPiece(destiny); ChessBoard.InputPiece(promoPiece, destiny); Pieces.Add(promoPiece); promo = true; } if (InCheck(PlayerColor)) { if (!promo) { ReverseMove(origin, destiny, p); } else { ReverseMove(origin, destiny, p, promoAux); } throw new BoardException("You can't move this piece, you in xeque"); } if (InCheck(Adversary(PlayerColor))) { Check = true; } else { Check = false; } if (CheckMate(Adversary(PlayerColor))) { Finish = true; } else { Turn++; ChangePlayer(); Piece Passant = ChessBoard.Piece(destiny); if (Passant is Pawn && (destiny.Line == origin.Line + 2 || destiny.Line == origin.Line - 2)) { EnPassant = Passant; } else { EnPassant = null; } } }
public void KingPossibleStartAndPlay_543479() { ChessBoard board = new ChessBoard(); board.GetPieceAtPosition(Pos(7, 4)).PieceType.Should().Be(ChessPieceType.King, "White's king at position (7,4)"); board.GetPieceAtPosition(Pos(0, 4)).PieceType.Should().Be(ChessPieceType.King, "Black's king at position (0,4)"); var whiteKingPossMoves = GetMovesAtPosition(board.GetPossibleMoves(), Pos(7, 4)); var blackKingPossMoves = GetMovesAtPosition(board.GetPossibleMoves(), Pos(0, 4)); // Game State Check of all False void StateCheck1() { board.IsFinished.Should().BeFalse(); board.IsStalemate.Should().BeFalse(); board.IsCheck.Should().BeFalse(); board.IsCheckmate.Should().BeFalse(); } // Check if the King's possible moves from the very start are nothing. They should be able to ignore their own pieces within possible moves whiteKingPossMoves.Should().BeEmpty(); blackKingPossMoves.Should().BeEmpty(); // Because they do not have possible moves, but it is the intiial start of the game, there shouldn't be any flags triggered StateCheck1(); // Do a similar test above, but pawns that are not within the movement range of the king's directions // Check that the king's possible moves is still empty Apply(board, "b2,b3"); StateCheck1(); Apply(board, "h7,h5"); StateCheck1(); // King shouldn't be able to move and double check the position of the King whiteKingPossMoves.Should().BeEmpty(); blackKingPossMoves.Should().BeEmpty(); board.GetPieceAtPosition(Pos("e1")).PieceType.Should().Be(ChessPieceType.King, "King should be at position e1"); board.GetPieceAtPosition(Pos("e8")).PieceType.Should().Be(ChessPieceType.King, "King should be at position e8"); // Move a white pawn that's in front of the King that's within its range of movement Apply(board, "e2,e3"); // Move a black pawn that's in front of the King that's within its range of movement Apply(board, "e7,e6"); // Check white king's possible moves, there should be "something" and apply it var wkMove = GetMovesAtPosition(board.GetPossibleMoves(), Pos("e1")); wkMove.Should().NotBeNullOrEmpty(); Apply(board, "e1,e2"); // Check black king's possible moves, there should be "something" and apply it var bkMove = GetMovesAtPosition(board.GetPossibleMoves(), Pos("e8")); bkMove.Should().NotBeNullOrEmpty(); Apply(board, "e8,e7"); board.GetPieceAtPosition(Pos("e2")).PieceType.Should().Be(ChessPieceType.King, "King should be at position e2"); board.GetPieceAtPosition(Pos("e7")).PieceType.Should().Be(ChessPieceType.King, "King should be at position e7"); // Move pawns in front of queen up to allow the queens to move for both sides Apply(board, "d2,d4"); Apply(board, "d7,d5"); Apply(board, "d1,d2"); Apply(board, "d8,d7"); // Move white Queen to check White King Apply(board, "d2,b4"); // Check what the Black King can do bkMove = GetMovesAtPosition(board.GetPossibleMoves(), Pos("e7")); board.IsCheck.Should().BeTrue(); bkMove.Should().Contain(Move("e7,e8"), "The king can move back to its starting position") .And.Contain(Move("e7,d8"), "The king can move to a back row") .And.Contain(Move("e7,f6"), "The king can move forward diagonally"); // Move black King back to start Apply(board, "e7,e8"); // Move some white pawn to get to black's turn Apply(board, "h2,h4"); // Move black Queen to check White King Apply(board, "d7,b5"); // Check what the White King can do wkMove = GetMovesAtPosition(board.GetPossibleMoves(), Pos("e2")); board.IsCheck.Should().BeTrue(); wkMove.Should().Contain(Move("e2,e1"), "The king can move back to its starting position") .And.Contain(Move("e2,d1"), "The king can move to a back row") .And.Contain(Move("e2,f3"), "The king can move forward diagonally"); // Move white King forward Apply(board, "e2,f3"); // Black Queen gets White Queen Apply(board, "b5,b4"); Apply(board, "c2,c3"); Apply(board, "b4,c3"); Apply(board, "c1,d2"); Apply(board, "c3,d2"); Apply(board, "b1,d2"); Apply(board, "e6,e5"); Apply(board, "d4,e5"); Apply(board, "d5,d4"); Apply(board, "e3,d4"); Apply(board, "f7,f5"); // Apply an EnPassat Move Apply(board, "e5,f6"); Apply(board, "g7,g5"); Apply(board, "f6,f7"); // Move King out of Pawn's check board.IsCheck.Should().BeTrue(); bkMove = GetMovesAtPosition(board.GetPossibleMoves(), Pos("e8")); board.IsCheck.Should().BeTrue(); bkMove.Should().Contain(Move("e8,d8"), "The king can move back to its starting position"); Apply(board, "e8,d8"); // Move Pawn to Promote to Queen Apply(board, "f7, g8, Queen"); board.GetPieceAtPosition(Pos("g8")).PieceType.Should().Be(ChessPieceType.Queen, "Pawn should've promoted to a Queen"); Apply(board, "c7,c5"); Apply(board, "h4,g5"); Apply(board, "h5,h4"); Apply(board, "h1,h4"); // Black bishop check's White King Apply(board, "c8,g4"); // Check if Check flag is triggered and eliminate Black Bishop on White King board.IsCheck.Should().BeTrue(); var protectWK = board.GetPossibleMoves(); protectWK.Should().Contain(Move("h4,g4"), "Rook should be able to capture enemy bishop checking White King"); Apply(board, "h4,g4"); // Eliminate Black Rook with White Rook Apply(board, "h8,h7"); Apply(board, "g4,h4"); Apply(board, "c5,d4"); Apply(board, "h4,h7"); // Play a dummy move Apply(board, "b8,a6"); // White Queen takes Black Bishop Apply(board, "g8,f8"); board.IsCheckmate.Should().BeTrue(); }
private static int CalculatePawnScores(ChessBoard cb) { var score = 0; // penalty for doubled pawns for (var i = 0; i < 8; i++) { if (BitOperations.PopCount((ulong)(cb.Pieces[White][Pawn] & Bitboard.Files[i])) > 1) { score -= EvalConstants.PawnScores[EvalConstants.IxPawnDouble]; } if (BitOperations.PopCount((ulong)(cb.Pieces[Black][Pawn] & Bitboard.Files[i])) > 1) { score += EvalConstants.PawnScores[EvalConstants.IxPawnDouble]; } } // bonus for connected pawns var pawns = Bitboard.GetWhitePawnAttacks(cb.Pieces[White][Pawn]) & cb.Pieces[White][Pawn]; while (pawns != 0) { score += EvalConstants.PawnConnected[BitOperations.TrailingZeroCount(pawns) / 8]; pawns &= pawns - 1; } pawns = Bitboard.GetBlackPawnAttacks(cb.Pieces[Black][Pawn]) & cb.Pieces[Black][Pawn]; while (pawns != 0) { score -= EvalConstants.PawnConnected[7 - BitOperations.TrailingZeroCount(pawns) / 8]; pawns &= pawns - 1; } // bonus for neighbour pawns pawns = Bitboard.GetPawnNeighbours(cb.Pieces[White][Pawn]) & cb.Pieces[White][Pawn]; while (pawns != 0) { score += EvalConstants.PawnNeighbour[BitOperations.TrailingZeroCount(pawns) / 8]; pawns &= pawns - 1; } pawns = Bitboard.GetPawnNeighbours(cb.Pieces[Black][Pawn]) & cb.Pieces[Black][Pawn]; while (pawns != 0) { score -= EvalConstants.PawnNeighbour[7 - BitOperations.TrailingZeroCount(pawns) / 8]; pawns &= pawns - 1; } // set outposts cb.PassedPawnsAndOutposts = 0; pawns = Bitboard.GetWhitePawnAttacks(cb.Pieces[White][Pawn]) & ~cb.Pieces[White][Pawn] & ~cb.Pieces[Black][Pawn]; while (pawns != 0) { if ((Bitboard.GetWhiteAdjacentMask(BitOperations.TrailingZeroCount(pawns)) & cb.Pieces[Black][Pawn]) == 0) { cb.PassedPawnsAndOutposts |= pawns & -pawns; } pawns &= pawns - 1; } pawns = Bitboard.GetBlackPawnAttacks(cb.Pieces[Black][Pawn]) & ~cb.Pieces[White][Pawn] & ~cb.Pieces[Black][Pawn]; while (pawns != 0) { if ((Bitboard.GetBlackAdjacentMask(BitOperations.TrailingZeroCount(pawns)) & cb.Pieces[White][Pawn]) == 0) { cb.PassedPawnsAndOutposts |= pawns & -pawns; } pawns &= pawns - 1; } int index; // white pawns = cb.Pieces[White][Pawn]; while (pawns != 0) { index = BitOperations.TrailingZeroCount(pawns); // isolated pawns if ((Bitboard.FilesAdjacent[index & 7] & cb.Pieces[White][Pawn]) == 0) { score -= EvalConstants.PawnScores[EvalConstants.IxPawnIsolated]; } // backward pawns else if ((Bitboard.GetBlackAdjacentMask(index + 8) & cb.Pieces[White][Pawn]) == 0) { if ((StaticMoves.PawnAttacks[White][index + 8] & cb.Pieces[Black][Pawn]) != 0) { if ((Bitboard.Files[index & 7] & cb.Pieces[Black][Pawn]) == 0) { score -= EvalConstants.PawnScores[EvalConstants.IxPawnBackward]; } } } // pawn defending 2 pawns if (BitOperations.PopCount((ulong)(StaticMoves.PawnAttacks[White][index] & cb.Pieces[White][Pawn])) == 2) { score -= EvalConstants.PawnScores[EvalConstants.IxPawnInverse]; } // set passed pawns if ((Bitboard.GetWhitePassedPawnMask(index) & cb.Pieces[Black][Pawn]) == 0) { cb.PassedPawnsAndOutposts |= pawns & -pawns; } // candidate passed pawns (no pawns in front, more friendly pawns behind and adjacent than enemy pawns) else if (63 - BitOperations.LeadingZeroCount( (ulong)((cb.Pieces[White][Pawn] | cb.Pieces[Black][Pawn]) & Bitboard.Files[index & 7])) == index) { if (BitOperations.PopCount((ulong)(cb.Pieces[White][Pawn] & Bitboard.GetBlackPassedPawnMask(index + 8))) >= BitOperations.PopCount( (ulong)(cb.Pieces[Black][Pawn] & Bitboard.GetWhitePassedPawnMask(index)))) { score += EvalConstants.PassedCandidate[index / 8]; } } pawns &= pawns - 1; } // black pawns = cb.Pieces[Black][Pawn]; while (pawns != 0) { index = BitOperations.TrailingZeroCount(pawns); // isolated pawns if ((Bitboard.FilesAdjacent[index & 7] & cb.Pieces[Black][Pawn]) == 0) { score += EvalConstants.PawnScores[EvalConstants.IxPawnIsolated]; } // backward pawns else if ((Bitboard.GetWhiteAdjacentMask(index - 8) & cb.Pieces[Black][Pawn]) == 0) { if ((StaticMoves.PawnAttacks[Black][index - 8] & cb.Pieces[White][Pawn]) != 0) { if ((Bitboard.Files[index & 7] & cb.Pieces[White][Pawn]) == 0) { score += EvalConstants.PawnScores[EvalConstants.IxPawnBackward]; } } } // pawn defending 2 pawns if (BitOperations.PopCount((ulong)(StaticMoves.PawnAttacks[Black][index] & cb.Pieces[Black][Pawn])) == 2) { score += EvalConstants.PawnScores[EvalConstants.IxPawnInverse]; } // set passed pawns if ((Bitboard.GetBlackPassedPawnMask(index) & cb.Pieces[White][Pawn]) == 0) { cb.PassedPawnsAndOutposts |= pawns & -pawns; } // candidate passers else if (BitOperations.TrailingZeroCount((cb.Pieces[White][Pawn] | cb.Pieces[Black][Pawn]) & Bitboard.Files[index & 7]) == index) { if (BitOperations.PopCount((ulong)(cb.Pieces[Black][Pawn] & Bitboard.GetWhitePassedPawnMask(index - 8))) >= BitOperations.PopCount( (ulong)(cb.Pieces[White][Pawn] & Bitboard.GetBlackPassedPawnMask(index)))) { score -= EvalConstants.PassedCandidate[7 - index / 8]; } } pawns &= pawns - 1; } return(score); }
public static int CalculateMobilityScoresAndSetAttacks(ChessBoard cb) { cb.ClearEvalAttacks(); for (var color = White; color <= Black; color++) { var kingArea = KingArea[cb.KingIndex[1 - color]]; var piece = cb.Pieces[color][Pawn] & ~cb.PinnedPieces; while (piece != 0) { cb.UpdatePawnAttacks(StaticMoves.PawnAttacks[color][BitOperations.TrailingZeroCount(piece)], color); piece &= piece - 1; } cb.UpdatePawnAttacks(color, kingArea); piece = cb.Pieces[color][Pawn] & cb.PinnedPieces; while (piece != 0) { cb.UpdateAttacks(StaticMoves.PawnAttacks[color][BitOperations.TrailingZeroCount(piece)] & PinnedMovement[BitOperations.TrailingZeroCount(piece)][cb.KingIndex[color]], Pawn, color, kingArea); piece &= piece - 1; } } var score = 0; long moves; for (var color = White; color <= Black; color++) { var tempScore = 0; var kingArea = KingArea[cb.KingIndex[1 - color]]; var safeMoves = ~cb.Pieces[color][All] & ~cb.Attacks[1 - color][Pawn]; // knights var piece = cb.Pieces[color][Knight] & ~cb.PinnedPieces; while (piece != 0) { moves = StaticMoves.KnightMoves[BitOperations.TrailingZeroCount(piece)]; cb.UpdateAttacks(moves, Knight, color, kingArea); tempScore += EvalConstants.MobilityKnight[BitOperations.PopCount((ulong)(moves & safeMoves))]; piece &= piece - 1; } // bishops piece = cb.Pieces[color][Bishop]; while (piece != 0) { moves = MagicUtil.GetBishopMoves(BitOperations.TrailingZeroCount(piece), cb.AllPieces ^ cb.Pieces[color][Queen]); cb.UpdateAttacks(moves, Bishop, color, kingArea); tempScore += EvalConstants.MobilityBishop[BitOperations.PopCount((ulong)(moves & safeMoves))]; piece &= piece - 1; } // rooks piece = cb.Pieces[color][Rook]; while (piece != 0) { moves = MagicUtil.GetRookMoves(BitOperations.TrailingZeroCount(piece), cb.AllPieces ^ cb.Pieces[color][Rook] ^ cb.Pieces[color][Queen]); cb.UpdateAttacks(moves, Rook, color, kingArea); tempScore += EvalConstants.MobilityRook[BitOperations.PopCount((ulong)(moves & safeMoves))]; piece &= piece - 1; } // queens piece = cb.Pieces[color][Queen]; while (piece != 0) { moves = MagicUtil.GetQueenMoves(BitOperations.TrailingZeroCount(piece), cb.AllPieces); cb.UpdateAttacks(moves, Queen, color, kingArea); tempScore += EvalConstants.MobilityQueen[BitOperations.PopCount((ulong)(moves & safeMoves))]; piece &= piece - 1; } score += tempScore * ColorFactor[color]; } // TODO king-attacks with or without enemy attacks? // WHITE king moves = StaticMoves.KingMoves[cb.KingIndex[White]] & ~StaticMoves.KingMoves[cb.KingIndex[Black]]; cb.Attacks[White][King] = moves; cb.DoubleAttacks[White] |= cb.Attacks[White][All] & moves; cb.Attacks[White][All] |= moves; score += EvalConstants.MobilityKing[ BitOperations.PopCount((ulong)(moves & ~cb.Pieces[White][All] & ~cb.Attacks[Black][All]))]; // BLACK king moves = StaticMoves.KingMoves[cb.KingIndex[Black]] & ~StaticMoves.KingMoves[cb.KingIndex[White]]; cb.Attacks[Black][King] = moves; cb.DoubleAttacks[Black] |= cb.Attacks[Black][All] & moves; cb.Attacks[Black][All] |= moves; score -= EvalConstants.MobilityKing[ BitOperations.PopCount((ulong)(moves & ~cb.Pieces[Black][All] & ~cb.Attacks[White][All]))]; return(score); }
public void WhenThereIsCapture_MovingPieceAndReversingTheMoveWillReaddRemovedPieceToAvailablePieces() { var whiteKingMock = new Mock <IChessPiece>(MockBehavior.Strict); var blackKingMock = new Mock <IChessPiece>(MockBehavior.Strict); var pawnMock = new Mock <IChessPiece>(MockBehavior.Strict); var pieceMoverMock = new Mock <IPieceMover>(MockBehavior.Strict); var piecesFactoryMock = new Mock <IPiecesFactory>(MockBehavior.Strict); var whiteKingPosition = new Position(4, 0); var blackKingPosition = new Position(4, 7); var pawnPosition = new Position(4, 1); var chessMove = new ChessMove(whiteKingPosition, new Position(4, 1), true); whiteKingMock .SetupGet(k => k.Color) .Returns(ChessColor.White); whiteKingMock .SetupGet(k => k.PieceType) .Returns(ChessPieceType.King); whiteKingMock .SetupGet(k => k.Position) .Returns(whiteKingPosition); blackKingMock .SetupGet(k => k.Color) .Returns(ChessColor.Black); blackKingMock .SetupGet(k => k.PieceType) .Returns(ChessPieceType.King); blackKingMock .SetupGet(k => k.Position) .Returns(blackKingPosition); pawnMock .SetupGet(k => k.Color) .Returns(ChessColor.Black); pawnMock .SetupGet(k => k.PieceType) .Returns(ChessPieceType.Pawn); pawnMock .SetupGet(k => k.Position) .Returns(pawnPosition); pieceMoverMock .Setup(p => p.Move(chessMove, It.IsAny <IEnumerable <IChessPiece> >())) .Returns(pawnMock.Object); pieceMoverMock .Setup(p => p.ReverseLastMove(It.IsAny <IEnumerable <IChessPiece> >())) .Returns(chessMove.IsCapture); var pieces = new HashSet <IChessPiece>(); pieces.Add(whiteKingMock.Object); pieces.Add(blackKingMock.Object); pieces.Add(pawnMock.Object); piecesFactoryMock .Setup(f => f.Create()) .Returns(pieces); var chessBoard = new ChessBoard(piecesFactoryMock.Object, pieceMoverMock.Object); chessBoard.Move(chessMove); chessBoard.ReverseLastMove(); Assert.AreEqual(3, chessBoard.Pieces.Count()); Assert.Contains(whiteKingMock.Object, chessBoard.Pieces.ToList()); Assert.Contains(blackKingMock.Object, chessBoard.Pieces.ToList()); Assert.Contains(pawnMock.Object, chessBoard.Pieces.ToList()); }
public void Initialize(string input) { this.rawInput = input; this.game = new ChessGame(); this.board = new ChessBoard(); }
public void OnEachMoveEnd(ChessBoard chessBoard) { ++moveCount; totalMoveMilliSeconds += moveTimeRecorder.GetTotalMilliSeconds(); }
/// <summary> /// Validates a move. The framework uses this to validate the opponents move. /// </summary> /// <param name="currentBoard">The board as it currently is.</param> /// <param name="moveToCheck">This is the move that needs to be checked to see if it's valid.</param> /// <param name="colorOfPlayerMoving">This is the color of the player who's making the move.</param> /// <returns>Returns true if the move was valid</returns> public bool? IsValidMove(ChessBoard currentBoard, ChessMove moveToCheck) { _moveToReturn = null; _isGetNextMoveCall = false; _isValidMove = false; if (this.IsHuman) { // Humans don't check the AI's moves, so just always return true return true; } _currentBoard = currentBoard.Clone(); _moveToCheck = moveToCheck.Clone(); StartAiInTimedThread(UvsChess.Gui.Preferences.CheckMoveTimeout); if ((_moveToReturn != null) && (_moveToReturn.Flag == ChessFlag.AIWentOverTime)) { // The AI Went over time while validating the move. Signal ChessGame of this. return null; } return _isValidMove; }
private void UpdateChessBoardComponent(ChessWebApiResult result) { ChessBoard.Update(result.Board, result.AvailableMoves, result.WhoseTurn.ToLower().Contains("white")); }
public static int CalculateThreats(ChessBoard cb) { var score = 0; var whites = cb.Pieces[White][All]; var whitePawns = cb.Pieces[White][Pawn]; var blacks = cb.Pieces[Black][All]; var blackPawns = cb.Pieces[Black][Pawn]; var whiteAttacks = cb.Attacks[White][All]; var whitePawnAttacks = cb.Attacks[White][Pawn]; var whiteMinorAttacks = cb.Attacks[White][Knight] | cb.Attacks[White][Bishop]; var blackAttacks = cb.Attacks[Black][All]; var blackPawnAttacks = cb.Attacks[Black][Pawn]; var blackMinorAttacks = cb.Attacks[Black][Knight] | cb.Attacks[Black][Bishop]; // double attacked pieces var piece = cb.DoubleAttacks[White] & blacks; while (piece != 0) { score += EvalConstants.DoubleAttacked[cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)]]; piece &= piece - 1; } piece = cb.DoubleAttacks[Black] & whites; while (piece != 0) { score -= EvalConstants.DoubleAttacked[cb.PieceIndexes[BitOperations.TrailingZeroCount(piece)]]; piece &= piece - 1; } if (MaterialUtil.HasPawns(cb.MaterialKey)) { // unused outposts score += BitOperations.PopCount((ulong)(cb.PassedPawnsAndOutposts & cb.EmptySpaces & whiteMinorAttacks & whitePawnAttacks)) * EvalConstants.Threats[EvalConstants.IxUnusedOutpost]; score -= BitOperations.PopCount((ulong)(cb.PassedPawnsAndOutposts & cb.EmptySpaces & blackMinorAttacks & blackPawnAttacks)) * EvalConstants.Threats[EvalConstants.IxUnusedOutpost]; // pawn push threat piece = (whitePawns << 8) & cb.EmptySpaces & ~blackAttacks; score += BitOperations.PopCount((ulong)(Bitboard.GetWhitePawnAttacks(piece) & blacks)) * EvalConstants.Threats[EvalConstants.IxPawnPushThreat]; piece = Util.RightTripleShift(blackPawns, 8) & cb.EmptySpaces & ~whiteAttacks; score -= BitOperations.PopCount((ulong)(Bitboard.GetBlackPawnAttacks(piece) & whites)) * EvalConstants.Threats[EvalConstants.IxPawnPushThreat]; // piece attacked by pawn score += BitOperations.PopCount((ulong)(whitePawnAttacks & blacks & ~blackPawns)) * EvalConstants.Threats[EvalConstants.IxPawnAttacks]; score -= BitOperations.PopCount((ulong)(blackPawnAttacks & whites & ~whitePawns)) * EvalConstants.Threats[EvalConstants.IxPawnAttacks]; // multiple pawn attacks possible if (BitOperations.PopCount((ulong)(whitePawnAttacks & blacks)) > 1) { score += EvalConstants.Threats[EvalConstants.IxMultiplePawnAttacks]; } if (BitOperations.PopCount((ulong)(blackPawnAttacks & whites)) > 1) { score -= EvalConstants.Threats[EvalConstants.IxMultiplePawnAttacks]; } // pawn attacked score += BitOperations.PopCount((ulong)(whiteAttacks & blackPawns)) * EvalConstants.Threats[EvalConstants.IxPawnAttacked]; score -= BitOperations.PopCount((ulong)(blackAttacks & whitePawns)) * EvalConstants.Threats[EvalConstants.IxPawnAttacked]; } // minors attacked and not defended by a pawn score += BitOperations.PopCount((ulong)(whiteAttacks & (cb.Pieces[Black][Knight] | (cb.Pieces[Black][Bishop] & ~blackAttacks)))) * EvalConstants.Threats[EvalConstants.IxMajorAttacked]; score -= BitOperations.PopCount((ulong)(blackAttacks & (cb.Pieces[White][Knight] | (cb.Pieces[White][Bishop] & ~whiteAttacks)))) * EvalConstants.Threats[EvalConstants.IxMajorAttacked]; if (cb.Pieces[Black][Queen] != 0) { // queen attacked by rook score += BitOperations.PopCount((ulong)(cb.Attacks[White][Rook] & cb.Pieces[Black][Queen])) * EvalConstants.Threats[EvalConstants.IxQueenAttacked]; // queen attacked by minors score += BitOperations.PopCount((ulong)(whiteMinorAttacks & cb.Pieces[Black][Queen])) * EvalConstants.Threats[EvalConstants.IxQueenAttackedMinor]; } if (cb.Pieces[White][Queen] != 0) { // queen attacked by rook score -= BitOperations.PopCount((ulong)(cb.Attacks[Black][Rook] & cb.Pieces[White][Queen])) * EvalConstants.Threats[EvalConstants.IxQueenAttacked]; // queen attacked by minors score -= BitOperations.PopCount((ulong)(blackMinorAttacks & cb.Pieces[White][Queen])) * EvalConstants.Threats[EvalConstants.IxQueenAttackedMinor]; } // rook attacked by minors score += BitOperations.PopCount((ulong)(whiteMinorAttacks & cb.Pieces[Black][Rook])) * EvalConstants.Threats[EvalConstants.IxRookAttacked]; score -= BitOperations.PopCount((ulong)(blackMinorAttacks & cb.Pieces[White][Rook])) * EvalConstants.Threats[EvalConstants.IxRookAttacked]; return(score); }
/// <summary> /// Find the best move for a player using alpha-beta for a given depth /// </summary> /// <param name="board"> Chess board</param> /// <param name="searchMode"> Search mode</param> /// <param name="ePlayer"> Color doing the move</param> /// <param name="moveList"> List of move to try</param> /// <param name="posInfoWhite"> Information about pieces attacks for the white</param> /// <param name="posInfoBlack"> Information about pieces attacks for the black</param> /// <param name="iTotalMoveCount"> Total list of moves</param> /// <param name="iDepth"> Maximum depth</param> /// <param name="iAlpha"> Alpha bound</param> /// <param name="iBeta"> Beta bound</param> /// <param name="transTable"> Transposition table or null if not using one</param> /// <param name="dtTimeOut"> Time limit (DateTime.MaxValue for no time limit)</param> /// <param name="iPermCount"> Total permutation evaluated</param> /// <param name="iBestMoveIndex"> Index of the best move</param> /// <param name="bTimeOut"> Return true if time out</param> /// <param name="arrPoints"> Returns point of each move in move list</param> /// <returns> /// Points /// </returns> private int FindBestMoveUsingAlphaBetaAtDepth(ChessBoard board, SearchMode searchMode, ChessBoard.PlayerE ePlayer, List <Move> moveList, ChessBoard.PosInfoS posInfoWhite, ChessBoard.PosInfoS posInfoBlack, int iTotalMoveCount, int iDepth, int iAlpha, int iBeta, TransTable transTable, DateTime dtTimeOut, out int iPermCount, out int iBestMoveIndex, out bool bTimeOut, out int[] arrPoints) { int iRetVal = -10000000; int iWhiteMoveCount; int iBlackMoveCount; int iMoveCount; int iIndex; int iPts; Move move; AlphaBetaInfo abInfo; ChessBoard.RepeatResultE eResult; bTimeOut = false; abInfo = new AlphaBetaInfo(); abInfo.m_arrMove = new Move[iDepth]; abInfo.m_iPermCount = 0; abInfo.m_dtTimeOut = dtTimeOut; abInfo.m_transTable = transTable; abInfo.m_iMaxDepth = iDepth; abInfo.m_searchMode = searchMode; abInfo.m_posInfoWhite = posInfoWhite; abInfo.m_posInfoBlack = posInfoBlack; iBestMoveIndex = -1; arrPoints = new int[moveList.Count]; if (ePlayer == ChessBoard.PlayerE.White) { iWhiteMoveCount = iTotalMoveCount; iBlackMoveCount = 0; } else { iWhiteMoveCount = 0; iBlackMoveCount = iTotalMoveCount; } iMoveCount = moveList.Count; iIndex = 0; iRetVal = iAlpha; while (iIndex < iMoveCount && !bTimeOut) { move = moveList[iIndex]; eResult = board.DoMoveNoLog(move); abInfo.m_arrMove[iDepth - 1] = move; if (eResult == ChessBoard.RepeatResultE.NoRepeat) { iPts = -AlphaBeta(board, (ePlayer == ChessBoard.PlayerE.Black) ? ChessBoard.PlayerE.White : ChessBoard.PlayerE.Black, iDepth - 1, -iBeta, -iRetVal, iWhiteMoveCount, iBlackMoveCount, abInfo); } else { iPts = 0; } arrPoints[iIndex] = iPts; board.UndoMoveNoLog(move); if (iPts == Int32.MinValue) { iRetVal = iPts; bTimeOut = true; } else { if (iPts > iRetVal) { TraceSearch(iDepth, ePlayer, move, iPts); iRetVal = iPts; iBestMoveIndex = iIndex; } } iIndex++; } iPermCount = abInfo.m_iPermCount; return(iRetVal); }
/// <summary> /// Sets the chess state as described in the FEN board. /// See: http://en.wikipedia.org/wiki/Forsyth-Edwards_Notation /// </summary> /// <param name="fenBoard"></param> public void FromFenBoard(string fenBoard) { string[] lines = fenBoard.Split(' '); CurrentBoard = new ChessBoard(fenBoard); if (lines[1] == "w") { CurrentPlayerColor = ChessColor.White; } else if (lines[1] == "b") { CurrentPlayerColor = ChessColor.Black; } else { throw new Exception("Missing active color in FEN board"); } //casting is lines[2] CastlingFromFen(lines[2]); //en passant is lines[3] EnPassant = EnPassantFromFen(lines[3].ToLower()); HalfMoves = Convert.ToInt32(lines[4]); FullMoves = Convert.ToInt32(lines[5]); }
/// <summary> /// Constructor for a new <see cref="Bishop"/>. /// </summary> /// <inheritdoc/> public Bishop(ChessBoard board, BoardSide side, Team team) : base(board, side, team) { }
public void BoardCreation() { var board = new ChessBoard(); var piece = board[0]; Console.WriteLine(piece.ToString()); }
public void SaveAsBitmap(string fileName) { ChessBoard.SaveAsBitmap(fileName); }
public override bool Move(int srcX, int srcY, int destX, int destY, ChessBoard chess) { throw new System.NotImplementedException(); }
private void get2DProjection_OpenCv(ChessBoard b, out PointF[] projected) { double[,] jabobian; projected = CVI.ProjectPoints(b.boardWorldCoordinated_Cv, Camera.Rvecs, Camera.Tvecs, Camera.Intrinsics.cvmat, Camera.Cv_DistCoeffs4); }
/// <summary> /// The constructor. /// </summary> /// <param name="board">The board where the Chess piece is located.</param> /// <param name="color">The color of the Chess piece.</param> /// <param name="square">The square where the Chess piece is located.</param> public Bishop(ChessBoard board, ChessColor color, Square square = null) : base(board, color, square) { this.Movement = new RowMovement(this, MovementDirection.Diagonal); }
public void initBoard() { this.Width = 2 * ChessBoard.BoardPaddingLeft + ChessBoard.ChessSize * ChessBoard.BoardColumns; this.Height = 2 * ChessBoard.BoardPaddingTop + ChessBoard.ChessSize * ChessBoard.BoardRows; _ChessBoard = Presenter.CreateNewGame(); Label turnLabel = new Label(); turnLabel.Name = "lblTurn"; turnLabel.Text = "Đến lượt X đi"; turnLabel.Font = new Font("Arial", 16, FontStyle.Bold); turnLabel.ForeColor = Color.Blue; turnLabel.TextAlign = ContentAlignment.MiddleCenter; turnLabel.Width = this.Width; turnLabel.Height = 30; turnLabel.Location = new Point(0, ChessBoard.BoardPaddingTop - ChessBoard.ChessSize * 3); Controls.Add(turnLabel); Label timeLabel = new Label(); timeLabel.Name = "lblTime"; timeLabel.Text = ChessBoard.MoveTime.ToString(); timeLabel.Font = new Font("Arial", 16, FontStyle.Bold); timeLabel.ForeColor = Color.Green; timeLabel.TextAlign = ContentAlignment.MiddleCenter; timeLabel.Width = 40; timeLabel.Height = 30; timeLabel.Location = new Point(ChessBoard.BoardPaddingLeft, ChessBoard.BoardPaddingTop - ChessBoard.ChessSize * 2); Controls.Add(timeLabel); ProgressBar progressBar = new ProgressBar(); progressBar.Name = "prgTime"; progressBar.Location = new Point(ChessBoard.BoardPaddingLeft + timeLabel.Width, ChessBoard.BoardPaddingTop - ChessBoard.ChessSize * 2); progressBar.Width = ChessBoard.BoardColumns * ChessBoard.ChessSize - timeLabel.Width; progressBar.Value = 100; Controls.Add(progressBar); for (int i = 0; i < ChessBoard.BoardRows; i++) { Label label = new Label(); label.Text = ((char)('A' + i)).ToString(); label.Font = new Font("Arial", 12, FontStyle.Bold); label.TextAlign = ContentAlignment.MiddleCenter; label.Height = ChessBoard.ChessSize; label.Width = ChessBoard.ChessSize; label.Location = new Point(ChessBoard.BoardPaddingLeft + ChessBoard.ChessSize * i, ChessBoard.BoardPaddingTop - ChessBoard.ChessSize); Controls.Add(label); } for (int i = 0; i < ChessBoard.BoardColumns; i++) { Label label = new Label(); label.Text = (i + 1).ToString(); label.Font = new Font("Arial", 12, FontStyle.Bold); label.TextAlign = ContentAlignment.MiddleCenter; label.Height = ChessBoard.ChessSize; label.Width = ChessBoard.ChessSize; label.Location = new Point(ChessBoard.BoardPaddingLeft - ChessBoard.ChessSize, ChessBoard.BoardPaddingTop + ChessBoard.ChessSize * i); Controls.Add(label); } for (int i = 1; i <= ChessBoard.BoardRows; i++) { for (int j = 1; j <= ChessBoard.BoardColumns; j++) { Button button = new Button(); button.Name = "Chess_" + i.ToString() + "_" + j.ToString(); button.Width = ChessBoard.ChessSize; button.Height = ChessBoard.ChessSize; button.Location = new Point(ChessBoard.BoardPaddingLeft + ChessBoard.ChessSize * (j - 1), ChessBoard.BoardPaddingTop + ChessBoard.ChessSize * (i - 1)); button.Click += btnChess_Click; button.BackgroundImageLayout = ImageLayout.Stretch; Controls.Add(button); _ChessBoard.Chesses[i, j] = new Chess(j, i, 0); } } _ChessBoard.StartTime = DateTime.Now; timerTurn.Start(); timerGameDuration.Start(); }