One Dimensional Cellular Automata

I'm reluctant to use random number generators for anything other than the initial state of a simulation because their inclusion elsewhere makes the end result no longer deterministic. Despite that I have a few ants whose behavior is random, showcased here.

Stumble picks a random direction and a random duration, then moves in a straight line until that duration elapses before repeating.

Fortify is a novel behavior that necessitated a near-total rewrite of the Ant object class. It initially claims pixels in black/gray, then when passing over a friendly pixel again it updates it to the purple "reinforced" state. Enemy ants moving over reinforced pixels revert them to their non-reinforced state without changing their active/passive state or claiming them.

Launch is another nerfed descendant of Voyager. It has the same "go straight on passive/hostile pixels" rule, but it has a limited amount of "fuel" to use to do so.

Glitch is a variant of skip that I tweaked to produce a different pattern. It follows the normal ant behavior but jumps two pixels per move. If it starts on an active pixel, it jumps three pixels.

The next variant is Voyager. The inverse of Highway, Voyager ONLY changes direction on friendly pixels.

Another ant race showcasing another ant variant.

Highway never changes direction on friendly pixels. Other than that it behaves like a normal ant.

New thing I coded, technically one dimension too many for this blog but whatever. It's a competition between ants to see which team can claim the most territory. Brown team is the classic Langton's Ant and Blue team is a variant I modified to add diagonal movement.

To keep things interesting, each team gets a new ant every 250 frames.

Every 5 generations:

Every other generation:

Every generation:

Here's how it works:

EDIT: there was a mistake in the code, using modulo 9 in all cases meant state 9 will never emerge. Fixing it later...

Here's how it works: The state of each cell determines the size of the neighborhood it will look at. State 0 looks at itself and the cell directly to the right (state 0 can't have neighborhood size 0 or no cells could be born). State 1 looks at itself and the next two cells, state 2 itself and the next three cells, and so on. To determine the next state, sum all the cells in the neighborhood, divide by 9 and keep the remainder.

Here's what it looks like:

It looks mostly green because I used yellow, yellow-geeen and green as states and they all sort of blend together.

I ran it again, this time color coding for even and odd, but still (almost) no patterns emerged: