// Recursive part of iterative deepening
private Tuple<Move, bool> RecursiveIterativeDeepening(State state, int depth, double alpha, double beta, int timeLimit, Stopwatch timer, Deck deck)
{
Move bestMove;
if (depth == 0 || state.IsGameOver())
{
if (state.Player == GameEngine.PLAYER)
{
bestMove = new PlayerMove(); // default constructor creates dummy action
bestMove.Score = AI.Evaluate(state);
return new Tuple<Move, Boolean>(bestMove, true);
}
else if (state.Player == GameEngine.COMPUTER)
{
bestMove = new ComputerMove(); // default constructor creates dummy action
bestMove.Score = AI.Evaluate(state);
return new Tuple<Move, Boolean>(bestMove, true);
}
else
{
throw new Exception();
}
}
if (state.Player == GameEngine.PLAYER){
bestMove = new PlayerMove();
double highestScore = Double.MinValue, currentScore = Double.MinValue;
List<Move> moves = state.GetAllMoves();
foreach (Move move in moves)
{
State resultingState = state.ApplyMove(move);
currentScore = RecursiveIterativeDeepening(resultingState, depth - 1, alpha, beta, timeLimit, timer, deck).Item1.Score;
if (currentScore > highestScore)
{
highestScore = currentScore;
bestMove = (PlayerMove)move;
}
alpha = Math.Max(alpha, highestScore);
if (beta <= alpha)
break;
if (timer.ElapsedMilliseconds > timeLimit)
{
bestMove.Score = highestScore;
return new Tuple<Move, Boolean>(bestMove, false); // recursion not completed, return false
}
}
bestMove.Score = highestScore;
return new Tuple<Move, Boolean>(bestMove, true);
}
else
{
bestMove = new ComputerMove();
double lowestScore = Double.MaxValue, currentScore = Double.MaxValue;
List<Move> moves = null;
if (depth == definedDepth - 1)
{
int nextCard = game.nextCard;
moves = state.GetAllComputerMoves(nextCard);
}
else
{
if (deck.IsEmpty()) deck = new Deck();
moves = state.GetAllComputerMoves(deck);
}
foreach (Move move in moves)
{
deck.Remove(((ComputerMove)move).Card);
State resultingState = state.ApplyMove(move);
currentScore = RecursiveIterativeDeepening(resultingState, depth - 1, alpha, beta, timeLimit, timer, deck).Item1.Score;
if (currentScore < lowestScore)
{
lowestScore = currentScore;
bestMove = (ComputerMove)move;
}
beta = Math.Min(beta, lowestScore);
if (beta <= alpha)
break;
deck.Add(((ComputerMove)move).Card);
if (timer.ElapsedMilliseconds > timeLimit)
{
bestMove.Score = lowestScore;
return new Tuple<Move, Boolean>(bestMove, false); // recursion not completed, return false
}
}
bestMove.Score = lowestScore;
return new Tuple<Move, Boolean>(bestMove, true);
}
}
// MIN part of Minimax
Move Min(State state, int depth, double alpha, double beta)
{
ComputerMove bestMove = new ComputerMove();
double lowestScore = Double.MaxValue, currentScore = Double.MaxValue;
List<Move> moves = null;
if (depth == definedDepth - 1)
{
int nextCard = game.nextCard;
moves = state.GetAllComputerMoves(nextCard);
}
else
{
if (deck.IsEmpty()) deck = new Deck();
moves = state.GetAllComputerMoves(deck);
}
foreach (Move move in moves)
{
deck.Remove(((ComputerMove)move).Card);
State resultingState = state.ApplyMove(move);
currentScore = MinimaxAlgorithm(resultingState, depth - 1, alpha, beta, deck).Score;
if (currentScore < lowestScore)
{
lowestScore = currentScore;
bestMove = (ComputerMove)move;
}
beta = Math.Min(beta, lowestScore);
if (beta <= alpha)
break;
deck.Add(((ComputerMove)move).Card);
}
bestMove.Score = lowestScore;
return bestMove;
}
// Runs an entire game using a parallelized version of iterative deepening minimax
private Move ParallelIterativeDeepening(State state, int timeLimit, Deck deck)
{
Move bestMove = new PlayerMove();
List<Move> moves = state.GetMoves(deck);
ConcurrentBag<Tuple<double, Move>> scores = new ConcurrentBag<Tuple<double, Move>>();
if (moves.Count == 0)
{
// game over
return bestMove;
}
// create the resulting states before starting the threads
List<State> resultingStates = new List<State>();
foreach (Move move in moves)
{
State resultingState = state.ApplyMove(move);
resultingStates.Add(resultingState);
}
Parallel.ForEach(resultingStates, resultingState =>
{
double score = IterativeDeepening(resultingState, timeLimit, deck.Clone()).Score;
scores.Add(new Tuple<double, Move>(score, resultingState.GeneratingMove));
});
// find the best score
double highestScore = Double.MinValue;
foreach (Tuple<double, Move> score in scores)
{
PlayerMove move = (PlayerMove)score.Item2;
if (score.Item1 > highestScore)
{
highestScore = score.Item1;
bestMove = score.Item2;
}
}
return bestMove;
}
// MAX part of Minimax
Move Max(State state, int depth, double alpha, double beta)
{
PlayerMove bestMove = new PlayerMove();
double highestScore = Double.MinValue, currentScore = Double.MinValue;
List<Move> moves = state.GetAllMoves();
foreach (Move move in moves)
{
State resultingState = state.ApplyMove(move);
currentScore = MinimaxAlgorithm(resultingState, depth - 1, alpha, beta, deck).Score;
if (currentScore > highestScore)
{
highestScore = currentScore;
bestMove = (PlayerMove)move;
}
alpha = Math.Max(alpha, highestScore);
if (beta <= alpha)
break;
}
bestMove.Score = highestScore;
return bestMove;
}
