/* snake.c: a snake game as a pardes addon. * cc -shared -fPIC -O2 -Wall -Wextra -Werror -I src/kinds -o snake.so addons/snake/snake.c * h j k l steer; once dead, any key starts again. It steps only while its * pane has the keyboard, and asks for nothing otherwise. */ #include #include "pardes_addon.h" #define W 20 /* the board, in cells, inside its wall */ #define H 5 #define PERIOD 150000000ull /* ns a step */ #define VERSION 1 typedef struct { uint8_t x, y; } pt; typedef struct snake { pt body[W * H]; /* body[0] is the head */ uint16_t len; pt food; int8_t dx, dy; /* the direction last stepped */ int8_t ndx, ndy; /* the direction the next step takes */ uint8_t dead, pad[3]; uint32_t score, steps; uint64_t rng, next; /* next: the deadline of the next step */ } snake; static const pa_api *api; static uint64_t rnd(snake *s) { s->rng ^= s->rng << 13, s->rng ^= s->rng >> 7, s->rng ^= s->rng << 17; return s->rng; } /* Is (x, y) one of the snake's first n segments? */ static int on_snake(const snake *s, int x, int y, unsigned n) { for (unsigned i = 0; i < n; i++) if (s->body[i].x == x && s->body[i].y == y) return 1; return 0; } static void place_food(snake *s) { unsigned free_cells = W * H - s->len; if (!free_cells) { s->dead = 1; return; } /* the board is full: a win, and over */ unsigned k = (unsigned)(rnd(s) % free_cells); for (int y = 0; y < H; y++) for (int x = 0; x < W; x++) if (!on_snake(s, x, y, s->len) && k-- == 0) { s->food = (pt){(uint8_t)x, (uint8_t)y}; return; } } static void restart(snake *s) { s->len = 3; for (unsigned i = 0; i < 3; i++) s->body[i] = (pt){(uint8_t)(W / 2 - i), H / 2}; s->dx = s->ndx = 1, s->dy = s->ndy = 0; s->dead = 0, s->score = 0, s->steps = 0; place_food(s); } static void step(snake *s) { s->dx = s->ndx, s->dy = s->ndy; int x = s->body[0].x + s->dx, y = s->body[0].y + s->dy; int eats = x == s->food.x && y == s->food.y; /* the tail moves away this step unless the snake grows */ if (x < 0 || y < 0 || x >= W || y >= H || on_snake(s, x, y, eats ? s->len : s->len - 1u)) { s->dead = 1; return; } if (eats) s->len++; memmove(&s->body[1], &s->body[0], (s->len - 1) * sizeof(pt)); s->body[0] = (pt){(uint8_t)x, (uint8_t)y}; s->steps++; if (eats) s->score++, place_food(s); } /* ---- the contract ---- */ static int init(const pa_api *a) { api = a; return PA_OK; } static void *open(const char *path, const uint8_t *bytes, uint64_t len) { (void)path, (void)bytes, (void)len; snake *s = api->alloc(sizeof *s); if (!s) return 0; s->rng = api->seed() | 1; restart(s); return s; } /* Unfocused or over, it stands still and asks for nothing: a key, or the * keyboard coming back, ticks it again. */ static uint64_t tick(void *st, uint64_t now, uint32_t flags) { snake *s = st; if (!(flags & PA_FOCUSED) || s->dead) return s->next = 0; if (s->next && now >= s->next) step(s); if (s->dead) return s->next = 0; if (!s->next || now >= s->next) s->next = now + PERIOD; return s->next; } static void paint(void *st, const pa_window *w, pa_paint *out) { const snake *s = st; for (unsigned x = 0; x < W + 2; x++) pa_put(w, 0, x, "#", PA_INDEX(8), PA_DEFAULT, 0), pa_put(w, H + 1, x, "#", PA_INDEX(8), PA_DEFAULT, 0); for (unsigned y = 1; y <= H; y++) pa_put(w, y, 0, "#", PA_INDEX(8), PA_DEFAULT, 0), pa_put(w, y, W + 1, "#", PA_INDEX(8), PA_DEFAULT, 0); pa_put(w, 1 + s->food.y, 1 + s->food.x, "*", PA_INDEX(1), PA_DEFAULT, PA_BOLD); for (unsigned i = s->len; i-- > 0;) pa_put(w, 1 + s->body[i].y, 1 + s->body[i].x, i ? "o" : s->dead ? "x" : "@", PA_INDEX(2), PA_DEFAULT, i ? 0 : PA_BOLD); if (s->dead) pa_put(w, H + 2, 0, "game over: any key", PA_INDEX(1), PA_DEFAULT, 0); else if (!w->focused) pa_put(w, H + 2, 0, "paused", PA_INDEX(8), PA_DEFAULT, 0); int n = snprintf(out->prefix, sizeof out->prefix, "Snake %u%s", s->score, s->dead ? " over" : ""); out->prefix_len = n < 0 ? 0 : (uint32_t)n; } static int key(void *st, const pa_key *k) { snake *s = st; if (s->dead) { restart(s); return 1; } int dx = 0, dy = 0; switch (k->cp) { case 'h': case PA_KEY_LEFT: dx = -1; break; case 'l': case PA_KEY_RIGHT: dx = 1; break; case 'k': case PA_KEY_UP: dy = -1; break; case 'j': case PA_KEY_DOWN: dy = 1; break; case 'r': restart(s); return 1; default: return 0; } if (dx != -s->dx || dy != -s->dy) s->ndx = (int8_t)dx, s->ndy = (int8_t)dy; /* no turning back */ return 1; } static uint32_t text(const snake *s, char *buf, uint32_t n) { int r = snprintf(buf, n, "score %u\nlength %u\nsteps %u\n%s\n", s->score, s->len, s->steps, s->dead ? "over" : "alive"); return r < 0 ? 0 : (uint32_t)r < n ? (uint32_t)r : n; } static uint64_t body_len(void *st) { char b[96]; return text(st, b, sizeof b); } static uint32_t body(void *st, uint64_t off, char *buf, uint32_t n) { char b[96]; return pa_copy(b, text(st, b, sizeof b), off, buf, n); } static uint32_t ctl_read(void *st, char *buf, uint32_t n) { const snake *s = st; int r = snprintf(buf, n, "score %u\nlength %u\n", s->score, s->len); return r < 0 ? 0 : (uint32_t)r < n ? (uint32_t)r : n; } PA_POD(snake, VERSION) static const pa_word words[] = { PA_WORD("Snake", 0, PA_ARG_NONE, 1, "a game of snake: h j k l steer") }; const pa_ops pardes_addon = { .head = PA_ADDON("snake", VERSION, "", words, 1), .init = init, .open = open, .tick = tick, .paint = paint, .key = key, .body_len = body_len, .body = body, .ctl_read = ctl_read, .dump = snake_dump, .load = snake_load, };