Морской бой (по плану)

///----------------------------------------------------------------------------|
/// Cкелетик пржэкта SeaBatle:
///-------------------------------------------------------статус:В разработке...
#include <iostream>
using std::cout;
 
#include <time.h>
int rrand(int range_min = 0, int range_max = 9)
{   return rand() % (range_max - range_min + 1) + range_min;
}
 
int colorr[10] = {4, 5, 6, 7, 11, 12, 13, 14, 3, 15};
 
#include <Windows.h>
#define SHOW_CHAR(N, color)  \
    mySetColor(color);       \
    cout << N << "\n";       \
    mySetColor()
#define S(N,C) "";mySetColor(C);cout<<N;mySetColor();cout
 
void mySetColor(UINT text = 7, UINT background = 0) // #include <Windows.h>
{   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                        (WORD)((background << 4) | text));
}
HANDLE hwD;
void gotoxy(int x, int y, char c = 'O')
{   COORD Gon = { SHORT(x*4+23), SHORT(y*2+5) };
    SetConsoleCursorPosition(hwD, Gon);
    SHOW_CHAR(char(c+64), colorr[c]);
}
void cls_field()
{   for(int x = 0; x < 10; x++)
    {   for(int y = 0; y < 10; y++)
        {   COORD Gon = { SHORT(x*4+23), SHORT(y*2+5) };
            SetConsoleCursorPosition(hwD, Gon);
            cout << ' ';
        }
    }
}
void calibr()
{   COORD Gon = { SHORT(19), SHORT(3) };
    SetConsoleCursorPosition(hwD, Gon);
    cout << 'W';
}
typedef BOOL (WINAPI *FN_SETCONSOLEFONT)(HANDLE, DWORD);
FN_SETCONSOLEFONT SetConsoleFont;
void setfont_01()
{   HMODULE hm = GetModuleHandleW(L"KERNEL32.DLL");
    SetConsoleFont = (FN_SETCONSOLEFONT) GetProcAddress(hm, "SetConsoleFont");
    SetConsoleFont(hwD, 9);
    //6 в Windows 7 ставит Lucida 12
}
void hidecursor()
{   CONSOLE_CURSOR_INFO info;
    info.dwSize = 100;
    info.bVisible = FALSE;
    SetConsoleCursorInfo( hwD, &info );
}
 
///----------------------------------------------------------------------------|
const int NUMBERMAX_BOAT_TYPE  =   4; /// Количество типов кораблей.
const int MAX_PALUB            =   4; /// Mаксимальное количество палуб.
const int MAX_BOAT             =  10; /// Количество кораблей.
const int NUM_BOAT[MAX_BOAT]   = {1,1,1,1,2,2,2,3,3,4};
 
enum STATUS {STATUS_EMPTY = 0, STATUS_LIVE, STATUS_BOOM};
 
struct sPaluba///--------------------------------------------------------------|
{   int x, y;
    int status; /// 0 - пусто.
                /// 1 - целый отсек коробля.
                /// 2 - подбитый отсек коробля.
    int n;      /// Номер корабля.
};
 
struct sBoat///----------------------------------------------------------------|
{   sBoat() : p(0)
    {   for(int i = 0; i < MAX_PALUB; ++i)
        {   p_paluba[i] = nullptr;
        };
    }
 
    sPaluba* p_paluba[MAX_PALUB];
    int p; /// Количество палуб.
 
    void show()
    {   cout << "\n";
        cout << "Для одного корабля:--------------------------------------->\n";
        for(int i = 0; i < p; i++)
        {   if(p_paluba[i] == nullptr) cout << "Ахтунг! nullptr";
            cout << "Палуба:------------------|||\n"
                 << "Номер корабля:" << p_paluba[i]->n      << "\n"
                 << "Координатa x: " << p_paluba[i]->x      << "\n"
                 << "Координатa y: " << p_paluba[i]->y      << "\n"
                 << "Статус:       " << p_paluba[i]->status << "\n"
                 << "Кол.палуб:    " << p                   << "\n\n";
        }
    }
    void showgraf()
    {   for(int i = 0; i < p; i++)
        {   gotoxy(p_paluba[i]->x, p_paluba[i]->y, p_paluba[i]->n);
        }
    }
};
 
/// Поле боя://----------------------------------------------------------------|
struct sField
{   static const int X = 10;
    static const int Y = 10;
    sPaluba paluba[X][Y];
};
 
/// Игрок://-------------------------------------------------------------------|
struct sPlayer
{   sPlayer()
    {   init_empty();
        computer_init_boat();
    }
    sPlayer(const char* str)
    {   init_empty();
        user_init_boat();
    }
 
    void init_empty()
    {   for(int i = 0; i < 10; i++)
        {   for(int j = 0; j < 10; j++)
            Field.paluba[i][j].status = STATUS_EMPTY;
        }
    }
 
    void user_init_boat()
    {   // Инициализация boat[]
        ///...
    }
    void computer_init_boat()
    {   // Инициализация boat[]
        ///...
    }
 
    void stepI()
    {   ///...
    }
    void stepComp()
    {   ///...
    }
 
    sField Field;
    sBoat  boat[MAX_BOAT];
 
    void show()
    {   cout << "\n===========================================Все корабли:===>";
        for(int i =0; i < MAX_BOAT; i++)
        {   boat[i].show();
            //getchar();
        }
    }
 
    void showgraf()
    {   for(int i = 0; i < MAX_BOAT; i++)
        {   boat[i].showgraf();
        }
    }
//private:
    void generator()
    {   init_empty();
        
        int n  = 0;
        int nn;
        /// Начинаем с 0 корабля:
        for(nn = 0; nn < MAX_BOAT; nn++)
        {
            /// Количество NUM_BOAT[nn] палуб:
            int j = NUM_BOAT[nn];
            while(true)
            {   int xx = rrand();
                int yy = rrand();
 
                if (Field.paluba[xx][yy].status == STATUS_EMPTY)
                {   Field.paluba[xx][yy].x = xx;
                    Field.paluba[xx][yy].y = yy;
 
                    boat[nn].p  = j;
 
                    gen_add(Field.paluba[xx][yy], j, nn);
                    n += NUM_BOAT[nn];
                    break;
                }
            }
        }
        if(MAX_BOAT != nn)
        {   cout << "ахтунг!\n";
        }
    }
 
private:
    void gen_add(sPaluba pp, int amount_paluba, int _nn)
    {
        initpaluba(pp, _nn, 0);
 
        //if(1 == amount_paluba) return;
        for(int i = 1; i < amount_paluba; i++)
        {   //cout << "#";
            bool done = true;
            sPaluba _pp = pp;
            int ZAS     = 0;           /// Защита от загнанного цикла...
            do{
                if(ZAS++ > 100) break; /// Теряем палубы...
                done  = true;
                pp    = _pp;
                int r = rrand(0, 3);
                //cout << "\r" << r ;
                switch(r)
                {   case 0:
                        if(pp.x != 9) // На берег не вылазеем!!!
                        {   pp.x++;
                            done = false;
                        }
                        break;
                    case 1:
                        if(pp.x != 0)
                        {   pp.x--;
                            done = false;
                        }
                        break;
                    case 2:
                        if(pp.y != 9)
                        {   pp.y++;
                            done = false;
                        }
                        break;
                    case 3:
                        if(pp.y != 0)
                        {   pp.y--;
                            done = false;
                        }
                        break;
                    default:
                        cout << "Рандом сломался!!!\n";
                }
            }while((Field.paluba[pp.x][pp.y].status != STATUS_EMPTY) || done
                   ); // Повторить если ячейка занята!
            /// Внимание цикл может уйти в бесконечность где-нить в углу!
            initpaluba(pp, _nn, i);
        }
    }
    void initpaluba(sPaluba& P, int _nn, int _pal)
    {   //cout << "\n@@@@@\n";
        Field.paluba[P.x][P.y].status = STATUS_LIVE;
        Field.paluba[P.x][P.y].n      = _nn; // Номер корабля
 
        /// Клетка поля хранит собственные координаты:
        Field.paluba[P.x][P.y].x      = P.x;
        Field.paluba[P.x][P.y].y      = P.y;
 
        boat[_nn].p_paluba[_pal]  = &Field.paluba[P.x][P.y];
    }
};
 
struct sArbitrator///----------------------------------------------------------|
{
    sArbitrator(sPlayer& a, sPlayer& b)
    {}
 
    bool done()//--------------------------------------------------------------|
    {   ///...
        return true;
    }
 
    void show()
    {
cout << "Sea Battle...\n\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 |   | A | B | C | D | E | F | G | J | K | L |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 0 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 1 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 2 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 3 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 4 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 5 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 6 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 7 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 8 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "                 | 9 |   |   |   |   |   |   |   |   |   |   |\n";
cout << "                 |---|---------------------------------------|\n";
cout << "\n...нажмите ENTER\n\n";
    }
};
 
///-Main-----------------------------------------------------------------------|
int main()
{   setlocale(0, "");
    hwD = GetStdHandle(STD_OUTPUT_HANDLE);
    setfont_01();
    hidecursor();
 
    // Инициализация рандома:
    srand(static_cast<unsigned int>(time(NULL)));
 
    system ("mode con cols=80 lines=29");
 
    sPlayer PlayerComp,
            PlayerI("myname");
 
    sArbitrator arbitrator(PlayerComp, PlayerI);
 
  //PlayerComp.Field.paluba[x][y].status;
  //PlayerI.Field.paluba[x][y].status;
    arbitrator.show();
    while(arbitrator.done())
    {   //system("cls");
        // Обойдемся без полиформизма, хотя....
        PlayerI.stepI();
        PlayerComp.stepComp();
 
        ///(это будет не здесь)Тест:
        PlayerComp.generator();
        cls_field();
        PlayerComp.showgraf();
        //calibr();
 
        getchar();///<<<---временно...
    }
 
    return 0;
}