A Plant Grown From a String

// internal/grow/lsys.go
// Package grow keeps the two halves of a growing thing apart: a grammar
// that turns a short string into a long one by rewriting it, and a
// turtle that reads the long one back as a list of straight segments.
// Nothing in here knows what a pixel is.
package grow

import "math/rand/v2"

// Rules says what each character becomes when one generation passes. A
// character with a single production is rewritten the same way every
// time. A character with several is a choice, taken from the stream the
// caller hands over, so the same seed grows the same plant. A character
// with no entry at all stands for itself, which is how +, -, [ and ]
// survive every generation untouched.
type Rules map[byte][]string

// Grow rewrites every character of s once. Every character is read out
// of the old string and written into a new one, so nothing this pass
// produces is ever rewritten by the same pass.
func Grow(s string, r Rules, rng *rand.Rand) string {
	out := make([]byte, 0, 2*len(s))
	for i := 0; i < len(s); i++ {
		p := r[s[i]]
		switch {
		case len(p) == 0:
			out = append(out, s[i])
		case len(p) == 1:
			out = append(out, p[0]...)
		default:
			out = append(out, p[rng.IntN(len(p))]...)
		}
	}
	return string(out)
}

// internal/grow/lsys.go — counting without growing

// Census is how many of each character a string holds: enough to work
// out how long the next generation will be without building it.
type Census map[byte]int

// Take counts the characters of one string.
func Take(s string) Census {
	c := Census{}
	for i := 0; i < len(s); i++ {
		c[s[i]]++
	}
	return c
}

// Next is the census of the generation after this one, computed from
// counts alone. A character with a choice of productions makes the
// answer a guess instead of a count, and Next says so rather than
// picking one.
func (c Census) Next(r Rules) (Census, bool) {
	n := Census{}
	for ch, k := range c {
		p := r[ch]
		if len(p) > 1 {
			return nil, false
		}
		if len(p) == 0 {
			n[ch] += k
			continue
		}
		for i := 0; i < len(p[0]); i++ {
			n[p[0][i]] += k
		}
	}
	return n, true
}

$ go run ./cmd/grow -mode gens
axiom F, F -> F[+F]F[-F]F
  gen 0     1  F
  gen 1    11  F[+F]F[-F]F
  gen 2    61  F[+F]F[-F]F[+F[+F]F[-F]F]F[+F]F[-F]F[-F[+F]F[-F]F]F[+F]F[-F]F

   gen    characters        F's   brackets   straight run  ink / height
     0             1          1          0              1          1.00
     1            11          5          2              3          1.67
     2            61         25         12              9          2.78
     3           311        125         62             27          4.63
     4          1561        625        312             81          7.72
     5          7811       3125       1562            243         12.86
     6         39061      15625       7812            729         21.43
     7        195311      78125      39062           2187         35.72
     8        976561     390625     195312           6561         59.54
     9       4882811    1953125     976562          19683         99.23
    10      24414061    9765625    4882812          59049        165.38
    11     122070311   48828125   24414062         177147        275.64
    12     610351561  244140625  122070312         531441        459.39

The first three lines are the strings, and the second one can be checked against the paragraph above character for character. The table underneath was never built. Only generations 0, 1 and 2 exist as text anywhere in that run; every row from 3 down is a census being multiplied out, which is why a run that finishes in milliseconds can tell you that generation 12 would hold 610,351,561 characters. Building it would need 610 megabytes of string and a good deal of patience.

Two columns carry the growth. The F count multiplies by 5 every generation, since every F becomes five of them, so it is 5 multiplied by itself as many times as there are generations. The straight run multiplies by 3, because three of those five Fs sit outside every bracket and those three are the ones that carry the main stalk upward. Five against three is the whole story of the last column.

// internal/grow/turtle.go

// pose is everything a branch has to remember about the turtle that
// left it: where it stood, and which way it faced. Both, or the branch
// does not come back to the same place pointing the same way.
type pose struct {
	pos     vec.Vec2
	heading float64 // rim, measured the way chapter 28 measures a turn
}

// Segment is one straight piece of a drawing: two ends in world pixels,
// and how many brackets deep the turtle was when it drew it. The turtle
// produces these and never touches a pixel.
type Segment struct {
	A, B  vec.Vec2
	Depth int
}

// Step is the movement a heading of h and a length of n come to, in
// world pixels. The heading names a place on chapter 28's circle, whose
// height counts upward, and a framebuffer counts rows downward: the one
// minus sign is that disagreement, and it lives here because here is
// where an angle stops being an angle and becomes a movement.
func Step(h, n float64) vec.Vec2 {
	return vec.Vec2{X: math.Cos(h), Y: -math.Sin(h)}.Scale(n)
}

// internal/grow/turtle.go — the five instructions

// Read walks the string once and hands back every segment an F drew.
// seg is how many world pixels one F carries the turtle; turn is how
// much rim one + or - adds to its heading. Any character the turtle has
// no meaning for is stepped over, which is what lets a grammar carry
// letters that exist only to be rewritten.
func Read(s string, start vec.Vec2, heading, seg, turn float64) []Segment {
	t := pose{pos: start, heading: heading}
	var stack []pose
	var out []Segment
	for i := 0; i < len(s); i++ {
		switch s[i] {
		case 'F':
			out = append(out, Segment{A: t.pos, B: t.pos.Add(Step(t.heading, seg)), Depth: len(stack)})
			t.pos = out[len(out)-1].B
		case '+':
			t.heading += turn
		case '-':
			t.heading -= turn
		case '[':
			stack = append(stack, t)
		case ']':
			if len(stack) == 0 {
				continue // Balanced catches this before Read ever runs
			}
			t = stack[len(stack)-1]
			stack = stack[:len(stack)-1]
		}
	}
	return out
}

$ go run ./cmd/grow -mode read
F[+F]F[-F]F: segment 10 pixels, turn 1/8 of a turn (0.7854 rim), setting off at 1.5708 rim
  [ remembers the place and heading
    i  char what it does                        x        y   heading  stack
    0     F draw (+0.0000,-10.0000)        0.0000 -10.0000    1.5708      0
    1     [ remember here, and this way    0.0000 -10.0000    1.5708      1
    2     + turn, heading gains            0.0000 -10.0000    2.3562      1
    3     F draw (-7.0711,-7.0711)        -7.0711 -17.0711    2.3562      1
    4     ] back to where the [ was        0.0000 -10.0000    1.5708      0
    5     F draw (+0.0000,-10.0000)        0.0000 -20.0000    1.5708      0
    6     [ remember here, and this way    0.0000 -20.0000    1.5708      1
    7     - turn, heading loses            0.0000 -20.0000    0.7854      1
    8     F draw (+7.0711,-7.0711)         7.0711 -27.0711    0.7854      1
    9     ] back to where the [ was        0.0000 -20.0000    1.5708      0
   10     F draw (+0.0000,-10.0000)        0.0000 -30.0000    1.5708      0

Every number in that table was predictable before the run. The turn is an eighth of a turn, which the interlude in chapter 28 wrote as 0.7854 of rim, and a heading an eighth of a turn either side of straight up gives a movement of 7.0711 across and 7.0711 up: the 0.7071 from that chapter's very first table, multiplied by the ten-pixel segment. The turtle drew five lines and the string holds five Fs.

Read the last two columns together and the brackets tell their own story. The stack goes to 1 at index 1 and back to 0 at index 4, and the position and heading at index 4 are digit for digit what they were at index 1. Nothing between them left a trace on the turtle. That is the property the whole picture rests on: a branch may wander as far as it likes and the stalk it grew from does not notice, because the note taken at [ is restored whole at ].

// cmd/worldc/plant.go

// The three greens a stalk is drawn in, palette entries 10, 11 and 12.
// Depth is the count of brackets the turtle was inside, so the trunk
// takes the darkest and every branch off it is lighter than its parent
// until the ramp runs out.
var stalk = [3]render.Color{0xFF254C39, 0xFF4C7841, 0xFF90A858}

// twig picks the colour for one segment from how deep it was drawn.
func twig(depth int) render.Color {
	if depth >= len(stalk) {
		return stalk[len(stalk)-1]
	}
	return stalk[depth]
}

// draw paints one segment into the framebuffer. The turtle works in
// exact world pixels and the buffer holds whole ones, so the rounding
// happens here and nowhere earlier.
func draw(b *render.Buffer, cam render.Camera, s grow.Segment) {
	x0, y0 := cam.ToScreen(int(math.Round(s.A.X)), int(math.Round(s.A.Y)))
	x1, y1 := cam.ToScreen(int(math.Round(s.B.X)), int(math.Round(s.B.Y)))
	b.Line(x0, y0, x1, y1, twig(s.Depth))
}

// cmd/worldc/plant.go — once per plant, inside the loop over -at

		s, segs := p.Sprout(root)
		if forget {
			segs = readForgetting(s, root, p.Up, p.Seg, p.Turn)
		}
		deep, balanced := grow.Balanced(s)
		if !balanced {
			die(fmt.Errorf("%s generation %d: the brackets do not close", name, gen))
		}
		box := grow.Bounds(segs)
		for _, sg := range segs {
			draw(b, cam, sg)
		}

$ go run ./cmd/worldc -plant
plant: sprig at generation 3 on the soil of seed 5, segment 3.00 pixels, out of row 110
       axiom F, F -> F[+F]F[-F]F
    at x     turn        rim     chars   segments   deep     w by h
     152      1/8   0.785398       311        125      3    41 by 81
  frame sha256 a4f65b143c3d33782d387fb68cdb9dd88acd774ed85ff7c161e754ff4f19b510

p is one plant's parameters, the five fields this chapter takes apart, and readForgetting behind the -forget flag is an earlier draft of the turtle kept so the failure below can be run instead of described. The ground is generated once from seed 5, tiled once, and never touched again, and no random number is drawn anywhere in this run, so every machine that types that command gets that hash. Three of the printed numbers were known before the program ran. 311 characters and 125 segments are rows 3 of the census table. The height of 81 is the straight run, 3³ = 27 segments, at three pixels each.

What stands on the soil east of the pond is a bracken stalk: one dead-straight stem twenty-seven segments long, with side branches leaving it at regular intervals and smaller branches leaving those. It reads as a plant and it reads as a stiff one, and every stiff thing about it is a number somebody typed. The stem is straight because the rule puts three Fs outside its brackets and never a turn between them. The branches leave at exactly an eighth of a turn because a flag said 8. That the picture is a plant at all is the grammar's doing; that it is this plant is four numbers' doing.

// internal/grow/plant.go

// Plant is everything about one plant that is a number or a name: which
// grammar it grows by, how many times that grammar is applied, how far
// one F carries the turtle, how much rim one + or - adds, which way the
// first stalk sets off, and which seed a rule with a choice in it draws
// from. There is no picture anywhere in it, and no two of these
// fields have to be changed together.
type Plant struct {
	Axiom string
	Rules Rules
	Gen   int
	Seg   float64
	Turn  float64
	Up    float64
	Seed  uint64
}

// Sprout grows the string and reads it, in that order, and hands back
// both so a caller can print the one and draw the other.
func (p Plant) Sprout(at vec.Vec2) (string, []Segment) {
	rng := rand.New(rand.NewPCG(p.Seed, 33))
	s := p.Axiom
	for i := 0; i < p.Gen; i++ {
		s = Grow(s, p.Rules, rng)
	}
	return s, Read(s, at, p.Up, p.Seg, p.Turn)
}

$ go run ./cmd/worldc -plant -bare -at 48,96,144 -part 24,12,6 -base 120
plant: sprig at generation 3 on the bare frame, segment 3.00 pixels, out of row 120
       axiom F, F -> F[+F]F[-F]F
    at x     turn        rim     chars   segments   deep     w by h
      48     1/24   0.261799       311        125      3    17 by 81
      96     1/12   0.523599       311        125      3    31 by 81
     144      1/6   1.047198       311        125      3    47 by 81
  frame sha256 54bdff9a59a0034f8e3e2a4477b80e322cfbab4c186e894e112644a5ed86d720

go run ./cmd/worldc -plant -bare -at 48,96,144 -part 24,12,6 -base 120 -shot assets/frames/plant-three-turns.png

One field changed between those three plants and the ground was left out of the frame entirely, so the hash is a statement about the plants and nothing else. All three grew from the same 311 characters and drew the same 125 segments; what differs is one number in Turn, and the widths in the last column are 17, 31 and 47. The height is 81 in all three rows, and that is the grammar showing through: the main stalk never turns, so the turn size can only decide how far a branch reaches sideways, never how tall the plant gets. Height belongs to Gen and Seg; spread belongs to Turn; the three knobs do not fight.

$ go run ./cmd/worldc -plant -rules weed -gen 4 -seg 3 -part 10 -at 144
plant: weed at generation 4 on the soil of seed 5, segment 3.00 pixels, out of row 110
       axiom X, X -> F[+X]F[-X]+X, F -> FF
    at x     turn        rim     chars   segments   deep     w by h
     144     1/10   0.628319       491        130      4    62 by 84
  frame sha256 796fbead6be5d51533991dfad3226efa5237363d773b56d9405debfe6f7a963c

go run ./cmd/worldc -plant -rules weed -gen 4 -seg 3 -part 10 -at 144 -shot assets/frames/plant-valley.png