Drawing the Neighbours

Create internal/village/face.go. The counts are the sheet's grammar, the way TileCols and CellSoilA were the tileset's: nothing downstream parses folk.png to find out what is on it. They live in village and not in render, because the question they answer is about a person, and render does not know what a person is.

// internal/village/face.go
package village

import (
	"theworld/internal/gene"
	"theworld/internal/render"
)

// A villager's face is worked out from the row every time it is drawn
// and is stored nowhere. Nothing on Person names a head, a hair or a
// colour, exactly as nothing on beast.Beast names a coat: appearance is
// derived from the record, and a record that has not changed cannot be
// drawn two ways.
//
// The face is four parts laid over one another, each one cell of
// assets/sprites/folk.png: a head, a pair of eyes, a mouth, and the
// hair, in that order, so the hair falls over the brow rather than
// under it. The sheet holds one row a kind, Across cells wide, and the
// rows are in the order the parts are laid down.
const (
	Cell   = 16 // a part is this many pixels on a side, and so is a face
	Heads  = 4
	Eyes   = 4
	Mouths = 4
	Hairs  = 6
	Tints  = 8
	Faces  = Heads * Eyes * Mouths * Hairs * Tints // 3072
	Across = Hairs                                 // the longest row is the sheet's width
)

// The rows of the sheet, one kind of part each, top to bottom.
const (
	HeadRow = iota
	EyesRow
	MouthRow
	HairRow
	Rows
)

// Radix is how many of each part there are, in the order a face's
// number is peeled: the head is the lowest digit and the colouring the
// highest. A face is one number under Faces, and this is its base.
var Radix = [5]int{Heads, Eyes, Mouths, Hairs, Tints}

// Strip is the sheet's own palette: seven of the valley's sixteen, in
// the order the strip lists them. Every pixel of every part on the
// sheet is one of these, and a colouring is a substitution on them.
var Strip = [7]int{gene.Ink, gene.SoilD, gene.SoilM, gene.SoilL, gene.RockD, gene.RockM, gene.Bone}

// What each entry of the strip is on the sheet, by its position in
// Strip. Line and White are fixed points of every colouring: an
// outline is ink whoever wears it, and an eye's white is bone.
const (
	Line  = iota // every outline, every pupil, every mouth
	SkinD        // the skin's shadow: under the chin, the far cheek, the nose's side
	SkinM        // most of the face
	SkinL        // the lit brow and cheek
	HairD        // the hair's sides and underside
	HairL        // the crown, which the light reaches first
	White        // the eye's white, and teeth
)

village now imports gene, and the import is for one thing: gene.Sixteen is where the palette has been read out of its file since the creature sheet, and a palette written down twice can disagree with itself. Nothing about a genome crosses. Tints is eight and Faces is 3072, and both are explained further down, where the colourings are; the constants are here because the sheet is drawn to them.

Create cmd/mkfolk/art.go. Every pixel is a letter, a letter is an entry of the strip, and a space is a pixel that is not there, so a part is mostly space: a pair of eyes is six pixels of a cell of two hundred and fifty-six, and everything else in the cell lets the head show through. Four of the eighteen are printed here in full; the other fourteen are in the same form, and figure 99.1 shows all of them.

// cmd/mkfolk/art.go
//
//	o  outline      ink, never remapped: every edge, every pupil, every mouth
//	s  skin shadow  the far cheek, the side of the nose, under the chin
//	k  skin midtone most of the face
//	l  skin lit     the brow and the near cheek, where the light lands first
//	h  hair dark    the sides and the underside
//	H  hair lit     the crown
//	e  white        the eye's white, and teeth

// ...

// roundHead is the founding face: a skull that closes on row 2, ears
// on rows 6 and 7, cheeks that come in one column a row from row 10,
// and a chin on row 12. The eye line is row 7 and the mouth line row
// 10, which every head keeps, and the near cheek carries the one lit
// pixel the hair does not cover.
var roundHead = []string{
	"                ",
	"                ",
	"     oooooo     ",
	"    olkkkkko    ",
	"   olkkkkkkso   ",
	"   okkkkkkkso   ",
	"  okkkkkkkkkso  ",
	"  okkkkkkkkkso  ",
	"   okkkkskkso   ",
	"   olkkkskkso   ",
	"   okkkkkkkso   ",
	"    okkkksso    ",
	"     oooooo     ",
	"      osso      ",
	"      okko      ",
	"      oooo      ",
}

// ...

// openEyes are six pixels: white, pupil, white, twice, two pixels
// apart on row 7. Three pixels is the least an eye can be and still
// have a white on both sides of its pupil.
var openEyes = []string{
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"    eoe  eoe    ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
}

// ...

// smileMouth is the line with a pixel raised at each end, on row 9.
var smileMouth = []string{
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
	"     o    o     ",
	"      oooo      ",
	"                ",
	"                ",
	"                ",
	"                ",
	"                ",
}

// ...

// longHair falls to row 13 down both sides, outside the face at
// columns 2 and 3 and 12 and 13. It once sat one column further in and
// took the outer white off each eye; a test in this directory now
// composes every hair over every pair of eyes and refuses that.
var longHair = []string{
	"                ",
	"     oooooo     ",
	"    oHHHHhho    ",
	"  oHHHHhhhhhho  ",
	"  oHH      hho  ",
	"  oHh      hho  ",
	"  oH        ho  ",
	"  oH        ho  ",
	"  oH        ho  ",
	"  oh        ho  ",
	"  oh        ho  ",
	"  oh        ho  ",
	"  oho      oho  ",
	"  ooo      ooo  ",
	"                ",
	"                ",
}

// ...

Read the round head against the rules. The outline is closed all the way round, ink on every boundary pixel, so the face sits on any background; the far cheek at column 11 and the neck under the chin are shadow, the second of those because the chin is above it and not because of the angle; the nose is two pixels of shadow down its right side at rows 8 and 9; and the lit pixels are the upper-left brow and the near cheek at row 9, which is the one lit pixel a fringe cannot reach. The long hair has its own outline and its own row 1, so it covers the head's row 2 instead of joining it, and its sides run down columns 2 and 3, outside the face, with a lit strand on the near side where the crown's light continues.

Create cmd/mkfolk/main.go. Painting a part into the sheet is a lookup and a Set, and the lookup is the part that matters: a character with no strip entry behind it stops the program instead of putting a colour nobody chose into an asset. The array types are the second check, and it is free: a row with one part too many or too few does not compile.

// cmd/mkfolk/main.go
var key = []struct {
	ch   byte
	at   int
	what string
}{
	{'o', village.Line, "outline"},
	{'s', village.SkinD, "skin shadow"},
	{'k', village.SkinM, "skin midtone"},
	{'l', village.SkinL, "skin lit"},
	{'h', village.HairD, "hair dark"},
	{'H', village.HairL, "hair lit"},
	{'e', village.White, "white"},
}

// The four rows of the sheet, each the parts of one kind in the order
// the row holds them, and what each part is called when a run has to
// say which it picked. The array sizes are the package's counts, so a
// row with one part too many or too few does not compile.
var (
	heads  = [village.Heads][]string{roundHead, longHead, squareHead, narrowHead}
	eyes   = [village.Eyes][]string{openEyes, asideEyes, wideEyes, liddedEyes}
	mouths = [village.Mouths][]string{lineMouth, smileMouth, frownMouth, grinMouth}
	hairs  = [village.Hairs][]string{cropHair, longHair, bunHair, fringeHair, sweptHair, bareHair}

	// ...
)

// ...

// colour is the valley colour a strip position is drawn in.
func colour(pos int) render.Color {
	return gene.Sixteen[village.Strip[pos]]
}

// ...

// paint writes one mask into the sheet at a cell.
func paint(sh *render.Buffer, col, row int, mask []string) {
	if len(mask) != village.Cell {
		die(fmt.Errorf("row %d cell %d has %d rows, want %d", row, col, len(mask), village.Cell))
	}
	for y, line := range mask {
		if len(line) != village.Cell {
			die(fmt.Errorf("row %d cell %d line %d is %d characters, want %d", row, col, y, len(line), village.Cell))
		}
		for x := 0; x < village.Cell; x++ {
			ch := line[x]
			if ch == ' ' {
				continue
			}
			pos, ok := at(ch)
			if !ok {
				die(fmt.Errorf("row %d cell %d line %d: no palette entry for %q", row, col, y, ch))
			}
			sh.Set(col*village.Cell+x, row*village.Cell+y, colour(pos))
		}
	}
}

// ...

// build paints the whole sheet and the strip.
func build() (*render.Buffer, *render.Buffer) {
	sheet := render.NewBuffer(village.Across*village.Cell, village.Rows*village.Cell)
	for row, parts := range rows() {
		for col, mask := range parts {
			paint(sheet, col, row, mask)
		}
	}
	strip := render.NewBuffer(len(key), 1)
	for i, k := range key {
		strip.Set(i, 0, colour(k.at))
	}
	return sheet, strip
}

$ go run ./cmd/mkfolk -to .
mkfolk: folk.png, 96x64, 4 rows of parts across 6 cells at 16 pixels, 845 bytes
  pixels sha256 9bf56629912881799d6e6403038a4f2183defe4aa60ea47237a3913925621b76

  the seven entries the sheet is drawn in, by their index in the valley's sixteen
    o  entry  0  181A29  outline
    s  entry  1  4C2F22  skin shadow
    k  entry  2  75563B  skin midtone
    l  entry  3  A1875A  skin lit
    h  entry  4  323847  hair dark
    H  entry  5  5A6470  hair lit
    e  entry 15  F5EBD7  white

  part            drawn  outline   skin   hair  white
    round head      114       38     76      0      0
    long head       104       38     66      0      0
    square head     124       44     80      0      0
    narrow head     109       36     73      0      0
    open eye          6        2      0      0      4
    aside eye         6        2      0      0      4
    wide eye         12        2      0      0     10
    lidded eye       12        8      0      0      4
    line mouth        4        4      0      0      0
    smile mouth       6        6      0      0      0
    frown mouth       6        6      0      0      0
    grin mouth        6        2      0      0      4
    crop hair        34       14      0     20      0
    long hair        74       36      0     38      0
    bun hair         36       14      0     22      0
    fringe hair      68       26      0     42      0
    swept hair       34       13      0     21      0
    bare hair        16        8      0      8      0
  3072 faces the sheet can make: 4 heads x 4 eyes x 4 mouths x 6 hair x 8 colourings

mkfolk: folk-7.png, 7x1, 7 entries, 92 bytes
  pixels sha256 50f170e5c379f76d3762ba89ab2a49e64b3b5dbd26db13ae70ef3ca13d52c0a8
  pixels on the sheet the strip does not hold: 0
  folk.png is byte for byte assets/sprites/folk.png
  folk-7.png is byte for byte assets/palette/folk-7.png

Two files come out. The sheet is ninety-six pixels by sixty-four: six cells across and four rows down, with the two cells the shorter rows do not use left empty, and the count of what each row holds in the code and not in the picture. The strip is seven pixels by one, one pixel an entry, the form the valley palette and the creature strip have shipped in since they were chosen, so that the sheet's palette is a file a reader can diff. Run with -to naming a directory, the program writes the pair there and compares them with the pair the book ships, and the last two lines are the whole reason the sheet is code: nobody has to trust that the committed file is what the table makes, because the program says so every time it runs. The tally is what the parts weigh. A head is a hundred and four to a hundred and twenty-four pixels; the other three kinds together add between twenty-six and ninety-two, and the smallest part on the sheet, the line of a mouth, is four.

The sheet is mostly not there, so the picture of it is the sheet laid on a field of open water with a line of rock between the cells, written out at four times by -mode parts. The field and the rule are entries of the sixteen no face is drawn in, so nothing in the picture is a part that is not one.

$ go run ./cmd/mkfolk -mode parts -shot assets/frames/folk-parts.png
mkfolk: the sheet on a field, one cell a part, 103 by 69 pixels, c581890205440a60d7a8634fe8ed6372d73e2af202d0e83ed7cf615640102e72
  wrote assets/frames/folk-parts.png at 4 times, 412 by 276

$ go run ./cmd/mkfolk -mode small
mkfolk: the parts at 16 pixels, the size they were drawn, and sampled to 12

  kind     at 16  closest pair, and by how much   at 12  closest pair, and by how much
  heads       16  round and square                    3  round and square
  eyes         4  open and aside                      0  open and aside
  mouths       2  line and smile                      0  line and frown
  hair        11  crop and bun                        6  crop and swept

  the four pairs of eyes at 16, rows 5 to 8, one character a pixel, and the four mouths, rows 8 to 12
     5  ....................................................................
     6  ......................................eee..eee.........ooo..ooo.....
     7  ....eoe..eoe.........oee..oee.........eoe..eoe.........eoe..eoe.....
     8  ....................................................................
     8  ....................................................................
     9  ......................o....o........................................
    10  ......oooo.............oooo.............oooo............oeeeeo......
    11  .......................................o....o.......................
    12  ....................................................................

  the eyes sampled to 12, rows 3 to 5: the sampler reads source row y*16/12 and never reads rows [3 7 11 15]
     3  ....................................................
     4  ....................................................
     5  .............................eee.ee.......ooo.oo....

At sixteen, the smallest difference the library carries is two pixels: the line and the smile differ by the two raised corners on row 9, and the four pairs of eyes are never closer than four. On a screen that draws a frame pixel four pixels wide, which is how volume 2 opened the window, two pixels of difference is a mark eight screen pixels long, and the smile reads. At one pixel to one, the size of a full stop on this page, what reads is the hair and the colouring; the eyes are two dots and the mouth is a dash, and that is what the inspector under figure 99.1 is for.

Sampled to twelve, the table says what twelve costs, and it costs rows. The sampler reads source row y × 16 / 12 for each of its twelve rows, which reaches rows 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13 and 14 and never rows 3, 7, 11 or 15. Row 7 is the eye line. Two of the four pairs of eyes are drawn on row 7 alone, so at twelve they are not there, and the closest pair of eyes differs by nought; the line and the frown differ on row 11 alone, so they are the same mouth. A hand-drawn twelve would place its pixels better than a sampler does, and it would still have one pixel for an eye and no room for a white on either side of it. Sixteen is the size at which an eye can be three pixels, and that is the whole of the argument for it.

$ go test -count=1 ./cmd/mkfolk/ -run 'TestEveryPartIsSixteenSquareAndDrawnInTheStrip|TestEveryHeadHasSkinUnderTheEyesAndTheMouth|TestNoHairCoversAnEyeOrAMouth' -v
=== RUN   TestEveryPartIsSixteenSquareAndDrawnInTheStrip
--- PASS: TestEveryPartIsSixteenSquareAndDrawnInTheStrip (0.00s)
=== RUN   TestEveryHeadHasSkinUnderTheEyesAndTheMouth
--- PASS: TestEveryHeadHasSkinUnderTheEyesAndTheMouth (0.00s)
=== RUN   TestNoHairCoversAnEyeOrAMouth
--- PASS: TestNoHairCoversAnEyeOrAMouth (0.00s)
PASS
ok  	theworld/cmd/mkfolk	0.006s

The first of the three is paint's three refusals as a test, so a character outside the strip is caught before the program that would refuse it is run. The other two are the drawing rules above, held where a rule about pixels belongs: beside the pixels, in the directory that holds the table.

Extend internal/village/face.go. Steps returns every turn so a bench can print the derivation and a reader can check it line by line; Key is its last value; FaceOf is the whole derivation, a row in and a face out, with no state anywhere; and Index is the peel run backwards, which a test walks for all 3072 numbers.

// internal/village/face.go — add below the strip's positions

// Face is which cell of each row a villager is drawn from, and which
// colouring the cells are put through. It is worked out from a Person
// by FaceOf and is never written back.
type Face struct {
	Head, Eyes, Mouth, Hair, Tint int
}

// The fold. A key is built from the row's fields by the oldest string
// hash there is: multiply what you have by Mult, add the next value,
// keep the remainder on division by Mod. The multiplier is small enough
// to work by hand and the modulus is the largest prime under 65536,
// prime because a multiplier and a modulus that share factors cycle:
// folded with the remainder taken on Faces instead, the letters "Ha"
// and "Hall" come to the same number.
const (
	Mult = 31
	Mod  = 65521
)

// Step is one turn of the fold, kept so a bench can print the whole
// derivation and a reader can check it line by line.
type Step struct {
	What  string // the field, or the letter
	Value int    // what was folded in
	Key   int    // the key after it
}

// fold is one turn: what there was times Mult, plus the value, mod Mod.
func fold(key, value, mod int) int {
	return (key*Mult + value) % mod
}

// Steps folds the two fields of the roll that make a person this
// person and not another, in a fixed order: the home column, the home
// row, then the name a byte at a time. The order is the whole of what
// makes the face total: the same row folded in the same order is the
// same number, and a field folded in a different place is a different
// number.
//
// The home goes in first. Whatever is folded last moves the key by
// exactly its own difference, so two rows alike in everything but that
// field differ by one, and one is the head alone. Neighbours a row
// apart are common in a village; names alike in every letter but the
// last are not.
//
// The persona is prose and stays out: it is read by people, not by
// arithmetic. The law profile stays out because a face that changed
// with it would be a law you can see, and law in this world is a file.
// Carrying stays out because it is the one number an operator is meant
// to change. The founding tick stays out because a village founded a
// tick later is the same village.
func Steps(p Person, mod int) []Step {
	var out []Step
	key := 0
	key = fold(key, p.Home.X, mod)
	out = append(out, Step{"home column", p.Home.X, key})
	key = fold(key, p.Home.Y, mod)
	out = append(out, Step{"home row", p.Home.Y, key})
	for i := 0; i < len(p.Name); i++ {
		key = fold(key, int(p.Name[i]), mod)
		out = append(out, Step{string(p.Name[i]), int(p.Name[i]), key})
	}
	return out
}

// Key is the fold's last value: one number under Mod for this row.
func Key(p Person) int {
	steps := Steps(p, Mod)
	return steps[len(steps)-1].Key
}

// FaceOf is the whole derivation: a row in, a face out, no state
// anywhere. The key is taken mod Faces, so that it names one of the
// faces the sheet can make, and then peeled.
func FaceOf(p Person) Face {
	return Peel(Key(p) % Faces)
}

// Peel writes a number under Faces in the sheet's mixed radix: the
// head is the remainder on division by Heads, the eyes the remainder of
// what is left on division by Eyes, and so on up to the colouring.
// Every number under Faces is exactly one face and every face is
// exactly one number.
func Peel(n int) Face {
	var d [5]int
	for i, r := range Radix {
		d[i] = n % r
		n /= r
	}
	return Face{Head: d[0], Eyes: d[1], Mouth: d[2], Hair: d[3], Tint: d[4]}
}

// Index is the peel run backwards: the one number under Faces this
// face is.
func (f Face) Index() int {
	d := [5]int{f.Head, f.Eyes, f.Mouth, f.Hair, f.Tint}
	n := 0
	for i := len(Radix) - 1; i >= 0; i-- {
		n = n*Radix[i] + d[i]
	}
	return n
}

$ go run ./cmd/mkfolk -mode key
mkfolk: the fold for Halla, home 8,5: times 31, plus the value, mod 65521

  folded in     value      key
  home column       8        8
  home row          5      253
  H                72     7915
  a                97    48899
  l               108     8994
  l               108    16838
  a                97    63428

  the key is 63428, and 63428 mod 3072 is 1988: face 1988 of the 3072 the sheet can make

  peeled, lowest digit first
     1988 mod 4 = 0  head      round
      497 mod 4 = 1  eyes      aside
      124 mod 4 = 0  mouth     line
       31 mod 6 = 1  hair      long
        5 mod 8 = 5  colouring light skin, brown hair
    and 1988 is 1988 back again: round head, aside eyes, line mouth, long hair, light skin, brown hair

  keys under 65521 that come back to themselves after "ll": 1 of 65521

The seven lines of the table are the seven turns of the interlude, and the peel under it is the interlude's second paragraph, so the two can be checked against each other line by line; the bench prints the modulus and the multiplier it used off the package's constants, and the last line counts the "ll" cycle under that modulus by trying every key. What the table shows about the fold's order is on its last line: the letter folded last adds itself to the key, so a row that differed from Halla's in its final letter alone would have a key one higher, and one higher is the next head. Exercise 2 runs that row. The home goes in first for exactly that reason: neighbours a row apart, which is what Halla and Mose are, get their one row of difference multiplied by 31 once for every letter that follows it, and neighbours are common in a village where a last letter's difference is not.

$ go run ./cmd/mkfolk -mode key -mod 3072
mkfolk: the fold for Halla, home 8,5: times 31, plus the value, mod 3072
  (the shipped modulus is 65521; this run is under 3072 off the flag)

  folded in     value      key
  home column       8        8
  home row          5      253
  H                72     1771
  a                97     2774
  l               108       86
  l               108     2774
  a                97       75

  the key is 75, and 75 mod 3072 is 75: face 75 of the 3072 the sheet can make

  peeled, lowest digit first
       75 mod 4 = 3  head      narrow
       18 mod 4 = 2  eyes      wide
        4 mod 4 = 0  mouth     line
        1 mod 6 = 1  hair      long
        0 mod 8 = 0  colouring dark skin, black hair
    and 75 is 75 back again: narrow head, wide eyes, line mouth, long hair, dark skin, black hair

  keys under 3072 that come back to themselves after "ll": 192 of 3072

The same seven values under the modulus that was tried first. The fourth and sixth lines are the cycle: after "a" the key is 2774, after "ll" it is 2774 again, and the last line counts a hundred and ninety-two keys under 3072 with that habit against one under 65521. Nothing else moved: under 3072 Halla is face 75, a narrow head with wide eyes and black hair, and there is nothing wrong with that face. What is wrong with the modulus is that one key in sixteen forgets two letters under it, and a fold that forgets letters is a fold whose collisions come in families instead of by chance.

Extend internal/village/face.go. A colouring names five entries of the sixteen; Table is the substitution it makes on the seven, and Remap is that table as the pair of colour lists the blit takes, which is chapter 68's Look.Remap over a shorter list.

// internal/village/face.go — add below the strip's positions

// Tint is a colouring: which three entries of the sixteen the skin's
// shadow, midtone and lit come out as, and which two the hair's dark
// and lit come out as. Each is an index into gene.Sixteen.
type Tint struct {
	Name string
	Skin [3]int
	Hair [2]int
}

// The two skins and the five hairs the colourings are built from. Two
// skins is what sixteen colours buy: the soil ramp whole, and the soil
// ramp moved one step toward bone.
var (
	dark  = [3]int{gene.SoilD, gene.SoilM, gene.SoilL}
	light = [3]int{gene.SoilM, gene.SoilL, gene.Bone}
	black = [2]int{gene.RockD, gene.RockM}
	grey  = [2]int{gene.RockM, gene.RockL}
	brown = [2]int{gene.SoilD, gene.SoilM}
	blond = [2]int{gene.SoilM, gene.Gold}
	red   = [2]int{gene.SoilD, gene.Ember}
)

// Colourings are the eight the sheet may come out in. Not every pair
// of a skin and a hair is here: a hair whose entries include the skin's
// midtone has no edge against the brow, and brown hair on dark skin is
// exactly that pair, so it is left out and a test holds the rule.
var Colourings = [Tints]Tint{
	{"dark skin, black hair", dark, black},
	{"dark skin, grey hair", dark, grey},
	{"dark skin, red hair", dark, red},
	{"light skin, black hair", light, black},
	{"light skin, grey hair", light, grey},
	{"light skin, brown hair", light, brown},
	{"light skin, blond hair", light, blond},
	{"light skin, red hair", light, red},
}

// ...

// Table is the substitution this face makes on the strip: entry i of
// the seven comes out as entry Table()[i] of the sixteen. The outline
// and the white are fixed points; the skin's three and the hair's two
// come out as the colouring says.
func (f Face) Table() [7]int {
	t := Strip
	c := Colourings[f.Tint]
	t[SkinD], t[SkinM], t[SkinL] = c.Skin[0], c.Skin[1], c.Skin[2]
	t[HairD], t[HairL] = c.Hair[0], c.Hair[1]
	return t
}

// Remap is that table as the pair of colour lists the blit takes.
func (f Face) Remap() render.Remap {
	from := make([]render.Color, len(Strip))
	to := make([]render.Color, len(Strip))
	for i, j := range Strip {
		from[i] = gene.Sixteen[j]
	}
	for i, j := range f.Table() {
		to[i] = gene.Sixteen[j]
	}
	return render.Remap{From: from, To: to}
}

// Cells are the four source rectangles of the sheet this face is
// drawn from, in the order they are laid down.
func (f Face) Cells(s *render.Sheet) [Rows]render.Rect {
	return [Rows]render.Rect{
		s.Frame(f.Head, HeadRow),
		s.Frame(f.Eyes, EyesRow),
		s.Frame(f.Mouth, MouthRow),
		s.Frame(f.Hair, HairRow),
	}
}

// Draw lays the four cells over one another at (x, y) on the buffer,
// each put through the face's substitution on the way. A pixel a part
// does not hold leaves what is under it alone, which is how the eyes
// sit on the head and the hair sits on both.
func (f Face) Draw(b *render.Buffer, s *render.Sheet, x, y int) {
	m := f.Remap()
	for _, r := range f.Cells(s) {
		b.BlitMap(s, r, x, y, Cell, Cell, &m)
	}
}

$ go run ./cmd/mkfolk -mode tints
mkfolk: the 8 colourings, as substitutions on the strip's seven entries

   #  colouring                skin: shadow mid lit   hair: dark lit
   0  dark skin, black hair    4C2F22 75563B A1875A   323847 5A6470
   1  dark skin, grey hair     4C2F22 75563B A1875A   5A6470 8A979E
   2  dark skin, red hair      4C2F22 75563B A1875A   4C2F22 C75938
   3  light skin, black hair   75563B A1875A F5EBD7   323847 5A6470
   4  light skin, grey hair    75563B A1875A F5EBD7   5A6470 8A979E
   5  light skin, brown hair   75563B A1875A F5EBD7   4C2F22 75563B
   6  light skin, blond hair   75563B A1875A F5EBD7   75563B F0BE35
   7  light skin, red hair     75563B A1875A F5EBD7   4C2F22 C75938

  every colouring keeps the outline at entry 0 and the white at entry 15

  Halla's face as the sheet holds it, one character a pixel, each character a strip entry
    ................
    .....oooooo.....
    ....oHHHHhho....
    ..oHHHHhhhhhho..
    ..oHHkkkkkkhho..
    ..oHhkkkkkkhho..
    ..oHkkkkkkkkho..
    ..oHoeekkoeeho..
    ..oHkkkkskksho..
    ..ohlkkkskksho..
    ..ohkkooooksho..
    ..ohokkkkssoho..
    ..ohooooooooho..
    ..ooo.osso.ooo..
    ......okko......
    ......oooo......

  entry comes out   what it is on the sheet
     0         0   outline        181A29 -> 181A29
     1         2   skin shadow    4C2F22 -> 75563B
     2         3   skin midtone   75563B -> A1875A
     3        15   skin lit       A1875A -> F5EBD7
     4         1   hair dark      323847 -> 4C2F22
     5         2   hair lit       5A6470 -> 75563B
    15        15   white          F5EBD7 -> F5EBD7

  the same face through colouring 5, light skin, brown hair, each character an entry of the sixteen
    ................
    .....000000.....
    ....02222110....
    ..022221111110..
    ..022333333110..
    ..021333333110..
    ..023333333310..
    ..020ff330ff10..
    ..023333233210..
    ..01f333233210..
    ..013300003210..
    ..010333322010..
    ..010000000010..
    ..000.0220.000..
    ......0330......
    ......0000......

Draw is four calls to the blit chapter 68 wrote, at the cell's own size, through one substitution, and nothing in render changed for it: a composed face is a sheet cell blitted four times with the alpha channel doing the layering, which is what the alpha channel has been for since the sprite chapter. The two pictures of Halla are the same picture, and every character in the second is the first's put through the table above it: k became 3 where the table says entry 2 comes out as entry 3, h became 1, and the o of every outline and the e of each eye's white came out as themselves. The face is composed on the sheet's own colours and substituted on the way to the buffer, inside the blit, for the reason chapter 68's worked failure gave: once the pixels are down they are colours with no history, and a substitution run over a finished picture recolours whatever else happens to share an entry with a face.

The claim this page makes is that the same row always makes the same face, and the bench makes it as something that can fail: it reads the roll off the embedded file, composes a face for everyone in it, hashes the pixels, and then reads the roll again and does it all a second time.

$ go run ./cmd/mkfolk -mode faces
mkfolk: assets/sprites/folk.png, 96x64, 24 cells of 16
  parts chosen off each row: home column, home row, name, folded times 31 mod 65521

  pass 1: the roll read from the file, 3 people
  name    home   key  face  head, eyes, mouth, hair, colouring
  Halla   8,5  63428  1988  0 1 0 1 5  round head, aside eyes, line mouth, long hair, light skin, brown hair
                                     pixels sha256 c1b27d2f5782d9d2
  Ander   9,5  27844   196  0 1 0 3 0  round head, aside eyes, line mouth, fringe hair, dark skin, black hair
                                     pixels sha256 e48fca05e27fe03b
  Mose    8,6  54642  2418  2 0 3 1 6  square head, open eyes, grin mouth, long hair, light skin, blond hair
                                     pixels sha256 db7735226cb801c9

  pass 2: the roll read from the file, 3 people
  name    home   key  face  head, eyes, mouth, hair, colouring
  Halla   8,5  63428  1988  0 1 0 1 5  round head, aside eyes, line mouth, long hair, light skin, brown hair
                                     pixels sha256 c1b27d2f5782d9d2
  Ander   9,5  27844   196  0 1 0 3 0  round head, aside eyes, line mouth, fringe hair, dark skin, black hair
                                     pixels sha256 e48fca05e27fe03b
  Mose    8,6  54642  2418  2 0 3 1 6  square head, open eyes, grin mouth, long hair, light skin, blond hair
                                     pixels sha256 db7735226cb801c9

  the second pass agrees with the first for 3 of 3 faces

Three keys, three face numbers, three sets of five digits and three hashes, twice, and the second pass agrees with the first for all three. Halla is 1988, worked by hand above. Ander's key is 27844, which is 9 × 3072 + 196: round head, aside eyes, line mouth, fringe, dark skin and black hair. Mose's is 54642, which is 17 × 3072 + 2418: square head, open eyes, grin, long hair, light skin and blond hair. Halla and Ander share a head, a pair of eyes and a mouth, because 1988 and 196 leave the same remainder on division by 64, and what tells them apart is the hair and the colouring; at a glance that is what tells people apart anyway, and the test that pins this run refuses only two rows that come out as one face.

$ go run ./cmd/mkfolk -mode card -shot assets/frames/folk-three.png
mkfolk: the 3 people of the roll, composed off their rows
  Halla  face 1988  round head, aside eyes, line mouth, long hair, light skin, brown hair
  Ander  face  196  round head, aside eyes, line mouth, fringe hair, dark skin, black hair
  Mose   face 2418  square head, open eyes, grin mouth, long hair, light skin, blond hair
  the card 108 by 37 pixels, 285ceee38555cf3d1db6b9600c3dd70380c8ac013c1a1b368ec1becc13ee8dc1
  wrote assets/frames/folk-three.png at 4 times, 432 by 148

$ go test -count=1 ./internal/village/ -run 'TestTheSameRowMakesTheSameFace|TestEveryNumberUnderFacesIsOneFaceAndBack|TestNoColouringPutsTheHairOnTheSkinsMidtone' -v
=== RUN   TestTheSameRowMakesTheSameFace
--- PASS: TestTheSameRowMakesTheSameFace (0.00s)
=== RUN   TestEveryNumberUnderFacesIsOneFaceAndBack
--- PASS: TestEveryNumberUnderFacesIsOneFaceAndBack (0.00s)
=== RUN   TestNoColouringPutsTheHairOnTheSkinsMidtone
--- PASS: TestNoColouringPutsTheHairOnTheSkinsMidtone (0.00s)
PASS
ok  	theworld/internal/village	0.005s

The first reads the roll twice and asks for the same key and the same face for everyone; then it moves each person one row south and adds a letter to each name and asks for a different key both times; then it blanks the persona, changes the law to bandit, empties the grams and moves the founding tick, and asks that the face did not move. The second walks all 3072 numbers through Peel and Index and asks that each comes back as itself and that no two peel to one face. The third is the colouring rule from above, and it also asks that every entry a colouring names is one of the sixteen and that the outline and the white are fixed points of every table.