snake_c

public

Small snake game in C

Star0

Fork 0

Watch0

49 commits 2 branches 1 tag 0 releases565.5 KiB

Commit `c28baaaf800e`

tarball

Jaglekon <58274093+Jaglekon@users.noreply.github.com>2026-04-03 20:49 UTC

3 files changed+327-266

integrating everything

Modified file: drawing.c+44 additions−13 deletions@@ -402,9 +402,10 @@ bool draw_board(
 
   uint8_t i, j;
 
-  uint8_t actual_height = game_size.y + 2 + 2;
+  uint8_t actual_height = game_size.y + 2 + 2 + 1;
   uint8_t actual_width = game_size.x * 2 + 1 + 2;
 
+
   if (actual_width > window_size.ws_col || actual_height > window_size.ws_row) {
 
     printf("\033[2J\033[HToo small\n");
@@ -466,11 +467,21 @@ bool draw_board(
   printf("╰");
   for (i = 0; i < game_size.x; i++)
     printf("──");
-  printf("─╯");
+  printf("─╯\n");
+
+  if (paused) {
+    if (paused == 2) {
+      char *game_over = "Press ENTER to continue";
+    
+      for (i = 0; i < (window_size.ws_col - strlen(game_over)) >> 1; i++)
+        printf(" ");
+      printf("%s", game_over);
+    }
 
-  if (paused)
     draw_pause(window_size, actual_width, actual_height, paused);
 
+  }
+
   fflush(stdout);
 
   return false;
@@ -483,14 +494,14 @@ void draw_pause(struct winsize window_size, uint8_t field_width,
   const uint8_t width = 14;
 
   const char *pause_menu[] = {
-    "+------------+", 
-    "|            |",
-    "|   PAUSED   |",
-    "|            |",
-    "+------------+"
+    "┌────────────┐", 
+    "│            │",
+    "│   PAUSED   │",
+    "│            │",
+    "└────────────┘"
   };
 
-  const char *game_over_menu = "| GAME OVER  |";
+  const char *game_over_menu = "│ GAME OVER  │";
 
   const uint8_t going_up = (field_height + height) >> 1;
   const uint8_t going_right = (field_width - width) >> 1;
@@ -523,20 +534,40 @@ void draw_pause(struct winsize window_size, uint8_t field_width,
   fflush(stdout);
 }
 
-void draw_highscore (int16_t new_score, score leader_board[SCORE_NUMBER]) {
+void draw_highscore (int16_t new_score, score leader_board[SCORE_NUMBER], struct winsize window_size) {
   
   uint8_t i;
 
   printf("\033[2J\033[H");
 
+  printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
+
+  printf("┃ RANK      NAME     SCORE ┃\n");
+  printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━━┫\n");
+ 
+
   for (i = 0; i < SCORE_NUMBER; i++) {
-    printf("%-10s %05d\n", leader_board[i].name, leader_board[i].points);
+
+    char *ordinals[] = {
+      "st", "nd", "rd", "th"
+    };
+
+    printf("┃ %2d%-4s  %-9s %06d ┃\n",i + 1, (i >= 3) ? ordinals[3] : ordinals[i] ,leader_board[i].name, leader_board[i].points);
+    printf("┃                          ┃\n");
+ 
   }
+  
+  printf("\033[%c┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛", UP_CODE);
+  
+  fflush(stdout);
 
   if (new_score != -1) {
-    for (i = SCORE_NUMBER - new_score; i > 0; i--)
+    for (i = (SCORE_NUMBER - new_score) * 2 -  1; i > 0; i--)
       printf("\033[%c", UP_CODE);
-    printf("\r_");
+    printf("\r");
+    for (i = 0; i < 8 + 1; i++)
+      printf("\033[%c", RIGHT_CODE);
+    printf("_");
     fflush(stdout);
 
     uint8_t number_characters = 0;

Modified file: snake.c+282 additions−252 deletions@@ -35,7 +35,6 @@ int main(int argc, char *args[]) {
   selected game_size = {WIDTH, HEIGHT};
 
   score leader_board[SCORE_NUMBER] = {};
-  uint16_t score = 0;
 
   /* Handling Files to store settings & highscores */
 
@@ -158,10 +157,11 @@ int main(int argc, char *args[]) {
   current_size = init_size;
   bool too_small = false;
 
+  bool gameloop = true;
 
   /* Animation at the start */
   if (!start_animation())
-    goto end_of_program;
+    gameloop = false;
 
 
   /* Menu */
@@ -173,362 +173,392 @@ int main(int argc, char *args[]) {
   main_menu selected_menu = NEW_GAME;
   settings selected_setting = HEIGHT_S;
 
-  struct timespec mili100 = {0, 1000000 * 100};
+  uint16_t score = 0;
+  
+  snake my_snake;
+  my_snake.position = NULL;
 
-menu_start:
+  board_state **board = NULL;
+  board_state *values = NULL;
 
-  while (menu) {
 
-    direction pressed_key = DIRECTIONS;
+  struct timespec mili100 = {0, 1000000 * 100};
 
-    char string[STRING_LEN] = {};
-    ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);
+  while(gameloop) {
 
+    bool play_game = false;
 
-    ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);
+    while (menu) {
 
-    if (current_size.ws_col != init_size.ws_col ||
-        current_size.ws_row != init_size.ws_row) {
-      init_size = current_size;
-      change_menu = true;
-    }
+      direction pressed_key = DIRECTIONS;
 
+      char string[STRING_LEN] = {};
+      ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);
 
-    if (length_string > 0) {
-      string[length_string] = '\0';
 
-      pressed_key = read_direction(string, false);
-    }
+      ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);
 
-    if (pressed_key == Q_KEY || pressed_key == ESCAPE)
-      goto end_of_program;
+      if (current_size.ws_col != init_size.ws_col ||
+          current_size.ws_row != init_size.ws_row) {
+        init_size = current_size;
+        change_menu = true;
+      }
 
 
-    if (setting == MAIN_MENU) {
-      
-      if (!too_small) {
-        switch (pressed_key) {
-          case UP:
-            selected_menu = (selected_menu + (MAIN_MENU - 1)) % MAIN_MENU;
-            change_menu = true;
-            break;
-          case DOWN:
-            selected_menu = (selected_menu + 1) % MAIN_MENU;
-            change_menu = true;
-            break;
-          default:
-            break;
-        }
-      }
+      if (length_string > 0) {
+        string[length_string] = '\0';
 
-      if (change_menu) {
-        too_small = draw_menu(selected_menu, init_size);
-        change_menu = false;
+        pressed_key = read_direction(string, false);
       }
 
-      if (pressed_key == ENTER && !too_small) {
-        switch (selected_menu) {
-        case NEW_GAME:
-          menu = false;
-          break;
-        case SETTINGS:
-          setting = SETTINGS;
-          break;
-        case HIGHSCORE:
-          setting = HIGHSCORE;
-          break;
-        default:
-          goto end_of_program; 
+      if (pressed_key == Q_KEY || pressed_key == ESCAPE) {
+        if (setting != MAIN_MENU) {
+          setting = MAIN_MENU;
+          change_menu = true;
+        } else {
+          gameloop = false;
           break;
         }
-        change_menu = true;
       }
 
-    } else if (setting == SETTINGS) {
 
-      /* Settings Menu */
-
-      if (change_menu) {
+      if (setting == MAIN_MENU) {
         
-        draw_settings(selected_setting, game_speed, game_size, init_size);
-
-        change_menu = false;
-      }
-
-
-      if (pressed_key < DIRECTIONS) {
+        if (!too_small) {
+          switch (pressed_key) {
+            case UP:
+              selected_menu = (selected_menu + (MAIN_MENU - 1)) % MAIN_MENU;
+              change_menu = true;
+              break;
+            case DOWN:
+              selected_menu = (selected_menu + 1) % MAIN_MENU;
+              change_menu = true;
+              break;
+            default:
+              break;
+          }
+        }
 
-        int8_t setting_change = 0;
+        if (change_menu) {
+          too_small = draw_menu(selected_menu, init_size);
+          change_menu = false;
+        }
 
-        switch (pressed_key) {
-          case UP:
-            selected_setting = (selected_setting + (SETTINGS_MENU - 1)) % SETTINGS_MENU;
-            break;
-          case DOWN:
-            selected_setting = (selected_setting + 1) % SETTINGS_MENU;
+        if (pressed_key == ENTER && !too_small) {
+          switch (selected_menu) {
+          case NEW_GAME:
+            menu = false;
+            play_game = true;
             break;
-          case LEFT:
-            setting_change = 1;
+          case SETTINGS:
+            setting = SETTINGS;
             break;
-          case RIGHT:
-            setting_change = -1;
+          case HIGHSCORE:
+            setting = HIGHSCORE;
             break;
           default:
+            menu = false;
+            gameloop = false; 
             break;
+          }
+          change_menu = true;
         }
-        
-        if (setting_change) {
-          switch (selected_setting) {
-            case SPEED_S:
-              if (
-                game_speed + setting_change <= SPEED_L - 1 &&
-                ((int8_t) game_speed) + setting_change >= 0 
-              ) {
-                game_speed += setting_change;
-              }
+
+      } else if (setting == SETTINGS) {
+
+        /* Settings Menu */
+
+        if (change_menu) {
+          
+          draw_settings(selected_setting, game_speed, game_size, init_size);
+
+          change_menu = false;
+        }
+
+
+        if (pressed_key < DIRECTIONS) {
+
+          int8_t setting_change = 0;
+
+          switch (pressed_key) {
+            case UP:
+              selected_setting = (selected_setting + (SETTINGS_MENU - 1)) % SETTINGS_MENU;
               break;
-            case WIDTH_S:
-              if (
-                game_size.x - setting_change >= MIN_SIZE &&
-                game_size.x - setting_change <= MAX_SIZE
-              ) {
-                game_size.x -= setting_change;
-              }
+            case DOWN:
+              selected_setting = (selected_setting + 1) % SETTINGS_MENU;
               break;
-            case HEIGHT_S:
-              if (
-                game_size.y - setting_change >= MIN_SIZE &&
-                game_size.y - setting_change <= MAX_SIZE
-              ) {
-                game_size.y -= setting_change;
-              }
+            case LEFT:
+              setting_change = 1;
+              break;
+            case RIGHT:
+              setting_change = -1;
               break;
             default:
               break;
           }
-        }
-
-        change_menu = true;
+          
+          if (setting_change) {
+            switch (selected_setting) {
+              case SPEED_S:
+                if (
+                  game_speed + setting_change <= SPEED_L - 1 &&
+                  ((int8_t) game_speed) + setting_change >= 0 
+                ) {
+                  game_speed += setting_change;
+                }
+                break;
+              case WIDTH_S:
+                if (
+                  game_size.x - setting_change >= MIN_SIZE &&
+                  game_size.x - setting_change <= MAX_SIZE
+                ) {
+                  game_size.x -= setting_change;
+                }
+                break;
+              case HEIGHT_S:
+                if (
+                  game_size.y - setting_change >= MIN_SIZE &&
+                  game_size.y - setting_change <= MAX_SIZE
+                ) {
+                  game_size.y -= setting_change;
+                }
+                break;
+              default:
+                break;
+            }
+          }
 
-      }
+          change_menu = true;
 
-      if (pressed_key == ENTER) {
-        switch (selected_setting) {
-          case BACK_S:
-            setting = MAIN_MENU;
-            break;
-          default:
-            break;
         }
-        change_menu = true;
-      }
-    } else if (setting == HIGHSCORE) {
-      
-      if(change_menu) {
-        uint8_t i;
 
-        for (i = 0; i < SCORE_NUMBER; i++) {
-          if (score > leader_board[i].points)
-            break;
+        if (pressed_key == ENTER) {
+          switch (selected_setting) {
+            case BACK_S:
+              setting = MAIN_MENU;
+              break;
+            default:
+              break;
+          }
+          change_menu = true;
         }
+      } else if (setting == HIGHSCORE) {
+        
+        if(change_menu) {
+          uint8_t i;
+
+          for (i = 0; i < SCORE_NUMBER; i++) {
+            if (score > leader_board[i].points)
+              break;
+          }
+
+          if (i < SCORE_NUMBER) {
 
-        if (i < SCORE_NUMBER) {
+            uint8_t new_score = i;
 
-          uint8_t new_score = i;
+            for (i = SCORE_NUMBER - 1; i > new_score; i--) {
+              leader_board[i] = leader_board[i -1]; 
+            }
+
+            leader_board[new_score].points = score;
+            leader_board[new_score].name[0] = '\0';
+
+            draw_highscore (new_score, leader_board, init_size);
+      
+            score = 0;
+            change_menu = true;
 
-          for (i = SCORE_NUMBER - 1; i > new_score; i--) {
-            leader_board[i] = leader_board[i -1]; 
+          } else {
+            if (change_menu)
+              draw_highscore (-1, leader_board, init_size);    
           }
+        }
 
-          leader_board[new_score].points = score;
-          leader_board[new_score].name[0] = '\0';
+        if(pressed_key == ENTER) {
+          setting = MAIN_MENU;
+          change_menu = true;
+        }
+      } else if(setting == NEW_GAME) {
 
-          draw_highscore (new_score, leader_board);
-    
-          score = 0;
+        if (change_menu)
+          draw_board(game_size, board, init_size, true, 2, score);
+
+        if(pressed_key == ENTER) {
+          setting = HIGHSCORE;
           change_menu = true;
 
-        } else {
-          draw_highscore (-1, leader_board);    
+          free(my_snake.position);
+          free(board);
+          free(values);
+          my_snake.position = NULL;
+          board = NULL;
+          values = NULL;
         }
       }
 
-      if(pressed_key == ENTER) {
-        setting = MAIN_MENU;
-        change_menu = true;
-      }
-    } else if(setting == NEW_GAME) {
-
-      if(pressed_key == ENTER) {
-        setting = HIGHSCORE;
-        change_menu = true;
-      }
+      nanosleep(&mili100, NULL);
     }
 
-  nanosleep(&mili100, NULL);
-  }
+    menu = true;
 
-  menu = true;
+    /* initialisation of the game */
+  
+    if(play_game) {
 
-  /* initialisation of the game */
+      bool run = true;
 
-  snake my_snake;
-  my_snake.length = STARTING_LENGTH;
+      my_snake.length = STARTING_LENGTH;
 
-  my_snake.position = malloc((my_snake.length + 1) * sizeof(snake_part));
+      my_snake.position = malloc((my_snake.length + 1) * sizeof(snake_part));
 
-  direction shift = RIGHT;
-  direction tmp_direction = shift;
+      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;
-    }
-  }
+      {
+        uint16_t i;
 
-  board_state **board = malloc(game_size.y * sizeof(board_state*));
-  board_state *values = calloc(game_size.y * game_size.x, sizeof(board_state));
+        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;
+        }
+      }
 
-  if(board == NULL || values == NULL)
-    goto end_of_program;
+      board = malloc(game_size.y * sizeof(board_state*));
+      values = calloc(game_size.y * game_size.x, sizeof(board_state));
 
-  {
-    uint8_t i;
+      if(board == NULL || values == NULL)
+        run = false;  
 
-    for (i = 0; i < game_size.y; i++)
-      board[i] = values + i * game_size.x;
-  }
+      {
+        uint8_t i;
 
-  update_field(my_snake, game_size, board, true);
+        for (i = 0; i < game_size.y; i++)
+          board[i] = values + i * game_size.x;
+      }
 
-  uint8_t paused = 0;
+      update_field(my_snake, game_size, board, true);
 
+      uint8_t paused = 0;
 
-  if ((too_small = draw_board(game_size, board, current_size, true, 0, score)))
-    paused = 1;
 
-  bool run = true;
+      if ((too_small = draw_board(game_size, board, current_size, true, 0, score)))
+        paused = 1;
 
-  struct timespec milispeed = {0, 1000000 * (SPEED + game_speed * 25)};
 
-  /* start of the actual game loop */
+      struct timespec milispeed = {0, 1000000 * (SPEED + game_speed * 25)};
 
-  while (run) {
+      /* start of the actual game loop */
 
-    /* input handling  */
+      while (run) {
 
+        /* input handling  */
 
-    direction pressed_key;
 
-    char string[STRING_LEN] = {};
-    ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);
+        direction pressed_key;
 
-    if (length_string > 0) {
-      string[length_string] = '\0';
+        char string[STRING_LEN] = {};
+        ssize_t length_string = read(STDIN_FILENO, string, sizeof(string) - 1);
 
-      pressed_key = read_direction(string, true);
+        if (length_string > 0) {
+          string[length_string] = '\0';
 
-      if (!too_small) {
-        if (pressed_key == P_KEY || pressed_key == ENTER) {
-          paused = (paused == 1) ? 0 : 1;
-          if (paused)
-            draw_board(game_size, board, current_size, true, paused, score);
-        } 
+          pressed_key = read_direction(string, true);
 
-        if (!paused && pressed_key < DIRECTIONS)
-          tmp_direction = pressed_key;
-      }
+          if (!too_small) {
+            if (pressed_key == P_KEY || pressed_key == ENTER) {
+              paused = (paused == 1) ? 0 : 1;
+              if (paused)
+                draw_board(game_size, board, current_size, true, paused, score);
+            } 
 
-      if (pressed_key == Q_KEY || pressed_key == ESCAPE)
-        run = false;
-    }
-  
+            if (!paused && pressed_key < DIRECTIONS)
+              tmp_direction = pressed_key;
+          }
 
-    /* game logic */
+          if (pressed_key == Q_KEY || pressed_key == ESCAPE)
+            run = false;
+        }
 
-    /*
-    struct timeval current;
-    gettimeofday(&current, NULL);*/
+        /* game logic */
 
-    if (/*time_diff >= SPEED * 1000*/ true) {
+        /*
+        struct timeval current;
+        gettimeofday(&current, NULL);*/
 
-      ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);
+        if (/*time_diff >= SPEED * 1000*/ true) {
 
-      if (current_size.ws_col != init_size.ws_col ||
-          current_size.ws_row != init_size.ws_row) {
-        init_size = current_size;
+          ioctl(STDOUT_FILENO, TIOCGWINSZ, &current_size);
 
-        paused = 1;
-        too_small = draw_board(game_size, board, current_size, true, paused, score);
-      }
+          if (current_size.ws_col != init_size.ws_col ||
+              current_size.ws_row != init_size.ws_row) {
+            init_size = current_size;
 
-      if (!paused) {
+            paused = 1;
+            too_small = draw_board(game_size, board, current_size, true, paused, score);
+          }
 
-        if (tmp_direction < DIRECTIONS &&
-            ((shift + (DIRECTIONS >> 1)) % DIRECTIONS) != tmp_direction) {
-          shift = tmp_direction;
-        }
+          if (!paused) {
 
-        uint8_t update = update_snake(game_size ,&my_snake, shift);
+            if (tmp_direction < DIRECTIONS &&
+                ((shift + (DIRECTIONS >> 1)) % DIRECTIONS) != tmp_direction) {
+              shift = tmp_direction;
+            }
 
-        uint8_t head_y = my_snake.position[0].coords.y;
-        uint8_t head_x = my_snake.position[0].coords.x;
+            uint8_t update = update_snake(game_size ,&my_snake, shift);
+
+            uint8_t head_y = my_snake.position[0].coords.y;
+            uint8_t head_x = my_snake.position[0].coords.x;
+
+            if (board[head_y][head_x] == FRUIT) {
+              my_snake.length++;
+              score += 1 + 
+                (((MAX_SIZE >> 1) / (game_size.y) + 
+                (MAX_SIZE >> 1) / (game_size.x) + 
+                (my_snake.length - STARTING_LENGTH)) / (game_speed + 1));
+              snake_part *tmp = realloc(my_snake.position, (my_snake.length + 1) * sizeof(snake_part));
+              if (tmp == NULL) {
+                gameloop = false;
+                break;
+              }
+              my_snake.position = tmp;
 
-        if (board[head_y][head_x] == FRUIT) {
-          my_snake.length++;
-          score += 1 + 
-            (((MAX_SIZE >> 1) / (game_size.y) + 
-            (MAX_SIZE >> 1) / (game_size.x) + 
-            (my_snake.length - STARTING_LENGTH)) / (game_speed + 1));
-          snake_part *tmp = realloc(my_snake.position, (my_snake.length + 1) * sizeof(snake_part));
-          if (tmp == NULL)
-            goto end_free;
-          my_snake.position = tmp;
+              my_snake.position[my_snake.length].coords.y = -1;
+              my_snake.position[my_snake.length].coords.x = -1;
+            }
 
-          my_snake.position[my_snake.length].coords.y = -1;
-          my_snake.position[my_snake.length].coords.x = -1;
-        }
+            update_field(my_snake, game_size, board, false);
 
-        update_field(my_snake, game_size, board, false);
+            draw_board(game_size, board, current_size, false, 0, score);
 
-        draw_board(game_size, board, current_size, false, 0, score);
+            switch (update) {
+              case 0: 
+                gameloop = false;
+                break;
+              case 2:
+                setting = NEW_GAME;
+                run = false;
+                break;
+              default:
+                break;
+            }
 
-        switch (update) {
-          case 0: 
-            goto end_free;
-            break;
-          case 2:
-            setting = NEW_GAME;
-            draw_board(game_size, board, current_size, false, 2, score);
-            goto end_free;
-            break;
-          default:
-            break;
+          }
         }
-
+        nanosleep(&milispeed, NULL);
       }
     }
-    nanosleep(&milispeed, NULL);
   }
 
-end_free:
+
 
   free(my_snake.position);
   free(board);
   free(values);
 
-  if (setting == NEW_GAME)
-    goto menu_start;
-
-end_of_program:
-
   tcsetattr(STDIN_FILENO, TCSANOW, &old);
   printf("\033[?25h\n\n");
 

Modified file: snake.h+1−1

@@ -99,7 +99,7 @@ bool draw_board(selected game_size, board_state **board,

9999 void draw_pause(struct winsize window_size,

100100 uint8_t field_width,uint8_t field_height, uint8_t game_over);

101101 void draw_highscore (int16_t new_score,

102- score leader_board[SCORE_NUMBER]);

102+ score leader_board[SCORE_NUMBER], struct winsize window_size);

103103

104104 bool print_buffer(uint16_t width, char *string);

snake_c

Commit c28baaaf800e

Commit `c28baaaf800e`