Exemple #1
0
        public void PreComputeNextMove(Board board)
        {
            // cancel any tasks that are running from last round
            foreach (var task in _tasksByOpponentMove.Select(x => x.Value).Where(x => !x.BestMoveTask.IsCompleted))
            {
                task.CancelSource.Cancel();
            }

            // remove all saved tasks
            _tasksByOpponentMove.Clear();

            // for every possible opponent move, pretend like the opponent picks it and start computing my response
            foreach (var move in board.GetValidMoves())
            {
                var newBoard = board.Copy().Move(move);

                var task = new AsyncSearchTask(TimeSpan.MaxValue);

                task.BestMoveTask = Task.Factory.StartNew(() =>
                {
                    task.Timer.StartTimer();
                    var result = MoveGetter().BestMove(newBoard, _config, MoveTimer.I, task.CancelSource.Token);
                    task.Timer.StopTimer();
                    return(result);
                }, task.CancelSource.Token);

                _tasksByOpponentMove[move] = task;
            }
        }
Exemple #2
0
        public BoardSpace GetMyNextMove(Board board)
        {
            // start the timer
            MoveTimer.I.StartTimer();

            // cancel all tasks that are now irrelevant
            foreach (var task in _tasksByOpponentMove.Where(x => !x.Key.Equals(board.LastMove)))
            {
                task.Value.CancelSource.Cancel();
            }

            TimeSpan?asyncTimeElapsed = null;

            IBestMoveResult bestMoveResult;

            if (board.LastMove == null || !_tasksByOpponentMove.ContainsKey(board.LastMove))
            {
                // we were not precomputing this path, so we need to start fresh
                bestMoveResult = MoveGetter().BestMove(board, _config, MoveTimer.I, new CancellationToken());
            }
            else
            {
                // we already started down this branch, so use the result from the task
                bestMoveResult = _tasksByOpponentMove[board.LastMove].BestMoveTask.Result;

                // check how long that took us
                asyncTimeElapsed = _tasksByOpponentMove[board.LastMove].Timer.GetTimeElapsed();
            }

            // stop timer and grab timer stats
            var percentRemaining = MoveTimer.I.GetPercentOfTimeRemaining();
            var elapsed          = MoveTimer.I.GetTimeElapsed();
            var timedOut         = MoveTimer.I.Timeout();

            MoveTimer.I.ResetTimer();

            // report stats, for debugging only, will be off in production
            if (_config.ReportStatistics)
            {
                Console.WriteLine("Time Taken (s): " + elapsed.TotalSeconds);
                Console.WriteLine("Time Left (%): " + percentRemaining * 100);
                if (asyncTimeElapsed != null)
                {
                    Console.WriteLine("Async Time Taken (s): " + asyncTimeElapsed.Value.TotalSeconds);
                }
                Console.WriteLine(bestMoveResult.ToString());
            }

            // if we have enough time remaining, increase the depth limit
            if (percentRemaining > _config.PercentTimeLeftToIncrementDepthLimit)
            {
                // if we didn't do the search async, just increase depth
                if (asyncTimeElapsed == null)
                {
                    _config.DepthLimit++;
                }
                else
                {
                    // only increase depth if async time was decent
                    var asyncPercentTimeLeft = (_config.MoveTimeout.TotalMilliseconds - asyncTimeElapsed.Value.TotalMilliseconds) / _config.MoveTimeout.TotalMilliseconds;
                    if (asyncPercentTimeLeft > _config.PercentTimeLeftToIncrementDepthLimit / 2)
                    {
                        _config.DepthLimit++;
                    }
                }
            }

            // if we timed out, decrease depth limit so we stop shooting ourself in the foot
            if (timedOut)
            {
                _config.DepthLimit--;
            }

            var emptySpaces = board.GetEmptySpacesRemaining();

            // figure out where we are in the game
            if (_config.GameMode == GameMode.Beginning)
            {
                if (emptySpaces <= 40)
                {
                    _config.DepthLimit--;
                    _config.GameMode = GameMode.Middle;
                }
            }
            else if (_config.GameMode == GameMode.Middle && !timedOut)
            {
                // find out what our areas look like
                var boardPostMove = board.Copy().Move(bestMoveResult.Move);
                var myArea        = OpenAreaHeuristic.GetOpenArea(boardPostMove, boardPostMove.MyPlayer);
                var oppArea       = OpenAreaHeuristic.GetOpenArea(boardPostMove, boardPostMove.OpponentPlayer);

                // if we are walled off, switch to end game
                if (myArea.All(x => !oppArea.Contains(x)))
                {
                    _isWalledOff     = true;
                    _config.GameMode = GameMode.End;
                }
                else // we aren't walled off
                {
                    // if it's time for end game, switch and max out depth
                    if (emptySpaces <= 28)
                    {
                        _config.DepthLimit = 30;
                        _config.GameMode   = GameMode.End;
                    }
                    // if we think we're going to lose, try to find our best move b/c alpha-beta will pick a random one
                    else if (bestMoveResult.Score == int.MinValue)
                    {
                        var tasksByDepthLimit = new Dictionary <int, AsyncSearchTask>();

                        // simultaneously search at smaller depths to get our best move that isn't -infinity
                        for (var newDepthLimit = _config.DepthLimit - 1; newDepthLimit > _config.DepthLimit / 2; newDepthLimit--)
                        {
                            var newConfig = new SearchConfig(_config)
                            {
                                DepthLimit = newDepthLimit
                            };

                            // new task with timeout set at our remaining time
                            var task = new AsyncSearchTask(_config.MoveTimeout.Subtract(elapsed));

                            task.BestMoveTask = Task.Factory.StartNew(() =>
                            {
                                task.Timer.StartTimer();
                                var result = MoveGetter().BestMove(board, newConfig, task.Timer, task.CancelSource.Token);
                                task.Timer.StopTimer();
                                return(result);
                            }, task.CancelSource.Token);

                            tasksByDepthLimit[newDepthLimit] = task;
                        }

                        foreach (var kvp in tasksByDepthLimit.OrderBy(x => x.Key))
                        {
                            var newBestMove = kvp.Value.BestMoveTask.Result;

                            // if we think we're going to lose or we timed out, cancel all deeper tasks because they will also think we're going to lose
                            if (newBestMove.Score == int.MinValue || kvp.Value.Timer.Timeout())
                            {
                                var kvpClosure = kvp;
                                foreach (var task in tasksByDepthLimit.Where(x => x.Key > kvpClosure.Key).Select(x => x.Value).Where(x => !x.BestMoveTask.IsCompleted))
                                {
                                    task.CancelSource.Cancel();
                                }
                                break;
                            }

                            // if we found a better move, use it
                            if (newBestMove.Score > bestMoveResult.Score)
                            {
                                bestMoveResult = newBestMove;
                            }
                        }
                    }
                }
            }

            return(bestMoveResult.Move);
        }
Exemple #3
0
        public BoardSpace GetMyNextMove(Board board)
        {
            // start the timer
            MoveTimer.I.StartTimer();

            // cancel all tasks that are now irrelevant
            foreach (var task in _tasksByOpponentMove.Where(x => !x.Key.Equals(board.LastMove)))
            {
                task.Value.CancelSource.Cancel();
            }

            TimeSpan? asyncTimeElapsed = null;

            IBestMoveResult bestMoveResult;

            if (board.LastMove == null || !_tasksByOpponentMove.ContainsKey(board.LastMove))
            {
                // we were not precomputing this path, so we need to start fresh
                bestMoveResult = MoveGetter().BestMove(board, _config, MoveTimer.I, new CancellationToken());
            }
            else
            {
                // we already started down this branch, so use the result from the task
                bestMoveResult = _tasksByOpponentMove[board.LastMove].BestMoveTask.Result;

                // check how long that took us
                asyncTimeElapsed = _tasksByOpponentMove[board.LastMove].Timer.GetTimeElapsed();
            }

            // stop timer and grab timer stats
            var percentRemaining = MoveTimer.I.GetPercentOfTimeRemaining();
            var elapsed = MoveTimer.I.GetTimeElapsed();
            var timedOut = MoveTimer.I.Timeout();
            MoveTimer.I.ResetTimer();

            // report stats, for debugging only, will be off in production
            if (_config.ReportStatistics)
            {
                Console.WriteLine("Time Taken (s): " + elapsed.TotalSeconds);
                Console.WriteLine("Time Left (%): " + percentRemaining * 100);
                if (asyncTimeElapsed != null)
                {
                    Console.WriteLine("Async Time Taken (s): " + asyncTimeElapsed.Value.TotalSeconds);
                }
                Console.WriteLine(bestMoveResult.ToString());
            }

            // if we have enough time remaining, increase the depth limit
            if (percentRemaining > _config.PercentTimeLeftToIncrementDepthLimit)
            {
                // if we didn't do the search async, just increase depth
                if (asyncTimeElapsed == null)
                {
                    _config.DepthLimit++;
                }
                else
                {
                    // only increase depth if async time was decent
                    var asyncPercentTimeLeft = (_config.MoveTimeout.TotalMilliseconds - asyncTimeElapsed.Value.TotalMilliseconds) / _config.MoveTimeout.TotalMilliseconds;
                    if (asyncPercentTimeLeft > _config.PercentTimeLeftToIncrementDepthLimit/2)
                    {
                        _config.DepthLimit++;
                    }
                }
            }

            // if we timed out, decrease depth limit so we stop shooting ourself in the foot
            if (timedOut)
            {
                _config.DepthLimit--;
            }

            var emptySpaces = board.GetEmptySpacesRemaining();

            // figure out where we are in the game
            if (_config.GameMode == GameMode.Beginning)
            {
                if (emptySpaces <= 40)
                {
                    _config.DepthLimit--;
                    _config.GameMode = GameMode.Middle;
                }
            }
            else if (_config.GameMode == GameMode.Middle && !timedOut)
            {
                // find out what our areas look like
                var boardPostMove = board.Copy().Move(bestMoveResult.Move);
                var myArea = OpenAreaHeuristic.GetOpenArea(boardPostMove, boardPostMove.MyPlayer);
                var oppArea = OpenAreaHeuristic.GetOpenArea(boardPostMove, boardPostMove.OpponentPlayer);

                // if we are walled off, switch to end game
                if (myArea.All(x => !oppArea.Contains(x)))
                {
                    _isWalledOff = true;
                    _config.GameMode = GameMode.End;
                }
                else // we aren't walled off
                {
                    // if it's time for end game, switch and max out depth
                    if (emptySpaces <= 28)
                    {
                        _config.DepthLimit = 30;
                        _config.GameMode = GameMode.End;
                    }
                    // if we think we're going to lose, try to find our best move b/c alpha-beta will pick a random one
                    else if (bestMoveResult.Score == int.MinValue)
                    {
                        var tasksByDepthLimit = new Dictionary<int, AsyncSearchTask>();

                        // simultaneously search at smaller depths to get our best move that isn't -infinity
                        for (var newDepthLimit = _config.DepthLimit - 1; newDepthLimit > _config.DepthLimit/2; newDepthLimit--)
                        {
                            var newConfig = new SearchConfig(_config) { DepthLimit = newDepthLimit };

                            // new task with timeout set at our remaining time
                            var task = new AsyncSearchTask(_config.MoveTimeout.Subtract(elapsed));

                            task.BestMoveTask = Task.Factory.StartNew(() =>
                            {
                                task.Timer.StartTimer();
                                var result = MoveGetter().BestMove(board, newConfig, task.Timer, task.CancelSource.Token);
                                task.Timer.StopTimer();
                                return result;
                            }, task.CancelSource.Token);

                            tasksByDepthLimit[newDepthLimit] = task;
                        }

                        foreach (var kvp in tasksByDepthLimit.OrderBy(x => x.Key))
                        {
                            var newBestMove = kvp.Value.BestMoveTask.Result;

                            // if we think we're going to lose or we timed out, cancel all deeper tasks because they will also think we're going to lose
                            if (newBestMove.Score == int.MinValue || kvp.Value.Timer.Timeout())
                            {
                                var kvpClosure = kvp;
                                foreach (var task in tasksByDepthLimit.Where(x => x.Key > kvpClosure.Key).Select(x => x.Value).Where(x => !x.BestMoveTask.IsCompleted))
                                {
                                    task.CancelSource.Cancel();
                                }
                                break;
                            }

                            // if we found a better move, use it
                            if (newBestMove.Score > bestMoveResult.Score)
                            {
                                bestMoveResult = newBestMove;
                            }
                        }
                    }
                }
            }

            return bestMoveResult.Move;
        }
Exemple #4
0
        public void PreComputeNextMove(Board board)
        {
            // cancel any tasks that are running from last round
            foreach (var task in _tasksByOpponentMove.Select(x => x.Value).Where(x => !x.BestMoveTask.IsCompleted))
            {
                task.CancelSource.Cancel();
            }

            // remove all saved tasks
            _tasksByOpponentMove.Clear();

            // for every possible opponent move, pretend like the opponent picks it and start computing my response
            foreach (var move in board.GetValidMoves())
            {
                var newBoard = board.Copy().Move(move);

                var task = new AsyncSearchTask(TimeSpan.MaxValue);

                task.BestMoveTask = Task.Factory.StartNew(() =>
                    {
                        task.Timer.StartTimer();
                        var result = MoveGetter().BestMove(newBoard, _config, MoveTimer.I, task.CancelSource.Token);
                        task.Timer.StopTimer();
                        return result;
                    }, task.CancelSource.Token);

                _tasksByOpponentMove[move] = task;
            }
        }