129 lines
4.3 KiB
Zig
129 lines
4.3 KiB
Zig
//! 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) void {
|
|
for (0..self.arr.len) |y| {
|
|
for (0..self.arr[y].len) |x| {
|
|
update(.{ .y = @truncate(y), .x = @truncate(x) }, self.*);
|
|
}
|
|
}
|
|
self.leaning = self.leaning.opposite();
|
|
}
|
|
|
|
pub const copyError = error{wrongDimensions};
|
|
pub fn copy(self: Grid, dest: *Grid) copyError!void {
|
|
if (self.arr.len != dest.arr.len or self.arr[0].len != dest.arr[0].len) return copyError.wrongDimensions;
|
|
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) void {
|
|
if (self.y == grid.max.y) return;
|
|
if (!grid.arr[self.y][self.x].alive) return;
|
|
const nextline = grid.arr[self.y + 1];
|
|
|
|
if (@cmpxchgStrong(bool, &nextline[self.x].alive, false, true, .seq_cst, .monotonic)) |_| {
|
|
if (self.x == grid.max.x) {
|
|
if (@cmpxchgStrong(bool, &nextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
} else if (self.x == 0) {
|
|
if (@cmpxchgStrong(bool, &nextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
} else {
|
|
switch (grid.leaning) {
|
|
.Right => {
|
|
if (@cmpxchgStrong(bool, &nextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {
|
|
if (@cmpxchgStrong(bool, &nextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
},
|
|
.Left => {
|
|
if (@cmpxchgStrong(bool, &nextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {
|
|
if (@cmpxchgStrong(bool, &nextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
},
|
|
}
|
|
}
|
|
} else {
|
|
@atomicStore(bool, &grid.arr[self.y][self.x].alive, false, .seq_cst);
|
|
}
|
|
}
|