summaryrefslogtreecommitdiff
path: root/addons/snake/snake.c
blob: ce9279dcde1fc3fcf9adde7d5b1962a42cb4b030 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/* 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 <stdio.h>
#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 (k->cp == 0x1b) return 0; /* Esc leaves */
  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,
};