Speed Has a Price

// internal/beast/move.go

// Speed is how fast a creature is actually travelling, in cells a
// tick. The body moves in world pixels, because everything in this
// world that moves keeps its position in world pixels; the price of
// moving is written in cells, because cells are the unit this valley's
// distances come in. terra.Tile is the only place the two units meet.
func (c *Beast) Speed() float64 { return c.Body.Vel.Len() / terra.Tile }

// Rent is what a body of this kind costs a tick whatever it does: the
// basal rate charged on every gram of it.
func (k Kind) Rent() float64 { return k.Basal * k.Bulk }

// Effort is the movement work one tick at this speed comes to: the
// mass being moved, times the square of the speed it is moved at, with
// the speed in cells a tick. It is work and not yet energy, which is
// what the row's Work is for.
func (k Kind) Effort(speed float64) float64 { return k.Bulk * speed * speed }

// Travel is the energy one tick at this speed charges the store: the
// work that tick took, at the row's price for a unit of it.
func (k Kind) Travel(speed float64) float64 { return k.Work * k.Effort(speed) }

// Cross is what one whole cell of ground costs to get over at this
// speed, with the upkeep left out of it: the tick's charge divided by
// the cells that tick covered. One of the two speeds cancels, so this
// is a straight line up from nothing and not a curve.
func (k Kind) Cross(speed float64) float64 {
	if speed <= 0 {
		return math.Inf(1)
	}
	return k.Travel(speed) / speed
}

// Cost is what that same cell costs with the upkeep put back in: the
// work the legs did crossing it, plus the rent the body paid for the
// ticks it spent getting across. Going fast costs work and going slow
// costs time, and this is the one number that adds the two together.
func (k Kind) Cost(speed float64) float64 {
	if speed <= 0 {
		return math.Inf(1)
	}
	return k.Cross(speed) + k.Rent()/speed
}

// Cheapest is the speed at which Cost is least: the speed where the
// rent charged over one cell and the work charged over that cell come
// to the same number. Below it a creature pays more to exist than its
// legs are saving; above it the legs cost more than the clock does.
func (k Kind) Cheapest() float64 { return math.Sqrt(k.Rent() / (k.Work * k.Bulk)) }

$ go run ./cmd/pace -mode row
pace: the browser's row, and what it prices before a tick is taken

  bulk                      40.0000  grams of body
  a full store             400.0000  energy units
  basal                      0.0040  energy units a gram a tick
  work                       0.6000  energy units a unit of movement work
  top                        0.4500  cells a tick at a sprint

  standing still it is charged 0.1600 a tick, so a full store on its own
  covers 2500 ticks

  what one tick of travel costs at four speeds, what a cell costs at them,
  and how far a full store goes
                     cells    effort    a tick    a cell    all in     reach
  a crawl         0.020000    0.0160    0.0096    0.4800    8.4800   47.1698
  the cheapest    0.081650    0.2667    0.1600    1.9596    3.9192  102.0621
  a walk          0.225000    2.0250    1.2150    5.4000    6.1111   65.4545
  a sprint        0.450000    8.1000    4.8600   10.8000   11.1556   35.8566

  effort is bulk times the square of the speed; a tick is that at 0.60 a unit;
  a cell is the tick's charge spread over the cells the tick covered; all in
  adds the 0.1600 of rent those ticks also owed; reach is the cells a full
  store buys at that speed and nothing to eat on the way

  the cheapest speed is 0.081650 cells a tick, where the rent over a cell and the
  work over it are both 1.959592, and a cell costs 3.919184 all in
  crossing 12 cells at it costs 47.0302 against 73.3333 at a walk and 133.8667 at a sprint

  a full store would pay for 4.0817 cells a tick if the legs could deliver it,
  which is 9.07 times the 0.45 they can. The store stops paying for a sprint
  at 5.0200 units left, 0.0125 of a full one

Every figure in that table was worked out on paper two sections ago, and not one tick was taken to produce any of it. The reach column is the one to keep an eye on: a full store crosses 102 cells at the cheapest speed, 65 at a walk and 36 at a sprint, so a sprinting creature has about three valley widths in it before the store is empty and a cruising one has eight and a half. The last two lines are the other end of the same law. A full store would pay for 4.0817 cells a tick if legs existed that could deliver it, nine times what these legs can, so for almost all of a creature's life the body is the limit and the store is not.

// internal/beast/body.go — the line Beast gains

	field.Body         // where it is and how fast, in world pixels

That line has no field name in front of it, and the missing name is the point. An embedded struct lends its own fields to whatever it is embedded in, so a creature's position reads c.Pos and its velocity reads c.Vel, with no middle word to remember and no pair of one-line methods forwarding them by hand. The whole body is still there under its type name whenever something wants to hand the physics an entire body: c.Body. Name the field instead and only the second of those two spellings works, and every line that wants a velocity has to name the body before it can name the velocity.

Both files gain an import along with the line. body.go and beast.go have needed nothing but their own package until now; a body and the constructor below both name field, so each file gets import "theworld/internal/field" at the top. The compiler will say so if it is forgotten, and it is the only housekeeping this chapter adds.

A creature is now two things that have to agree about how heavy it is, so one call makes both. The store is filled from the row's Full and the body is built on the row's Bulk, and from the first tick the physics and the ledger are looking at the same forty grams.

// internal/beast/beast.go

// Spawn turns a row of numbers into one creature standing somewhere,
// with a full store and a body of the row's own mass. Every trait is
// copied into the individual and the row is never consulted for a rate
// again, so nothing one creature does can reach back and edit the kind
// it came from.
func (k Kind) Spawn(at field.Vec2, t int) *Beast {
	kind := k
	return &Beast{Name: k.Name, Kind: &kind, Store: k.Full,
		Body: field.NewBody(at, k.Bulk), Born: t}
}

The force is where a trap is waiting. Steering answers a request for a velocity with a vector: the velocity the body wants, less the velocity it has, cut down to a limit. The walkers that machinery was written for had a mass of one, and on a body of mass one a change in velocity and the force that buys it are the same number, so nobody ever had to say which of the two the limit was. On forty grams they part company at once. Hand a browser the walkers' cap of 0.3 and the acceleration it produces is 0.3 ÷ 40 = 0.0075 pixels a tick per tick, which needs 960 ticks to reach a sprint. The creature would spend a minute and a half getting up to speed.

// internal/beast/move.go

// Ramp is how many ticks a creature standing still takes to reach its
// top speed. It is what turns a top speed into the hardest push the
// legs can give, and it sits here rather than in the row because four
// tenths of a second is the same answer for everything in this valley
// that walks.
const Ramp = 4

// Afford is the fastest a creature could travel this tick without
// asking its store for more than the store holds: whatever is left
// after the rent it owes however it spends the tick, divided by the
// price of a unit of work and by the mass being moved, then square
// rooted, because that is what undoes the square in Effort.
func (c *Beast) Afford() float64 {
	left := c.Store - c.Kind.Rent()
	if left <= 0 {
		return 0
	}
	return math.Sqrt(left / (c.Kind.Work * c.Kind.Bulk))
}

// Pace is the fastest this creature may be asked to go this tick: the
// top speed its legs have, or the top speed its store will pay for,
// whichever of the two runs out first.
func (c *Beast) Pace() float64 { return math.Min(c.Kind.Top, c.Afford()) }

// Gait is what this creature can do about its own motion this tick, in
// the world pixels field.Gait steers in. It may aim at no velocity
// faster than its Pace, and it may change the velocity it has by no
// more than one Ramp's worth of its top speed in a tick. The second of
// those is a limit on acceleration and not on force, which is the
// whole reason Push exists.
func (c *Beast) Gait() field.Gait {
	return field.Gait{
		MaxSpeed: c.Pace() * terra.Tile,
		MaxForce: c.Kind.Top * terra.Tile / Ramp,
	}
}

// Push is the force the legs put into the accumulator to aim at a
// velocity. Three things happen to the velocity asked for. It is cut
// to the Pace this creature may travel at this tick, because
// field.Gait.Steer enforces its force limit and takes the desired
// velocity entirely on trust. The difference between what is left and
// the velocity the body has is cut to what a tick of legs can change.
// And the result is multiplied by the mass that has to be moved,
// because steering was written against bodies of one unit of mass,
// where a change in velocity and the force that buys it are the same
// number; on forty grams they are not, and the mass is the whole of
// the difference. That last line is field.Body.Weight's trick, done
// to a push instead of to a pull.
func (c *Beast) Push(want field.Vec2) field.Vec2 {
	g := c.Gait()
	if want.Len() > g.MaxSpeed {
		want = want.Unit().Scale(g.MaxSpeed)
	}
	return g.Steer(c.Body, want).Scale(c.Kind.Bulk)
}

Three limits, doing three different jobs. MaxForce here is an acceleration: a sprint is 0.45 × 16 = 7.2 pixels a tick, and a quarter of that is 1.8, so the legs may change a velocity by 1.8 pixels a tick in any one tick and a standstill becomes a sprint in four. MaxSpeed is the velocity a creature is allowed to aim for, which is where the store gets a vote. And the Scale at the end turns the whole thing from an acceleration into a force by multiplying by the mass, exactly the way a body turns a downward acceleration into its own weight. Leave that multiplication out and a heavy creature accelerates like a leaf.

The cut on want in the first two lines matters more than it looks. Steering cuts the force it produces and trusts the desired velocity it was handed, so a caller that asks for a sprint gets pushed toward a sprint whatever MaxSpeed says. Capping the request is the caller's job, and Push is the caller for every creature in this book.

// internal/beast/move.go

// Toll is what one tick took out of one creature's store, in the order
// the charges are worked out.
type Toll struct {
	Rent   float64 // energy the body charged for being a body
	Speed  float64 // cells a tick the body actually travelled
	Effort float64 // the movement work that speed came to
	Haul   float64 // energy that work charged
	Spent  float64 // the two charges added together
}

// Step is one tick of one creature's motion: whatever the tick piled
// into the accumulator moves the body, and then the store is charged
// for the two things a body costs, being one and moving one. The
// charge is worked out after the move because the speed being priced
// is the speed that did the moving, not the one the creature had
// before the tick's forces arrived.
func (c *Beast) Step() Toll {
	c.Body.Step()
	t := Toll{Rent: c.Kind.Rent(), Speed: c.Speed()}
	t.Effort = c.Kind.Effort(t.Speed)
	t.Haul = c.Kind.Travel(t.Speed)
	t.Spent = t.Rent + t.Haul
	c.Store -= t.Spent
	return t
}

// cmd/pace/main.go — the loop under every table in this chapter: ask
// for a velocity, push, step, print what the tick took

	for t := 1; t <= ticks && c.Store > 0; t++ {
		pace := c.Pace()
		c.Body.ApplyForce(c.Push(want))
		l := c.Step()
		fmt.Printf("  %5d %9.6f %9.4f %9.6f %9.4f %9.4f %9.4f %11.4f\n",
			t, pace, c.Body.Vel.Len(), l.Speed, l.Effort, l.Haul, l.Spent, c.Store)
	}

$ go run ./cmd/pace -mode hold -ticks 6
pace: one browser asked to hold 0.4500 cells a tick from a standstill
      that is 7.2000 world pixels a tick, and one tick of legs may change a
      velocity by 1.8000 pixels, so it is 4 ticks getting there
      opening store 400.0000

   tick      pace    pixels     cells    effort      haul     spent       store
      1  0.450000    1.8000  0.112500    0.5062    0.3037    0.4637    399.5362
      2  0.450000    3.6000  0.225000    2.0250    1.2150    1.3750    398.1612
      3  0.450000    5.4000  0.337500    4.5563    2.7338    2.8938    395.2675
      4  0.450000    7.2000  0.450000    8.1000    4.8600    5.0200    390.2475
      5  0.450000    7.2000  0.450000    8.1000    4.8600    5.0200    385.2275
      6  0.450000    7.2000  0.450000    8.1000    4.8600    5.0200    380.2075
  2.0250 cells covered, 19.7925 units spent, 380.2075 left

Four ticks of acceleration, exactly as the header predicted, and then a flat line at 5.0200 a tick. The square is visible in the haul column without any arithmetic. The second tick travels twice as fast as the first and its haul is four times as big, 0.3037 becoming 1.2150. The fourth travels four times as fast and its haul is sixteen times as big, 4.8600 against that same 0.3037, because four squared is sixteen. Six ticks of it bought 2.0250 cells of ground and cost 19.7925 units, which is 5% of everything the creature had.

The 5.0200 is a number to hold on to. It is the whole cost of one sprinting tick, rent included, and it is also the store at which a creature stops being able to sprint at all: below 0.160 + 4.86 units there is not enough left to pay for one tick of it. That is 1.25% of a full store, which is why Afford has been sitting in the code doing nothing visible. Ask a creature with three units left for a sprint and it becomes visible immediately.

$ go run ./cmd/pace -mode hold -store 3 -ticks 10
pace: one browser asked to hold 0.4500 cells a tick from a standstill
      that is 7.2000 world pixels a tick, and one tick of legs may change a
      velocity by 1.8000 pixels, so it is 4 ticks getting there
      opening store 3.0000

   tick      pace    pixels     cells    effort      haul     spent       store
      1  0.343996    1.8000  0.112500    0.5062    0.3037    0.4637      2.5362
      2  0.314659    3.6000  0.225000    2.0250    1.2150    1.3750      1.1613
      3  0.204252    3.2680  0.204252    1.6688    1.0013    1.1613      0.0000
  0.5418 cells covered, 3.0000 units spent, 0.0000 left

The request never changes: 0.45 cells a tick, every tick. What changes is the pace column, and it changes because the store is draining. On the first two ticks the legs are still the limit, since the body has not accelerated far enough for the cap to bite. On the third the cap is 0.204252 and the creature is held there, slower than it was going a tick earlier, because Push cut the request before steering ever saw it. And the store lands on 0.0000 to the last digit, which is not luck: Afford returns the speed whose charge is precisely what the store holds, so a creature cut down to its affordable speed has, by construction, exactly one tick left in it.

// cmd/pace/main.go

// cruise runs one creature east at a chosen speed until it has covered
// dist cells of ground, and hands back the ticks it took, the charges
// added up, and the creature itself.
func cruise(k beast.Kind, speed, dist float64) (int, beast.Toll, *beast.Beast) {
	c := k.Spawn(field.Vec2{}, 0)
	want := field.Vec2{X: speed * terra.Tile}
	var sum beast.Toll
	n := 0
	for c.Body.Pos.X < dist*terra.Tile && c.Store > 0 {
		c.Body.ApplyForce(c.Push(want))
		l := c.Step()
		sum.Rent += l.Rent
		sum.Effort += l.Effort
		sum.Haul += l.Haul
		sum.Spent += l.Spent
		n++
	}
	sum.Speed = c.Body.Pos.X / terra.Tile / float64(n)
	return n, sum, c
}

$ go run ./cmd/pace -mode race
pace: four browsers over the same 12 cells, one speed each
      every one of them starts still, with a full store of 400

                     asked   ticks      mean       got      rent      haul     spent      left
  a crawl         0.020000     601  0.020000   12.0200   96.1600    5.7696  101.9296  298.0704
  the cheapest    0.081650     147  0.081650   12.0025   23.5200   23.5200   47.0400  352.9600
  a walk          0.225000      54  0.222917   12.0375    8.6400   64.6988   73.3387  326.6612
  a sprint        0.450000      29  0.426724   12.3750    4.6400  130.6125  135.2525  264.7475

  mean is the cells covered divided by the ticks it took, which is under the
  speed asked for because the first ticks are spent getting up to it; got is
  how far it actually reached, and a run that stops short of 12 ran out

Four creatures, one valley width, and the fastest of them pays nearly three times what the cheapest pays to reach the same place. The sprinter is there in 29 ticks and hands over 135.2525 units; the cruiser takes 147 ticks, five times as long, and hands over 47.0400. Look at where each one's money went. The sprinter's bill is 96% legs. The cruiser's splits down the middle, 23.5200 of rent against 23.5200 of haul, which is the definition of the cheapest speed turning up in a measured run. And the crawler, slowest of the four, pays 101.9296 by being out in the open for 601 ticks: below the bottom of that curve, going slower costs more.

The paper prediction was 47.0302 at the cheapest, 73.3333 at a walk and 133.8667 at a sprint, and the run says 47.0400, 73.3387 and 135.2525. The gaps are small and they are explainable. A crossing has to end on a whole tick, so the sprinter actually covered 12.3750 cells instead of 12, and every creature spent its first ticks below the speed it asked for while the legs caught up. The prediction is what a creature already at speed pays. The run also pays for getting there.

Widen the valley and the arithmetic stops being about tactics.

$ go run ./cmd/pace -mode race -dist 100
pace: four browsers over the same 100 cells, one speed each
      every one of them starts still, with a full store of 400

                     asked   ticks      mean       got      rent      haul     spent      left
  a crawl         0.020000    2359  0.019992   47.1600  377.4400   22.6368  400.0768   -0.0768
  the cheapest    0.081650    1225  0.081650  100.0208  196.0000  196.0000  392.0000    8.0000
  a walk          0.225000     293  0.223799   65.5731   46.8800  353.3377  400.2177   -0.2177
  a sprint        0.450000      82  0.440969   36.1595   13.1200  386.8800  400.0000   -0.0000

  mean is the cells covered divided by the ticks it took, which is under the
  speed asked for because the first ticks are spent getting up to it; got is
  how far it actually reached, and a run that stops short of 100 ran out

One of the four arrives. The other three empty their stores on the way and stop where they stopped: the sprinter at 36.1595 cells, the walker at 65.5731, the crawler at 47.1600. Set those against the reach column from two sections back, which said 35.8566, 65.4545 and 47.1698 before a tick was taken, and the two lists agree to within the ticks each creature spent accelerating. A number computed from four constants said how far a creature could get on one meal, and four runs went out and got that far.

// cmd/pace/main.go — the walk that never eats. It asks for the same
// velocity every tick and records the two ticks on which its store
// stops covering something it used to be able to do.

	for c.Store > 0 {
		t++
		af, pace := c.Afford(), c.Pace()
		if sprint == 0 && af < k.Top {
			sprint = t
		}
		if slowed == 0 && af < walk {
			slowed = t
		}
		want := field.Vec2{X: walk * terra.Tile}
		c.Body.ApplyForce(c.Push(want))
		l := c.Step()
		if t%every == 0 || t == sprint || t == slowed || c.Store <= 0 {
			fmt.Printf("  %6d %9.4f %9.4f %9.6f %9.4f %11.6f\n",
				t, af, pace, l.Speed, l.Spent, c.Store)
		}
	}

$ go run ./cmd/pace -mode fade
pace: one browser walking at 0.2250 cells a tick with nothing to eat
      it is asked for that walk every tick, and gets whatever its store allows

    tick    afford      pace     cells     spent       store
      50    3.7270    0.4500  0.225000    1.3750  332.161250
     100    3.3206    0.4500  0.225000    1.3750  263.411250
     150    2.8568    0.4500  0.225000    1.3750  194.661250
     200    2.3015    0.4500  0.225000    1.3750  125.911250
     250    1.5596    0.4500  0.225000    1.3750   57.161250
     289    0.4449    0.4449  0.225000    1.3750    3.536250
     292    0.1615    0.1615  0.161536    0.7862    0.000000
     293    0.0000    0.0000  0.049036    0.2177   -0.217708

  it could not have sprinted from tick 289, and could not hold its own walk
  from tick 292. The store was empty on tick 293, 65.5731 cells from where it
  started, having spent 400.2177 of the 400 it opened with

For 288 of its 293 ticks this creature could have sprinted at any moment and never knew the store had anything to say about it. Then afford crosses 0.45 on tick 289 and the sprint quietly leaves the list of things it can do; three ticks later the walk goes the same way; on the last tick the store is empty and the creature is still drifting, still being charged, and 0.2177 units overdrawn. That final negative is not a rounding error. Momentum is not billed in advance: a body already moving keeps moving whether or not anything can pay for it, and the tick that catches up with it charges what it charges.