go: port dungeon generation, items base, pack, and monster creation

rooms.c, passages.c, new_level.c ported in full: room/maze layout,
corridor spanning tree with extra connections, passage numbering flood
fill, trap/stairs/object placement, treasure rooms. Careful RNG-call
ordering throughout keeps generation seed-faithful to C.

Supporting subsystems this depends on, also ported:
- screen.go: curses replaced by in-memory Window cell buffers behind a
  Terminal interface (tcell arrives with the UI phase; tests run headless)
- io.go: msg/addmsg/endmsg message-line protocol, status line, step_ok
- pack.c in full (add_pack sorting/stacking walk, get_item, inventory)
- things.c in full (inv_name, new_thing, discovery lists, pagination)
- monsters.c in full; chase.c navigation half (roomin/cansee/see_monst/
  find_dest/runto/set_oldch); rings.c, armor.c in full
- weapons.c/sticks.c creation half (init_weapon, fix_stick, num)
- misc.c look() display update, eat, level-up, direction input
- daemons.c callbacks except stomach (needs death()) and the runners
  chase driver (combat phase)
- init.c init_player with the starting kit

Tests: level invariants across seeds, determinism, 30-depth sweep.

game/newlevel_test.go

@@ -0,0 +1,124 @@
+package game
+
+import (
+	"strings"
+	"testing"
+)
+
+func genLevel(t *testing.T, seed int32) *RogueGame {
+	t.Helper()
+	g := NewGame(Config{Seed: seed})
+	g.NewLevel()
+	return g
+}
+
+// renderMap draws the raw level map (not the screen) as text.
+func renderMap(g *RogueGame) string {
+	var sb strings.Builder
+	for y := 0; y < NumLines; y++ {
+		for x := 0; x < NumCols; x++ {
+			ch := g.Level.Char(y, x)
+			if m := g.Level.MonsterAt(y, x); m != nil {
+				ch = m.Type
+			}
+			sb.WriteByte(ch)
+		}
+		sb.WriteByte('\n')
+	}
+	return sb.String()
+}
+
+func TestNewLevelInvariants(t *testing.T) {
+	for _, seed := range []int32{1, 12345, 2026, 99999} {
+		g := genLevel(t, seed)
+
+		// The staircase is somewhere real.
+		st := g.Level.Stairs
+		if g.Level.Char(st.Y, st.X) != Stairs {
+			t.Errorf("seed %d: no staircase at recorded stairs position", seed)
+		}
+
+		// The hero stands on a walkable, monster-free cell.
+		hp := g.Player.Pos
+		if !stepOk(g.Level.Char(hp.Y, hp.X)) {
+			t.Errorf("seed %d: hero on unwalkable cell %q", seed,
+				g.Level.Char(hp.Y, hp.X))
+		}
+		if g.Level.MonsterAt(hp.Y, hp.X) != nil {
+			t.Errorf("seed %d: hero standing on a monster", seed)
+		}
+		if g.Player.Room == nil {
+			t.Errorf("seed %d: hero not in any room", seed)
+		}
+
+		// Some rooms exist and are drawn.
+		m := renderMap(g)
+		if !strings.Contains(m, "|") || !strings.Contains(m, "-") {
+			t.Errorf("seed %d: no room walls drawn", seed)
+		}
+		if !strings.Contains(m, ".") && !strings.Contains(m, "#") {
+			t.Errorf("seed %d: no floor or passages drawn", seed)
+		}
+
+		// Every monster is indexed on the map and placed in a room.
+		for _, mon := range g.Level.Monsters {
+			if g.Level.MonsterAt(mon.Pos.Y, mon.Pos.X) != mon {
+				t.Errorf("seed %d: monster %c not indexed at its position",
+					seed, mon.Type)
+			}
+			if mon.Room == nil {
+				t.Errorf("seed %d: monster %c has no room", seed, mon.Type)
+			}
+		}
+
+		// Every level object sits on a cell displaying its type (items can
+		// share cells only with monsters standing on them).
+		for _, obj := range g.Level.Objects {
+			ch := g.Level.Char(obj.Pos.Y, obj.Pos.X)
+			if ch != obj.Type && g.Level.MonsterAt(obj.Pos.Y, obj.Pos.X) == nil {
+				t.Errorf("seed %d: object %q at (%d,%d) but map shows %q",
+					seed, obj.Type, obj.Pos.Y, obj.Pos.X, ch)
+			}
+		}
+
+		// The player has her starting kit: food, armor, mace, bow, arrows.
+		if len(g.Player.Pack) != 5 {
+			t.Errorf("seed %d: starting pack has %d items, want 5",
+				seed, len(g.Player.Pack))
+		}
+		if g.Player.CurWeapon == nil || g.Player.CurWeapon.Which != Mace {
+			t.Errorf("seed %d: not wielding the starting mace", seed)
+		}
+		if g.Player.CurArmor == nil || g.Player.CurArmor.Which != RingMail {
+			t.Errorf("seed %d: not wearing the starting ring mail", seed)
+		}
+	}
+}
+
+func TestNewLevelDeterministic(t *testing.T) {
+	a := renderMap(genLevel(t, 12345))
+	b := renderMap(genLevel(t, 12345))
+	if a != b {
+		t.Error("same seed produced different levels")
+	}
+	c := renderMap(genLevel(t, 54321))
+	if a == c {
+		t.Error("different seeds produced identical levels")
+	}
+}
+
+// TestDeeperLevels exercises generation across many depths and seeds —
+// mazes, dark rooms, traps, treasure rooms — as a crash/invariant sweep.
+func TestDeeperLevels(t *testing.T) {
+	for _, seed := range []int32{7, 42, 1000, 31337} {
+		g := NewGame(Config{Seed: seed})
+		for depth := 1; depth <= 30; depth++ {
+			g.Depth = depth
+			g.NewLevel()
+			st := g.Level.Stairs
+			if g.Level.Char(st.Y, st.X) != Stairs {
+				t.Fatalf("seed %d depth %d: missing staircase", seed, depth)
+			}
+		}
+	}
+}