Оцените и посоветуйте как можно улучшить код Крестики-нолики

#include <iostream>
#include <stdio.h>
#include <cstdlib>
#include <windows.h>
using namespace std;
 
void output(char** field) {
    cout << "  1 2 3" << endl;
    for (int i = 0; i < 3; i++) {
        cout << i + 1 << " ";
        for (int j = 0; j < 3; j++) {
            cout << field[i][j] << " ";
        }
        cout << endl;
    }
}
void input(char** field, bool& gamer, string& Name1, string& Name2) {
 
    int answer;
    while (true) {
 
        if (gamer) {
            cout << Name1;
        }
        else {
            cout << Name2;
        }
        cout << ", введите номер строки и столбца: ";
 
 
        cin >> answer;
        if (answer > 10 && answer < 34) {
            int i = answer / 10;
            int j = answer % 10;
 
            if (0 < j && j < 4) {
                if (field[i - 1][j - 1] != 'X' && field[i - 1][j - 1] != 'O') {
                    if (gamer) {
                        field[i - 1][j - 1] = 'X';
                    }
                    else {
                        field[i - 1][j - 1] = 'O';
                    }
                    gamer = !gamer;
                    break;
                }
            }
        }
        cout << "Вы ввели неверную ячейку" << endl;
    }
}
char** fieldCreate(char c = '_') {
    int const n = 3;
    char** field = new char* [n];
    for (int i = 0; i < n; i++) {
        field[i] = new char[n];
        field[i][0] = c;
        field[i][1] = c;
        field[i][2] = c;
    }
    return field;
}
bool chekWin(char** field, string& Name1, string& Name2) {
    bool chekWin = false, gamer = false;
 
    if (field[0][0] == field[1][1] && field[0][0] == field[2][2] && (field[0][0] == 'X' || field[0][0] == 'O') || field[2][0] == field[1][1] && field[2][0] == field[0][2] && (field[2][0] == 'X' || field[2][0] == 'O')) {
        chekWin = true;
        if (field[1][1] == 'X') {
            gamer = true;
        }
    }
    else {
        for (int i = 0; i < 3; i++) {
            if (field[i][0] == field[i][1] && field[i][0] == field[i][2] && (field[i][0] == 'X' || field[i][0] == 'O') || field[0][i] == field[1][i] && field[0][i] == field[2][i] && (field[0][i] == 'X' || field[0][i] == 'O')) {
                chekWin = true;
                if (field[i][i] == 'X') {
                    gamer = true;
                }
                break;
            }
        }
    }
 
    if (chekWin) {
        if (gamer) {
            cout << "победил !" << Name1 << endl;
        }
        else {
            cout << "победил  !" << Name2 << endl;
        }
        return true;
    }
    else {
        bool draw = true;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (field[i][j] != 'X' && field[i][j] != 'O') {
                    draw = false;
                }
            }
        }
 
        if (draw) {
            cout << "ничья";
            return true;
        }
    }
 
    return false;
}
void defoultMassive(char** field, char c = '_') {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            field[i][j] = c;
        }
    }
}
bool continueGame() {
    bool flag = true;
    while (true) {
        string answer;
        cout << "Хотите ли вы продолжить игру?(Да/Нет)" << endl << "Введите ответ: "; //<< answer;
        cin >> answer;
        if (answer == "Да") {
            break;
        }
        else if (answer == "Нет") {
            flag = false;
            break;
        }
        else {
            cout << "Такого ответа не существует!";
        }
    }
    return flag;
}
void deleteMassive(char** field) {
    for (int i = 0; i < 3; i++) {
        delete[] field[i];
    }
    delete[] field;
}
void randomPlayer(string& Name1, string& Name2) {
    srand(time(0));
    int num = rand() % 2;
    cout << "Введите имя первого игрока: ";
    cin >> Name1;
    cout << "Введите имя второго игрока: ";
    cin >> Name2;
    if (num) {
        string tmp = Name1;
        Name1 = Name2;
        Name2 = tmp;
    }
    cout << "Первым ходит: " << Name1 << endl;
}
 
int main() {
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    bool gamer = true;
    char** field = fieldCreate();
    string Name1, Name2;
    randomPlayer(Name1, Name2);
    while (true) {
        defoultMassive(field);
        while (true) {
            system("Cls");
            output(field);
            if (chekWin(field, Name1, Name2))
                break;
            input(field, gamer, Name1, Name2);
 
        }
        if (!continueGame())
            break;
    }
    deleteMassive(field);
    return 0;
}

#include <iostream>
 
const char* INTERFACE_VERSION = "interface_version:xlat";
 
///----------------------------------------------------------------------------|
/// C++17
/// Исходник в UTF-8
///----------------------------------------------------------------------------|
/// AI для игры в крестонолики.
///----------------------------------------------------------------------------:
#include <cstdlib>
#include <vector>
#include <string>
#include <ctime>
 
#include <iostream>
 
///----------|
/// Конфиг.  |
///----------:
struct  Cfg
{
    ///-----------------------------|
    /// Количество фишек для победы.|
    ///-----------------------------:
    size_t FWIN   =   5;
    size_t WIDTH  =  30; /// Размер поля по горизонтали.
    size_t HEIGHT =  20; /// Размер поля по вертикали.
    ///-----------------------------.
 
    char FISHKI[2]{'X', 'O'};
};
 
const char EMPTY = '.';
 
template<typename T>
T& operator<<(T& o, const Cfg& c)
{   o   << L"КОНФИГ ---------------------------:\n"
        << "   FWIN      = " << c.FWIN      << '\n'
        << "   WIDTH     = " << c.WIDTH     << '\n'
        << "   HEIGHT    = " << c.HEIGHT    << '\n'
        << "   FISHKI[0] = " << c.FISHKI[0] << '\n'
        << "   FISHKI[1] = " << c.FISHKI[1] << '\n'
        << std::endl;
    return o;
}
 
///----------|
/// Конфиг.  |
///----------:
Cfg   cfg;
 
struct Plot
{   size_t x, y;
    bool operator==(const Plot& p) const { return x == p.x && y == p.y; }
};
 
 
template<typename T>
T& operator<<(T& o, const Plot& p)
{          o << "{ " << p.x << ", " << p.y << " }";
    return o;
}
 
 
std::ostream& operator<<(std::ostream& o, const std::vector<std::string>& f)
{
    std::string line(f[0].size()+2, '-');
    o << line << '\n';
    for    (size_t h = 0; h < f   .size(); ++h)
    {   o << "|";
        for(size_t w = 0; w < f[0].size(); ++w)
        {   o << f[h][w];
        }   o << "|\n";
    }       o << line << '\n';
    return  o;
}
 
namespace stp
{
    ///-------------------------------------------------|
    /// Когда нужно понять кто первый сделал ход.       |
    ///-------------------------------------------------:
    const Plot START_STEP = {size_t(-111), size_t(-111)};
    const Plot   NOT_INIT = {size_t(-1  ),         0   };
    const Plot BAD_RETURN = {size_t(-112),         0   };
}
 
 
bool TYPE_IS_SERVER_OR_CLIENT = false;
 
 
///----------------------------------------------------------------------------|
/// ИИ.
///     Всё что нужно сделать это ПРИНЯТЬ РЕШЕНИЕ,
///     в какую координату поставить фишку.
///----------------------------------------------------------------------------:
 
const bool DEBUG_DLL_RUNTIME = false;
 
///------------------------------------|
/// ...                                |
///------------------------------------:
const wchar_t* authorname = L"Глупыш";
//const wchar_t* authorname = L"Дебил";
//const wchar_t* authorname = L"АфторРэнд";
 
 
struct Rand
{   Rand(            ){   srand((unsigned)time(0));}
    Rand(unsigned sid){   srand(sid);              }
    int  operator   ()(int range_min, int range_max)   const
    {
        return rand () %  (range_max -    range_min) + range_min;
    }
}rrand;
 
 
struct  AI
{       AI() : field(std::vector(cfg.HEIGHT, std::string(cfg.WIDTH, '.')))
        {
        }
 
    ///---------------------|
    /// Ваша фишка.         |
    ///---------------------:
    char FISHKA       = 0; /// Устанавливается Арбитром
    char FISHKA_ENEMY = 0; /// непосредственно перед матчем.
 
    ///---------------------|
    /// Послединй ход врага.|
    ///---------------------:
    Plot last_step{stp::NOT_INIT};
 
    ///---------------------|
    /// Это ваше поле.      |
    ///---------------------:
    std::vector<std::string> field;
 
    ///-------------------------------|
    /// Это основной метод.           |
    /// его будет дёргать Арбитер,    |
    /// чтоб узнать ваше решение.     |
    ///-------------------------------:
    Plot step(const Plot& enemy_step)
    {
        set_step(enemy_step);
 
        const auto& H = field   .size();
        const auto& W = field[0].size();
 
        Plot p;
 
        /// TODO ...
        ///--------------------...
        /// пример простейшего решения ...
        ///--------------------...
        while(true)
        {
            p.x = rrand(0, W);
            p.y = rrand(0, H);
 
            if( verification_no_info(p))
            {   field[p.y][p.x] = FISHKA;
 
                if(DEBUG_DLL_RUNTIME)
                {   std::wcout << authorname << L" сделал ход: " << p << ":\n";
                    std::cout  << field      << std::endl;
                    std::cin.get();
                }
 
                return p;
            }
        }
 
        return {size_t(-1), 0};
    }
 
 
    void fclear()
    {   field = std::vector(cfg.HEIGHT, std::string(cfg.WIDTH, '.'));
    }
 
private:
    void set_step(const Plot& enemy_step)
    {   last_step = enemy_step;
 
        if (verification_no_info(last_step))
        {   field[last_step.y][last_step.x] = FISHKA_ENEMY;
 
            if(DEBUG_DLL_RUNTIME)
            {   std::wcout << authorname  << L" состояние доски до хода:\n";
                std::cout  << field       << std::endl;
            }
        }
        else
        {
            ///------------------------|
            /// Арбитер прислал НЕ ход.|
            ///------------------------:
            if(last_step == stp::START_STEP)
            {
                if(DEBUG_DLL_RUNTIME)
                {   std::wcout  << authorname  << L" ходит первым.\n";
                    std::wcout  << L"Состояние доски:\n";
                    std::cout  << field      << std::endl;
                }
            }
            else
            {   printf("ERROR in dll ...");
                std::cin.get();
            }
        }
    }
 
    bool verification_no_info(const Plot& p) const
    {   return field[p.y][p.x] != '.';
    }
};
 
 
static AI* ai = nullptr;
///----------------------------------------------------------------------------|
/// Внешний интерфейс AI.
///----------------------------------------------------------------------------:
 
void create_(const Cfg _cfg)
{   cfg = _cfg;
    ai  = new AI();
}
 
Plot step_(const Plot enemy_step)
{   return ai->step(enemy_step);
}
 
const wchar_t* name_(                  )
{   return authorname  ;
}
void         delete_(                  )
{   delete ai          ;
}
void         stfish_(const char FISHKA )
{   ai->FISHKA  = FISHKA;
    if(ai->FISHKA == cfg.FISHKI[0]) ai->FISHKA_ENEMY = cfg.FISHKI[1];
    else                            ai->FISHKA_ENEMY = cfg.FISHKI[0];
    ai->fclear();
}
 
void sendplot_(Plot plot, char color)
{   ai->field[plot.y][plot.x] = color;
 
    if(DEBUG_DLL_RUNTIME)
    {   std::wcout << L"sendplot_:\n";
        /// ...
    }
}
 
const char* get_interface_version()
{   return INTERFACE_VERSION;
}
 
 
 
int main()
{
 
/*
    /// псевдокод:
    while(true)
    {
        CONNECTOR con;
 
        switch(con.command)
        {
            case 1:
                Arg arg = con.arg();
                create_(arg.cfg);
                break;
 
            case 2:
                Arg arg = con.arg();
                std::cout << step_(arg.plot);
                break;
 
            ...
            ...
            ...
        }
    }
*/
}

#include <iostream>
///----------------------------------------------------------------------------|
/// ...
///----------------------------------------------------------------------------:
#include <cstdlib>
#include <vector>
#include <string>
#include <ctime>
 
struct Plot{ size_t x, y; };
 
std::ostream& operator<<(std::ostream& o, std::vector<std::string>& f)
{
    const auto& H = f   .size();
    const auto& W = f[0].size();
 
    std::string line(W+2, '-');
    o << line << '\n';
    for    (size_t h = 0; h < H; ++h)
    {   o << "|";
        for(size_t w = 0; w < W; ++w)
        {   o << f[h][w];
        }   o << "|\n";
    }       o << line << '\n';
    return  o;
}
 
 
struct Rand
{   Rand(            ){   srand((unsigned)time(0));}
    Rand(unsigned sid){   srand(sid);              }
    int  operator   ()(int range_min, int range_max)   const
    {
        return rand () %  (range_max -    range_min) + range_min;
    }
}rrand;
 
 
struct  Bot
{       Bot      (std::string nm) :
            field(std::vector(10, std::string(10, '.'))),
            authorname  (nm),
            MAXSTEP(10 * 10 / 2)
        {
        }
 
    ///---------------------|
    /// Это ваше поле.      |
    ///---------------------:
    std::vector<std::string> field;
    std::string         authorname;
 
    int cnt_steps = 0;
    const int MAXSTEP;
 
    void step(const Plot p, char f)
    {   field[p.y][p.x] = f;
        std::cout  << field      << std::endl;
    }
 
    ///-------------------------------|
    /// Это основной метод.           |
    /// его будет дёргать Арбитер,    |
    /// чтоб узнать ваше решение.     |
    ///-------------------------------:
    Plot step()
    {
        if(MAXSTEP == cnt_steps++) return {0, size_t(-1)};
 
        const auto& H = field   .size();
        const auto& W = field[0].size();
 
        Plot p;
 
        /// TODO ...
        ///--------------------...
        /// пример простейшего решения ...
        ///--------------------...
        while(true)
        {
            p.x = rrand(0, W);
            p.y = rrand(0, H);
 
            if( verification_no_info(p))
            {   field[p.y][p.x] = authorname.back();
 
                std::cout << authorname  << ": "
                          << p.x << ", " << p.y << ":\n";
 
                std::cout  << field      << std::endl;
 
                return p;
            }
        }
 
        return {size_t(-1), 0};
    }
 
    void fclear()
    {   field = std::vector(10, std::string(10, '.'));
    }
 
private:
    bool verification_no_info(const Plot& p) const
    {   return field[p.y][p.x] != '.';
    }
};
 
struct Web
{
    bool is_end(){ return step.y == size_t(-1); }
 
    Plot step{5,5};
}web;
 
struct  Server
{       Server() : bot("Vasia-X") {}
 
    Bot bot;
 
    void go()
    {
        switch(now)
        {
            case 0:            bot.step(web.step, bot.authorname.back()); break;
            case 1: web.step = bot.step(                               ); break;
        }
 
        now = 1 - now;
    }
 
    int now = 0;
};
 
struct  Client
{       Client() : bot("John-O") {}
 
    Bot bot;
 
    void go()
    {
        switch(now)
        {
            case 0: web.step = bot.step(                               ); break;
            case 1:            bot.step(web.step, bot.authorname.back()); break;
        }
 
        now = 1 - now;
    }
 
    int now = 1;
};
 
 
int main()
{
    Server s;
    Client c;
 
    while(!web.is_end())
    {
        s.go();
        s.go();
        c.go();
        c.go();
 
        std::cout << ".... press enter\n";
        std::cin.get(); /// Моделируем магнитные бури ...
    }
}

#include <iostream>
///----------------------------------------------------------------------------|
/// ...
///----------------------------------------------------------------------------:
#include <cstdlib>
#include <vector>
#include <string>
#include <ctime>
 
#define  l(v)  std::cout << #v << " = " << v << "\n";
 
struct Plot{ size_t x, y; };
 
template<typename T>
T& operator<<(T& o, const Plot& p)
{          o << "{ " << p.x << ", " << p.y << " }";
    return o;
}
 
std::ostream& operator<<(std::ostream& o, std::vector<std::string>& f)
{
    const auto& H = f   .size();
    const auto& W = f[0].size();
 
    std::string line(W+2, '-');
    o << line << '\n';
    for    (size_t h = 0; h < H; ++h)
    {   o << "|";
        for(size_t w = 0; w < W; ++w)
        {   o << f[h][w];
        }   o << "|\n";
    }       o << line << '\n';
    return  o;
}
 
 
struct Rand
{   Rand(            ){   srand((unsigned)time(0));}
    Rand(unsigned sid){   srand(sid);              }
    int  operator   ()(int range_min, int range_max)   const
    {
        return rand () %  (range_max -    range_min) + range_min;
    }
}rrand;
 
 
struct  Bot
{       Bot      (std::string nm) :
            field(std::vector(10, std::string(10, '.'))),
            authorname  (nm),
            MAXSTEP(10 * 10 / 3)
        {
        }
 
    ///---------------------|
    /// Это ваше поле.      |
    ///---------------------:
    std::vector<std::string> field;
    std::string         authorname;
 
    int cnt_steps = 0;
    const int MAXSTEP;
 
    void step(const Plot p, char f)
    {   field[p.y][p.x] = f == 'X' ? 'O' : 'X';
        std::cout  << field      << std::endl;
    }
 
    ///-------------------------------|
    /// Это основной метод.           |
    /// его будет дёргать Арбитер,    |
    /// чтоб узнать ваше решение.     |
    ///-------------------------------:
    Plot step()
    {
        if(MAXSTEP == cnt_steps++) return {0, size_t(-1)};
 
        const auto& H = field   .size();
        const auto& W = field[0].size();
 
        Plot p;
 
        /// TODO ...
        ///--------------------...
        /// пример простейшего решения ...
        ///--------------------...
        while(true)
        {
            p.x = rrand(0, W);
            p.y = rrand(0, H);
 
            if( verification_no_info(p))
            {   field[p.y][p.x] = authorname.back();
 
                std::cout << authorname  << ": "
                          << p.x << ", " << p.y << ":\n";
 
                std::cout << field      << std::endl;
 
                return p;
            }
        }
 
        return {size_t(-1), 0};
    }
 
    void fclear()
    {   field = std::vector(10, std::string(10, '.'));
    }
 
private:
    bool verification_no_info(const Plot& p) const
    {   return field[p.y][p.x] == '.';
    }
};
 
struct Web
{
    bool is_end(){ return step.y == size_t(-1); }
 
    Plot step{5,5};
}web;
 
struct  Server
{       Server() : bot("Vasia-X") {}
 
    Bot bot;
 
    void go()
    {
        switch(now)
        {
            case 0:            bot.step(web.step, bot.authorname.back()); break;
            case 1: web.step = bot.step(                               ); break;
        }
 
        now = 1 - now;
    }
 
    int now = 1;
};
 
struct  Client
{       Client() : bot("John-O") {}
 
    Bot bot;
 
    void go()
    {
        switch(now)
        {
            case 0: web.step = bot.step(                               ); break;
            case 1:            bot.step(web.step, bot.authorname.back()); break;
        }
 
        now = 1 - now;
    }
 
    int now = 1;
};
 
 
int main()
{
    Server s;
    Client c;
 
    while(!web.is_end())
    {
        s.go();
        c.go();
        c.go();
        s.go();
 
        std::cout << ".... press enter\n";
        std::cin.get(); /// Моделируем магнитные бури ...
    }
}

::io::create_process_channel(m_strand.context(), "echo_cli -t")
//                                                  ^
//                                                 вот это в двух местах