Eating What the Valley Grew

// internal/beast/beast.go
// Package beast keeps a creature's books. Package terra prices a plant:
// what a cell of ground offers in a tick, and what the thing rooted in
// it can afford out of that. This package prices an animal on the same
// two questions turned round: what a gram of body costs to keep, and
// what a mouthful of somebody else's tissue is worth. Nothing in here
// draws anything, nothing in here knows how long a tick is, and nothing
// in here draws a random number.
package beast

// Kind is one kind of creature written down as numbers, laid out the
// way terra.Species is: one flat row with nothing nested inside it, so
// two creatures of different kinds run the same code and differ only
// here. The first block is the body, the second is what a tick costs,
// the third is what it eats, and the fourth is what it is physically
// able to do.
type Kind struct {
	Name string

	// the body
	Bulk float64 // grams of body
	Full float64 // energy units the store holds when it is full

	// what a tick costs
	Basal float64 // energy units one gram of body costs a tick
	Work  float64 // energy units one unit of movement work costs

	// what it eats
	Bite    float64 // grams one bite takes off a stand
	Convert float64 // energy units one gram of eaten tissue is worth
	Reach   float64 // cells a bite reaches

	// what it is able to do
	Sight float64 // cells one line of sight runs
	Top   float64 // cells a tick at a sprint
	Swing float64 // the part of a whole turn one turn action covers
}

Read the four blocks as four questions. How much of it is there, and how much can it bank? What does a tick cost it standing still, and what does a unit of moving cost on top? What does one mouthful take off a plant, what is that mouthful worth once it is inside, and how far can the mouth reach? And how far can it see, how fast can it go, how far round can it turn. Work, Sight, Top and Swing are not charged anything on this page, and neither is Reach, because the creature here does not move and its food is under its feet. They are in the row because the row is the unit the rest of the volume passes around, and a struct that gains a field every time somebody needs one is a struct nobody can reason about.

// internal/beast/beast.go, continued
// Bill is the energy this kind's standing body charges it every tick,
// whatever the creature is doing with the tick: its bulk times what one
// gram of it costs. It is the plant's upkeep line with a different name
// on it.
func (k Kind) Bill() float64 { return k.Bulk * k.Basal }

// Mouthful is what one bite is worth once it is inside: the grams the
// bite takes off a stand, times the energy a gram of tissue turns into.
func (k Kind) Mouthful() float64 { return k.Bite * k.Convert }

// Fast is how many ticks a full store covers with nothing whatever
// coming in: the store divided by the bill. It is worked out from the
// row and never measured from a run.
func (k Kind) Fast() float64 { return k.Full / k.Bill() }

// Rhythm is how many ticks one bite pays for: the mouthful divided by
// the bill. Bite more often than this and the store fills; bite less
// often and it empties. The number says nothing about how full the
// store is: it is a fact about the kind, not about the afternoon.
func (k Kind) Rhythm() float64 { return k.Mouthful() / k.Bill() }

// Fauna is the valley's creature list, opened here with one row. A
// browser is an animal that takes small mouthfuls off standing plants
// and keeps taking them: it is the cheapest kind of eater to price,
// because nothing it does to its food is sudden.
var Fauna = []Kind{
	{
		Name: "browser",
		Bulk: 40, Full: 400,
		Basal: 0.004, Work: 0.60,
		Bite: 0.25, Convert: 4.0, Reach: 1.0,
		Sight: 12, Top: 0.45, Swing: 1.0 / 12,
	},
}

// Row is the kind of that name, and whether the table holds one.
func Row(name string) (Kind, bool) {
	for _, k := range Fauna {
		if k.Name == name {
			return k, true
		}
	}
	return Kind{}, false
}

$ go run ./cmd/graze -mode row
graze: the browser, ten numbers and what they come to

  Bulk         40.000  grams of body
  Full        400.000  energy units the store holds full
  Basal         0.004  energy units a gram of body costs a tick
  Work          0.600  energy units one unit of movement work costs
  Bite          0.250  grams one bite takes off a stand
  Convert       4.000  energy units a gram of eaten tissue is worth
  Reach         1.000  cells a bite reaches
  Sight        12.000  cells one line of sight runs
  Top           0.450  cells a tick at a sprint
  Swing         0.083  the part of a whole turn one turn action covers

  the bill      40.00 x 0.004 = 0.1600 energy units a tick
  one bite      0.25 x 4.000 = 1.0000 energy units
  a full store  400.0000 / 0.1600 = 2500.0000 ticks of standing still
  one bite      1.0000 / 0.1600 = 6.2500 ticks of standing still
  a full store is 400 bites, and 2500.0000 ticks is 0.6944 of a year of 3600

Not one of those four methods takes a tick, a world or a creature. They take a row and divide. Bill is the plant's upkeep line with a different name on it: a charge proportional to how much of the thing there is. Fast and Rhythm are the two divisions that turn that charge into time, and both are available before anything is standing anywhere. A browser weighs forty grams, each of which costs four thousandths of an energy unit a tick, so standing still costs it 0.1600 a tick. Four hundred units in a full store buys 2,500 of those ticks. One bite of a quarter of a gram, at four units a gram, is worth exactly one unit, so one bite buys 6.2500 ticks.

// internal/beast/body.go
package beast

import (
	"theworld/internal/terra"
)

// Beast is one creature: the row it was stamped from, and the store,
// which is the only number a tick changes. Everything else on it is a
// running total or a fact about when it started.
type Beast struct {
	Name  string
	Kind  *Kind
	Store float64 // energy units in the store right now
	Born  int     // the tick it was born on
	Ate   float64 // grams it has taken off the valley since it was born
	Dead  bool    // its store reached nothing and it stopped
	Last  Ledger

	// Greedy is the bite as it was first written: a whole mouthful
	// taken whether or not the plant has one to give. It is kept behind
	// a flag so the failure can be run instead of described, and it is
	// false in every creature this book ships.
	Greedy bool

	// Unpaid is the bite with the repayment switched off: the grams
	// still leave the plant, but the minerals they were holding go
	// nowhere instead of landing on the cell that lent them. It is
	// named for the ground's books and not for the animal, because a
	// creature carrying it eats exactly as it always did and the whole
	// of the loss is the bed's. It is kept behind a flag so what that
	// missing line costs can be run instead of described, and it is
	// false in every creature this book ships.
	Unpaid bool
}

// Ledger is one creature's tick, in the order the numbers are worked
// out.
type Ledger struct {
	Ate    float64 // grams taken off a stand
	Gained float64 // energy units those grams were worth
	Spilt  float64 // energy units of that the store had no room for
	Paid   float64 // energy units the standing body charged
	Left   float64 // what is in the store when the tick closes
}

Nothing in this file builds a creature for you. On this page one is a row and a number, and the bench writes both by hand: k := beast.Fauna[0] takes a copy of the row off the table, and &beast.Beast{Name: k.Name, Kind: &k, Store: k.Full} stands one up with a full store. The pointer goes to that copy and never into Fauna itself. A plant's Germinate is careful about the same thing for the same reason: an individual holding a pointer into the table can edit the kind it came from, and every other creature of that kind changes with it. The Ledger is five numbers in the order they get worked out, and it is returned instead of printed for the same reason a plant's is: the arithmetic and the reporting come apart, and the caller that wants a table and the caller that wants a census run the same tick underneath. Spilt is the line that keeps the energy honest. A store has a top, an animal that eats when it is already full gets nothing for it, and the units that did not fit have to be written down somewhere or they are units the world lost track of.

// internal/beast/body.go, continued
// Graze takes one bite off a stand and hands back the grams that
// actually moved. Nothing is manufactured here: the grams come off the
// plant's standing mass and no bite is bigger than the plant it is
// taken from.
//
// The grams and the minerals inside them leave in opposite directions.
// The grams go into the mouth, become energy in the store and are burned
// off as the body runs. The nutrient those grams were holding was
// borrowed out of the ground by the plant that built them, and it goes
// back onto the cell that plant is standing on the moment the bite is
// taken, through the same terra.Bed.Fall the plant's own burned upkeep
// goes through. Nothing charges a creature nutrient when it is stood up,
// so a creature has no nutrient account to hold the minerals in and
// never carries any: the loan was the plant's, and a bite repays it.
//
// A nil bed is a bench with one stand and one mouth and no valley
// underneath them, which is how the chapters that priced a bite ran it.
// There is no ground there to hand anything back to and nothing keeping
// nutrient books, so the bite is grams alone.
func (b *Beast) Graze(st *terra.Stand, bed *terra.Bed) float64 {
	grams := b.Kind.Bite
	if !b.Greedy && grams > st.Plant.Mass {
		grams = st.Plant.Mass
	}
	st.Plant.Mass -= grams
	if bed != nil && !b.Unpaid {
		bed.Fall(st.At, terra.Pile{Nutrient: grams * st.Plant.Hunger})
	}
	b.Ate += grams
	return grams
}

// Tick charges one creature one tick against one stand, or against
// nothing at all when st is nil, handing the bite the bed that stand is
// rooted in so the minerals it takes have ground to go back to. The
// order is the plant's order: income first, upkeep second, and whatever
// the upkeep leaves is what the creature carries into the next tick.
//
// The store is allowed past nothing. Clamping it at zero would be the
// world forgiving a bill, and a forgiven bill is energy nobody paid
// for; the creature is marked instead, and what it went under by stays
// on the ledger.
func (b *Beast) Tick(st *terra.Stand, bed *terra.Bed) Ledger {
	l := Ledger{}
	if st != nil {
		l.Ate = b.Graze(st, bed)
		l.Gained = l.Ate * b.Kind.Convert
		b.Store += l.Gained
		if b.Store > b.Kind.Full {
			l.Spilt = b.Store - b.Kind.Full
			b.Store = b.Kind.Full
		}
	}
	l.Paid = b.Kind.Bill()
	b.Store -= l.Paid
	if b.Store <= 0 {
		b.Dead = true
	}
	l.Left = b.Store
	b.Last = l
	return l
}

$ go run ./cmd/graze -mode starve -ticks 3000 -every 250
graze: one browser with nothing to eat, 400.00 in the store, 0.1600 charged a tick
       the row says it runs out after 400.0000 / 0.1600 = 2500.0000 ticks

    tick       paid      store   ticks left
     250     0.1600   360.0000    2250.0000
     500     0.1600   320.0000    2000.0000
     750     0.1600   280.0000    1750.0000
    1000     0.1600   240.0000    1500.0000
    1250     0.1600   200.0000    1250.0000
    1500     0.1600   160.0000    1000.0000
    1750     0.1600   120.0000     750.0000
    2000     0.1600    80.0000     500.0000
    2250     0.1600    40.0000     250.0000
    2500     0.1600    -0.0000      -0.0000

  the store reached nothing on tick 2500, having paid 400.0000 in all
  the last subtraction left -1.7737e-11 rather than exactly nothing
  that is 0.6944 of a year of 3600 ticks: full in spring, gone in autumn

The prediction is on the second line of output, before a tick has been taken, and the table walks to it in a straight line: 40.0000 units gone every 250 ticks, ten of those, and the store is empty. The right-hand column is the same number read as time, and it counts down as evenly as the store does. Nothing here is a curve. A plant's growth bends because its upkeep is charged on a mass that keeps changing; a starving creature's body does not change, so its bill does not either, and the line is straight.

Two details in that run are the code being careful. The last subtraction leaves −1.7737e−11 and not nothing, because 0.16 is not a number binary holds exactly and 2,500 of them do not add back to 400 in the last few bits. That is why the test in Tick is written as at or under nothing instead of equal to nothing, and it is also why the residue is printed: it lands on the same side of zero on every machine, so the creature dies on tick 2,500 everywhere. And the store is left holding that residue instead of being clamped to zero. Clamping would be the world forgiving a bill, and a forgiven bill is energy that nobody paid for and nobody wrote down.

One line of Graze has nothing to do with the store. A gram of leaf is two things at once: tissue a mouth can burn, and the nutrient a root drew out of the bed to build that tissue with. The mouth wants only the first. So the bite hands the second straight back, as a pile carrying minerals and no mass, onto the cell the plant is standing on, through the same terra.Bed.Fall that plant's own burned upkeep has gone through since the terrarium learned to rot. The figure is grams * st.Plant.Hunger, which is what the terrarium already calls the nutrient locked up in that much of that row's tissue. Nothing ever charges a creature nutrient, not for the body it was stood up with and not for a mouthful, so it has no account to hold minerals in and carrying them about would mean opening one. The flag on that line is Unpaid, and it is named for the ground and not for the animal: a creature carrying it eats exactly what it always ate, and every unit that goes missing goes missing from the bed. Like Greedy it is false in everything this book ships, and it is there so that what one line of handback is holding up can be measured instead of asserted.

On this page the bed is always nil, and that is what a nil bed means: a bench holding one stand and one mouth and no valley underneath them. There is no ground to hand anything back to and nothing keeping nutrient books, so the bite is grams alone. The starvation run above never takes one, and the browsing bench further down takes thousands with nothing under the plant but the numbers the bench made up. A creature standing in The Hollow is handed the real bed, and the minerals land on it.

// cmd/graze/main.go — the bench's tick: the plant eats, then the animal
// bites and gone are the bench function's own named results, and the loop
// below is quoted at the indentation it has inside that function
	for t := 1; t <= ticks; t++ {
		st.Plant.Grow(g, 1)
		if b.Dead {
			continue
		}
		if n > 0 && (t-1)%n == 0 {
			b.Tick(st, nil)
			bites++
		} else {
			b.Tick(nil, nil)
		}
		if b.Dead {
			gone = t
		}
	}

$ go run ./cmd/graze -mode browse -ticks 3000 -store 100
graze: one browser on one scrub, 12.00 light and 2.50 water a tick
       the plant fixes 1.4400 a tick, light-limited, and tops out at 180.0000 grams
       the creature is charged 0.1600 a tick and one bite is worth 1.0000,
       so one bite every 6.2500 ticks is the rhythm that pays for itself

    a bite    bites      grams      plant    settles      store     died      drift
     every    taken      eaten      grams         at       left  on tick     a tick
         1     3000   750.0000   148.7500   148.7500   399.8400        -     0.8400
         2     1500   375.0000   164.4378   164.3750   399.6800        -     0.3400
         4      750   187.5000   172.2814   172.1875   370.0000        -     0.0900
         6      500   125.0000   174.8957   174.7917   120.0000        -     0.0067
         7      429   107.2500   175.5363   175.5357    49.0000        -    -0.0171
         8      358    89.5000   178.7263   176.0938    -0.0800     2863    -0.0350
        12      109    27.2500   180.0000   177.3958    -0.1200     1307    -0.0767
         0        0     0.0000   180.0000   180.0000    -0.1600      626    -0.1600

  settles at is worked out, not measured: (1.4400 - bite/every) / 0.0080
  drift a tick is the same: 1.0000 / every - 0.1600
  a creature that died stopped biting; the plant kept growing to tick 3000

Two columns of that table are predictions and the rest are measurements, and the point of the run is how close they sit. settles at is the mass where the scrub's income covers its own upkeep and the browsing together, worked out as (1.4400 − bite ÷ every) ÷ 0.0080 with nothing measured in it. At one bite a tick the prediction is 148.7500 grams and the plant is standing at 148.7500. At one bite every seven it predicts 175.5357 and measures 175.5363. The gaps in between come from lumpiness: a plant losing a quarter of a gram every seventh tick is never quite at the mass a smooth drain would hold it at, and the coarser the rhythm the wider it swings.

The drift column is the other prediction, and it is where the 6.2500 from the row does its work. One bite every six ticks earns 0.1667 a tick against a bill of 0.1600, so the store creeps up by 0.0067 a tick: over three thousand ticks that is a climb from 100 to 120.0000, which is what the run shows. One bite every seven earns 0.1429 against the same bill, drifts down 0.0171 a tick, and the store falls from 100 to 49.0000. Between six and seven lies 6.25, and nothing about the plant, the light or the store decides where that line falls. Two numbers on the row do.

The last three rows are the same arithmetic run past the point where it holds. At one bite every eight the store is falling 0.0350 a tick and the creature reaches nothing on tick 2863; at every twelfth tick it falls 0.0767 and stops on tick 1307; taking nothing at all it falls the whole 0.1600 and stops on 626. That last figure deserves a second look, because 100 ÷ 0.16 is 625 and not 626. The subtraction that should have landed on nothing at tick 625 landed 1.4e−12 above it instead, the creature was not yet under, and it bought one more tick. The residue fell the other way in the run before this one, where a full store emptied on 2,500 exactly.

$ go run ./cmd/graze -mode valley -years 1000
graze: seed 5, 1000 years, brake 1 on K = 75, creep 0.0010, rim walled and cracked
       internal/beast is in the module and nothing in the valley imports it

  world df1c117e69bdf157, census 75c77a67f6f430bb after 3600000 ticks
  2662.2 grams standing on 44 plants
  that is 10649 bites of 0.25 grams, and 66555 ticks of one browser standing still
  or 18.49 years of one, in a valley that took 1000 to grow it

Both digests match the ones the terrarium closed on: the world digest over the bed's two numbers per cell and every stand's cell and mass, and the census digest folded over all thousand midsummers. A package that draws no random numbers cannot move a valley, and this is what that looks like when it is checked instead of asserted. The last two lines are the hinge in one figure. Everything standing in The Hollow after a thousand years comes to 10,649 mouthfuls, which is 66,555 ticks of one browser doing nothing at all, which is eighteen and a half years of one animal. A millennium of light, arithmetic and weather, spent in under two decades by a single forty-gram body that never moves.

Neither count is whole before it is printed, and the bench rounds them in opposite directions on purpose: 2,662.2 grams is 10,648.8 bites, and the bites round up because the last bite of a stand takes whatever is left of it and that part-bite still has to be taken, while the ticks truncate because a fraction of a tick buys the browser nothing. Floor them both and the line reads 10,648 instead. The rule sits in the comment over the two lines that print those counts, so a reader who redoes the division on 2,662.2 finds the answer beside the arithmetic that produced it.