Ludum Dare? That’s been a while!

I didn’t actually enter the game jam. Honestly, I wasn’t sure I was going to write anything. But I had a bit of an idea and spent a few hours only on Sunday hammering something out:

Yeah, I did another cellular automata thing 😄

It’s not at all complete, but the basic idea is:

• Generate a random level
• See it with multiple players (colonies of bugs)
• Each bug will send out waves of ‘shine’, expanding their territory
• Take over the map to win

It’s sort of got that?

I’m using Rust as I’ve been doing a lot recently.

The main libraries are:

• pixels for the rendering; it gives me direct access to a pixel buffer, which is my favorite
• winit for windowing; this did require the feature rwh_05 to be properly compatible with pixels, which took a minute to track down

Other than, that, it’s straight custom code which you can see in it’s entirety on my github.

• main.rs - creates the window and handles input
• world.rs - runs the simulation mostly in an update function; with generation in new

I think that perhaps the only really interesting bit about the code is how the ‘shine waves’ work. Basically, I have a grid of the state of each cell, but I also have a Vec that tracks ‘active’ pixels. Those are the only ones that can update–which both helps performance and makes the simulation appear the way it does.

Overall, a nice quick project. More than anything, it actually convinced me to try setting up something that can render pixel buffers on Rust. And with a (very minimal) GUI, too! Both things I’ve been meaning to learn.

I probably won’t do anything more with this code, but it’s got the seeds of something more interesting. Keep an eye out. 😄

Onward!

read more...

Source: Unstable Diffusion

Part 1

Implement a cellular automaton with the following rules:

• If you have no neighbors, don’t move (important, I forgot this one for a while)
• Otherwise:
  • Calculate a potential move:
    • If you have no neighbors to the north, move north
    • If not, check likewise for south, then west, than east
  • If no other agent is moving to the same space, move to your potential move
  • Otherwise, don’t move
• On each frame, rotate the order the directions are checked in (NSWE, SWEN, WENS, ENSW, NSWE, …)

read more...

Source: Regolith Reservoir

Part 1

Given a series of walls as input, run a falling sand simulation until any new sand falls of the map. Count how many grains of sand we end up with.

read more...

Source: Cathode-Ray Tube

Part 1

Implement a simple virtual machine with two instructions: nop which does nothing for 1 cycles and addx $n which adds $n to the X register (initial value 1) in two cycles. Calculate the sum of cycle * X for the cycles 20, 60, 100, 140, 180, 220.

read more...

Source: Rope Bridge

Part 1

Simulate two connected links such that whenever the first link (head) moves, the tail moves to follow according to the following rules:

• If the tail is at the same location as head, don’t move
• If the tail is adjacent to the head (orthogonal or diagonal), don’t move
• If the tail is in the same row/column as the head, move one directly towards it orthogonally
• If the tail is in neither the same row nor column, move one towards diagonally

Count how many unique spaces are visited by the tail of the link.

read more...

Source: Sea Cucumber

Part 1: Load a grid of empty cells (.), east movers (>), and south movers (v). Each step, move all east movers than all south movers (only if they can this iteration). Wrap east/west and north/south. How many steps does it take the movers to get stuck?

read more...

Source: Trench Map

Part 1: Given a 9->1 cellular automota update function (take the pixel and 8 surrounding pixels as a 9-bit index into the function) and a binary image, apply the function twice and count the number of ’lit’ pixels. Assume that the canvas is infinite.

read more...

Source: Dumbo Octopus

Part 1: Simulate a grid of numbers such that on each tick: advance all numbers by 1, any number that increases over 9 will ‘flash’ and add 1 to all neighbors (recursively, but each cell can only flash once) and then reset to 0. Count the number of flashes in the first 100 ticks.

read more...

Source: Latternfish

Part 1: Simulate a population of lanternfish. Each fish is immortal, starts having children after 9 days, and has another child after 7 more days. Calculate the number of fish after 80 days.

read more...