snake_c

public
Small snake game in C
Star0
Watch0
27 commits 2 branches 1 tag 0 releases565.5 KiB
#define _POSIX_C_SOURCE 199309L

#include <termios.h>
#include <unistd.h>

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include <sys/ioctl.h>

#include <time.h>

#include <ctype.h>
#include <string.h>

#define RIGHT_CODE 'C'
#define LEFT_CODE 'D'
#define UP_CODE 'A'
#define DOWN_CODE 'B'

#define WIDTH 20
#define HEIGHT 20

#define MIN_SIZE 10
#define MAX_SIZE 100

#define STRING_LEN 20

#define SPEED 50 /* in ms */

#define MAX_LENGTH 1000
#define STARTING_LENGTH 2

typedef enum { NEW_GAME, SETTINGS, EXIT, MAIN_MENU } main_menu;

typedef enum {HEIGHT_S, WIDTH_S, SPEED_S, BACK_S, SETTINGS_MENU} settings;

typedef enum {V_FAST, FAST, AVERAGE, SLOW, V_SLOW, SPEED_L} speed;

typedef enum {
  NO_DIRECTION = -1,
  UP = 0,
  LEFT = 1,
  DOWN = 2,
  RIGHT = 3,
  DIRECTIONS = 4
} direction;

typedef enum {
  AIR, FRUIT, HEAD_1, HEAD_2, HORIZONTAL, VERTICAL, 
  TOP_RIGHT, TOP_LEFT, BOTTOM_RIGHT, BOTTOM_LEFT
} board_state;

typedef struct selected {
  int8_t x;
  int8_t y;
} selected;

typedef struct snake_part {
  selected coords;
  direction directions[2];
} snake_part;

typedef struct snake {
  snake_part position[MAX_LENGTH];
  uint16_t length;
} snake;


uint8_t update_snake (selected game_size, snake *my_snake, direction shift);
void update_field(snake my_snake, selected game_size, 
  board_state **board, selected fruit);
selected new_fruit(selected game_size, board_state **board);

bool start_animation();
bool draw_menu(main_menu menu, struct winsize window_size);
bool draw_board(selected game_size, board_state **board,
  struct winsize window_size, bool redraw, bool paused);
void draw_pause(struct winsize window_size, 
  uint8_t field_width,uint8_t field_height);

char *give_state(board_state square);

direction read_direction(char *string, bool wasd_enabled);

int main(int argc, char *args[]) {

  /* command argument handling */

  if (argc > 1) {
    if (argc > 2) {
      printf("Too many parameters\n");
      goto help_info;
    }

    if (!strcmp(args[1], "-h") || !strcmp(args[1], "--help")) {

      printf("This is a small TUI snake game.\n\n");
      printf("Controls: Arrow keys/WASD to control the snake.\n");
      printf("          P to pause.\n");
      printf("          Q to quit.\n");

      return 0;
    }

    printf("Argument \"%s\" not recognized\n", args[1]);

  help_info:
    printf("Try \"-h\" or \"--help\" for more information\n");
    return 1;
  }

  /* Setting up terminal with termios */

  struct termios old, new;

  tcgetattr(STDIN_FILENO, &old);

  new = old;

  new.c_lflag &= ~(ECHO | ICANON);
  new.c_cc[VMIN] = 0;
  new.c_cc[VTIME] = 0;

  tcsetattr(STDIN_FILENO, TCSANOW, &new);

  srand(time(NULL));

  printf("\033[?25l");

  struct winsize init_size, current_size;
  ioctl(STDOUT_FILENO, TIOCGWINSZ, &init_size);
  current_size = init_size;
  bool too_small = false;


  struct timespec mili100 = {0, 1000000 * 100};


  /* Animation at the start */
  if (!start_animation())
    goto end_of_program;

  /* Menu */

  bool menu = true;
  bool setting = false;
  bool change_menu = true;

  main_menu selected_menu = NEW_GAME;
  settings selected_setting = HEIGHT_S;

  speed game_speed = AVERAGE;

  selected game_size = {WIDTH, HEIGHT};

  while (menu) {

    bool pressed_enter = false;
    bool changed_selected = false;

    direction arrow = NO_DIRECTION;

    char string[STRING_LEN] = {};
    ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);


    ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);

    if (current_size.ws_col != init_size.ws_col ||
        current_size.ws_row != init_size.ws_row) {
      init_size = current_size;
      changed_selected = true;
    }


    if (length_string > 0) {
      string[length_string] = '\0';

      arrow = read_direction(string, false);

      if (string[0] == '\n')
        pressed_enter = true;
      
      if (toupper(string[0]) == 'Q')
        goto end_of_program;
    }

    if (!setting) {
      
      if (!too_small) {
        switch (arrow) {
          case UP:
            selected_menu = (selected_menu + (MAIN_MENU - 1)) % MAIN_MENU;
            changed_selected = true;
            break;
          case DOWN:
            selected_menu = (selected_menu + 1) % MAIN_MENU;
            changed_selected = true;
            break;
          default:
            break;
        }
      }

      if (changed_selected || change_menu) {
        too_small = draw_menu(selected_menu, init_size);
        change_menu = false;
      }

      if (pressed_enter && !too_small) {
        switch (selected_menu) {
        case NEW_GAME:
          menu = false;
          break;
        case SETTINGS:
          setting = true;
          change_menu = true;
          break;
        default:
          tcsetattr(STDIN_FILENO, TCSANOW, &old);
          printf("\033[?25h\n\n");


          printf("\033[32m");
          return 0;
          break;
        }
      }
    } else {

      char *setting_string[] = {
        "  HEIGHT  ",
        "  WIDTH   ",
        "  SPEED   ",
        "   BACK   "
      };

      char *speed_char[] = {
        "  VERY FAST  ",
        "    FAST     ",
        "   AVERAGE   ",
        "    SLOW     ",
        "  VERY SLOW  "
      };

      uint8_t width = (uint8_t) strlen(setting_string[0]);
      uint8_t width_setting = (uint8_t) strlen(speed_char[0]);


      if (changed_selected || change_menu) {
              
        uint8_t i, j;

        printf("\033[2J\033[H");
      
         
        for (i = 0; i < SETTINGS_MENU; i++) {
      
          printf("+");
          for (j = 0; j < width; j++)
            printf("-");
          printf("+");

          if (i != BACK_S) {
            printf ("  +");

            for (j = 0; j < width_setting; j++)
              printf("-");
            printf("+");
          }

          printf("\n|");

          if (i == selected_setting)
            printf("\033[32m");

          printf("%s\033[0m", setting_string[i]);

          printf("|");

          if (i != BACK_S) {
            printf("  |");
            if (selected_setting == i)
              printf("\033[32m");

            switch (i) {
              case SPEED_S:
                printf("%s", speed_char[game_speed]);
                break;

              case WIDTH_S:
              case HEIGHT_S:
              for (j = 0; j < (width_setting - 3) >> 1; j++)
                printf(" ");
              printf("%3d", (i == WIDTH_S) ? game_size.x : game_size.y);
              for (j = 0; j < width_setting - ((width_setting - 3) >> 1) - 3; j++)
                printf(" ");

            }
            printf("\033[0m");
            printf("|");
          }

          printf("\n");

          if (i != HEIGHT_S) {
          
            printf("+");
            for (j = 0; j < width; j++)
              printf("-");
            printf("+");

            if (i != BACK_S) {
              printf ("  +");

              for (j = 0; j < width_setting; j++)
                printf("-");
              printf("+");
            }

            if (i < SETTINGS_MENU - 1)
              printf("\n");
          }
        }
        fflush(stdout);

        change_menu = false;
      }


      if (arrow != NO_DIRECTION) {

        switch (arrow) {
          case UP:
            selected_setting = (selected_setting + (SETTINGS_MENU - 1)) % SETTINGS_MENU;
            break;
          case DOWN:
            selected_setting = (selected_setting + 1) % SETTINGS_MENU;
            break;
          case LEFT:
            switch (selected_setting) {
              case SPEED_S:
                if (game_speed < SPEED_L - 1)
                  game_speed++;
                break;
              case WIDTH_S:
                if (game_size.x > MIN_SIZE)
                  game_size.x--;
                break;
              case HEIGHT_S:
                if (game_size.y > MIN_SIZE)
                  game_size.y--;
                break;
              default:
                break;
            }
            break;
          case RIGHT:
            switch (selected_setting) {
              case SPEED_S:
                if (game_speed)
                  game_speed--;
                break;
              case WIDTH_S:
                if (game_size.x < MAX_SIZE)
                  game_size.x++;
                break;
              case HEIGHT_S:
                if (game_size.y < MAX_SIZE)
                  game_size.y++;
                break;
              default:
                break;
            }
            break;
          default:
            break;
        }
        change_menu = true;

      }

      if (pressed_enter) {
        switch (selected_setting) {
          case BACK_S:
            setting = false;
            break;
          default:
            break;
        }
        change_menu = true;
      }
      pressed_enter = false;
    }

  nanosleep(&mili100, NULL);
  }

  /* initialisation of the game */

  snake my_snake = {};
  my_snake.length = STARTING_LENGTH;

  direction shift = RIGHT;
  direction tmp_direction = shift;

  {
    uint16_t i;

    my_snake.position[0].coords.y = game_size.y >> 1;
    my_snake.position[0].coords.x = game_size.x >> 1;
    my_snake.position[0].directions[0] = shift;
    my_snake.position[0].directions[1] = shift;
    for (i = 1; i < my_snake.length; i++) {
      my_snake.position[i].coords.y = -1;
      my_snake.position[i].coords.x = -1;
    }
  }

  selected fruit = {-1, -1};

  board_state **board = malloc(game_size.y * sizeof(board_state*));
  board_state *values = calloc(game_size.y * game_size.x, sizeof(board_state));

  if(board == NULL || values == NULL)
  goto end_of_program;

  {
    uint8_t i;

    for (i = 0; i < game_size.y; i++)
      board[i] = values + i * game_size.x;
  }


  update_field(my_snake, game_size, board, fruit);

  fruit = new_fruit(game_size, board);
  update_field(my_snake, game_size, board, fruit);

  bool paused = false;

  if ((too_small = draw_board(game_size, board, current_size, true, false)))
    paused = true;


  bool run = true;

  struct timespec milispeed = {0, 1000000 * (SPEED + game_speed * 25)};

  /* start of the actual game loop */

  while (run) {

    /* input handling  */

    
      char string[STRING_LEN] = {};
      ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);

      if (length_string > 0) {
        string[length_string] = '\0';

        if (!too_small) {
          if (toupper(string[0]) == 'P' || string[0] == '\n') {
            paused = !paused;
            if (paused)
              draw_board(game_size, board, current_size, true, paused);
          }

          if (!paused)
            tmp_direction = read_direction(string, true);
        }

        if (toupper(string[0]) == 'Q')
          run = false;
      }
    

    /* game logic */

    /*
    struct timeval current;
    gettimeofday(&current, NULL);*/

    if (/*time_diff >= SPEED * 1000*/ true) {

      ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);

      if (current_size.ws_col != init_size.ws_col ||
          current_size.ws_row != init_size.ws_row) {
        init_size = current_size;

        paused = true;
        too_small = draw_board(game_size, board, current_size, true, paused);
      }

      if (!paused) {

        if (tmp_direction != NO_DIRECTION &&
            ((shift + (DIRECTIONS >> 1)) % DIRECTIONS) != tmp_direction) {
          shift = tmp_direction;
        }

        uint8_t update = update_snake(game_size ,&my_snake, shift);

        switch (update) {
            case 0: 
              printf("\nERROR\n");
              goto end_free;
              break;
            case 2:
              printf("\nHAHA LOST, LOSER");
              goto end_free;
              break;
            default:
              break;
        }

        update_field(my_snake, game_size, board, fruit);

        
        uint8_t head_y = my_snake.position[0].coords.y;
        uint8_t head_x = my_snake.position[0].coords.x;

        if (head_y == fruit.y && head_x == fruit.x) {
          my_snake.length++;
          fruit = new_fruit(game_size, board);
        }

        update_field(my_snake, game_size, board, fruit);
        draw_board(game_size, board, current_size, false, false);
      }
    }
    nanosleep(&milispeed, NULL);
  }

end_free:

      free(board);
      free(values);

end_of_program:

  tcsetattr(STDIN_FILENO, TCSANOW, &old);
  printf("\033[?25h\n\n");


  printf("\033[32m");
  return 0;
}


uint8_t update_snake (selected game_size, snake *my_snake, direction shift) {
  
  my_snake->position[0].directions[1] = my_snake->position[0].directions[0];
  my_snake->position[0].directions[0] = shift;

  uint16_t i;
  for (i = my_snake->length; i > 0; i--)
    my_snake->position[i] = my_snake->position[i - 1];

  switch (shift) {
  case UP:
    my_snake->position[0].coords.y =
        ((my_snake->position[0].coords.y + game_size.y - 1) % game_size.y);
    break;
  case DOWN:
    my_snake->position[0].coords.y = ((my_snake->position[0].coords.y + 1) % game_size.y);
    break;
  case LEFT:
    my_snake->position[0].coords.x =((my_snake->position[0].coords.x + game_size.x - 1) % game_size.x);
    break;
  case RIGHT:
    my_snake->position[0].coords.x = ((my_snake->position[0].coords.x + 1) % game_size.x);
    break;
  default:
    return 0;
    break;
  }

  uint8_t head_y = my_snake->position[0].coords.y;
  uint8_t head_x = my_snake->position[0].coords.x;

  for (i = 1; i < my_snake->length; i++) {
    int16_t x = my_snake->position[i].coords.x;
    int16_t y = my_snake->position[i].coords.y;

    if (x == head_x && y == head_y)
      return 2;
  }


  return 1;
}

void update_field(snake my_snake, selected game_size, board_state **board, selected fruit) {

  uint8_t i, j;

  for (i = 0; i < game_size.y; i++) {
    for (j = 0; j < game_size.x; j++) {
      board[i][j] = AIR;
    }
  }

  for (i = 0; i < my_snake.length; i++) {
    int16_t x = my_snake.position[i].coords.x;
    int16_t y = my_snake.position[i].coords.y;
    if (x >= 0 && y >= 0) {
      if (!i) {
        if (my_snake.position[i].directions[0] == RIGHT) {
          board[y][x] = HEAD_1;
        } else {
          board[y][x] = HEAD_2;
        }
      } else {

        board_state snake_bit[DIRECTIONS][DIRECTIONS] = {
          [UP][UP] = VERTICAL,
          [DOWN][DOWN] = VERTICAL,
          
          [RIGHT][RIGHT] = HORIZONTAL,
          [LEFT][LEFT] = HORIZONTAL,
          
          [DOWN][RIGHT] = BOTTOM_LEFT,
          [LEFT][UP] = BOTTOM_LEFT,
          
          [UP][RIGHT] = TOP_LEFT,
          [LEFT][DOWN] = TOP_LEFT,
          
          [DOWN][LEFT] = BOTTOM_RIGHT,
          [RIGHT][UP] = BOTTOM_RIGHT,
          
          [UP][LEFT] = TOP_RIGHT,
          [RIGHT][DOWN] = TOP_RIGHT
        };

        direction first = my_snake.position[i].directions[0];
        direction second = my_snake.position[i].directions[1];

        board[y][x] = snake_bit[first][second];
      }
    }
  }

  if (fruit.x >= 0 && fruit.y >= 0)
    board[fruit.y][fruit.x] = FRUIT;
}

selected new_fruit(selected game_size, board_state **board) {
  bool found_space = false;

  uint8_t x;
  uint8_t y;

  while (!found_space) {
    x = rand() % game_size.x;
    y = rand() % game_size.y;

    if (board[y][x] == AIR)
      found_space = true;
  }

  selected fruit = {x, y};

  return fruit;
}

bool start_animation() {  

  struct winsize current_size;
  ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);

  struct timespec mili10 = {0, 1000000 * 10};

  char *snake[3][7] = {
    {
      "           ________  ",
      "         _/ _      \\_",
      "________/  (_)       ",
      "\\       \\            ",
      "/_______/   _        ",
      "        \\_ (_)      _",
      "          \\________/ "
    },
    {
      "        ",
      "________",
      "\\      /",
      " \\    / ",
      "  \\  /  ",
      "___\\/___",
      "        ",
    },
    {
      "         ",
      "__        ",
      "  \\_____ ",
      "        \\",
      "   _____/",
      "__/      ",
      "         "
    }
  };

  uint8_t width_snake[3] = {};

  {
    uint8_t i;

    for (i = 0; i < 3; i++)
      width_snake[i] = (uint8_t) strlen(snake[i][0]);
  }

  uint8_t middle;

  uint8_t height = 7;
  uint8_t width = width_snake[0] + width_snake[1] + width_snake[2];

  for (middle = 1; width < current_size.ws_col; middle++)
    width += width_snake[1];

  int32_t end = current_size.ws_col + width;



  while (end >= 0) {

    ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);

    int32_t start = end - width; 

    int32_t i, j;
 
    char string[1000] = {};
    ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);

     if (length_string > 0) {
    
      string[length_string] = '\0';


    if (toupper(string[0]) == 'Q')
      return false;

    if (string[0] == '\n')
      break;
    }

    printf("\033[2J\033[H");

    for (j = 0; j < ((height > current_size.ws_row) ? current_size.ws_row : height) ; j++) {

    for (i = 0; i < current_size.ws_col; i++) {
      int32_t index = i - start;

      if (index >= 0 && index < width) {
        if (index < width_snake[0]) {
          printf("%c", snake[0][j][index]);
        } else if (index < width_snake[0] + width_snake[1] * middle) {
          printf("%c", snake[1][j][(index - width_snake[0]) % width_snake[1]]);
        } else {
          printf("%c", snake[2][j][index - (width_snake[0] + width_snake[1] * middle)]);
        }
      } else {
        printf(" ");
      }
    }      
    
      printf("\n");

    }
    fflush(stdout);
    
    end--;

    nanosleep(&mili10, NULL);
  }
  return true;
}

bool draw_menu(main_menu menu, struct winsize window_size) {

  char *menu_string[] = {"NEW GAME", "SETTINGS", "EXIT"};

  const uint8_t width_small = 8;
  const uint8_t height_small = 5;

  char *menu_string_big[][6] = {
      {"███╗   ██╗███████╗██╗    ██╗     ██████╗  █████╗ ███╗   ███╗███████╗",
       "████╗  ██║██╔════╝██║    ██║    ██╔════╝ ██╔══██╗████╗ ████║██╔════╝",
       "██╔██╗ ██║█████╗  ██║ █╗ ██║    ██║  ███╗███████║██╔████╔██║█████╗  ",
       "██║╚██╗██║██╔══╝  ██║███╗██║    ██║   ██║██╔══██║██║╚██╔╝██║██╔══╝  ",
       "██║ ╚████║███████╗╚███╔███╔╝    ╚██████╔╝██║  ██║██║ ╚═╝ ██║███████╗",
       "╚═╝  ╚═══╝╚══════╝ ╚══╝╚══╝      ╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝"},
      {"███████╗███████╗████████╗████████╗██╗███╗   ██╗ ██████╗ ███████╗",
       "██╔════╝██╔════╝╚══██╔══╝╚══██╔══╝██║████╗  ██║██╔════╝ ██╔════╝",
       "███████╗█████╗     ██║      ██║   ██║██╔██╗ ██║██║  ███╗███████╗",
       "╚════██║██╔══╝     ██║      ██║   ██║██║╚██╗██║██║   ██║╚════██║",
       "███████║███████╗   ██║      ██║   ██║██║ ╚████║╚██████╔╝███████║",
       "╚══════╝╚══════╝   ╚═╝      ╚═╝   ╚═╝╚═╝  ╚═══╝ ╚═════╝ ╚══════╝"},
      {"███████╗██╗  ██╗██╗████████╗", "██╔════╝╚██╗██╔╝██║╚══██╔══╝",
       "█████╗   ╚███╔╝ ██║   ██║   ", "██╔══╝   ██╔██╗ ██║   ██║   ",
       "███████╗██╔╝ ██╗██║   ██║   ", "╚══════╝╚═╝  ╚═╝╚═╝   ╚═╝   "}};

  const uint8_t height_line = 6;
  const uint8_t height_space = 2;

  const uint8_t width_text[] = {68, 64, 28};

  const uint8_t width_big = width_text[0] /*strlen(menu_string_big[0][0])*/;
  const uint8_t height_big =
      height_line * MAIN_MENU + height_space * (MAIN_MENU - 1);

  printf("\033[2J\033[H");

  if (window_size.ws_row < height_small || window_size.ws_col < width_small) {
    printf("Too small\n");
    return true;
  }

  uint8_t i, j, k;

  if (window_size.ws_row >= height_big && window_size.ws_col >= width_big) {

    uint8_t vertical_buffer = (window_size.ws_row - height_big) >> 1;

    for (i = 0; i < vertical_buffer; i++)
      printf("\n");

    for (i = 0; i < MAIN_MENU; i++) {

      if (i == menu)
        printf("\033[32m");

      uint8_t horizontal_buffer = (window_size.ws_col - width_text[i]) >> 1;

      for (j = 0; j < height_line; j++) {

        for (k = 0; k < horizontal_buffer; k++)
          printf(" ");

        printf("%s", menu_string_big[i][j]);

        if (j != height_line - 1)
          printf("\n");
      }

      printf("\033[0m");

      if (i != MAIN_MENU - 1)
        printf("\n\n");
    }

  } else {

    uint8_t vertical_buffer = (window_size.ws_row - height_small) >> 1;

    for (i = 0; i < vertical_buffer; i++)
      printf("\n");

    for (i = 0; i < MAIN_MENU; i++) {
      if (i == menu)
        printf("\033[32m");

      uint8_t horizontal_buffer =
          (window_size.ws_col - strlen(menu_string[i])) >> 1;

      for (j = 0; j < horizontal_buffer; j++)
        printf(" ");

      printf("%s\033[0m", menu_string[i]);

      if (i != MAIN_MENU - 1)
        printf("\n\n");
    }
  }

  fflush(stdout);
  return false;
}

bool draw_board(
  selected game_size,
  board_state **board,
  struct winsize window_size, 
  bool redraw, bool paused
) {

  uint8_t i, j;

  uint8_t actual_height = game_size.y + 2;
  uint8_t actual_width = game_size.x * 2 + 2;

  if (actual_width > window_size.ws_col || actual_height > window_size.ws_row) {

    printf("\033[2J\033[HToo small\n");
    printf("Min width: %i & Min height: %i\n", actual_height, actual_width);

    return true;
  }

  uint8_t vertical_buffer = (window_size.ws_row - actual_height) >> 1;
  uint8_t horizontal_buffer = (window_size.ws_col - actual_width) >> 1;

  if (redraw) {
    printf("\033[2J\033[H");
    for (i = 0; i < vertical_buffer; i++)
      printf("\n");
  } else {
    for (i = 0; i < actual_height - 1; i++)
      printf("\033[%c", UP_CODE);
    printf("\r");
  }

  for (i = 0; i < horizontal_buffer; i++)
    printf(" ");
  printf("+");
  for (i = 0; i < game_size.x; i++)
    printf("--");
  printf("+\n");

  for (i = 0; i < game_size.y; i++) {

    for (j = 0; j < horizontal_buffer; j++)
      printf(" ");

    printf("|");

    for (j = 0; j < game_size.x; j++)
      printf("%s", give_state(board[i][j]));

    printf("|\n");
  }

  for (i = 0; i < horizontal_buffer; i++)
    printf(" ");
  printf("+");
  for (i = 0; i < game_size.x; i++)
    printf("--");
  printf("+");

  if (paused)
    draw_pause(window_size, actual_width, actual_height);

  fflush(stdout);

  return false;
}

void draw_pause(struct winsize window_size, uint8_t field_width,
                uint8_t field_height) {

  const uint8_t height = 5;
  const uint8_t width = 14;

  const char *pause_menu[] = {
    "+------------+", 
    "|            |",
    "|   PAUSED   |",
    "|            |",
    "+------------+"
  };

  const uint8_t going_up = (field_height + height) >> 1;
  const uint8_t going_right = (field_width - width) >> 1;

  const uint8_t horizontal_buffer = (window_size.ws_col - field_width) >> 1;

  uint8_t i, j;

  for (i = 0; i < going_up; i++)
    printf("\033[%c", UP_CODE);
  printf("\r");

  for (i = 0; i < height; i++) {
    for (j = 0; j < horizontal_buffer; j++)
      printf("\033[%c", RIGHT_CODE);
    for (j = 0; j < going_right; j++)
      printf("\033[%c", RIGHT_CODE);

    printf("\033[37m%s\033[0m\033[%c\r", pause_menu[i], DOWN_CODE);
  }

  for (i = 0; i < going_up - height; i++)
    printf("\033[%c", DOWN_CODE);
  printf("\r");

  fflush(stdout);
}

char *give_state(board_state square) {

  switch (square) {
    case FRUIT:
      return "\033[32m O\033[0m";
      break;
    case HEAD_1:
      return "\033[33m═\033[31mX\033[0m";
      break;
    case HEAD_2:
      return "\033[31m X\033[0m";
      break;    
    case VERTICAL:
      return "\033[33m ║\033[0m";
      break;
    case HORIZONTAL:
      return "\033[33m══\033[0m";
      break;
    case TOP_RIGHT:
      return "\033[33m ╚\033[0m";
      break;
    case TOP_LEFT:
      return "\033[33m═╝\033[0m";
      break;
    case BOTTOM_RIGHT:
      return "\033[33m ╔\033[0m";
      break;
    case BOTTOM_LEFT:
      return "\033[33m═╗\033[0m";
      break;
    default:
      return "  ";
      break;
  }
}


direction read_direction(char *string, bool wasd_enabled) {

  if (strlen(string) >= 3) {
    if (string[0] == '\033') {
      if (string[1] == '[') {

        switch (string[2]) {
        case RIGHT_CODE:
          return RIGHT;
          break;
        case LEFT_CODE:
          return LEFT;
          break;
        case UP_CODE:
          return UP;
          break;
        case DOWN_CODE:
          return DOWN;
          break;
        }
      }
    }
  }

  if (wasd_enabled) {
    switch (toupper(string[0])) {
    case 'A':
      return LEFT;
      break;
    case 'D':
      return RIGHT;
      break;
    case 'W':
      return UP;
      break;
    case 'S':
      return DOWN;
      break;
    }
  }

  return NO_DIRECTION;
}