Winter Comes on Schedule

// internal/terra/year.go

// Year is one trip round the world's calendar, in ticks. It is the
// period of a single oscillator, and every seasonal number in the
// valley is a reading taken off that one angle.
const Year = 3600

// Quarter is the length of one season: four of them make the year.
const Quarter = Year / 4

// Seasons are the four quarters of the year, in the order they open.
var Seasons = [4]string{"spring", "summer", "autumn", "winter"}

// Season is the quarter tick t falls in.
func Season(t int) string { return Seasons[(((t%Year)+Year)%Year)/Quarter] }

// Angle is where on the rim the year stands at tick t. The angle is
// taken from the tick's place inside the year rather than accumulated,
// so a run that starts at year 40 opens on exactly the angle a run that
// started at year 0 reaches there.
func Angle(t int) float64 {
	return float64(((t%Year)+Year)%Year) * field.Turn / Year
}

// Reading is one weather number taken off the year's angle: a middle it
// sits at when the swing is nowhere, how far it swings either side, and
// how far round the rim its swing is shifted from the angle itself. A
// negative Lag is a reading whose peak arrives after the angle's does.
type Reading struct {
	Mid   float64
	Swing float64
	Lag   float64
}

// At is this reading at that angle: the height of a point standing Lag
// behind the year's own position, stretched to the swing and lifted to
// the middle.
func (r Reading) At(theta float64) float64 {
	return r.Mid + r.Swing*math.Sin(theta+r.Lag)
}

// Weather is the three readings the valley keeps its year by.
type Weather struct {
	Daylight Reading
	Warmth   Reading
	Rain     Reading
}

// Read takes all three readings at one angle, so no caller can take two
// of them at different places on the rim.
func (w Weather) Read(theta float64) (day, warm, wet float64) {
	return w.Daylight.At(theta), w.Warmth.At(theta), w.Rain.At(theta)
}

// Day is the valley's climate: the numbers this book runs with. The
// daylight swing is six tenths, so the longest day is 1.60 of an
// average one and the shortest is 0.40. Warmth lags an eighth of a turn
// behind the light. Rain is warmth's opposite, half a turn round from
// it, so the wet part of the year is the cold part.
var Day = Weather{
	Daylight: Reading{Mid: 1.00, Swing: 0.60, Lag: 0},
	Warmth:   Reading{Mid: 0.50, Swing: 0.50, Lag: -field.Turn / 8},
	Rain:     Reading{Mid: 1.00, Swing: 0.90, Lag: -field.Turn/8 + field.Turn/2},
}

Season is the line that turns a tick into a word. Divide the tick's place in the year by the length of a season and the answer is 0, 1, 2 or 3, which picks one of the four names, and that is where every spring and winter printed anywhere in this chapter comes from. The remainder is taken twice there, and in Angle above it, for a reason that only shows itself before tick 0. Go's % keeps the sign of the number on its left, so tick −1000 stays −1000, divides to −1, and indexes off the front of a four-name array, which Go answers by stopping the program. Add a whole year and take the remainder again and any tick, however far back, lands inside 0 to 3599.

Weather exists so that the three readings cannot be taken apart. Each of them would work perfectly well as a loose variable, and a valley holding three loose readings will one day take daylight at one angle and warmth at another, and run half a tick of summer against half a tick of autumn with nothing crashing and nothing to see. Read takes one angle and hands back all three, so there is no way to write that tick.

$ go run ./cmd/season -mode year
the year is 3600 ticks, and one angle gains 0.001745329 of rim a tick
    tick      angle       sin   daylight    warmth      rain  quarter opens
       0   0.000000    0.0000     1.0000    0.1464    1.6364  spring
     900   1.570796    1.0000     1.6000    0.8536    0.3636  summer
    1800   3.141593    0.0000     1.0000    0.8536    0.3636  autumn
    2700   4.712389   -1.0000     0.4000    0.1464    1.6364  winter
    3600   6.283185   -0.0000     1.0000    0.1464    1.6364
  warmth is highest at tick 1350 and rain at tick 3150
  species       cue    wakes    opens    shuts  ticks up
    herb    warmth     0.50      450     2251      1801
    tree  daylight     1.00        0     1801      1801

Every number in the daylight column was worked out above with a calculator, and so was every number in the two beside it. The sin column is there to make the claim checkable: it holds 0, 1, 0, −1 at the four quarter-days, which is chapter 28's table of eighths with every other entry left out. The last row is the same lesson that chapter closed on. π is not exact in a float64, so a whole turn is a hair under a whole turn, and the height at tick 3600 prints as -0.0000 where tick 0 prints 0.0000. The daylight, warmth and rain columns agree anyway, to four places.

$ go run ./cmd/season -mode year -eighths
the year is 3600 ticks, and one angle gains 0.001745329 of rim a tick
    tick      angle       sin   daylight    warmth      rain  quarter opens
       0   0.000000    0.0000     1.0000    0.1464    1.6364  spring
     450   0.785398    0.7071     1.4243    0.5000    1.0000
     900   1.570796    1.0000     1.6000    0.8536    0.3636  summer
    1350   2.356194    0.7071     1.4243    1.0000    0.1000
    1800   3.141593    0.0000     1.0000    0.8536    0.3636  autumn
    2250   3.926991   -0.7071     0.5757    0.5000    1.0000
    2700   4.712389   -1.0000     0.4000    0.1464    1.6364  winter
    3150   5.497787   -0.7071     0.5757    0.0000    1.9000
    3600   6.283185   -0.0000     1.0000    0.1464    1.6364
  warmth is highest at tick 1350 and rain at tick 3150
  species       cue    wakes    opens    shuts  ticks up
    herb    warmth     0.50      450     2251      1801
    tree  daylight     1.00        0     1801      1801

The eighths are where the lag shows itself. Warmth and rain both hit their extremes on the eighth-turn ticks and never on a quarter-day: warmth is 1.0000 at tick 1350 and 0.0000 at tick 3150, and rain is exactly the reverse of it, 0.1000 against 1.9000. That is what an eighth of a lag buys, and it is the whole reason the valley's hottest weeks are not its brightest ones. Daylight, taking its height on the angle itself, is symmetric about the solstice and reads 1.4243 twice.

// internal/terra/terra.go

// Grow is one tick of the ledger with the year in it. The three
// resources are priced and compared exactly as before; what the year
// changes is how fast the chemistry runs, so the income the smallest of
// them paid for is multiplied by the warmth and everything downstream
// follows from the smaller figure.
func (p *Plant) Grow(g Ground, warmth float64) Ledger {
	l := Ledger{}
	e, name := p.Limit(g)
	l.Caught, l.Limit = e*warmth, name
	l.Drawn = l.Caught * p.Thirst
	l.Ate = l.Caught * p.Hunger
	l.Paid = p.Mass * p.Upkeep
	l.Grown = l.Caught - l.Paid
	p.Mass += l.Grown
	return l
}

// Sleep is the tick a plant takes with its leaves down. It fixes
// nothing, draws nothing, and pays share of its usual upkeep out of the
// tissue it is standing up: spending less and earning none.
func (p *Plant) Sleep(share float64) Ledger {
	l := Ledger{Limit: "asleep"}
	l.Paid = p.Mass * p.Upkeep * share
	l.Grown = -l.Paid
	p.Mass += l.Grown
	return l
}

Two methods, and between them they are the entire annual-versus-perennial argument in arithmetic. Grow still charges upkeep at the full rate whether the plant is earning or not, so a plant holding its leaves up in cold weather pays the bill and collects almost nothing against it. Sleep collects nothing at all and cuts the bill by whatever share is. Dormancy is a slower burn with the income switched off instead of a pause, and whether that trade is useful depends entirely on how long the dark half lasts.

The tick below reads three things off a Stand that the last chapter left it no way to ask for. Here they are, smallest first.

// internal/terra/sky.go — one more line inside type Stand

	Sleep bool    // its leaves are down this tick

The flag is set once, at the top of every tick, out of the row's own calendar, and read twice after that. A stand with it up pays only the doze share of its upkeep and casts no shade at all. It is worked out fresh every tick and never carried across one, which is the only thing keeping it from being half a season out of date at the moment it matters.

// internal/terra/sky.go — and one more method on it

// Holds is the nutrient locked up in this stand's standing tissue.
func (st *Stand) Holds() float64 { return st.Plant.Mass * st.Plant.Hunger }

One multiplication, and the reason it is a method instead of that multiplication written out wherever it is wanted is that it is wanted in several places and they must never disagree with each other. A plant is standing up nutrient in proportion to the tissue it is standing up. The tick below asks for the figure on the line that buries a plant, the longer runs two chapters on ask for it on that same line and again whenever they add up what the valley is holding, and the last section of this page is about where the nutrient goes once the plant has let go of it.

// internal/terra/sky.go — the loop inside Cast, one line longer

	for _, i := range order {
		st := stands[i]
		st.Lit = s.At(st.At)
		if st.Sleep {
			continue // bare branches shade nothing
		}
		pass := st.Crown.Pass(st.Plant.Mass)
		for _, c := range s.Under(st.At, st.Crown.Crown) {
			s.Dim(c, pass)
		}
	}

Where that guard sits is the entire content of the change. It is after st.Lit = s.At(st.At), so a sleeping stand still takes its reading and skips only the writing, and both halves of that are deliberate. The light over a bare tree in the dark half of the year is still there, and the tree is still standing in it, so refusing it the reading would be inventing a darkness nothing casts. What it no longer does is put its own crown into the sky, because bare branches shade nothing, and the ground under a tree goes back to full daylight on the tick the leaves come down. Move the guard one line up and a dormant plant spends half the year on a number nobody wrote; move it one line down and the sky over the valley never notices that winter happened.

One line of the tick below asks every stand a question the row has to answer for itself: are this plant's leaves up at this place in the year? Two short functions answer it.

// internal/terra/species.go — the question the tick asks every row

// Awake reports whether this row has its leaves up at that place in the
// year, and the value of the reading it decided by.
func (s Species) Awake(w Weather, theta float64) (bool, float64) {
	v := w.Cue(s.Cue).At(theta)
	return v >= s.Wake, v
}

Two return values, and the tick keeps the first one. The boolean is the decision. The float beside it is the reading the decision was made on, the actual warmth or daylight at that angle, and it is there because a run that prints asleep and nothing else hands you nothing to check. Beside the threshold it was compared against, that number is a claim you can hold up to the curve you worked out with a calculator at the top of this page. The tick throws it away with up, _ :=. The tables keep it, and that is why the tables are believable.

// internal/terra/year.go — one more method on Weather

// Cue is the reading a species keeps its calendar by, named.
func (w Weather) Cue(name string) Reading {
	if name == "warmth" {
		return w.Warmth
	}
	return w.Daylight
}

Both halves of w.Cue(s.Cue) are spelled Cue and they are two different things. The one on the row is a string somebody typed when they wrote the species down; the one on the weather turns that string into a reading with a middle, a swing and a lag on it. The method is dull on purpose: two names, no validation, and anything that is not warmth gets daylight. A row with a typo in its cue therefore keeps a daylight calendar and runs a plausible-looking year. The cheapest guard against that is the cue column in the tables above, where every run prints the dial each row actually read.

// internal/terra/valley.go

// Tick advances the valley by one. The order is the whole design: read
// the calendar, settle who has leaves up, cast the light, let
// everything eat in a fixed order, bury whatever died, and only then
// let the weather work on the ground.
func (v *Valley) Tick() (day, warm, wet float64) {
	theta := Angle(v.Now)
	day, warm, wet = v.Climate.Read(theta)

	v.Sky.Full = v.Light * day
	for _, st := range v.Stands {
		up, _ := st.Kind.Awake(v.Climate, theta)
		st.Sleep = !up
	}
	Cast(v.Sky, v.Stands)

	for _, st := range v.Stands {
		var l Ledger
		if st.Sleep {
			l = st.Plant.Sleep(st.Kind.Doze)
		} else {
			g := v.Bed.Offer(st.At, st.Plant.Root, st.Lit)
			l = st.Plant.Grow(g, warm)
			v.Bed.Draw(st.At, st.Plant.Root, Cell{Moisture: l.Drawn, Nutrient: l.Ate})
			v.Built += l.Caught
		}
		// The tissue upkeep burned is gone as tissue, and the nutrient
		// that was locked in it is not: it falls where the plant stands.
		v.Burned += l.Paid
		v.Bed.Fall(st.At, Pile{Nutrient: l.Paid * st.Plant.Hunger})
		v.Fell += l.Paid * st.Plant.Hunger
		st.Last = l
	}

	live := v.Stands[:0]
	for _, st := range v.Stands {
		up, _ := st.Kind.Awake(v.Climate, theta)
		dead := st.Plant.Mass < st.Kind.Least || (st.Kind.Annual && !up)
		if !dead {
			live = append(live, st)
			continue
		}
		v.Bed.Fall(st.At, Pile{Mass: st.Plant.Mass, Nutrient: st.Holds()})
		v.Fell += st.Holds()
	}
	v.Stands = live

	v.Bed.Shower(v.Fall*wet, v.Full)
	v.Bed.Evaporate(v.Sun * warm)
	burned, back := v.Bed.Rot(v.Decay * warm)
	v.Rotted += burned
	v.Back += back

	v.Now++
	return day, warm, wet
}

Three placements in that function are decisions and not habits. The sleep flags are all settled before the caster runs, because a bare tree has to pass its light through on the same tick it drops its leaves and not on the one after. The death sweep runs after everything has eaten, so a plant that died this tick still paid this tick's bill and its tissue lands in the litter with the correct mass on it. And the weather comes last: rain, evaporation and rotting all work on the ground the plants have already finished with, so no plant drinks water that fell after it stopped drinking.

$ go run ./cmd/season -mode life -every 450
season: 12x8 valley from seed 5, 44 soil cells, 12.00 light on an average day
        rain 0.02 a cell an average day, sun lifts 0.01 at full warmth, litter rots 0.01000

    tick   season daylight  warmth    rain      tree  held by     herb    wet
       0   spring   1.0000  0.1464  1.6364     1.172    light    0.000   1.00
     450   spring   1.4243  0.5000  1.0000   120.569    light    2.842   1.00  the herb comes up
     900   summer   1.6000  0.8536  0.3636   309.870    light   57.527   0.99
    1350   summer   1.4243  1.0000  0.1000   418.494    light   51.947   0.93
    1800   autumn   1.0000  0.8536  0.3636   340.231    light   35.442   0.87
    1801   autumn   0.9990  0.8529  0.3647   340.197   asleep   36.226   0.87  the tree drops its leaves
    2250   autumn   0.5757  0.5000  1.0000   325.259   asleep   18.310   0.91
    2251   autumn   0.5750  0.4991  1.0016   325.227   asleep    0.000   0.91  the herb dies, 18.310 grams into the litter
    2700   winter   0.4000  0.1464  1.6364   310.946   asleep    0.000   0.97
    3150   winter   0.5757  0.0000  1.9000   297.263   asleep    0.000   1.00
    3599   winter   0.9990  0.1458  1.6375   284.211   asleep    0.000   1.00

One year, one seed of each, and the calendar has taken over the whole run. The tree climbs to 418.494 grams by tick 1350 and then loses mass through the back half of summer while its light is still falling, because its ceiling is income divided by upkeep and the income is now a moving number. The wet column is the average soil cell as a share of full: 1.00 through the wet spring, down to 0.87 as the rain fails and the sun works, back to 1.00 by midwinter. Nothing in that column ever limits anybody here, and the held by column says so by reading light on every tick the tree is awake.

// internal/terra/species.go — the third block of the row

	// the year
	Cue    string  // "daylight" or "warmth": the reading its calendar keeps
	Wake   float64 // the cue at or above which its leaves are up
	Doze   float64 // the share of its upkeep it still pays with them down
	Least  float64 // the mass below which there is not enough of it to live
	Annual bool    // true: the tick its window shuts is the tick it dies

// cmd/season/main.go

// The two species this chapter runs. Everything above the Cue line is
// the row the last chapter wrote; everything below it is what the plant
// does with a year.
var herb = terra.Species{
	Name: "herb",
	Seed: 1, Catch: 0.25, Thirst: 0.03, Hunger: 0.05, Upkeep: 0.05, Root: 1.5,
	Reach: 1.5, Leafy: 0.03, Tall: 0.01,
	Cue: "warmth", Wake: 0.50, Doze: 0, Least: 0.25, Annual: true,
}

var tree = terra.Species{
	Name: "tree",
	Seed: 1, Catch: 0.10, Thirst: 0.02, Hunger: 0.02, Upkeep: 0.004, Root: 2.5,
	Reach: 2.5, Leafy: 0.02, Tall: 0.02,
	Cue: "daylight", Wake: 1.00, Doze: 0.025, Least: 0.50, Annual: false,
}

Read the two Upkeep figures against each other and the rest follows. The herb charges itself 0.05 an hour on every gram, twelve times the tree's rate, so it climbs to its ceiling twelve times as fast and that ceiling is a twelfth as high. It is a plant built to convert a good season into as much tissue as possible and to be finished before the season is. The tree is built the opposite way round: cheap tissue, a low ceiling per unit of light, and a mass that takes hundreds of ticks to move. Expensive tissue makes a small plant quickly and cheap tissue makes a large one slowly, and a year with a hard winter in it is what turns that trade into two kinds of plant instead of one preference.

$ go run ./cmd/season -mode winter
a dormant tree pays 0.004 x 0.025 = 0.000100 of itself a tick
    tick   season     asleep         mass of what went in
       0   spring      false   398.575736     1.000000
     450   spring      false   186.022351     1.000000
     900   summer      false   320.650535     1.000000
    1350   summer      false   420.269752     1.000000
    1800   autumn      false   340.523443     1.000000
    2250   autumn       true   325.538821     0.955995
    2700   winter       true   311.213593     0.913927
    3150   winter       true   297.518742     0.873710
    3599   winter       true   284.454973     0.835346
  it slept from tick 1801, so 1799 ticks of paying 0.000100 of itself
  flat estimate: 1799 x 0.000100 = 0.179900 of it gone
  compounded:    0.999900 multiplied by itself 1799 times = 0.835346

The last column and the last line are the same six digits, 0.835346, one measured across 1799 ticks of a simulation and one worked out from two constants before the simulation started. That agreement is the point of doing the arithmetic first: a dormancy discount is not a feel, it is a number with a known effect over a known number of ticks, and any run that disagrees with it has a bug in it somewhere between the two.

The spring rows are the other half of the story. This tree was stood up at 400 grams, which is more than the cold months can carry, so it loses more than half of itself by tick 450 before the strengthening light turns it round. A perennial does not settle at one mass. It settles into a loop, and the loop's low point is the one that decides whether it is alive.

// internal/terra/bed.go

// Pile is what has died on one cell and not yet gone back into it. The
// two numbers are counted separately because they leave separately: the
// grams go off as the rotting burns them, and the nutrient goes down
// into the cell underneath.
type Pile struct {
	Mass     float64 // grams of dead tissue lying on the cell
	Nutrient float64 // nutrient units still locked up in it
}

// Rot works the same fraction off every pile in the valley and hands
// back what left each column. The nutrient goes straight into the cell
// the pile was lying on, with no cap on it: a cap would be a hole in
// the books, since the units it refused would be units nothing in the
// world is holding any more.
//
// The rate is a share of a pile per tick and is passed in already
// multiplied by the warmth, because rotting is something alive doing
// the work and cold weather slows it the way it slows every other
// chemistry in the valley.
func (b *Bed) Rot(rate float64) (burned, returned float64) {
	if rate <= 0 {
		return 0, 0
	}
	if rate > 1 {
		rate = 1
	}
	for i := range b.litter {
		p := &b.litter[i]
		m, n := p.Mass*rate, p.Nutrient*rate
		p.Mass -= m
		p.Nutrient -= n
		b.cells[i].Nutrient += n
		burned += m
		returned += n
	}
	return burned, returned
}

The comment about the cap is the whole reason this function is short. A soil cell caps its moisture, and it must, because rain that falls on saturated ground runs off and goes somewhere else in the world. Nutrient arriving from a pile is already in the world and already accounted for, so refusing it would delete it, and a ledger that balances is worth more than a cell that never exceeds a tidy maximum.

One line above says why a gram of tissue holds any nutrient at all. A gram was built out of one unit of fixed energy, and fixing one unit of energy cost Hunger units of nutrient, so a body of mass m is holding m × Hunger units and nothing has to accumulate that figure. When upkeep burns a gram, that gram's share falls onto the cell; when the plant dies, all of it does.

$ go run ./cmd/season -mode years -years 6
season: 12x8 valley from seed 5, 44 soil cells, 12.00 light on an average day
        rain 0.02 a cell an average day, sun lifts 0.01 at full warmth, litter rots 0.01000

   year tree spring tree autumn   winter  herb best      fell      back    litter      soil     books
      1       1.000     340.569   16.55%     58.140  243.3683  240.9471    2.4212  123.8946  0.000000
      2     284.211     340.777   16.55%     57.682  247.9215  247.9212    2.4215  123.8908 -0.000000
      3     284.384     340.778   16.55%     57.682  247.9239  247.9239    2.4215  123.8908 -0.000000
      4     284.384     340.778   16.55%     57.682  247.9239  247.9239    2.4215  123.8908  0.000000
      5     284.384     340.778   16.55%     57.682  247.9239  247.9239    2.4215  123.8908  0.000000
      6     284.384     340.778   16.55%     57.682  247.9239  247.9239    2.4215  123.8908  0.000000

  the books in grams              the books in nutrient units
    standing          284.3842      in living tissue      5.687684
    lying dead          2.8535      lying dead            2.421542
    burned          37330.0685      in the soil         123.890774
    rotted            107.0075      the valley opened   132.000000
    ever built      37724.3137      difference            0.000000
    difference        0.000000

Both differences are zero to six places, every year, and they are zero for different reasons. In grams, every gram ever manufactured is standing in a plant, lying in a pile, burned as upkeep, or rotted away, and 37724.3137 is exactly the four of them added up. In nutrient, the 132.000000 units the valley opened with (44 soil cells at 3.0 each) are still 132.000000, distributed across bodies, piles and soil. The second identity is the stronger one, because it is checkable against a number nobody computed from a run: the opening stock is a multiplication.

The fell and back columns are the ones to stare at. 247.9239 units go from bodies into the litter every year, and 247.9239 come back out of it, on a valley that owns 132.000000 units in total. The whole nutrient stock makes nearly two complete circuits a year. That is the number that decides how much can be alive here at once, and it is a rate and not a quantity: 132 units moving twice a year support a 340-gram tree and a 58-gram herb, where the same 132 units sitting still would support nothing at all.

$ go run ./cmd/season -mode frames -year 3
season: 12x8 valley from seed 5, 44 soil cells, 12.00 light on an average day
        rain 0.02 a cell an average day, sun lifts 0.01 at full warmth, litter rots 0.01000

    tick   season  daylight   warmth     rain      tree      herb  frame
   11250   spring    1.4243   0.5000   1.0000   167.056     2.747  e98e052b8edba852
   12150   summer    1.4243   1.0000   0.1000   419.755    51.834  2352314866533cfb
   13050   autumn    0.5757   0.5000   1.0000   325.458    18.310  fdba48ce1880cdd8
   13950   winter    0.5757   0.0000   1.9000   297.445     0.000  f54f16648b487429

Four frames from the middle of each season of the fourth year. A frame here is not a picture but everything a picture would have to be drawn from, folded down the way volume 3 folded a run of moving bodies: every cell's moisture and nutrient as raw float64 bits, big-endian, in row order, then the two totals lying dead on top of them, then each stand's cell and its mass in the order the valley holds them. The first eight bytes of that are what gets printed. The spring and summer frames share a daylight reading of 1.4243 and are nothing like the same valley: one has a 167-gram tree in leaf over a seedling, the other a 419-gram tree over a herb at 51.834 grams. The autumn and winter frames share the other 0.5757 and differ by a whole herb. A single number never identifies a moment in a year; the position on the rim does, and these four digests are what pins that to something a machine can check.

Add -art to any of those and the sky prints under each frame, one character a cell, as the share of the open daylight that reached it out of nine. Midsummer has a patch five cells across in it, deepest in the three the herb is standing in as well. In the autumn frame the tree's part of that patch is gone and the herb's three cells are all that is left of it, which is a bare tree turning from a claim about a boolean into something you can look at.