2-D Totalistic Cellular Automaton (Conway + variants)

Math essence

nbr = sum(8 rolled neighbors). next_grid[dead & nbr in birth_set | alive & nbr in survive_set] = 1. Brian's Brain uses 3 states with refractory dying. All transitions are fully vectorized via numpy.roll on torus.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/reas_processing/wolframCA2D/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


LIFE_RULES = {
    "conway": (3, (2, 3)),
    "highlife": (3, (2, 3)),
    "day_and_night": (3, (3, 4), (4, 6), (4, 7)),
    "seeds": (2, tuple()),
    "brians_brain": (2,),
    "wire_world": None,
}


class WolframCA2D:
    """Two-dimensional totalistic cellular automaton.

    Each cell on a torus looks at its 8 Moore neighbors and applies a
    totalistic rule: a birth rule (number of live neighbors required for
    a dead cell to come alive) and a survival rule (number of live
    neighbors required to keep a live cell alive). The canonical
    Conway's Game of Life is B3/S23, and other classics include
    HighLife (B36/S23), Day&Night, Brian's Brain, and Seeds. This is
    the standard 2-D CA referenced in Casey Reas's creative-coding
    curricula.
    """

    family: ClassVar[str] = "reas_processing"
    sketch: ClassVar[str] = "wolframCA2D"

    def __init__(
        self,
        dim: int = 200,
        rule_name: str = "conway",
        initial_density: float = 0.32,
        palette: str = "two_color",
        bg_color: tuple[int, int, int] = (240, 235, 225),
        ink_color: tuple[int, int, int] = (30, 30, 50),
        glow_color: tuple[int, int, int] | None = None,
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.rule_name = rule_name
        self.initial_density = initial_density
        self._palette_mode = palette
        self.bg_color = np.array(bg_color, dtype=np.uint8)
        self.ink_color = np.array(ink_color, dtype=np.uint8)
        self.glow_color = (
            np.array(glow_color, dtype=np.uint8) if glow_color is not None else None
        )
        self._seed = seed
        self.reset()

    def _build_rule(self, name: str) -> tuple[set[int], set[int]]:
        if name == "conway":
            return {3}, {2, 3}
        if name == "highlife":