diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-06 13:28:30 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-06 14:24:59 -0300 |
| commit | 0f81de017ca7b52e951bb70f6f5f3e8c88b425e6 (patch) | |
| tree | fde88db0ed0dd68fbeb7bf7aaa49d3cd1f08b1c1 /addons/snake/snake.zig | |
| parent | b7fdfb18ffd199d49a254c1c799bc3415ad45ec2 (diff) | |
| download | pardes-0f81de017ca7b52e951bb70f6f5f3e8c88b425e6.tar.gz pardes-0f81de017ca7b52e951bb70f6f5f3e8c88b425e6.zip | |
kinds #25, addons in Zig: src/kinds/addon.zig, over the translated header and nothing of the core, makes a kind's pa_ops from a struct of the functions it has (its head from name, version, extensions and words; a public function of no kind's name a compile error), the pane's arena and a job's pa_out as std Allocators, typed keys, a Window to put text in, a Paint for the prefix and placements, tick's flags and a Deadline, dump and load as an extern struct's bytes in one line each, and body and ctl over a Writer; snake.zig and image.zig (stb_image in stb.c, static, beside any zstbi) replace snake.c and image.c with the same goldens, harness and perf cell, and addon-test runs their own zig tests
Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'addons/snake/snake.zig')
| -rw-r--r-- | addons/snake/snake.zig | 147 |
1 files changed, 147 insertions, 0 deletions
diff --git a/addons/snake/snake.zig b/addons/snake/snake.zig new file mode 100644 index 00000000..badafc54 --- /dev/null +++ b/addons/snake/snake.zig @@ -0,0 +1,147 @@ +//! snake.zig: a snake game as a pardes addon, over src/kinds/addon.zig +//! (`zig build addon-test` builds it as snake.so and runs snake.script). +//! 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. +const std = @import("std"); +const addon = @import("addon"); + +const W = 20; // the board, in cells, inside its wall +const H = 5; +const period = 150 * std.time.ns_per_ms; + +const Pt = extern struct { x: u8, y: u8 }; + +pub const Snake = extern struct { + segs: [W * H]Pt, // segs[0] is the head + len: u16, + food: Pt, + dir: [2]i8, // the direction last stepped + turn: [2]i8, // the direction the next step takes + dead: bool, + score: u32, + steps: u32, + rng: u64, + next: addon.Deadline, + + pub const head: addon.Head = .{ .name = "snake", .version = 1, .words = &.{ + .{ .name = "Snake", .opens = true, .doc = "a game of snake: h j k l steer" }, + } }; + + fn rnd(s: *Snake) u64 { + 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? + 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 placeFood(s: *Snake) void { + s.dead = s.len == W * H; // the board full: a win, and over + if (s.dead) return; + var k = s.rnd() % (W * H - s.len); + s.food = for (0..W * H) |i| { + const p: Pt = .{ .x = @intCast(i % W), .y = @intCast(i / W) }; + if (s.on(p.x, p.y, s.len)) continue; + if (k == 0) break p; + k -= 1; + } else s.food; + } + + fn restart(s: *Snake) void { + s.len = 3; + for (s.segs[0..3], 0..) |*p, i| p.* = .{ .x = @intCast(W / 2 - i), .y = H / 2 }; + s.dir, s.turn, s.dead, s.score, s.steps = .{ .{ 1, 0 }, .{ 1, 0 }, false, 0, 0 }; + s.placeFood(); + } + + fn step(s: *Snake) void { + s.dir = s.turn; + const x = @as(i32, s.segs[0].x) + s.dir[0]; + const y = @as(i32, s.segs[0].y) + s.dir[1]; + const eats = x == s.food.x and y == s.food.y; + // The tail moves away this step unless the snake grows. + s.dead = x < 0 or y < 0 or x >= W or y >= H or s.on(x, y, if (eats) s.len else s.len - 1); + if (s.dead) return; + 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; + if (!eats) return; + s.score += 1; + s.placeFood(); + } + + pub fn open(s: *Snake, _: ?[]const u8) void { + s.rng = addon.seed() | 1; + s.restart(); + } + + /// Unfocused or over, it stands still and asks for nothing: a key, or + /// the keyboard coming back, ticks it again. + pub fn tick(s: *Snake, now: u64, flags: addon.Flags) u64 { + if (s.next.due(now) and flags.focused and !s.dead) s.step(); + return if (!flags.focused or s.dead) s.next.stop() else s.next.every(now, period); + } + + pub fn paint(s: *const Snake, w: addon.Window, out: addon.Paint) void { + const wall: addon.Style = .{ .fg = .index(8) }; + for (0..H + 2) |y| for (0..W + 2) |x| if (x % (W + 1) == 0 or y % (H + 1) == 0) 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, H + 2, "game over: any key", .{ .fg = .index(1) }) else if (!w.focused) w.put(0, H + 2, "paused", wall); + out.prefix("Snake {d}{s}", .{ s.score, if (s.dead) " over" else "" }); + } + + pub fn key(s: *Snake, k: addon.Key) bool { + if (k.code == .esc) return false; // Esc leaves + if (s.dead or k.code == addon.char('r')) { + s.restart(); + return true; + } + const d: [2]i8 = 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, + }; + if (d[0] != -s.dir[0] or d[1] != -s.dir[1]) s.turn = d; // no turning back + return true; + } + + pub fn body(s: *const Snake, w: *std.Io.Writer) !void { + try w.print("score {d}\nlength {d}\nsteps {d}\n{s}\n", .{ s.score, s.len, s.steps, if (s.dead) "over" else "alive" }); + } + + pub fn ctlRead(s: *const Snake, w: *std.Io.Writer) !void { + try w.print("score {d}\nlength {d}\n", .{ s.score, s.len }); + } + + pub const dump = addon.dumpBytes; + pub const load = addon.loadBytes; +}; + +export const pardes_addon = addon.ops(Snake); + +test "it eats, grows a segment and a point, dies on the wall, and its record is its state" { + var s = std.mem.zeroInit(Snake, .{ .rng = 3 }); + s.restart(); + s.food = .{ .x = s.segs[0].x + 1, .y = s.segs[0].y }; + s.step(); + try std.testing.expectEqual(4, s.len); + try std.testing.expectEqual(1, s.score); + _ = s.key(.{ .code = addon.char('k') }); + while (!s.dead) s.step(); + try std.testing.expectEqual(0, s.segs[0].y); + var record: [@sizeOf(Snake)]u8 = undefined; + var back = std.mem.zeroInit(Snake, .{}); + try std.testing.expect(addon.loadBytes(&back, record[0..addon.dumpBytes(&s, &record)], 1)); + try std.testing.expect(std.meta.eql(back, s)); + try std.testing.expect(!addon.loadBytes(&back, &record, 2)); +} |
