private static string UpdateUi(TicTacToeBoard board)
{
board.Display();
var userInput = Console.ReadLine();
return(userInput);
}
public void MainMethod()
{
board = new TicTacToeBoard();
Console.WriteLine("Hello! To play tic tac toe, when it is your turn, enter the index of where you want to play (0-8)");
Console.Read();
while (!board.IsFull() && !board.IsWinner(SquareType.X) && !board.IsWinner(SquareType.O))
{
DisplayBoardGrid();
Console.WriteLine("It is {0} turn.", currentTurn);
int move = promptForInt("Enter your index: ");
if (board.IsLegalMove(move))
board.MakeMove(move, currentTurn);
else
{
Console.WriteLine("Illegal Move! Press enter!");
Console.Read();
continue;
}
// Swap the turn
currentTurn = currentTurn == SquareType.X ? SquareType.O : SquareType.X;
}
DisplayBoardGrid();
if (board.IsFull())
Console.WriteLine("Tie! Board is full!");
else if (board.IsWinner(SquareType.X))
AccounceWinner(SquareType.X);
else if (board.IsWinner(SquareType.O))
AccounceWinner(SquareType.O);
else
Console.WriteLine("Something has gone wrong!");
}
public Game()
{
// initialize a new game board
theBoard = new TicTacToeBoard();
// choose the type of players
this.InitPlayers(this.players);
}
/// <summary>Command line method used by a human player to select a move.</summary>
/// <returns>Board index to move to.</returns>
public static ushort PromptForMove(TicTacToeBoard board, Piece.PieceValue token)
{
ushort i = 0;
do
{
Console.Write("Enter the location of your move: ");
i = Convert.ToUInt16(Console.ReadLine());
} while (i < 0 || i > 9);
return(i);
}
public override ushort Move(TicTacToeBoard currentBoard)
{
ushort chosenMove = 0;
do
{
// call the method used to determine the move
chosenMove = this.moveMethod(currentBoard, this.Token);
} while (currentBoard.At(chosenMove));
return(chosenMove);
}
// Constructs board based on passed board
public TicTacToeBoard(TicTacToeBoard otherBoard)
{
board = new int[3, 3];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
board[i, j] = otherBoard.GetBoard()[i, j];
}
}
}
/// <summary>
/// Plays the game.
/// </summary>
public void Play()
{
int move;
bool over = false;
Move currentPlayer = Move.X;
var board = new TicTacToeBoard();
// Print a greeting.
Console.WriteLine("xox Play Tic-Tac-Toe! xox" + Newline);
// Keep going until the game is deemed "over"
while (!over)
{
// Print the board.
Console.WriteLine(board.ToString());
Console.WriteLine("Player 1 => X, Player 2 => O");
// Ask the player to enter a square number
Console.Write("Enter Square [player " + PrintMove(currentPlayer) + "]: ");
var playersMove = Console.ReadLine();
Console.Write(Newline);
// Process player's move
if (int.TryParse(playersMove, out move))
{
try
{
// Attempt to make the move, then change players.
board.MakeMove(move, currentPlayer);
currentPlayer = FlipCurrentPlayer(currentPlayer);
}
catch (Exception e)
{
Console.WriteLine(e.Message + Newline);
}
}
else
{
// Just in case someone doesn't give us an int.
Console.WriteLine("Unable to parse your move, please try again." + Newline);
}
// A little magic here. If the board has a winner set then we're done.
if (board.Winner != null)
{
this.PrintEndGame(board);
over = true;
}
}
}
/// <summary>
/// Plays the game.
/// </summary>
public void Play()
{
int move;
bool over = false;
Move currentPlayer = Move.X;
var board = new TicTacToeBoard();
// Print a greeting.
Console.WriteLine("xox Play Tic-Tac-Toe! xox" + Newline);
// Keep going until the game is deemed "over"
while (!over)
{
// Print the board.
Console.WriteLine(board.ToString());
Console.WriteLine("Player 1 => X, Player 2 => O");
// Ask the player to enter a square number
Console.Write("Enter Square [player " + PrintMove(currentPlayer) + "]: ");
var playersMove = Console.ReadLine();
Console.Write(Newline);
// Process player's move
if (int.TryParse(playersMove, out move))
{
try
{
// Attempt to make the move, then change players.
board.MakeMove(move, currentPlayer);
currentPlayer = FlipCurrentPlayer(currentPlayer);
}
catch (Exception e)
{
Console.WriteLine(e.Message + Newline);
}
}
else
{
// Just in case someone doesn't give us an int.
Console.WriteLine("Unable to parse your move, please try again." + Newline);
}
// A little magic here. If the board has a winner set then we're done.
if (board.Winner != null)
{
this.PrintEndGame(board);
over = true;
}
}
}
public override ushort Move(TicTacToeBoard currentBoard)
{
// computer's algorithm will modify the board so create a copy to work on
// TicTacToeBoard tempBoard = new TicTacToeBoard(currentBoard);
// call the method used to determine the move
ushort chosenMove = this.moveMethod(currentBoard, this.Token);
while (currentBoard.At(chosenMove))
{
chosenMove = this.moveMethod(currentBoard, this.Token);
}
return(chosenMove);
}
private static void GameFinished(GameState result, TicTacToeBoard board)
{
if (result == GameState.XWins)
{
Console.WriteLine("X you badass!!");
}
else if (result == GameState.OWins)
{
Console.WriteLine("O is dope!!!");
}
else
{
Console.WriteLine("This game is rigged!");
}
}
public int Minimax(bool isMax, int depth)
{
if (TicTacToeBoard.IsGameOver())
{
return(TicTacToeBoard.EvaluateWinningScore(depth));
}
var Scores = new List <int>();
var availableMoves = TicTacToeBoard.GetAvailablePositions();
//Calculate MIN and MAX scores
if (isMax)
{
foreach (var move in availableMoves)
{
// Make a move from the available
// user made move, now compo makes
TicTacToeBoard.Board[move.Item1, move.Item2] = MaxPlayer;
// Add the score of the that board
Scores.Add(Minimax(!isMax, depth++));
TicTacToeBoard.Board[move.Item1, move.Item2] = TicTacToeBoard.Player.E;
}
int maxScore = Scores.Max();
return(maxScore);
}
else
{
foreach (var move in availableMoves)
{
// Make a move from the available
// user made move, now compo makes
TicTacToeBoard.Board[move.Item1, move.Item2] = MinPlayer;
// Add the score of the that board
Scores.Add(Minimax(!isMax, depth++));
TicTacToeBoard.Board[move.Item1, move.Item2] = TicTacToeBoard.Player.E;
}
int minScore = Scores.Min();
return(minScore);
}
}
public static void Main(string[] args)
{
/*1.Make board
* 2.Play
* 3.Check for winner
* 4.Check spaces left (if zero then draw)
* 5.Play again ...
* 6.Clear board
*/
var board = new TicTacToeBoard();
var game = new TicTacToeGame(board);
Console.WriteLine("Please play modafuckkers!! q to quit");
var userInput = UpdateUi(board);
while (userInput != "q")
{
if (int.TryParse(userInput, out var position))
{
try
{
var result = game.Play(position);
if (result != GameState.Continue)
{
GameFinished(result, board);
board.Clear();
Console.WriteLine("Please play modafuckkers!! q to quit");
}
}
catch (Exception e)
{
Console.WriteLine($"{e.Message}");
}
}
else
{
Console.WriteLine("Please enter a number from 1 to 9");
}
userInput = UpdateUi(board);
}
}
/// <summary>
/// Prints the end game.
/// </summary>
/// <param name="board">
/// The board to print.
/// </param>
private void PrintEndGame(TicTacToeBoard board)
{
switch (board.Winner.Value)
{
case Move.X:
case Move.O:
Console.WriteLine("Congratulations, we have a winner: " + PrintMove(board.Winner.Value) + "!" + Newline);
break;
case Move.Undefined:
Console.WriteLine("And we have a tie!" + Newline);
break;
}
Console.WriteLine(board.ToString() + Newline);
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
protected static bool ImmediateWin(Piece inPiece, TicTacToeBoard inBoard, ref ushort bestMove)
{
for (ushort i = 0; i < inBoard.Length; ++i)
{
// create a clone of the current board
TicTacToeBoard tempBoard = new TicTacToeBoard(inBoard);
// place a piece on each sqaure in the new board
tempBoard.Place(inPiece, i);
// and see if it results in an immediate win
if (tempBoard.Win(inPiece.Value))
{
bestMove = i;
return(true);
}
}
return(false);
}
protected static bool ImmediateBlock(Piece inPiece, TicTacToeBoard inBoard, ref ushort bestMove)
{
Piece p = (inPiece.Value == Piece.PieceValue.X) ? new Piece(Piece.PieceValue.X) : new Piece(Piece.PieceValue.O);
for (ushort i = 0; i < inBoard.Length; ++i)
{
// create a clone of the current board
TicTacToeBoard tempBoard = new TicTacToeBoard(inBoard);
tempBoard.Place(p, i);
if (tempBoard.Win(p.Value))
{
bestMove = i;
return(true);
}
}
return(false);
}
public static ushort MinMaxMove(TicTacToeBoard board, Piece.PieceValue token)
{
// computer always plays the center square if it is available
if (!board.At(4))
{
return(4);
}
// computer's 2nd move should be a corner if computer went first
// computer's 1st move should be a corner if the center is taken
// really not the best strategy
if ((board.Moves == 1 && board.At(4)) || board.Moves == 2)
{
return((TicTacToeBoard.Corners)[Computer.randNum.Next(0, TicTacToeBoard.Corners.Length - 1)]);
}
// start with recommended move
ushort aMove = 4;
// use MinMax strategy to find the next move
MoveStrategy strategy = Computer.LookAhead(new Piece(token), new TicTacToeBoard(board), ref aMove);
return(aMove);
}
private void CreateGameBoard()
{
gameBoard = new TicTacToeBoard();
}
public void TakeATurn(TicTacToeBoard board)
{
board.DisplayBoard();
bool validMove = false;
while (!validMove)
{
Console.WriteLine("Please make a move (1-9):");
int move;
if (Int32.TryParse(Console.ReadLine(), out move))
{
if (board.GetMove(move) == 0)
{
board.MakeMove(move, 2);
validMove = true;
}
else
{
Console.WriteLine("Invalid move. Please try again.");
}
}
else
{
Console.WriteLine("Invalid syntax. Please try again.");
}
}
}
public void PlayAGame()
{
TicTacToeBot ai = new TicTacToeBot();
TicTacToeBoard board = new TicTacToeBoard();
Random rng = new Random();
bool yourTurn;
Console.WriteLine("Randomizing who starts...");
if (rng.Next(2) == 0)
{
Console.WriteLine("You start!");
yourTurn = true;
}
else
{
Console.WriteLine("AI starts.");
yourTurn = false;
}
int winner = 0;
bool draw = false;
while (winner == 0 && !draw)
{
if (yourTurn)
{
TakeATurn(board);
}
else
{
board.MakeMove(ai.GetBestMove(board), 1);
}
yourTurn = !yourTurn;
winner = board.CheckForWin();
draw = board.CheckForDraw();
}
board.DisplayBoard();
if (winner == 1)
{
Console.WriteLine("AI wins.");
}
else if (winner == 2)
{
Console.WriteLine("You win!");
}
else
{
Console.WriteLine("Draw game.");
}
}
public double AlphaBeta(TicTacToeBoard oldBoard, double alpha, double beta, int player)
{
if (oldBoard.CheckForWin() != 0 || oldBoard.CheckForDraw())
{
return Score(oldBoard);
}
if (player == 1)
{
double val = -10000.0;
for (int i = 1; i <= 9; i++)
{
if (oldBoard.GetMove(i) == 0)
{
TicTacToeBoard newBoard = new TicTacToeBoard(oldBoard);
newBoard.MakeMove(i, player);
val = Math.Max(val, gamma * AlphaBeta(newBoard, alpha, beta, 2));
alpha = Math.Max(alpha, val);
if (beta <= alpha) break;
}
}
return alpha;
}
else
{
double val = 10000.0;
for (int i = 1; i <= 9; i++)
{
if (oldBoard.GetMove(i) == 0)
{
TicTacToeBoard newBoard = new TicTacToeBoard(oldBoard);
newBoard.MakeMove(i, player);
val = Math.Min(val, gamma * AlphaBeta(newBoard, alpha, beta, 1));
beta = Math.Min(val, beta);
if (beta <= alpha) break;
}
}
return beta;
}
}
public int GetBestMove(TicTacToeBoard board)
{
double max = -100000.0;
int bestMoveSoFar = 0;
for (int i = 1; i <= 9; i++)
{
if (board.GetMove(i) == 0)
{
TicTacToeBoard testBoard = new TicTacToeBoard(board);
testBoard.MakeMove(i, 1);
double moveScore = AlphaBeta(testBoard, -10000.0, 10000.0, 2);
if (moveScore > max)
{
max = moveScore;
bestMoveSoFar = i;
}
}
}
return bestMoveSoFar;
}
public double Score(TicTacToeBoard board)
{
int winner = board.CheckForWin();
if (winner == 1)
{
return 10.0;
}
else if (winner == 2)
{
return -10.0;
}
else
{
return 0.0;
}
}
/// <summary>
/// Prints the end game.
/// </summary>
/// <param name="board">
/// The board to print.
/// </param>
private void PrintEndGame(TicTacToeBoard board)
{
switch(board.Winner.Value) {
case Move.X:
case Move.O:
Console.WriteLine("Congratulations, we have a winner: " + PrintMove(board.Winner.Value) + "!" + Newline);
break;
case Move.Undefined:
Console.WriteLine("And we have a tie!" + Newline);
break;
}
Console.WriteLine(board.ToString() + Newline);
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
/// <summary>Clone a TicTacToe board from another instance of a board.</summary>
/// <param name="b">Board to create a deep copy of.</param>
public TicTacToeBoard(TicTacToeBoard b) : base(b)
{
}
/// <summary>Computer picks a board move randomly.</summary>
/// <returns>Index of board location to move to.</returns>
public static ushort RandomMove(TicTacToeBoard board, Piece.PieceValue token)
{
return(Convert.ToUInt16(Computer.randNum.Next(0, 8)));
}
protected static MoveStrategy LookAhead(Piece inPiece, TicTacToeBoard inBoard, ref ushort bestMove)
{
// unused dummy value to seend the algorithm
ushort aDummy = 0;
// temporary strategy
MoveStrategy aResponse;
// the strategy to return
MoveStrategy outValue = (inPiece.Value == Piece.PieceValue.X) ? MoveStrategy.OWin - 1 : MoveStrategy.XWin + 1;
// first check to see if the game is a draw
if (inBoard.Full())
{
outValue = MoveStrategy.Draw;
}
// return any move that results in an immediate win
else if (Computer.ImmediateWin(inPiece, inBoard, ref bestMove))
{
outValue = (inPiece.Value == Piece.PieceValue.X) ? MoveStrategy.XWin : MoveStrategy.OWin;
}
// return any move that will result in blocking the other player from an immediate win on his next turn
else if (Computer.ImmediateBlock(inPiece, inBoard, ref bestMove))
{
outValue = (inPiece.Value == Piece.PieceValue.X) ? MoveStrategy.XBlock : MoveStrategy.OBlock;
}
// no immediate wins so look for a promising move
else
{
for (ushort i = 0; i < inBoard.Length; ++i)
{
if (!inBoard.At(i))
{
inBoard.Place(inPiece, i);
// swap pieces and go down a move
Piece aPiece = (inPiece.Value == Piece.PieceValue.X) ? new Piece(Piece.PieceValue.O) : new Piece(Piece.PieceValue.X);
// call look ahead recursively with a copy of the board each time
aResponse = LookAhead(aPiece, new TicTacToeBoard(inBoard), ref aDummy);
// determine the best move
switch (inPiece.Value)
{
case Piece.PieceValue.X:
if (aResponse > outValue)
{
outValue = aResponse;
bestMove = i;
}
break;
case Piece.PieceValue.O:
if (aResponse < outValue)
{
outValue = aResponse;
bestMove = i;
}
break;
default:
break;
} // end switch
} // end if
} // end for loop
} // end else
// return the best move strategy
return(outValue);
}
public void Play()
{
Console.WriteLine("Starting Tic-Tac-Toe game...");
Console.WriteLine("Choose a position on the board");
// The scores for each round
// Hard coded
MaxPlayer = TicTacToeBoard.Player.O;
MinPlayer = TicTacToeBoard.Player.X;
while (!TicTacToeBoard.IsFull())
{
var scores = new List <int>();
string humanMove = Console.ReadLine();
int row = Convert.ToInt32(humanMove.Split(',')[0]);
int column = Convert.ToInt32(humanMove.Split(',')[1]);
if (!TicTacToeBoard.IsValidCell(row, column) || !TicTacToeBoard.IsCellEmpty(row, column))
{
throw new ArgumentOutOfRangeException("Invalid positions.");
}
Console.WriteLine("\n");
TicTacToeBoard.Board[row, column] = TicTacToeBoard.Player.X;
TicTacToeBoard.Print();
Console.WriteLine("\n");
var availableMoves = TicTacToeBoard.GetAvailablePositions();
foreach (var currMove in availableMoves)
{
TicTacToeBoard.Board[currMove.Item1, currMove.Item2] = MaxPlayer;
int minimaxScore = Minimax(false, 0);
scores.Add(minimaxScore);
TicTacToeBoard.Board[currMove.Item1, currMove.Item2] = TicTacToeBoard.Player.E;
}
Console.WriteLine();
// User moved (min) -> Its computers move (should be max)
// For each avaiable move, call minimax
var index = scores.FindIndex(score => score == scores.Max());
if (index != -1)
{
var move = availableMoves[index];
TicTacToeBoard.Board[move.Item1, move.Item2] = TicTacToeBoard.Player.O;
TicTacToeBoard.Print();
}
string winner = TicTacToeBoard.HasWinner();
if (winner == "X")
{
Console.WriteLine("You win!");
break;
}
else if (winner == "O")
{
Console.WriteLine("Computer wins!");
break;
}
else if (winner == "-")
{
Console.WriteLine("It is a draw game!");
break;
}
}
}
public GameBoard()
{
_ticTacToeBoard = new TicTacToeBoard(3, 3, Symbol.Empty);
CurrentGameBoard = _ticTacToeBoard.GameBoard;
}
