tictactoe

 #include <iostream>
 #include <cstdlib>
 #include <csignal>
 #include <termios.h>
 #include <string>
 #include <sstream>
 
 #define  TUI_TOTAL_HEIGHT  7
 
 typedef enum {
     PLAYER_1 = 1,
     PLAYER_2
 } player_t;
 
 typedef enum {
     PLAYING,
     WIN,
     DRAFT,
     RESET,
     HALT,
     EXIT
 } game_status_t;
 
 static struct termios default_attributes;
 static player_t current_player;
 static game_status_t game_status;
 static int cursor_col, cursor_row, cursor_row_pre;
 std::string player_status, key_string;
 char game_board[3][3];
 
 void tui_set_input_mode(void) {
     struct termios tattr;
 
     if (!isatty(STDIN_FILENO)) {
         std::cerr <<  "Error: not a terminal" << std::endl;
         exit (EXIT_FAILURE);
     }
 
     tcgetattr(STDIN_FILENO, &default_attributes);
     tcgetattr(STDIN_FILENO, &tattr);
     tattr.c_lflag &= ~(ICANON|ECHO);
     tattr.c_cc[VMIN] = 1;
     tattr.c_cc[VTIME] = 0;
     tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
 }
 
 void tui_reset_input_mode(void) {
     tcsetattr(STDIN_FILENO, TCSANOW, &default_attributes);
 }
 
 void game_sig_handler(int signo) {
     signal(signo, SIG_IGN);
     if ((signo == SIGINT) || (signo == SIGQUIT)) {
         game_status = EXIT;
         exit(0);
     }
 }
 
 void game_clear_board(void) {
     std::cout << "\033[" << (cursor_row_pre*2)+1 << "F\033[0K";
     cursor_row_pre = cursor_row;
 }
 
 void game_player_status_msg(void) {
     key_string.assign("\033[0J");
 
     switch(game_status) {
     case PLAYING:
         player_status.assign("Player ");
         player_status += (std::ostringstream() << current_player).str();
         player_status += "\033[0J";
         break;
     case WIN:
         player_status.assign("Player ");
         player_status += (std::ostringstream() << (current_player^3)).str();
         player_status += " Wins";
         key_string.assign("Press `r` to restart\033[0J");
         game_status = HALT;
         break;
     case DRAFT:
         player_status.assign("Draft\033[0J");
         game_status = HALT;
     case HALT:
         key_string.assign("Press `r` to restart\033[0J");
         break;
     default:
         break;
     }
 }
 
 void game_print_board(void) {
     game_player_status_msg();
     std::cout << "┌───┬───┬───┐\n│ "
               << game_board[0][0] << " │ "
               << game_board[0][1] << " │ "
               << game_board[0][2] << " │ " << player_status << "\n";
 
     std::cout << "├───┼───┼───┤ " << key_string << "\n│ "
               << game_board[1][0] << " │ "
               << game_board[1][1] << " │ "
               << game_board[1][2] << " │\n";
 
     std::cout << "├───┼───┼───┤\n│ "
               << game_board[2][0] << " │ "
               << game_board[2][1] << " │ "
               << game_board[2][2] << " │\n"
               << "└───┴───┴───┘\n";
 
     std::cout << "\033[" << TUI_TOTAL_HEIGHT-1 << "A";
 }
 
 void game_board_set_cursor(void) {
     if(cursor_row)
         std::cout << "\033[" << cursor_row*2 << "B";
 
     std::cout << "\033[0G\033[" << (cursor_col*4)+2 << "C";
 }
 
 void game_move_cursor_right(void) {
     cursor_col = (cursor_col == 2) ? 0 : cursor_col + 1;
 }
 
 void game_move_cursor_left(void) {
     cursor_col = (cursor_col > 0) ? cursor_col-1 : 2;
 }
 
 void game_move_cursor_up(void) {
     cursor_row_pre = cursor_row;
     cursor_row = (cursor_row > 0) ? cursor_row-1 : 2;
 }
 
 void game_move_cursor_down(void) {
     cursor_row_pre = cursor_row;
     cursor_row = ((cursor_row + 1) > 2) ? 0 : cursor_row+1;
 }
 
 void game_set_at_cursor_pos(void) {
     if(game_board[cursor_row][cursor_col] == ' ') {
         game_board[cursor_row][cursor_col] = ((current_player == PLAYER_1) ? 'X' : 'O');
         current_player = ((current_player == PLAYER_1) ? PLAYER_2 : PLAYER_1);
     }
 }
 
 void game_redraw_board(void) {
     game_clear_board();
     game_print_board();
     game_board_set_cursor();
 }
 
 void game_tui_cleanup(void) {
     tui_reset_input_mode();
     std::cout << "\033[" << TUI_TOTAL_HEIGHT-(cursor_row*2)-1 << "E";
     std::cout << "\033[0 q"; // block cursor shape
 }
 
 void game_tui_setup(void) {
     tui_set_input_mode();
     signal(SIGINT,  game_sig_handler);
     signal(SIGQUIT, game_sig_handler);
     signal(SIGTSTP, SIG_IGN);
     atexit(game_tui_cleanup);
     std::cout << "\033[4 q"; // underline cursor shape
 }
 
 void game_initialize_board(void) {
     game_status = PLAYING;
     cursor_col = cursor_row = 1;
     current_player = PLAYER_1;
     for(size_t i = 0; i < 3; ++i) {
         for(size_t j = 0; j < 3; ++j) {
             game_board[i][j] = ' ';
         }
     }
 }
 
 void game_check_status(void) {
     char first;
     size_t i, j, h, v, d, rd, white_space;
 
     if(game_status != PLAYING)
         return;
 
     for(i = white_space = 0; i < 3; ++i) {
         for(j = h = v = d = rd = 0; j < 3; ++j) {
             if((first = game_board[i][0]) != ' ') { // horizontal (-)
                 if(game_board[i][j] == first) {
                     if((h++) == 2) {
                         game_status = WIN;
                         return;
                     }
                 }
             }
             if((first = game_board[0][i]) != ' ') { // vertical (|)
                 if(game_board[j][i] == first) {
                     if((v++) == 2) {
                         game_status = WIN;
                         return;
                     }
                 }
             }
             if((first = game_board[0][0]) != ' ') { // diagonal (/)
                 if(game_board[j][j] == first) {
                     if((d++) == 2) {
                         game_status = WIN;
                         return;
                     }
                 }
             }
             if((first = game_board[0][2]) != ' ') { // reverse diagonal (\)
                 if(game_board[2-j][j] == first) {
                     if((rd++) == 2) {
                         game_status = WIN;
                         return;
                     }
                 }
             }
             if(game_board[i][j] == ' ') {
                 white_space++;
             }
         }
     }
     if((i == 3) && (j == 3) && (white_space == 0))
         game_status = DRAFT;
 }
 
 void game_key_handler(void) {
     char cmd;
 
     std::cin.get(cmd);
     switch(cmd) {
     case 'w':
     case 'k':
         game_move_cursor_up();
         break;
     case 's':
     case 'j':
         game_move_cursor_down();
         break;
     case  10: // Enter
     case ' ':
         if(game_status == PLAYING)
             game_set_at_cursor_pos();
         break;
     case 'l':
     case 'd':
         game_move_cursor_right();
         break;
     case 'h':
     case 'a':
         game_move_cursor_left();
         break;
     case 'r':
         if(game_status == HALT)
             game_status = RESET;
         break;
     case 'q':
         game_status = EXIT;
         break;
     case 27: { // Escape codes (i.e. arrow keys)
         std::cin.get(cmd); // skip '['
         std::cin.get(cmd);
         switch (cmd) {
         case 'A': // up
             game_move_cursor_up();
             break;
         case 'B': // down
             game_move_cursor_down();
             break;
         case 'C': // right
             game_move_cursor_right();
             break;
         case 'D': // left
             game_move_cursor_left();
             break;
         }
         break;
         }
     }
 }
 
 int main(void) {
     cursor_row = cursor_col = cursor_row_pre = 0;
 
     game_tui_setup();
     game_initialize_board();
     game_print_board();
     std::cout << "\033[" << ((cursor_col*4)+2) << "C";
     game_redraw_board();
 
     while(game_status != EXIT) {
         game_key_handler();
         game_check_status();
         if(game_status == RESET)
             game_initialize_board();
         game_redraw_board();
     }
 
     return 0;
 }