commit 8f3894a2c975924175d88de9a739c6c016851077 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jun 05 17:18:38 2025 +0000

    Add: info on compilation and configuration in the main README

diff --git a/README.md b/README.md
index d4ed8ea..c9df78b 100644
--- a/README.md
+++ b/README.md
@@ -13 +158 @@ 
 # Games
 
-A collection of small games. Configuration is done in the source file of each game.
+A collection of small games. Configuration is done in the source file of each
+game.
+
+Each game is in its own directory, accompanied with a README file explaining how
+to play the game and what configuration options are available. Additionally,
+each game is only a single source file, allowing them the be turned into what
+may be referred to as "C scripts".
+
+## Compilation
+
+Each game requires only ncurses. Since the source for each game is a single
+file, compilation is fairly simple, and no makefile is provided.
+
+Enter the directory for whichever game. Compile the single C file using any C
+compiler, linking against ncurses. (`tcc` is my preferred compiler for this
+project.) Once compiled, simply run the binary.
+
+For example, to run `snake`:
+
+```
+$ cd snake
+$ cc -o snake snake.c -lncurses
+$ ./snake
+```
+
+If using `tcc`, the game can be run directly from the compiler:
+
+```
+$ cd snake
+$ tcc -lncurses -run snake.c
+```
+
+## Configuring
+
+Configuration is done by either specifying the config options in the compiler
+command line, or by `#define`-ing them at the top of the C file.
+
+To configure from the command line, the compilation command may look like this:
+
+```
+$ cc -DX=128 -DY=64 -o snake snake.c -lncurses
+```
+
+This will set the `X` option equal to `128` and the `Y` option to `64`.
+
+Configuring directly in the source file may look like this:
+
+```c
+// define your options here vvv
+#define X 128
+#define Y 64
+
+// this is stuff already in the file vvv
+#include <ncurses.h>
+...
+```

commit c4580f99e613de30bafaefac162f0570b68c1fc2 
Author: rani <clagv.randomgames@gmail.com>
Date: Tue Jun 03 21:41:35 2025 +0000

    Add: td: sniper turret

diff --git a/td/td.c b/td/td.c
index cd854e0..0ce4ab8 100644
--- a/td/td.c
+++ b/td/td.c
@@ -1526 +15212 @@ struct {
 					       { 50,   4,   0,    2,   0,            5     },
 					       { 75,   4,   0,    3,   0,            4     },
 	}},
+	{"Sniper",         '|', 125,  25,   0,    1,   0,    -1,    40,   4, {
+	                       {100,  25,   0,    2,   0,           32     },
+						   {125,  25,   0,    3,   0,           27     },
+						   {200,  25,   0,    5,   0,           20     },
+						   {400,  25,   0,    5,   0,           10     },
+	}},
 	{"Bomb Lobber",    '&', 165,   3,   1,    1,   1,    -1,    10,   3, {
 	                       { 50,   3,   2,    1,   1,           10     },
 					       {100,   4,   2,    1,   2,           10     },

commit 758b343b66b3bf706c61a9f813e04d03c200ff73 
Author: rani <clagv.randomgames@gmail.com>
Date: Tue Jun 03 21:20:41 2025 +0000

    Fix: td: error opening upgrade menu for adjacent turrets

diff --git a/td/td.c b/td/td.c
index d770976..cd854e0 100644
--- a/td/td.c
+++ b/td/td.c
@@ -9037 +9037 @@ int main(void) {
 						for (int i = 0; i < spawned_turrets.idx; i++) {
 							x = spawned_turrets.spawned[i].x;
 							y = spawned_turrets.spawned[i].y;
-							if (x != e.x - 1 && y != e.y - 1) continue;
+							if (x != e.x - 1 || y != e.y - 1) continue;
 							
 							tid = i;
 							break;

commit 8df6b05358ace1afad3c0a43315c4b15c430c4a8 
Author: rani <clagv.randomgames@gmail.com>
Date: Tue Jun 03 21:04:14 2025 +0000

    Add td game

diff --git a/td/README.md b/td/README.md
new file mode 100644
index 0000000..4cf4838 
--- /dev/null
+++ b/td/README.md
@@ -00 +134 @@ 
+# TD
+
+A simple, randomly generated, tower defense game.
+
+Click on a turret's name in the shop to begin purchasing, then click on a tile
+to place it there. Press q to abort the purchase. Click on a turret (that has
+already been placed) to open the upgrade menu. Click on the info button to see
+the turret's stats. Buttons (in any menu) can be clicked on if they are
+highlighted. Otherwise, they cannot be clicked on. Space to pause, any to
+resume. q to quit.
+
+Start by purchasing a turret and placing it on the map such that it is in range
+of a path tile. Spikes may only be placed on path tiles and will run out after a
+certain number of enemies run over them. When an enemy is killed, cash is
+rewarded and the score increases. Once enough cash is earned, a turret may be
+upgraded from its upgrade menu. Otherwise, another turret can be purchased and
+placed on the map. Certain turrets may deal splash damage to enemies so that one
+attack will damage multiple enemies at once. After killing enough enemies, the
+round is progressed and a new wave of enemies is spawned. As the rounds
+progress, enemies will gain more health and move faster.
+
+# Config
+
+* `X`: Board width (integer)
+* `Y`: Board height (integer)
+* `SEED`: PRNG seed (integer)
+* `DELAY`: The delay (in milliseconds) between game ticks (integer)
+* `PATH_BENDS`: The number of bends in the path (integer)
+* `ATTACK_ANIMATION_DELAY`: The delay (ms) to animate attacks (integer)
+* `MAX_ENEMIES`: The maximum number of enemies in a round (integer)
+* `MAX_TURRETS`: The maximum number of turrets allowed on the map (integer)
+* `STARTING_CASH`: Amount of cash at the start of the game (integer)
+* `STARTING_LIVES`: Amount of lives at the start of the game (integer)
+* `STARTING_ROUND`: The round at which the game starts (integer)
diff --git a/td/td.c b/td/td.c
new file mode 100644
index 0000000..d770976 
--- /dev/null
+++ b/td/td.c
@@ -00 +1965 @@ 
+#include <ncurses.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdlib.h>
+
+/* BEGIN CONFIG */
+#ifndef X
+#define X 64
+#endif /* X */
+
+#ifndef Y
+#define Y 32
+#endif /* Y */
+
+#ifndef SEED
+#include <time.h>
+#define SEED time(NULL)
+#endif /* SEED */
+
+#ifndef DELAY
+#define DELAY 100
+#endif /* DELAY */
+
+#ifndef PATH_BENDS
+#define PATH_BENDS 3
+#endif /* PATH_BENDS */
+
+#ifndef ATTACK_ANIMATION_DELAY
+#define ATTACK_ANIMATION_DELAY 35
+#endif /* ATTACK_ANIMATION_DELAY */
+
+#ifndef MAX_ENEMIES
+#define MAX_ENEMIES 256
+#endif /* MAX_ENEMIES */
+
+#ifndef MAX_TURRETS
+#define MAX_TURRETS 128
+#endif /* MAX_TURRETS */
+
+#ifndef STARTING_CASH
+#define STARTING_CASH 120
+#endif /* STARTING_CASH */
+
+#ifndef STARTING_LIVES
+#define STARTING_LIVES 25
+#endif /* STARTING_LIVES */
+
+#ifndef STARTING_ROUND
+#define STARTING_ROUND 1
+#endif /* STARTING_ROUND */
+/* END CONFIG */
+
+#define ARRLEN(a) (sizeof(a)/sizeof(*a))
+
+#define BIN1(a) (a & 1)
+#define BIN2(a,b) ((BIN1(a) << 1 ) | BIN1(b))
+#define BIN4(a,b,c,d) ((BIN2(a,b) << 2) | BIN2(c,d))
+#define BIN8(a,b,c,d,e,f,g,h) ((BIN4(a,b,c,d) << 4) | BIN4(e,f,g,h))
+
+#define CELL_PATH_MASK BIN8(0,0,0,0,1,1,0,0)
+#define INT_TO_CELL_PATH(i) (((i) & (CELL_PATH_MASK >> 2)) << 2)
+#define CELL_PATH_TO_INT(c) (((c) & CELL_PATH_MASK) >> 2)
+
+#define CELL_TURRET_MASK BIN8(1,1,1,1,0,0,0,0)
+#define INT_TO_CELL_TURRET(i) (((i) & (CELL_TURRET_MASK >> 4)) << 4)
+#define CELL_TURRET_TO_INT(c) (((c) & CELL_TURRET_MASK) >> 4)
+
+#define SHOP_STARTX (X + 2)
+#define SHOP_STARTY (1)
+
+#define SHOP_ID_TO_X(id) (SHOP_STARTX)
+#define SHOP_ID_TO_Y(id) ((id) * 2 + SHOP_STARTY + 2)
+
+#define Y_TO_SHOP_ID(y) (((y) - SHOP_STARTY) % 2 == 1 ?     \
+                         (-1) :                             \
+                         (((y) - SHOP_STARTY - 2) / 2))
+
+
+enum color {
+	RED = 1,
+	GREEN,
+	YELLOW,
+	BLUE,
+	MAGENTA,
+	CYAN,
+};
+
+enum state {
+	RUNNING,
+	PAUSED,
+	GAME_OVER,
+	QUIT,
+};
+
+enum cell {
+	CELL_EMPTY  = 0,
+	CELL_PATH   = 1 << 0,
+	CELL_TURRET = 1 << 1,
+};
+
+enum cell_path {
+	CELL_PATH_UP,
+	CELL_PATH_DOWN,
+	CELL_PATH_LEFT,
+	CELL_PATH_RIGHT,
+};
+
+
+struct enemies {
+	struct enemy {
+		int x;
+		int y;
+		int count;
+		int ticks;
+	} enemies[MAX_ENEMIES];
+
+	int idx;
+	int last_round;
+	int spawned;
+	int killed;
+	int to_spawn;
+
+	int spawnx;
+	int spawny;
+};
+
+
+struct {
+	char * name;
+	char symbol;
+	int cost;    // cost to purchase
+	int radius;  // attack radius
+	int rsplash; // slash damage radius
+	int damage;  // damage per attack
+	int dsplash; // splash damage
+	int stack;   // amount of turrets per tile (-1 for attacking turrets)
+	int ticks;   // ticks between attacks
+	int n_upgrades; // number of upgrades
+	struct {
+		int cost;
+		int radius;
+		int rsplash;
+		int damage;
+		int dsplash;
+		int ticks;
+	} upgrades[4];
+} turrets[] = {
+/*    Name             Sym  Cost  Rad RSplsh Dmg DSplsh Stack  Tick nUpgr*/
+	{"Spikes",         'M',  25,   0,   0,    1,   0,    10,     1,   0,},
+	{"Gunner",         '%', 100,   3,   0,    1,   0,    -1,     5,   3, {
+	                       { 25,   4,   0,    1,   0,            5     },
+					       { 50,   4,   0,    2,   0,            5     },
+					       { 75,   4,   0,    3,   0,            4     },
+	}},
+	{"Bomb Lobber",    '&', 165,   3,   1,    1,   1,    -1,    10,   3, {
+	                       { 50,   3,   2,    1,   1,           10     },
+					       {100,   4,   2,    1,   2,           10     },
+					       {150,   4,   2,    1,   2,            6     },
+	}},
+	{"Machine Gunner", '$', 400,   2,   0,    1,   0,    -1,     3,   4, {
+	                       {200,   3,   0,    1,   0,            3     },
+						   {400,   4,   0,    2,   0,            2     },
+						   {800,   5,   0,    4,   0,            2     },
+						   {8000,  5,   0,    4,   0,            1     },
+	}},
+};
+
+struct turrets {
+	struct spawned_turret {
+		int x;
+		int y;
+		int id;
+		int radius;
+		int rsplash;
+		int damage;
+		int dsplash;
+		int stack;
+		int ticks;
+		int level; // upgrade level
+		int kills;
+	} spawned[MAX_TURRETS];
+
+	int idx;
+} spawned_turrets;
+
+
+unsigned long ticks = 0;
+
+
+void enemies_push(struct enemies * enemies, int x, int y, int count, int ticks) {
+	int idx = enemies->idx;
+	enemies->enemies[idx].x = x;
+	enemies->enemies[idx].y = y;
+	enemies->enemies[idx].count = count;
+	enemies->enemies[idx].ticks = ticks;
+	enemies->spawned += count;
+	enemies->idx++;
+}
+
+
+void enemies_pop(struct enemies * enemies, int i) {
+	enemies->idx--;
+	memmove(&enemies->enemies[i], &enemies->enemies[i + 1],
+	        (MAX_ENEMIES - (i + 1)) * sizeof(*enemies->enemies));
+}
+
+
+void turrets_push(
+	struct turrets * spawned_turrets, char grid[X][Y], int x, int y, int id
+) {
+	int idx = spawned_turrets->idx;
+	spawned_turrets->spawned[idx].x = x;
+	spawned_turrets->spawned[idx].y = y;
+	spawned_turrets->spawned[idx].id = id;
+	spawned_turrets->spawned[idx].radius = turrets[id].radius;
+	spawned_turrets->spawned[idx].rsplash = turrets[id].rsplash;
+	spawned_turrets->spawned[idx].damage = turrets[id].damage;
+	spawned_turrets->spawned[idx].dsplash = turrets[id].dsplash;
+	spawned_turrets->spawned[idx].stack = turrets[id].stack;
+	spawned_turrets->spawned[idx].ticks = turrets[id].ticks;
+	spawned_turrets->spawned[idx].level = 0;
+	spawned_turrets->spawned[idx].kills = 0;
+	spawned_turrets->idx++;
+
+	grid[x][y] |= CELL_TURRET | INT_TO_CELL_TURRET(id);
+}
+
+void turrets_pop(struct turrets * spawned, char grid[X][Y], int x, int y, int i) {
+	spawned->idx--;
+	memmove(&spawned->spawned[i], &spawned->spawned[i + 1],
+	        (MAX_TURRETS - (i + 1)) * sizeof(*spawned->spawned));
+
+	grid[x][y] &= ~CELL_TURRET | INT_TO_CELL_TURRET(0xFF);
+}
+
+
+int rand_range(int lo, int hi) {
+	return rand() % (hi - lo) + lo;
+}
+
+
+void generate_path(char grid[X][Y], struct enemies * enemies) {
+	int spawnx = 0;
+	int spawny = rand() % Y;
+	enemies->spawnx = spawnx;
+	enemies->spawny = spawny;
+
+	int lastx = spawnx;
+	int lasty = spawny;
+	for (int i = 0; i < PATH_BENDS; i++) {
+		int bendx = rand_range(lastx + 1, (i + 1) * X / PATH_BENDS);
+		int bendy = rand_range(0, Y);
+
+		// horizontal run
+		for (int x = lastx; x < bendx; x++) {
+			grid[x][lasty] |= CELL_PATH | INT_TO_CELL_PATH(CELL_PATH_RIGHT);
+		}
+
+		// vertical connection
+		if (lasty != bendy) {
+			if (lasty < bendy) for (int y = lasty; y < bendy; y++) {
+				grid[bendx][y] |= CELL_PATH | INT_TO_CELL_PATH(CELL_PATH_DOWN);
+			} else for (int y = lasty; y > bendy; y--) {
+				grid[bendx][y] |= CELL_PATH | INT_TO_CELL_PATH(CELL_PATH_UP);
+			}
+		}
+
+		lastx = bendx;
+		lasty = bendy;
+	}
+
+	// connect to edge
+	for (int x = lastx; x < X; x++) {
+		grid[x][lasty] |= CELL_PATH | INT_TO_CELL_PATH(CELL_PATH_RIGHT);
+	}
+}
+
+
+char grid_getc(char grid[X][Y], int x, int y) {
+	char c = grid[x][y];
+	char out = ' ';
+	if (c & CELL_TURRET) out = turrets[CELL_TURRET_TO_INT(c)].symbol;
+    else if (c & CELL_PATH) switch(CELL_PATH_TO_INT(c)) {
+		case CELL_PATH_UP:    out = '^'; break;
+		case CELL_PATH_DOWN:  out = 'v'; break;
+		case CELL_PATH_LEFT:  out = '<'; break;
+		case CELL_PATH_RIGHT: out = '>'; break;
+	}
+	return out;
+}
+
+
+int grid_getcolor(char grid[X][Y], int x, int y) {
+	char c = grid[x][y];
+	int out = 0;
+	if (c & CELL_TURRET) out = A_UNDERLINE;
+	else if (c & CELL_PATH) out = A_DIM;
+	return out;
+}
+
+
+void draw_grid(char grid[X][Y]) {
+	addch('+');
+	for (int x = 0; x < X; x++) addch('-');
+	addch('+');
+	addch('\n');
+	for (int y = 0; y < Y; y++) {
+		addch('|');
+		for (int x = 0; x < X; x++) {
+			int cp = grid_getcolor(grid, x, y);
+			attron(cp);
+			addch(grid_getc(grid, x, y));
+			attroff(cp);
+		}
+		addstr("|\n");
+	}
+	addch('+');
+	for (int x = 0; x < X; x++) addch('-');
+	addch('+');
+	addch('\n');
+}
+
+
+
+int get_shop_str(char * s, int n, int i) {
+	return snprintf(s, n, "%s: $%d", turrets[i].name,
+	                turrets[i].cost);
+}
+
+
+int yx_to_shop_id(int y, int x) {
+	int id = Y_TO_SHOP_ID(y);
+	if (id < 0) return -1;
+	if (id >= ARRLEN(turrets)) return -1;
+
+	int len = get_shop_str(NULL, 0, id);
+	int off = x - SHOP_ID_TO_X(id);
+	if (off < 0 || off >= len) return -1;
+	return id;
+}
+
+
+void draw_shop(int cash) {
+	int y = SHOP_STARTY;
+	int x = SHOP_STARTX;
+	mvaddstr(y, x,   "Shop:");
+	mvaddstr(++y, x, "-----");
+
+	char s[25];
+	for (int i = 0; i < ARRLEN(turrets); i++) {
+		x = SHOP_ID_TO_X(i);
+		y = SHOP_ID_TO_Y(i);
+		move(y, x);
+		int len = get_shop_str(s, ARRLEN(s), i);
+		if (cash >= turrets[i].cost) attron(A_REVERSE);
+		addstr(s);
+		if (cash >= turrets[i].cost) attroff(A_REVERSE);
+	}
+}
+
+
+void erase_shop(void) {
+	int y = SHOP_STARTY;
+	int x = SHOP_STARTX;
+	move(y, x);
+	clrtoeol();
+	move(++y, x);
+	clrtoeol();
+
+	for (int i = 0; i < ARRLEN(turrets); i++) {
+		x = SHOP_ID_TO_X(i);
+		y = SHOP_ID_TO_Y(i);
+		move(y, x);
+		clrtoeol();
+	}
+}
+
+
+void draw_radius(char grid[X][Y], int x, int y, int r) {
+	attron(A_REVERSE);
+	for (int rx = -r + 1; rx < r; rx++) {
+		for (int ry = -r + 1; ry < r; ry++) {
+			if (rx*rx + ry*ry > r*r) continue;
+			int dx = rx + x;
+			int dy = ry + y;
+			if (dx < 0) dx = 0;
+			else if (dx >= X) dx = X - 1;
+			if (dy < 0) dy = 0;
+			else if (dy >= Y) dy = Y - 1;
+			move(dy + 1, dx + 1);
+			addch(grid_getc(grid, dx, dy));
+		}
+	}
+	attroff(A_REVERSE);
+}
+
+
+int try_purchase(char grid[X][Y], int id, int cash, struct turrets * spawned_turrets) {
+	int cost = turrets[id].cost;
+	int radius = turrets[id].radius;
+	if (cost > cash) return -1;
+	timeout(-1);
+
+	bool done = false;
+	while (!done) {
+		move(Y + 2, X + 2 - 10);
+		addstr("q to abort");
+		move(Y + 3, X + 2 - 14);
+		addstr("Click to place");
+		refresh();
+
+		switch (getch()) {
+			case 'q':
+				cost = 0;
+				done = true;
+				break;
+			case KEY_MOUSE:;
+				MEVENT e;
+				if (getmouse(&e) != OK) break;
+				int x = e.x - 1;
+				int y = e.y - 1;
+				if (x < 0 || x >= X || y < 0 || y >= Y) break;
+				// turrets with a nonnegative stack must be placed on paths
+				// other turrets can only by placed on empty cells
+				if ((grid[x][y] & CELL_TURRET) ||
+				       (turrets[id].stack < 0 && (grid[x][y] & CELL_PATH))) {
+					break;
+				}
+				if (turrets[id].stack > 0 && !(grid[x][y] & CELL_PATH)) break;
+
+				// draw radius
+				draw_radius(grid, x, y, radius);
+				move(e.y, e.x);
+				addch(turrets[id].symbol);
+				move(Y + 3, X + 2 - 15);
+				addstr("Enter to accept");
+				refresh();
+				if (getch() != '\n') {
+					cost = 0;
+					done = true;
+					break;
+				}
+
+				turrets_push(spawned_turrets, grid, x, y, id);
+				done = true;
+				break;
+		}
+	}
+
+	timeout(DELAY);
+	return cost;
+}
+
+
+int try_upgrade(int id, int cash, struct turrets * spawned_turrets, char grid[X][Y]) {
+	int cost = 0;
+	timeout(-1);
+
+	struct spawned_turret * st = &spawned_turrets->spawned[id];
+
+	erase_shop();
+	int y = SHOP_STARTY;
+	int x = SHOP_STARTX;
+	move(y, x);
+	addstr(turrets[st->id].name);
+	addch(':');
+	move(++y, x);
+	int nlen = strlen(turrets[st->id].name);
+	for (int i = 0; i < nlen + 1; i++) addch('-');
+
+	move(SHOP_ID_TO_Y(0), SHOP_ID_TO_X(0));
+	attron(A_REVERSE);
+	addstr("Turret Info");
+	attroff(A_REVERSE);
+
+	int tid = st->id;
+	int max_level = turrets[tid].n_upgrades;
+	int cur_level = st->level;
+	int up_idx = cur_level;
+	// sell for 75% of purchasing cost
+	int selling = 0;
+	selling += turrets[tid].cost;
+	for (int i = 0; i < cur_level; i++) {
+		selling += turrets[tid].upgrades[i].cost;
+	}
+	if (turrets[tid].stack > 0) {
+		selling *= st->stack;
+		selling /= turrets[tid].stack;
+	}
+	selling *= 3;
+	selling /= 4;
+	move(SHOP_ID_TO_Y(1), SHOP_ID_TO_X(1));
+	attron(A_REVERSE);
+	printw("Sell: -$%d", selling);
+	attroff(A_REVERSE);
+
+	if (cur_level < max_level) {
+		cost = turrets[tid].upgrades[up_idx].cost;
+		bool affordable = true;
+		if (cash < cost) affordable = false;
+		move(SHOP_ID_TO_Y(2), SHOP_ID_TO_X(2));
+		if (affordable) attron(A_REVERSE);
+		printw("Upgrade: $%d", cost);
+		if (affordable) attroff(A_REVERSE);
+
+
+	}
+
+	draw_radius(grid, st->x, st->y, st->radius);
+
+	bool done = false;
+	while (!done) {
+		move(Y + 2, X + 2 - 12);
+		addstr("Any to abort");
+		// clear the pause/resume prompt
+		move(Y + 3, X + 2 - 14);
+		clrtoeol();
+		refresh();
+
+		switch (getch()) {
+			case KEY_MOUSE:;
+				MEVENT e;
+				if (getmouse(&e) != OK) break;
+				int x = e.x - 1;
+				int y = e.y - 1;
+				int sid = yx_to_shop_id(e.y, e.x);
+				// turret info
+				if (sid == 0) {
+					int kills = st->kills;
+					int ticks = st->ticks;
+					int rad = st->radius;
+					int dmg = st->damage;
+					int rsp = st->rsplash;
+					int dsp = st->dsplash;
+					int stk = st->stack;
+					int py, px;
+					py = SHOP_STARTY;
+					px = SHOP_STARTX;
+					erase_shop();
+					move(py, px);
+					addstr(turrets[st->id].name);
+					addch(':');
+					move(++py, px);
+					for (int i = 0; i < nlen + 1; i++) addch('-');
+
+					mvprintw(++py, px, "Kills: %d", kills); 
+					mvprintw(++py, px, "Level: %d", cur_level);
+					mvprintw(++py, px, "Attack Ticks: %d", ticks);
+					mvprintw(++py, px, "Radius: %d", rad);
+					mvprintw(++py, px, "Damage: %d", dmg);
+					if (rsp > 0 && dsp > 0) {
+						mvprintw(++py, px, "Splash Radius: %d", rsp);
+						mvprintw(++py, px, "Splash Damage: %d", dsp);
+					}
+					if (stk > 0) {
+						mvprintw(++py, px, "Stacked: %d", stk);
+					}
+
+					move(Y + 2, X + 2 - 13);
+					addstr("Any to finish");
+					refresh();
+					getch();
+					done = true;
+					cost = 0;
+					break;
+				// sell turret
+				} else if (sid == 1) {
+					cost = -selling;
+					done = true;
+				// upgrade turret
+				} else if (sid == 2) {
+					if (cash < cost) break;
+					st->level++;
+					st->radius = turrets[tid].upgrades[up_idx].radius;
+					st->rsplash = turrets[tid].upgrades[up_idx].rsplash;
+					st->damage = turrets[tid].upgrades[up_idx].damage;
+					st->dsplash = turrets[tid].upgrades[up_idx].dsplash;
+					st->ticks = turrets[tid].upgrades[up_idx].ticks;
+					done = true;
+					break;
+				}
+				break;
+			default:
+				cost = 0;
+				done = true;
+				break;
+		}
+	}
+
+	timeout(DELAY);
+	return cost;
+}
+
+
+void draw_enemies(struct enemies * enemies) {
+	for (int i = 0; i < enemies->idx; i++) {
+		if (enemies->enemies[i].count == 0) continue;
+		int cp = 0;
+		switch (enemies->enemies[i].count) {
+			case 1: cp = COLOR_PAIR(RED); break;
+			case 2: cp = COLOR_PAIR(CYAN); break;
+			case 3: cp = COLOR_PAIR(GREEN); break;
+			case 4: cp = COLOR_PAIR(YELLOW); break;
+			default: cp = COLOR_PAIR(MAGENTA); break;
+		}
+		int x = enemies->enemies[i].x;
+		int y = enemies->enemies[i].y;
+		move(1 + y, 1 + x);
+		attron(cp);
+		addch('@');
+		attroff(cp);
+	}
+}
+
+
+int get_spawn_rate(int round) {
+	if (round <= 10) return 5;
+	if (round <= 35) return rand_range(2,4);
+	return rand_range(1, 4);
+}
+
+
+int get_speed(int round) {
+	if (round <= 10) return 5;
+	if (round <= 35) return rand_range(3, 5);
+	return rand_range(1, 3);
+}
+
+
+int get_stack(int round) {
+	int lower_rounds[] = {
+		1, 1, 1, 2, 2,
+	};
+	int mid_rounds[] = {
+		1, 1, 1, 1, 1, 1, 1, 1, 1,
+		2, 2, 2, 2, 2, 2, 2, 2, 2,
+		2, 2, 2, 2, 2, 3, 3, 3, 3,
+		3, 3, 3, 3, 3, 3, 4, 4, 4,
+	};
+	int mid_rounds2[] = {
+		2, 2, 2, 3, 3, 3, 3, 3, 3,
+		4, 4, 4, 4, 4, 4, 4, 5, 5,
+		5, 5, 6, 6, 6, 7, 7, 8, 9
+	};
+	if (round <= 10) return lower_rounds[rand_range(0, ARRLEN(lower_rounds))];
+	if (round <= 35) return mid_rounds[rand_range(0, ARRLEN(mid_rounds))];
+	if (round <= 60) return mid_rounds2[rand_range(0, ARRLEN(mid_rounds2))];
+	return rand_range(5, 20);
+}
+
+
+int get_to_spawn(int round) {
+	int ret = 0;
+	if (round <= 3) ret = (round + 1) * 4 + rand_range(0, 2);
+	else if (round <= 20) ret = round * 3 + rand_range(0, 5);
+	else if (round <= 40) ret = 2 * MAX_ENEMIES / 3 + rand_range(-5, 5);
+	else ret =  7 * MAX_ENEMIES / 8 + rand_range(-5, 5);
+	return ret > MAX_ENEMIES - 20 ? MAX_ENEMIES - 20 : ret;
+}
+
+
+int spawn_enemies(struct enemies * enemies, char grid[X][Y], int round) {
+	if (enemies->last_round != round) {
+		enemies->spawned = 0;
+		enemies->killed = 0;
+		enemies->last_round = round;
+		enemies->to_spawn = get_to_spawn(round);
+	}
+
+	int deaths = 0;
+	
+	// advance all enemies
+	// iterate backward so that popping doesn't mess up the iteration
+	for (int i = enemies->idx - 1; i >= 0; i--) {
+		if (enemies->enemies[i].count == 0) continue;
+		if (ticks % enemies->enemies[i].ticks != 0) continue;
+		int x = enemies->enemies[i].x;
+		int y = enemies->enemies[i].y;
+		int c = grid[x][y];
+		if (c & CELL_PATH) switch (CELL_PATH_TO_INT(c)) {
+			case CELL_PATH_UP:    y--; break;
+			case CELL_PATH_DOWN:  y++; break;
+			case CELL_PATH_LEFT:  x--; break;
+			case CELL_PATH_RIGHT: x++; break;
+		}
+		enemies->enemies[i].x = x;
+		enemies->enemies[i].y = y;
+		if (x >= X || y >= Y) {
+			enemies->killed += enemies->enemies[i].count;
+			deaths += enemies->enemies[i].count;
+			enemies_pop(enemies, i);
+		}
+	}
+
+	if (enemies->spawned >= enemies->to_spawn) return deaths;
+
+	int spawn_rate = get_spawn_rate(round);
+	int speed = get_speed(round);
+	int stack = get_stack(round);
+	if (ticks % spawn_rate == 0) {
+		enemies_push(enemies, enemies->spawnx, enemies->spawny, stack, speed);
+	}
+
+	return deaths;
+}
+
+
+int find_nearest_enemy(struct enemies * enemies, int x, int y, int rad) {
+	if (enemies->idx == 0) return -1;
+
+	int nearestx = X + 1;
+	int nearesty = Y + 1;
+	int nearestid = -1;
+
+	for (int i = 0; i < enemies->idx; i++) {
+		int ex = enemies->enemies[i].x - x;
+		int ey = enemies->enemies[i].y - y;
+		if (ex*ex + ey*ey > rad*rad) continue;
+		if (ex*ex + ey*ey < nearestx*nearestx + nearesty*nearesty) {
+			nearestx = ex;
+			nearesty = ey;
+			nearestid = i;
+		}
+	}
+
+	return nearestid;
+}
+
+
+int attack_enemy(struct enemies * enemies, int id, int dmg) {
+	int kills = enemies->enemies[id].count;
+	enemies->enemies[id].count -= dmg;
+	if (dmg >= kills) {
+		enemies_pop(enemies, id);
+	} else kills = dmg;
+	enemies->killed += kills;
+	return kills;
+}
+
+
+int splash_enemies(struct enemies * enemies, int x, int y, int rad, int dmg) {
+	int kills = 0;
+	for (int i = 0; i < enemies->idx; i++) {
+		int ex = enemies->enemies[i].x - x;
+		int ey = enemies->enemies[i].y - y;
+		if (ex*ex + ey*ey > rad*rad) continue;
+
+		kills += attack_enemy(enemies, i, dmg);
+	}
+
+	return kills;
+}
+
+
+int run_turrets(struct turrets * spawned, struct enemies * enemies, char grid[X][Y]) {
+	int kills = 0;
+
+	for (int i = 0; i < spawned->idx; i++) {
+		int tid = spawned->spawned[i].id;
+		int tx = spawned->spawned[i].x;
+		int ty = spawned->spawned[i].y;
+		int radius = spawned->spawned[i].radius;
+		int damage = spawned->spawned[i].damage;
+		int rsplash = spawned->spawned[i].rsplash;
+		int dsplash = spawned->spawned[i].dsplash;
+
+		if (ticks % spawned->spawned[i].ticks != 0) continue;
+
+		int nearest = find_nearest_enemy(enemies, tx, ty, radius);
+		if (nearest < 0) continue;
+
+		int nx = enemies->enemies[nearest].x;
+		int ny = enemies->enemies[nearest].y;
+
+		// damage animation
+		move(ny + 1, nx + 1);
+		attron(A_REVERSE);
+		addch(grid_getc(grid, nx, ny));
+		refresh();
+		napms(ATTACK_ANIMATION_DELAY);
+		attroff(A_REVERSE);
+		refresh();
+
+		int just_killed = attack_enemy(enemies, nearest, damage);
+		if (rsplash > 0 && dsplash > 0)
+			just_killed += splash_enemies(enemies, nx, ny, rsplash, dsplash);
+
+		kills += just_killed;
+		if (spawned->spawned[i].stack > 0) {
+			spawned->spawned[i].stack -= just_killed;
+			if (spawned->spawned[i].stack <= 0) {
+				turrets_pop(spawned, grid, tx, ty, i);
+			}
+		}
+
+		spawned->spawned[i].kills += just_killed;
+	}
+
+	return kills;
+}
+
+
+bool no_enemies(struct enemies * enemies) {
+	return enemies->killed >= enemies->to_spawn;
+}
+
+
+int main(void) {
+	srand(SEED);
+
+	initscr();
+	noecho();
+	curs_set(0);
+	keypad(stdscr, TRUE);
+	timeout(DELAY);
+
+	mousemask(BUTTON1_CLICKED, NULL);
+
+	use_default_colors();
+	start_color();
+	init_pair(RED, COLOR_RED, -1);
+	init_pair(GREEN, COLOR_GREEN, -1);
+	init_pair(YELLOW, COLOR_YELLOW, -1);
+	init_pair(BLUE, COLOR_BLUE, -1);
+	init_pair(MAGENTA, COLOR_MAGENTA, -1);
+	init_pair(CYAN, COLOR_CYAN, -1);
+
+	while (true) {
+		char grid[X][Y] = {};
+		struct enemies enemies = {};
+		struct turrets spawned_turrets = {};
+
+		int cash = STARTING_CASH;
+		int lives = STARTING_LIVES;
+		int round = STARTING_ROUND;
+		int score = 0;
+
+		generate_path(grid, &enemies);
+
+		bool paused = true;
+		int done = RUNNING;
+		while (!done) {
+			if (!paused) {
+				int deaths = spawn_enemies(&enemies, grid, round);
+				lives -= deaths;
+
+				if (no_enemies(&enemies)) {
+					round++;
+				}
+
+				if (lives < 0) {
+					done = GAME_OVER;
+				}
+
+				int killed = run_turrets(&spawned_turrets, &enemies, grid);
+				if (killed >= 0) {
+					cash += killed;
+					score += killed;
+				}
+			}
+
+			erase();
+			draw_grid(grid);
+			draw_enemies(&enemies);
+			draw_shop(cash);
+			move(Y + 2, 0);
+			printw("Round: %d\n", round);
+			printw("Lives: %d\n", lives);
+			printw("Cash: %d\n", cash);
+			printw("Score: %d\n", score);
+			move(Y + 2, X + 2 - 9);
+			addstr("q to quit");
+			move(Y + 3, X + 2 - 14);
+			if (paused) addstr(" Any to resume");
+			else addstr("Space to pause");
+			refresh();
+
+			switch (getch()) {
+				case 'q': done = QUIT; break;
+				case ' ':
+					paused = !paused;
+					break;
+				case KEY_MOUSE:;
+					MEVENT e;
+					if (getmouse(&e) != OK) break;
+
+					int id = yx_to_shop_id(e.y, e.x);
+					if (id >= 0) {
+						int cost = try_purchase(grid, id, cash, &spawned_turrets);
+						if (cost < 0) {
+							move(Y/2 + 1, X/2 + 1 - 9);
+							attron(A_REVERSE);
+							addstr("Insufficient Funds");
+							attroff(A_REVERSE);
+							refresh();
+							napms(500);
+						} else {
+							cash -= cost;
+						}
+					} else {
+						int tid = -1;
+						int x, y;
+						for (int i = 0; i < spawned_turrets.idx; i++) {
+							x = spawned_turrets.spawned[i].x;
+							y = spawned_turrets.spawned[i].y;
+							if (x != e.x - 1 && y != e.y - 1) continue;
+							
+							tid = i;
+							break;
+						}
+
+						if (tid >= 0) {
+							int cost = try_upgrade(tid, cash, &spawned_turrets, grid);
+							cash -= cost;
+							// turret was sold, remove it
+							if (cost < 0) {
+								turrets_pop(&spawned_turrets, grid, x, y, tid);
+							}
+						}
+					}
+					break;
+				case ERR: break;
+				default:
+					if (paused) paused = false;
+					break;
+			}
+
+			ticks++;
+		}
+
+		switch (done) {
+			case QUIT: goto terminate;
+			case GAME_OVER:
+				move(Y/2 + 1, X/2 + 1 - 12);
+				addch(' ');
+				attron(A_REVERSE);
+				addstr("You ran out of lives :(");
+				attroff(A_REVERSE);
+				addch(' ');
+				move(Y/2 + 2, X/2 + 1 - 12);
+				addch(' ');
+				attron(A_REVERSE);
+				printw("Final Score: %9d ", score);
+				attroff(A_REVERSE);
+				addch(' ');
+				break;
+		}
+
+		move(Y/2 + 3, X/2 + 1 - 14);
+		addch(' ');
+		attron(A_REVERSE);
+		addstr("Any to play again, q to quit");
+		attroff(A_REVERSE);
+		addch(' ');
+		timeout(-1);
+		if (getch() == 'q') goto terminate;
+		timeout(DELAY);
+	}
+
+	terminate:
+	keypad(stdscr, FALSE);
+	curs_set(1);
+	echo();
+	endwin();
+}

commit 92103382d644ba153562fc3023adb4775fc55186 
Author: rani <clagv.randomgames@gmail.com>
Date: Sat Oct 14 15:06:10 2023 +0000

    Add tetris

diff --git a/tetris/README.md b/tetris/README.md
new file mode 100644
index 0000000..c868b0c 
--- /dev/null
+++ b/tetris/README.md
@@ -00 +117 @@ 
+# Tetris
+
+Classic Tetris.
+
+* Left/right arrow keys to move left or right.
+* Up arrow key to rotate tetromino. 
+* Down arrow key to force one block down.
+* Space to immediately drop tetromino.
+* q to quit.
+
+## Config
+
+* `X`: Integer, number of columns
+* `Y`: Integer, number of rows
+* `HIGHLIGHT`: Either true/false, whether or not to highlight blocks
+* `SEED`: Integer, specify PRNG seed
+* `GRAVITY`: Integer, specify initial gravity in milliseconds
diff --git a/tetris/tetris.c b/tetris/tetris.c
new file mode 100644
index 0000000..dd43ed1 
--- /dev/null
+++ b/tetris/tetris.c
@@ -00 +1407 @@ 
+#include <time.h>
+#include <stdlib.h>
+#include <ncurses.h>
+#include <stdbool.h>
+#include <sys/time.h>
+
+
+/* BEGIN CONFIG */
+#ifndef X
+#define X 10
+#endif /* X */
+
+#ifndef Y
+#define Y 20
+#endif /* Y */
+
+#ifndef HIGHLIGHT
+#define HIGHLIGHT false
+#endif /* HIGHLIGHT */
+
+#ifndef SEED
+#define SEED time(NULL)
+#endif /* SEED */
+
+#ifndef GRAVITY
+#define GRAVITY 750
+#endif /* GRAVITY */
+/* END CONFIG */
+
+#define TSTOMS(TS) ((TS.tv_sec * 1000000 + TS.tv_nsec / 1000) / 1000)
+
+
+struct coord {
+	int x, y;
+};
+
+
+enum tetromino {
+	EMPTY,
+	TET_Q, /* SQUARE */
+	TET_I,
+	TET_L,
+	TET_J,
+	TET_S,
+	TET_Z,
+	TET_T,
+	LAST,
+};
+
+
+enum color {
+	RED = 1,
+	GREEN,
+	YELLOW,
+	BLUE,
+	MAGENTA,
+	CYAN,
+	WHITE
+};
+
+
+enum state {
+	RUNNING,
+	GAME_OVER,
+	QUIT,
+};
+
+
+/* (0,0) is the center of the top row */
+struct coord tetrominos[][4] = {
+	[TET_Q] = {{0, 0}, {1, 0}, {0, 1}, {1, 1}},
+	[TET_I] = {{0, 1}, {0, 0}, {0, 2}, {0, 3}},
+	[TET_L] = {{0, 1}, {0, 0}, {0, 2}, {1, 2}},
+	[TET_J] = {{0, 1}, {0, 0}, {0, 2}, {-1,2}},
+	[TET_S] = {{0, 0}, {1, 0}, {0, 1}, {-1,1}},
+	[TET_Z] = {{0, 0}, {-1,0}, {0, 1}, {1, 1}},
+	[TET_T] = {{0, 0}, {-1,0}, {1, 0}, {0, 1}},
+};
+
+
+bool valid(int x, int y) {
+	return x >= 0 && y >= 0 && x < X && y < Y;
+}
+
+
+void cptogrid(struct coord tet[4], enum tetromino t, enum tetromino grid[X][Y]) {
+	for (int i = 0; i < 4; i++) {
+		int x = tet[i].x;
+		int y = tet[i].y;
+		grid[x][y] = t;
+	}
+}
+
+
+bool down1(struct coord tet[4], enum tetromino t,  enum tetromino grid[X][Y]) {
+	bool active = true;
+
+	for (int i = 0; i < 4; i++) {
+		int nx = tet[i].x;
+		int ny = tet[i].y + 1;
+		if (!valid(nx, ny) || grid[nx][ny]) {
+			cptogrid(tet, t, grid);
+			active = false;
+			break;
+		}
+	}
+	if (active) for (int i = 0; i < 4; i++) tet[i].y++;
+
+	return active;
+}
+
+
+int nlen(int n) {
+	int l = 1;
+	while ((n /= 10) != 0) l++;
+	return l;
+}
+
+
+void draw_grid(enum tetromino grid[X][Y], int level, int score) {
+	erase();
+	for (int x = 0; x < X; x++) addstr("++++");
+	addstr("+\n");
+	for (int y = 0; y < Y; y++) {
+		addch('+');
+		for (int x = 0; x < X; x++) {
+			addch(' ');
+			int cp = COLOR_PAIR((enum color)grid[x][y]);
+			if (grid[x][y] && HIGHLIGHT) cp |= A_REVERSE;
+			attron(cp);
+			if (!HIGHLIGHT) addch(grid[x][y] ? '#' : ' ');
+			else addch(' ');
+			attroff(cp);
+			addch(' ');
+			if (x < X - 1) addch('.');
+		}
+		addstr("+\n");
+	}
+	for (int x = 0; x < X; x++) addstr("++++");
+	addch('+');
+
+	mvprintw(0, 0, "Level: %d", level);
+	mvprintw(0, X * 4 + 1 - 7 - nlen(score), "Score: %d", score);
+}
+
+
+int main(void) {
+	srand(SEED);
+
+	initscr();
+	noecho();
+	curs_set(0);
+	keypad(stdscr, TRUE);
+	timeout(0);
+
+	use_default_colors();
+	start_color();
+	init_pair(RED, COLOR_RED, -1);
+	init_pair(GREEN, COLOR_GREEN, -1);
+	init_pair(YELLOW, COLOR_YELLOW, -1);
+	init_pair(BLUE, COLOR_BLUE, -1);
+	init_pair(MAGENTA, COLOR_MAGENTA, -1);
+	init_pair(CYAN, COLOR_CYAN, -1);
+	init_pair(WHITE, COLOR_WHITE, -1);
+
+	while (true) {
+		enum tetromino grid[X][Y] = {0};
+
+		int level = 0;
+		int score = 0;
+		int total_cleared = 0;
+
+		bool active = false;
+		struct coord cur_tet[4];
+		enum tetromino tet_type;
+
+		int reftime = 0;
+		{
+			struct timespec ts;
+			clock_gettime(CLOCK_MONOTONIC, &ts);
+			reftime = TSTOMS(ts);
+		}
+
+		enum state done = RUNNING;
+		while (!done) {
+			if (!active) {
+				int t = rand() % ((LAST-1) - (EMPTY+1) + 1) + (EMPTY+1);
+				tet_type = t;
+				for (int i = 0; i < 4; i++) {
+					int y = tetrominos[t][i].y;
+					int x = tetrominos[t][i].x + X / 2;
+					if (grid[x][y]) {
+						done = GAME_OVER;
+						goto finished;
+					}
+					cur_tet[i].x = x;
+					cur_tet[i].y = y;
+				}
+				active = true;
+			}
+
+			draw_grid(grid, level, score);
+
+			// draw current tetromino
+			int cp = COLOR_PAIR((enum color)tet_type);
+			if (HIGHLIGHT) cp |= A_REVERSE;
+			attron(cp);
+			for (int i = 0; i < 4; i++) {
+				int x = cur_tet[i].x * 4 + 2;
+				int y = cur_tet[i].y + 1;
+				if (!HIGHLIGHT) mvaddch(y, x, '@');
+				else mvaddch(y, x, ' ');
+			}
+			attroff(cp);
+
+			// draw tetromino shadow
+			int x_lo = X;
+			int x_hi = -1;
+			for (int i = 0; i < 4; i++) {
+				int x = cur_tet[i].x;
+				if (x > x_hi) x_hi = x;
+				if (x < x_lo) x_lo = x;
+			}
+
+			x_lo = x_lo * 4 + 2;
+			x_hi = x_hi * 4 + 2;
+
+			for (int i = x_lo; i <= x_hi; i++) {
+				int y = Y + 1;
+				mvaddch(y, i, '_');
+			}
+
+			refresh();
+
+			switch (getch()) {
+				case KEY_DOWN:
+					active = down1(cur_tet, tet_type, grid);
+					if (active) score++;
+					break;
+				case KEY_LEFT:
+					{
+					bool can_move = true;
+					for (int i = 0; i < 4; i++) {
+						int x = cur_tet[i].x - 1;
+						int y = cur_tet[i].y;
+						if (!valid(x, y) || grid[x][y]) {
+							can_move = false;
+							break;
+						}
+					}
+					if (!can_move) break;
+
+					for (int i = 0; i < 4; i++) cur_tet[i].x--;
+					}
+					break;
+				case KEY_RIGHT:
+					{
+					bool can_move = true;
+					for (int i = 0; i < 4; i++) {
+						int x = cur_tet[i].x + 1;
+						int y = cur_tet[i].y;
+						if (!valid(x, y) || grid[x][y]) {
+							can_move = false;
+							break;
+						}
+					}
+					if (!can_move) break;
+
+					for (int i = 0; i < 4; i++) cur_tet[i].x++;
+					}
+					break;
+				case KEY_UP:
+					// squares don't really rotate
+					if (tet_type == TET_Q) break;
+					/* x' = y_c - y + x_c
+					 * y' = x - x_c + y_c
+					 */
+					bool can_rotate = true;
+					struct coord ncoords[4];
+					int x_c = cur_tet[0].x;
+					int y_c = cur_tet[0].y;
+
+					for (int i = 0; i < 4; i++) {
+						int x = y_c - cur_tet[i].y + x_c;
+						int y = cur_tet[i].x - x_c + y_c;
+						ncoords[i] = (struct coord){x, y};
+
+						if (!valid(ncoords[i].x, ncoords[i].y) || grid[x][y]) {
+							can_rotate = false;
+							break;
+						}
+					}
+					if (!can_rotate) break;
+
+					for (int i = 0; i < 4; i++) {
+						cur_tet[i] = ncoords[i];
+					}
+					break;
+				case ' ':
+					while ((active = down1(cur_tet, tet_type, grid)))
+						score++;
+					break;
+				case 'q':
+					done = QUIT;
+					goto finished;
+				case ERR:
+				deafult: break;
+			}
+
+			struct timespec ts;
+			clock_gettime(CLOCK_MONOTONIC, &ts);
+			int dt = TSTOMS(ts) - reftime;
+			if (dt >= GRAVITY - ((GRAVITY/10) * level)) {
+				reftime = TSTOMS(ts);
+				active = down1(cur_tet, tet_type, grid);
+			}
+
+			if (!active) {
+				int first_row = -1;
+
+				int rows_cleared = 0;
+				for (int y = Y - 1; y >= 0; y--) {
+					bool full_row = true;
+					for (int x = 0; x < X; x++) {
+						if (!grid[x][y]) {
+							full_row = false;
+							break;
+						}
+					}
+
+					if (full_row) {
+						draw_grid(grid, level, score);
+
+						if (first_row < 0) first_row = y;
+
+						attron(COLOR_PAIR(GREEN) | A_REVERSE);
+						for (int x = 1; x < 4 * X; x++) {
+							mvaddch(y + 1, x, '#');	
+						}
+						attroff(COLOR_PAIR(GREEN) | A_REVERSE);
+
+						for (int x = 0; x < X; x++) {
+							grid[x][y] = 0;
+						}
+
+						refresh();
+						napms(1000);
+						rows_cleared++;
+						total_cleared++;
+
+						if (total_cleared >= 10) {
+							level++;
+							total_cleared -= 10;
+						}
+					}
+				}
+
+				if (rows_cleared > 0) {
+					for (int y = first_row - rows_cleared; y >= 0; y--) {
+						for (int x = 0; x < X; x++) {
+							grid[x][y + rows_cleared] = grid[x][y];
+						}
+					}
+				}
+
+				switch (rows_cleared) {
+					case 1:
+						score += 40 * (level + 1);
+						break;
+					case 2:
+						score += 100 * (level + 1);
+						break;
+					case 3:
+						score += 300 * (level + 1);
+						break;
+					case 4:
+						score += 1200 * (level + 1);
+						break;
+				}
+			}
+		}
+
+		finished:
+		switch (done) {
+			case GAME_OVER:
+				move((Y + 1) / 2, (X * 4 + 2) / 2 - 5);
+				if (!HIGHLIGHT) attron(A_REVERSE);
+				addstr("Game over");
+				move((Y + 1) / 2 + 1, (X * 4 + 2) / 2 - 13);
+				addstr("Press any key to continue");
+				if (!HIGHLIGHT) attroff(A_REVERSE);
+				refresh();
+				timeout(-1);
+				getch();
+				timeout(0);
+				break;
+			case QUIT:
+				goto terminate;
+		}
+	}
+
+	terminate:
+	keypad(stdscr, FALSE);
+	curs_set(1);
+	echo();
+	endwin();
+}

commit 4dddf2f885015bb03e70fa1d577e322c9dac1d91 
Author: rani <clagv.randomgames@gmail.com>
Date: Sun Aug 13 12:42:23 2023 +0000

    Re-add global include of time.h

diff --git a/mines/mines.c b/mines/mines.c
index edeac3e..9f6ed07 100644
--- a/mines/mines.c
+++ b/mines/mines.c
@@ -13 +14 @@ 
+#include <time.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <ncurses.h>
@@ -247 +256 @@ 
 #endif /* HIGHLIGHT_SQUARES */
 
 #ifndef SEED
-#include <time.h>
 #define SEED time(NULL)
 #endif /* SEED */
 /* END CONFIG */

commit fcfd46fba8b4060bc7b1cc43f42807395e65e3d0 
Author: rani <clagv.randomgames@gmail.com>
Date: Sun Aug 13 12:32:55 2023 +0000

    Add SEED definition for games utilizing rand()

diff --git a/bejeweled/README.md b/bejeweled/README.md
index e92d5b1..cb68527 100644
--- a/bejeweled/README.md
+++ b/bejeweled/README.md
@@ -113 +114 @@ Tile match game. Click on a tile to select it, click on another tile directly ad
 * `MATCH_DELAY`: The delay after a successful match
 * `BAD_MATCH_DELAY`: The delay after a non successful match
 * `GRID`: Either `true` or `false`, whether or not to show the grid outline
+* `SEED`: Seed value for PRNG
diff --git a/bejeweled/bejeweled.c b/bejeweled/bejeweled.c
index a1aecde..7d624a2 100644
--- a/bejeweled/bejeweled.c
+++ b/bejeweled/bejeweled.c
@@ -19 +19 @@ 
-#include <time.h>
 #include <stdlib.h>
 #include <ncurses.h>
 #include <stdbool.h>
 
 
+/* BEGIN CONFIG */
 #ifndef HIGHLIGHT
 #define HIGHLIGHT false
 #endif /* HIGHLIGHT */
@@ -326 +3212 @@ 
 #define GRID true
 #endif /* GRID */
 
+#ifndef SEED
+#include <time.h>
+#define SEED time(NULL)
+#endif /* SEED */
+/* END CONFIG */
+
 #define SQUARE_C   '#'
 #define CIRCLE_C   'O'
 #define TRIANGLE_C 'A'
@@ -2307 +2367 @@ void sort(struct coord s[], int n) {
 
 
 int main(void) {
-	srand(time(NULL));
+	srand(SEED);
 
 	initscr();
 	noecho();
diff --git a/flappy/README.md b/flappy/README.md
index 9ab5ea0..b2387a6 100644
--- a/flappy/README.md
+++ b/flappy/README.md
@@ -13 +17 @@ 
 # Flappy
 
-Flappy bird. Space to flap, otherwise fall. Avoid the pipes. No configuration possible.
+Flappy bird. Space to flap, otherwise fall. Avoid the pipes.
+
+## Config
+
+* `SEED`: Seed value for PRNG
diff --git a/flappy/flappy.c b/flappy/flappy.c
index f0ba557..8c89f57 100644
--- a/flappy/flappy.c
+++ b/flappy/flappy.c
@@ -19 +116 @@ 
-#include <time.h>
 #include <stdlib.h>
 #include <ncurses.h>
 #include <stdbool.h>
 
 
+/* BEGIN CONFIG */
+#ifndef SEED
+#include <time.h>
+#define SEED time(NULL)
+#endif /* SEED */
+/* END CONFIG */
+
+
 #define X COLS
 #define Y LINES
 
@@ -457 +527 @@ int rrand(int hi, int lo) {
 
 
 int main() {
-	srand(time(NULL));
+	srand(SEED);
 
 	initscr();
 	noecho();
diff --git a/mines/README.md b/mines/README.md
index b845462..14b4203 100644
--- a/mines/README.md
+++ b/mines/README.md
@@ -83 +84 @@ Minesweeper. Left click reveals a square, right click flags it. `f` toggles "fla
 * `X`: Minefield width
 * `MINES`: Number of mines
 * `HIGHLIGHT_SQUARES`: Either `true` or `false`. Enables or disables highlighting of number squares
+* `SEED`: Seed value for PRNG
diff --git a/mines/mines.c b/mines/mines.c
index c8e52a0..edeac3e 100644
--- a/mines/mines.c
+++ b/mines/mines.c
@@ -16 +15 @@ 
 #include <stdlib.h>
 #include <stdbool.h>
-#include <time.h>
 #include <ncurses.h>
 #include <string.h>
 
@@ -236 +2211 @@ 
 // reverse the highlighting of squares
 #define HIGHLIGHT_SQUARES true
 #endif /* HIGHLIGHT_SQUARES */
+
+#ifndef SEED
+#include <time.h>
+#define SEED time(NULL)
+#endif /* SEED */
 /* END CONFIG */
 
 
@@ -2097 +2137 @@ int nlen(int n) {
 
 
 int main(void) {
-	srand(time(NULL));
+	srand(SEED);
 
 	initscr();
 	noecho();
diff --git a/snake/README.md b/snake/README.md
index b2b84db..676112d 100644
--- a/snake/README.md
+++ b/snake/README.md
@@ -93 +94 @@ Classic snake game. Move with arrow keys, eat the apples to grow longer. Space t
 * `X`: Width of play area
 * `DELAY`: The delay, in milliseconds, between each movement
 * `WALLS`: Either `true` or `false`. If `true`, enable solid walls (game over on crash). Otherwise, allow snake to teleport through walls.
+* `SEED`: Seed value for PRNG
diff --git a/snake/snake.c b/snake/snake.c
index 3c050d9..58672d4 100644
--- a/snake/snake.c
+++ b/snake/snake.c
@@ -14 +13 @@ 
-#include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <ncurses.h>
@@ -246 +2311 @@ 
 // enable or disable solid walls
 #define WALLS false
 #endif /* WALLS */
+
+#ifndef SEED
+#include <time.h>
+#define SEED time(NULL)
+#endif /* SEED */
 /* END CONFIG */
 
 
@@ -957 +997 @@ int nlen(int n) {
 
 
 int main() {
-	srand(time(NULL));
+	srand(SEED);
 
 	initscr();
 	noecho();

commit 7c4eb0c0e304da847a7001008ce45b7ce7766ddd 
Author: rani <clagv.randomgames@gmail.com>
Date: Sun Aug 06 19:35:08 2023 +0000

    Add delay after game over

diff --git a/flappy/flappy.c b/flappy/flappy.c
index f499531..f0ba557 100644
--- a/flappy/flappy.c
+++ b/flappy/flappy.c
@@ -1636 +1637 @@ int main() {
 				attroff(A_REVERSE);
 				refresh();
 
+				napms(500);
 				if (getch() == 'q') goto terminate;
 				break;
 			default: break;

commit 4cd0b77600fadc3932f56561879e095a6e8142dd 
Author: Raniconduh <clagv.randomgames@gmail.com>
Date: Sat Aug 05 14:25:53 2023 +0000

    fix cascading match recognition

diff --git a/bejeweled/bejeweled.c b/bejeweled/bejeweled.c
index b62bb8b..a1aecde 100644
--- a/bejeweled/bejeweled.c
+++ b/bejeweled/bejeweled.c
@@ -3786 +3787 @@ int main(void) {
 								}
 
 								if (r >= 3) {
+									nc += r;
 									first = invc;
 									makepop(rc, r);
 									display();

commit f76f7745fd9b85a1cfb581e83ed21ce78392250f 
Author: rani <clagv.randomgames@gmail.com>
Date: Sat Aug 05 13:58:21 2023 +0000

    Allow clearing in 2 dimensions if the gem used for clearing is a corner piece

diff --git a/bejeweled/README.md b/bejeweled/README.md
index 2e412d0..e92d5b1 100644
--- a/bejeweled/README.md
+++ b/bejeweled/README.md
@@ -103 +104 @@ Tile match game. Click on a tile to select it, click on another tile directly ad
 * `SHIFT_DELAY`: The delay between shifts of tiles above each other when a match is made
 * `MATCH_DELAY`: The delay after a successful match
 * `BAD_MATCH_DELAY`: The delay after a non successful match
+* `GRID`: Either `true` or `false`, whether or not to show the grid outline
diff --git a/bejeweled/bejeweled.c b/bejeweled/bejeweled.c
index 7e00055..b62bb8b 100644
--- a/bejeweled/bejeweled.c
+++ b/bejeweled/bejeweled.c
@@ -286 +2810 @@ 
 #define BAD_MATCH_DELAY 750
 #endif /* BAD_MATCH_DELAY */
 
+#ifndef GRID
+#define GRID true
+#endif /* GRID */
+
 #define SQUARE_C   '#'
 #define CIRCLE_C   'O'
 #define TRIANGLE_C 'A'
@@ -11711 +12114 @@ void newgem(struct coord c) {
 
 void display(void) {
 	erase();
-	for (int x = 0; x < X; x++) addstr("+ - ");
-	addstr("+\n");
+	if (GRID) {
+		for (int x = 0; x < X; x++) addstr("+ - ");
+		addstr("+\n");
+	} else addch('\n');
 	for (int y = 0; y < Y; y++) {
 		for (int x = 0; x < X; x++) {
-			addstr("| ");
+			if (GRID) addstr("| ");
+			else addstr("  ");
 			int cp = GETCOLOR(GETGEM(grid[x][y]));
 			bool reverse = false;
 			if (HIGHLIGHT) reverse = true;;
@@ -1339 +14011 @@ void display(void) {
 			attroff(cp);
 			addch(' ');
 		}
-		addstr("|\n");
-		for (int x = 0; x < X; x++) addstr("+ - ");
-		addstr("+\n");
+		if (GRID) {
+			addstr("|\n");
+			for (int x = 0; x < X; x++) addstr("+ - ");
+			addstr("+\n");
+		} else addstr("\n\n");
 	}
 
 	attron(A_REVERSE);
@@ -29427 +30335 @@ int main(void) {
 					struct coord hc[X];
 					int h = checkhoriz(x, y, hc);
 
+					struct coord rc[Y + X];
+					int r = 0;
 					if (v >= 3) {
-						first = invc;
 						sort(vc, v);
-						makepop(vc, v);
-						display();
-						napms(MATCH_DELAY);
-						shift(vc, v);
+						while (v--) {
+							rc[r] = vc[r];
+							r++;
+						}
+					}
 
-						score += 1000;
-						v -= 3;
-						score += 2000*v;
-					} else if (h >= 3) {
+					if (h >= 3) {
+						int i = 0;
+						while (h--) {
+							rc[r] = hc[i];
+							i++;
+							r++;
+						}
+					}
+
+					if (r >= 3) {
 						first = invc;
-						makepop(hc, h);
+						makepop(rc, r);
 						display();
 						napms(MATCH_DELAY);
-						shift(hc, h);
+						shift(rc, r);
 
 						score += 1000;
-						h -= 3;
-						score += 2000*h;
+						r -= 3;
+						score += 2000*r*r;
 					} else {
 						// no matches
 						struct coord c = first;
@@ -34129 +35835 @@ int main(void) {
 								int v = checkvert(nx, ny, vc);
 								struct coord hc[X];
 								int h = checkhoriz(nx, ny, hc);
+								struct coord rc[Y + X];
+								int r = 0;
 								if (v >= 3) {
-									nc += v;
-
 									sort(vc, v);
-									makepop(vc, v);
-									display();
-									napms(750);
-									shift(vc, v);
+									while (v--) {
+										rc[r] = vc[r];
+										r++;
+									}
+								}
 
-									score += 1000;
-									v -= 3;
-									score += 2000*v;
-								} else if (h >= 3) {
-									nc += h;
+								if (h >= 3) {
+									int i = 0;
+									while (h--) {
+										rc[r] = hc[i];
+										i++;
+										r++;
+									}
+								}
 
-									makepop(hc, h);
+								if (r >= 3) {
+									first = invc;
+									makepop(rc, r);
 									display();
-									napms(750);
-									shift(hc, h);
+									napms(MATCH_DELAY);
+									shift(rc, r);
 
 									score += 1000;
-									h -= 3;
-									score += 2000*h;
+									r -= 3;
+									score += 2000*r*r;
 								}
 							}
 						}

commit 29c192d50ba2887fafcd7c6dc66e1dadf6223e47 
Author: Raniconduh <clagv.randomgames@gmail.com>
Date: Fri Aug 04 10:12:48 2023 +0000

    replace inline function with macros

diff --git a/bejeweled/bejeweled.c b/bejeweled/bejeweled.c
index bca6b21..7e00055 100644
--- a/bejeweled/bejeweled.c
+++ b/bejeweled/bejeweled.c
@@ -416 +419 @@ 
 #define ISPOP(g) (g & POP)
 #define GETGEM(g) (g & 0xFF)
 
+#define GETCOLOR(g) (COLOR_PAIR(g + 1))
+#define VALID(x, y) (x < X && y < Y && x >= 0 && y >= 0)
+
 
 enum gem {
 	SQUARE,
@@ -8316 +866 @@ struct coord first = {-1, -1};
 int score = 0;
 
 
-inline int getcolor(enum gem g) {
-	return COLOR_PAIR(g + 1);
-}
-
-
-inline bool valid(int x, int y) {
-	return x < X && y < Y && x >= 0 && y >= 0;
-}
-
-
 int abs(int n) {
 	return n < 0 ? -n : n;
 }
@@ -1168 +1098 @@ void newgem(struct coord c) {
 	do {
 		done = true;
 		grid[x][y] = rand() % LAST_GEM;
-		if (valid(x - 1, y) && grid[x][y] == grid[x - 1][y]) done = false;
-		if (valid(x, y - 1) && grid[x][y] == grid[x][y - 1]) done = false;
+		if (VALID(x - 1, y) && grid[x][y] == grid[x - 1][y]) done = false;
+		if (VALID(x, y - 1) && grid[x][y] == grid[x][y - 1]) done = false;
 	} while (!done);
 }
 
@@ -1297 +1227 @@ void display(void) {
 	for (int y = 0; y < Y; y++) {
 		for (int x = 0; x < X; x++) {
 			addstr("| ");
-			int cp = getcolor(GETGEM(grid[x][y]));
+			int cp = GETCOLOR(GETGEM(grid[x][y]));
 			bool reverse = false;
 			if (HIGHLIGHT) reverse = true;;
 			if (first.x == x && first.y == y) reverse = !reverse;
@@ -16012 +15312 @@ int checkvert(int x, int y, struct coord vc[]) {
 	int s = 0;
 
 	int n = y;
-	while (valid(x, n) && grid[x][n] == grid[x][y]) {
+	while (VALID(x, n) && grid[x][n] == grid[x][y]) {
 		vc[s++] = (struct coord){x, n};
 		n++;
 	}
 	n = y - 1;
-	while (valid(x, n) && grid[x][n] == grid[x][y]) {
+	while (VALID(x, n) && grid[x][n] == grid[x][y]) {
 		vc[s++] = (struct coord){x, n};
 		n--;
 	}
@@ -17812 +17112 @@ int checkhoriz(int x, int y, struct coord hc[]) {
 	int s = 0;
 
 	int n = x;
-	while (valid(n, y) && grid[n][y] == grid[x][y]) {
+	while (VALID(n, y) && grid[n][y] == grid[x][y]) {
 		hc[s++] = (struct coord){n, y};
 		n++;
 	}
 	n = x - 1;
-	while (valid(n, y) && grid[n][y] == grid[x][y]) {
+	while (VALID(n, y) && grid[n][y] == grid[x][y]) {
 		hc[s++] = (struct coord){n, y};
 		n--;
 	}
@@ -26812 +26112 @@ int main(void) {
 					MEVENT e;
 					if (getmouse(&e) != OK) break;
 
-					// get and validate x and y coords
+					// get and VALIDate x and y coords
 					if (e.x % 4 == 0 || e.y % 2 == 0) break;
 					int x = (e.x - 2) / 4;
 					int y = (e.y - 1) / 2;
 					if ((e.x - 1) % 4 == 0) x++;
-					if (!valid(x, y)) break;
+					if (!VALID(x, y)) break;
 
 					if (first.x == -1 && first.y == -1) {
 						first.x = x;

commit 59c8971cfb441034c4e8e3ccfa5611a65ea008e6 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Aug 03 23:11:18 2023 +0000

    Add bejeweled

diff --git a/bejeweled/README.md b/bejeweled/README.md
new file mode 100644
index 0000000..2e412d0 
--- /dev/null
+++ b/bejeweled/README.md
@@ -00 +112 @@ 
+# Bejeweled
+
+Tile match game. Click on a tile to select it, click on another tile directly adjacent to swap the two. Click on a selected tile to deselect it. Press 'r' to restart the game with a new board.
+
+## Config
+
+* `X`: Width of the board
+* `Y`: Height of the board
+* `HIGHLIGHT`: Either `true` or `false`, whether or not to highlight tiles
+* `SHIFT_DELAY`: The delay between shifts of tiles above each other when a match is made
+* `MATCH_DELAY`: The delay after a successful match
+* `BAD_MATCH_DELAY`: The delay after a non successful match
diff --git a/bejeweled/bejeweled.c b/bejeweled/bejeweled.c
new file mode 100644
index 0000000..bca6b21 
--- /dev/null
+++ b/bejeweled/bejeweled.c
@@ -00 +1389 @@ 
+#include <time.h>
+#include <stdlib.h>
+#include <ncurses.h>
+#include <stdbool.h>
+
+
+#ifndef HIGHLIGHT
+#define HIGHLIGHT false
+#endif /* HIGHLIGHT */
+
+#ifndef X
+#define X 16
+#endif /* X */
+
+#ifndef Y
+#define Y 16
+#endif /* Y */
+
+#ifndef SHIFT_DELAY
+#define SHIFT_DELAY 25
+#endif /* SHIFT_DELAY */
+
+#ifndef MATCH_DELAY
+#define MATCH_DELAY 750
+#endif /* MATCH_DELAY */
+
+#ifndef BAD_MATCH_DELAY
+#define BAD_MATCH_DELAY 750
+#endif /* BAD_MATCH_DELAY */
+
+#define SQUARE_C   '#'
+#define CIRCLE_C   'O'
+#define TRIANGLE_C 'A'
+#define RHOMBUS_C  '='
+#define DIAMOND_C  'm'
+#define HEXAGON_C  '&'
+
+
+#define POP (1<<9)
+
+#define ISPOP(g) (g & POP)
+#define GETGEM(g) (g & 0xFF)
+
+
+enum gem {
+	SQUARE,
+	CIRCLE,
+	TRIANGLE,
+	RHOMBUS,
+	DIAMOND,
+	HEXAGON,
+	LAST_GEM
+};
+
+
+enum {
+	RED = 1,
+	GREEN,
+	YELLOW,
+	BLUE,
+	MAGENTA,
+	CYAN,
+};
+
+
+struct coord {
+	int x, y;
+};
+
+
+char gemc[] = {
+	[SQUARE]   = SQUARE_C,
+	[CIRCLE]   = CIRCLE_C,
+	[TRIANGLE] = TRIANGLE_C,
+	[RHOMBUS]  = RHOMBUS_C,
+	[DIAMOND]  = DIAMOND_C,
+	[HEXAGON]  = HEXAGON_C,
+};
+
+const struct coord invc = {-1, -1};
+enum gem grid[X][Y];
+struct coord first = {-1, -1};
+int score = 0;
+
+
+inline int getcolor(enum gem g) {
+	return COLOR_PAIR(g + 1);
+}
+
+
+inline bool valid(int x, int y) {
+	return x < X && y < Y && x >= 0 && y >= 0;
+}
+
+
+int abs(int n) {
+	return n < 0 ? -n : n;
+}
+
+
+int nlen(int n) {
+	int len = 0;
+	while (n > 0) {
+		len++;
+		n /= 10;
+	}
+	return len;
+}
+
+
+void newgem(struct coord c) {
+	int x = c.x;
+	int y = c.y;
+
+	bool done;
+	do {
+		done = true;
+		grid[x][y] = rand() % LAST_GEM;
+		if (valid(x - 1, y) && grid[x][y] == grid[x - 1][y]) done = false;
+		if (valid(x, y - 1) && grid[x][y] == grid[x][y - 1]) done = false;
+	} while (!done);
+}
+
+
+void display(void) {
+	erase();
+	for (int x = 0; x < X; x++) addstr("+ - ");
+	addstr("+\n");
+	for (int y = 0; y < Y; y++) {
+		for (int x = 0; x < X; x++) {
+			addstr("| ");
+			int cp = getcolor(GETGEM(grid[x][y]));
+			bool reverse = false;
+			if (HIGHLIGHT) reverse = true;;
+			if (first.x == x && first.y == y) reverse = !reverse;
+			if (ISPOP(grid[x][y])) reverse = !reverse;
+			if (reverse) cp |= A_REVERSE;
+			attron(cp);
+			addch(gemc[GETGEM(grid[x][y])]);
+			attroff(cp);
+			addch(' ');
+		}
+		addstr("|\n");
+		for (int x = 0; x < X; x++) addstr("+ - ");
+		addstr("+\n");
+	}
+
+	attron(A_REVERSE);
+	move(Y*2+1, (X*4+2)/2 - (nlen(score) + 8)/2);
+	printw("Score: %d", score);
+	attroff(A_REVERSE);
+	move(Y*2+1, 0);
+	addstr("r to restart");
+
+	refresh();
+}
+
+
+int checkvert(int x, int y, struct coord vc[]) {
+	int s = 0;
+
+	int n = y;
+	while (valid(x, n) && grid[x][n] == grid[x][y]) {
+		vc[s++] = (struct coord){x, n};
+		n++;
+	}
+	n = y - 1;
+	while (valid(x, n) && grid[x][n] == grid[x][y]) {
+		vc[s++] = (struct coord){x, n};
+		n--;
+	}
+
+	return s;
+}
+
+
+int checkhoriz(int x, int y, struct coord hc[]) {
+	int s = 0;
+
+	int n = x;
+	while (valid(n, y) && grid[n][y] == grid[x][y]) {
+		hc[s++] = (struct coord){n, y};
+		n++;
+	}
+	n = x - 1;
+	while (valid(n, y) && grid[n][y] == grid[x][y]) {
+		hc[s++] = (struct coord){n, y};
+		n--;
+	}
+
+	return s;
+}
+
+
+void shift(struct coord s[], int n) {
+	for (int i = 0; i < n; i++) {
+		struct coord sc = s[i];
+		for (int n = sc.y; n > 0; n--) {
+			grid[sc.x][n] = grid[sc.x][n - 1];
+			display();
+			napms(SHIFT_DELAY);
+		}
+
+		newgem((struct coord){sc.x, 0});
+	}
+}
+
+
+void makepop(struct coord s[], int n) {
+	for (int i = 0; i < n; i++) {
+		struct coord c = s[i];
+		grid[c.x][c.y] |= POP;
+	}
+}
+
+
+void sort(struct coord s[], int n) {
+	for (int i = 0; i < n; i++) {
+		for (int j = 0; j < n - 1; j++) {
+			if (s[j].y > s[j + 1].y) {
+				struct coord t = s[j];
+				s[j] = s[j + 1];
+				s[j + 1] = t;
+			}
+		}
+	}
+}
+
+
+int main(void) {
+	srand(time(NULL));
+
+	initscr();
+	noecho();
+	curs_set(0);
+	keypad(stdscr, TRUE);
+
+	mousemask(BUTTON1_CLICKED, NULL);
+
+	use_default_colors();
+	start_color();
+	init_pair(RED, COLOR_RED, -1);
+	init_pair(GREEN, COLOR_GREEN, -1);
+	init_pair(YELLOW, COLOR_YELLOW, -1);
+	init_pair(BLUE, COLOR_BLUE, -1);
+	init_pair(MAGENTA, COLOR_MAGENTA, -1);
+	init_pair(CYAN, COLOR_CYAN, -1);
+
+	restart:
+	while (true) {
+		// generate a grid where each element is unique from its direct neighbors
+		for (int x = 0; x < X; x++) {
+			for (int y = 0; y < Y; y++) {
+				newgem((struct coord){x, y});
+			}
+		}
+
+		first = invc;
+
+		while (true) {
+			display();
+
+
+			switch (getch()) {
+				case 'r':
+					goto restart;
+				case KEY_MOUSE:;
+					MEVENT e;
+					if (getmouse(&e) != OK) break;
+
+					// get and validate x and y coords
+					if (e.x % 4 == 0 || e.y % 2 == 0) break;
+					int x = (e.x - 2) / 4;
+					int y = (e.y - 1) / 2;
+					if ((e.x - 1) % 4 == 0) x++;
+					if (!valid(x, y)) break;
+
+					if (first.x == -1 && first.y == -1) {
+						first.x = x;
+						first.y = y;
+						break;
+					}
+
+					if (first.x == x && first.y == y) {
+						first = invc;
+						break;
+					}
+
+					if (abs(first.x - x) + abs(first.y - y) > 1) {
+						first = invc;
+						break;
+					}
+
+					// swap the gems and see what happens
+					enum gem t = grid[first.x][first.y];
+					grid[first.x][first.y] = grid[x][y];
+					grid[x][y] = t;
+
+					struct coord vc[Y];
+					int v = checkvert(x, y, vc);
+					struct coord hc[X];
+					int h = checkhoriz(x, y, hc);
+
+					if (v >= 3) {
+						first = invc;
+						sort(vc, v);
+						makepop(vc, v);
+						display();
+						napms(MATCH_DELAY);
+						shift(vc, v);
+
+						score += 1000;
+						v -= 3;
+						score += 2000*v;
+					} else if (h >= 3) {
+						first = invc;
+						makepop(hc, h);
+						display();
+						napms(MATCH_DELAY);
+						shift(hc, h);
+
+						score += 1000;
+						h -= 3;
+						score += 2000*h;
+					} else {
+						// no matches
+						struct coord c = first;
+						first.x = x;
+						first.y = y;
+						display();
+						napms(BAD_MATCH_DELAY);	
+						first = c;
+						enum gem t = grid[first.x][first.y];
+						grid[first.x][first.y] = grid[x][y];
+						grid[x][y] = t;
+
+						first = invc;
+					}
+
+					// hacky, ugly way to clear all gems
+					int nc;
+					do {
+						nc = 0;
+
+						for (int nx = 0; nx < X; nx++) {
+							for (int ny = 0; ny < Y; ny++) {
+								struct coord vc[Y];
+								int v = checkvert(nx, ny, vc);
+								struct coord hc[X];
+								int h = checkhoriz(nx, ny, hc);
+								if (v >= 3) {
+									nc += v;
+
+									sort(vc, v);
+									makepop(vc, v);
+									display();
+									napms(750);
+									shift(vc, v);
+
+									score += 1000;
+									v -= 3;
+									score += 2000*v;
+								} else if (h >= 3) {
+									nc += h;
+
+									makepop(hc, h);
+									display();
+									napms(750);
+									shift(hc, h);
+
+									score += 1000;
+									h -= 3;
+									score += 2000*h;
+								}
+							}
+						}
+					} while (nc != 0);
+					break;
+				case 'q':
+					goto terminate;
+			}
+		}
+	}
+
+	terminate:
+	echo();
+	curs_set(1);
+	endwin();
+}

commit aa86bc0e78768e98602181333f2cbee4aa2be20e 
Author: rani <clagv.randomgames@gmail.com>
Date: Tue Aug 01 17:22:42 2023 +0000

    Fix random number generation

diff --git a/flappy/flappy.c b/flappy/flappy.c
index d1ca048..f499531 100644
--- a/flappy/flappy.c
+++ b/flappy/flappy.c
@@ -407 +407 @@ int nlen(int n) {
 
 
 int rrand(int hi, int lo) {
-	return rand() & (hi - lo + 1) + lo;
+	return rand() % (hi - lo + 1) + lo;
 }
 
 

commit 86b274bd2f0240ff2974af483ef4e639148268f1 
Author: rani <clagv.randomgames@gmail.com>
Date: Tue Aug 01 16:29:06 2023 +0000

    Add flappy

diff --git a/flappy/README.md b/flappy/README.md
new file mode 100644
index 0000000..9ab5ea0 
--- /dev/null
+++ b/flappy/README.md
@@ -00 +13 @@ 
+# Flappy
+
+Flappy bird. Space to flap, otherwise fall. Avoid the pipes. No configuration possible.
diff --git a/flappy/flappy.c b/flappy/flappy.c
new file mode 100644
index 0000000..d1ca048 
--- /dev/null
+++ b/flappy/flappy.c
@@ -00 +1177 @@ 
+#include <time.h>
+#include <stdlib.h>
+#include <ncurses.h>
+#include <stdbool.h>
+
+
+#define X COLS
+#define Y LINES
+
+#define N_PIPES (X / 30)
+#define OPENING (Y / 8)
+#define JUMP (Y / 14)
+
+
+enum {
+	YELLOW = 1,
+	GREEN,
+};
+
+
+enum state {
+	GAME_OVER = 0,
+	RUNNING = 1,
+};
+
+
+struct coord {
+	int x, y;
+};
+
+
+int nlen(int n) {
+	int len = 1;
+	while (n > 0) {
+		len++;
+		n /= 10;
+	}
+	return len;
+}
+
+
+int rrand(int hi, int lo) {
+	return rand() & (hi - lo + 1) + lo;
+}
+
+
+int main() {
+	srand(time(NULL));
+
+	initscr();
+	noecho();
+	curs_set(0);
+
+	timeout(0);
+
+	use_default_colors();
+	start_color();
+	init_pair(YELLOW, COLOR_YELLOW, -1);
+	init_pair(GREEN, COLOR_GREEN, -1);
+
+	while (true) {
+		struct coord bird = {X / (N_PIPES+1), (Y - 1) / 2};
+		int last_movement = 0;
+
+		struct coord pipes[N_PIPES];
+		for (int i = 0; i < N_PIPES; i++) {
+			pipes[i] = (struct coord){X / (N_PIPES+1) + ((X / (N_PIPES+1)) * (i + 1)), rrand(Y-OPENING/2, OPENING/2)};
+		}
+		int curpipe = 0;
+
+		int score = 0;
+
+		enum state state = RUNNING;
+		while (state == RUNNING) {
+			erase();
+
+			move(bird.y, bird.x);
+			attron(COLOR_PAIR(YELLOW));
+			addch('@');
+			attroff(COLOR_PAIR(YELLOW));
+
+			attron(COLOR_PAIR(GREEN));
+			for (int i = 0; i < N_PIPES; i++) {
+				// create the top half of the pipe
+				for (int y = 0; y < pipes[i].y - OPENING / 2; y++) {
+					for (int x = -1; x <= 1; x++) {
+						move(y, pipes[i].x + x);
+						addch('#');
+					}
+				}
+
+				// bottom half
+				for (int y = pipes[i].y + OPENING / 2; y < Y; y++) {
+					for (int x = -1; x <= 1; x++) {
+						move(y, pipes[i].x + x);
+						addch('#');
+					}
+				}
+			}
+			attroff(COLOR_PAIR(GREEN));
+
+			move(0, 0);
+			printw("Score: %d", score);
+
+			refresh();
+
+			// check bird position
+			if (bird.y >= Y) {
+				state = GAME_OVER;
+				break;
+			}
+
+			int px, py;
+			px = pipes[curpipe].x;
+			py = pipes[curpipe].y;
+			if (bird.x >= px - 1 && bird.x <= px + 1 && (bird.y < py - OPENING / 2 || bird.y > py + OPENING / 2)) {
+				state = GAME_OVER;
+				break;
+			} else if (bird.x == pipes[curpipe].x + 1) {
+				score++;
+
+				pipes[curpipe] = (struct coord){X / (N_PIPES+1) + ((X / (N_PIPES+1)) * N_PIPES), rrand(Y-OPENING/2, OPENING/2)};
+
+				curpipe++;
+				if (curpipe >= N_PIPES) curpipe = 0;
+			}
+
+			switch (getch()) {
+				case ' ':
+					last_movement = 0;
+					if (bird.y == 0) break;
+					bird.y -= JUMP;
+
+					if (bird.y < 0) bird.y = 0;
+					break;
+				case 'q':
+				case KEY_RESIZE:
+					goto terminate;
+					break;
+				default:
+					break;
+			}
+
+
+			// move everything now
+			bird.y += ++last_movement / 3;
+
+			for (int i = 0; i < N_PIPES; i++) {
+				pipes[i].x--;
+			}
+
+			napms(100);
+		}
+
+		timeout(-1);
+		switch (state) {
+			case GAME_OVER:
+				attron(A_REVERSE);
+				move(Y / 2, X / 2 - 5);
+				addstr("Game Over!");
+				move(Y / 2 + 1, (X - nlen(score)) / 2 - 6);
+				printw("Final Score: %d", score);
+				attroff(A_REVERSE);
+				refresh();
+
+				if (getch() == 'q') goto terminate;
+				break;
+			default: break;
+		}
+		timeout(0);
+	}
+
+	terminate:
+	echo();
+	curs_set(1);
+	endwin();
+}

commit c982d0d77f75ab0ae4873c2a7533b459c5cb7f6d 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jul 27 23:07:29 2023 +0000

    Mask only l/r click

diff --git a/mines/mines.c b/mines/mines.c
index fd4adc4..c8e52a0 100644
--- a/mines/mines.c
+++ b/mines/mines.c
@@ -2167 +2167 @@ int main(void) {
 	curs_set(0);
 	keypad(stdscr, TRUE);
 
-	mousemask(ALL_MOUSE_EVENTS, NULL);
+	mousemask(BUTTON1_CLICKED | BUTTON3_CLICKED, NULL);
 
 	use_default_colors();
 	start_color();

commit 4747198acc617f2e9315489b18ae693a0bd85895 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jul 20 20:22:35 2023 +0000

    Allow redefinition of config macros on compiler command line

diff --git a/life/life.c b/life/life.c
index 0424d52..072a68e 100644
--- a/life/life.c
+++ b/life/life.c
@@ -413 +425 @@ 
 
 
 /* BEGIN CONFIG */
+#ifndef Y
 #define Y 16
+#endif /* Y */
+
+#ifndef X
 #define X 16
+#endif /* X */
 
+#ifndef DELAY
 #define DELAY 250
+#endif /* DELAY */
 
+#ifndef LIVE_C
 #define LIVE_C '#'
+#endif /* LIVE_C */
+
+#ifndef DEAD_C
 #define DEAD_C ' '
+#endif /* DEAD_C */
 /* END CONFIG */
 
 
diff --git a/mines/mines.c b/mines/mines.c
index bc41790..fd4adc4 100644
--- a/mines/mines.c
+++ b/mines/mines.c
@@ -615 +623 @@ 
 
 
 /* BEGIN CONFIG */
-// grid size
+#ifndef Y
 #define Y 16
+#endif /* Y */
+
+#ifndef X
 #define X 16
+#endif /* X */
 
+#ifndef MINES
 // number of mines
 #define MINES 35
+#endif /* MINES */
 
+#ifndef HIGHLIGHT_SQUARES
 // reverse the highlighting of squares
 #define HIGHLIGHT_SQUARES true
+#endif /* HIGHLIGHT_SQUARES */
 /* END CONFIG */
 
 
diff --git a/snake/snake.c b/snake/snake.c
index 80a6b7d..3c050d9 100644
--- a/snake/snake.c
+++ b/snake/snake.c
@@ -714 +723 @@ 
 
 
 /* BEGIN CONFIG */
+#ifndef Y
 #define Y 16
+#endif /* Y */
+
+#ifndef X
 #define X 32
+#endif /* X */
 
+#ifndef DELAY
 // time between movements (ms)
 #define DELAY 100
+#endif /* DELAY */
 
+#ifndef WALLS
 // enable or disable solid walls
 #define WALLS false
+#endif /* WALLS */
 /* END CONFIG */
 
 

commit bf1c36213bbb2c4b8714cb133a768349008d9eca 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jul 20 20:14:18 2023 +0000

    Update README.md

diff --git a/snake/README.md b/snake/README.md
index e7cb09c..b2b84db 100644
--- a/snake/README.md
+++ b/snake/README.md
@@ -16 +16 @@ 
 # snake
 
-Classic snake game. Move with arrow keys, eat the apples to grow longer.
+Classic snake game. Move with arrow keys, eat the apples to grow longer. Space to pause, any key to resume. q to quit.
 
 
 ## Config

commit 41897528a1c695e9c6b2c10f3c5b623e31e9aa80 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jul 20 19:51:49 2023 +0000

    Add game of life

diff --git a/life/README.md b/life/README.md
new file mode 100644
index 0000000..d86105b 
--- /dev/null
+++ b/life/README.md
@@ -00 +113 @@ 
+# Life
+
+Conway's Game of Life. The game begins in a board editor. Click on a dead cell to give it life and click on a living cell to kill it. Pressing enter begins the simulation. r clears the board. q quits the game.
+
+During simulation, i edits the initial board, e edits the current board, and q quits the game.
+
+# Config
+
+* `Y`: Board height
+* `X`: Board width
+* `DELAY`: Time between generations (ms)
+* `LIVE_C`: Character for living cells
+* `DEAD_C`: Character for dead cells
diff --git a/life/life.c b/life/life.c
new file mode 100644
index 0000000..0424d52 
--- /dev/null
+++ b/life/life.c
@@ -00 +1178 @@ 
+#include <string.h>
+#include <ncurses.h>
+#include <stdbool.h>
+
+
+/* BEGIN CONFIG */
+#define Y 16
+#define X 16
+
+#define DELAY 250
+
+#define LIVE_C '#'
+#define DEAD_C ' '
+/* END CONFIG */
+
+
+#define ARRLEN(a) (sizeof(a)/sizeof(*a))
+
+#define LIVE 1<<0
+#define DEAD 1<<1
+#define TODIE 1<<2
+#define TOLIVE 1<<3
+
+
+enum {
+	GREEN = 1,
+};
+
+
+struct {
+	 int x, y;
+} around[8] = {
+	{.x = -1, .y = -1}, {.x = 0, .y = -1}, {.x = +1, .y = -1},
+	{.x = -1, .y = 0},                     {.x = +1, .y = 0},
+	{.x = -1, .y = +1}, {.x = 0, .y = +1}, {.x = +1, .y = +1}
+};
+
+
+void display(const char grid[X][Y], bool edit) {
+	for (int x = 0; x < X; x++) addstr("+ - ");
+	addstr("+\n");
+	for (int y = 0; y < Y; y++) {
+		for (int x = 0; x < X; x++) {
+			addstr("| ");
+			char c = grid[x][y];
+			int cp = 0;
+			if (edit) cp = COLOR_PAIR(GREEN);
+			attron(cp);
+			addch(c & LIVE ? LIVE_C : DEAD_C);
+			attroff(cp);
+			addch(' ');
+		}
+		addstr("|\n");
+		for (int x = 0; x < X; x++) addstr("+ - ");
+		addstr("+\n");
+	}
+}
+
+
+int main() {
+	initscr();
+	noecho();
+	curs_set(0);
+	keypad(stdscr, TRUE);
+
+	mousemask(BUTTON1_CLICKED, NULL);
+
+	use_default_colors();
+	start_color();
+	init_pair(GREEN, COLOR_GREEN, -1);
+
+	char grid[X][Y];
+	memset(grid, DEAD, sizeof(grid));
+	char initial_grid[X][Y];
+	memset(initial_grid, DEAD, sizeof(grid));
+
+	clear();
+
+	bool edit_initial = true;
+	while (true) {
+		// initialize the board
+		while (true) {
+			erase();
+			display(grid, true);
+
+			move(0, (X*4+2)/2 - 5);
+			attron(A_REVERSE);
+			addstr("BOARD EDIT");
+			move(Y*2, (X*4+2)/2 - 21);
+			addstr("Enter to start | r to restart | q to quit");
+			attroff(A_REVERSE);
+			refresh();
+
+			int c = getch();
+			if (c == KEY_ENTER || c == '\n') break;
+			if (c == 'q') goto terminate;
+			if (c == 'r') {
+				memset(grid, DEAD, sizeof(grid));
+				continue;
+			}
+			if (c != KEY_MOUSE) continue;
+			MEVENT e;
+			if (getmouse(&e) != OK) continue;
+			
+			if (e.x % 4 == 0 || e.y % 2 == 0) continue;
+			int x = (e.x - 2) / 4;
+			int y = (e.y - 1) / 2;
+			if ((e.x - 1) % 4 == 0) x++;
+			if (x > X || y > Y) continue;
+
+			if (grid[x][y] == LIVE) grid[x][y] = DEAD;
+			else grid[x][y] = LIVE;
+		}
+
+		if (edit_initial) memcpy(initial_grid, grid, sizeof(grid));
+
+		timeout(0);
+
+		while (true) {
+			// determine new cell states
+			for (int x = 0; x < X; x++) {
+				for (int y = 0; y < Y; y++) {
+					int neighbors = 0;
+					for (int i = 0; i < ARRLEN(around); i++) {
+						int nx = x + around[i].x;
+						int ny = y + around[i].y;
+						if (nx < 0 || ny < 0 || nx >= X || ny >= Y) continue;
+						if (grid[nx][ny] & LIVE) neighbors++;
+					}
+
+					if (neighbors == 3) grid[x][y] |= TOLIVE;
+					else if (neighbors == 2 && grid[x][y] & LIVE) grid[x][y] |= TOLIVE;
+					else grid[x][y] |= TODIE;
+				}
+			}
+
+			// update all cells
+			for (int x = 0; x < X; x++) {
+				for (int y = 0; y < Y; y++) {
+					if (grid[x][y] & TOLIVE) grid[x][y] = LIVE;
+					else grid[x][y] = DEAD;
+				}
+			}
+
+			erase();
+			display(grid, false);
+
+			move(Y*2, (X*4+2)/2 - 23);
+			attron(A_REVERSE);
+			addstr("q to quit | i to edit initial | e to edit now");
+			attroff(A_REVERSE);
+			refresh();
+
+			int c = getch();
+			if (c != ERR) {
+				if (c == 'q') goto terminate;
+				if (c == 'i') {
+					edit_initial = true;
+					break;
+				}
+				if (c == 'e') {
+					edit_initial = false;
+					break;
+				}
+			}
+
+			napms(DELAY);
+		}
+
+		timeout(-1);
+		if (edit_initial) memcpy(grid, initial_grid, sizeof(grid));
+	}
+
+	terminate:
+	echo();
+	curs_set(1);
+	endwin();
+}

commit ef58bff8f96fe41ef9fe6c11d0259909342ff3dc 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jul 20 16:22:07 2023 +0000

    Fix bad defines

diff --git a/snake/snake.c b/snake/snake.c
index 56badc0..80a6b7d 100644
--- a/snake/snake.c
+++ b/snake/snake.c
@@ -1414 +1414 @@ 
 #define DELAY 100
 
 // enable or disable solid walls
-#define WALLS true
+#define WALLS false
 /* END CONFIG */
 
 
 #if WALLS
 #define WALLC '#'
 #else
-#define WALLC ''
+#define WALLC ' '
 #endif
 
 
@@ -1857 +1857 @@ int main() {
 				}
 
 				// teleport the snake in no-walls mode
-				if (MODE == NOWALLS) {
+				if (!WALLS) {
 					if (n->x < 0) n->x = X - 1;
 					else if (n->x >= X) n->x = 0;
 					
@@ -2027 +2027 @@ int main() {
 			}
 
 			// handle wall crash
-			if (MODE == WALLS && (s.nodes->x < 0 || s.nodes->x >= X || s.nodes->y < 0 || s.nodes->y >= Y)) {
+			if (WALLS && (s.nodes->x < 0 || s.nodes->x >= X || s.nodes->y < 0 || s.nodes->y >= Y)) {
 				state = WALL_CRASH;
 				goto done;
 			}

commit 53bf7297fc90a266c23c6ff6054efb06d2cd1478 
Author: rani <clagv.randomgames@gmail.com>
Date: Thu Jul 20 14:25:10 2023 +0000

    Initial commit

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d4ed8ea 
--- /dev/null
+++ b/README.md
@@ -00 +13 @@ 
+# Games
+
+A collection of small games. Configuration is done in the source file of each game.
diff --git a/mines/README.md b/mines/README.md
new file mode 100644
index 0000000..b845462 
--- /dev/null
+++ b/mines/README.md
@@ -00 +110 @@ 
+# Mines
+
+Minesweeper. Left click reveals a square, right click flags it. `f` toggles "flag mode" which allows placing a flag on left click as well.
+
+## Config
+
+* `Y`: Minefield height
+* `X`: Minefield width
+* `MINES`: Number of mines
+* `HIGHLIGHT_SQUARES`: Either `true` or `false`. Enables or disables highlighting of number squares
diff --git a/mines/mines.c b/mines/mines.c
new file mode 100644
index 0000000..bc41790 
--- /dev/null
+++ b/mines/mines.c
@@ -00 +1405 @@ 
+#include <stdlib.h>
+#include <stdbool.h>
+#include <time.h>
+#include <ncurses.h>
+#include <string.h>
+
+
+/* BEGIN CONFIG */
+// grid size
+#define Y 16
+#define X 16
+
+// number of mines
+#define MINES 35
+
+// reverse the highlighting of squares
+#define HIGHLIGHT_SQUARES true
+/* END CONFIG */
+
+
+#define ARRLEN(a) (sizeof(a)/sizeof(*a))
+
+
+enum color {
+	RED = 1,
+	GREEN,
+	CYAN,
+	BLUE,
+	MAGENTA,
+	BLACK,
+};
+
+
+enum state {
+	RUNNING,
+	QUIT,
+	GAME_OVER,
+	WIN,
+};
+
+
+struct square {
+	bool revealed;
+	bool mine;
+	bool flagged;
+	int neighbors;
+};
+
+
+struct {
+	 int x, y;
+} around[8] = {
+	{.x = -1, .y = -1}, {.x = 0, .y = -1}, {.x = +1, .y = -1},
+	{.x = -1, .y = 0},                     {.x = +1, .y = 0},
+	{.x = -1, .y = +1}, {.x = 0, .y = +1}, {.x = +1, .y = +1}
+};
+
+
+struct square grid[X][Y] = {0};
+int total_revealed = 0;
+int total_flags = 0;
+
+
+void global_reset(void) {
+	memset(grid, 0, sizeof(grid));
+	total_revealed = 0;
+	total_flags = 0;
+}
+
+
+bool won(void) {
+	return total_revealed >= X*Y - MINES;
+}
+
+
+int count_mines(int x, int y) {
+	int n = 0;
+
+	for (int i = 0; i < ARRLEN(around); i++) {
+		int nx = x + around[i].x;
+		int ny = y + around[i].y;
+		if (nx < 0 || ny < 0 || nx >= X || ny >= Y) continue;
+		if (grid[nx][ny].mine) n++;
+	}
+
+	return n;
+}
+
+
+void reveal(int x, int y) {
+	if (grid[x][y].revealed) return;
+	total_revealed++;
+	grid[x][y].revealed = true;
+}
+
+
+void reveal_blank(int x, int y) {
+	struct coord {
+		int x, y;
+	} coords[8];
+	for (int i = 0; i < ARRLEN(coords); i++) coords[i] = (struct coord){-1, -1};
+	int n = 0;
+
+	for (int i = 0; i < ARRLEN(around); i++) {
+		int nx = x + around[i].x;
+		int ny = y + around[i].y;
+		if (nx < 0 || ny < 0 || nx >= X || ny >= Y) continue;
+		struct square s = grid[nx][ny];
+		if (s.mine) continue;
+		if (s.neighbors == 0 && !s.revealed) {
+			reveal(nx, ny);
+
+			coords[n].x = nx;
+			coords[n].y = ny;
+			n++;
+		} else if (s.neighbors != 0) reveal(nx, ny);
+	}
+
+	for (int i = 0; i < n; i++) {
+		reveal_blank(coords[i].x, coords[i].y);
+	}
+}
+
+
+void create_grid(int x, int y) {
+	struct {
+		int x, y;
+	} exclude[9] = {0};
+	int n = 0;
+
+	exclude[n].x = x;
+	exclude[n].y = y;
+	n++;
+
+	// squares around the grid that mines cannot spawn in
+	for (int i = 0; i < ARRLEN(around); i++) {
+		int nx, ny;
+		nx = x + around[i].x;
+		ny = y + around[i].y;
+
+		if (nx < 0 || ny < 0 || nx >= X || ny >= Y) continue;
+		else {
+			exclude[n].x = nx;
+			exclude[n].y = ny;
+			n++;
+		}
+	}
+
+	bool done = false;
+	int tries = 0;
+	do {
+		for (int i = 0; i < MINES; i++) {
+			int mx, my;
+			bool done = false;
+			do {
+				mx = rand() % X;
+				my = rand() % Y;
+
+				bool illegal = false;
+				for (int i = 0; i < n; i++) {
+					if (exclude[i].x == mx && exclude[i].y == my) {
+						illegal = true;
+						break;
+					}
+				}
+
+				if (illegal) continue;
+
+				if (!grid[mx][my].mine) {
+					grid[mx][my].mine = true;
+					done = true;
+				}
+			} while (!done);
+		}
+
+
+		for (int x = 0; x < X; x++) {
+			for (int y = 0; y < Y; y++) {
+				grid[x][y].neighbors = count_mines(x, y);
+			}
+		}
+
+		// prevent insta-wins
+		reveal_blank(x, y);
+		if (!won()) done = true;
+		else global_reset();
+		tries++;
+
+	} while (tries < 10 && !done);
+}
+
+
+int nlen(int n) {
+	int len = 0;
+	while (n > 0) {
+		len++;
+		n /= 10;
+	}
+	return len;
+}
+
+
+int main(void) {
+	srand(time(NULL));
+
+	initscr();
+	noecho();
+	curs_set(0);
+	keypad(stdscr, TRUE);
+
+	mousemask(ALL_MOUSE_EVENTS, NULL);
+
+	use_default_colors();
+	start_color();
+	init_pair(RED, COLOR_RED, -1);
+	init_pair(GREEN, COLOR_GREEN, -1);
+	init_pair(CYAN, COLOR_CYAN, -1);
+	init_pair(BLUE, COLOR_BLUE, -1);
+	init_pair(MAGENTA, COLOR_MAGENTA, -1);
+	init_pair(BLACK, COLOR_WHITE, COLOR_BLACK);
+
+
+	while (true) {
+		bool grid_exists = false;
+		bool flag_mode = false;
+
+		clear();
+
+		time_t start_time;
+
+		enum state done = RUNNING;
+		bool display_once_more = false;
+		while (!done || display_once_more) {
+			erase();
+			// draw the board
+			for (int x = 0; x < X; x++) addstr("+ - ");
+			addstr("+\n");
+
+			for (int y = 0; y < Y; y++) {
+				for (int x = 0; x < X; x++) {
+					addstr("| ");
+					struct square s = grid[x][y];
+					if (done == GAME_OVER && s.mine) {
+						attron(COLOR_PAIR(RED) | A_REVERSE);
+						addch('*');
+						attroff(COLOR_PAIR(RED) | A_REVERSE);
+					} else if (s.flagged) {
+						int cp = COLOR_PAIR(RED);
+						char flagc = '!';
+						if (!HIGHLIGHT_SQUARES) cp |= A_REVERSE;
+						if (done == GAME_OVER) {
+							cp = COLOR_PAIR(CYAN) | A_REVERSE;
+							flagc = '?';
+						}
+						attron(cp);
+						addch(flagc);
+						attroff(cp);
+					} else if (s.revealed) {
+						int cp = 0;
+						switch (s.neighbors) {
+						case 0: cp = 0; break;
+						case 1: cp = COLOR_PAIR(CYAN); break;
+						case 2: cp = COLOR_PAIR(MAGENTA); break;
+						case 3: cp = COLOR_PAIR(BLACK); break;
+						case 4: cp = COLOR_PAIR(BLUE); break;
+						case 5: cp = COLOR_PAIR(CYAN); break;
+						case 6: cp = COLOR_PAIR(MAGENTA); break;
+						case 7: cp = COLOR_PAIR(BLACK); break;
+						case 8: cp = COLOR_PAIR(BLUE); break;
+						}
+						if (HIGHLIGHT_SQUARES && cp) cp |= A_REVERSE;
+						if (done == GAME_OVER) cp = 0;
+						attron(cp);
+						addch(s.neighbors > 0 ? '0' + s.neighbors : ' ');
+						attroff(cp);
+					} else {
+						int cp = COLOR_PAIR(GREEN);
+						if (done == GAME_OVER) cp = 0;
+						attron(cp);
+						addch('#');
+						attroff(cp);
+					}
+					addch(' ');
+				}
+				addstr("|\n");
+
+				for (int x = 0; x < X; x++) addstr("+ - ");
+				addstr("+\n");
+			}
+
+			int y, x;
+			getyx(stdscr, y, x);
+			move(y, (X*4+2)/2 - (24+nlen(MINES)+nlen(total_flags))/2);
+			printw("MINES: %d   FLAGS PLACED: %d\n", MINES, total_flags);
+			move(y+1, (X*4+2)/2 - 16);
+			printw("'f' to toggle flag mode: now %s\n", flag_mode ? "ON" : "OFF");
+
+			refresh();
+
+			if (display_once_more) break;
+			
+			int c = getch();
+			switch (c) {
+			case KEY_MOUSE:;
+				MEVENT event;
+				if (getmouse(&event) != OK) break;
+				// ignore clicks on grid patterning
+				if (event.x % 4 == 0) break;
+				if (event.y % 2 == 0) break;
+				// convert to grid indices
+				int x = (event.x - 2) / 4;
+				int y = (event.y - 1) / 2;
+
+				// fix clicks on left space in each cell
+				if ((event.x - 1) % 4 == 0) x++;
+
+				if (x > X || y > Y) break;
+
+				if (!flag_mode && event.bstate & BUTTON1_CLICKED) {
+					if (!grid_exists) {
+						create_grid(x, y);
+						start_time = time(NULL);
+						grid_exists = true;
+					}
+
+					// clicking on a flag should do nothing
+					if (grid[x][y].flagged) break;
+					if (grid[x][y].mine) {
+						done = GAME_OVER;
+						display_once_more = true;
+						break;
+					}
+
+					// don't waste time if the square is already revealed
+					if (grid[x][y].revealed) break;
+					reveal(x, y);
+
+					if (grid[x][y].neighbors == 0) {
+						reveal_blank(x, y);
+					}
+
+					if (won()) {
+						done = WIN;
+						display_once_more = true;
+					}
+				} else if (flag_mode || (!grid[x][y].revealed && event.bstate & BUTTON3_CLICKED)) {
+					grid[x][y].flagged = !grid[x][y].flagged;
+					if (grid[x][y].flagged) total_flags++;
+					else total_flags--;
+				}
+				break;
+			case 'f':
+				flag_mode = !flag_mode;
+				break;
+			case 'q':
+			case 27:
+			   done = QUIT;
+			   break;
+			default:
+			   break;
+			}
+		}
+
+		switch (done) {
+			case GAME_OVER:
+				move(0, (X*4+2) / 2 - 3);
+				attron(A_REVERSE | COLOR_PAIR(RED));
+				addstr("BOOM!");
+				attroff(A_REVERSE | COLOR_PAIR(RED));
+				break;
+			case WIN:
+				move((Y*2+1)/2, (X*4+2) / 2 - 16);
+				attron(A_REVERSE);
+				addstr("All the mines have been found :)");
+				attroff(A_REVERSE);
+				break;
+			case QUIT:
+				goto terminate;
+			default: break;
+		}
+
+
+		time_t end_time = time(NULL);
+
+		move(Y*2+1, 0);
+		clrtoeol();
+		move(Y*2+1, (X*4+2)/2 - 14);
+		attron(A_REVERSE);
+		addstr("Any to play again, q to quit");
+		attroff(A_REVERSE);
+		move(Y*2+2, 0);
+		clrtoeol();
+		move(Y*2+2, (X*4+2)/2 - (4 + nlen(end_time - start_time)/2));
+		printw("TIME: %ds", end_time - start_time);
+		refresh();
+		if (getch() == 'q') goto terminate;
+
+		global_reset();
+	}
+
+	terminate:
+	echo();
+	curs_set(1);
+	endwin();
+}
diff --git a/snake/README.md b/snake/README.md
new file mode 100644
index 0000000..e7cb09c 
--- /dev/null
+++ b/snake/README.md
@@ -00 +111 @@ 
+# snake
+
+Classic snake game. Move with arrow keys, eat the apples to grow longer.
+
+
+## Config
+
+* `Y`: Height of play area
+* `X`: Width of play area
+* `DELAY`: The delay, in milliseconds, between each movement
+* `WALLS`: Either `true` or `false`. If `true`, enable solid walls (game over on crash). Otherwise, allow snake to teleport through walls.
diff --git a/snake/snake.c b/snake/snake.c
new file mode 100644
index 0000000..56badc0 
--- /dev/null
+++ b/snake/snake.c
@@ -00 +1365 @@ 
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ncurses.h>
+#include <stdbool.h>
+#include <sys/time.h>
+
+
+/* BEGIN CONFIG */
+#define Y 16
+#define X 32
+
+// time between movements (ms)
+#define DELAY 100
+
+// enable or disable solid walls
+#define WALLS true
+/* END CONFIG */
+
+
+#if WALLS
+#define WALLC '#'
+#else
+#define WALLC ''
+#endif
+
+
+enum rstate {
+	RUNNING,
+	WALL_CRASH,
+	SELF_HIT,
+	QUIT,
+};
+
+
+enum color {
+	RED = 1,
+	MAGENTA,
+	GREEN,
+	CYAN,
+};
+
+
+enum direction {
+	DIR_UP,
+	DIR_DOWN,
+	DIR_LEFT,
+	DIR_RIGHT,
+};
+
+
+struct node {
+	enum direction dir;
+
+	bool pivot;
+	int x;
+	int y;
+
+	struct node * next;
+	struct node * prev;
+};
+
+
+struct snake {
+	struct node * nodes;
+	struct node * last;
+
+	int length;
+};
+
+
+struct apple {
+	int x;
+	int y;
+};
+
+
+int nlen(int n) {
+	int len = 0;
+	while (n > 0) {
+		len++;
+		n /= 10;
+	}
+	return len;
+}
+
+
+int main() {
+	srand(time(NULL));
+
+	initscr();
+	noecho();
+	keypad(stdscr, true);
+	curs_set(0);
+	// the snake should move once every DELAY ms,
+	// no matter if input is recieved
+	timeout(DELAY);
+
+	use_default_colors();
+	start_color();
+	init_pair(RED, COLOR_RED, -1);
+	init_pair(MAGENTA, COLOR_MAGENTA, -1);
+	init_pair(GREEN, COLOR_GREEN, -1);
+	init_pair(CYAN, COLOR_CYAN, -1);
+
+	while (true) {
+		struct snake s = {
+			.nodes = &(struct node){
+				.dir = DIR_RIGHT,
+				.pivot = false,
+				.x = X / 2,
+				.y = Y / 2,
+				.next = NULL,
+				.prev = NULL,
+			},
+			.last = NULL,
+			.length = 1,
+		};
+		s.last = s.nodes;
+
+		struct apple a = {
+			.x = rand() % X,
+			.y = rand() % Y,
+		};
+
+		int score = 1;
+
+		enum rstate state = RUNNING;
+		while (true) {
+			// ate an apple!
+			if (s.nodes->x == a.x && s.nodes->y == a.y) {
+				score++;
+
+				struct node * l = s.last;
+				// add a new node
+				s.length++;
+				l->next = malloc(sizeof(struct node));
+				struct node * nw = l->next;
+				nw->dir = l->dir;
+				nw->pivot = false;
+
+				switch (l->dir) {
+					case DIR_UP:
+						nw->x = l->x;
+						nw->y = l->y + 1;
+						break;
+					case DIR_DOWN:
+						nw->x = l->x;
+						nw->y = l->y - 1;
+						break;
+					case DIR_LEFT:
+						nw->x = l->x + 1;
+						nw->y = l->y;
+						break;
+					case DIR_RIGHT:
+						nw->x = l->x - 1;
+						nw->y = l->y;
+						break;
+				}
+
+				nw->prev = l;
+				nw->next = NULL;
+
+				s.last = l->next;
+
+				a.x = rand() % X;
+				a.y = rand() % Y;
+			}
+
+			// move the snake
+			for (struct node * n = s.last; n; n = n->prev) {
+				switch (n->dir) {
+					case DIR_UP:
+						n->y--;
+						break;
+					case DIR_DOWN:
+						n->y++;
+						break;
+					case DIR_LEFT:
+						n->x--;
+						break;
+					case DIR_RIGHT:
+						n->x++;
+						break;
+				}
+
+				// teleport the snake in no-walls mode
+				if (MODE == NOWALLS) {
+					if (n->x < 0) n->x = X - 1;
+					else if (n->x >= X) n->x = 0;
+					
+					if (n->y < 0) n->y = Y - 1;
+					else if (n->y >= Y) n->y = 0;
+				}
+
+				// set the direction of the next node to that of the previous one
+				if (n->prev && n->prev->pivot) {
+					n->dir = n->prev->dir;
+					n->prev->pivot = false;
+					n->pivot = true;
+				}
+			}
+
+			// handle wall crash
+			if (MODE == WALLS && (s.nodes->x < 0 || s.nodes->x >= X || s.nodes->y < 0 || s.nodes->y >= Y)) {
+				state = WALL_CRASH;
+				goto done;
+			}
+
+			// handle bumping into self
+			for (struct node * n = s.nodes->next; n; n = n->next) {
+				if (s.nodes->x == n->x && s.nodes->y == n->y) {
+					state = SELF_HIT;
+					goto done;
+				}
+			}
+
+			erase();
+			// draw the border
+			attron(A_REVERSE | A_DIM | COLOR_PAIR(MAGENTA));
+			for (int i = 0; i <= X + 1; i++) { // top
+				move(0, i);
+				addch(WALLC);
+			}
+			for (int i = 1; i < Y + 1; i++) { // middle
+				move(i, 0);
+				addch(WALLC);
+				move(i, X + 1);
+				addch(WALLC);
+				
+			}
+			for (int i = 0; i <= X + 1; i++) { // bottom
+				attron(A_REVERSE);
+				move(Y + 1, i);
+				addch(WALLC);
+			}
+			attroff(A_REVERSE | A_DIM | COLOR_PAIR(MAGENTA));
+			// write the score
+			move(0, X / 2 - 3 - nlen(score) / 2);
+			attron(A_UNDERLINE);
+			printw("Score: %d", score);
+			attroff(A_UNDERLINE);
+			// draw the snake
+			move(s.nodes->y + 1, s.nodes->x + 1);
+			// first the head
+			attron(COLOR_PAIR(CYAN));
+			switch (s.nodes->dir) {
+				case DIR_UP:
+					addch('^');
+					break;
+				case DIR_DOWN:
+					addch('v');
+					break;
+				case DIR_LEFT:
+					addch('<');
+					break;
+				case DIR_RIGHT:
+					addch('>');
+					break;
+			}
+			attroff(COLOR_PAIR(CYAN));
+			// then the body
+			attron(COLOR_PAIR(GREEN));
+			for (struct node * n = s.nodes->next; n; n = n->next) {
+				move(n->y + 1, n->x + 1);
+				addch('*');
+			}
+			attroff(COLOR_PAIR(GREEN));
+			// draw the apple
+			move(a.y + 1, a.x + 1);
+			attron(COLOR_PAIR(RED));
+			addch('@');
+			attroff(COLOR_PAIR(RED));
+			refresh();
+
+			// handle input
+			struct timeval start;
+			gettimeofday(&start, NULL);
+
+			int c = getch();
+			switch (c) {
+				case KEY_UP:
+					if (s.length > 1 && s.nodes->dir == DIR_DOWN) break;
+					s.nodes->dir = DIR_UP;
+					s.nodes->pivot = true;
+					break;
+				case KEY_DOWN:
+					if (s.length > 1 && s.nodes->dir == DIR_UP) break;
+					s.nodes->dir = DIR_DOWN;
+					s.nodes->pivot = true;
+					break;
+					break;
+				case KEY_LEFT:
+					if (s.length > 1 && s.nodes->dir == DIR_RIGHT) break;
+					s.nodes->dir = DIR_LEFT;
+					s.nodes->pivot = true;
+					break;
+				case KEY_RIGHT:
+					if (s.length > 1 && s.nodes->dir == DIR_LEFT) break;
+					s.nodes->dir = DIR_RIGHT;
+					s.nodes->pivot = true;
+					break;
+				case ' ':
+					timeout(-1);
+					move(Y / 2, X / 2 - 2);
+					attron(A_REVERSE);
+					addstr("Paused");
+					attroff(A_REVERSE);
+					int c;
+					while ((c = getch()) != ' ') {
+						if (c == 'q') {
+							state = QUIT;
+							goto done;
+						}
+					}
+					timeout(DELAY);
+					break;
+				case 'q':
+					state = QUIT;
+					goto done;
+			}
+
+			struct timeval end;
+			gettimeofday(&end, NULL);
+
+			unsigned delta_ms = (end.tv_usec - start.tv_usec) * 1000;
+			if (delta_ms < DELAY) {
+				napms(delta_ms);
+			}
+		}
+
+		done:
+		switch (state) {
+			case QUIT:
+				goto terminate;
+			case WALL_CRASH:
+				move(Y / 2, X / 2 - 12);
+				attron(A_REVERSE);
+				addstr("You crashed into the wall");
+				attroff(A_REVERSE);
+				refresh();
+				napms(1500);
+				break;
+			case SELF_HIT:
+				move(Y / 2, X / 2 - 10);
+				attron(A_REVERSE);
+				addstr("You ran into yourself");
+				attroff(A_REVERSE);
+				refresh();
+				napms(1500);
+				break;
+			default: break;
+		}
+
+		for (struct node * n = s.nodes->next; n; n = n->next) {
+			free(n);
+		}
+	}
+
+	terminate:
+	curs_set(1);
+	keypad(stdscr, false);
+	echo();
+	endwin();
+}