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

#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;
}

///----------------------------------------------------------------------------|
/// ИИ.
///----------------------------------------------------------------------------:
struct AI
{
    Plot step(const Field& field)
    {
        /// TODO ...
 
        return {size_t(-1), 0};
    }
};

    bool verification(const Plot& p)
    {   return p.x < W && p.y < H && m[p.y][p.x] == EMPTY;
    }

extern "C"
{
    DLLEXP void         _create(                  ){        ai = new AI()  ; }
    DLLEXP Plot           _step(const Field& field){ return ai->step(field); }
    DLLEXP const wchar_t* _name(                  ){ return name           ; }
    DLLEXP void         _delete(                  ){ delete ai             ; }
}

///
/// C++17
/// Исходник(DLL) в UTF-8
///----------------------------------------------------------------------------|
/// AI для игры в крестонолики. (это dll проект.)
///----------------------------------------------------------------------------:
#include <fstream>
#include <vector>
#include <string>
#include <ctime>
#include <cstdlib>
 
#pragma pack(push, 1)
 
///--------------------------------------------------|
/// ...                                              |
///--------------------------------------------------:
const wchar_t* name = L"Автор Randович";
 
///----------|
/// Конфиг.  |
///----------:
namespace  cfg
{
    ///-----------------------------|
    /// Количество фишек для победы.|
    ///-----------------------------:
    const size_t FWIN   =  5;
    const size_t WIDTH  = 10; /// Размер поля по горизонтали.
    const size_t HEIGHT =  5; /// Размер поля по вертикали.
    ///-----------------------------.
 
} // End namespace cfg
 
struct Plot
{   size_t x, y;
};
 
///----------------------------------------------------------------------------|
/// Поле.
///----------------------------------------------------------------------------:
struct  Field
{       Field() : m(nullptr)
        {   create();
        }
 
    const char EMPTY = '.';
 
    size_t W = 0,
           H = 0;
 
    ///---------------------------|
    /// Проверка фишки на выигрыш.|
    ///---------------------------:
    bool is_win(const char FISHKA) const
    {
        std::string fishka(cfg::FWIN, FISHKA);
 
        for(const auto& str : get_all_str())
        {   if(str.find(fishka) != str.npos) return true;
        }
        return false;
    }
 
    ///---------------------------|
    /// Есть ли ходы?             |
    ///---------------------------:
    bool is_step() const
    {   for    (size_t h = 0; h < H; ++h)
        {   for(size_t w = 0; w < W; ++w)
            {   if(m[h][w] == EMPTY) return true;
            }
        }
        return false;
    }
 
    char* operator[](const size_t i)
    {   return  m[i];
    }
 
    void clear()
    {   for    (size_t h = 0; h < H; ++h)
        {   for(size_t w = 0; w < W; ++w)
            {   m[h][w] = EMPTY;
            }
        }
    }
 
    void fill_for_test()
    {   char cnt = 'A';
        for    (size_t h = 0; h < H; ++h)
        {   for(size_t w = 0; w < W; ++w)
            {   m[h][w] = cnt++;
            }
        }
    }
 
    bool verification(const Plot& p) const
    {   return p.x < W && p.y < H && m[p.y][p.x] == EMPTY;
    }
 
private:
    char** m;
 
    void create()
    {   if(nullptr !=  m)  return;
 
        m = new char* [H];
        for (size_t i = 0; i < H; i++)
        {   m[i] = new char[W];
        }
    }
 
    #define TESTMODE false
    ///---------------------------|
    /// Разворачиваем строки!     |
    ///---------------------------:
    std::vector<std::string> get_all_str() const
    {
        std::vector<std::string> r;
 
        for    (size_t h = 0; h < H; ++h)
        {   r.push_back(std::string());
            for(size_t w = 0; w < W;  ++w)
            {   r.back().push_back(m[h][w]);
            }
        }
 
        for    (size_t w = 0; w < W;  ++w)
        {   r.push_back(std::string());
            for(size_t h = 0; h < H; ++h)
            {   r.back().push_back(m[h][w]);
            }
        }
 
        ///---------------------------|
        /// Повернуть на -45 градусов.|
        ///---------------------------:
        for    (size_t h = 0; h < H; ++h)
        {   std::string s;
            for(size_t w = 0, y = h; w < W && y < H; ++w, ++y)
            {   s.push_back(m[y][w]);
            }
            if(s.size() >= cfg::FWIN || TESTMODE)
            {   r.push_back(s);
            }
        }
 
        for    (size_t w = 1; w < W; ++w)
        {   std::string s;
            for(size_t x = w, h = 0; x < W && h < H; ++x, ++h)
            {   s.push_back(m[h][x]);
            }
            if(s.size() >= cfg::FWIN || TESTMODE)
            {   r.push_back(s);
            }
        }
 
        ///---------------------------|
        /// Повернуть на +45 градусов.|
        ///---------------------------:
        for    (size_t h = 0; h < H; ++h)
        {   std::string s;
            for(size_t w = W - 1, y = h; w < W && y < H; --w, ++y)
            {   s.push_back(m[y][w]);
            }
            if(s.size() >= cfg::FWIN || TESTMODE)
            {   r.push_back(s);
            }
        }
 
        for    (size_t w = W - 2; w < W; --w)
        {   std::string s;
            for(size_t x = w, h = 0; x < W && h < H; --x, ++h)
            {   s.push_back(m[h][x]);
            }
            if(s.size() >= cfg::FWIN || TESTMODE)
            {   r.push_back(s);
            }
        }
 
        return r;
    }
    #undef TESTMODE
};
 
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
{
    Plot step(const Field& field)
    {
        /// TODO ...
 
        while(true)
        {
            Plot p;
                 p.x = rrand(0, field.W);
                 p.y = rrand(0, field.H);
 
            if(field.verification(p)) return p;
        }
 
        return {size_t(-1), 0};
    }
};
 
#define DLLEXP __declspec (dllexport)
 
static AI* ai = nullptr;
///--------------------------------------------------|
/// Интерфейс AI.                                    |
///--------------------------------------------------:
extern "C"
{
    DLLEXP void         _create(                  ){        ai = new AI()  ; }
    DLLEXP Plot           _step(const Field& field){ return ai->step(field); }
    DLLEXP const wchar_t* _name(                  ){ return name           ; }
    DLLEXP void         _delete(                  ){ delete ai             ; }
}
 
#undef DLLEXP

/// main.exe
///----------------------------------------------------------------------------|
/// ИИ.
///----------------------------------------------------------------------------:
#include <windows.h>
 
typedef void          (__stdcall * _create_t)(                  );
typedef Plot          (__stdcall * _step_t  )(const Field& field);
typedef const wchar_t*(__stdcall * _name_t  )(                  );
typedef void          (__stdcall * _delete_t)(                  );
 
struct AI
{   Plot step(const Field& field) const
    {   /// TODO ...
 
        return {size_t(-1), 0};
    }
 
    _create_t _create;
    _step_t   _step  ;
    _name_t   _name  ;
    _delete_t _delete;
 
    int load_dll()
    {   HINSTANCE hGetProcIDDLL = LoadLibrary("0.dll");
 
        if (!hGetProcIDDLL)
        {   std::cout << "could not load the dynamic library" << std::endl;
            return EXIT_FAILURE;
        }
 
        _name = (_name_t)GetProcAddress(hGetProcIDDLL, "_name");
        if (!_name)
        {   std::cout << "could not locate the function" << std::endl;
            return EXIT_FAILURE;
        }
 
        std::wcout << L"_name() returned " << _name() << std::endl;
 
        return EXIT_SUCCESS;
    }
 
public:
    static void testclass();
};
/// Тест:
///------------------------------|
/// ...
///------------------------------:
void AI::testclass()
{   std::wcout << L"TEST AI:\n";
 
    AI  ai;
        ai.load_dll();
 
    std::wcout << "TEST FINSHED!\n";
    std::cin.get();
}

///----------------------------------------------------------------------------|
/// ИИ.
///----------------------------------------------------------------------------:
#include <windows.h>
 
typedef const wchar_t*(__stdcall * _name_t  )(                  );
typedef Plot          (__stdcall * _step_t  )(const Field& field);
typedef void          (__stdcall * _create_t)(                  );
typedef void          (__stdcall * _delete_t)(                  );
 
struct  AI
{       AI()
        {   if(EXIT_SUCCESS == load_dll()) std::wcout << L"DLL load GOOD!\n";
        }
 
    Plot step(const Field& field) const
    {   /// TODO ...
 
        return {size_t(-1), 0};
    }
 
    _name_t   _name  ;
    _step_t   _step  ;
    _create_t _create;
    _delete_t _delete;
 
    int load_dll()
    {   HINSTANCE hGetProcIDDLL = LoadLibrary("0.dll");
 
        if (!hGetProcIDDLL)
        {   std::cout << "could not load the dynamic library" << std::endl;
            return EXIT_FAILURE;
        }
 
        _name = (_name_t)GetProcAddress(hGetProcIDDLL, "_name");
        if (!_name)
        {   std::cout << "ERROR: dll load _name" << std::endl;
            return EXIT_FAILURE;
        }
 
        std::wcout << L"_name() returned: " << _name() << std::endl;
 
        _step = (_step_t)GetProcAddress(hGetProcIDDLL, "_step");
        if (!_step)
        {   std::cout << "ERROR: dll load _step" << std::endl;
            return EXIT_FAILURE;
        }
 
        _create = (_create_t)GetProcAddress(hGetProcIDDLL, "_create");
        if (!_create)
        {   std::cout << "ERROR: dll load _create" << std::endl;
            return EXIT_FAILURE;
        }
 
        _create();
 
        _delete = (_delete_t)GetProcAddress(hGetProcIDDLL, "_delete");
        if (!_delete)
        {   std::cout << "ERROR: dll load _delete" << std::endl;
            return EXIT_FAILURE;
        }
 
        return EXIT_SUCCESS;
    }
 
public:
    static void testclass();
};
/// Тест:
///------------------------------|
/// ...
///------------------------------:
void AI::testclass()
{   std::wcout << L"TEST AI:\n";
 
    Field f;
    AI   ai;
 
        std::wcout << ai._step(f) << '\n';
        std::wcout << ai._step(f) << '\n';
        std::wcout << ai._step(f) << '\n';
        std::wcout << ai._step(f) << '\n';
        std::wcout << ai._step(f) << std::endl;
 
    std::wcout << "TEST FINISHED!\n";
    std::cin.get();
}

Plot step(Plot last_step);