1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:

#include <stdio.h>
#include <stdlib.h>
#include "support.h"
#define BLANK 0
#define HEAD 1
#define TAIL 2
#define KEY_MOVE_UP 119
#define KEY_MOVE_LEFT 97
#define KEY_MOVE_DOWN 115
#define KEY_MOVE_RIGHT 100
#define WIDTH 60
#define HEIGHT 30

struct position {
  int x;
  int y;
} pos;

int field[WIDTH][HEIGHT];
void setItem(int, int, int);
void move(int);
int collision(int, int, int);
void printGame();

int main() {
	int key;
	support_clear();
	int i,j;
	for(i=0;i<WIDTH;i++)
	  for(j=0;j<HEIGHT;j++)
	    field[i][j] = 0;
	// Startposition
	pos.x=WIDTH/2;
	pos.y=HEIGHT/2;
	setItem(pos.x, pos.y, HEAD);
	support_init();
	do {
		key = support_readkey(1000);
		move(key);
		printGame();
	} while(key!='q');
	
	printf("\n\n");
	printf("Spiel vorbei!");
	return 0; 
}

void move(int key) {
	setItem(pos.x, pos.y, TAIL);
	switch(key) {
		case KEY_MOVE_UP: pos.y--; break;
		case KEY_MOVE_LEFT: pos.x--; break;
		case KEY_MOVE_DOWN: pos.y++; break;
		case KEY_MOVE_RIGHT: pos.x++; break;
	}

	if(pos.y >= HEIGHT) pos.y=0;
	if(pos.y < 0) pos.y=HEIGHT-1;
	if(pos.x >= WIDTH) pos.x=0;
	if(pos.x < 0) pos.x=WIDTH-1;

	setItem(pos.x, pos.y, HEAD);
}

void printGame() {
 support_clear();
 int i,j;
	for(i=0;i<WIDTH;i++) {
	    for(j=0;j<HEIGHT;j++) {
		switch(field[i][j]) {
		  case HEAD: printf("o");break;
		  case TAIL: printf("x");break;
		  default:break;
		}
	    }
	} 
}

void setItem(int x, int y, int item) {
	field[x][y] = item;
}

int collision(int x, int y, int item) {
	return 0;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:

#include "support.h"

#ifdef _WIN32

#include <conio.h>

void support_init() {
	// not needed
}

void support_clear() {
	system("CLS");
}

int support_readkey(int timeout_ms) {
	Sleep(timeout_ms);
	if (!kbhit()) return 0;
	return getch();
}

#else

#include <stdio.h>
#include <unistd.h>
#include <termios.h>
#include <sys/select.h>

void support_init() {
	struct termios tio;
	tcgetattr(STDIN_FILENO, &tio);
	tio.c_lflag &= (~ICANON & ~ECHO);
	tcsetattr(STDIN_FILENO, TCSANOW, &tio);
}

void support_clear() {
	printf("\x1B[2J\x1B[0;0f");
}

int support_readkey(int timeout_ms) {
	struct timeval tv = { 0L, timeout_ms * 1000L };
	fd_set fds;
	FD_ZERO(&fds);
	FD_SET(0, &fds);
	int r = select(1, &fds, NULL, NULL, &tv);
	if (!r) return 0;

	return getchar();
}

#endif

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

//   ___     __ ___                                       _
//  |_ _|   / // _ \     ___ _   _ _ __  _ __   ___  _ __| |_
//   | |   / /| | | |   / __| | | | '_ \| '_ \ / _ \| '__| __|
//   | |  / / | |_| |   \__ \ |_| | |_) | |_) | (_) | |  | |_
//  |___|/_/   \___/    |___/\__,_| .__/| .__/ \___/|_|   \__|
//                                |_|   |_|

/**
 * Prepares support library for operation.
 *
 * Call this once at (or near) program start.
 */
void support_init();


/**
 * Clears the screen.
 */
void support_clear();


/**
 * Waits up to "timeout_ms" milliseconds for key press.
 *
 * Returns ASCII value or 0 (if no key was pressed).
 */
int support_readkey(int timeout_ms);

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

CFLAGS=-std=c11 -Wall -g
CC=clang

all: snake

.PHONY: all clean

snake: snake.o support.o

snake.o: snake.c support.h

clean:
	rm -f snake
	rm -f snake.o support.o

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:

#include <stdio.h>
#include <stdlib.h>
#include "support.h"
#define KEY_MOVE_UP 119
#define KEY_MOVE_LEFT 97
#define KEY_MOVE_DOWN 115
#define KEY_MOVE_RIGHT 100
#define WIDTH 40
#define HEIGHT 40
#define LENGTH 8

struct position {
  int x;
  int y;
} pos;

int direction = KEY_MOVE_UP;
int end = 0;
int field[WIDTH][HEIGHT];
void setItem(int, int, int);
void move(int);
int collision(int, int, int);
void printGame();

int main() {
	int key;
	support_init();
	support_clear();
	int i,j;
	for (i = 0; i < WIDTH; i++)
	  for (j = 0; j < HEIGHT; j++)
	    field[i][j] = 0;
	pos.x = WIDTH / 2;
	pos.y = HEIGHT / 2;
	printGame();
	do {
		key = support_readkey(200);
		move(key);
		printGame();
	} while(!end && key!='q');
	
	printf("\n\nSpiel vorbei!\n\n");
	return 0; 
}

void move(int key) {
	int x, y;
	for (x = 0; x < WIDTH; x++) {
		for (y = 0; y < HEIGHT; y++) {
			if (field[x][y] > 0) {
				field[x][y]--;
			}
		}
	}

	if (key == KEY_MOVE_UP || key == KEY_MOVE_LEFT || key == KEY_MOVE_DOWN || key == KEY_MOVE_RIGHT) {
		direction = key;
	}
	switch(direction) {
		case KEY_MOVE_UP: pos.y = (pos.y+HEIGHT-1) % HEIGHT; break;
		case KEY_MOVE_LEFT: pos.x = (pos.x+WIDTH-1) % WIDTH; break;
		case KEY_MOVE_DOWN: pos.y = (pos.y+1) % HEIGHT; break;
		case KEY_MOVE_RIGHT: pos.x = (pos.x+1) % WIDTH; break;
		default: return;
	}
	if (field[pos.x][pos.y] > 0) end = 1;
	field[pos.x][pos.y] = LENGTH;
}

void printGame() {
 support_clear();
 int i, j;
	for (j = 0; j < HEIGHT; j++) {
		for (i = 0; i < WIDTH; i++) {
			switch(field[i][j]) {
				case LENGTH: printf("o"); break;
				case 0: printf(" "); break; 
				default: printf("x"); break;
			}
		}
		printf("\n");
	} 
}