private void RunInteractiveGames(int numGames, ITicTacToePlayer player1, ITicTacToePlayer player2)
{
for (var i = 0; i < numGames; i++)
{
RunSingleGame(player1, player2);
}
}
private int EvaluateMove(TicTacToeBoard board, ITicTacToePlayer currentPlayer, ITicTacToePlayer otherPlayer)
{
if ((new EquationWinEvaluator()).HasPlayerWon(currentPlayer, board))
return currentPlayer == this ? Win : Loss;
return Draw;
}
private ScoreTally PlayAllPossibleGames(TicTacToeBoard currentBoard, ITicTacToePlayer player, ITicTacToePlayer opponent)
{
var tally = ScoreTally.Start;
var position = player.PlayTurn(currentBoard);
var nextBoard = currentBoard.UpdateBoard(position, player);
if (new BitMaskWinEvaluator().HasPlayerWon(player, nextBoard))
return ScoreTally.Win;
if (nextBoard.IsComplete)
return ScoreTally.Draw;
foreach (var boardPosition in nextBoard.VacantSquares)
{
var possibleMove = nextBoard.UpdateBoard(boardPosition, opponent);
if (new BitMaskWinEvaluator().HasPlayerWon(opponent, possibleMove))
return ScoreTally.Loss;
if (possibleMove.IsComplete)
return ScoreTally.Draw;
var result = PlayAllPossibleGames(possibleMove, player, opponent);
tally = result + tally;
}
return tally;
}
public string NameForPlayer(ITicTacToePlayer player)
{
if (player == _game.Naughts)
return "Naughts";
if (player == _game.Crosses)
return "Crosses";
return null;
}
public string SymbolForPlayer(ITicTacToePlayer player)
{
if (player == _game.Naughts)
return "O";
if (player == _game.Crosses)
return "X";
return " ";
}
public TicTacToeGame(Board board, ITicTacToePlayer player1, ITicTacToePlayer player2)
{
Board = board;
_player1 = player1;
_player2 = player2;
ThrowIfPlayersInvalid();
}
public TicTacToeGame(ITicTacToePlayer naughts, ITicTacToePlayer crosses)
{
Naughts = naughts;
Crosses = crosses;
_board = new TicTacToeBoard();
CurrentPlayer = Naughts;
}
public void Setup()
{
_board = Board.CreateEmptyBoard();
_player1 = Substitute.For <ITicTacToePlayer>();
_player2 = Substitute.For <ITicTacToePlayer>();
_player1.Tile.Returns(BoardTile.X);
_player2.Tile.Returns(BoardTile.O);
_game = new TicTacToeGame(_board, _player1, _player2);
}
public void RenderStart(ITicTacToePlayer player1, ITicTacToePlayer player2, ITicTacToeBoard ticTacToeBoard)
{
Console.WriteLine("");
Console.WriteLine("New game started");
Console.WriteLine("Player 1 is {0} and playing {1}", player1.Name, player1.Piece.ToConsoleString());
Console.WriteLine("Player 2 is {0} and playing {1}", player2.Name, player2.Piece.ToConsoleString());
Console.WriteLine("");
RenderBoard(ticTacToeBoard);
}
public bool HasPlayerWon(ITicTacToePlayer currentPlayer, TicTacToeBoard board)
{
var playerMask = GetPositionMaskForPlayer(currentPlayer, board);
foreach (var win in _wins)
{
if ((win & playerMask) == win)
return true;
}
return false;
}
private void RunHeadless(int numGames, ITicTacToePlayer player1, ITicTacToePlayer player2)
{
var runner = new HeadlessRunner(player1, player2);
runner.PlayGames(numGames);
var totalXWins = runner.NumberOfWins(BoardTile.X);
var totalOWins = runner.NumberOfWins(BoardTile.O);
Print($"After {runner.NumberOfGames} games, x wins, o wins: {totalXWins}, {totalOWins}");
}
private static TicTacToeGame RunSingleGame(ITicTacToePlayer player1, ITicTacToePlayer player2)
{
var game = new TicTacToeGame(Board.CreateEmptyBoard(), player1, player2);
while (!game.IsFinished())
{
game.DoNextTurn();
}
return(game);
}
public bool HasPlayerWon(ITicTacToePlayer currentPlayer, TicTacToeBoard ticTacToeBoard)
{
var winningLines = new WinningLinesGenerator(ticTacToeBoard.Boundries, ticTacToeBoard).PossibleWins();
foreach (var winningLine in winningLines)
{
if (PlayerHasWon(currentPlayer, winningLine))
return true;
}
return false;
}
private int GetPositionMaskForPlayer(ITicTacToePlayer currentPlayer, TicTacToeBoard board)
{
var positionMask = 0;
var gridPosition = 1;
foreach (var playerOnPosition in board)
{
if (playerOnPosition == currentPlayer)
positionMask |= 1 << (board.Boundries.TotalNumberOfSquares - gridPosition);
gridPosition++;
}
return positionMask;
}
public void Setup()
{
_opponent = Substitute.For <ITicTacToePlayer>();
_opponent.Tile.Returns(BoardTile.O);
_opponent.GetAction(Arg.Any <Board>())
.Returns(new TicTacToeAction
{
Position = 0,
Tile = BoardTile.O
});
_env = new TicTacToeEnvironment(_opponent);
}
public IGameResult GetGameResult(
ITicTacToeBoard ticTacToeBoard,
ITicTacToePlayer player1,
ITicTacToePlayer player2
)
{
var cells = ticTacToeBoard.Cells();
var diagonal = IsWinOnDiagonal(cells);
if (diagonal != TicTacToePiece.None)
{
return new TicTacToeGameResult()
{
IsDraw = false,
Winner = diagonal == player1.Piece ? player1 : player2,
Loser = diagonal == player1.Piece ? player2 : player1,
};
}
var horizontal = IsWinOnHorizontal(cells);
if (horizontal != TicTacToePiece.None)
{
return new TicTacToeGameResult()
{
IsDraw = false,
Winner = horizontal == player1.Piece ? player1 : player2,
Loser = horizontal == player1.Piece ? player2 : player1,
};
}
var vertical = IsWinOnVertical(cells);
if (vertical != TicTacToePiece.None)
{
return new TicTacToeGameResult()
{
IsDraw = false,
Winner = vertical == player1.Piece ? player1 : player2,
Loser = vertical == player1.Piece ? player2 : player1,
};
}
if (IsDrawn(ticTacToeBoard))
{
return new TicTacToeGameResult()
{
IsDraw = true
};
}
throw new Exception("No valid result found");
}
public TicTacToeGame(
ITicTacToeBoard ticTacToeBoard,
ITicTacToePlayer player1,
ITicTacToePlayer player2,
IGameJudge gameJudge,
IGameRenderer gameRenderer,
IGamePauser gamePauser
)
{
_ticTacToeBoard = ticTacToeBoard;
_player1 = player1;
_player2 = player2;
_gameJudge = gameJudge;
_gameRenderer = gameRenderer;
_gamePauser = gamePauser;
}
public GameBuilder NaughtsWins()
{
_naughts = new PrepopulatedPlayerStub(new[]
{
new BoardPosition(1, 1),
new BoardPosition(1, 2),
new BoardPosition(1, 3),
});
_crosses = new PrepopulatedPlayerStub(new[]
{
new BoardPosition(2, 1),
new BoardPosition(2, 2),
});
return this;
}
public void PlayTurn()
{
if(IsFinished)
throw new GameOverException();
// this design isn't perfect because it doesn't feed back to the
// player if they have made an invalid move
var position = CurrentPlayer.PlayTurn(_board);
if(_board[position] == null)
{
_board = _board.UpdateBoard(position, CurrentPlayer);
if (HasMadeWinningMove(CurrentPlayer))
Winner = CurrentPlayer;
CurrentPlayer = CurrentPlayer == Naughts ? Crosses : Naughts;
}
}
public TicTacToeGameTests()
{
TicTacToeBoard = Substitute.For<ITicTacToeBoard>();
Player1 = Substitute.For<ITicTacToePlayer>();
Player2 = Substitute.For<ITicTacToePlayer>();
GameJudge = Substitute.For<IGameJudge>();
GameRenderer = Substitute.For<IGameRenderer>();
GamePauser = Substitute.For<IGamePauser>();
Sut = new TicTacToeGame(
TicTacToeBoard,
Player1,
Player2,
GameJudge,
GameRenderer,
GamePauser
);
}
public void Play()
{
_ticTacToeBoard.Reset();
_gameRenderer.RenderStart(_player1, _player2, _ticTacToeBoard);
while (_gameJudge.IsGameInPlay(_ticTacToeBoard))
{
_gamePauser.Pause();
var player = GetNextPlayer();
player.TakeTurn(_ticTacToeBoard);
_lastTicTacToePlayerToPlay = player;
_gameRenderer.RenderBoard(_ticTacToeBoard);
}
var result = _gameJudge.GetGameResult(_ticTacToeBoard, _player1, _player2);
_gameRenderer.RenderResult(result);
}
private void RunSingleGame(ITicTacToePlayer player1, ITicTacToePlayer player2)
{
var game = new TicTacToeGame(Board.CreateEmptyBoard(), player1, player2);
while (!game.IsFinished())
{
Print(RenderBoard(game.Board));
game.DoNextTurn();
}
Print(RenderBoard(game.Board));
if (game.Winner().HasValue)
{
Print($"The winner is: {game.Winner()}!");
}
else
{
Print("Draw!");
}
}
public PlayerAgent(ITicTacToePlayer ticTacToePlayer)
{
_ticTacToePlayer = ticTacToePlayer;
}
private bool PlayerHasWon(ITicTacToePlayer currentPlayer, IEnumerable<ITicTacToePlayer> winningLine)
{
return winningLine.All(player => player == currentPlayer);
}
private bool HasMadeWinningMove(ITicTacToePlayer player)
{
var winEvaluator = new EquationWinEvaluator();
return winEvaluator.HasPlayerWon(player, _board);
}
public HeadlessRunner(ITicTacToePlayer player1, ITicTacToePlayer player2)
{
_player1 = player1;
_player2 = player2;
_winnerRecord = new List <BoardTile?>();
}
public void Train(ITicTacToePlayer opponent, int?numGamesLimit = null)
{
throw new NotImplementedException();
}
private bool IsFinalMove(TicTacToeBoard board, ITicTacToePlayer currentPlayer, ITicTacToePlayer otherPlayer)
{
return board.IsComplete || (new EquationWinEvaluator()).HasPlayerWon(currentPlayer, board);
}
public MiniMaxPlayer(ITicTacToePlayer opponent)
{
_opponent = opponent;
}
public TicTacToeEnvironment(ITicTacToePlayer opponent)
{
_opponent = opponent;
Reset();
}
