Консольный морской бой. Расстановка кораблей

#include <iostream>
#include <time.h>
#include <conio.h>
using namespace std;
 
// размер поля 10х10 + 1 поле для индексации
const size_t field_size = 11;
 
const char default_symb = '-';
const char nonwritable_symb = '.';
const char sheep_symb = 'O';
 
 
char **create_field(const size_t, const size_t);
void init_field (char **);
void show_field (char **);
void init_sheep (char **, unsigned short, unsigned short);
// можно ли ставить кораблик в точку X,Y
bool IsEmpty (char**, int, int);
void MarkNear (char **field);
void UnMark (char **field);
 
int main()
{   
    setlocale (LC_ALL,"Rus");
    char ch = '\0';
    char **plr, **cpu;
    
    srand( (unsigned)time(NULL) );
    
    // Player's game space
    plr = create_field(field_size, field_size);
    // CPU's game space
    cpu = create_field(field_size, field_size);
 
    do 
    {
        system("CLS");
        // Заполняем значениями
        init_field(plr);
        // Расставляем корабли
        size_t SHEEP_SIZE = 4;
        size_t SHEEP_COUNT = 1;
        while (SHEEP_SIZE>0)
        {
            init_sheep(plr, SHEEP_SIZE, SHEEP_COUNT);
            SHEEP_SIZE--;
            SHEEP_COUNT++;
        }
            UnMark(plr);
            show_field(plr);
        cout << "\nRepeat? (y/n)\n";
        ch = getch();
    } while ( (ch != 'n') && (ch != 'N') );
 
    return 0;
}
 
char **create_field(const size_t rows, const size_t cols)
{
    char **temp = new char* [rows];
 
    for (size_t i = 0; i < rows; ++i)
         temp[i] = new char [cols];
 
     if (temp == 0)
     {
         cout << "\nНе удалось выделить память под массив\n";
         return 0;
     }
     else 
         return temp;
}
 
void show_field(char **field)
{
    for (size_t i=0; i<field_size; i++)
    {
        for (size_t j=0; j<field_size; j++)
            cout << *(*(field + i) + j) << ' ';
        cout << '\n';
    }
}
 
void init_field(char **field)
{
    field[0] = " РЕСПУБЛИКА";
    for (size_t i=1; i<field_size; i++)
        field[i][0] = 47+i;
 
    for (size_t i=1; i<field_size; i++)
        for (size_t j=1; j<field_size; j++)
            field[j][i] = default_symb;
}
 
bool IsEmpty (char **field, int pointX, int pointY)
{
    if ( field[pointY][pointX] == default_symb )
        return true;
    else
        return false;
}
 
void MarkNear (char **field)
{
    short near[8][2] = { {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1} };
    short add_x, add_y;
 
    for (unsigned short y=1; y<field_size; y++)
        for (unsigned short x=1; x<field_size; x++)
            if (field[y][x] == sheep_symb)
                for (unsigned short i=0; i<8; i++)
                {
                    add_x = x + near[i][0];
                    add_y = y + near[i][1]; 
                    if ( add_x >= 1 && add_x <= field_size-1 && add_y >= 1 && add_y <= field_size-1 && field[add_y][add_x] == default_symb)
                        field[add_y][add_x] = nonwritable_symb; 
                }
}
void UnMark (char **field)
{
    for (unsigned short y=1; y<field_size; y++)
        for (unsigned short x=1; x<field_size; x++)
            if (field[y][x] == nonwritable_symb)
                field[y][x] = default_symb;
}
 
void init_sheep (char **field, unsigned short DECKS, unsigned short COUNT)
{
    int X;
    int Y;
    int add_X;
    int add_Y;
    
    // один из 4-х вариантов пути приращения
    size_t way;
    // количество сгенерированных палуб
    size_t decks_count;
    // направление(X,Y) приращивания координат = вверх, вниз, влево, вправо 
    int direction[4][2] = { {0,1},{0,-1},{-1,0},{1,0} };
    // количество сгенерированных кораблей
    unsigned short sheeps_counter = 0;
 
    while (sheeps_counter < COUNT)
    {
    decks_count = 0;
    while (decks_count < DECKS)
    {
        if (decks_count == 0)
        {
            // большие корабли прижимаем к стенкам :)
            if (DECKS > 1)
            {
                size_t variant = rand()%4;
                switch (variant)
                {
                    case 0:
                        X = 1;
                        Y = rand()%(field_size-1)+1;
                        break;
                    case 1:
                        X = field_size-1;
                        Y = rand()%(field_size-1)+1;
                        break;
                    case 2:
                        X = rand()%(field_size-1)+1;
                        Y = 1;
                        break;
                    case 3:
                        X = rand()%(field_size-1)+1;
                        Y = field_size-1;
                        break;
                }
            }
            
            if (DECKS == 1)
            {
                X = rand()%(field_size-1)+1;
                Y = rand()%(field_size-1)+1;
            }
            if ( IsEmpty(field, X,Y) )
            {
                field[Y][X] = sheep_symb;
                decks_count++;
            }
        } else if (decks_count > 0 )
        {
            way = rand()%4;
            add_X = direction[way][0];
            add_Y = direction[way][1];
 
            if ( ((add_X + X) >= 1) && ((add_X + X) <= (field_size-1)) && ((add_Y + Y) >= 1) && ((add_Y + Y) <= (field_size-1)) ) 
            {
                if ( IsEmpty (field,(add_X + X),(add_Y + Y)) )
                {
                    X += add_X;
                    Y += add_Y;
                    field[Y][X] = sheep_symb;
                    decks_count++;
                }
            }
            
        }
    }
    sheeps_counter++;
    MarkNear(field);
    }
 
}

/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
class  T_battleship
{
    static const int    SHIP_SIZE_MIN   =   1;
    static const int    SHIP_SIZE_MAX   =   4;
    static const int    FIELD_ORDER     =   10;
    static const int    DIST_MIN        =   2;
    static const int    WATER_SYMB      =   ' ';
    static const int    SHIP_SYMB       =   'X';
    //-----------------------------------------------------------------------------------
    struct  T_cell
    {
        int     row_;
        int     col_;
        //-------------------------------------------------------------------------------
    public:
        //-------------------------------------------------------------------------------
        T_cell
            (
                int     row,
                int     col
            )
            :
            row_( row ),
            col_( col )
        {}
        //-------------------------------------------------------------------------------
        void  shift_to_right()
        {
            ++col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_down()
        {
            ++row_;
        }
        //-------------------------------------------------------------------------------
        int  dist( const T_cell&  cell )    const
        {
            return  std::max
                        (
                            abs( row_ - cell.row_ ),
                            abs( col_ - cell.col_ )
                        );
        }
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    typedef std::vector<T_cell>         T_ship;
    typedef std::vector<T_ship>         T_ships;
    typedef std::vector<char>           T_field_row;
    typedef std::vector<T_field_row>    T_field;
    //-----------------------------------------------------------------------------------
    T_ships     ships_;
    T_field     field_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_battleship()
        :
        field_
            (
                T_field
                    (
                        FIELD_ORDER,
                        T_field_row
                            ( 
                                FIELD_ORDER,
                                WATER_SYMB
                            )
                    )
            )
    {}
    //-----------------------------------------------------------------------------------
    void  rand_fill_field()
    {
        rand_fill_ships             ();
        to_display_ships_in_field   ();
    }
    //-----------------------------------------------------------------------------------
    void  print_field()   const
    {
        for(int  i = 0; i < FIELD_ORDER; ++i)
        {
            for(int  j = 0; j < FIELD_ORDER; ++j)
            {
                std::cout << field_[i][j]
                          << ' ';
            }    
            std::cout << std::endl;
        }
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  to_display_ships_in_field()
    {
        for (
                T_ships::const_iterator
                ship_it     =   ships_.begin    ();
                ship_it     !=  ships_.end      ();
                ++ship_it            
            )
        {
            for (
                    T_ship::const_iterator
                    cell_it     =   ship_it->begin  ();
                    cell_it     !=  ship_it->end    ();
                    ++cell_it
                )
            {
                field_
                    [ cell_it->row_ ]
                    [ cell_it->col_ ]   =   SHIP_SYMB;
            }
        }
    }
    //-----------------------------------------------------------------------------------
    void  rand_fill_ships()
    {
        for( int  ship_size = SHIP_SIZE_MIN; ship_size <= SHIP_SIZE_MAX; ++ship_size )
        {
            int  quantity   =   SHIP_SIZE_MAX + 1 - ship_size;
            for(int  i = 0; i < quantity; ++i)
            {
                add_correct_rand_ship_with_size( ship_size );
            }
        }
    }
    //-----------------------------------------------------------------------------------
    void  add_correct_rand_ship_with_size( int  size )
    {
        T_ship  ship;
        do
        {
            bool    is_horiz        =   rand() % 2 == 0;
            int     horiz_size      =   SHIP_SIZE_MIN;
            int     vert_size       =   SHIP_SIZE_MIN;
            is_horiz
                ?   horiz_size  =   size
                :   vert_size   =   size;
 
            int     pos_row_max     =   FIELD_ORDER - vert_size;
            int     pos_col_max     =   FIELD_ORDER - horiz_size;
 
            T_cell  left_top_pos    =   get_rand_cell
                                            (
                                                pos_row_max,
                                                pos_col_max
                                            );
 
            ship    =   get_ship_in_pos_with_arrangement_and_size
                            (
                                left_top_pos,
                                is_horiz,
                                size
                            );
 
        }while  (
                    !ship_is_correct( ship )
                );
        ships_.push_back( ship );
    }
    //-----------------------------------------------------------------------------------
    T_cell  get_rand_cell
        (
            int     row_max,
            int     col_max
        )
    {
        int  row    =   get_rand_val(0, row_max);
        int  col    =   get_rand_val(0, col_max);
 
        T_cell  res     =   T_cell
                                (
                                    row,
                                    col
                                );
 
        return  res;
    }
    //-----------------------------------------------------------------------------------
    T_ship  get_ship_in_pos_with_arrangement_and_size
        (
            const T_cell&   left_top_pos,
            bool            is_horiz,
            int             size
        )
    {
        T_ship  ship;
        T_cell  cur_cell    =   left_top_pos;
        for(int  i = 0; i < size; ++i)
        {
            ship.push_back( cur_cell );
            is_horiz
                ?   cur_cell.shift_to_right     ()
                :   cur_cell.shift_down         ();
        }
        return  ship;
    }
    //-----------------------------------------------------------------------------------
    bool  ship_is_correct( const T_ship&  ship )
    {
        bool    bool_res    =   true;
 
        for (
                T_ships::const_iterator
                ship_it     =   ships_.begin    ();
                ship_it     !=  ships_.end      ();
                ++ship_it
            )
        {
            if  (
                        dist
                            (
                                *ship_it,
                                ship
                            )
 
                    <   DIST_MIN
                )
            {
                bool_res    =   false;
                break;
            }
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    int  dist
        (
            const T_ship&   L,
            const T_ship&   R
        )
    {
        int     res_dist    =   FIELD_ORDER;
        for (
                T_ship::const_iterator
                L_cell_it     =   L.begin     ();
                L_cell_it     !=  L.end       ();
                ++L_cell_it
            )
        {
            for (
                    T_ship::const_iterator
                    R_cell_it     =   R.begin     ();
                    R_cell_it     !=  R.end       ();
                    ++R_cell_it
                )
            {
                int     cur_dist    =   L_cell_it->dist( *R_cell_it );
                if( cur_dist < res_dist )
                {
                    res_dist = cur_dist;
                }
            }//for
        }//for
        return  res_dist;
    }
    //-----------------------------------------------------------------------------------
    int  get_rand_val
        (
            int     val_min,
            int     val_max
        )
    {
        return  rand() % ( val_max - val_min + 1 ) + val_min;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    srand(static_cast<unsigned>(time(0)));
    T_battleship    battleship;
    battleship.rand_fill_field  ();
    battleship.print_field      ();
}

0 1 2 3 4 5 6
1 - - - - - -
2 о - - - - -
3 - - - - - -