Написание игры "Крестики - Нолики"

#include "stdafx.h"
#include <iostream>//стандартная библиотека
 
using namespace std;
 
 
 
int main() 
{
    setlocale(0,"");
    
 
    char cells[9] = {'-','-','-','-','-','-','-','-','-',};
    
    int cell;
    int cell1;
    
     cout << "------------" << "\n" << endl;
    cout << "Номера клеток:" << endl;
    cout << "-" << 1 << "-" << '|' << "-" << 2 << "-" << '|' << "-" << 3 << "-" << " |" << endl;
    cout << "-" << 4 << "-" << '|' << "-" << 5 << "-" << '|' << "-" << 6 << "-" << " |" <<  endl;
    cout << "-" << 7 << "-" << '|' << "-" << 8 << "-" << '|' << "-" << 9 << "-" << " |" << "\n" << endl;
 
 
    cout << "Игровое поле (--- пусто):" << endl;
    cout << "-" << cells[0] << "-" << '|' << "-" << cells[1] << "-" << '|' << "-" << cells[2] << "-" << " |" <<  endl;
    cout << "-" << cells[3] << "-" << '|' << "-" << cells[4] << "-" << '|' << "-" << cells[5] << "-" << " |" <<  endl;
    cout << "-" << cells[6] << "-" << '|' << "-" << cells[7] << "-" << '|' << "-" << cells[8] << "-" << " |" <<  "\n" << endl;
 
    cout << "------------\n" << endl;
 
 
    
    for(int o = 0; o <= 9; ++o){
        cout << "Введите номер клетки, куда ходить  X: ";
        cin >> cell;  
        cells[cell-1] = 'x';
 
        cout << "-" << cells[0] << "-" << '|' << "-" << cells[1] << "-" << '|' << "-" << cells[2] << "-" << " |" <<  endl;
        cout << "-" << cells[3] << "-" << '|' << "-" << cells[4] << "-" << '|' << "-" << cells[5] << "-" << " |" <<  endl;
        cout << "-" << cells[6] << "-" << '|' << "-" << cells[7] << "-" << '|' << "-" << cells[8] << "-" << " |" <<  "\n" << endl;
 
 
 
        cout << "Введите номер клетки, куда ходить 0: ";
        cin >> cell1;
        cells[cell1-1] = '0';
 
        cout << "-" << cells[0] << "-" << '|' << "-" << cells[1] << "-" << '|' << "-" << cells[2] << "-" << " |" <<  endl;
        cout << "-" << cells[3] << "-" << '|' << "-" << cells[4] << "-" << '|' << "-" << cells[5] << "-" << " |" <<  endl;
        cout << "-" << cells[6] << "-" << '|' << "-" << cells[7] << "-" << '|' << "-" << cells[8] << "-" << " |" <<  "\n" << endl;
        
 
    }
    
 
    
 
 
 
    system("pause");
    return 0;
 
 
}

if((cells[0] == 'x') && (cells[1] == 'x') && (cells[2] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[3] == 'x') && (cells[4] == 'x') && (cells[5] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[6] == 'x') && (cells[7] == 'x') && (cells[8] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[0] == 'x') && (cells[3] == 'x') && (cells[6] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[1] == 'x') && (cells[4] == 'x') && (cells[7] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[2] == 'x') && (cells[5] == 'x') && (cells[8] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[0] == 'x') && (cells[4] == 'x') && (cells[8] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }
        if((cells[2] == 'x') && (cells[4] == 'x') && (cells[6] == 'x' )){
            cout << "Победа! X" << endl;
            break;
        }

#include <iostream>
#include <cmath>
#include <cstdlib>
 
using namespace std;
 
int main()
{
const int N = 3;
int x, y, k, dgt;
char A[N][N], c, z;
string s, a, b, name1, name2;
a = "НОЛИКИ";
b = "КРЕСТИКИ";
z = '0';
c = 'X';
cout << "Игра крестики-нолики:" << endl;
cout << "Введите имя первого игрока: ";
getline(cin, name1);
cout << "Введите имя второго игрока: ";
getline(cin, name2);
cout << "За кого ходит первый игрок?(введите цифру):" << endl;
cout << "0: 1" << endl;
cout << "X: 2" << endl;
cout << "Цифра: ";
cin >> dgt;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
A[i][j] = '?';
cout << A[i][j] << " ";
}
cout << endl;
}
for (int i = 0; i < 9; i++)
{
if ((!(i % 2)) && (dgt == 1)) s = a;
if ((!(i % 2)) && (dgt == 2)) s = b;
if ((i % 2) && (dgt == 1)) s = b;
if ((i % 2) && (dgt == 2)) s = a;
mylabel:
cout << "Сделайте ваш ход (" << s << ")" << endl;
cout << "Строка: ";
cin >> x;
cout << "Столбец: ";
cin >> y;
x--;
y--;
if (A[x][y] != '?')
{
system("cls");
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
cout << A[i][j] << " ";
}
cout << endl;
}
cout << "Данная позиция занята!" << endl;
goto mylabel;
}
if ((!(i % 2)) && (dgt == 1)) A[x][y] = z;
if ((!(i % 2)) && (dgt == 2)) A[x][y] = c;
if ((i % 2) && (dgt == 1)) A[x][y] = c;
if ((i % 2) && (dgt == 2)) A[x][y] = z;
system("cls");
k = 0;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
cout << A[i][j] << " ";
}
cout << endl;
}
if (((A[0][0] == '0') && (A[0][1] == '0') && (A[0][2] == '0')) ||
    ((A[1][0] == '0') && (A[1][1] == '0') && (A[1][2] == '0')) ||
    ((A[2][0] == '0') && (A[2][1] == '0') && (A[2][2] == '0')) ||
    ((A[0][0] == '0') && (A[1][0] == '0') && (A[2][0] == '0')) ||
    ((A[0][1] == '0') && (A[1][1] == '0') && (A[2][1] == '0')) ||
    ((A[0][2] == '0') && (A[1][2] == '0') && (A[2][2] == '0')) ||
    ((A[0][0] == '0') && (A[1][1] == '0') && (A[2][2] == '0')) ||
    ((A[2][0] == '0') && (A[1][1] == '0') && (A[0][2] == '0')) ||
    ((A[0][0] == 'X') && (A[0][1] == 'X') && (A[0][2] == 'X')) ||
    ((A[1][0] == 'X') && (A[1][1] == 'X') && (A[1][2] == 'X')) ||
    ((A[2][0] == 'X') && (A[2][1] == 'X') && (A[2][2] == 'X')) ||
    ((A[0][0] == 'X') && (A[1][0] == 'X') && (A[2][0] == 'X')) ||
    ((A[0][1] == 'X') && (A[1][1] == 'X') && (A[2][1] == 'X')) ||
    ((A[0][2] == 'X') && (A[1][2] == 'X') && (A[2][2] == 'X')) ||
    ((A[0][0] == 'X') && (A[1][1] == 'X') && (A[2][2] == 'X')) ||
    ((A[2][0] == 'X') && (A[1][1] == 'X') && (A[0][2] == 'X')))
{
k++;
cout << "Игра закончена! ";
if ((A[x][y] == z) && (dgt == 1)) cout << name1 << " победил(a)!" << endl;
if ((A[x][y] == c) && (dgt == 2)) cout << name1 << " победил(а)!" << endl;
if ((A[x][y] == c) && (dgt == 1)) cout << name2 << " победил(а)!" << endl;
if ((A[x][y] == z) && (dgt == 2)) cout << name2 << " победил(а)!" << endl;
break;
}
}
if (!(k)) cout << "Игра закончилась вничью!" << endl;
system("pause");
return 0;
}

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::vector     < T_str     >   T_strings;
typedef T_strings                       T_field_matr;
///////////////////////////////////////////////////////////////////////////////
class   T_xs_and_os
{
    //-------------------------------------------------------------------------
    static  const   int     FIELD_DIM           =   3;
 
    static  const   int     FIELD_SIZE          =       FIELD_DIM
                                                    *   FIELD_DIM;
 
    static  const   int     FIRST_CELL_NUM      =   1;
    static  const   int     LAST_CELL_NUM       =   FIELD_SIZE;
 
    static  const   char    GAME_SYMB_FIRST     =   'X';
    static  const   char    GAME_SYMB_SECOND    =   'O';
    static  const   char    ZERO_SYMB           =   '0';
 
    static  const   char    SPACE_SYMB          =   ' ';
    static  const   char    MINUS_SYMB          =   '-';
    static  const   char    VERTICAL_LINE_SYMB  =   '|';
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    static
    void    play()
    {
        T_field_matr    field_matr
                            (
                                FIELD_DIM,
 
                                T_str   (
                                            FIELD_DIM,
                                            SPACE_SYMB
                                        )
                            );
 
        print_new_game_message  ();
        print_field_matr        ( field_matr    );
 
        for (
                int
                moves_counter   {};
                moves_counter   <   FIELD_SIZE;
                ++moves_counter
            )
        {
            auto    cur_symb    =   get_cur_symb( moves_counter );
 
            input_move
                (
                    cur_symb,
                    field_matr
                );
 
            print_empty_line    ();
            print_field_matr    ( field_matr    );
 
            if  (
                    symb_won_in_matr
                        (
                            cur_symb,
                            field_matr
                        )
                )
            {
                print_win_message_for_symb  ( cur_symb  );
                return;
            }//if
        }//for
 
        print_draw_message  ();
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    static
    void    print_empty_line()
    {
        std::cout   <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    void    print_new_game_message()
    {
        std::cout   <<  "\n\n\n\n\n\n\n\n\n"
                    <<  "NEW GAME:"
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    char    get_cur_symb( int   moves_counter )
    {
        return  moves_counter   %   2   ==  0
                    ?   GAME_SYMB_FIRST
                    :   GAME_SYMB_SECOND;
    }
    //-------------------------------------------------------------------------
    static
    void    input_move
        (
            char                symb,
            T_field_matr    &   field_matr
        )
    {
        int     i   {};
        int     j   {};
 
        do
        {
            for_symb_input_field_matr_indexes
                (
                    symb,
                    i,
                    j
                );
        }
        while   (
                         field_matr[i][j]
                     !=  SPACE_SYMB
                );
 
        field_matr[i][j]    =   symb;
    }
    //-------------------------------------------------------------------------
    static
    bool    symb_won_in_matr
        (
            char                        symb,
            T_field_matr    const   &   field_matr
        )
    {
        T_field_matr    rotated_matr    { field_matr    };
        transp                          ( rotated_matr  );
        reverse_strings                 ( rotated_matr  );
 
        return      symb_won_in_row_or_main_diag_of_matr
                        (
                            symb,
                            field_matr
                        )
 
                ||  symb_won_in_row_or_main_diag_of_matr
                        (
                            symb,
                            rotated_matr
                        );
    }
    //-------------------------------------------------------------------------
    static
    bool    symb_won_in_row_or_main_diag_of_matr
        (
            char                        symb,
            T_field_matr    const   &   field_matr
        )
    {
        T_str   winning_str
                    (
                        FIELD_DIM,
                        symb
                    );
 
        return          std::find
                            (
                                field_matr.begin    (),
                                field_matr.end      (),
                                winning_str
                            )
 
                    !=  field_matr.end()
 
                ||      winning_str
 
                    ==  T_str   {
                                    field_matr[0][0],
                                    field_matr[1][1],
                                    field_matr[2][2]
                                };
    }
    //-------------------------------------------------------------------------
    static
    void    reverse_strings( T_field_matr    &   field_matr )
    {
        std::reverse
            (
                field_matr.begin    (),
                field_matr.end      ()
            );
    }
    //-------------------------------------------------------------------------
    static
    void    transp( T_field_matr    &   field_matr )
    {
        for( size_t  i{}; i < field_matr.size() - 1; ++i )
        {
            for( size_t  j{i + 1}; j < field_matr.size(); ++j )
            {
                std::swap
                    (
                        field_matr[i][j],
                        field_matr[j][i]
                    );
            }//for
        }//for
    }
    //-------------------------------------------------------------------------
    static
    void    print_win_message_for_symb( char    symb )
    {
        std::cout   <<  "'"
                    <<  symb
                    <<  "'"
                    <<  " won."
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    void    print_draw_message()
    {
        std::cout   <<  "Draw."
                    <<  std::endl;
    }
    //-------------------------------------------------------------------------
    static
    void    print_field_matr( T_field_matr  const   &   field_matr )
    {
        for( size_t  i{}; i < field_matr.size(); ++i )
        {
            print_field_row_of_matr_with_ind
                (
                    field_matr,
                    i
                );
        }//for
    }
    //-----------------------------------------------------------------------------------
    static
    void    print_field_row_of_matr_with_ind
        (
            T_field_matr    const   &   field_matr,
            int                         i
        )
    {
        const   int     SPACES_COUNT_BETWEEN_CELL_BORDER_AND_SYMBOL     =   1;
 
        int             border_horiz_len
 
            =           ( SPACES_COUNT_BETWEEN_CELL_BORDER_AND_SYMBOL + 1 )
                    *   2
                    *   field_matr.size()
                +   1;
 
        T_str   border_horiz    =   T_str   (
                                                border_horiz_len,
                                                MINUS_SYMB
                                            );
 
        if( i   ==  0 )
        {
            std::cout   <<  border_horiz
                        <<  std::endl;
        }
 
        auto    &   field_row  =   field_matr[i];
 
        for( size_t  j{}; j < field_row.size(); ++j )
        {
            print_field_cell_of_row_with_ind
                (
                    field_row,
                    j,
                    SPACES_COUNT_BETWEEN_CELL_BORDER_AND_SYMBOL
                );
        }//for
 
        std::cout   <<  std::endl
                    <<  border_horiz
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    static
    void    print_field_cell_of_row_with_ind
        (
            T_str   const   &   field_row,
            int                 j,
            size_t              spaces_count_between_cell_border_and_symbol
        )
    {
        T_str   spaces_line     (
                                    spaces_count_between_cell_border_and_symbol,
                                    SPACE_SYMB
                                );
 
        if( j   ==  0 )
        {
            std::cout   <<  VERTICAL_LINE_SYMB;
        }
 
        std::cout   <<  spaces_line
                    <<  field_row[j]
                    <<  spaces_line
                    <<  VERTICAL_LINE_SYMB;
    }
    //-----------------------------------------------------------------------------------
    static
    void    for_symb_input_field_matr_indexes
        (
            char        symb,
            int     &   i,
            int     &   j
        )
    {
        int     move_cell_num   {};
        char    digit_symb      {};
 
        for(;;)
        {
            print_move_prompt_for_symb( symb );
            std::cin    >>  digit_symb;
 
            if  (
                    std::isdigit( digit_symb )
                )
            {
                move_cell_num   =       digit_symb
                                    -   ZERO_SYMB;
 
                if  (
                            move_cell_num   >=  FIRST_CELL_NUM
                        &&  move_cell_num   <=  LAST_CELL_NUM
                    )
                {
                    break;
                }//if
            }//if
        }//for
 
        //Так как строки матрицы цифровой клавиатуры расположены по убыванию индекса строки,
        //а матрицы игрового поля - по возрастанию, то делаем реверс по индексу строки
        //матрицы.
 
        int     ind_from_num    =       move_cell_num
                                    -   FIRST_CELL_NUM;
 
        int     i_from_num      =       ind_from_num
                                    /   FIELD_DIM;
 
        i                       =       FIELD_DIM
                                    -   1
                                    -   i_from_num;
 
        j                       =       ind_from_num
                                    %   FIELD_DIM;
    }
    //-------------------------------------------------------------------------
    static
    void    print_move_prompt_for_symb( char    symb )
    {
        std::cout   <<  "Move '"
                    <<  symb
                    <<  "'."
                    <<  std::endl
                    <<  "Enter cell number "
                    <<  FIRST_CELL_NUM
                    <<  ".."
                    <<  LAST_CELL_NUM
                    <<  " on numeric keypad: ";
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        T_xs_and_os::play();
    }
}

#include <conio.h>
#include <iostream>
#include <locale.h>
 
using namespace std;
 
int const N = 3;
int Win;
char const P1S = 'X', P2S = '0', NPS = '-';
void Instructions()
{
    cout << "Добро пожаловать в мою первую игру КРЕСТИКИ НОЛИКИ:\n\n";
    cout << "Инструкция:\n\n";
    cout << "1. Игрок A ходит крестиками \'X\' игрок B ходит \'0\' по очереди.\n";
    cout << "1. Побеждает тот, у кого выставленные им символы трижды пересекаются либо по горизонтали, либо по вертикали, либо по диагонали.\n";
    cout << "1. Если тройной комбинации нет, получается ничья!\n\n";
}
void NewGame(char a[N][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            a[i][j] = NPS;
        }
    }
}
bool PlayerTurn(bool a)
{
    if (a)
    {
        return false;
    }
    else
        return true;
}
bool Mistake(int b[2], char a[N][N])
{
    if ((a[b[0]-1][b[1]-1] == P1S) || (a[b[0] - 1][b[1] - 1] == P2S))
    {
        return true;
    }
    else return false;
}
void TextInput(bool a, bool b)
{
    if (a && !b)
    {
        cout << "\nИгрок 1, введите координаты \'" << P1S << "\': ";
    }
    else if(!a && !b)
    {
        cout << "\nИгрок 2, введите координаты \'" << P2S << "\': ";
    }
    if (a && b)
    {
        cout << "\nИгрок 1, вы ошиблись, повторите ввод \'" << P1S << "\': ";
    }
    else if (!a && b)
    {
        cout << "\nИгрок 2, вы ошиблись, повторите ввод \'" << P2S << "\': ";
    }
}
int Input()
{
    int a;
    while (!(cin >> a ) || a <=0 ||a > 3)
    {
        cin.clear();
        while (cin.get() != '\n');
        cout << "Ошибка!!! Повторите ввод: ";
    }
    return a;
}
void GameMap(char a[N][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (a[i][j] != P1S && a[i][j] != P2S)
            {
                a[i][j] = NPS;
            }
        }
    }
    cout << "   1  2  3\n";
    for (int i = 0; i < N; i++)
    {
        cout << i+1 << " ";
        for (int j = 0; j < N; j++)
        {
            cout << "[" << a[i][j] << "]";
        }
        cout << endl;
    }
}
bool InGame(char a[N][N], bool b)
{
    char simbol;
    if (b) simbol = P1S;
    else simbol = P2S;
    bool GameOwer = false;
    Win = 0;
    for (int i = 0; i < N; i++)
    {
        Win = 0;
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[j][i] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            if (a[i][i] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0, j = N - 1; j > 0; i++, j--)
        {
            if (a[i][j] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == P1S || a[i][j] == P2S) Win++;
            }
        }
        if (Win == 9) GameOwer = true;
        else if (Win < 9) Win = 0;
    }
    if (!GameOwer) return true;
    else return false;
}
void Outpoot(char a[N][N])
{
    bool Player1 = true;
    bool GameRuning = InGame(a, Player1);
    while (GameRuning)
    {
        bool OutputMistake = false;
        bool Turn = true;
        int Coordinates[2];
        while (Player1 && Turn)
        {
            Turn = true;
            Instructions();
            GameMap(a);
            TextInput(Player1, OutputMistake);
            Coordinates[0] = Input();
            Coordinates[1] = Input();
            if (!Mistake(Coordinates, a))
            {
                a[Coordinates[0] - 1][Coordinates[1] - 1] = P1S;
                GameRuning = InGame(a, Player1);
                if (GameRuning)
                {
                    Player1 = PlayerTurn(Player1);
                    system("cls");
                    Turn = false;
                }
                else if (!GameRuning) Turn = false;
            }
            else if (Mistake(Coordinates, a))
            {
                OutputMistake = true;
                system("cls");
            }
        }
        while (!Player1 && Turn)
        {
            Turn = true;
            Instructions();
            GameMap(a);
            TextInput(Player1, OutputMistake);
            Coordinates[0] = Input();
            Coordinates[1] = Input();
            if (!Mistake(Coordinates, a))
            {
                a[Coordinates[0] - 1][Coordinates[1] - 1] = P2S;
                GameRuning = InGame(a, Player1);
                if (GameRuning)
                {
                    Player1 = PlayerTurn(Player1);
                    system("cls");
                    Turn = false;
                }
                else if (!GameRuning) Turn = false;
            }
            else if (Mistake(Coordinates, a))
            {
                OutputMistake = true;
                system("cls");
            }
        }
        if (!GameRuning && Win != 9)
        {
            switch (Player1)
            {
            case 1:
            {
                system("cls");
                Instructions();
                GameMap(a);
                cout << "\nПоздравляем! Победил игрок 1.\n";
            }
            break;
            case 0:
            {
                system("cls");
                Instructions();
                GameMap(a);
                cout << "\nПоздравляем! Победил игрок 2.\n";
            }
            break;
            }
        }
        else if (Win == 9)
        {
            system("cls");
            Instructions();
            GameMap(a);
            cout << "\nХо-хо-хо, ничья!!!\n";
        }
    }
}
 
int main()
{
    setlocale(LC_ALL, "RUS");
    bool Retry = true;
    char a;
    while (Retry)
    {
        char Game[N][N];
        Outpoot(Game);
        cout << "\nЖелаете повторить? (y/s): ";
        while (!(cin >> a) || a != 'y' && a != 'n')
        {
            cin.clear();
            while (cin.get() != '\n');
            cout << "Ошибка! Повторите! (y/n): ";
        }
        switch (a)
        {
        case 'y':
        {
            NewGame(Game);
            Retry = true;
            system("cls");
        }
        break;
        case 'n': Retry = false; break;
        }
    }
    return 0;
}

char simbol;
    if (b) simbol = P1S;
    else simbol = P2S;
    bool GameOwer = false;
    Win = 0;
    for (int i = 0; i < N; i++)
    {
        Win = 0;
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
        if (!GameOwer)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[j][i] == simbol) Win++;
            }
            if (Win == 3) GameOwer = true;
            else if (Win < 3) Win = 0;
        }
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            if (a[i][i] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0, j = N - 1; j > 0; i++, j--)
        {
            if (a[i][j] == simbol) Win++;
        }
        if (Win == 3) GameOwer = true;
        else if (Win < 3) Win = 0;
    }
    if (!GameOwer)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (a[i][j] == P1S || a[i][j] == P2S) Win++;
            }
        }
        if (Win == 9) GameOwer = true;
        else if (Win < 9) Win = 0;
    }

// Tic-Tac-Toe 2.0
// Plays the game of tic-tac-toe against a human opponent
// Uses pointers instead of refernces for function parameters
 
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
 
using namespace std;
 
// global constants
const char X = 'X';
const char O = 'O';
const char EMPTY = ' ';
const char TIE = 'T';
const char NO_ONE = 'N';
 
// function prototypes
void instructions();
char askYesNo(string question);
int askNumber(string question, int high, int low = 0);
char humanPiece();
char opponent(char piece);
void displayBoard(const vector<char>* const pBoard);
char winner(const vector<char>* const pBoard);
bool isLegal(const vector<char>* const pBoard, int move);
int humanMove(const vector<char>* const pBoard, char human);
int computerMove(vector<char> board, char computer);
void announceWinner(char winner, char computer, char human);
 
// main function
int main()
{
    int move;
    const int NUM_SQUARES = 9;
    vector<char> board(NUM_SQUARES, EMPTY);
 
    instructions();
    char human = humanPiece();
    char computer = opponent(human);
    char turn = X;
    displayBoard(&board);
 
    while (winner(&board) == NO_ONE)
    {
        if (turn == human)
        {
            move = humanMove(&board, human);
            board[move] = human;
        }
        else
        {
            move = computerMove(board, computer);
            board[move] = computer;
        }
        displayBoard(&board);
        turn = opponent(turn);
    }
 
    announceWinner(winner(&board), computer, human);
 
    return 0;
}
 
// functions
void instructions()
{
    cout << "Welcome to the ultimate man-machine showdown: Tic-Tac-Toe.\n";
    cout << "--where human brain is pit against silicon processor\n\n";
 
    cout << "Make your move known by entering a number, 0 - 8.  The number\n";
    cout << "corresponds to the desired board position, as illustrated:\n\n";
 
    cout << "       0 | 1 | 2\n";
    cout << "       ---------\n";
    cout << "       3 | 4 | 5\n";
    cout << "       ---------\n";
    cout << "       6 | 7 | 8\n\n";
 
    cout << "Prepare yourself, human.  The battle is about to begin.\n\n";
}
 
char askYesNo(string question)
{
    char response;
    do
    {
        cout << question << " (y/n): ";
        cin >> response;
    } while (response != 'y' && response != 'n');
 
    return response;
}
 
int askNumber(string question, int high, int low)
{
    int number;
    do
    {
        cout << question << " (" << low << " - " << high << "): ";
        cin >> number;
    } while (number > high || number < low);
 
    return number;
}
 
char humanPiece()
{
    char go_first = askYesNo("Do you require the first move?");
    if (go_first == 'y')
    {
        cout << "\nThen take the first move.  You will need it.\n";
        return X;
    }
    else
    {
        cout << "\nYour bravery will be your undoing... I will go first.\n";
        return O;
    }
}
 
char opponent(char piece)
{
    if (piece == X)
    {
        return O;
    }
    else
    {
        return X;
    }
}
 
void displayBoard(const vector<char>* const pBoard)
{
    cout << "\n\t" << (*pBoard)[0] << " | " << (*pBoard)[1] << " | " << (*pBoard)[2];
    cout << "\n\t" << "---------";
    cout << "\n\t" << (*pBoard)[3] << " | " << (*pBoard)[4] << " | " << (*pBoard)[5];
    cout << "\n\t" << "---------";
    cout << "\n\t" << (*pBoard)[6] << " | " << (*pBoard)[7] << " | " << (*pBoard)[8];
    cout << "\n\n";
}
 
char winner(const vector<char>* const pBoard)
{
    // all possible winning rows
    const int WINNING_ROWS[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 } };
    const int TOTAL_ROWS = 8;
 
    // if any winning row has three values that are the same (and not EMPTY),
    // then we have a winner
    for (int row = 0; row < TOTAL_ROWS; ++row)
    {
        if (((*pBoard)[WINNING_ROWS[row][0]] != EMPTY) &&
            ((*pBoard)[WINNING_ROWS[row][0]] == (*pBoard)[WINNING_ROWS[row][1]]) &&
            ((*pBoard)[WINNING_ROWS[row][1]] == (*pBoard)[WINNING_ROWS[row][2]]))
        {
            return (*pBoard)[WINNING_ROWS[row][0]];
        }
    }
 
    // since nobody has won, check for a tie (no empty squares left)
    if (count(pBoard->begin(), pBoard->end(), EMPTY) == 0)
        return TIE;
 
    // since nobody has won and it isn't a tie, the game ain't over
    return NO_ONE;
}
 
inline bool isLegal(int move, const vector<char>* pBoard)
{
    return ((*pBoard)[move] == EMPTY);
}
 
int humanMove(const vector<char>* const pBoard, char human)
{
    int move = askNumber("Where will you move?", (pBoard->size() - 1));
    while (!isLegal(move, pBoard))
    {
        cout << "\nThat square is already occupied, foolish human.\n";
        move = askNumber("Where will you move?", (pBoard->size() - 1));
    }
    cout << "Fine...\n";
    return move;
}
 
int computerMove(vector<char> board, char computer)
{
    unsigned int move = 0;
    bool found = false;
 
    //if computer can win on next move, that’s the move to make
    while (!found && move < board.size())
    {
        if (isLegal(move, &board))
        {
            //try move
            board[move] = computer;
            //test for winner
            found = winner(&board) == computer;
            //undo move
            board[move] = EMPTY;
        }
 
        if (!found)
        {
            ++move;
        }
    }
 
    //otherwise, if opponent can win on next move, that's the move to make
    if (!found)
    {
        move = 0;
        char human = opponent(computer);
 
        while (!found && move < board.size())
        {
            if (isLegal(move, &board))
            {
                //try move
                board[move] = human;
                //test for winner
                found = winner(&board) == human;
                //undo move
                board[move] = EMPTY;
            }
 
            if (!found)
            {
                ++move;
            }
        }
    }
 
    //otherwise, moving to the best open square is the move to make
    if (!found)
    {
        move = 0;
        unsigned int i = 0;
 
        const int BEST_MOVES[] = { 4, 0, 2, 6, 8, 1, 3, 5, 7 };
        //pick best open square
        while (!found && i <  board.size())
        {
            move = BEST_MOVES[i];
            if (isLegal(move, &board))
            {
                found = true;
            }
 
            ++i;
        }
    }
 
    cout << "I shall take square number " << move << endl;
    return move;
}
 
void announceWinner(char winner, char computer, char human)
{
    if (winner == computer)
    {
        cout << winner << "'s won!\n";
        cout << "As I predicted, human, I am triumphant once more -- proof\n";
        cout << "that computers are superior to humans in all regards.\n";
    }
 
    else if (winner == human)
    {
        cout << winner << "'s won!\n";
        cout << "No, no!  It cannot be!  Somehow you tricked me, human.\n";
        cout << "But never again!  I, the computer, so swear it!\n";
    }
 
    else
    {
        cout << "It's a tie.\n";
        cout << "You were most lucky, human, and somehow managed to tie me.\n";
        cout << "Celebrate... for this is the best you will ever achieve.\n";
    }
}