//! The logic of the sand const std = @import("std"); const Io = std.Io; pub const state = enum(u1) { Alive, Dead }; pub const leaning = enum(u1) { Left = 0, Right = 1, pub fn opposite(self: leaning) leaning { return @enumFromInt(@intFromBool(self == .Left)); } }; pub const cell = struct { alive: bool, }; pub const position = packed struct { x: u16, y: u16, }; pub const Grid = struct { arr: [][]cell, max: position, leaning: leaning, pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { for (self.arr) |line| { for (line) |grain| { try writer.writeAll(if (grain.alive) "" else ""); } try writer.writeByte('\n'); } } pub fn init(x: u16, y: u16, allocator: std.mem.Allocator) std.mem.Allocator.Error!Grid { const arr: [][]cell = try allocator.alloc([]cell, y); for (arr) |*line| { line.* = try allocator.alloc(cell, x); for (line.*) |*c| { c.* = .{ .alive = false }; } } return .{ .max = position{ .x = x - 1, .y = y - 1, }, .arr = arr, .leaning = .Left, }; } pub fn deinit(self: Grid, allocator: std.mem.Allocator) void { for (self.arr) |line| { allocator.free(line); } allocator.free(self.arr); } pub fn updateAll(self: *Grid, allocator: std.mem.Allocator) std.mem.Allocator.Error!void { var newGrid: Grid = try .init(self.max.x + 1, self.max.y + 1, allocator); newGrid.leaning = self.leaning.opposite(); for (0..self.arr.len) |y| { for (0..self.arr[y].len) |x| { update(.{ .y = @truncate(y), .x = @truncate(x) }, self.*, newGrid); } } self.deinit(allocator); self.* = newGrid; } pub fn updateAllConcurrent(self: *Grid, allocator: std.mem.Allocator, io: std.Io, async: []std.Io.Future(void)) (std.mem.Allocator.Error || std.Io.ConcurrentError)!void { var newGrid: Grid = try .init(self.max.x + 1, self.max.y + 1, allocator); newGrid.leaning = self.leaning.opposite(); for (0..self.arr.len) |y| { async[y] = try io.concurrent((struct { pub fn updateLine(s: Grid, ng: Grid, fy: usize) void { for (0..s.arr[fy].len) |x| { update(.{ .y = @truncate(fy), .x = @truncate(x) }, s, ng); } } }).updateLine, .{ self.*, newGrid, y }); } for (async) |*a| { a.await(io); } self.deinit(allocator); self.* = newGrid; } pub const copyError = error{wrongDimensions}; pub fn copy(self: Grid, dest: *Grid) void { std.debug.assert(self.arr.len == dest.arr.len and self.arr[0].len == dest.arr[0].len); for (dest.arr, self.arr) |d, s| { @memcpy(d, s); } } pub fn eql(self: Grid, dest: Grid) bool { if (!(self.max == dest.max)) return false; for (self.arr, dest.arr) |ls, ld| { for (ls, ld) |cs, cd| { if (cs.alive != cd.alive) return false; } } return true; } }; pub fn update(self: position, grid: Grid, newGrid: Grid) void { alive: switch (false) { false => { std.debug.assert(grid.max == newGrid.max); if (!grid.arr[self.y][self.x].alive) return; if (self.y == grid.max.y) continue :alive true; const nextline = grid.arr[self.y + 1]; const newnextline = newGrid.arr[self.y + 1]; down: switch (nextline[self.x].alive) { false => { if (@cmpxchgStrong(bool, &newnextline[self.x].alive, false, true, .seq_cst, .monotonic)) |_| { continue :down true; } else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } }, true => { if (self.x == grid.max.x) { if (!nextline[self.x - 1].alive) { if (@cmpxchgStrong(bool, &newnextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } } } else if (self.x == 0) { if (!nextline[self.x + 1].alive) { if (@cmpxchgStrong(bool, &newnextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } } } else { switch (grid.leaning) { .Right => { right: switch (nextline[self.x + 1].alive) { false => { if (@cmpxchgStrong(bool, &newnextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| { continue :right true; } else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } }, true => { if (!nextline[self.x - 1].alive) { if (@cmpxchgStrong(bool, &newnextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } } }, } }, .Left => { left: switch (nextline[self.x - 1].alive) { false => { if (@cmpxchgStrong(bool, &newnextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| { continue :left true; } else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } }, true => { if (!nextline[self.x + 1].alive) { if (@cmpxchgStrong(bool, &newnextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); return; } } }, } }, } } }, } continue :alive true; }, true => @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, true, .seq_cst), } }