summaryrefslogtreecommitdiff
path: root/addons
diff options
context:
space:
mode:
Diffstat (limited to 'addons')
-rw-r--r--addons/snake_shader/snake.frag52
-rw-r--r--addons/snake_shader/snake.post.frag34
-rw-r--r--addons/snake_shader/snake.vert6
-rw-r--r--addons/snake_shader/snake_shader.out147
-rw-r--r--addons/snake_shader/snake_shader.script26
-rw-r--r--addons/snake_shader/snake_shader.zig547
6 files changed, 812 insertions, 0 deletions
diff --git a/addons/snake_shader/snake.frag b/addons/snake_shader/snake.frag
new file mode 100644
index 00000000..14896f2f
--- /dev/null
+++ b/addons/snake_shader/snake.frag
@@ -0,0 +1,52 @@
+#version 450
+layout(location = 0) in vec2 uv;
+layout(location = 0) out vec4 color;
+layout(std140, set = 3, binding = 0) uniform Board {
+ vec4 status; // dead, focused, target width, target height
+ vec4 points; // head xy, food xy
+ vec4 grid; // board size, hovered cell including walls
+ vec4 motion; // seconds, tile pixels, board offset xy
+ uvec4 rows[128];
+} board;
+float box(vec2 p, float size, float radius) {
+ vec2 d = abs(p) - size + radius;
+ return length(max(d, 0)) + min(max(d.x, d.y), 0) - radius;
+}
+void main() {
+ vec2 p = (uv * board.status.zw - board.motion.zw) / board.motion.y;
+ vec3 bg = vec3(.018, .028, .043);
+ float dim = board.status.y < .5 ? .6 : 1;
+ if (any(lessThan(p, vec2(0))) || any(greaterThanEqual(p, board.grid.xy + 2))) {
+ color = vec4(bg * dim, 1);
+ return;
+ }
+ ivec2 cell = ivec2(floor(p)) - 1;
+ vec2 local = fract(p) - .5;
+ vec3 ink = vec3(.10, .16, .23);
+ float dist = box(local, .43, .10);
+ bool inside = cell.x >= 0 && cell.x < int(board.grid.x) && cell.y >= 0 && cell.y < int(board.grid.y);
+ if (inside) {
+ dist = 1;
+ if ((board.rows[cell.y][cell.x / 32] & (1u << uint(cell.x % 32))) != 0u) {
+ ink = board.status.x > .5 ? vec3(.85, .12, .20) : vec3(.12, .78, .43);
+ dist = box(local, .44, .16);
+ if (all(equal(cell, ivec2(board.points.xy)))) ink *= 1.18;
+ } else if (all(equal(cell, ivec2(board.points.zw)))) {
+ ink = vec3(1, .42, .10) * (1 + .035 * sin(board.motion.x * 1.5707963));
+ dist = length(local) - .26;
+ } else {
+ bg += vec3(.008, .014, .018) * (1 - smoothstep(.44, .49, max(abs(local.x), abs(local.y))));
+ }
+ }
+ float aa = max(fwidth(dist), .002);
+ float coverage = 1 - smoothstep(-aa, aa, dist);
+ vec3 rgb = mix(bg + ink * .10 * exp(-max(dist, 0) * 8), ink, coverage);
+ if (board.grid.z >= 0) {
+ vec2 delta = p - (board.grid.zw + .5);
+ float halo = exp(-dot(delta, delta) * 2.5);
+ float rim = 1 - smoothstep(.015, .07, abs(box(local, .45, .09)));
+ bool hovered = all(equal(ivec2(floor(p)), ivec2(board.grid.zw)));
+ rgb += vec3(.12, .30, .36) * halo + (hovered ? vec3(.14, .32, .40) * rim : vec3(0));
+ }
+ color = vec4(rgb * dim, 1);
+}
diff --git a/addons/snake_shader/snake.post.frag b/addons/snake_shader/snake.post.frag
new file mode 100644
index 00000000..226e98de
--- /dev/null
+++ b/addons/snake_shader/snake.post.frag
@@ -0,0 +1,34 @@
+#version 450
+layout(location = 0) in vec2 uv;
+layout(location = 0) out vec4 color;
+layout(set = 2, binding = 0) uniform sampler2D board;
+layout(std140, set = 3, binding = 0) uniform Clock { vec4 phase; } clock;
+
+vec3 bright(vec2 at) {
+ vec3 rgb = texture(board, at).rgb;
+ return rgb * smoothstep(.16, .65, max(rgb.r, max(rgb.g, rgb.b)));
+}
+vec3 mapColor(vec3 rgb) {
+ // Soft highlights with a cool shadow tint; retain the dark board floor.
+ rgb *= vec3(.98, 1.02, 1.06);
+ return clamp((rgb * (2.51 * rgb + .03)) / (rgb * (2.43 * rgb + .59) + .14), 0, 1);
+}
+void main() {
+ vec2 size = vec2(textureSize(board, 0));
+ vec2 pixel = uv * size;
+ vec2 pitch = vec2(3, 4);
+ vec2 sampleUV = (floor(pixel / pitch) + .5) * pitch / size;
+ vec4 source = texture(board, sampleUV);
+ vec3 bloom = vec3(0);
+ vec2 stepUV = vec2(4) / size;
+ for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {
+ float weight = float((x == 0 ? 2 : 1) * (y == 0 ? 2 : 1));
+ bloom += bright(sampleUV + vec2(x, y) * stepUV) * weight / 16;
+ }
+ vec3 rgb = mapColor(source.rgb + bloom * .24);
+ vec3 mask = vec3(.65);
+ mask[int(mod(floor(pixel.x), 3))] = 1.45;
+ float scanline = mix(.5, 1, smoothstep(.15, .35, fract(pixel.y / 4)));
+ float shimmer = 1 + .006 * sin(clock.phase.x * 18.849556 + pixel.y * .12);
+ color = vec4(rgb * mask * scanline * shimmer, source.a);
+}
diff --git a/addons/snake_shader/snake.vert b/addons/snake_shader/snake.vert
new file mode 100644
index 00000000..5f09493f
--- /dev/null
+++ b/addons/snake_shader/snake.vert
@@ -0,0 +1,6 @@
+#version 450
+layout(location = 0) out vec2 uv;
+void main() {
+ uv = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
+ gl_Position = vec4(uv * vec2(2, -2) + vec2(-1, 1), 0, 1);
+}
diff --git a/addons/snake_shader/snake_shader.out b/addons/snake_shader/snake_shader.out
new file mode 100644
index 00000000..462a138e
--- /dev/null
+++ b/addons/snake_shader/snake_shader.out
@@ -0,0 +1,147 @@
+> seed 3
+> size 26 14
+window 24x4
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# * #
+|# oo@ #
+> tick 150
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# * #
+|# oo@ #
+> key jk
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# * #
+|# oo@ #
+> tick 1
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# * #
+|# oo@ #
+> tick 60
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# * #
+|# oo@ #
+> tick 150
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @ * #
+|# oo #
+> key jh
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @ * #
+|# oo #
+> tick 150
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @o * #
+|# o #
+> tick 150
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @oo * #
+|# #
+> body
+=score 0
+=length 3
+=steps 3
+=alive
+=board 22x3
+=hover -1 -1
+> click 3 3
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @oo * #
+|# #
+> body
+=score 0
+=length 3
+=steps 3
+=alive
+=board 22x3
+=hover 3 3
+> blur
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @oo * #
+|# #
+> tick 500
+tag SnakeShader 0 22x3
+|########################
+|# #
+|# @oo * #
+|# #
+> body
+=score 0
+=length 3
+=steps 3
+=alive
+=board 22x3
+=hover 3 3
+> size 34 18
+window 32x6
+tag SnakeShader 0 30x4
+|################################
+|# #
+|# @oo * #
+|# #
+|# #
+|################################
+> body
+=score 0
+=length 3
+=steps 3
+=alive
+=board 30x4
+=hover -1 -1
+> size 22 10
+window 20x2
+tag SnakeShader 0 18x3
+|####################
+|# #
+> body
+=score 0
+=length 3
+=steps 3
+=alive
+=board 18x3
+=hover -1 -1
+> dump
+dump 34392 bytes
+tag SnakeShader 0 18x3
+|####################
+|# #
+> body
+=score 0
+=length 3
+=steps 3
+=alive
+=board 18x3
+=hover -1 -1
+> focus
+tag SnakeShader 0 18x3
+|####################
+|# #
+> key r
+tag SnakeShader 0 18x3
+|####################
+|# * #
+> tick 150
+tag SnakeShader 0 18x3
+|####################
+|# * #
diff --git a/addons/snake_shader/snake_shader.script b/addons/snake_shader/snake_shader.script
new file mode 100644
index 00000000..02dc2c23
--- /dev/null
+++ b/addons/snake_shader/snake_shader.script
@@ -0,0 +1,26 @@
+# Dynamic board, quick turn correction, resize, hover and record roundtrip.
+seed 3
+size 26 14
+tick 150
+key jk
+tick 1
+tick 60
+tick 150
+key jh
+tick 150
+tick 150
+body
+click 3 3
+body
+blur
+tick 500
+body
+size 34 18
+body
+size 22 10
+body
+dump
+body
+focus
+key r
+tick 150
diff --git a/addons/snake_shader/snake_shader.zig b/addons/snake_shader/snake_shader.zig
new file mode 100644
index 00000000..d6f803d5
--- /dev/null
+++ b/addons/snake_shader/snake_shader.zig
@@ -0,0 +1,547 @@
+//! A resizable snake with buffered turns and an optional CRT GPU picture.
+//! h j k l or arrows steer; r restarts. Losing focus pauses movement.
+const std = @import("std");
+const addon = @import("addon");
+const scene = @import("gpu_scene");
+const shaders = @import("shaders");
+
+const max_side = 126; // 4096 pixels / minimum 32-pixel tile, less the walls.
+const period = 150 * std.time.ns_per_ms;
+const grace = 60 * std.time.ns_per_ms;
+const animation_period = 50 * std.time.ns_per_ms;
+const Pt = extern struct { x: u8, y: u8 };
+const Dir = [2]i8;
+const Size = extern struct { cols: u16 = 0, rows: u16 = 0, cell_w: u16 = 0, cell_h: u16 = 0, glyphs: bool = false };
+const Layout = struct { tile: u32, x: u32, y: u32 };
+const Uniforms = extern struct { status: [4]f32, points: [4]f32, grid: [4]f32, motion: [4]f32, rows: [128][4]u32 };
+
+// Version 1's exact record, so a live addon reload keeps the game.
+const Legacy = extern struct {
+ segs: [100]Pt,
+ len: u16,
+ food: Pt,
+ dir: Dir,
+ turn: Dir,
+ dead: bool,
+ score: u32,
+ steps: u32,
+ rng: u64,
+ next: addon.Deadline,
+};
+
+pub const Snake = extern struct {
+ segs: [max_side * max_side]Pt,
+ len: u16,
+ food: Pt,
+ dir: Dir,
+ turns: [2]Dir,
+ queued: u8,
+ dead: bool,
+ score: u32,
+ steps: u32,
+ rng: u64,
+ next: addon.Deadline,
+ collision_at: u64,
+ input_pending: bool,
+ grace_given: bool,
+ now: u64,
+ width: u8,
+ height: u8,
+ owner: u8,
+ sizes: [256]Size,
+ hover_view: u8,
+ hover_x: i16,
+ hover_y: i16,
+
+ pub const head: addon.Head = .{ .name = "snake_shader", .version = 2, .words = &.{
+ .{ .name = "SnakeShader", .opens = true, .doc = "a resizable game of snake: h j k l steer, r restarts" },
+ } };
+
+ fn rnd(s: *Snake) u64 {
+ s.rng ^= s.rng << 13;
+ s.rng ^= s.rng >> 7;
+ s.rng ^= s.rng << 17;
+ return s.rng;
+ }
+
+ fn on(s: *const Snake, x: i32, y: i32, n: usize) bool {
+ for (s.segs[0..n]) |q| if (q.x == x and q.y == y) return true;
+ return false;
+ }
+
+ fn bits(s: *const Snake) [128][4]u32 {
+ var out: [128][4]u32 = @splat(@splat(0));
+ for (s.segs[0..s.len]) |p| out[p.y][p.x / 32] |= @as(u32, 1) << @intCast(p.x % 32);
+ return out;
+ }
+
+ fn placeFood(s: *Snake) void {
+ const area = @as(u32, s.width) * s.height;
+ if (s.len == area) {
+ s.dead = true;
+ return;
+ }
+ var k = s.rnd() % (area - s.len);
+ const occupied = s.bits();
+ for (0..area) |i| {
+ const p: Pt = .{ .x = @intCast(i % s.width), .y = @intCast(i / s.width) };
+ if (occupied[p.y][p.x / 32] & (@as(u32, 1) << @intCast(p.x % 32)) != 0) continue;
+ if (k == 0) {
+ s.food = p;
+ return;
+ }
+ k -= 1;
+ }
+ }
+
+ fn restart(s: *Snake) void {
+ if (s.width == 0) s.width = 20;
+ if (s.height == 0) s.height = 5;
+ s.len = 3;
+ for (s.segs[0..3], 0..) |*p, i| p.* = .{ .x = @intCast(@max(2, s.width / 2) - i), .y = s.height / 2 };
+ s.dir = .{ 1, 0 };
+ s.queued = 0;
+ s.dead = false;
+ s.score = 0;
+ s.steps = 0;
+ s.next = .{};
+ s.collision_at = 0;
+ s.input_pending = false;
+ s.grace_given = false;
+ s.placeFood();
+ }
+
+ // A rejected move changes no coordinates: a late turn can still save it.
+ fn step(s: *Snake) bool {
+ const d = if (s.queued > 0) s.turns[0] else s.dir;
+ const x = @as(i32, s.segs[0].x) + d[0];
+ const y = @as(i32, s.segs[0].y) + d[1];
+ const eats = x == s.food.x and y == s.food.y;
+ if (x < 0 or y < 0 or x >= s.width or y >= s.height or s.on(x, y, if (eats) s.len else s.len - 1)) {
+ s.queued = 0;
+ return false;
+ }
+ s.dir = d;
+ if (s.queued > 0) {
+ s.turns[0] = s.turns[1];
+ s.queued -= 1;
+ }
+ if (eats) s.len += 1;
+ std.mem.copyBackwards(Pt, s.segs[1..s.len], s.segs[0 .. s.len - 1]);
+ s.segs[0] = .{ .x = @intCast(x), .y = @intCast(y) };
+ s.steps += 1;
+ s.collision_at = 0;
+ s.grace_given = false;
+ if (eats) {
+ s.score += 1;
+ s.placeFood();
+ }
+ return true;
+ }
+
+ pub fn open(s: *Snake, _: ?[]const u8, _: ?[]const u8) void {
+ s.rng = addon.seed() | 1;
+ s.hover_x = -1;
+ s.hover_y = -1;
+ s.restart();
+ }
+
+ pub fn tick(s: *Snake, now: u64, flags: addon.Flags) u64 {
+ s.now = now;
+ // Only visible panes animate; the food and phosphor breathe at 20 Hz.
+ const visible = for (s.sizes) |v| {
+ if (v.cols > 0 and v.rows > 0) break true;
+ } else false;
+ if (!flags.focused or s.dead or !visible) {
+ _ = s.next.stop();
+ s.collision_at = 0;
+ s.grace_given = false;
+ } else {
+ if (s.next.at == 0) s.next.at = now + period;
+ if (s.input_pending and s.collision_at == 0 and !s.grace_given) {
+ s.next.at = @max(s.next.at, now + grace);
+ s.grace_given = true;
+ }
+ if (s.next.due(now) or (s.collision_at != 0 and s.input_pending)) {
+ if (s.collision_at != 0 and now >= s.collision_at) {
+ s.dead = true;
+ _ = s.next.stop();
+ } else if (s.step()) {
+ s.next.at = now + period;
+ } else if (s.collision_at == 0) {
+ s.collision_at = now + grace;
+ s.next.at = s.collision_at;
+ }
+ }
+ }
+ s.input_pending = false;
+ const animation = if (visible) now + animation_period else std.math.maxInt(u64);
+ const next = @min(if (s.next.at == 0) std.math.maxInt(u64) else s.next.at, animation);
+ return if (next == std.math.maxInt(u64)) 0 else next;
+ }
+
+ fn resize(s: *Snake, width: u8, height: u8) void {
+ if (s.width == width and s.height == height) return;
+ s.width = width;
+ s.height = height;
+ var lo = s.segs[0];
+ var hi = lo;
+ var keep: usize = 1;
+ for (s.segs[1..s.len]) |p| {
+ const low: Pt = .{ .x = @min(lo.x, p.x), .y = @min(lo.y, p.y) };
+ const high: Pt = .{ .x = @max(hi.x, p.x), .y = @max(hi.y, p.y) };
+ if (high.x - low.x >= width or high.y - low.y >= height) break;
+ lo = low;
+ hi = high;
+ keep += 1;
+ }
+ // Keep the head and score; only an unfit tail is shortened on shrink.
+ s.len = @intCast(keep);
+ const dx = @max(@as(i16, hi.x) - width + 1, 0);
+ const dy = @max(@as(i16, hi.y) - height + 1, 0);
+ for (s.segs[0..s.len]) |*p| {
+ p.x = @intCast(@as(i16, p.x) - dx);
+ p.y = @intCast(@as(i16, p.y) - dy);
+ }
+ if (s.food.x >= width or s.food.y >= height or s.on(s.food.x, s.food.y, s.len)) s.placeFood();
+ s.collision_at = 0;
+ s.next = .{};
+ s.hover_x = -1;
+ s.hover_y = -1;
+ }
+
+ fn useView(s: *Snake, id: u8) void {
+ const v = s.sizes[id];
+ if (id == 0 or v.cols == 0 or v.rows == 0) return;
+ s.owner = id;
+ const tile = @max(32, v.cell_h);
+ const cols = if (v.glyphs) v.cols else @min(4096, @as(u32, v.cols) * v.cell_w) / tile;
+ const rows = if (v.glyphs) v.rows else @min(4096, @as(u32, v.rows) * v.cell_h) / tile;
+ s.resize(@intCast(std.math.clamp(cols -| 2, 3, max_side)), @intCast(std.math.clamp(rows -| 2, 3, max_side)));
+ }
+
+ pub fn view(s: *Snake, v: addon.View) void {
+ s.sizes[v.id] = .{ .cols = v.cols, .rows = v.rows, .cell_w = v.cell_w, .cell_h = v.cell_h, .glyphs = v.glyphs };
+ if (s.hover_view == v.id and (v.cols == 0 or v.rows == 0)) {
+ s.hover_x = -1;
+ s.hover_y = -1;
+ }
+ if (s.owner == v.id and (v.cols == 0 or v.rows == 0)) s.owner = 0;
+ if (s.owner == 0) for (s.sizes, 0..) |size, i| {
+ if (i > 0 and size.cols > 0 and size.rows > 0) {
+ s.useView(@intCast(i));
+ break;
+ }
+ };
+ if (s.owner == v.id) s.useView(v.id);
+ }
+
+ fn layout(s: *const Snake, width: u32, height: u32) Layout {
+ const tile = @max(1, @min(width / (@as(u32, s.width) + 2), height / (@as(u32, s.height) + 2)));
+ return .{ .tile = tile, .x = (width -| tile * (@as(u32, s.width) + 2)) / 2, .y = (height -| tile * (@as(u32, s.height) + 2)) / 2 };
+ }
+
+ pub fn mouse(s: *Snake, m: addon.Mouse) bool {
+ if (m.action != .motion and m.action != .drag and m.button != .left) return false;
+ if (m.action == .press) s.useView(m.view);
+ const v = s.sizes[m.view];
+ s.hover_view = m.view;
+ s.hover_x = -1;
+ s.hover_y = -1;
+ if (m.col == 0xffff or m.row == 0xffff or v.cols == 0 or v.rows == 0) return true;
+ if (v.glyphs) {
+ if (m.col < @as(u16, s.width) + 2 and m.row < @as(u16, s.height) + 2) {
+ s.hover_x = @intCast(m.col);
+ s.hover_y = @intCast(m.row);
+ }
+ } else {
+ const l = s.layout(@min(4096, @as(u32, v.cols) * v.cell_w), @min(4096, @as(u32, v.rows) * v.cell_h));
+ const x = @as(u32, m.col) * v.cell_w + v.cell_w / 2;
+ const y = @as(u32, m.row) * v.cell_h + v.cell_h / 2;
+ if (x >= l.x and y >= l.y and (x - l.x) / l.tile < @as(u32, s.width) + 2 and (y - l.y) / l.tile < @as(u32, s.height) + 2) {
+ s.hover_x = @intCast((x - l.x) / l.tile);
+ s.hover_y = @intCast((y - l.y) / l.tile);
+ }
+ }
+ return true;
+ }
+
+ fn opposite(a: Dir, b: Dir) bool {
+ return a[0] == -b[0] and a[1] == -b[1];
+ }
+ fn same(a: Dir, b: Dir) bool {
+ return a[0] == b[0] and a[1] == b[1];
+ }
+
+ pub fn key(s: *Snake, k: addon.Key) bool {
+ if (k.code == .esc) return false;
+ s.useView(k.view);
+ if (s.dead or k.code == addon.char('r')) {
+ s.restart();
+ return true;
+ }
+ const d: Dir = switch (k.code) {
+ .left, addon.char('h') => .{ -1, 0 },
+ .right, addon.char('l') => .{ 1, 0 },
+ .up, addon.char('k') => .{ 0, -1 },
+ .down, addon.char('j') => .{ 0, 1 },
+ else => return false,
+ };
+ const last = if (s.queued > 0) s.turns[s.queued - 1] else s.dir;
+ if (same(d, last)) return true;
+ if (opposite(d, last)) {
+ // A quick j/k correction replaces an uncommitted turn, never a move.
+ const before = if (s.queued > 1) s.turns[s.queued - 2] else s.dir;
+ if (s.queued == 0 or opposite(d, before)) return true;
+ s.turns[s.queued - 1] = d;
+ } else {
+ if (s.queued == s.turns.len) return true;
+ s.turns[s.queued] = d;
+ s.queued += 1;
+ }
+ s.input_pending = true;
+ return true;
+ }
+
+ pub fn prefix(s: *const Snake, w: *std.Io.Writer) !void {
+ try w.print("SnakeShader {d} {d}x{d}{s}", .{ s.score, s.width, s.height, if (s.dead) " over" else "" });
+ }
+
+ pub fn paint(s: *const Snake, w: addon.Window, out: addon.Paint) void {
+ const wall: addon.Style = .{ .fg = .index(8) };
+ for (0..@as(usize, s.height) + 2) |y| for (0..@as(usize, s.width) + 2) |x| if (x == 0 or x == s.width + 1 or y == 0 or y == s.height + 1) w.put(x, y, "#", wall);
+ w.put(1 + s.food.x, 1 + s.food.y, "*", .{ .fg = .index(1), .attrs = .{ .bold = true } });
+ for (s.segs[0..s.len], 0..) |p, i| w.put(1 + p.x, 1 + p.y, if (i > 0) "o" else if (s.dead) "x" else "@", .{ .fg = .index(2), .attrs = .{ .bold = i == 0 } });
+ if (s.dead) w.put(0, s.height + 2, "game over: any key", .{ .fg = .index(1) }) else if (!w.focused) w.put(0, s.height + 2, "paused", wall);
+ s.gpuPaint(w, out);
+ }
+
+ fn gpuPaint(s: *const Snake, w: addon.Window, out: addon.Paint) void {
+ if (addon.api.abi < 0x30001 or out.out.gpu == null) return;
+ const width: u32 = @min(4096, @max(1, @as(u32, w.cols) * w.cell_w));
+ const height: u32 = @min(4096, @max(1, @as(u32, w.rows) * w.cell_h));
+ const phase: f32 = @as(f32, @floatFromInt(s.now % (4 * std.time.ns_per_s))) / std.time.ns_per_s;
+ const l = s.layout(width, height);
+ const hover = s.hover_view == w.view;
+ const uniforms: Uniforms = .{
+ .status = .{ @floatFromInt(@intFromBool(s.dead)), @floatFromInt(@intFromBool(w.focused)), @floatFromInt(width), @floatFromInt(height) },
+ .points = .{ @floatFromInt(s.segs[0].x), @floatFromInt(s.segs[0].y), @floatFromInt(s.food.x), @floatFromInt(s.food.y) },
+ .grid = .{ @floatFromInt(s.width), @floatFromInt(s.height), @floatFromInt(if (hover) s.hover_x else @as(i16, -1)), @floatFromInt(if (hover) s.hover_y else @as(i16, -1)) },
+ .motion = .{ phase, @floatFromInt(l.tile), @floatFromInt(l.x), @floatFromInt(l.y) },
+ .rows = s.bits(),
+ };
+ const post: [4]f32 = .{ phase, 0, 0, 0 };
+ const pipelines = [_]scene.abi.gpu.Pipeline{.{ .vertex = .{ .code = shaders.vert }, .fragment = .{ .code = shaders.frag, .uniform_buffers = 1 }, .stride = 0, .attributes = &.{} }};
+ var buffer: [32768]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buffer);
+ scene.encodePostProcess(&writer, .{ .image = .none, .width = width, .height = height, .pipelines = &pipelines, .draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = std.mem.asBytes(&uniforms) }} }, .{ .vertex = .{ .code = shaders.vert }, .fragment = .{ .code = shaders.post, .uniform_buffers = 1 }, .fragment_uniforms = std.mem.asBytes(&post) }) catch return;
+ _ = out.gpu(writer.buffered());
+ }
+
+ pub fn body(s: *const Snake, w: *std.Io.Writer) !void {
+ try w.print("score {d}\nlength {d}\nsteps {d}\n{s}\nboard {d}x{d}\nhover {d} {d}\n", .{ s.score, s.len, s.steps, if (s.dead) "over" else "alive", s.width, s.height, s.hover_x, s.hover_y });
+ }
+ pub fn ctlRead(s: *const Snake, w: *std.Io.Writer) !void {
+ try s.body(w);
+ }
+ pub const dump = addon.dumpBytes;
+
+ pub fn load(s: *Snake, bytes: []const u8, version: u32) bool {
+ if (version == 1 and bytes.len == @sizeOf(Legacy)) {
+ const old = std.mem.bytesToValue(Legacy, bytes);
+ if (old.len == 0 or old.len > old.segs.len) return false;
+ s.* = std.mem.zeroInit(Snake, .{ .width = 20, .height = 5, .len = old.len, .food = old.food, .dir = old.dir, .dead = old.dead, .score = old.score, .steps = old.steps, .rng = old.rng });
+ @memcpy(s.segs[0..old.len], old.segs[0..old.len]);
+ if (!same(old.dir, old.turn) and !opposite(old.dir, old.turn)) {
+ s.turns[0] = old.turn;
+ s.queued = 1;
+ }
+ } else if (!addon.loadBytes(s, bytes, version)) return false;
+ if (s.width < 3 or s.height < 3 or s.width > max_side or s.height > max_side or s.len == 0 or s.len > @as(u32, s.width) * s.height or s.queued > 2) return false;
+ for (s.segs[0..s.len]) |p| if (p.x >= s.width or p.y >= s.height) return false;
+ if (s.food.x >= s.width or s.food.y >= s.height or @abs(s.dir[0]) + @as(u16, @abs(s.dir[1])) != 1) return false;
+ for (s.turns[0..s.queued]) |d| if (@abs(d[0]) + @as(u16, @abs(d[1])) != 1) return false;
+ s.hover_x = -1;
+ s.hover_y = -1;
+ s.next = .{};
+ s.collision_at = 0;
+ s.input_pending = false;
+ s.grace_given = false;
+ return true;
+ }
+};
+
+pub const pardes_addon = addon.ops(Snake);
+comptime {
+ addon.exportLib(&pardes_addon);
+}
+
+fn testGame() Snake {
+ var s = std.mem.zeroInit(Snake, .{ .rng = 3, .hover_x = -1, .hover_y = -1 });
+ s.restart();
+ s.view(testView(44, 7, 1));
+ return s;
+}
+fn testView(cols: u16, rows: u16, id: u8) addon.View {
+ return .{ .cols = cols, .rows = rows, .cell_w = 16, .cell_h = 32, .fg = .default, .bg = .default, .sel = .default, .link = .default, .dpi = 96, .max_px = 4096, .fill = true, .glyphs = false, .id = id };
+}
+const focused: addon.Flags = .{ .focused = true, .framed = true, ._ = 0 };
+
+test "quick opposite corrections and consecutive corners retain intent without reversing" {
+ var s = testGame();
+ const start = s.segs[0];
+ _ = s.key(.{ .code = addon.char('j') });
+ _ = s.key(.{ .code = addon.char('k') });
+ try std.testing.expectEqual(@as(u8, 1), s.queued);
+ try std.testing.expect(s.step());
+ try std.testing.expectEqual(start.y - 1, s.segs[0].y);
+ _ = s.key(.{ .code = addon.char('j') });
+ try std.testing.expectEqual(@as(u8, 0), s.queued);
+ s.restart();
+ _ = s.key(.{ .code = addon.char('j') });
+ _ = s.key(.{ .code = addon.char('h') });
+ try std.testing.expect(s.step());
+ try std.testing.expectEqualDeep(Dir{ 0, 1 }, s.dir);
+ try std.testing.expect(s.step());
+ try std.testing.expectEqualDeep(Dir{ -1, 0 }, s.dir);
+}
+
+test "late turn gets sixty milliseconds and repeated keys cannot stall movement" {
+ var s = testGame();
+ _ = s.tick(1, focused);
+ const due = s.next.at;
+ _ = s.key(.{ .code = addon.char('j') });
+ _ = s.tick(due - std.time.ns_per_ms, focused);
+ const extended = s.next.at;
+ try std.testing.expectEqual(due - std.time.ns_per_ms + grace, extended);
+ _ = s.key(.{ .code = addon.char('k') });
+ _ = s.tick(extended - 1, focused);
+ try std.testing.expectEqual(extended, s.next.at);
+ try std.testing.expectEqual(@as(u32, 0), s.steps);
+ _ = s.tick(extended, focused);
+ try std.testing.expectEqual(@as(u32, 1), s.steps);
+ try std.testing.expectEqualDeep(Dir{ 0, -1 }, s.dir);
+}
+
+test "a late wall turn recovers during collision grace and missing it ends the round" {
+ var s = testGame();
+ for (s.segs[0..3], 0..) |*p, i| p.* = .{ .x = @intCast(s.width - 1 - i), .y = 2 };
+ s.food = .{ .x = 0, .y = 0 };
+ _ = s.tick(1, focused);
+ const due = s.next.at;
+ _ = s.tick(due, focused);
+ try std.testing.expect(!s.dead);
+ try std.testing.expectEqual(due + grace, s.collision_at);
+ var missed = s;
+ _ = missed.key(.{ .code = addon.char('k') });
+ _ = missed.tick(due + grace, focused);
+ try std.testing.expect(missed.dead);
+ _ = s.key(.{ .code = addon.char('k') });
+ _ = s.tick(due + grace - 1, focused);
+ try std.testing.expect(!s.dead);
+ try std.testing.expectEqual(@as(u32, 1), s.steps);
+ try std.testing.expectEqual(@as(u8, 1), s.segs[0].y);
+}
+
+test "board uses whole square cells, resizes safely, and a replica does not change it" {
+ var s = testGame();
+ s.view(testView(80, 30, 1));
+ try std.testing.expectEqual(@as(u8, 38), s.width);
+ try std.testing.expectEqual(@as(u8, 28), s.height);
+ s.view(testView(30, 10, 2));
+ try std.testing.expectEqual(@as(u8, 38), s.width);
+ const old_head = s.segs[0];
+ s.view(testView(80, 40, 1));
+ try std.testing.expectEqualDeep(old_head, s.segs[0]);
+ s.score = 7;
+ s.len = 5;
+ for (s.segs[0..s.len], 0..) |*p, i| p.* = .{ .x = @intCast(10 - i), .y = 2 };
+ s.resize(3, 3);
+ try std.testing.expectEqual(@as(u32, 7), s.score);
+ try std.testing.expectEqual(@as(u16, 3), s.len);
+ for (s.segs[0..s.len]) |p| try std.testing.expect(p.x < 3 and p.y < 3);
+ try std.testing.expect(!s.on(s.food.x, s.food.y, s.len));
+ const l = s.layout(1333, 977);
+ try std.testing.expect(l.tile * (s.width + @as(u32, 2)) <= 1333);
+ try std.testing.expect(l.tile * (s.height + @as(u32, 2)) <= 977);
+ s.width = max_side;
+ s.height = max_side;
+ s.len = 1;
+ s.segs[0] = .{ .x = 125, .y = 125 };
+ const occupied = s.bits();
+ try std.testing.expectEqual(@as(u32, 1) << 29, occupied[125][3]);
+}
+
+test "hover maps to discrete cells, clears on leave, and idle animation never moves the snake" {
+ var s = testGame();
+ s.view(testView(80, 30, 1));
+ const m: addon.Mouse = .{ .button = .left, .action = .motion, .ctrl = false, .alt = false, .shift = false, .view = 1, .col = 4, .row = 3, .amount = 0 };
+ try std.testing.expect(s.mouse(m));
+ try std.testing.expectEqual(@as(i16, 2), s.hover_x);
+ try std.testing.expectEqual(@as(i16, 3), s.hover_y);
+ const before = s.segs[0];
+ try std.testing.expectEqual(10 + animation_period, s.tick(10, .{ .focused = false, .framed = true, ._ = 0 }));
+ _ = s.tick(10 + animation_period, .{ .focused = false, .framed = true, ._ = 0 });
+ try std.testing.expectEqualDeep(before, s.segs[0]);
+ var leave = m;
+ leave.col = 0xffff;
+ leave.row = 0xffff;
+ _ = s.mouse(leave);
+ try std.testing.expectEqual(@as(i16, -1), s.hover_x);
+ _ = s.mouse(m);
+ s.view(testView(0, 0, 1));
+ try std.testing.expectEqual(@as(i16, -1), s.hover_x);
+ try std.testing.expectEqual(@as(u64, 0), s.tick(100, .{ .focused = false, .framed = false, ._ = 0 }));
+}
+
+test "old records migrate and current records retain geometry and game state on reload" {
+ var old = std.mem.zeroInit(Legacy, .{ .len = 3, .food = .{ .x = 1, .y = 1 }, .dir = .{ 1, 0 }, .turn = .{ 0, -1 }, .score = 4, .steps = 12, .rng = 3 });
+ for (old.segs[0..3], 0..) |*p, i| p.* = .{ .x = @intCast(10 - i), .y = 2 };
+ var s: Snake = undefined;
+ try std.testing.expect(Snake.load(&s, std.mem.asBytes(&old), 1));
+ try std.testing.expectEqual(@as(u32, 4), s.score);
+ try std.testing.expectEqual(@as(u32, 12), s.steps);
+ try std.testing.expectEqualDeep(old.segs[0], s.segs[0]);
+ s.view(testView(80, 30, 1));
+ var record: [@sizeOf(Snake)]u8 = undefined;
+ var back: Snake = undefined;
+ try std.testing.expect(Snake.load(&back, record[0..Snake.dump(&s, &record)], 2));
+ try std.testing.expectEqualDeep(s.sizes, back.sizes);
+ try std.testing.expectEqual(s.score, back.score);
+ try std.testing.expectEqualDeep(s.segs[0..s.len], back.segs[0..back.len]);
+ try std.testing.expect(!Snake.load(&back, &record, 3));
+ old.len = 101;
+ try std.testing.expect(!Snake.load(&back, std.mem.asBytes(&old), 1));
+}
+
+test "GPU fallback stays optional and dynamic board and post uniforms encode without mutation" {
+ var api = std.mem.zeroes(addon.c.pa_api);
+ api.abi = 0x30000;
+ addon.api = &api;
+ var output = std.mem.zeroes(addon.c.pa_paint);
+ const paint: addon.Paint = .{ .out = &output };
+ try std.testing.expect(!paint.gpu("unused"));
+ api.abi = 0x30001;
+ try std.testing.expect(!paint.gpu("unused"));
+ var s = testGame();
+ s.view(testView(80, 30, 1));
+ const before = s;
+ const Capture = struct {
+ called: bool = false,
+ fn emit(ctx: ?*anyopaque, bytes: [*c]const u8, n: u32) callconv(.c) c_int {
+ const self: *@This() = @ptrCast(@alignCast(ctx.?));
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ const frame = scene.decodeFrame(arena.allocator(), bytes[0..n]) catch return 1;
+ self.called = frame.pass.draws[0].fragment_uniforms.len == @sizeOf(Uniforms) and frame.post != null and frame.post.?.fragment_uniforms.len == 16 and frame.pass.width == 1280 and frame.pass.height == 960;
+ return 0;
+ }
+ };
+ var capture: Capture = .{};
+ output.gpu = Capture.emit;
+ output.gpu_ctx = &capture;
+ var cells: [80 * 30]addon.c.pa_cell = @splat(std.mem.zeroes(addon.c.pa_cell));
+ s.paint(.{ .cells = &cells, .stride = 80, .cols = 80, .rows = 30, .cell_w = 16, .cell_h = 32, .focused = true, .view = 1, .glyphs = false }, paint);
+ try std.testing.expect(capture.called);
+ try std.testing.expectEqualDeep(s, before);
+}