На чем писать игру 2048 - C++

/////////////////////////////////////////////////////////////////////////////////////////
//Правила игры
//
//  В каждом раунде появляется плитка номинала «2» (с вероятностью 90%) или «4» (с вероятностью 10%)
//  Нажатием стрелки игрок может скинуть все плитки игрового поля в одну из 4 сторон. 
//  Если при сбрасывании две плитки одного номинала «налетают» одна на другую, то 
//  они слипаются в одну, номинал которой равен сумме соединившихся плиток. 
//  Если при нажатии кнопки местоположение плиток или их номинал не изменится, то ход не совершается.
//  За каждое соединение игровые очки увеличиваются на номинал получившейся плитки.
//  Игра заканчивается, если после очередного хода невозможно совершить действие.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <conio.h>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
#include <windows.h>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::pair       < int,   int    >   T_cell;
typedef std::vector     < T_cell        >   T_cells;
typedef std::vector     < int           >   T_row;
typedef std::vector     < T_row         >   T_matr;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_game_2048
{
    //-----------------------------------------------------------------------------------
    static  int     const   MATR_DIM                =   4;
    static  char    const   CELL_VAL_EMPTY_SYMB     =   '_';
 
    static  int     const   CELL_VAL_EMPTY          =   0;
    static  int     const   CELL_VAL_MIN            =   2;
    static  int     const   CELL_VAL_MIN_TWICE      =   CELL_VAL_MIN * 2;
    static  int     const   CELL_VAL_MAX            =   131072;
 
    static  int     const   ARROW_KEY_FIRST_BYTE    =   224;
 
    static  int     const   LEFT_ARROW_KEY          =   75;
    static  int     const   RIGHT_ARROW_KEY         =   77;
    static  int     const   UP_ARROW_KEY            =   72;
    static  int     const   DOWN_ARROW_KEY          =   80;
    //-----------------------------------------------------------------------------------
    int         result_;
    int         cur_max_cell_val_;
    T_cells     free_cells_;
    T_matr      matr_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_game_2048()
        :
        result_             (),
        cur_max_cell_val_   (),
 
        matr_               (
                                T_matr
                                    (
                                        MATR_DIM,
                                        T_row
                                            (
                                                MATR_DIM,
                                                CELL_VAL_EMPTY
                                            )
                                    )
                            )
    {}
    //-----------------------------------------------------------------------------------
    void    play()
    {
        set_rand_val_into_rand_free_cell    ();
        set_rand_val_into_rand_free_cell    ();
        print                               ();
 
        while   (
                    cur_max_cell_val_ < CELL_VAL_MAX
                )
        {
            if  (
                    successfully_input_and_process_direction()
                )
            {
                set_rand_val_into_rand_free_cell    ();
                print                               ();
            }//if
        }
 
        std::cout   <<  "Игра закончена, так как достигнуто максимальное значение клетки "
                    <<  CELL_VAL_MAX
                    <<  "."
                    <<  std::endl;
 
        system( "pause" );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void    set_rand_val_into_rand_free_cell()
    {
        clear_and_calculate_free_cells();
 
        if  (
                free_cells_exist()
            )
        {
            set_val_into_cell
                (
                    get_rand_cell_val   (),
                    get_rand_free_cell  ()
                );
        }//if
    }
    //-----------------------------------------------------------------------------------
    void    clear_and_calculate_free_cells()
    {
        free_cells_.clear();
 
        for( int  i = 0; i < MATR_DIM; ++i )
        {
            for( int  j = 0; j < MATR_DIM; ++j )
            {
                if( matr_[i][j] == CELL_VAL_EMPTY )
                {
                    free_cells_.push_back( T_cell( i, j ) );
                }
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    bool    free_cells_exist()
    {
        return  !free_cells_.empty();
    }
    //-----------------------------------------------------------------------------------
    void    set_val_into_cell
        (
            int     val,
            T_cell  cell
        )
    {
        matr_[ cell.first ][ cell.second ]  =   val;
    }
    //-----------------------------------------------------------------------------------
    int     get_rand_cell_val()
    {
        T_row   values
                    (
                        9,
                        CELL_VAL_MIN
                    );
 
        values.push_back( CELL_VAL_MIN_TWICE );
 
        return  values
                    [
                        rand() % values.size()
                    ];
    }
    //-----------------------------------------------------------------------------------
    T_cell  get_rand_free_cell()
    {
        return  free_cells_[ rand() % free_cells_.size() ];
    }
    //-----------------------------------------------------------------------------------
    void    print()
    {
        system("cls");
 
        std::for_each
            (
                matr_.begin     (),
                matr_.end       (),
                T_print_row     ()
            );
 
        std::cout   <<  "Набрано очков "
                    <<  result_
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    struct  T_print_row
    {
        //-------------------------------------------------------------------------------
        void    operator()  ( T_row     const   &   row )
        {
            std::for_each
                (
                    row.begin           (),
                    row.end             (),
                    T_print_cell_val    ()
                );
 
            std::cout   <<  std::endl
                        <<  std::endl
                        <<  std::endl;
        }
        //-------------------------------------------------------------------------------
        struct  T_print_cell_val
        {
            void    operator()  ( int   val )
            {
                if( val ==  CELL_VAL_EMPTY )
                {
                    std::cout   <<  CELL_VAL_EMPTY_SYMB;
                }
                else
                {
                    std::cout   <<  val;
                }
                std::cout   <<  '\t';
            }
        };
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    bool    successfully_input_and_process_direction()
    {
        int     direction   =   0;
        return      successfully_input_direction    ( direction )
                &&  successfully_process_direction  ( direction );
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_input_direction    ( int   &   direction )
    {
        bool    bool_res    =   _getch() == ARROW_KEY_FIRST_BYTE;
 
        if( bool_res )
        {
            direction   =   _getch();
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_process_direction  ( int   direction )
    {
            switch( direction )
            {
            case    LEFT_ARROW_KEY      :   shift_left      ()  ;     return  true;
            case    RIGHT_ARROW_KEY     :   shift_right     ()  ;     return  true;
            case    UP_ARROW_KEY        :   shift_up        ()  ;     return  true;
            case    DOWN_ARROW_KEY      :   shift_down      ()  ;     return  true;
 
            default                     :                       ;     return  false;
            }//switch
    }
    //-----------------------------------------------------------------------------------
    void    shift_left()
    {
        std::for_each
            (
                matr_.begin                     (),
                matr_.end                       (),
                T_shift_row_left_with_result_and_cur_max_cell_val
                    (
                        result_,
                        cur_max_cell_val_
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    struct  T_shift_row_left_with_result_and_cur_max_cell_val
    {
        //-------------------------------------------------------------------------------
        int     &   result_;
        int     &   cur_max_cell_val_;
        //-------------------------------------------------------------------------------
        T_shift_row_left_with_result_and_cur_max_cell_val
            (
                int     &   result,
                int     &   cur_max_cell_val
            )
            :
            result_             ( result            ),
            cur_max_cell_val_   ( cur_max_cell_val  )
        {}
        //-------------------------------------------------------------------------------
        void    operator()  ( T_row     &   row )
        {
            for(;;)
            {
                auto    it  =   std::adjacent_find
                                    (
                                        row.begin                       (),
                                        row.end                         (),
                                        T_empty_and_non_empty_values    ()
                                    );
 
                if  (
                        it  ==  row.end()
                    )
                {
                    break;
                }
 
                std::iter_swap
                    (
                        it,
                        it + 1
                    );
            }//for
 
            auto    it  =   std::adjacent_find
                                (
                                    row.begin           (),
                                    row.end             (),
                                    T_non_empty_and_eq  ()
                                );
 
            if  (
                    it  !=  row.end()
                )
            {
                *it     *=  2;
                row.erase       ( it + 1 );
                row.push_back   ( CELL_VAL_EMPTY );
 
                int     val_twice   =   *it;
                result_             +=  val_twice;
 
                if( val_twice > cur_max_cell_val_ )
                {
                    cur_max_cell_val_ = val_twice;
                }
            }//If
        }
        //-------------------------------------------------------------------------------
        struct  T_empty_and_non_empty_values
        {
            bool    operator()
                (
                    int     L,
                    int     R
                )
            {
                return      L   ==  CELL_VAL_EMPTY
                        &&  R   !=  L;
            }
        };
        //-------------------------------------------------------------------------------
        struct  T_non_empty_and_eq
        {
            bool    operator()
                (
                    int     L,
                    int     R
                )
            {
                return      L   !=  CELL_VAL_EMPTY
                        &&  R   ==  L;
            }
        };
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    void    shift_right()
    {
        reverse_rows    ( matr_ );
        shift_left      ();
        reverse_rows    ( matr_ );
    }
    //-----------------------------------------------------------------------------------
    static  void    reverse_rows( T_matr    &   matr_ )
    {
        std::for_each
            (
                matr_.begin     (),
                matr_.end       (),
                T_reverse_row   ()
            );
    }
    //-----------------------------------------------------------------------------------
    struct  T_reverse_row
    {
        void    operator()  ( T_row     &   row )
        {
            std::reverse
                (
                    row.begin   (),
                    row.end     ()
                );
        }
    };
    //-----------------------------------------------------------------------------------
    void    shift_up()
    {
        transp      ( matr_ );
        shift_left  ();
        transp      ( matr_ );
    }
    //-----------------------------------------------------------------------------------
    void    transp( T_matr  &   matr )
    {
        for( int  i = 0; i < MATR_DIM; ++i )
        {
            for( int  j = i + 1; j < MATR_DIM; ++j )
            {
                std::swap
                    (
                        matr_[i][j],
                        matr_[j][i]
                    );
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void    shift_down()
    {
        transp          ( matr_ );
        shift_right     ();
        transp          ( matr_ );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
    T_game_2048     game_2048;
    game_2048.play();
}

    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));

/////////////////////////////////////////////////////////////////////////////////////////
//ПРАВИЛА ИГРЫ
//
//Игровое поле имеет форму квадрата 4x4.
//Целью игры является получение плитки номинала «2048» (при желании можно продолжить дальше).
//В каждом раунде появляется плитка номинала «2» (с вероятностью 90%) или «4» (с вероятностью 10%)
//Нажатием стрелки игрок может скинуть все плитки игрового поля в одну из 4 сторон. 
//Если при сбрасывании две плитки одного номинала «налетают» одна на другую, то 
//они слипаются в одну, номинал которой равен сумме соединившихся плиток. 
//Если при нажатии кнопки местоположение плиток или их номинал не изменится, то ход не совершается.
//За каждое соединение игровые очки увеличиваются на номинал получившейся плитки.
//Игра заканчивается, если после очередного хода невозможно совершить действие.
//Максимальный номинал плитки — 131 072.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <conio.h>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#include <windows.h>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                         T_str;
typedef std::pair       < int,   int    >   T_cell;
typedef std::vector     < T_cell        >   T_cells;
typedef std::vector     < int           >   T_row;
typedef std::vector     < T_row         >   T_matr;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_game_2048
{
    //-----------------------------------------------------------------------------------
    static  int     const   MATR_DIM                =   4;
    static  char    const   CELL_VAL_EMPTY_SYMB     =   '_';
 
    static  int     const   CELL_VAL_EMPTY          =   0;
    static  int     const   CELL_VAL_MIN            =   2;
    static  int     const   CELL_VAL_MIN_TWICE      =   CELL_VAL_MIN * 2;
    static  int     const   CELL_VAL_MAX            =   131072;
 
    static  int     const   ARROW_KEY_FIRST_BYTE    =   224;
 
    static  int     const   LEFT_ARROW_KEY          =   75;
    static  int     const   RIGHT_ARROW_KEY         =   77;
    static  int     const   UP_ARROW_KEY            =   72;
    static  int     const   DOWN_ARROW_KEY          =   80;
    //===================================================================================
    class  T_records
    {
        T_str   const   &   record_file_name_;
        int                 result_;
        int                 record_;
        int                 cur_max_cell_val_;
        //-------------------------------------------------------------------------------
    public:
        //-------------------------------------------------------------------------------
        T_records( T_str   const   &   record_file_name )
            :
            record_file_name_   ( record_file_name ),
            result_             (),
            record_             (),
            cur_max_cell_val_   ()
        {
            std::ifstream   i_record_file( record_file_name_ );
 
            if( i_record_file )
            {
                i_record_file   >>  record_;
            }
        }
        //-------------------------------------------------------------------------------
        ~T_records()
        {
            std::ofstream   o_record_file( record_file_name_ );
            o_record_file   <<  record_;
        }
        //-------------------------------------------------------------------------------
        bool    cur_max_cell_val_is_valid()                                         const
        {
            return  cur_max_cell_val_ <= CELL_VAL_MAX;
        }
        //-------------------------------------------------------------------------------
        void    set_records( int    cell_val )
        {
            result_     +=  cell_val;
 
            if( result_ > record_ )
            {
                record_ = result_;
            }
 
            if( cell_val > cur_max_cell_val_ )
            {
                cur_max_cell_val_ = cell_val;
            }
        }
        //-------------------------------------------------------------------------------
        void    print()                                                             const
        {
            std::cout   <<  "Набрано очков\t"
                        <<  result_
                        <<  std::endl
                        <<  "Рекорд\t\t"
                        <<  record_
                        <<  std::endl;
        }
        //-------------------------------------------------------------------------------
    };
    //===================================================================================
    class   T_rand_cell_val_generator
    {
        T_matr  &   matr_;
        T_row       rand_cell_values_;
        T_cells     free_cells_;
        //-------------------------------------------------------------------------------
    public:
        //-------------------------------------------------------------------------------
        T_rand_cell_val_generator( T_matr  &   matr )
            :
            matr_( matr ),
 
            rand_cell_values_
            (
                9,
                CELL_VAL_MIN
            )
        {
            rand_cell_values_.push_back( CELL_VAL_MIN_TWICE );
        }
        //-------------------------------------------------------------------------------
        void    set_rand_val_into_rand_free_cell()
        {
            if  (
                    free_cells_exist()
                )
            {
                set_val_into_cell
                    (
                        get_rand_cell_val   (),
                        get_rand_free_cell  ()
                    );
            }//if
        }
        //-------------------------------------------------------------------------------
        bool    free_cells_exist()
        {
            clear_and_calculate_free_cells();
 
            return  !free_cells_.empty();
        }
        //-------------------------------------------------------------------------------
    private:
        //-------------------------------------------------------------------------------
        void    clear_and_calculate_free_cells()
        {
            free_cells_.clear();
 
            for( int  i = 0; i < MATR_DIM; ++i )
            {
                for( int  j = 0; j < MATR_DIM; ++j )
                {
                    if( matr_[i][j] == CELL_VAL_EMPTY )
                    {
                        free_cells_.push_back
                            (
                                T_cell( i, j )
                            );
                    }
                }//for
            }//for
        }
        //-------------------------------------------------------------------------------
        int     get_rand_cell_val()                                                 const
        {
            return  get_rand_elem_from_container( rand_cell_values_ );
        }
        //-------------------------------------------------------------------------------
        T_cell  get_rand_free_cell()                                                const
        {
            return  get_rand_elem_from_container( free_cells_ );
        }
        //-------------------------------------------------------------------------------
        template< typename  T_cont >
        static  typename    T_cont::value_type  get_rand_elem_from_container
            ( T_cont    const   &   cont )
        {
            return  cont[ rand() % cont.size() ];
        }
        //-------------------------------------------------------------------------------
        void    set_val_into_cell
            (
                int         val,
                T_cell      cell
            )
        {
            matr_[ cell.first ][ cell.second ]  =   val;
        }
        //-------------------------------------------------------------------------------
    };
    //===================================================================================

    T_matr                      matr_;
    T_records                   records_;
    T_rand_cell_val_generator   rand_cell_val_generator_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_game_2048( T_str  const   &   record_file_name )
        :
        matr_   (
                    T_matr
                        (
                            MATR_DIM,
                            T_row
                                (
                                    MATR_DIM,
                                    CELL_VAL_EMPTY
                                )
                        )
                ),
 
        records_                    ( record_file_name ),
        rand_cell_val_generator_    ( matr_ )
    {}
    //-----------------------------------------------------------------------------------
    void    play()
    {
        rand_cell_val_generator_.set_rand_val_into_rand_free_cell   ();
 
        T_str   end_game_message;
 
        do
        {
            rand_cell_val_generator_.set_rand_val_into_rand_free_cell   ();
 
            if  (
                    !cur_max_cell_val_is_valid_or_set_end_game_message  ( end_game_message )
                )
            {
                break;
            }
 
            print();
        }
        while   (
                        is_continue_possibility_or_set_end_game_message                     ( end_game_message )
                    &&  successfully_input_and_process_direction_or_set_end_game_message    ( end_game_message )
                );
 
        std::cout   <<  end_game_message
                    <<  std::endl;
 
        system( "pause" );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    struct  T_non_empty_and_eq
    {
        bool    operator()
            (
                int     L,
                int     R
            )                                                                       const
        {
            return      L   !=  CELL_VAL_EMPTY
                    &&  R   ==  L;
        }
    };
    //-----------------------------------------------------------------------------------
    bool    cur_max_cell_val_is_valid_or_set_end_game_message
        ( T_str    &   end_game_message )                                           const
    {
        bool    bool_res    =   records_.cur_max_cell_val_is_valid();
 
        if( !bool_res )
        {
            std::ostringstream  sout;
 
            sout    <<  "Игра закончена, так как была попытка создания клетки с номиналом,\n"
                        "превышающим максимально допустимое значение "
                    <<  CELL_VAL_MAX
                    <<  ".";
 
            end_game_message    =   sout.str();
        }//if
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    is_continue_possibility_or_set_end_game_message     ( T_str     &   end_game_message )
    {
        bool    bool_res    =       rand_cell_val_generator_.free_cells_exist   ()
                                ||  is_shift_possibility                        ();
 
        if( !bool_res )
        {
            end_game_message    =   "Вы проиграли!";
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    is_shift_possibility()                                                  const
    {
        T_matr  transp_matr     =   matr_;
        transp( transp_matr );
 
        return      !all_rows_are_bad( matr_        )
                ||  !all_rows_are_bad( transp_matr  );
    }
    //-----------------------------------------------------------------------------------
    static  bool    all_rows_are_bad( T_matr    const   &   matr )
    {
        return  std::find_if
                    (
                        matr.begin      (),
                        matr.end        (),
                        T_row_is_good   ()
                    )
                    ==  matr.end();
    }
    //-----------------------------------------------------------------------------------
    struct  T_row_is_good
    {
        //-------------------------------------------------------------------------------
        bool    operator()  ( T_row     const   &   row )                           const
        {
            return  std::adjacent_find
                        (
                            row.begin           (),
                            row.end             (),
                            T_non_empty_and_eq  ()
                        )
                        !=  row.end();
        }
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    void    print()                                                                 const
    {
        system("cls");
 
        std::for_each  
            (
                matr_.begin     (),
                matr_.end       (),
                T_print_row     ()
            );
 
        records_.print();
        std::cout   <<  std::endl
                    <<  "(для выхода нажмите пробел)"
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    struct  T_print_row
    {
        //-------------------------------------------------------------------------------
        void    operator()  ( T_row     const   &   row )                           const
        {
            std::for_each
                (
                    row.begin           (),
                    row.end             (),
                    T_print_cell_val    ()
                );
 
            std::cout   <<  std::endl
                        <<  std::endl
                        <<  std::endl
                        <<  std::endl;
        }
        //-------------------------------------------------------------------------------
        struct  T_print_cell_val
        {
            void    operator()  ( int   val )                                       const
            {
                if( val ==  CELL_VAL_EMPTY )
                {
                    std::cout   <<  CELL_VAL_EMPTY_SYMB;
                }
                else
                {
                    std::cout   <<  val;
                }
                std::cout   <<  '\t';
            }
        };
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    bool    successfully_input_and_process_direction_or_set_end_game_message
        ( T_str     &   end_game_message )
    {
        int     direction   =   0;
        bool    bool_res    =       successfully_input_direction    ( direction )
                                &&  successfully_process_direction  ( direction );
 
        if( !bool_res )
        {
            end_game_message    =   "Игра закончена.";
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_input_direction    ( int   &   direction )                 const
    {
        bool    bool_res    =   _getch() == ARROW_KEY_FIRST_BYTE;
 
        if( bool_res )
        {
            direction   =   _getch();
        }
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool    successfully_process_direction  ( int   direction )
    {
        bool    bool_res    =   true;
 
            switch( direction )
            {
            case    LEFT_ARROW_KEY      :   shift_left      ()  ;     break;
            case    RIGHT_ARROW_KEY     :   shift_right     ()  ;     break;
            case    UP_ARROW_KEY        :   shift_up        ()  ;     break;
            case    DOWN_ARROW_KEY      :   shift_down      ()  ;     break;
 
            default                     :   bool_res    =   false;
            }//switch
 
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    void    shift_left()
    {
        std::for_each
            (
                matr_.begin                         (),
                matr_.end                           (),
                T_shift_row_left_and_set_records    ( records_ )
            );
    }
    //-----------------------------------------------------------------------------------
    struct  T_shift_row_left_and_set_records
    {
        //-------------------------------------------------------------------------------
        T_records   &   records_;
        //-------------------------------------------------------------------------------
        T_shift_row_left_and_set_records( T_records   &   records )
            :
            records_( records )
        {}
        //-------------------------------------------------------------------------------
        void    operator()  ( T_row     &   row )
        {
            shift_row_left                                              ( row );
            merge_two_equal_adjacent_non_empty_cells_and_set_records    ( row );
        }
        //-------------------------------------------------------------------------------
        void    shift_row_left( T_row     &   row )
        {
            std::stable_partition
                (
                    row.begin   (),
                    row.end     (),
 
                    std::not1
                        (
                            std::bind2nd
                                (
                                    std::equal_to<int>(),
                                    CELL_VAL_EMPTY
                                )
                        )
                );
        }
        //-------------------------------------------------------------------------------
        void    merge_two_equal_adjacent_non_empty_cells_and_set_records( T_row     &   row )
        {
            auto    it  =   std::adjacent_find
                                (
                                    row.begin           (),
                                    row.end             (),
                                    T_non_empty_and_eq  ()
                                );
 
            if  (
                    it  !=  row.end()
                )
            {
                *it *= 2;
                row.erase       ( it + 1 );
                row.push_back   ( CELL_VAL_EMPTY );
 
                records_.set_records( *it );
            }//If
        }
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    void    shift_right()
    {
        reverse_rows    ( matr_ );
        shift_left      ();
        reverse_rows    ( matr_ );
    }
    //-----------------------------------------------------------------------------------
    static  void    reverse_rows( T_matr    &   matr_ )
    {
        std::for_each
            (
                matr_.begin     (),
                matr_.end       (),
                T_reverse_row   ()
            );
    }
    //-----------------------------------------------------------------------------------
    struct  T_reverse_row
    {
        void    operator()  ( T_row     &   row )
        {
            std::reverse
                (
                    row.begin   (),
                    row.end     ()
                );
        }
    };
    //-----------------------------------------------------------------------------------
    void    shift_up()
    {
        transp      ( matr_ );
        shift_left  ();
        transp      ( matr_ );
    }
    //-----------------------------------------------------------------------------------
    static  void    transp( T_matr  &   matr )
    {
        for( int  i = 0; i < MATR_DIM; ++i )
        {
            for( int  j = i + 1; j < MATR_DIM; ++j )
            {
                std::swap
                    (
                        matr[i][j],
                        matr[j][i]
                    );
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void    shift_down()
    {
        transp          ( matr_ );
        shift_right     ();
        transp          ( matr_ );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    T_str   const   RECORD_FILE_NAME    =   "record.txt";
    T_game_2048     game_2048( RECORD_FILE_NAME );
    game_2048.play();
}