Add AI to Tic Tac Toe

[ozamsey10]

Hey,
I need to make it so that my Tic tac toe board is against the computer rather than against another person so can anyone help me with how I should edit my code? I will be adding more to the switch statement in due time.

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

char board1[3][3] = { '1','2','3','4','5','6','7','8','9' };
char player = 'X';
void draw1()
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << board1[i][j] << " | ";
		}
		cout << endl;
	}
	cout << endl;
}
void input1()
{
	int a;
	cout << "Press number you want to input: ";
	cin >> a;
	if (a == 1)
	{
		if (board1[0][0] == '1')
			board1[0][0] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 2)
	{
		if (board1[0][1] == '2')
			board1[0][1] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 3)
	{
		if (board1[0][2] == '3')
			board1[0][2] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 4)
	{
		if (board1[1][0] == '4')
			board1[1][0] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 5)
	{
		if (board1[1][1] == '5')
			board1[1][1] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 6)
	{
		if (board1[1][2] == '6')
			board1[1][2] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 7)
	{
		if (board1[2][0] == '7')
			board1[2][0] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 8)
	{
		if (board1[2][1] == '8')
			board1[2][1] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
	else if (a == 9)
	{
		if (board1[2][2] == '9')
			board1[2][2] = player;
		else
		{
			cout << "Field is in use!" << endl;
			input1();
		}
	}
}
void toggleplayer1()
{
	if (player == 'X')
		player = 'O';
	else
		player = 'X';
}
char win1()
{
	if (board1[0][0] == 'X'&&board1[0][1] == 'X'&&board1[0][2] == 'X')//horizontal
		return 'X';
	if (board1[1][0] == 'X'&&board1[1][1] == 'X'&&board1[1][2] == 'X')//horizontal
		return 'X';
	if (board1[2][0] == 'X'&&board1[2][1] == 'X'&&board1[2][2] == 'X')//horizontal
		return 'X';
	if (board1[0][0] == 'X'&&board1[1][1] == 'X'&&board1[2][2] == 'X')//diaganol
		return 'X';
	if (board1[2][0] == 'X'&&board1[1][1] == 'X'&&board1[0][2] == 'X')//diaganol
		return 'X';
	if (board1[0][0] == 'X'&&board1[1][0] == 'X'&&board1[2][0] == 'X')//vertical
		return 'X';
	if (board1[0][1] == 'X'&&board1[1][1] == 'X'&&board1[2][1] == 'X')//vertical
		return 'X';
	if (board1[0][2] == 'X'&&board1[1][2] == 'X'&&board1[2][2] == 'X')//vertical
		return 'X';
	//s
	if (board1[0][0] == 'O'&&board1[0][1] == 'O'&&board1[0][2] == 'O')//horizontal
		return 'O';
	if (board1[1][0] == 'O'&&board1[1][1] == 'O'&&board1[1][2] == 'O')//horizontal
		return 'O';
	if (board1[2][0] == 'O'&&board1[2][1] == 'O'&&board1[2][2] == 'O')//horizontal
		return 'O';
	if (board1[0][0] == 'O'&&board1[1][1] == 'O'&&board1[2][2] == 'O')//diaganol
		return 'O';
	if (board1[2][0] == 'O'&&board1[1][1] == 'O'&&board1[0][2] == 'O')//diaganol
		return 'O';
	if (board1[0][0] == 'O'&&board1[1][0] == 'O'&&board1[2][0] == 'O')//vertical
		return 'O';
	if (board1[0][1] == 'O'&&board1[1][1] == 'O'&&board1[2][1] == 'O')//vertical
		return 'O';
	if (board1[0][2] == 'O'&&board1[1][2] == 'O'&&board1[2][2] == 'O')//vertical
		return 'O';

	return '/';

}
int main()
{
	bool movemade;
	int space;
	bool availability;
	int number;
	srand(time(NULL));
	number = rand() % 2;
	if (number == 0)
		player = 'X';
	else
		player = 'O';
	n = 0;
	int board = 0;
	while (1)
	{
		do
		{
			cout << "Choose Board:";
			cin >> board;
			draw1();
			switch (board)
			{
			case 1:
				draw1();
				if (win1() == 'X')
				{
					cout << "X wins board 1!" << endl;
				}
				else if (win1() == 'O')
				{
					cout << "O wins board 1!" << endl;
				}
				else if (win1() == '/' && n == 9)
					cout << "NO winner!" << endl;
				input1();
				toggleplayer1();
				break;

		} while (board != 2);
	}

	system("pause");
}

[tpb]

Just implement the strategy that you would use to play optimally. Google "tic tac toe winning strategy".

[Manga]

create a variable that will store the number of players. If it is 1 player create a check in your game loop for this value. At the right point in the game loop you can test the variable with something like...

if (numPlayers == 1 && player == 'O') {
cout << "it is the computer's turn!" << endl;

Once you get that working correctly you can start to implement AI strategy. You might start with random moves at first but gradually get more complex.

[jonnin]

TTT has a lot of repeated patterns that you mirror or rotate the board to match. These are called transposition tables. It turns out that a very small number of lookup tables will give you a solid base AI... you simply get the current position, match it, and that gives you the next best move. There are other ways to do it, but that one, while a little tedious, works great.

[icy1]

Also, try to make everything relative to the size of a side. I could change my side from 3 to 5, for example, and it'd still work.

Just hacked out something a lil dirty in the win checks, but appears to be working, to demonstrate a random AI movement and a different way to setup the drawing of the board.

To let comp go first, you'd comment out line 279 and uncomment 281, 282:
Running at https://repl.it/repls/LowestUtilizedDatabase

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cstdlib>
#include <ctime>
using namespace std;

string operator*(const string& s, const unsigned int n) {
    stringstream out;
    for (int x=1; x<=n; ++x)
        out << s;
    return out.str();
}

string operator*(const unsigned int n, const string& s) { return s * n; }


class TicTacToe
{
    
enum Move
{
    X,
    O
};
    
public:
    TicTacToe() :
        to_move_(Move::X),
        num_moves_(0),
        game_over_(false),
        winner_("No One")
    {
        empty_row_ = string(" ")*side_ + ("|" + string(" ")*side_)*(side_-1);
        space_ = string(" ")*(side_/2);
        divider_ = string("-")*(side_*side_ + side_-1);
        
        board_.reserve(side_);
        for (int x=1; x<=side_; ++x)
        {
            vector<string> vec;
            vec.reserve(side_);
            for (int y=1; y<=side_; ++y)
                vec.push_back(default_symbol_);
            board_.push_back(vec);
        }
    }
    
    
    
    void DrawRow(vector<string>& row)
    {
        for (int x=1; x<=side_/2; ++x)
        {
            cout << empty_row_ << endl;
        }
        for (int i=0; i<side_-1; ++i)
        {
            cout << space_ << row[i] << space_ << "|";
        }
        cout << space_ << row[side_-1] << endl;
        
        for (int x=1; x<=side_/2; ++x)
        {
            cout << empty_row_ << endl;
        }
    }

    // Draw the board
    void Draw()
    {
        for (int r=0; r<side_-1; ++r)
        {
            DrawRow(board_[r]);
            cout << divider_ << endl;
        }
        DrawRow(board_[side_-1]);
        cout << endl;
    }
    
    void CheckGameOver(int row, int col)
    {
        if (num_moves_ == side_*side_)
            game_over_ = true;
        
        // Check if it was a winning move
        string symbol = board_[row][col];
        
        // Check row
        bool found_winner = true;
        int down = col-1;
        int up = col+1;
        while (down>=0 || up<side_)
        {
            if (down>=0)
            {
                if (board_[row][down] != symbol)
                {
                    found_winner = false;
                    break;
                }
            }
            if (up<side_)
            {
                if (board_[row][up] != symbol)
                {
                    found_winner = false;
                    break;
                }
            }
            down--;
            up++;
        }
        if (found_winner)
        {
            game_over_ = true;
            winner_ = symbol;
            return;
        }
        
        // Check column
        found_winner = true;
        down = row-1;
        up = row+1;
        while (down>=0 || up<side_)
        {
            if (down>=0)
            {
                if (board_[down][col] != symbol)
                {
                    found_winner = false;
                    break;
                }
            }
            if (up<side_)
            {
                if (board_[up][col] != symbol)
                {
                    found_winner = false;
                    break;
                }
            }
            down--;
            up++;
        }
        if (found_winner)
        {
            game_over_ = true;
            winner_ = symbol;
            return;
        }
        
        // Diagonals check
        if (row==0 || col==0 || row==side_-1 || col==side_-1)
        {
            found_winner = true;
            for (int r=0, c=0; r<side_, c<side_; ++r, ++c)
            {
                if (board_[r][c] != symbol)
                {
                    found_winner = false;
                    break;
                }
            }
            if (found_winner)
            {
                game_over_ = true;
                winner_ = symbol;
                return;
            }
            
            found_winner = true;
            for (int r=side_-1, c=0; r>=0, c<side_; --r, ++c)
            {
                if (board_[r][c] != symbol)
                {
                    found_winner = false;
                    break;
                }
            }
            if (found_winner)
            {
                game_over_ = true;
                winner_ = symbol;
                return;
            }
        }
    }
    
    bool IsGameOver()
    {
        return game_over_;
    }
    
    string Winner()
    {
        return winner_;
    }
    
    // Prompt row and column of move
    void PromptPlayerMove()
    {
        if (game_over_)
            return;

        int row, col;
        
        while (true)
        {
            cout << "Row? ";
            cin >> row;
            cout << "Col? ";
            cin >> col;
        
            if (! (0<=row && row<side_ && 0<=col && col<side_) )
            {
                cout << "Input out of range (0-"<<(side_-1)<<")\n";
                continue;
            }
            if (board_[row][col]!=default_symbol_)
            {
                cout << "Square ["<<row<<", "<<col<<"] is taken!\n";
                continue;
            }
            break;
        }
        board_[row][col] = to_move_ == Move::X ? "X" : "O";
        num_moves_ += 1;
        CheckGameOver(row, col);
        to_move_ = (to_move_ == Move::X ? Move::O : Move::X);
    }
    
    void MakeCompMove()
    {
        if (game_over_)
            return;
            
        vector<pair<int,int>> avail_moves;
        for (int r=0; r<side_; ++r)
        {
            for (int c=0; c<side_; ++c)
            {
                if (board_[r][c]==default_symbol_)
                    avail_moves.emplace_back(r,c);
            }
        }
        
        srand(std::time(nullptr)); 
        pair<int,int> move = avail_moves[rand() % avail_moves.size()];
        board_[move.first][move.second] = to_move_ == Move::X ? "X" : "O";
        cout << "Comp plays to ("<<move.first<<", "<<move.second<<").\n";
        num_moves_ += 1;
        CheckGameOver(move.first, move.second);
        to_move_ = (to_move_ == Move::X ? Move::O : Move::X);
    }

private:
    vector<vector<string>> board_;
    const unsigned int side_ = 3;
    const string default_symbol_ = "˘";
    
    string empty_row_;
    string divider_;
    string space_;
    Move to_move_;
    int num_moves_;
    bool game_over_;
    string winner_;
};

int main()
{
    TicTacToe t;
  
    while (!t.IsGameOver())
    {
        t.Draw();
        t.PromptPlayerMove();
        t.MakeCompMove();
        //t.Draw();
        //t.PromptPlayerMove();
    }
    cout << "Game is over!  Winner is "<<t.Winner() << endl;
    t.Draw();
  
    return 0;
}