CB100

 #include <iostream>
 #include <cstdlib>
 #include <csignal>
 #include <termios.h>
 #include <string>
 #include <sstream>
 
 typedef enum {
     PLAYER_1,
     PLAYER_2
 } player_t;
 
 typedef enum {
     PLAYING,
     WIN,
     DRAFT,
     RESET,
     HALT,
     EXIT
 } game_status_t;
 
 static struct termios default_attributes;
 static unsigned int tui_total_height;
 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 <<  "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() {
     std::ostringstream current_player_string;
     unsigned int player_won;
     key_string.assign("\033[0J");
 
     switch(game_status) {
     case PLAYING:
         player_status = std::string("Player ");
         current_player_string << current_player+1;
         player_status += current_player_string.str();
         player_status += "\033[0J";
         break;
     case WIN:
         player_won = ((current_player == PLAYER_1) ? PLAYER_2 : PLAYER_1);
         player_status = std::string("Player ");
         current_player_string << player_won+1;
         player_status += current_player_string.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");
         key_string.assign("Press `r` to restart\033[0J");
         game_status = HALT;
         break;
     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";
 }
 
 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] == ' ') {
         char aux = ((current_player == PLAYER_1) ? 'X' : 'O');
         game_board[cursor_row][cursor_col] = aux;
         current_player = ((current_player == PLAYER_1) ? PLAYER_2 : PLAYER_1);
     }
 }
 
 void game_redraw_board(void) {
     game_clear_board();
     game_print_board();
     std::cout << "\033[" << tui_total_height-1 << "A";
     game_board_set_cursor();
 }
 
 void game_tui_cleanup() {
     tui_reset_input_mode();
     std::cout << "\033[" << tui_total_height-(cursor_row*2)-1 << "E";
 }
 
 void game_tui_setup() {
     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"; // Blinking block cursor
 }
 
 void game_initialize_board() {
     for(size_t i = 0; i < 3; ++i) {
         for(size_t j = 0; j < 3; ++j) {
             game_board[i][j] = ' ';
         }
     }
 }
 
 void game_check_status() {
     char aux;
     size_t i, j, occ_x, occ_o;
     if(game_status != PLAYING)
         return;
 
     // Horizontal line
     for(i = occ_x = occ_o = 0; i < 3; ++i) {
         aux = game_board[cursor_row][i];
         if(aux == 'X') {
             occ_x++;
             occ_o = 0;
         }
         else if (aux == 'O'){
             occ_x = 0;
             occ_o++;
         }
         else {
             occ_x = occ_o = 0;
         }
     }
     if ((occ_o == 3) || (occ_x == 3)) {
         game_status = WIN;
     }
 
     // Vertical line
     for(i = occ_x = occ_o = 0; i < 3; ++i) {
         aux = game_board[i][cursor_col];
         if(aux == 'X') {
             occ_x++;
             occ_o = 0;
         }
         else if (aux == 'O'){
             occ_x = 0;
             occ_o++;
         }
         else {
             occ_x = occ_o = 0;
         }
     }
     if ((occ_o == 3) || (occ_x == 3)) {
         game_status = WIN;
     }
 
     // Reverse diagonal line (\)
     for(i = occ_x = occ_o = 0; i < 3; ++i) {
         aux = game_board[i][i];
         if(aux == 'X') {
             occ_x++;
             occ_o = 0;
         }
         else if (aux == 'O'){
             occ_x = 0;
             occ_o++;
         }
         else {
             occ_x = occ_o = 0;
         }
     }
     if ((occ_o == 3) || (occ_x == 3)) {
         game_status = WIN;
     }
 
     // Forward diagonal line (/)
     for(i = occ_x = occ_o = 0; i < 3; ++i) {
         aux = game_board[2-i][i];
         if(aux == 'X') {
             occ_x++;
             occ_o = 0;
         }
         else if (aux == 'O'){
             occ_x = 0;
             occ_o++;
         }
         else {
             occ_x = occ_o = 0;
         }
     }
     if ((occ_o == 3) || (occ_x == 3)) {
         game_status = WIN;
     }
 
     if(game_status != WIN) {
         for(i = 0; i < 3; ++i)
             for(j = 0; j < 3; ++j)
                 if(game_board[i][j] == ' ')
                     return;
 
         if((i == j) && (i == 3))
             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) {
     tui_total_height = 7;
     cursor_row = cursor_row_pre = cursor_col = 0;
     game_status = PLAYING;
     current_player = PLAYER_1;
 
     game_tui_setup();
     game_initialize_board();
     game_print_board();
     std::cout << "\033[" << tui_total_height-1 << "A";
     std::cout << "\033[" << ((cursor_col*4)+2) << "C";
 
     game_move_cursor_right();
     game_redraw_board();
     game_move_cursor_down();
     game_redraw_board();
 
     while(game_status != EXIT) {
         game_key_handler();
         if(game_status == RESET) {
             game_status = PLAYING;
             current_player = PLAYER_1;
             cursor_col = cursor_row = 1;
             game_initialize_board();
         }
         game_check_status();
         game_redraw_board();
     }
 
     return 0;
 }