diff options
Diffstat (limited to 'addons')
| -rw-r--r-- | addons/snake_shader/snake.frag | 52 | ||||
| -rw-r--r-- | addons/snake_shader/snake.post.frag | 34 | ||||
| -rw-r--r-- | addons/snake_shader/snake.vert | 6 | ||||
| -rw-r--r-- | addons/snake_shader/snake_shader.out | 147 | ||||
| -rw-r--r-- | addons/snake_shader/snake_shader.script | 26 | ||||
| -rw-r--r-- | addons/snake_shader/snake_shader.zig | 547 |
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); +} |
