I'm learning C programming. And wrote a Snake game for practice. Since I'm self-learning I figured I could post my program here and ask for tips and recommendations to improve it and it could turn into a reference for beginners with more experienced programmers comments on it.
It uses ANSI codes and Linux specific library to handle terminal drawings unfortunately. If there is a platform independent solutions please help me with that.
It compiles with no additional linking or flag:
`$ cc snake.c`
Code:
Code:#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
// For input handling
#include <fcntl.h>
#include <termios.h>
#define W 32
#define H 16
#define MAX_INX (H * W)
#define BODY_C 's'
#define HEAD_C 'Q'
#define APPLE_C '*'
// Set this to 1 for passing through walls and comming out from the other side
#define PASS_WALL 1
// `CSI 0 ; 0 H` puts the cursor at 0, 0 (defaul position).
// `CSI 0 J` clears from cursor to end of screen.
// `CSI 3 J` clears entire screen and deletes all lines saved in the scrollback
// buffer.
#define cls() printf("\033[H\033[J\033[3J")
#define hide_cursor() printf("\033[?25l")
#define show_cursor() printf("\033[?25h")
#define set_cursor(x, y) printf("\033[%d;%dH", x, y)
typedef struct Point {
char c;
struct Point* n; // next point
} Point;
typedef struct Snake {
int len;
int vx; // x axis velocity
int vy; // y axis velocity
int inx;
Point* head;
Point* tail;
} Snake;
void drop_apple(Point* table) {
while (1) {
int a_inx = rand() % MAX_INX;
if (table[a_inx].c == ' ') {
table[a_inx].c = APPLE_C;
break;
}
}
}
void init_game(Point* table, Snake* snake) {
// Fill table with spaces
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
table[(i * W) + j].c = ' ';
table[(i * W) + j].n = NULL;
}
}
// Fill vertical table borders with '|'
for (int j = 0; j < W; j += (W - 1)) {
for (int i = 0; i < H; ++i) {
table[(i * W) + j].c = '|';
}
}
// Fill horizontal table borders with '-'
for (int i = 0; i < H; i += (H - 1)) {
for (int j = 0; j < W; ++j) {
table[(i * W) + j].c = '-';
}
}
// We use a fixed position and body direction for now.
int x = 1;
int y = 1;
int inx = (y * W) + x;
// Tail of the snake
table[inx].c = BODY_C;
table[inx].n = &table[inx + 1];
snake->tail = &table[inx];
// Body of the snake
for (int i = 1; i < snake->len; ++i) {
table[inx + i].c = BODY_C;
table[inx + i].n = &table[inx + i + 1];
}
// Head of the snake
table[inx + snake->len].c = HEAD_C;
table[inx + snake->len].n = NULL;
snake->head = &table[inx + snake->len];
snake->inx = inx + snake->len;
srand(time(NULL)); // Initialization, should only be called once.
drop_apple(table);
}
void draw_table(const Point* table, const Snake* snake) {
cls();
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
printf("%c", table[(i * W) + j].c);
}
printf("\r\n");
}
printf("j: down, k: up, h: left, l: right\n");
printf("score: %d\n", snake->len - 3);
}
// Defined at the end of the file.
int kbhit(void);
void get_dir(int* vx, int* vy) {
char c = ' ';
if (kbhit()) {
c = getchar();
}
switch (c) {
case 'h':
*vx = -1;
*vy = 0;
break;
case 'j':
*vy = 1;
*vx = 0;
break;
case 'k':
*vy = -1;
*vx = 0;
break;
case 'l':
*vx = 1;
*vy = 0;
break;
default:; break;
}
}
void update_table(Point* table, Snake* snake) {
int vx = 0;
int vy = 0;
get_dir(&vx, &vy);
// Ignore changing the velocity if trying to move backwards.
if (!(snake->vx == -vx || snake->vy == -vy)) {
snake->vx = vx;
snake->vy = vy;
}
int inx = snake->inx + snake->vx + (snake->vy * W);
// We are opting to move the tail before the head. So that the player
// could run in a circle. Therefore we check for invalid index after
// moving the tail.
if (table[inx].c != APPLE_C) {
// Move the tail one up in linked list
Point* temp = snake->tail->n;
snake->tail->n = NULL;
snake->tail->c = ' ';
snake->tail = temp;
} else {
// Don't move the tail and increase score (len) drop a new apple
snake->len += 1;
drop_apple(table);
}
#if PASS_WALL == 1
// Validate the new head position.
if (table[inx].c == BODY_C) {
printf("Illegal index, you lost!\n");
printf("Index %d\n", inx);
exit(1);
}
// Move to the other side if hitting walls.
if (table[inx].c == '|') {
inx = (inx % W) > (W / 2) ? inx - (W - 2) : inx + (W - 2);
} else if (table[inx].c == '-') {
inx = (inx / W) > (H / 2) ? inx - ((H - 2) * W) : inx + ((H - 2) * W);
}
#else
// Validate the new head position.
if (table[inx].c != ' ' && table[inx].c != APPLE_C) {
printf("Illegal index, you lost!\n");
exit(1);
}
#endif
// Set the new head position.
table[inx].n = NULL;
table[inx].c = HEAD_C;
snake->head->n = &table[inx];
snake->head->c = BODY_C;
snake->head = &table[inx];
snake->inx = inx;
}
int main(int argc, char** argv) {
Point table[W][H];
Snake snake = {.len = 3, .vx = 1, .vy = 0};
init_game(&table[0][0], &snake);
while (1) {
update_table(&table[0][0], &snake);
draw_table(&table[0][0], &snake);
// loop's delay
usleep(150000);
}
}
// Copied from the internet for non-blocking, non-line-bufferd input read
// Thanks to Thantos's answer in this thread:
// https://cboard.cprogramming.com/c-programming/63166-kbhit-linux.html
int kbhit(void) {
struct termios oldt;
struct termios newt;
int ch;
int oldf;
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
fcntl(STDIN_FILENO, F_SETFL, oldf);
if (ch != EOF) {
ungetc(ch, stdin);
return 1;
}
return 0;
}
