Пятнашки - Как сделать перехват нажатий клавиш в консоли

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <cctype>
#include <cmath>
#include <vector>
 
using namespace std;
//такие значения, чтобы можно было вернуть все возможные ходы одним числом
enum moves {UP = 0b1000, DOWN = 0b0100, LEFT = 0b0010, RIGHT = 0b0001};
 
enum status {PLAYING, WIN, MENU, QUIT};
 
typedef struct {
    moves move; // на самом деле поле не используется, но висит тут, чтобы не запутаться
    struct {
        int dx;
        int dy;
    };
} movetypes;
 
typedef struct {
    int x;
    int y;
} pos;
 
pos posfree; // тут хранится текущее положение пустой ячейки, чтобы не искать каждый раз. Реально в ней находится значение 16
 
movetypes mvt[] = {{UP,    {-1,  0}},
                   {DOWN,  { 1,  0}},
                   {LEFT,  { 0, -1}},
                   {RIGHT, { 0,  1}}};
 
pos & operator+=(pos & pf, const movetypes & trymove) {
    pf.x += trymove.dx;
    pf.y += trymove.dy;
    return pf;
}
 
pos operator+(const pos & posfrom, const moves& move) {
    pos ret = posfrom;
    switch(move) {
    case UP:
        ret += mvt[0];
        break;
    case DOWN:
        ret += mvt[1];
        break;
    case LEFT:
        ret += mvt[2];
        break;
    case RIGHT:
        ret += mvt[3];
        break;
    }
    return ret;
}
 
vector <int> board[4];
 
void boardinit() {
    for(int x = 0; x < 4; ++x) {
        board[x].clear();
        for(int y = 0; y < 4; ++y)
            board[x].push_back(1 + x*4 + y);
    }
    posfree.x = 3;
    posfree.y = 3;
}
 
void showboard() {
    for(int i = 0; i < 4; ++i) {
        fputs("\n+----+----+----+----+\n|", stdout);
        for(int j = 0; j < 4; ++j) {
            if(board[i][j] == 16)
                fputs("    |", stdout);
            else
                printf(" %2d |", board[i][j]);
        }
    }
    puts("\n+----+----+----+----+");
}
 
bool isvalidpos(pos ps) {
    return ((ps.x >= 0) && (ps.x <= 3) &&
            (ps.y >= 0) && (ps.y <= 3));
}
 
int getpossiblemoves() {
    int ret = 0;
    if(isvalidpos(posfree + UP))    ret |= UP;
    if(isvalidpos(posfree + DOWN))  ret |= DOWN;
    if(isvalidpos(posfree + LEFT))  ret |= LEFT;
    if(isvalidpos(posfree + RIGHT)) ret |= RIGHT;
    return ret;
}
 
moves getrandmove() {
    int possiblemoves = getpossiblemoves();
    moves mvs[4];
    int npm = 0;
    if (possiblemoves & UP){
        mvs[npm] = UP;
        ++npm;
    }
    if (possiblemoves & DOWN){
        mvs[npm] = DOWN;
        ++npm;
    }
    if (possiblemoves & LEFT){
        mvs[npm] = LEFT;
        ++npm;
    }
    if (possiblemoves & RIGHT){
        mvs[npm] = RIGHT;
        ++npm;
    }
    int moveint = rand() % npm;
    return mvs[moveint];
}
 
status checkwin() {
    for(int x = 0; x < 4; ++x) {
        board[x].clear();
        for(int y = 0; y < 4; ++y) {
            if(board[x][y] != (1 + x*4 + y))
                    return PLAYING;
        }
    }
    return WIN;
}
 
status makemove(moves move) {
    pos from = posfree;
    pos to   = posfree + move;
    if(isvalidpos(to) == false)
        return PLAYING;
    int tmp = board[from.x][from.y];
    board[from.x][from.y] = board[to.x][to.y];
    board[to.x][to.y] = tmp;
    posfree = to;
    return checkwin();
}
 
void shuffle(int level) {
    while(level-- > 0)
        makemove(getrandmove());
}
 
status playing() {
    char msg;
    moves currentmove;
    while(true) {
        showboard();
        cin >> msg;
        msg = tolower(msg);
        switch(msg) {
        case 'q':
            return QUIT;
        case 'm':   case 'n':
            return MENU;
        case 'w':   case '8':
            currentmove = UP;
            break;
        case 's':   case '2':
            currentmove = DOWN;
            break;
        case 'a':   case '4':
            currentmove = LEFT;
            break;
        case 'd':   case '6':
            currentmove = RIGHT;
            break;
        default:
            cout << "Wrong input: " << msg;
            continue;
        }
        if(makemove(currentmove) == WIN) {
            puts("WIN!");
            return WIN;
        }
    }
}
 
void gameloop() {
    srand(time(0));
    cin.exceptions(ios::failbit | ios::badbit);
    int level;
    while(true) { // main loop
        boardinit();
        fputs("New game: input level: ", stdout);
        while(true){ // input level
            try { // весь этот выпендреж, чтобы попробовать try..carth
                cin >> level;
                if(level < 1) {
                    fputs("\nLevel must be > 0: Input level: ", stdout);
                    continue;
                }
                break;
            }
            catch (istream::failure &e) {
                fputs("\nNaN: Input level: ", stdout);
                cin.clear();
                cin.ignore(1024, '\n');
            }
        }
        shuffle(level);
        if (playing() == QUIT)
            return;
    }
}
 
int main() {
    gameloop();
    return 0;
}