Rock, Water, Soil

// internal/sim/terrain.go
package sim

// Terrain is what the ground is at one cell.
type Terrain uint8

const (
	Rock Terrain = iota // the zero value: a new world is solid rock
	Water
	Soil
)

// String makes a Terrain print as a word instead of a number.
func (t Terrain) String() string {
	switch t {
	case Rock:
		return "rock"
	case Water:
		return "water"
	case Soil:
		return "soil"
	}
	return "unknown"
}

// Glyph is the one-byte map symbol for a terrain kind.
func (t Terrain) Glyph() byte {
	switch t {
	case Water:
		return '~'
	case Soil:
		return '.'
	}
	return '#'
}

// cmd/worldd/main.go — a throwaway main to poke the new type
package main

import (
	"fmt"

	"theworld/internal/sim"
)

func main() {
	fmt.Println(sim.Rock, sim.Water, sim.Soil)
	fmt.Println(uint8(sim.Rock), uint8(sim.Water), uint8(sim.Soil))
	var t sim.Terrain
	fmt.Println("a fresh Terrain is", t)
}

$ go run ./cmd/worldd
rock water soil
0 1 2
a fresh Terrain is rock

type Terrain uint8 declares a new type whose underlying storage is one unsigned byte. It is not an alias: a uint8 holding a page count will not pass where a Terrain is expected unless you convert it on purpose.

The compiler now polices the difference between ground and arithmetic.

iota is Go's counter for constant blocks: it starts at 0 on the first line and climbs by one per line. Rock, Water, and Soil receive 0, 1, 2 without anyone typing the numbers, and adding a kind later is one new line, not a renumbering.

The String method is a quiet contract with the standard library: fmt checks whether a value knows how to describe itself and calls this method if so. The first printed line says rock water soil, while the converted second line shows the bytes underneath.

The third line is a design decision wearing a demo's clothes. Go initializes every variable; a Terrain nobody has assigned is 0, and 0 is Rock because Rock came first in the block.

That ordering is chosen. A freshly allocated world is solid bedrock, which is geologically sensible and obvious at a glance. A bug that forgets to assign terrain shows up as rock where you expected anything else, not as a plausible-looking valley.

// internal/sim/terrain.go — continued

// Grid is the ground itself: W by H cells of terrain in one flat slice.
type Grid struct {
	W, H  int
	cells []Terrain
}

// NewGrid allocates a w-by-h grid in a single allocation.
// Every cell starts as the zero value, Rock.
func NewGrid(w, h int) *Grid {
	return &Grid{W: w, H: h, cells: make([]Terrain, w*h)}
}

// index turns a 2D coordinate into a position in the flat slice.
func (g *Grid) index(c Coord) int {
	return c.Y*g.W + c.X
}

// In reports whether a coordinate is on the grid at all.
func (g *Grid) In(c Coord) bool {
	return c.X >= 0 && c.X < g.W && c.Y >= 0 && c.Y < g.H
}

// At returns the terrain at a coordinate.
func (g *Grid) At(c Coord) Terrain {
	return g.cells[g.index(c)]
}

// Set overwrites the terrain at a coordinate.
func (g *Grid) Set(c Coord, t Terrain) {
	g.cells[g.index(c)] = t
}

// cmd/worldd/main.go — replace the throwaway main
func main() {
	g := sim.NewGrid(12, 8)
	c := sim.Coord{X: 3, Y: 2}
	fmt.Println("slot for (3,2):", c.Y*g.W+c.X)
	fmt.Println("before:", g.At(c))
	g.Set(c, sim.Water)
	fmt.Println("after: ", g.At(c))
	fmt.Println("neighbor untouched:", g.At(sim.Coord{X: 4, Y: 2}))
}

$ go run ./cmd/worldd
slot for (3,2): 27
before: rock
after:  water
neighbor untouched: rock

cells and index start with small letters, so nothing outside internal/sim can touch them. The rest of the program goes through At and Set or it does not get in.

That is last chapter's method discipline paying its first real rent: the flattening formula exists in exactly one function, three lines long. If the layout ever changes, one function changes with it, and no caller anywhere is holding a copy of the arithmetic.

The run confirms the formula against the interlude, 27 on the nose, and confirms that writing one cell disturbed nothing beside it.

// internal/sim/terrain.go — add the import and the renderer
import "strings"

// Render draws the whole grid as one glyph per cell, one row per line.
func (g *Grid) Render() string {
	var b strings.Builder
	for y := 0; y < g.H; y++ {
		for x := 0; x < g.W; x++ {
			b.WriteByte(g.At(Coord{X: x, Y: y}).Glyph())
		}
		b.WriteByte('\n')
	}
	return b.String()
}

// cmd/worldd/main.go — the whole file
package main

import (
	"fmt"

	"theworld/internal/sim"
)

const version = "0.0.1"

func main() {
	fmt.Println("worldd", version, "starting")

	g := sim.NewGrid(12, 8)

	// Soil everywhere except a one-cell rock rim.
	for y := 1; y < g.H-1; y++ {
		for x := 1; x < g.W-1; x++ {
			g.Set(sim.Coord{X: x, Y: y}, sim.Soil)
		}
	}

	// A pond, placed by hand. Real generation needs randomness
	// the sim does not have yet.
	pond := []sim.Coord{
		{X: 4, Y: 2}, {X: 5, Y: 2}, {X: 6, Y: 2}, {X: 7, Y: 2},
		{X: 3, Y: 3}, {X: 4, Y: 3}, {X: 5, Y: 3}, {X: 6, Y: 3},
		{X: 7, Y: 3}, {X: 8, Y: 3},
		{X: 4, Y: 4}, {X: 5, Y: 4}, {X: 6, Y: 4}, {X: 7, Y: 4},
	}
	for _, c := range pond {
		g.Set(c, sim.Water)
	}

	fmt.Print(g.Render())
	fmt.Println("ground:", g.W*g.H, "cells,", len(pond), "of them water")
}

$ go run ./cmd/worldd
worldd 0.0.1 starting
############
#..........#
#...~~~~...#
#..~~~~~~..#
#...~~~~...#
#..........#
#..........#
############
ground: 96 cells, 14 of them water

Read it against the code. The top and bottom rows and both edge columns were never assigned, so they render as rock: the zero value drew the valley walls for free.

The pond's middle row runs from x=3 to x=8, one cell wider than the rows above and below it, and the map shows exactly that bulge.

Nothing here is generated, so nothing here can surprise you. That property becomes the baseline every run is judged against.

strings.Builder deserves its one sentence: appending to a string with + copies the whole string every time, while a builder accumulates bytes in a growing buffer and produces the final string once, at the end.

For 96 cells it is a habit. For the grids this world grows into, it is the difference between a render and a stall.