progress

global_macros.h

@@ -1,8 +0,0 @@
-#ifndef GLOBAL_MACROS_H
-#define GLOBAL_MACROS_H
-
-#define BUF_SIZE 256
-#define BRD_SIZE_X 15
-#define BRD_SIZE_Y 30
-
-#endif // GLOBAL_MACROS_H

globals.h

@@ -1,5 +1,5 @@
-#ifndef GLOBALS_H
-#define GLOBALS_H
+#ifndef GLOBALS_H_
+#define GLOBALS_H_
 
 #define BUF_SIZE 256
 
@@ -13,4 +13,4 @@
 #define PL_BRD_YS 1
 #define PL_BRD_YE BRD_SIZE_Y - 2
 
-#endif // GLOBALS_H
+#endif  // GLOBALS_H_

main.c

@@ -2,34 +2,22 @@
 #include <unistd.h>
 #include <termios.h>
 #include <stdlib.h>
-#include <time.h>
 #include <ctype.h>
+#include <string.h>
+#include <time.h>
 #include "./globals.h"
+#include "./utils/utils.h"
+#include "./snake/snake.h"
 
-//TEMP
-#include "./test_utils/test_utils.h"
-
-typedef struct {
-  int x;
-  int y;
-  char visChar;
-} brdSymbol;
-
-typedef struct snakeNode {
-  int x;
-  int y;
-
-  char dir;
-  struct snakeNode* prev;
-} snakePart;
-
-int randomInt(const int start, const int end);
-void sleep_ms(const int ms);
-void mvSymbol(brdSymbol* symbol, const char dir);
+void mvSnakeParts(snakePart* head);
 
 char board[BRD_SIZE_Y][BRD_SIZE_X];
 
+const char SNAKE_VIS = '#';
+
 int main() {
+  clock_t initClock = clock();
+
   // Termios setup
   struct termios attr;
 
@@ -46,74 +34,126 @@ int main() {
   // Game board setup
   for (int i = 0; i < BRD_SIZE_Y; i++) {
     for (int j = 0; j < BRD_SIZE_X; j++) {
-      if (
-          (i > 0 && i < BRD_SIZE_Y - 1)
-          && (j == 0 || j == BRD_SIZE_X - 1)
-          ) {
-        board[i][j] = '|';
-      } else if (
-          (i == 0 || i == BRD_SIZE_Y - 1)
-          && (j > 0 && j < BRD_SIZE_X - 1)
-        ) {
+      if (i == 0 || i == BRD_SIZE_Y - 1)
         board[i][j] = '-';
-      } else {
+      else if (j == 0 || j == BRD_SIZE_X - 1)
+        board[i][j] = '|';
+      else
         board[i][j] = ' ';
     }
   }
-  }
 
   board[0][0] = '+';
   board[BRD_SIZE_Y - 1][0] = '+';
   board[0][BRD_SIZE_X - 1] = '+';
   board[BRD_SIZE_Y - 1][BRD_SIZE_X - 1] = '+';
 
-  brdSymbol player;
-  player.x = randomInt(PL_BRD_XS, PL_BRD_XE);
-  player.y = randomInt(PL_BRD_YS, PL_BRD_YE);
-  player.visChar = '#';
+  char mvPoints[BRD_SIZE_Y][BRD_SIZE_X];
   
-  board[player.y][player.x] = player.visChar;
+  for (int i = 0; i < BRD_SIZE_Y; i++) {
+    for (int j = 0; j < BRD_SIZE_X; j++) {
+      mvPoints[i][j] = '0';
+    }
+  }
 
+  int points = 0;
+
+  // Snake head setup
+  snakePart* snakeHead = (snakePart*) malloc(sizeof(snakePart));
+  snakeHead->x = randomX(initClock);
+  snakeHead->y = randomY(initClock);
+  snakeHead->visChar = SNAKE_VIS;
+  snakeHead->dir = 'w';
+  snakeHead->next = NULL;
+
+  board[snakeHead->y][snakeHead->x] = snakeHead->visChar;
+
+  // Food setup
+  struct {
+    int x;
+    int y;
+    char visChar;
+  } food;
+  food.x = randomX(initClock);
+  food.y = randomY(initClock);
+  food.visChar = '$';
+
+  board[food.y][food.x] = food.visChar;
+
+  // Screen init
   system("clear");
-  printBoard();
-  printf("x: %d\n", player.x);
-  printf("y: %d\n", player.y);
 
+  // Game loop
   while (1) {
     fflush(stdout);
     char buf[1] = {0};
-    if (read(STDIN_FILENO, buf, 1) == 0)
-      continue;
+    if (read(STDIN_FILENO, buf, 1) != 0 && isalpha(buf[0])) {
       char input = buf[0];
 
-    if (!isalpha(input))
-      continue;
-
       input = tolower(input);
 
-    switch (input) {
-      case 'w':
-        mvSymbol(&player, 'u');
+      if (
+          input == 'w'
+          || input == 's'
+          || input == 'a'
+          || input == 'd'
+          ) {
+        if (points > 0)
+          mvPoints[snakeHead->y][snakeHead->x] = input;
+        snakeHead->dir = input;
+      }
+    }
+
+    for (int i = 0; i < BRD_SIZE_Y; i++) {
+      for (int j = 0; j < BRD_SIZE_X; j++) {
+        if (mvPoints[i][j] == '0')
+          continue;
+
+        snakePart* part = snakeHead;
+        while (part->next != NULL) {
+          part = part->next;
+
+          if (part->y == i && part->x == j) {
+            part->dir = mvPoints[i][j];
+            if (part->next == NULL)
+              mvPoints[i][j] = '0';
             break;
-      case 's':
-        mvSymbol(&player, 'd');
+          }
+
+          if (part->next == NULL)
             break;
-      case 'a':
-        mvSymbol(&player, 'l');
-        break;
-      case 'd':
-        mvSymbol(&player, 'r');
-        break;
-      default:
-        NULL;
+        }
+      }
+    }
+
+    mvSnakeParts(snakeHead);
+
+    if (snakeHead->x == food.x
+        && snakeHead->y == food.y) {
+      points++;
+      food.x = randomX(initClock);
+      food.y = randomY(initClock);
+      board[food.y][food.x] = food.visChar;
+      addSnakePart(snakeHead);
     }
     
     system("clear");
     printBoard();
-    printf("x: %d\n", player.x);
-    printf("y: %d\n", player.y);
+    printf("Points: %d\n", points);
+    printf("x: %d\n", snakeHead->x);
+    printf("y: %d\n", snakeHead->y);
+    printf("food x: %d\n", food.x);
+    printf("food y: %d\n", food.y);
+    printf("food: %c\n", board[food.y][food.x]);
 
-    sleep_ms(50);
+    for (int i = 0; i < BRD_SIZE_Y; i++) {
+      for (int j = 0; j < BRD_SIZE_X; j++) {
+        printf("%c ", mvPoints[i][j]);
+      }
+      printf("\n");
+    }
+
+    sleep_ms(200);
   }
 
   // Termios reset
@@ -122,45 +162,41 @@ int main() {
   return 0;
 }
 
-int randomInt(const int start, const int end) {
-  /*
-   * Gets random int from range
-   * [start, end[
-  */
-  srand(time(NULL));
-  int result = rand() % end;
-  result = result >= start ? result : result + start;
-  return result;
-}
+void mvSnakeParts(snakePart* head) { 
+  snakePart* part = head;
+  while (1) {
+    int x = part->x;
+    int y = part->y;
 
-void sleep_ms(const int ms) {
-  usleep(ms * 1000);
-}
+    board[y][x] = ' ';
 
-void mvSymbol(brdSymbol* symbol, const char dir) { 
-  board[symbol->y][symbol->x] = ' ';
-
-  switch (dir) {
-    case 'u':
-      symbol->y = symbol->y - 1 < PL_BRD_YS ? PL_BRD_YE : symbol->y - 1;
+    switch (part->dir) {
+      case 'w':
+        y = y - 1 < PL_BRD_YS ? PL_BRD_YE : y - 1;
+        break;
+      case 's':
+        y = y + 1 > PL_BRD_YE ? PL_BRD_YS : y + 1;
+        break;
+      case 'a':
+        x = x - 2 < PL_BRD_XS ? PL_BRD_XE : x - 2;
         break;
       case 'd':
-      symbol->y = symbol->y + 1 > PL_BRD_YE ? PL_BRD_YS : symbol->y + 1;
-      break;
-    case 'l':
-      symbol->x = symbol->x - 2 < PL_BRD_XS ? PL_BRD_XE : symbol->x - 2;
-      break;
-    case 'r':
-      symbol->x = symbol->x + 2 > PL_BRD_XE ? PL_BRD_XS : symbol->x + 2;
+        x = x + 2 > PL_BRD_XE ? PL_BRD_XS : x + 2;
         break;
       default:
         printf("ERROR in func mvSymbol\n");
+        printf("dir: %c\n", part->dir);
         exit(1);
     }
 
-  board[symbol->y][symbol->x] = symbol->visChar;
-}
+    part->x = x;
+    part->y = y;
 
-void addSnakePart(snakePart** tail) {
-  *(tail)->symbolInfo.visChar = 
+    board[y][x] = part->visChar;
+
+    if (part->next == NULL)
+      return;
+
+    part = part->next;
+  }
 }

snake/snake.c

@@ -0,0 +1,44 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "snake.h"
+
+extern char board[BRD_SIZE_Y][BRD_SIZE_X];
+
+void addSnakePart(snakePart* head) {
+  snakePart* tail = head;
+
+  while (tail->next != NULL)
+    tail = tail->next;
+
+  snakePart* newTail = (snakePart*) malloc(sizeof(snakePart));
+  newTail->visChar = '#';
+  newTail->dir = tail->dir;
+
+  switch (newTail->dir) {
+    case 'w':
+      newTail->x = tail->x;
+      newTail->y = tail->y + 1;
+      break;
+    case 's':
+      newTail->x = tail->x - 1;
+      newTail->y = tail->y;
+      break;
+    case 'a':
+      newTail->x = tail->x - 1;
+      newTail->y = tail->y;
+      break;
+    case 'd':
+      newTail->x = tail->x;
+      newTail->y = tail->y - 1;
+      break;
+    default:
+      printf("Invalid direction in func addSnakePart\n");
+      exit(1);
+  }
+
+  newTail->next = NULL;
+
+  tail->next = newTail;
+
+  board[newTail->y][newTail->x] = newTail->visChar;
+}

snake/snake.h

@@ -0,0 +1,17 @@
+#ifndef SNAKE_H_
+#define SNAKE_H_
+
+#include "../globals.h"
+
+typedef struct snakeNode {
+  int x;
+  int y;
+  char visChar;
+
+  char dir;
+  struct snakeNode* next;
+} snakePart;
+
+void addSnakePart(snakePart* head);
+
+#endif  // SNAKE_H_

test_utils/test_utils.c

@@ -1,14 +0,0 @@
-#include <stdio.h>
-#include "test_utils.h"
-#include "../globals.h"
-
-extern char board[BRD_SIZE_Y][BRD_SIZE_X];
-
-void printBoard() {
-  for (int i = 0; i < BRD_SIZE_Y; i++) {
-    for (int j = 0; j < BRD_SIZE_X; j++) {
-      printf("%c", board[i][j]);
-    }
-    printf("\n");
-  }
-}

test_utils/test_utils.h

@@ -1,8 +0,0 @@
-#ifndef TEST_UTILS_H
-#define TEST_UTILS_H
-
-#include "../globals.h"
-
-void printBoard();
-
-#endif // TEST_UTILS_H

utils/utils.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "utils.h"
+#include "../globals.h"
+
+extern char board[BRD_SIZE_Y][BRD_SIZE_X];
+
+int randomInt(const int start, const int end, const unsigned int seed) {
+  /*
+   * Gets random int from range
+   * [start, end[
+  */
+  srand(seed);
+  int result = rand() % end;
+  result = result >= start ? result : result + start;
+  return result;
+}
+
+int randomX(const clock_t initClock) {
+  int x;
+  const unsigned int seed = clock() - initClock;
+  for (int i = randomInt(0, 100, seed); ; i++) {
+    x = randomInt(PL_BRD_XS, PL_BRD_XE, i);
+    if (x % 2 == 0)
+      break;
+  }
+
+  return x;
+}
+
+int randomY(const clock_t initClock) {
+  const unsigned int seed = clock() - initClock;
+  return randomInt(PL_BRD_YS, PL_BRD_YE, seed);
+}
+
+void sleep_ms(const int ms) {
+  usleep(ms * 1000);
+}
+
+void printBoard() {
+  for (int i = 0; i < BRD_SIZE_Y; i++) {
+    for (int j = 0; j < BRD_SIZE_X; j++) {
+      printf("%c", board[i][j]);
+    }
+    printf("\n");
+  }
+}

utils/utils.h

@@ -0,0 +1,12 @@
+#ifndef UTILS_H_
+#define UTILS_H_
+
+#include <time.h>
+
+int randomInt(const int start, const int end, const unsigned int seed);
+int randomX(const clock_t initClock);
+int randomY(const clock_t initClock);
+void sleep_ms(const int ms);
+void printBoard();
+
+#endif  // UTILS_H_