/// <summary> /// Recursive method to find the best move in a given position. Min-max algorithm alternates /// between black and white. /// </summary> /// <param name="board"></param> /// <param name="turn"></param> /// <param name="possibleMoves"></param> /// <param name="level">Number of half moves to look forward.</param> /// <param name="topLevel">True if this is the outermost call.</param> /// <param name="alpha"></param> /// <param name="beta"></param> /// <param name="bestMove"></param> /// <returns></returns> private int CalculateMove(ChessBoard board, ChessPieceColor turn, List <ChessMove> possibleMoves, int level, bool topLevel, int alpha, int beta, out ChessMove bestMove, int initialDepth) { int best_score = -INFINITY; bestMove = null; if (!Stop) { int i = 0; foreach (ChessMove possibleMove in possibleMoves) { if (topLevel && ((depthToVisualize != 0 && initialDepth >= depthToVisualize) || (depthToVisualize == 0 && initialDepth > 2))) { RaiseConsideringMoveEvent(possibleMove); } i++; ChessBoard resBoard = new ChessBoard(board); resBoard.ApplyMove(turn, possibleMove, null); int move_score = 0; if (level == 0) { #if PROF prof.Start("StaticEval"); #endif move_score = StaticEvaluation(resBoard, turn); #if PROF prof.End("StaticEval"); #endif } else { ChessMove m = null; ChessPieceColor newTurn = ChessGame.InvertColor(turn); List <ChessMove> moves = ChessGame.GetPossibleMoves(resBoard, newTurn); bool abort = false; if (moves.Count == 0) { if (!ChessGame.IsInCheck(board, newTurn)) { // Stale mate, good depending on piece value. int whiteValue = 0; int blackValue = 0; board.GetPiecesValue(out whiteValue, out blackValue); int delta = (turn == ChessPieceColor.White ? whiteValue - blackValue : blackValue - whiteValue); if (delta > 0) { move_score = -10000; } else { move_score = 10000; } } else { int checkMateScore = 50000 + level * 100; // Prioritize early check mate. move_score = checkMateScore; // Check mate. } } else { move_score = -CalculateMove(resBoard, newTurn, moves, level - 1, false, -beta, -alpha, out m, initialDepth); if (m == null) // Abort { abort = true; } } if (abort) // Abort { bestMove = null; best_score = -INFINITY; break; } } if (topLevel) { // Decrease score for repetition moves. if (Game.ChessMoves.Count >= 3) { ChessMove myLastMove = Game.ChessMoves[Game.ChessMoves.Count - 2]; ChessMove oppLastMove = Game.ChessMoves[Game.ChessMoves.Count - 1]; ChessMove oppSecLastMove = Game.ChessMoves[Game.ChessMoves.Count - 3]; if (myLastMove.FromIndex == possibleMove.ToIndex && myLastMove.ToIndex == possibleMove.FromIndex && !myLastMove.IsCapture && oppLastMove.FromIndex == oppSecLastMove.ToIndex && oppLastMove.ToIndex == oppSecLastMove.FromIndex && !oppLastMove.IsCapture && !oppSecLastMove.IsCapture) // TODO: check for IsCapture in possibleMove { move_score -= 30; } } } #if LOGGING Debug.WriteLine(string.Format("{0}Level {1} {2} {3} alpha {4} beta {5}", GetIndent(level), level, possibleMove.ToString(), move_score, alpha, beta)); #endif if (move_score > best_score) { best_score = move_score; bestMove = possibleMove; } if (best_score > alpha) { alpha = best_score; } if (alpha >= beta) { return(alpha); // This means the move is as good as or worse than a previous move. } } } return(best_score); }
private ChessMove GetNextMove() { int startTicks = (int)DateTime.Now.Ticks; ChessMove move = null; Progress = 0; Aborted = false; Stop = false; // Try opening book first. move = openingBook.GetNextMove(Game.ChessMoves); if (move != null && Game.MakeMove(move, true)) { #if !NETFX_CORE Thread.Sleep(200); #endif } else { #if LOGGING Debug.WriteLine(string.Format("Calc start")); #endif #if NETFX_CORE MyTimer timer = null; if (TimeLimit > 0) { timer = new MyTimer(OutOfTime, null, TimeLimit, System.Threading.Timeout.Infinite); Debug.WriteLine("Timer " + TimeLimit); } #else Timer timer = null; if (TimeLimit > 0) { timer = new Timer(OutOfTime, null, TimeLimit, System.Threading.Timeout.Infinite); Debug.WriteLine("Timer " + TimeLimit); } #endif List <ChessMove> possibleMoves = ChessGame.GetPossibleMoves(Game.Board, Game.Turn); // Iterative deepening. int depth = 0; while (true) { ChessMove bestMove = null; Game.AddLog(string.Format("lvl {0} start depth {1}", (int)DifficultyLevel, depth)); int calcStartTicks = (int)DateTime.Now.Ticks; CalculateMove(Game.Board, Game.Turn, possibleMoves, depth, true, -INFINITY, INFINITY, out bestMove, depth); int calcTimeTicks = (int)DateTime.Now.Ticks - calcStartTicks; Game.AddLog(string.Format("end depth {0} ticks {1} bestMove {2}", depth, calcTimeTicks, (bestMove == null ? 0 :1))); Debug.WriteLine(string.Format("dTV: {0} time: {1}", depthToVisualize, calcTimeTicks / TimeSpan.TicksPerSecond)); if (depthToVisualize == 0 && ((float)calcTimeTicks / (float)TimeSpan.TicksPerSecond) > 0.3f) { depthToVisualize = depth; } if (bestMove != null) { move = bestMove; } if (bestMove == null || DepthLimit > 0 && depth >= DepthLimit) { if (timer != null) { timer.Dispose(); } break; } else { // Move the move to the beginning of the list. if (possibleMoves.Remove(move)) { possibleMoves.Insert(0, move); } } depth++; } #if LOGGING Debug.WriteLine(string.Format("Calc end.")); #endif } gameTicks += (int)DateTime.Now.Ticks - startTicks; return(move); }