Question

in c++ :

Problem Domain:

The classic TicTacToe game alternatively place Xs and Os on a 3x3 grid. The winner is the first player to place 3 consecutive marks in a horizontal, vertical or diagonal row.

Understanding the Problem:

In this assignment, you will:
1) Create a tic tac toe board data structure.
2) Check for game over.
3) Clear the tic tac toe game for each game.
4) Display the tic tac toe board to screen.
5) Simulate playing a game until the board is full.

How to play this version of the game (main.cpp flow)

The program will call the start_game function with argument O or X to indicate first player and will keep track of the next player while players take turns marking the board until the board is full. This version of the game only plays one game.

Class Specifications

TicTacToe class does not have a constructor.
Member Functions and Member(variable) Specifications
+ = public
- = private

	Function/Data Member	Functionality of function or data member
+	bool game_over	No parameters 1) return check_board_full function return value
+	void start_game(string first_player)	1) First_player function argument value must be X or O 2) In function set player(private variable) to first_player function argument. 3) Call the clear_board function
+	void mark_board(int position)	1) Mark vector w position -1 equal to player 2) Call set_next_player private function
+	string get_player() const	Return the player value
+	void display_board() const	No parameters Iterate vector of strings pegs to Display a tic tac toe board in 3x 3 format
-	void set_next_player()	Set player. If private variable player X player is O else player is X
-	void check_board_full()	No parameters 1) return false if vector of strings pegs has available slot by checking for a “ “(space)in each element. Otherwise return true
-	void clear_board() const	No parameters 1) Set all 9 elements to a “ “ (space)
	Class private Data
-	string player	Class member variable
	vector of string pegs	Class member variable 1) (initialize to 9 “ “(spaces)

Implementation Files:
1) In file tic_tac_toe.h, write the class interface code.
2) In file tic_tac_toe.cpp, write the class implementation.
3) In file main.cpp, write game flow code to play the tic tac to game.

Running the program from main (write the code in main.cpp)

Main program flow(main.cpp)

1) Prompt the user for first player
2) Start the game
3) In a user-controlled loop prompt the user for a position (int type) and call the mark_board tic tac toe class member function.  

Answer 1

:: Solution ::

The classic TicTacToe game alternatively place Xs and Os on a 3x3 grid. The winner is the first player to place 3 consecutive marks in a horizontal, vertical or diagonal row.

COMPILER: USED dev c++

#include <windows.h>
#include <iostream>
#include <string>
 
//--------------------------------------------------------------------------------------------------
using namespace std;
 
//--------------------------------------------------------------------------------------------------
enum players { Computer, Human, Draw, None };
const int iWin[8][3] = { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 0, 3, 6 }, { 1, 4, 7 }, { 2, 5, 8 }, { 0, 4, 8 }, { 2, 4, 6 } };
 
//--------------------------------------------------------------------------------------------------
class ttt
{
public:
    ttt() { _p = rand() % 2; reset(); }
 
    void play()
    {
        int res = Draw;
        while( true )
        {
            drawGrid();
            while( true )
            {
                if( _p ) getHumanMove();
                else getComputerMove();
 
                drawGrid();
 
                res = checkVictory();
                if( res != None ) break;
 
                ++_p %= 2;
            }
 
            if( res == Human ) cout << "CONGRATULATIONS HUMAN --- You won!";
            else if( res == Computer ) cout << "NOT SO MUCH A SURPRISE --- I won!";
            else cout << "It's a draw!";
 
            cout << endl << endl;
 
            string r;
            cout << "Play again( Y / N )? "; cin >> r;
            if( r != "Y" && r != "y" ) return;
 
            ++_p %= 2;
            reset();
 
        }
    }
 
private:
    void reset() 
    {
        for( int x = 0; x < 9; x++ )
            _field[x] = None;
    }
 
    void drawGrid()
    {
        system( "cls" );
 
        COORD c = { 0, 2 };
        SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), c );
 
        cout << " 1 | 2 | 3 " << endl;
        cout << "---+---+---" << endl;
        cout << " 4 | 5 | 6 " << endl;
        cout << "---+---+---" << endl;
        cout << " 7 | 8 | 9 " << endl << endl << endl;
 
        int f = 0;
        for( int y = 0; y < 5; y += 2 )
            for( int x = 1; x < 11; x += 4 )
            {
                if( _field[f] != None )
                {
                    COORD c = { x, 2 + y };
                    SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), c );
                    string o = _field[f] == Computer ? "X" : "O";
                    cout << o;
                }
                f++;
            }
 
        c.Y = 9;
        SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), c );
    }
 
    int checkVictory()
    {
        for( int i = 0; i < 8; i++ )
        {
            if( _field[iWin[i][0]] != None &&
                _field[iWin[i][0]] == _field[iWin[i][1]] && _field[iWin[i][1]] == _field[iWin[i][2]] )
            {
                return _field[iWin[i][0]];
            }
        }
 
        int i = 0;
        for( int f = 0; f < 9; f++ )
        {
            if( _field[f] != None )
                i++;
        }
        if( i == 9 ) return Draw;
 
        return None;
    }
 
    void getHumanMove()
    {
        int m;
        cout << "Enter your move ( 1 - 9 ) ";
        while( true )
        {
            m = 0;
            do
            { cin >> m; }
            while( m < 1 && m > 9 );
 
            if( _field[m - 1] != None )
                cout << "Invalid move. Try again!" << endl;
            else break;
        }
 
        _field[m - 1] = Human;
    }
 
    void getComputerMove()
    {
        int move = 0;
 
        do{ move = rand() % 9; }
        while( _field[move] != None );
 
        for( int i = 0; i < 8; i++ )
        {
            int try1 = iWin[i][0], try2 = iWin[i][1], try3 = iWin[i][2];
 
            if( _field[try1] != None && _field[try1] == _field[try2] && _field[try3] == None )
            {
                move = try3;
                if( _field[try1] == Computer ) break;
            }
 
            if( _field[try1] != None && _field[try1] == _field[try3] && _field[try2] == None ) 
            {                   
                move = try2;
                if( _field[try1] == Computer ) break;
            }
 
            if( _field[try2] != None && _field[try2] == _field[try3] && _field[try1] == None )
            {
                move = try1;
                if( _field[try2] == Computer ) break;
            }
        }
        _field[move] = Computer;
 
    }
 
 
int _p;
int _field[9];
};
//--------------------------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
    srand( GetTickCount() );
 
    ttt tic;
    tic.play();
 
    return 0;
}

OUTPUT:

Please rate my answer. Thank you...