Dario48/sand
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

colors wow

Browse source
This commit is contained in:
Dario48 2026-04-20 00:41:51 +02:00
commit ef2679d872
2 changed files with 200 additions and 179 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/main.zig
View file

@ -1,6 +1,16 @@
const std = @import("std"); const std = @import("std");
const sand = @import("sand"); const s = @import("sand");
// const colorType = packed struct {
// r: u8,
// g: u8,
// b: u8,
// };
//
// const sand = s.init(colorType, .{ .r = 0, .g = 0, .b = 0 });
const sand = s.init(u9, 0);
const pow = std.math.pow; const pow = std.math.pow;
@ -48,6 +58,8 @@ pub fn main(init: std.process.Init) !void {
var placeChace: u8 = 250; var placeChace: u8 = 250;
var slider: u9 = 1;
raylib.setTargetFPS(50); raylib.setTargetFPS(50);
var timeForUpdate: u64 = 0; var timeForUpdate: u64 = 0;
@ -84,10 +96,11 @@ pub fn main(init: std.process.Init) !void {
const drawTimer = std.Io.Clock.now(.awake, init.io); const drawTimer = std.Io.Clock.now(.awake, init.io);
for (grid.arr, 0..) |line, y| { for (grid.arr, 0..) |line, y| {
for (line, 0..) |cell, x| { for (line, 0..) |cell, x| {
texture[x + screenWidth * y] = if (cell.alive) //texture[x + screenWidth * y] = if (!(cell == sand.dead))
raylib.Color.init(@truncate((255 * y) / screenHeight), @truncate((255 * x) / screenWidth), 0, 255) // raylib.Color.init(@truncate((255 * y) / screenHeight), @truncate((255 * x) / screenWidth), 0, 255)
else //else
.black; // .black;
texture[x + screenWidth * y] = if (cell == 0) .black else raylib.Color.fromHSV(cell - 1, 1, 1);
} }
} }
@ -115,19 +128,20 @@ pub fn main(init: std.process.Init) !void {
if (circleAsyncArray) |_| {} else circleAsyncArray = try init.gpa.alloc(std.Io.Future(void), xend - xstart); if (circleAsyncArray) |_| {} else circleAsyncArray = try init.gpa.alloc(std.Io.Future(void), xend - xstart);
for (xstart..xend, 0..) |x, i| { for (xstart..xend, 0..) |x, i| {
circleAsyncArray.?[i] = init.io.async((struct { circleAsyncArray.?[i] = init.io.async((struct {
pub fn l(IP: raylib.Vector2, IS: f32, fx: usize, rand: *std.Random.DefaultPrng, gr: sand.Grid, pc: u8) void { pub fn l(IP: raylib.Vector2, IS: f32, fx: usize, rand: *std.Random.DefaultPrng, gr: sand.Grid, pc: u8, slid: u9) void {
const ystart: usize = @intCast(@max(0, @as(i32, @trunc(IP.y - IS)))); const ystart: usize = @intCast(@max(0, @as(i32, @trunc(IP.y - IS))));
const yend: usize = @intCast(@max(0, @as(i32, @trunc(IP.y + IS)))); const yend: usize = @intCast(@max(0, @as(i32, @trunc(IP.y + IS))));
for (ystart..yend) |y| { for (ystart..yend) |y| {
const dx = @as(f32, @floatFromInt(fx)) - IP.x; const dx = @as(f32, @floatFromInt(fx)) - IP.x;
const dy = @as(f32, @floatFromInt(y)) - IP.y; const dy = @as(f32, @floatFromInt(y)) - IP.y;
if (fx >= screenWidth or y >= screenHeight) {} else if (pow(f32, dx, 2) + pow(f32, dy, 2) <= pow(f32, IS, 2) and rand.random().int(u8) > pc) if (fx >= screenWidth or y >= screenHeight) {} else if (pow(f32, dx, 2) + pow(f32, dy, 2) <= pow(f32, IS, 2) and rand.random().int(u8) > pc)
gr.arr[y][fx].alive = true; gr.arr[y][fx] = slid;
} }
} }
}).l, .{ IndicatorPosition, IndicatorSize, x, &random, grid, placeChace }); }).l, .{ IndicatorPosition, IndicatorSize, x, &random, grid, placeChace, slider });
} }
} }
slider = (slider % 361) + 1;
} }
if (circleAsyncArray) |arr| { if (circleAsyncArray) |arr| {
for (arr) |*a| { for (arr) |*a| {

89
src/root.zig
View file

@ -2,7 +2,6 @@
const std = @import("std"); const std = @import("std");
const Io = std.Io; const Io = std.Io;
pub const state = enum(u1) { Alive, Dead };
pub const leaning = enum(u1) { pub const leaning = enum(u1) {
Left = 0, Left = 0,
Right = 1, Right = 1,
@ -10,15 +9,18 @@ pub const leaning = enum(u1) {
return @enumFromInt(@intFromBool(self == .Left)); return @enumFromInt(@intFromBool(self == .Left));
} }
}; };
pub const cell = struct { //pub const cell = struct {
alive: bool, // alive: state,
}; //};
pub const position = packed struct { pub const position = packed struct {
x: u16, x: u16,
y: u16, y: u16,
}; };
pub fn init(comptime cell: type, d: cell) type {
return struct {
pub const dead = d;
pub const Grid = struct { pub const Grid = struct {
arr: [][]cell, arr: [][]cell,
max: position, max: position,
@ -26,7 +28,7 @@ pub const Grid = struct {
pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void {
for (self.arr) |line| { for (self.arr) |line| {
for (line) |grain| { for (line) |grain| {
try writer.writeAll(if (grain.alive) "" else ""); try writer.writeAll(if (!(grain == dead)) "" else "");
} }
try writer.writeByte('\n'); try writer.writeByte('\n');
} }
@ -37,7 +39,7 @@ pub const Grid = struct {
for (arr) |*line| { for (arr) |*line| {
line.* = try allocator.alloc(cell, x); line.* = try allocator.alloc(cell, x);
for (line.*) |*c| { for (line.*) |*c| {
c.* = .{ .alive = false }; c.* = dead;
} }
} }
@ -116,8 +118,8 @@ pub const Grid = struct {
pub const copyError = error{wrongDimensions}; pub const copyError = error{wrongDimensions};
pub fn copy(self: Grid, dest: *Grid) void { 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); 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| { for (dest.arr, self.arr) |des, s| {
@memcpy(d, s); @memcpy(des, s);
} }
} }
@ -126,7 +128,7 @@ pub const Grid = struct {
for (self.arr, dest.arr) |ls, ld| { for (self.arr, dest.arr) |ls, ld| {
for (ls, ld) |cs, cd| { for (ls, ld) |cs, cd| {
if (cs.alive != cd.alive) return false; if (cs != cd) return false;
} }
} }
@ -138,51 +140,52 @@ pub fn update(self: position, grid: Grid, newGrid: Grid) void {
alive: switch (false) { alive: switch (false) {
false => { false => {
std.debug.assert(grid.max == newGrid.max); std.debug.assert(grid.max == newGrid.max);
if (!grid.arr[self.y][self.x].alive) return; if (grid.arr[self.y][self.x] == dead) return;
if (self.y == grid.max.y) continue :alive true; if (self.y == grid.max.y) continue :alive true;
const alive = grid.arr[self.y][self.x];
const nextline = grid.arr[self.y + 1]; const nextline = grid.arr[self.y + 1];
const newnextline = newGrid.arr[self.y + 1]; const newnextline = newGrid.arr[self.y + 1];
down: switch (nextline[self.x].alive) { down: switch (nextline[self.x] == dead) {
false => { true => {
if (@cmpxchgStrong(bool, &newnextline[self.x].alive, false, true, .seq_cst, .monotonic)) |_| { if (@cmpxchgStrong(cell, &newnextline[self.x], dead, alive, .seq_cst, .monotonic)) |_| {
continue :down true; continue :down false;
} else { } else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
}, },
true => { false => {
if (self.x == grid.max.x) { if (self.x == grid.max.x) {
if (!nextline[self.x - 1].alive) { if (nextline[self.x - 1] == dead) {
if (@cmpxchgStrong(bool, &newnextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { if (@cmpxchgStrong(cell, &newnextline[self.x - 1], dead, alive, .seq_cst, .monotonic)) |_| {} else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
} }
} else if (self.x == 0) { } else if (self.x == 0) {
if (!nextline[self.x + 1].alive) { if (nextline[self.x + 1] == dead) {
if (@cmpxchgStrong(bool, &newnextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { if (@cmpxchgStrong(cell, &newnextline[self.x + 1], dead, alive, .seq_cst, .monotonic)) |_| {} else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
} }
} else { } else {
switch (grid.leaning) { switch (grid.leaning) {
.Right => { .Right => {
right: switch (nextline[self.x + 1].alive) { right: switch (nextline[self.x + 1] == dead) {
false => { true => {
if (@cmpxchgStrong(bool, &newnextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| { if (@cmpxchgStrong(cell, &newnextline[self.x + 1], dead, alive, .seq_cst, .monotonic)) |_| {
continue :right true; continue :right false;
} else { } else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
}, },
true => { false => {
if (!nextline[self.x - 1].alive) { if (nextline[self.x - 1] == dead) {
if (@cmpxchgStrong(bool, &newnextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { if (@cmpxchgStrong(cell, &newnextline[self.x - 1], dead, alive, .seq_cst, .monotonic)) |_| {} else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
} }
@ -190,19 +193,19 @@ pub fn update(self: position, grid: Grid, newGrid: Grid) void {
} }
}, },
.Left => { .Left => {
left: switch (nextline[self.x - 1].alive) { left: switch (nextline[self.x - 1] == dead) {
false => { true => {
if (@cmpxchgStrong(bool, &newnextline[self.x - 1].alive, false, true, .seq_cst, .monotonic)) |_| { if (@cmpxchgStrong(cell, &newnextline[self.x - 1], dead, alive, .seq_cst, .monotonic)) |_| {
continue :left true; continue :left false;
} else { } else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
}, },
true => { false => {
if (!nextline[self.x + 1].alive) { if (nextline[self.x + 1] == dead) {
if (@cmpxchgStrong(bool, &newnextline[self.x + 1].alive, false, true, .seq_cst, .monotonic)) |_| {} else { if (@cmpxchgStrong(cell, &newnextline[self.x + 1], dead, alive, .seq_cst, .monotonic)) |_| {} else {
@atomicStore(bool, &newGrid.arr[self.y][self.x].alive, false, .seq_cst); @atomicStore(cell, &newGrid.arr[self.y][self.x], dead, .seq_cst);
return; return;
} }
} }
@ -215,6 +218,10 @@ pub fn update(self: position, grid: Grid, newGrid: Grid) void {
} }
continue :alive true; continue :alive true;
}, },
true => @atomicStore(bool, &newGrid.arr[self.y][self.x].alive, true, .seq_cst), true => @atomicStore(cell, &newGrid.arr[self.y][self.x], grid.arr[self.y][self.x], .seq_cst),
} }
} }
};
}
pub const default = init(u1, 0);