Merge seed-compat (item-table cross-validation vs C reference)

Instrumented the C game on modern-rogue with a DUMP mode (patch in
testdata/c_seedcompat.patch) that forces the RNG seed and prints the
per-seed item appearance tables — potion colors, scroll names, ring
stones, wand/staff materials — in the normal init order, before initscr
so no terminal is needed. Captured its output for four seeds as
testdata/item_tables.golden.

TestSeedCompatItemTables regenerates the same tables from the Go port
via New(Params{Seed, Wizard: true}) and checks they match the golden
byte for byte. They do, for all four seeds — proving the LCG and its
consumption order through the whole init sequence (init_probs →
init_player → init_names → init_colors → init_stones → init_materials,
including init_player's arrow rnd(8)+rnd(15)) agree with C exactly.

testdata/README.md documents how to regenerate the golden.

.golangci.yml

@@ -0,0 +1,38 @@
+version: "2"
+
+run:
+  timeout: 5m
+  modules-download-mode: readonly
+
+linters:
+  default: all
+  disable:
+    # Genuinely incompatible with project patterns
+    - exhaustruct      # Requires all struct fields
+    - depguard         # Dependency allow/block lists
+    - godot            # Requires comments to end with periods
+    - wsl              # Deprecated, replaced by wsl_v5
+    - wrapcheck        # Too verbose for internal packages
+    - varnamelen       # Short names like db, id are idiomatic Go
+    # Repo-specific exceptions approved by sneak (2026-07-06)
+    - paralleltest     # Requires t.Parallel() in every test
+    # Approved by sneak 2026-07-07
+    - testpackage      # Tests use internal package game to reach unexported state
+    - exhaustive       # C-faithful switches handle only the cases C handled
+    - mnd              # C-faithful gameplay literals; naming them hurts C-greppability
+
+linters-settings:
+  lll:
+    line-length: 88
+  funlen:
+    lines: 80
+    statements: 50
+  cyclop:
+    max-complexity: 15
+  dupl:
+    threshold: 100
+
+issues:
+  exclude-use-default: false
+  max-issues-per-linter: 0
+  max-same-issues: 0

MEMORY.md

@@ -0,0 +1,41 @@
+# Project Memory
+
+Working notes for agents on this repo. Read this alongside TODO.md (which holds
+the step queue and workflow) before starting work.
+
+## Error handling
+
+Panicking on bad/unexpected errors is allowed and preferred over threading
+unlikely error returns through game code — e.g. write-side Close/encode failures
+where continuing would mean corrupt state. The game already unwinds C's exit()
+calls via a gameEnd panic recovered in Run. Return errors where a caller
+genuinely handles them (save-file prompts, restore validation). Reserve
+deliberate `_ =` discards for true best-effort paths (scorefile writes,
+signal-time autosave), always with a comment saying why.
+
+## Linting
+
+The .golangci.yml is the house standard and may only be modified with sneak's
+explicit permission. To disable a linter, ask, explaining what the linter does;
+he approves specific exceptions, which are recorded in the config's
+"Repo-specific exceptions" block with the approval date. Approved so far:
+paralleltest (2026-07-06); testpackage, exhaustive, and mnd (2026-07-07). The
+complexity linters (cyclop, gocognit, nestif) are enabled and clean as of
+refactor step 7 (2026-07-07): the whole golangci-lint run is 0 issues, so keep
+it that way — decompose new hot spots rather than reaching for a nolint.
+Line-level //nolint with a reason is used sparingly for C-faithfulness (e.g. the
+authentic "missle" message spellings) and provably-safe gosec conversions; each
+needs a justifying comment.
+
+## Faithfulness
+
+Behavior must not change during the idiomatic-Go refactor unless a TODO step
+says so. The 80x24 seed-compatible gameplay, message text (including original
+typos), RNG call order, and C quirks (documented in tests like
+TestHoldScrollGreedyMonsterQuirk) are contract. Doc comments keep their "(file.c
+func_name)" breadcrumbs.
+
+## Debugging
+
+Write real, committed test files with t.Logf output and run plain `go test -v`;
+no throwaway scratch scripts. Successful debug probes become regression tests.

Makefile

@@ -0,0 +1,35 @@
+# Development convenience targets. This repo is exempt from the standard
+# policy scaffold (no Dockerfile, CI, or REPO_POLICIES.md); this Makefile
+# is only a thin wrapper around the Go toolchain, golangci-lint, and
+# prettier so `make fmt` / `make check` behave the same as in sneak's
+# other repos.
+
+GO_PKGS  := ./...
+MD_FILES := $(shell git ls-files '*.md')
+PRETTIER := prettier --tab-width 4 --prose-wrap always
+
+.PHONY: check fmt fmt-check lint test
+
+# Format, lint, and test — the full local pre-commit gate.
+check: fmt-check lint test
+
+# Format Go and Markdown in place.
+fmt:
+	gofmt -w .
+	$(PRETTIER) --write $(MD_FILES)
+
+# Fail if any Go or Markdown file is not formatted.
+fmt-check:
+	@unformatted="$$(gofmt -l .)"; \
+	if [ -n "$$unformatted" ]; then \
+		echo "gofmt needed on:"; echo "$$unformatted"; exit 1; \
+	fi
+	$(PRETTIER) --check $(MD_FILES)
+
+# Run the house linter (config in .golangci.yml).
+lint:
+	golangci-lint run $(GO_PKGS)
+
+# Run the test suite.
+test:
+	go test $(GO_PKGS)

README.md

@@ -2,19 +2,19 @@
 
 [![License](https://img.shields.io/badge/license-BSD-blue.svg)](LICENSE.TXT)
 
-**Rogue** is the original dungeon-crawling adventure game that spawned an
+**Rogue** is the original dungeon-crawling adventure game that spawned an entire
-entire genre. This branch is a faithful Go port of Rogue 5.4.4: explore
+genre. This branch is a faithful Go port of Rogue 5.4.4: explore procedurally
-procedurally generated dungeons, fight monsters, collect treasure, and
+generated dungeons, fight monsters, collect treasure, and attempt to retrieve
-attempt to retrieve the Amulet of Yendor.
+the Amulet of Yendor.
 
-**Original authors:** Michael Toy, Ken Arnold, and Glenn Wichman
+**Original authors:** Michael Toy, Ken Arnold, and Glenn Wichman (1980–1983,
-(1980–1983, 1985, 1999).
+1985, 1999).
 
 The port is function-by-function faithful to the classic C sources — same
-dungeon generation (seed-compatible RNG), same combat math, same item
+dungeon generation (seed-compatible RNG), same combat math, same item tables,
-tables, same messages. The C reference implementation lives on the
+same messages. The C reference implementation lives on the `master` and
-`master` and `modern-rogue` branches; [ARCHITECTURE.md](ARCHITECTURE.md)
+`modern-rogue` branches; [ARCHITECTURE.md](ARCHITECTURE.md) documents both the
-documents both the original program structure and the design of this port.
+original program structure and the design of this port.
 
 ## Building and running
 
@@ -40,13 +40,12 @@ go build ./cmd/rogue
 
 Press `?` in game for the full list.
 
-- **arrows** or **h/j/k/l/y/u/b/n** — move (shift to run, ctrl to run
+- **arrows** or **h/j/k/l/y/u/b/n** — move (shift to run, ctrl to run until
-  until adjacent)
+  adjacent)
 - **`.`** rest, **`s`** search for hidden doors and traps
 - **`i`** inventory, **`,`** pick up, **`d`** drop
 - **`q`** quaff potion, **`r`** read scroll, **`e`** eat food
-- **`w`** wield weapon, **`W`** wear armor, **`P`**/**`R`** put on /
+- **`w`** wield weapon, **`W`** wear armor, **`P`**/**`R`** put on / remove ring
-  remove ring
 - **`t`** throw, **`z`** zap a wand, **`f`**/**`F`** fight
 - **`>`**/**`<`** take the stairs
 - **`S`** save, **`Q`** quit
@@ -61,8 +60,8 @@ export ROGUEOPTS="name=YourName,terse,jump,fruit=mango"
 ROGUE_WIZARD=1 SEED=12345 ./rogue
 ```
 
-The scoreboard is kept in `~/.rogue.scores`. Save files are Go gob
+The scoreboard is kept in `~/.rogue.scores`. Save files are Go gob snapshots
-snapshots and, as in the original, are deleted when restored.
+and, as in the original, are deleted when restored.
 
 ## Code layout
 
@@ -73,13 +72,17 @@ term/        tcell-backed terminal, replacing curses
 cmd/rogue/   the executable
 ```
 
-The engine package is fully headless-testable: `go test ./game/` runs
+The engine package is fully headless-testable: `go test ./game/` runs scripted
-scripted game sessions, dungeon-generation golden checks, and an RNG
+command sequences, dungeon-generation golden checks, and an RNG compatibility
-compatibility test against the original C generator.
+test against the original C generator.
+
+For development, the `Makefile` wraps the toolchain: `make fmt` (gofmt +
+prettier), `make lint` (golangci-lint), `make test`, and `make check` (all
+three).
 
 ## License
 
 BSD-style; see [LICENSE.TXT](LICENSE.TXT).
 
-Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn
+Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn Wichman.
-Wichman. All rights reserved.
+All rights reserved.

TODO.md

@@ -1,120 +1,188 @@
 # Workflow
 
-* branch (from `main`)
+- branch (from `main`)
-* do the work in Next Step
+- do the work in Next Step
-* move Next Step to the top of Completed Steps
+- move Next Step to the top of Completed Steps
-* move the top item of Future Steps into Next Step
+- move the top item of Future Steps into Next Step
-* commit (`TODO.md` changes in the same commit as the work)
+- commit (`TODO.md` changes in the same commit as the work)
-* merge to `main` if the branch is not protected, otherwise open a PR
+- merge to `main` if the branch is not protected, otherwise open a PR
-* push
+- push
 
 # Status
 
 pre-1.0
 
-The port on main is complete and faithful (function-by-function from
+The port on main is complete and faithful (function-by-function from Rogue 5.4.4
-Rogue 5.4.4 C; reference sources on c-master/modern-rogue). Current
+C; reference sources on c-master/modern-rogue). Current phase: refactor from a
-phase: refactor from a transliterated port into idiomatic Go — one
+transliterated port into idiomatic Go — one feature branch per step below,
-feature branch per step below, descriptive naming, real types, house
+descriptive naming, real types, house style per
-style per ~/dev/prompts/prompts/CODE_STYLEGUIDE_GO.md.
+~/dev/prompts/prompts/CODE_STYLEGUIDE_GO.md.
 
 Refactor ground rules:
 
-- Behavior must not change unless a step says so. The full test suite
+- Behavior must not change unless a step says so. The full test suite (scripted
-  (scripted sessions, generation invariants, C-compatible RNG goldens)
+  sessions, generation invariants, C-compatible RNG goldens) gates every step;
-  gates every step; 80x24 seed-compatible gameplay stays intact.
+  80x24 seed-compatible gameplay stays intact.
-- Renames keep the C lineage greppable: doc comments retain their
+- Renames keep the C lineage greppable: doc comments retain their "(file.c
-  "(file.c func_name)" breadcrumbs, and the docs refresh step adds a
+  func_name)" breadcrumbs, and the docs refresh step adds a C-name → Go-name
-  C-name → Go-name table to ARCHITECTURE.md.
+  table to ARCHITECTURE.md.
 
 # Next Step
 
-Adopt the house Go linting standards: copy .golangci.yml from the
+Broaden unit test coverage where playtesting finds thin spots (rings, sticks,
-prompts repo and bring game/, term/, and cmd/ lint-clean (the port is
+wizard commands).
-greenfield code, so no exemptions apply).
 
 # Completed Steps
 
-- 2026-07-06 Module base path updated to git.eeqj.de/sneak/rgoue
+- 2026-07-24 Seed compatibility — item tables (seed-compat): instrumented the C
-  (go.mod, term/ and cmd/ imports, ARCHITECTURE.md, version string).
+  reference on modern-rogue with a DUMP mode (testdata/c_seedcompat.patch) that
-- 2026-07-06 Refactor step 3 (refactor/object-fields): Object.Arm split
+  forces the RNG seed and prints the per-seed item appearance tables (potion
-  into ArmorClass/Charges/GoldValue/Bonus (rings); Stats.Arm →
+  colors, scroll names, ring stones, wand/staff materials) before initscr, and
-  ArmorClass; damage strings parsed once into DiceSpec at table
+  captured its output for four seeds as testdata/item_tables.golden.
-  definition (ParseDice keeps C roll_em parse semantics, incl. "%%%x0"
+  TestSeedCompatItemTables regenerates the same tables from the Go port and they
-  and "000x0" edge cases, regression-tested); save format 5.4.4-go3.
+  match byte for byte — proving the LCG and its consumption order through the
-- 2026-07-06 Refactor step 2 (refactor/typed-kinds, b940cfc):
+  whole init sequence agree with C. The remaining "same dungeon (map)" half
-  ObjectKind separates item category from map glyph (Object.Type byte
+  would need the harder headless-curses C dump (new_level draws to curses);
-  → Kind ObjectKind with Glyph()); PotionKind/ScrollKind/RingKind/
+  deferred — the item-table match already validates RNG-order faithfulness
-  WandKind/WeaponKind/ArmorKind/TrapKind typed iota enums with
+  through init, and the Go generation goldens guard determinism thereafter.
-  Stringer; typed accessors on Object; getItem/inventory/whatis
+
-  filters take ObjectKind (KindCallable/KindRingOrStick replace
+- 2026-07-23 Playtest hardening (playtest-hardening): added two death-safe
-  CALLABLE/R_OR_S); save format bumped to 5.4.4-go2. Suite green.
+  crash-sweep drives through the real turn loop, within the step-8 os.Exit
-- 2026-07-06 Refactor step 1 (refactor/descriptive-constants): renamed
+  constraint (a fortify() helper pins HP/food/exp and clears the freeze/stuck
-  all flag bits, trap types, item subtype constants, and Max* counts to
+  counters each turn so no death exits the test binary; fixed seeds keep them
-  descriptive names (IsHuh→Confused, SeeMonst→SenseMonsters,
+  deterministic). TestDeepPlaythrough uses quaff/read/zap through command
-  WsHasteM→WandHasteMonster, MaxSticks→NumWandTypes, ...);
+  dispatch, then descends to depth 8 with a save/restore at depth 4;
-  Level.NTraps→TrapCount; C names kept as comment breadcrumbs. Pure
+  TestTurnLoopCrashSweep mashes movement/search/rest for 200 turns on four
-  rename, suite green.
+  seeds. Neither surfaced a panic. The interactive "play several games at a real
+  tcell terminal" portion needs a human at an 80x24 terminal and is left to the
+  maintainer; the binary's non-interactive paths (`-s` scores) were
+  smoke-tested.
+
+- 2026-07-23 Docs refresh (docs-refresh): rewrote ARCHITECTURE.md Part 2 (the
+  pre-implementation design sketch) to match the final code — current type/field
+  names (ObjectKind, DiceSpec, split o_arm, step-1 flag names, TrapCount, Level
+  list methods), the static tables now on the per-game gameData struct, the
+  daemon/effect handler tables, the MessageLine extraction, the Terminal
+  interface, the flat gob SaveState, and the New(Params) + os.Exit design. Added
+  §7.1, a C-name → Go-name rename table, and a README note on the make targets.
+
+- 2026-07-23 Refactor step 8 (refactor/constructor-style): constructor and exit
+  pass. NewGame(Config) → New(Params) and Restore takes Params, so the package's
+  primary type gets the canonical New() constructor with a named-field Params
+  struct (styleguide 139/159). The gameEnd panic unwind is gone: one game run is
+  one process, so myExit restores the terminal (new Terminal.Fini) and calls
+  os.Exit(0), and Run() no longer returns; the four Run()-to-completion tests
+  were reworked/dropped since death (combat or starvation) now exits the process
+  (TestScoreRendersList and TestRunDownStairs preserve what is still drivable;
+  save/restore stays covered by TestSaveRestoreRoundTrip). The 77-column wrap
+  sweep was dropped per sneak (2026-07-23): line lengths left as-is (lll caps at
+  88 and passes).
+
+- 2026-07-07 Refactor step 7 (refactor/effects-dispatch): effects dispatch
+  tables plus a full decomposition sweep — the quaff / readScroll / doZap
+  switches, the attack monster-power switch, the be_trapped switch, the daemon
+  d_func switch, and the command-key switch all became handler tables on
+  gameData (quaffHandlers, readHandlers, zapHandlers, hitHandlers, trapHandlers,
+  daemonHandlers, commandHandlers), one small named method per case. Every
+  remaining cyclop/gocognit/nestif hot spot was split into named helpers across
+  fight, misc (look), command, chase, move, passages, options, pack, things,
+  save, daemons, rooms, score, monsters, rings, rip, io, object, weapons,
+  wizard, and term/tcell, plus three test functions. Effect order and RNG call
+  sequence preserved throughout; the whole golangci-lint run is now 0 issues.
+
+- 2026-07-07 Refactor step 6 (refactor/god-object-extraction): MessageLine (was
+  MsgLine) owns the msg/addmsg/endmsg machinery, wired to its screen/look/input
+  needs via attach(); RogueGame keeps one-line msg/addmsgf/endmsg shorthands so
+  call sites are unchanged. Player owns pack bookkeeping (nextPackChar,
+  removeFromPack — the state half of leave_pack; leavePack keeps only LastPick
+  tracking). Level owns object/monster list management and lookup (ObjectAt
+  replaces findObj; AddObject/RemoveObject/AddMonster/RemoveMonster replace
+  direct attachObj/detachObj/attachMon/detachMon on level lists).
+  Inventory/pickup UI flows stay on RogueGame deliberately: they are display and
+  turn orchestration, not state surgery.
+
+- 2026-07-07 Refactor step 5 (refactor/item-combat-ui-renames, three commits,
+  one subsystem each): items — getItem→promptPackItem now returning (obj, ok),
+  invName→inventoryName, doPot→applyPotionFuse; combat — rollEm→rollAttacks,
+  attack/moveMonster/chaseStep return (removed bool) instead of C -1/0 int
+  codes; UI — getDir→promptDirection. C breadcrumbs kept; suite green.
+
+- 2026-07-07 Refactor step 4 (refactor/movement-renames): movement/world renames
+  (doMove→moveHero, beTrapped→springTrap, rndmove→randomStep,
+  doRooms/doPassages/doMaze→digRooms/digPassages/digMaze, chgStr→changeStrength,
+  doRun→startRun, moveStuff→finishMove, turnref→turnRefresh,
+  moveMonst→moveMonster, doChase→chaseStep, setOldch→setOldChar, cansee→canSee,
+  roomin→roomIn, runto→runTo, conn→connectRooms, putpass→putPassage,
+  passnum→numberPassages, numpass→numberPassage, rndPos→randomPos,
+  rndRoom→randomRoom, treasRoom→treasureRoom, accntMaze→accountMaze); all
+  goto/label flows replaced with loops (moveHero retry loop + extracted
+  passageTurn, dispatch re-dispatch loop, chaseStep passage loop, saveGame
+  labeled prompt loop); C breadcrumbs kept in doc comments.
+- 2026-07-07 Lint adoption finished (refactor/no-package-globals): all 37
+  package-level vars moved into `gameData` (built by `newGameData`, hung on
+  RogueGame as `g.data`, set in NewGame and Restore); ObjectKind
+  Glyph()/objectKindForGlyph became switches; the table-reading subtype
+  Stringers were removed; isMagic became a RogueGame method; goconst fixed with
+  named word constants (potionName, goldName, staffName, ripWall, ...);
+  testpackage and exhaustive disabled in .golangci.yml with sneak's approval
+  (2026-07-07); misspell's corruption of the "ther" scroll syllable reverted.
+  mnd disabled with sneak's approval (2026-07-07, follow-up commit). Remaining
+  red: cyclop (36), nestif (30), gocognit (23) stay until step 7 fixes them per
+  sneak's ruling.
+- 2026-07-06 Lint adoption bulk (refactor/lint-adoption, 5ba9fe8): .golangci.yml
+  copied verbatim from the prompts repo (plus the sneak-approved paralleltest
+  exception, 2026-07-06); ~1,500 findings fixed (autofix formatting sweep,
+  errcheck/err113/noinlineerr error handling, forbidigo, funcorder, recvcheck
+  pointer receivers, goprintffuncname renames msg helpers to *f, revive doc
+  comments, gocritic switch rewrites, gosec real fixes plus justified nolints,
+  unparam signature tightening, C-faithful "missle" spellings restored after
+  misspell autofix changed game text).
+- 2026-07-06 Module base path updated to git.eeqj.de/sneak/rgoue (go.mod, term/
+  and cmd/ imports, ARCHITECTURE.md, version string).
+- 2026-07-06 Refactor step 3 (refactor/object-fields): Object.Arm split into
+  ArmorClass/Charges/GoldValue/Bonus (rings); Stats.Arm → ArmorClass; damage
+  strings parsed once into DiceSpec at table definition (ParseDice keeps C
+  roll_em parse semantics, incl. "%%%x0" and "000x0" edge cases,
+  regression-tested); save format 5.4.4-go3.
+- 2026-07-06 Refactor step 2 (refactor/typed-kinds, b940cfc): ObjectKind
+  separates item category from map glyph (Object.Type byte → Kind ObjectKind
+  with Glyph()); PotionKind/ScrollKind/RingKind/
+  WandKind/WeaponKind/ArmorKind/TrapKind typed iota enums with Stringer; typed
+  accessors on Object; getItem/inventory/whatis filters take ObjectKind
+  (KindCallable/KindRingOrStick replace CALLABLE/R_OR_S); save format bumped to
+  5.4.4-go2. Suite green.
+- 2026-07-06 Refactor step 1 (refactor/descriptive-constants): renamed all flag
+  bits, trap types, item subtype constants, and Max* counts to descriptive names
+  (IsHuh→Confused, SeeMonst→SenseMonsters, WsHasteM→WandHasteMonster,
+  MaxSticks→NumWandTypes, ...); Level.NTraps→TrapCount; C names kept as comment
+  breadcrumbs. Pure rename, suite green.
 - 2026-07-06 Made the rgoue branch Go-only: removed C sources and the
-  autoconf/VS build system (they remain on master and modern-rogue),
+  autoconf/VS build system (they remain on master and modern-rogue), ported the
-  ported the last wizard command (item-probability listing), rewrote
+  last wizard command (item-probability listing), rewrote README.md for the Go
-  README.md for the Go port (c0b533e)
+  port (c0b533e)
-- 2026-07-06 Ported the command loop, save/restore, the tcell terminal
+- 2026-07-06 Ported the command loop, save/restore, the tcell terminal layer,
-  layer, and the playable binary at cmd/rogue (41fc104)
+  and the playable binary at cmd/rogue (41fc104)
-- 2026-07-06 Ported item effects: potions, scrolls, options, call_it
+- 2026-07-06 Ported item effects: potions, scrolls, options, call_it (cdf9bf7)
-  (cdf9bf7)
+- 2026-07-06 Ported combat, the chase driver, traps, zapping, death and scores
-- 2026-07-06 Ported combat, the chase driver, traps, zapping, death and
+  (3c5add8)
-  scores (3c5add8)
+- 2026-07-06 Ported dungeon generation, base items, the pack, and monster
-- 2026-07-06 Ported dungeon generation, base items, the pack, and
+  creation (a69ef7d)
-  monster creation (a69ef7d)
+- 2026-07-06 Ported the foundation: types, seed-compatible RNG, item tables,
-- 2026-07-06 Ported the foundation: types, seed-compatible RNG, item
+  daemon scheduler (7fa2048)
-  tables, daemon scheduler (7fa2048)
+- 2026-07-06 Wrote ARCHITECTURE.md Parts 1 and 2: complete map of the C program
-- 2026-07-06 Wrote ARCHITECTURE.md Parts 1 and 2: complete map of the C
+  and the Go port design (91eeee0, 45dba95)
-  program and the Go port design (91eeee0, 45dba95)
+- Fork base: Davidslv/rogue C 5.4.4 with modernization fixes (C23 prototypes,
-- Fork base: Davidslv/rogue C 5.4.4 with modernization fixes (C23
+  ncurses compat), preserved on master/modern-rogue
-  prototypes, ncurses compat), preserved on master/modern-rogue
 
 # Future Steps
 
-1. Refactor step 4: method renames, movement/world subsystem
+1. Tag a release once a full game (Amulet retrieval and score entry) completes
-   (doMove→moveHero, beTrapped→springTrap, rndmove→randomStep,
+   without defects.
-   doRooms/doPassages/doMaze→digRooms/digPassages/digMaze,
+2. Full-terminal-size support (deferred by explicit decision 2026-07-06):
-   chgStr→changeStrength, ...); remove the goto/label flows in doMove,
+   per-game dungeon dimensions instead of the 80x24 constants; open design
-   dispatch, and saveGame in favor of loops and helpers.
+   questions are resize policy, gameplay tuning at larger sizes, and a --classic
-2. Refactor step 5: method renames, items/combat/UI subsystems
+   80x24 mode.
-   (invName→inventoryName, rollEm→rollAttacks, doPot→applyPotionFuse,
+3. Note: this repo is exempt from the standard policy scaffold. A minimal dev
-   getItem→promptPackItem returning (obj, ok), getDir→promptDirection);
+   Makefile (fmt/fmt-check/lint/test/check targets) exists per sneak's
-   int status codes (attack returning -1) become named results. Two or
+   2026-07-07 request, but do not add a Dockerfile, CI config, or
-   three commits, one subsystem each.
+   REPO_POLICIES.md.
-3. Refactor step 6: extract types from the god object — MessageLine
-   owns the msg/addmsg/endmsg machinery; pack/inventory operations move
-   onto *Player; monster/object list management and map queries
-   consolidate onto *Level; RogueGame keeps turn orchestration and
-   cross-system effects only.
-4. Refactor step 7: effects dispatch — the giant quaff/readScroll/doZap
-   switches become per-kind handler tables of small named methods,
-   keeping effect order and RNG call sequence identical.
-5. Refactor step 8: constructor and style pass per the house
-   styleguide — game.New(game.Params{...}) replacing NewGame(Config);
-   replace the gameEnd panic unwind with error-based turn results where
-   feasible; 77-column wrap sweep.
-6. Docs refresh: update ARCHITECTURE.md Part 2 and README.md for the
-   post-refactor names; add the C name → Go name rename table.
-7. Playtest hardening pass: play several full games with the tcell
-    binary and extend run_test.go to script a deeper multi-level
-    playthrough (descend past level 5, use potions, scrolls, zapping,
-    save/restore). Fix any panics, message mismatches, or divergences
-    from the C behavior that this uncovers, with regression tests.
-8. Verify the seed-compatibility claim against the C reference on
-    c-master: same seed, same dungeon, same item tables, for several
-    seeds.
-9. Broaden unit test coverage where playtesting finds thin spots
-    (rings, sticks, wizard commands).
-10. Tag a release once a full game (Amulet retrieval and score entry)
-    completes without defects.
-11. Full-terminal-size support (deferred by explicit decision
-    2026-07-06): per-game dungeon dimensions instead of the 80x24
-    constants; open design questions are resize policy, gameplay
-    tuning at larger sizes, and a --classic 80x24 mode.
-12. Note: this repo is exempt from the standard policy scaffold. Do not
-    add Makefile, Dockerfile, or REPO_POLICIES.md.

cmd/rogue/main.go

@@ -18,84 +18,116 @@ import (
 )
 
 func main() {
+	os.Exit(run())
+}
+
+// run does the real work and returns an exit code. It only returns on a
+// startup error; once the game starts, it ends by exiting the process
+// from within (game.myExit restores the terminal first). The deferred
+// Fini covers the early-return paths.
+func run() int {
 	scores := flag.Bool("s", false, "print the scoreboard and exit")
 	deathDemo := flag.Bool("d", false, "die a random death (demo)")
+
 	flag.Parse()
 
-	home, _ := os.UserHomeDir()
+	params := loadParams()
-
-	// get options from environment (main.c)
-	rogueOpts := os.Getenv("ROGUEOPTS")
-	name := ""
-	if u, err := user.Current(); err == nil {
-		name = u.Username
-	}
-
-	wizard := os.Getenv("ROGUE_WIZARD") != ""
-	// dungeon number: SEED for reproducible dungeons (wizard mode in C),
-	// else time+pid
-	var seed int32
-	if env := os.Getenv("SEED"); env != "" && wizard {
-		n, _ := strconv.Atoi(env)
-		seed = int32(n)
-	} else {
-		seed = int32(time.Now().Unix()) + int32(os.Getpid())
-	}
-
-	cfg := game.Config{
-		Seed:      seed,
-		Name:      name,
-		RogueOpts: rogueOpts,
-		Home:      home,
-		ScorePath: home + "/.rogue.scores",
-		Wizard:    wizard,
-	}
 
 	if *scores {
-		g := game.NewGame(cfg)
+		game.New(params).ShowScores()
-		g.ShowScores()
+
-		return
+		return 0
 	}
 
 	t, err := term.New()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
+
+		return 1
 	}
 	defer t.Fini()
-	cfg.Term = t
+
+	params.Term = t
 
 	var g *game.RogueGame
+
 	if args := flag.Args(); len(args) == 1 && !*deathDemo {
 		// restore a saved game
-		g, err = game.Restore(args[0], cfg)
+		g, err = game.Restore(args[0], params)
 		if err != nil {
-			t.Fini()
+			fmt.Fprintln(os.Stderr, err) // deferred Fini restores the terminal
-			fmt.Fprintln(os.Stderr, err)
+
-			os.Exit(1)
+			return 1
 		}
 	} else {
-		g = game.NewGame(cfg)
+		g = game.New(params)
 	}
 
 	if *deathDemo {
-		g.DeathDemo()
+		g.DeathDemo() // does not return: death exits the process
-		return
+
+		return 0
 	}
 
-	// SIGHUP/SIGTERM autosave (save.c auto_save)
+	installAutosave(g, t)
+
+	g.Run() // does not return: the game ends by exiting the process
+
+	return 0
+}
+
+// loadParams gathers the game parameters from the environment: home
+// directory, ROGUEOPTS, user name, wizard mode, and the dungeon seed
+// (main.c's startup).
+func loadParams() game.Params {
+	home, _ := os.UserHomeDir()
+
+	name := ""
+
+	u, userErr := user.Current()
+	if userErr == nil {
+		name = u.Username
+	}
+
+	wizard := os.Getenv("ROGUE_WIZARD") != ""
+
+	return game.Params{
+		Seed:      chooseSeed(wizard),
+		Name:      name,
+		RogueOpts: os.Getenv("ROGUEOPTS"),
+		Home:      home,
+		ScorePath: home + "/.rogue.scores",
+		Wizard:    wizard,
+	}
+}
+
+// installAutosave saves the game and exits on SIGHUP/SIGTERM (save.c
+// auto_save).
+func installAutosave(g *game.RogueGame, t *term.Tcell) {
 	sig := make(chan os.Signal, 1)
+
 	signal.Notify(sig, syscall.SIGHUP, syscall.SIGTERM)
+
 	go func() {
 		<-sig
 		g.AutoSave()
 		t.Fini()
 		os.Exit(0)
 	}()
+}
 
-	if err := g.Run(); err != nil {
+// chooseSeed picks the dungeon number: SEED for reproducible dungeons
-		t.Fini()
+// (wizard mode, as in the C game), else time+pid (main.c).
-		fmt.Fprintln(os.Stderr, err)
+func chooseSeed(wizard bool) int32 {
-		os.Exit(1)
+	if env := os.Getenv("SEED"); env != "" && wizard {
+		n, err := strconv.ParseInt(env, 10, 32)
+		if err == nil {
+			return int32(n)
 		}
 	}
+
+	// The C game computed `lowtime + getpid()` in int; the truncation to
+	// 32 bits is the same wraparound the C int arithmetic performed.
+	return int32(time.Now().Unix()&0x7fffffff) +
+		int32(os.Getpid()&0x7fffffff)
+}

game/armor.go

@@ -5,36 +5,47 @@ package game
 // wear lets the player put armor on (armor.c wear).
 func (g *RogueGame) wear() {
 	p := &g.Player
-	obj := g.getItem("wear", KindArmor)
+
-	if obj == nil {
+	obj, ok := g.promptPackItem("wear", KindArmor)
+	if !ok {
 		return
 	}
+
 	if p.CurArmor != nil {
-		g.addmsg("you are already wearing some")
+		g.addmsgf("you are already wearing some")
+
 		if !g.Options.Terse {
-			g.addmsg(".  You'll have to take it off first")
+			g.addmsgf(".  You'll have to take it off first")
 		}
+
 		g.endmsg()
 		g.After = false
+
 		return
 	}
+
 	if obj.Kind != KindArmor {
 		g.msg("you can't wear that")
+
 		return
 	}
+
 	g.wasteTime()
 	obj.Flags.Set(Known)
-	sp := g.invName(obj, true)
+	sp := g.inventoryName(obj, true)
 	p.CurArmor = obj
+
 	if !g.Options.Terse {
-		g.addmsg("you are now ")
+		g.addmsgf("you are now ")
 	}
+
 	g.msg("wearing %s", sp)
 }
 
 // takeOff gets the armor off of the player's back (armor.c take_off).
 func (g *RogueGame) takeOff() {
 	p := &g.Player
+
 	obj := p.CurArmor
 	if obj == nil {
 		g.After = false
@@ -43,18 +54,23 @@ func (g *RogueGame) takeOff() {
 		} else {
 			g.msg("you aren't wearing any armor")
 		}
+
 		return
 	}
+
 	if !g.dropCheck(p.CurArmor) {
 		return
 	}
+
 	p.CurArmor = nil
+
 	if g.Options.Terse {
-		g.addmsg("was")
+		g.addmsgf("was")
 	} else {
-		g.addmsg("you used to be")
+		g.addmsgf("you used to be")
 	}
-	g.msg(" wearing %c) %s", obj.PackCh, g.invName(obj, true))
+
+	g.msg(" wearing %c) %s", obj.PackCh, g.inventoryName(obj, true))
 }
 
 // wasteTime does nothing but let other things happen (armor.c waste_time).

game/chase.go

@@ -9,44 +9,61 @@ const dragonShot = 5
 func (g *RogueGame) runners(int) {
 	list := append([]*Monster(nil), g.Level.Monsters...)
 	for _, tp := range list {
-		if !tp.On(Held) && tp.On(Awake) {
+		g.runnerTurn(tp)
-			origPos := tp.Pos
-			wastarget := tp.On(Targeted)
-			if g.moveMonst(tp) == -1 {
-				continue
-			}
-			if tp.On(Flying) && distCp(g.Player.Pos, tp.Pos) >= 3 {
-				if g.moveMonst(tp) == -1 {
-					continue
-				}
-			}
-			if wastarget && origPos != tp.Pos {
-				tp.Flags.Clear(Targeted)
-				g.ToDeath = false
-			}
-		}
 	}
+
 	if g.HasHit {
 		g.endmsg()
 		g.HasHit = false
 	}
 }
 
-// moveMonst executes a single turn of running for a monster (chase.c
+// runnerTurn gives one monster its motion for the turn; flying monsters
-// move_monst). Returns -1 if the monster died or left the level.
+// far from the hero move twice (the loop body of chase.c runners).
-func (g *RogueGame) moveMonst(tp *Monster) int {
+func (g *RogueGame) runnerTurn(tp *Monster) {
+	if tp.On(Held) || !tp.On(Awake) {
+		return
+	}
+
+	origPos := tp.Pos
+
+	wastarget := tp.On(Targeted)
+	if removed := g.moveMonster(tp); removed {
+		return
+	}
+
+	if tp.On(Flying) && distCp(g.Player.Pos, tp.Pos) >= 3 {
+		if removed := g.moveMonster(tp); removed {
+			return
+		}
+	}
+
+	if wastarget && origPos != tp.Pos {
+		tp.Flags.Clear(Targeted)
+
+		g.ToDeath = false
+	}
+}
+
+// moveMonster executes a single turn of running for a monster (chase.c
+// move_monst). The result reports that the monster died or left the
+// level (the C -1 return).
+func (g *RogueGame) moveMonster(tp *Monster) bool {
 	if !tp.On(Slowed) || tp.Turn {
-		if g.doChase(tp) == -1 {
+		if g.chaseStep(tp) {
-			return -1
+			return true
 		}
 	}
+
 	if tp.On(Hasted) {
-		if g.doChase(tp) == -1 {
+		if g.chaseStep(tp) {
-			return -1
+			return true
 		}
 	}
+
 	tp.Turn = !tp.Turn
-	return 0
+
+	return false
 }
 
 // relocate makes the monster's new location be the specified one, updating
@@ -54,18 +71,21 @@ func (g *RogueGame) moveMonst(tp *Monster) int {
 func (g *RogueGame) relocate(th *Monster, newLoc Coord) {
 	if newLoc != th.Pos {
 		g.mvaddch(th.Pos.Y, th.Pos.X, th.OldCh)
-		th.Room = g.roomin(newLoc)
+		th.Room = g.roomIn(newLoc)
-		g.setOldch(th, newLoc)
+		g.setOldChar(th, newLoc)
 		oroom := th.Room
 		g.Level.SetMonsterAt(th.Pos.Y, th.Pos.X, nil)
 
 		if oroom != th.Room {
 			th.Dest = g.findDest(th)
 		}
+
 		th.Pos = newLoc
 		g.Level.SetMonsterAt(newLoc.Y, newLoc.X, th)
 	}
+
 	g.move(newLoc.Y, newLoc.X)
+
 	if g.seeMonst(th) {
 		g.addch(th.Disguise)
 	} else if g.Player.On(SenseMonsters) {
@@ -75,31 +95,80 @@ func (g *RogueGame) relocate(th *Monster, newLoc Coord) {
 	}
 }
 
-// doChase makes one thing chase another (chase.c do_chase). Returns -1 if
+// chaseStep makes one thing chase another (chase.c do_chase). The
-// the chaser died in the attempt.
+// result reports that the chaser died or left the level in the attempt
-func (g *RogueGame) doChase(th *Monster) int {
+// (the C -1 return).
-	p := &g.Player
+func (g *RogueGame) chaseStep(th *Monster) bool {
 	stoprun := false // true means we are there
-	mindist := 32767
+
+	rer, ree, door := g.chaseRooms(th)
+
+	this, shot := g.chaseGoal(th, rer, ree, door, 32767)
+	if shot {
+		return false
+	}
+	// This now contains what we want to run to this time so we run to it.
+	// If we hit it we either want to fight it or stop running
+	if g.chase(th, this) {
+		if th.Type == 'F' {
+			return false
+		}
+	} else {
+		switch this {
+		case g.Player.Pos:
+			return g.attack(th)
+		case *th.Dest:
+			g.chaseTakeObject(th)
+
+			stoprun = th.Type != 'F'
+		}
+	}
+
+	g.relocate(th, g.chRet)
+	// And stop running if need be
+	if stoprun && th.Pos == *th.Dest {
+		th.Flags.Clear(Awake)
+	}
+
+	return false
+}
+
+// chaseRooms finds the rooms of the chaser and its desire; doors do not
+// count as inside rooms here (the setup of chase.c do_chase).
+func (g *RogueGame) chaseRooms(th *Monster) (*Room, *Room, bool) {
+	p := &g.Player
 
 	rer := th.Room // find room of chaser
 	if th.On(Greedy) && rer.GoldVal == 0 {
 		th.Dest = &p.Pos // if gold has been taken, run after hero
 	}
+
 	var ree *Room // find room of chasee
 	if th.Dest == &p.Pos {
 		ree = p.Room
 	} else {
-		ree = g.roomin(*th.Dest)
+		ree = g.roomIn(*th.Dest)
 	}
-	// We don't count doors as inside rooms for this routine
+
-	door := g.Level.Char(th.Pos.Y, th.Pos.X) == Door
+	return rer, ree, g.Level.Char(th.Pos.Y, th.Pos.X) == Door
+}
+
+// chaseGoal picks the spot the chaser runs toward this turn: the
+// nearest exit toward its desire when it is in a different room, or the
+// desire itself. shot means a dragon breathed flame instead of moving
+// (the goal loop of chase.c do_chase).
+func (g *RogueGame) chaseGoal(th *Monster, rer, ree *Room, door bool, mindist int) (Coord, bool) {
 	var this Coord
 
-over:
+	for {
-	// If the object of our desire is in a different room, and we are not
+		// If the object of our desire is in a different room, and we are
-	// in a corridor, run to the door nearest to our goal.
+		// not in a corridor, run to the door nearest to our goal.
-	if rer != ree {
+		if rer == ree {
+			this = *th.Dest
+
+			return this, g.dragonBreath(th)
+		}
+
 		for i := range rer.Exits {
 			curdist := distCp(*th.Dest, rer.Exits[i])
 			if curdist < mindist {
@@ -107,79 +176,86 @@ over:
 				mindist = curdist
 			}
 		}
-		if door {
+
+		if !door {
+			return this, false
+		}
+
 		rer = &g.Level.Passages[*g.Level.FlagsAt(th.Pos.Y, th.Pos.X)&FPassNum]
 		door = false
-			goto over
+		// the C goto over: redo with the passage as room
 	}
-	} else {
+}
-		this = *th.Dest
+
-		// For dragons check and see if (a) the hero is on a straight line
+// dragonBreath checks whether a dragon shoots flame at the hero instead
-		// from it, and (b) that it is within shooting distance, but
+// of moving, and shoots it (the D block of chase.c do_chase).
-		// outside of striking range.
+func (g *RogueGame) dragonBreath(th *Monster) bool {
-		if th.Type == 'D' && (th.Pos.Y == p.Pos.Y || th.Pos.X == p.Pos.X ||
+	if th.Type != 'D' || !g.dragonShoots(th) {
-			abs(th.Pos.Y-p.Pos.Y) == abs(th.Pos.X-p.Pos.X)) &&
+		return false
-			distCp(th.Pos, p.Pos) <= BoltLength*BoltLength &&
+	}
-			!th.On(Cancelled) && g.rnd(dragonShot) == 0 {
+
+	p := &g.Player
+
 	g.Delta.Y = sign(p.Pos.Y - th.Pos.Y)
+
 	g.Delta.X = sign(p.Pos.X - th.Pos.X)
 	if g.HasHit {
 		g.endmsg()
 	}
+
 	g.fireBolt(th.Pos, &g.Delta, "flame")
 	g.Running = false
 	g.Count = 0
+
 	g.Quiet = 0
 	if g.ToDeath && !th.On(Targeted) {
 		g.ToDeath = false
 		g.Kamikaze = false
 	}
-			return 0
+
+	return true
 }
+
+// dragonShoots decides whether the dragon takes the shot: the hero is
+// on a straight line from it, within shooting distance but outside
+// striking range, it is not cancelled, and the shot roll comes up
+// (chase.c do_chase).
+func (g *RogueGame) dragonShoots(th *Monster) bool {
+	p := &g.Player
+	if th.Pos.Y != p.Pos.Y && th.Pos.X != p.Pos.X &&
+		abs(th.Pos.Y-p.Pos.Y) != abs(th.Pos.X-p.Pos.X) {
+		return false
 	}
-	// This now contains what we want to run to this time so we run to it.
+
-	// If we hit it we either want to fight it or stop running
+	return distCp(th.Pos, p.Pos) <= BoltLength*BoltLength &&
-	if !g.chase(th, this) {
+		!th.On(Cancelled) && g.rnd(dragonShot) == 0
-		if this == p.Pos {
+}
-			return g.attack(th)
+
-		} else if this == *th.Dest {
+// chaseTakeObject has the monster pick up the object it was running to
+// (the dest arm of chase.c do_chase).
+func (g *RogueGame) chaseTakeObject(th *Monster) {
 	for _, obj := range g.Level.Objects {
 		if th.Dest == &obj.Pos {
-					detachObj(&g.Level.Objects, obj)
+			g.Level.RemoveObject(obj)
 			attachObj(&th.Pack, obj)
+
 			if th.Room.Flags.Has(Gone) {
 				g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Passage)
 			} else {
 				g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Floor)
 			}
+
 			th.Dest = g.findDest(th)
+
 			break
 		}
 	}
-			if th.Type != 'F' {
-				stoprun = true
-			}
-		}
-	} else {
-		if th.Type == 'F' {
-			return 0
-		}
-	}
-	g.relocate(th, g.chRet)
-	// And stop running if need be
-	if stoprun && th.Pos == *th.Dest {
-		th.Flags.Clear(Awake)
-	}
-	return 0
 }
 
 // chase finds the spot for the chaser to move closer to the chasee
 // (chase.c chase). Returns true if we want to keep on chasing later, false
 // if we reach the goal. The chosen spot lands in g.chRet.
 func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
-	p := &g.Player
-	er := tp.Pos
-	plcnt := 1
 	var curdist int
 
 	// If the thing is confused, let it move randomly. Invisible Stalkers
@@ -188,24 +264,41 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 	if (tp.On(Confused) && g.rnd(5) != 0) || (tp.Type == 'P' && g.rnd(5) == 0) ||
 		(tp.Type == 'B' && g.rnd(2) == 0) {
 		// get a valid random move
-		g.chRet = g.rndmove(&tp.Creature)
+		g.chRet = g.randomStep(&tp.Creature)
 		curdist = distCp(g.chRet, ee)
 		// Small chance that it will become un-confused
 		if g.rnd(20) == 0 {
 			tp.Flags.Clear(Confused)
 		}
 	} else {
-		// Otherwise, find the empty spot next to the chaser that is
+		curdist = g.chaseBestSpot(tp, ee)
-		// closest to the chasee. This will eventually hold where we move
+	}
-		// to get closer. If we can't find an empty spot, we stay where we
+
-		// are.
+	return curdist != 0 && g.chRet != g.Player.Pos
-		curdist = distCp(er, ee)
+}
+
+// chaseSearch is the scan state while chase looks for the step that
+// gets a monster closest to its chasee.
+type chaseSearch struct {
+	er      Coord // where the chaser is
+	ee      Coord // where it wants to go
+	curdist int
+	plcnt   int
+}
+
+// chaseBestSpot finds the empty spot next to the chaser that is closest
+// to the chasee, leaving it in g.chRet; if there is none, the chaser
+// stays where it is (the search half of chase.c chase).
+func (g *RogueGame) chaseBestSpot(tp *Monster, ee Coord) int {
+	er := tp.Pos
+	s := chaseSearch{er: er, ee: ee, curdist: distCp(er, ee), plcnt: 1}
 	g.chRet = er
 
 	ey := er.Y + 1
 	if ey >= NumLines-1 {
 		ey = NumLines - 2
 	}
+
 	ex := er.X + 1
 	if ex >= NumCols {
 		ex = NumCols - 1
@@ -215,58 +308,71 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 		if x < 0 {
 			continue
 		}
+
 		for y := er.Y - 1; y <= ey; y++ {
+			g.chaseTry(&s, y, x)
+		}
+	}
+
+	return s.curdist
+}
+
+// chaseTry scores one candidate square, reservoir-sampling among ties
+// (the scan body of chase.c chase).
+func (g *RogueGame) chaseTry(s *chaseSearch, y, x int) {
 	tryp := Coord{X: x, Y: y}
-				if !g.diagOk(er, tryp) {
+	if !g.diagOk(s.er, tryp) {
-					continue
+		return
 	}
+
 	ch := g.Level.VisibleChar(y, x)
-				if stepOk(ch) {
+	if !stepOk(ch) {
-					// If it is a scroll, it might be a scare monster
+		return
-					// scroll so we need to look it up to see what type
-					// it is.
-					if ch == Scroll {
-						var found *Object
-						for _, obj := range g.Level.Objects {
-							if y == obj.Pos.Y && x == obj.Pos.X {
-								found = obj
-								break
-							}
-						}
-						if found != nil && found.ScrollKind() == ScrollScareMonster {
-							continue
 	}
+	// If it is a scroll, it might be a scare monster scroll so we need
+	// to look it up to see what type it is.
+	if ch == Scroll && g.scareScrollAt(y, x) {
+		return
 	}
 	// It can also be a Xeroc, which we shouldn't step on
 	if m := g.Level.MonsterAt(y, x); m != nil && m.Type == 'X' {
-						continue
+		return
 	}
-					// If we didn't find any scrolls at this place or it
+	// If we didn't find any scrolls at this place or it wasn't a scare
-					// wasn't a scare scroll, then this place counts
+	// scroll, then this place counts
-					thisdist := distance(y, x, ee.Y, ee.X)
+	thisdist := distance(y, x, s.ee.Y, s.ee.X)
-					if thisdist < curdist {
+	if thisdist < s.curdist {
-						plcnt = 1
+		s.plcnt = 1
 		g.chRet = tryp
-						curdist = thisdist
+		s.curdist = thisdist
-					} else if thisdist == curdist {
+	} else if thisdist == s.curdist {
-						if plcnt++; g.rnd(plcnt) == 0 {
+		if s.plcnt++; g.rnd(s.plcnt) == 0 {
 			g.chRet = tryp
-							curdist = thisdist
+			s.curdist = thisdist
 		}
 	}
 }
-			}
-		}
-	}
-	return curdist != 0 && g.chRet != p.Pos
-}
 
-// setOldch sets the oldch character for the monster (chase.c set_oldch).
+// scareScrollAt reports whether the object lying at (y, x) is a scare
-func (g *RogueGame) setOldch(tp *Monster, cp Coord) {
+// monster scroll (chase.c chase).
+func (g *RogueGame) scareScrollAt(y, x int) bool {
+	for _, obj := range g.Level.Objects {
+		if y == obj.Pos.Y && x == obj.Pos.X {
+			return obj.ScrollKind() == ScrollScareMonster
+		}
+	}
+
+	return false
+}
+
+// setOldChar sets the oldch character for the monster (chase.c set_oldch).
+func (g *RogueGame) setOldChar(tp *Monster, cp Coord) {
 	if tp.Pos == cp {
 		return
 	}
+
 	sch := tp.OldCh
+
 	tp.OldCh = g.mvinch(cp.Y, cp.X)
 	if !g.Player.On(Blind) {
 		if (sch == Floor || tp.OldCh == Floor) && tp.Room.Flags.Has(Dark) {
@@ -284,25 +390,30 @@ func (g *RogueGame) seeMonst(mp *Monster) bool {
 	if p.On(Blind) {
 		return false
 	}
+
 	if mp.On(Invisible) && !p.On(CanSeeInvisible) {
 		return false
 	}
+
 	y, x := mp.Pos.Y, mp.Pos.X
 	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
 		if y != p.Pos.Y && x != p.Pos.X &&
 			!stepOk(g.Level.Char(y, p.Pos.X)) && !stepOk(g.Level.Char(p.Pos.Y, x)) {
 			return false
 		}
+
 		return true
 	}
+
 	if mp.Room != p.Room {
 		return false
 	}
+
 	return !mp.Room.Flags.Has(Dark)
 }
 
-// runto sets a monster running after the hero (chase.c runto).
+// runTo sets a monster running after the hero (chase.c runto).
-func (g *RogueGame) runto(runner Coord) {
+func (g *RogueGame) runTo(runner Coord) {
 	tp := g.Level.MonsterAt(runner.Y, runner.X)
 	if tp == nil {
 		return
@@ -313,9 +424,9 @@ func (g *RogueGame) runto(runner Coord) {
 	tp.Dest = g.findDest(tp)
 }
 
-// roomin finds what room some coordinates are in; nil means they aren't in
+// roomIn finds what room some coordinates are in; nil means they aren't in
 // any room (chase.c roomin).
-func (g *RogueGame) roomin(cp Coord) *Room {
+func (g *RogueGame) roomIn(cp Coord) *Room {
 	fp := *g.Level.FlagsAt(cp.Y, cp.X)
 	if fp.Has(FPassage) {
 		return &g.Level.Passages[fp&FPassNum]
@@ -330,6 +441,7 @@ func (g *RogueGame) roomin(cp Coord) *Room {
 	}
 
 	g.msg("in some bizarre place (%d, %d)", cp.Y, cp.X)
+
 	return nil
 }
 
@@ -338,19 +450,22 @@ func (g *RogueGame) diagOk(sp, ep Coord) bool {
 	if ep.X < 0 || ep.X >= NumCols || ep.Y <= 0 || ep.Y >= NumLines-1 {
 		return false
 	}
+
 	if ep.X == sp.X || ep.Y == sp.Y {
 		return true
 	}
+
 	return stepOk(g.Level.Char(ep.Y, sp.X)) && stepOk(g.Level.Char(sp.Y, ep.X))
 }
 
-// cansee returns true if the hero can see a certain coordinate (chase.c
+// canSee returns true if the hero can see a certain coordinate (chase.c
 // cansee).
-func (g *RogueGame) cansee(y, x int) bool {
+func (g *RogueGame) canSee(y, x int) bool {
 	p := &g.Player
 	if p.On(Blind) {
 		return false
 	}
+
 	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
 		if g.Level.FlagsAt(y, x).Has(FPassage) {
 			if y != p.Pos.Y && x != p.Pos.X &&
@@ -359,11 +474,13 @@ func (g *RogueGame) cansee(y, x int) bool {
 				return false
 			}
 		}
+
 		return true
 	}
 	// We can only see if the hero is in the same room as the coordinate
 	// and the room is lit, or if it is close.
-	rer := g.roomin(Coord{X: x, Y: y})
+	rer := g.roomIn(Coord{X: x, Y: y})
+
 	return rer == p.Room && !rer.Flags.Has(Dark)
 }
 
@@ -374,22 +491,29 @@ func (g *RogueGame) findDest(tp *Monster) *Coord {
 	if prob <= 0 || tp.Room == g.Player.Room || g.seeMonst(tp) {
 		return &g.Player.Pos
 	}
+
 	for _, obj := range g.Level.Objects {
 		if obj.Kind == KindScroll && obj.ScrollKind() == ScrollScareMonster {
 			continue
 		}
-		if g.roomin(obj.Pos) == tp.Room && g.rnd(100) < prob {
+
-			claimed := false
+		if g.roomIn(obj.Pos) == tp.Room && g.rnd(100) < prob &&
-			for _, other := range g.Level.Monsters {
+			!g.objectClaimed(obj) {
-				if other.Dest == &obj.Pos {
-					claimed = true
-					break
-				}
-			}
-			if !claimed {
 			return &obj.Pos
 		}
 	}
-	}
+
 	return &g.Player.Pos
 }
+
+// objectClaimed reports whether some monster already runs toward this
+// object (chase.c find_dest).
+func (g *RogueGame) objectClaimed(obj *Object) bool {
+	for _, other := range g.Level.Monsters {
+		if other.Dest == &obj.Pos {
+			return true
+		}
+	}
+
+	return false
+}

game/creature.go

@@ -23,6 +23,7 @@ type Monster struct {
 // in the C sources (cur_armor, purse, food_left, ...).
 type Player struct {
 	Creature
+
 	CurArmor    *Object    // what he is wearing
 	CurWeapon   *Object    // which weapon he is wielding
 	CurRing     [2]*Object // which rings are being worn (Left/Right)
@@ -49,6 +50,47 @@ func (p *Player) IsWearing(ring RingKind) bool {
 	return p.IsRing(Left, ring) || p.IsRing(Right, ring)
 }
 
+// nextPackChar claims and returns the next unused pack character (pack.c
+// pack_char).
+func (p *Player) nextPackChar() byte {
+	for i := range p.PackUsed {
+		if !p.PackUsed[i] {
+			p.PackUsed[i] = true
+
+			return byte(i) + 'a'
+		}
+	}
+
+	return byte(len(p.PackUsed)) + 'a' // C would walk off the array here
+}
+
+// removeFromPack takes an item out of the pack: the whole entry, or one
+// of a stack when all is false (the bookkeeping half of pack.c
+// leave_pack). It returns the object that left the pack — a copy when
+// newobj asks for a split.
+func (p *Player) removeFromPack(obj *Object, newobj, all bool) *Object {
+	p.Inpack--
+
+	nobj := obj
+	if obj.Count > 1 && !all {
+		obj.Count--
+		if obj.Group != 0 {
+			p.Inpack++
+		}
+
+		if newobj {
+			copied := *obj
+			nobj = &copied
+			nobj.Count = 1
+		}
+	} else {
+		p.PackUsed[obj.PackCh-'a'] = false
+		detachObj(&p.Pack, obj)
+	}
+
+	return nobj
+}
+
 // attachMon pushes a monster onto the front of a list (list.c attach).
 func attachMon(list *[]*Monster, item *Monster) {
 	*list = append([]*Monster{item}, *list...)
@@ -59,6 +101,7 @@ func detachMon(list *[]*Monster, item *Monster) {
 	for i, m := range *list {
 		if m == item {
 			*list = append((*list)[:i], (*list)[i+1:]...)
+
 			return
 		}
 	}

game/daemon.go

@@ -10,6 +10,10 @@ package game
 // function-pointer-to-int mapping in state.c rs_write_daemons.
 type DaemonID int
 
+// Daemon and fuse callback identifiers. The first block's numeric values
+// match the function-pointer-to-int mapping in state.c rs_write_daemons;
+// the second block covers fuses state.c never saved (the Go save format
+// handles them all uniformly).
 const (
 	DNone      DaemonID = 0
 	DRollwand  DaemonID = 1
@@ -21,8 +25,6 @@ const (
 	DUnconfuse DaemonID = 7
 	DUnsee     DaemonID = 8
 	DSight     DaemonID = 9
-	// Fuses beyond the C save map (state.c never saved these; the Go save
-	// format handles them uniformly).
 	DVisuals   DaemonID = 10
 	DComeDown  DaemonID = 11
 	DLand      DaemonID = 12
@@ -59,6 +61,7 @@ func (g *RogueGame) dSlot() *delayedAction {
 			return &g.Daemons.List[i]
 		}
 	}
+
 	panic("ran out of fuse slots") // C: debug message in MASTER, NULL deref otherwise
 }
 
@@ -70,6 +73,7 @@ func (g *RogueGame) findSlot(f DaemonID) *delayedAction {
 			return d
 		}
 	}
+
 	return nil
 }
 

game/daemons.go

@@ -5,38 +5,14 @@ package game
 
 // runDaemon invokes the callback named by id (the call through d_func in C).
 func (g *RogueGame) runDaemon(id DaemonID, arg int) {
-	switch id {
+	h := g.data.daemonHandlers[id]
-	case DRollwand:
+	if h == nil {
-		g.rollwand(arg)
+		// Handlers are added to the table as their subsystems are
-	case DDoctor:
+		// ported; reaching one that isn't there is a porting bug.
-		g.doctor(arg)
-	case DStomach:
-		g.stomach(arg)
-	case DRunners:
-		g.runners(arg)
-	case DSwander:
-		g.swander(arg)
-	case DNohaste:
-		g.nohaste(arg)
-	case DUnconfuse:
-		g.unconfuse(arg)
-	case DUnsee:
-		g.unsee(arg)
-	case DSight:
-		g.sight(arg)
-	case DVisuals:
-		g.visuals(arg)
-	case DComeDown:
-		g.comeDown(arg)
-	case DLand:
-		g.land(arg)
-	case DTurnSee:
-		g.turnSee(arg != 0)
-	default:
-		// Callbacks are added to this switch as their subsystems are
-		// ported; reaching one that isn't here is a porting bug.
 		panic("daemon not yet ported")
 	}
+
+	h(g, arg)
 }
 
 // doctor is the healing daemon that restores hit points after rest
@@ -45,6 +21,7 @@ func (g *RogueGame) doctor(int) {
 	p := &g.Player
 	lv := p.Stats.Lvl
 	ohp := p.Stats.HP
+
 	g.Quiet++
 	if lv < 8 {
 		if g.Quiet+(lv<<1) > 20 {
@@ -53,16 +30,20 @@ func (g *RogueGame) doctor(int) {
 	} else if g.Quiet >= 3 {
 		p.Stats.HP += g.rnd(lv-7) + 1
 	}
+
 	if p.IsRing(Left, RingRegeneration) {
 		p.Stats.HP++
 	}
+
 	if p.IsRing(Right, RingRegeneration) {
 		p.Stats.HP++
 	}
+
 	if ohp != p.Stats.HP {
 		if p.Stats.HP > p.Stats.MaxHP {
 			p.Stats.HP = p.Stats.MaxHP
 		}
+
 		g.Quiet = 0
 	}
 }
@@ -82,6 +63,7 @@ func (g *RogueGame) rollwand(int) {
 			g.KillDaemon(DRollwand)
 			g.Fuse(DSwander, 0, wanderTime(g), Before)
 		}
+
 		g.Daemons.Between = 0
 	}
 }
@@ -103,6 +85,7 @@ func (g *RogueGame) unsee(int) {
 			g.mvaddch(th.Pos.Y, th.Pos.X, th.OldCh)
 		}
 	}
+
 	g.Player.Flags.Clear(CanSeeInvisible)
 }
 
@@ -112,9 +95,11 @@ func (g *RogueGame) sight(int) {
 	if p.On(Blind) {
 		g.Extinguish(DSight)
 		p.Flags.Clear(Blind)
+
 		if !p.Room.Flags.Has(Gone) {
 			g.enterRoom(p.Pos)
 		}
+
 		g.msg("%s", g.chooseStr("far out!  Everything is all cosmic again",
 			"the veil of darkness lifts"))
 	}
@@ -129,8 +114,27 @@ func (g *RogueGame) nohaste(int) {
 // stomach digests the hero's food (daemons.c stomach).
 func (g *RogueGame) stomach(int) {
 	p := &g.Player
+
 	origHungry := p.HungryState
 	if p.FoodLeft <= 0 {
+		g.stomachFaint()
+	} else {
+		g.stomachDigest()
+	}
+
+	if p.HungryState != origHungry {
+		p.Flags.Clear(Awake)
+
+		g.Running = false
+		g.ToDeath = false
+		g.Count = 0
+	}
+}
+
+// stomachFaint starves and possibly faints an empty-stomached hero (the
+// no-food arm of daemons.c stomach).
+func (g *RogueGame) stomachFaint() {
+	p := &g.Player
 	if p.FoodLeft--; p.FoodLeft < -StarveTime {
 		g.death('s')
 	}
@@ -138,29 +142,41 @@ func (g *RogueGame) stomach(int) {
 	if g.NoCommand != 0 || g.rnd(5) != 0 {
 		return
 	}
+
 	g.NoCommand += g.rnd(8) + 4
 	p.HungryState = 3
+
 	if !g.Options.Terse {
-			g.addmsg("%s", g.chooseStr(
+		g.addmsgf("%s", g.chooseStr(
 			"the munchies overpower your motor capabilities.  ",
 			"you feel too weak from lack of food.  "))
 	}
+
 	g.msg("%s", g.chooseStr("You freak out", "You faint"))
-	} else {
+}
+
+// stomachDigest burns food and reports growing hunger (the fed arm of
+// daemons.c stomach).
+func (g *RogueGame) stomachDigest() {
+	p := &g.Player
 	oldfood := p.FoodLeft
+
 	amulet := 0
 	if g.HasAmulet {
 		amulet = 1
 	}
+
 	p.FoodLeft -= g.ringEat(Left) + g.ringEat(Right) + 1 - amulet
 
 	if p.FoodLeft < MoreTime && oldfood >= MoreTime {
 		p.HungryState = 2
+
 		g.msg("%s", g.chooseStr(
-				"the munchies are interfering with your motor capabilites",
+			"the munchies are interfering with your motor capabilities",
 			"you are starting to feel weak"))
 	} else if p.FoodLeft < 2*MoreTime && oldfood >= 2*MoreTime {
 		p.HungryState = 1
+
 		if g.Options.Terse {
 			g.msg("%s", g.chooseStr("getting the munchies", "getting hungry"))
 		} else {
@@ -169,13 +185,6 @@ func (g *RogueGame) stomach(int) {
 		}
 	}
 }
-	if p.HungryState != origHungry {
-		p.Flags.Clear(Awake)
-		g.Running = false
-		g.ToDeath = false
-		g.Count = 0
-	}
-}
 
 // comeDown takes the hero down off her acid trip (daemons.c come_down).
 func (g *RogueGame) comeDown(int) {
@@ -193,16 +202,18 @@ func (g *RogueGame) comeDown(int) {
 
 	// undo the things
 	for _, tp := range g.Level.Objects {
-		if g.cansee(tp.Pos.Y, tp.Pos.X) {
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
 			g.mvaddch(tp.Pos.Y, tp.Pos.X, tp.Kind.Glyph())
 		}
 	}
 
 	// undo the monsters
 	seemonst := p.On(SenseMonsters)
+
 	for _, tp := range g.Level.Monsters {
 		g.move(tp.Pos.Y, tp.Pos.X)
-		if g.cansee(tp.Pos.Y, tp.Pos.X) {
+
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
 			if !tp.On(Invisible) || p.On(CanSeeInvisible) {
 				g.addch(tp.Disguise)
 			} else {
@@ -214,41 +225,49 @@ func (g *RogueGame) comeDown(int) {
 			g.standend()
 		}
 	}
+
 	g.msg("Everything looks SO boring now.")
 }
 
 // visuals changes the characters for the player while hallucinating
 // (daemons.c visuals).
 func (g *RogueGame) visuals(int) {
-	p := &g.Player
 	if !g.After || (g.Running && g.Options.Jump) {
 		return
 	}
 	// change the things
 	for _, tp := range g.Level.Objects {
-		if g.cansee(tp.Pos.Y, tp.Pos.X) {
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
 			g.mvaddch(tp.Pos.Y, tp.Pos.X, g.rndThing())
 		}
 	}
 
 	// change the stairs
-	if !g.SeenStairs && g.cansee(g.Level.Stairs.Y, g.Level.Stairs.X) {
+	if !g.SeenStairs && g.canSee(g.Level.Stairs.Y, g.Level.Stairs.X) {
 		g.mvaddch(g.Level.Stairs.Y, g.Level.Stairs.X, g.rndThing())
 	}
 
 	// change the monsters
-	seemonst := p.On(SenseMonsters)
+	g.visualMonsters()
+}
+
+// visualMonsters redraws the monsters through the hallucination (the
+// monster loop of daemons.c visuals).
+func (g *RogueGame) visualMonsters() {
+	seemonst := g.Player.On(SenseMonsters)
+
 	for _, tp := range g.Level.Monsters {
 		g.move(tp.Pos.Y, tp.Pos.X)
+
 		if g.seeMonst(tp) {
 			if tp.Type == 'X' && tp.Disguise != 'X' {
 				g.addch(g.rndThing())
 			} else {
-				g.addch(byte(g.rnd(26) + 'A'))
+				g.addch(g.randomMonsterLetter())
 			}
 		} else if seemonst {
 			g.standout()
-			g.addch(byte(g.rnd(26) + 'A'))
+			g.addch(g.randomMonsterLetter())
 			g.standend()
 		}
 	}

game/dice.go

@@ -25,20 +25,26 @@ type DiceSpec []DiceRoll
 // a single 0x0 attack, as it did in C.
 func ParseDice(s string) DiceSpec {
 	var spec DiceSpec
+
 	for s != "" {
 		count := cAtoi(s)
+
 		xi := strings.IndexByte(s, 'x')
 		if xi < 0 {
 			break
 		}
+
 		s = s[xi+1:]
 		spec = append(spec, DiceRoll{Count: count, Sides: cAtoi(s)})
+
 		si := strings.IndexByte(s, '/')
 		if si < 0 {
 			break
 		}
+
 		s = s[si+1:]
 	}
+
 	return spec
 }
 
@@ -48,11 +54,14 @@ func dice(s string) DiceSpec { return ParseDice(s) }
 // String renders the spec back in the classic "NxM/NxM" form.
 func (d DiceSpec) String() string {
 	var sb strings.Builder
+
 	for i, r := range d {
 		if i > 0 {
 			sb.WriteByte('/')
 		}
+
 		fmt.Fprintf(&sb, "%dx%d", r.Count, r.Sides)
 	}
+
 	return sb.String()
 }

game/dice_test.go

@@ -32,14 +32,16 @@ func TestParseDice(t *testing.T) {
 // The bestiary and weapon tables must parse to at least one attack each so
 // every creature and weapon actually swings.
 func TestTablesHaveDice(t *testing.T) {
-	for i, m := range monsterTable {
+	data := newGameData()
+	for i, m := range data.monsterTable {
 		if len(m.Stats.Dmg) == 0 {
 			t.Errorf("monster %c (%s) has no attacks", 'A'+i, m.Name)
 		}
 	}
-	for w, iw := range initWeaps {
+
+	for w, iw := range data.initWeaps {
 		if len(iw.dam) == 0 || len(iw.hrl) == 0 {
-			t.Errorf("weapon %v has empty dice", WeaponKind(w))
+			t.Errorf("weapon %d has empty dice", w)
 		}
 	}
 }

game/effects_test.go

@@ -2,13 +2,16 @@ package game
 
 import "testing"
 
-// mkGameInput builds a headless game whose input plays the given script.
+// mkGameInput builds a headless game; tests script it via setInput. The
-func mkGameInput(t *testing.T, seed int32, input string) *RogueGame {
+// fixed seed keeps the scripted item/monster interactions stable.
+func mkGameInput(t *testing.T) *RogueGame {
 	t.Helper()
-	g := NewGame(Config{Seed: seed, Term: &testTerm{input: []byte(input)}})
+
+	g := New(Params{Seed: 5, Term: &testTerm{}})
 	g.NewLevel()
 	g.Oldpos = g.Player.Pos
-	g.Oldrp = g.roomin(g.Player.Pos)
+	g.Oldrp = g.roomIn(g.Player.Pos)
+
 	return g
 }
 
@@ -16,42 +19,61 @@ func mkGameInput(t *testing.T, seed int32, input string) *RogueGame {
 func give(g *RogueGame, obj *Object) byte {
 	obj.Count = 1
 	g.addPack(obj, true)
+
 	return obj.PackCh
 }
 
+// setInput replaces the scripted terminal input.
+func setInput(t *testing.T, g *RogueGame, input ...byte) {
+	t.Helper()
+
+	tt, ok := g.scr.term.(*testTerm)
+	if !ok {
+		t.Fatal("game terminal is not a testTerm")
+	}
+
+	tt.input = input
+	tt.pos = 0
+}
+
 func TestQuaffHealingPotion(t *testing.T) {
-	g := mkGameInput(t, 5, "")
+	g := mkGameInput(t)
 	pot := newObject()
 	pot.Kind = KindPotion
 	pot.Which = int(PotionHealing)
 	ch := give(g, pot)
-	g.scr.term.(*testTerm).input = []byte{ch}
+	setInput(t, g, ch)
 
 	g.Player.Stats.HP = 1
 	g.quaff()
+
 	if g.Player.Stats.HP <= 1 {
 		t.Error("healing potion did not heal")
 	}
+
 	if !g.Items.Potions[PotionHealing].Know {
 		t.Error("healing potion not identified after drinking")
 	}
+
 	if len(g.Player.Pack) != 5 {
 		t.Errorf("potion not consumed: %d items", len(g.Player.Pack))
 	}
 }
 
 func TestQuaffConfusionSetsFlagAndFuse(t *testing.T) {
-	g := mkGameInput(t, 5, "")
+	g := mkGameInput(t)
 	pot := newObject()
 	pot.Kind = KindPotion
 	pot.Which = int(PotionConfusion)
 	ch := give(g, pot)
-	g.scr.term.(*testTerm).input = []byte{ch}
+	setInput(t, g, ch)
 
 	g.quaff()
+
 	if !g.Player.On(Confused) {
 		t.Error("confusion potion did not confuse")
 	}
+
 	if g.findSlot(DUnconfuse) == nil {
 		t.Error("no unconfuse fuse pending")
 	}
@@ -59,21 +81,23 @@ func TestQuaffConfusionSetsFlagAndFuse(t *testing.T) {
 	for range 30 {
 		g.DoFuses(After)
 	}
+
 	if g.Player.On(Confused) {
 		t.Error("confusion never wore off")
 	}
 }
 
 func TestReadEnchantArmor(t *testing.T) {
-	g := mkGameInput(t, 5, "")
+	g := mkGameInput(t)
 	scr := newObject()
 	scr.Kind = KindScroll
 	scr.Which = int(ScrollEnchantArmor)
 	ch := give(g, scr)
-	g.scr.term.(*testTerm).input = []byte{ch}
+	setInput(t, g, ch)
 
 	before := g.Player.CurArmor.ArmorClass
 	g.readScroll()
+
 	if g.Player.CurArmor.ArmorClass != before-1 {
 		t.Errorf("enchant armor: AC %d -> %d, want %d",
 			before, g.Player.CurArmor.ArmorClass, before-1)
@@ -86,17 +110,19 @@ func TestReadHoldMonsterFreezesAdjacent(t *testing.T) {
 	// look(TRUE) at the end of read_scroll immediately re-wakes greedy
 	// monsters. The port reproduces that quirk faithfully — see
 	// TestHoldScrollGreedyMonsterQuirk.
-	g := mkGameInput(t, 5, "")
+	g := mkGameInput(t)
 	tp := spawnAdjacent(g, 'Z')
 	tp.Flags.Set(Awake)
+
 	scr := newObject()
 	scr.Kind = KindScroll
 	scr.Which = int(ScrollHoldMonster)
 	ch := give(g, scr)
-	g.scr.term.(*testTerm).input = []byte{ch}
+	setInput(t, g, ch)
 
 	g.readScroll()
 	t.Logf("after scroll: flags=%o huh=%q", tp.Flags, g.Msgs.Huh)
+
 	if tp.On(Awake) || !tp.On(Held) {
 		t.Error("hold monster scroll did not hold the adjacent monster")
 	}
@@ -107,21 +133,24 @@ func TestReadHoldMonsterFreezesAdjacent(t *testing.T) {
 // (orc) held by a scroll is re-woken by the look(TRUE) that read_scroll
 // performs, ending up both held and running again.
 func TestHoldScrollGreedyMonsterQuirk(t *testing.T) {
-	g := mkGameInput(t, 5, "")
+	g := mkGameInput(t)
 	tp := spawnAdjacent(g, 'O')
 	tp.Flags.Set(Awake)
+
 	scr := newObject()
 	scr.Kind = KindScroll
 	scr.Which = int(ScrollHoldMonster)
 	ch := give(g, scr)
-	g.scr.term.(*testTerm).input = []byte{ch}
+	setInput(t, g, ch)
 
 	g.readScroll()
 	t.Logf("orc after scroll: flags=%o (Awake=%v Held=%v)",
 		tp.Flags, tp.On(Awake), tp.On(Held))
+
 	if !tp.On(Held) {
 		t.Error("orc lost Held entirely")
 	}
+
 	if !tp.On(Awake) {
 		t.Error("quirk changed: greedy monster stayed held; if this is a " +
 			"deliberate fix, update this test and ARCHITECTURE.md")
@@ -129,41 +158,50 @@ func TestHoldScrollGreedyMonsterQuirk(t *testing.T) {
 }
 
 func TestZapSlowMonster(t *testing.T) {
-	g := mkGameInput(t, 5, "")
+	g := mkGameInput(t)
 	tp := spawnAdjacent(g, 'Z')
 	stick := newObject()
 	stick.Kind = KindWand
 	stick.Which = int(WandSlowMonster)
 	g.fixStick(stick)
 	ch := give(g, stick)
-	g.scr.term.(*testTerm).input = []byte{ch}
+	setInput(t, g, ch)
+
 	g.Delta = Coord{X: 1, Y: 0} // aim at the monster
 
 	charges := stick.Charges
+
 	g.doZap()
+
 	if !tp.On(Slowed) {
 		t.Error("slow monster wand did not slow")
 	}
+
 	if stick.Charges != charges-1 {
 		t.Error("zap did not use a charge")
 	}
 }
 
 func TestParseOpts(t *testing.T) {
-	g := NewGame(Config{Seed: 1})
+	g := New(Params{Seed: 1})
 	g.ParseOpts("terse,nojump,name=Conan,fruit=mango,inven=slow")
+
 	if !g.Options.Terse {
 		t.Error("terse not set")
 	}
+
 	if g.Options.Jump {
 		t.Error("nojump not honored")
 	}
+
 	if g.Whoami != "Conan" {
 		t.Errorf("name = %q", g.Whoami)
 	}
+
 	if g.Fruit != "mango" {
 		t.Errorf("fruit = %q", g.Fruit)
 	}
+
 	if g.Options.InvType != InvSlow {
 		t.Errorf("inven = %d", g.Options.InvType)
 	}

game/fight.go

@@ -4,43 +4,6 @@ import "strconv"
 
 // fight.c — all the fighting gets done here.
 
-// hNames are the strings for hitting; the first four are used when the
-// player strikes, the second four for monsters (fight.c h_names).
-var hNames = [8]string{
-	" scored an excellent hit on ",
-	" hit ",
-	" have injured ",
-	" swing and hit ",
-	" scored an excellent hit on ",
-	" hit ",
-	" has injured ",
-	" swings and hits ",
-}
-
-// mNames are the strings for missing (fight.c m_names).
-var mNames = [8]string{
-	" miss",
-	" swing and miss",
-	" barely miss",
-	" don't hit",
-	" misses",
-	" swings and misses",
-	" barely misses",
-	" doesn't hit",
-}
-
-// strPlus adjusts hit probabilities due to strength (fight.c str_plus).
-var strPlus = [32]int{
-	-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
-	1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
-}
-
-// addDam adjusts damage done due to strength (fight.c add_dam).
-var addDam = [32]int{
-	-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3,
-	3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6,
-}
-
 // setMname returns the monster name for the given monster (fight.c
 // set_mname).
 func (g *RogueGame) setMname(tp *Monster) string {
@@ -48,20 +11,27 @@ func (g *RogueGame) setMname(tp *Monster) string {
 		if g.Options.Terse {
 			return "it"
 		}
+
 		return "something"
 	}
+
 	var mname string
+
 	if g.Player.On(Hallucinating) {
-		ch := int(g.mvinch(tp.Pos.Y, tp.Pos.X))
+		var idx int
-		if !isUpper(byte(ch)) {
+
-			ch = g.rnd(26)
+		ch := g.mvinch(tp.Pos.Y, tp.Pos.X)
+		if isUpper(ch) {
+			idx = int(ch - 'A')
 		} else {
-			ch -= 'A'
+			idx = g.rnd(26)
 		}
-		mname = g.Monsters[ch].Name
+
+		mname = g.Monsters[idx].Name
 	} else {
 		mname = g.Monsters[tp.Type-'A'].Name
 	}
+
 	return "the " + mname
 }
 
@@ -77,84 +47,136 @@ func (g *RogueGame) fight(mp Coord, weap *Object, thrown bool) bool {
 	// place.
 	g.Count = 0
 	g.Quiet = 0
-	g.runto(mp)
+	g.runTo(mp)
-	// Let him know it was really a xeroc (if it was one).
+
-	if tp.Type == 'X' && tp.Disguise != 'X' && !p.On(Blind) {
+	if g.revealXeroc(tp) && !thrown {
-		tp.Disguise = 'X'
-		if p.On(Hallucinating) {
-			g.mvaddch(tp.Pos.Y, tp.Pos.X, byte(g.rnd(26)+'A'))
-		}
-		g.msg("%s", g.chooseStr("heavy!  That's a nasty critter!",
-			"wait!  That's a xeroc!"))
-		if !thrown {
 		return false
 	}
-	}
+
 	mname := g.setMname(tp)
-	didHit := false
+
 	g.HasHit = g.Options.Terse && !g.ToDeath
-	if g.rollEm(&p.Creature, &tp.Creature, weap, thrown) {
+	if g.rollAttacks(&p.Creature, &tp.Creature, weap, thrown) {
-		didHit = false
+		g.heroHits(tp, mname, weap, thrown)
+
+		return true
+	}
+
+	if thrown {
+		g.bounce(weap, mname, g.Options.Terse)
+	} else {
+		g.miss("", mname, g.Options.Terse)
+	}
+
+	return false
+}
+
+// revealXeroc lets him know it was really a xeroc (if it was one); it
+// reports whether one was unmasked (the X block of fight.c fight).
+func (g *RogueGame) revealXeroc(tp *Monster) bool {
+	p := &g.Player
+	if tp.Type != 'X' || tp.Disguise == 'X' || p.On(Blind) {
+		return false
+	}
+
+	tp.Disguise = 'X'
+	if p.On(Hallucinating) {
+		g.mvaddch(tp.Pos.Y, tp.Pos.X, g.randomMonsterLetter())
+	}
+
+	g.msg("%s", g.chooseStr("heavy!  That's a nasty critter!",
+		"wait!  That's a xeroc!"))
+
+	return true
+}
+
+// heroHits lands the hero's blow on a monster: messages, the confusing
+// touch, and the kill check (the hit arm of fight.c fight).
+func (g *RogueGame) heroHits(tp *Monster, mname string, weap *Object, thrown bool) {
+	p := &g.Player
+	confused := false
+
 	if thrown {
 		g.thunk(weap, mname, g.Options.Terse)
 	} else {
 		g.hit("", mname, g.Options.Terse)
 	}
+
 	if p.On(CanConfuse) {
-			didHit = true
+		confused = true
+
 		tp.Flags.Set(Confused)
 		p.Flags.Clear(CanConfuse)
 		g.endmsg()
 		g.HasHit = false
 		g.msg("your hands stop glowing %s", g.pickColor("red"))
 	}
+
 	if tp.Stats.HP <= 0 {
 		g.killed(tp, true)
-		} else if didHit && !p.On(Blind) {
+	} else if confused && !p.On(Blind) {
 		g.msg("%s appears confused", mname)
 	}
-		didHit = true
-	} else {
-		if thrown {
-			g.bounce(weap, mname, g.Options.Terse)
-		} else {
-			g.miss("", mname, g.Options.Terse)
-		}
-	}
-	return didHit
 }
 
-// attack has the monster attack the player (fight.c attack). Returns -1 if
+// attack has the monster attack the player (fight.c attack). The result
-// the monster removed itself from the level during its own attack.
+// reports that the monster took itself off the level during its own
-func (g *RogueGame) attack(mp *Monster) int {
+// attack (the C -1 return).
+func (g *RogueGame) attack(mp *Monster) bool {
 	p := &g.Player
 	// Since this is an attack, stop running and any healing that was
 	// going on at the time.
 	g.Running = false
 	g.Count = 0
+
 	g.Quiet = 0
 	if g.ToDeath && !mp.On(Targeted) {
 		g.ToDeath = false
 		g.Kamikaze = false
 	}
+
 	if mp.Type == 'X' && mp.Disguise != 'X' && !p.On(Blind) {
 		mp.Disguise = 'X'
 		if p.On(Hallucinating) {
-			g.mvaddch(mp.Pos.Y, mp.Pos.X, byte(g.rnd(26)+'A'))
+			g.mvaddch(mp.Pos.Y, mp.Pos.X, g.randomMonsterLetter())
 		}
 	}
+
 	mname := g.setMname(mp)
 	oldhp := p.Stats.HP
 	removed := false
-	if g.rollEm(&mp.Creature, &p.Creature, nil, false) {
+
+	if g.rollAttacks(&mp.Creature, &p.Creature, nil, false) {
+		removed = g.monsterHit(mp, mname, oldhp)
+	} else {
+		g.monsterMiss(mp, mname)
+	}
+
+	if g.Options.FightFlush && !g.ToDeath {
+		g.flushType()
+	}
+
+	g.Count = 0
+	g.status()
+
+	return removed
+}
+
+// monsterHit lands a monster's blow on the hero: messages, death and
+// to-death bookkeeping, then the monster's special power (the hit arm
+// of fight.c attack). It reports whether the monster removed itself.
+func (g *RogueGame) monsterHit(mp *Monster, mname string, oldhp int) bool {
+	p := &g.Player
 	if mp.Type != 'I' {
 		if g.HasHit {
-				g.addmsg(".  ")
+			g.addmsgf(".  ")
 		}
+
 		g.hit(mname, "", false)
 	} else if g.HasHit {
 		g.endmsg()
 	}
+
 	g.HasHit = false
 	if p.Stats.HP <= 0 {
 		g.death(mp.Type) // Bye bye life ...
@@ -163,181 +185,274 @@ func (g *RogueGame) attack(mp *Monster) int {
 		if oldhp > g.MaxHit {
 			g.MaxHit = oldhp
 		}
+
 		if p.Stats.HP <= g.MaxHit {
 			g.ToDeath = false
 		}
 	}
+
 	if !mp.On(Cancelled) {
-			switch mp.Type {
+		if h := g.data.hitHandlers[mp.Type-'A']; h != nil {
-			case 'A':
+			return h(g, mp, mname)
-				// If an aquator hits, you can lose armor class.
-				g.rustArmor(p.CurArmor)
-			case 'I':
-				// The ice monster freezes you
-				p.Flags.Clear(Awake)
-				if g.NoCommand == 0 {
-					g.addmsg("you are frozen")
-					if !g.Options.Terse {
-						g.addmsg(" by the %s", mname)
-					}
-					g.endmsg()
-				}
-				g.NoCommand += g.rnd(2) + 2
-				if g.NoCommand > BoreLevel {
-					g.death('h')
-				}
-			case 'R':
-				// Rattlesnakes have poisonous bites
-				if !g.save(VsPoison) {
-					if !p.IsWearing(RingSustainStrength) {
-						g.chgStr(-1)
-						if !g.Options.Terse {
-							g.msg("you feel a bite in your leg and now feel weaker")
-						} else {
-							g.msg("a bite has weakened you")
-						}
-					} else if !g.ToDeath {
-						if !g.Options.Terse {
-							g.msg("a bite momentarily weakens you")
-						} else {
-							g.msg("bite has no effect")
 		}
 	}
+
+	return false
 }
-			case 'W', 'V':
+
-				// Wraiths might drain energy levels, and Vampires can
+// monsterMiss handles a monster's whiffed swing (the miss arm of
-				// steal max_hp
+// fight.c attack); ice monsters miss silently.
-				chance := 30
+func (g *RogueGame) monsterMiss(mp *Monster, mname string) {
-				if mp.Type == 'W' {
+	if mp.Type == 'I' {
-					chance = 15
+		return
 	}
-				if g.rnd(100) < chance {
+
-					var fewer int
+	p := &g.Player
-					if mp.Type == 'W' {
+
-						if p.Stats.Exp == 0 {
-							g.death('W') // All levels gone
-						}
-						if p.Stats.Lvl--; p.Stats.Lvl == 0 {
-							p.Stats.Exp = 0
-							p.Stats.Lvl = 1
-						} else {
-							p.Stats.Exp = eLevels[p.Stats.Lvl-1] + 1
-						}
-						fewer = g.roll(1, 10)
-					} else {
-						fewer = g.roll(1, 3)
-					}
-					p.Stats.HP -= fewer
-					p.Stats.MaxHP -= fewer
-					if p.Stats.HP <= 0 {
-						p.Stats.HP = 1
-					}
-					if p.Stats.MaxHP <= 0 {
-						g.death(mp.Type)
-					}
-					g.msg("you suddenly feel weaker")
-				}
-			case 'F':
-				// Venus Flytrap stops the poor guy from moving
-				p.Flags.Set(Held)
-				p.VfHit++
-				g.Monsters['F'-'A'].Stats.Dmg = DiceSpec{{Count: p.VfHit, Sides: 1}}
-				if p.Stats.HP--; p.Stats.HP <= 0 {
-					g.death('F')
-				}
-			case 'L':
-				// Leprechaun steals some gold
-				lastpurse := p.Purse
-				p.Purse -= g.goldCalc()
-				if !g.save(VsMagic) {
-					p.Purse -= g.goldCalc() + g.goldCalc() + g.goldCalc() + g.goldCalc()
-				}
-				if p.Purse < 0 {
-					p.Purse = 0
-				}
-				g.removeMon(mp.Pos, mp, false)
-				removed = true
-				if p.Purse != lastpurse {
-					g.msg("your purse feels lighter")
-				}
-			case 'N':
-				// Nymphs steal a magic item; look through the pack and
-				// pick out one we like.
-				var steal *Object
-				nobj := 0
-				for _, obj := range p.Pack {
-					if obj != p.CurArmor && obj != p.CurWeapon &&
-						obj != p.CurRing[Left] && obj != p.CurRing[Right] &&
-						obj.isMagic() {
-						if nobj++; g.rnd(nobj) == 0 {
-							steal = obj
-						}
-					}
-				}
-				if steal != nil {
-					g.removeMon(mp.Pos, g.Level.MonsterAt(mp.Pos.Y, mp.Pos.X), false)
-					removed = true
-					g.leavePack(steal, false, false)
-					g.msg("she stole %s!", g.invName(steal, true))
-				}
-			}
-		}
-	} else if mp.Type != 'I' {
 	if g.HasHit {
-			g.addmsg(".  ")
+		g.addmsgf(".  ")
 		g.HasHit = false
 	}
+
 	if mp.Type == 'F' {
 		p.Stats.HP -= p.VfHit
 		if p.Stats.HP <= 0 {
 			g.death(mp.Type) // Bye bye life ...
 		}
 	}
+
 	g.miss(mname, "", false)
 }
-	if g.Options.FightFlush && !g.ToDeath {
+
-		g.flushType()
+// The monster special-power handlers, dispatched through
+// gameData.hitHandlers when an uncancelled monster's hit lands. Each is
+// one case of the C attack switch; a true return means the monster
+// removed itself from the level.
+
+func (g *RogueGame) hitAquator(*Monster, string) bool {
+	// If an aquator hits, you can lose armor class.
+	g.rustArmor(g.Player.CurArmor)
+
+	return false
 }
-	g.Count = 0
+
-	g.status()
+func (g *RogueGame) hitIceMonster(_ *Monster, mname string) bool {
-	if removed {
+	// The ice monster freezes you
-		return -1
+	g.Player.Flags.Clear(Awake)
+
+	if g.NoCommand == 0 {
+		g.addmsgf("you are frozen")
+
+		if !g.Options.Terse {
+			g.addmsgf(" by the %s", mname)
 		}
-	return 0
+
+		g.endmsg()
+	}
+
+	g.NoCommand += g.rnd(2) + 2
+	if g.NoCommand > BoreLevel {
+		g.death('h')
+	}
+
+	return false
+}
+
+func (g *RogueGame) hitRattlesnake(*Monster, string) bool {
+	// Rattlesnakes have poisonous bites
+	if g.save(VsPoison) {
+		return false
+	}
+
+	if !g.Player.IsWearing(RingSustainStrength) {
+		g.changeStrength(-1)
+		g.msg("%s", g.chooseTerse("a bite has weakened you",
+			"you feel a bite in your leg and now feel weaker"))
+	} else if !g.ToDeath {
+		g.msg("%s", g.chooseTerse("bite has no effect",
+			"a bite momentarily weakens you"))
+	}
+
+	return false
+}
+
+func (g *RogueGame) hitLifeDrainer(mp *Monster, _ string) bool {
+	// Wraiths might drain energy levels, and Vampires can steal max_hp
+	p := &g.Player
+
+	chance := 30
+	if mp.Type == 'W' {
+		chance = 15
+	}
+
+	if g.rnd(100) >= chance {
+		return false
+	}
+
+	var fewer int
+
+	if mp.Type == 'W' {
+		if p.Stats.Exp == 0 {
+			g.death('W') // All levels gone
+		}
+
+		if p.Stats.Lvl--; p.Stats.Lvl == 0 {
+			p.Stats.Exp = 0
+			p.Stats.Lvl = 1
+		} else {
+			p.Stats.Exp = g.data.eLevels[p.Stats.Lvl-1] + 1
+		}
+
+		fewer = g.roll(1, 10)
+	} else {
+		fewer = g.roll(1, 3)
+	}
+
+	p.Stats.HP -= fewer
+
+	p.Stats.MaxHP -= fewer
+	if p.Stats.HP <= 0 {
+		p.Stats.HP = 1
+	}
+
+	if p.Stats.MaxHP <= 0 {
+		g.death(mp.Type)
+	}
+
+	g.msg("you suddenly feel weaker")
+
+	return false
+}
+
+func (g *RogueGame) hitFlytrap(*Monster, string) bool {
+	// Venus Flytrap stops the poor guy from moving
+	p := &g.Player
+	p.Flags.Set(Held)
+	p.VfHit++
+
+	g.Monsters['F'-'A'].Stats.Dmg = DiceSpec{{Count: p.VfHit, Sides: 1}}
+	if p.Stats.HP--; p.Stats.HP <= 0 {
+		g.death('F')
+	}
+
+	return false
+}
+
+func (g *RogueGame) hitLeprechaun(mp *Monster, _ string) bool {
+	// Leprechaun steals some gold
+	p := &g.Player
+	lastpurse := p.Purse
+
+	p.Purse -= g.goldCalc()
+	if !g.save(VsMagic) {
+		p.Purse -= g.goldCalc() + g.goldCalc() + g.goldCalc() + g.goldCalc()
+	}
+
+	if p.Purse < 0 {
+		p.Purse = 0
+	}
+
+	g.removeMon(mp.Pos, mp, false)
+
+	if p.Purse != lastpurse {
+		g.msg("your purse feels lighter")
+	}
+
+	return true
+}
+
+func (g *RogueGame) hitNymph(mp *Monster, _ string) bool {
+	// Nymphs steal a magic item; look through the pack and pick out one
+	// we like.
+	p := &g.Player
+
+	var steal *Object
+
+	nobj := 0
+
+	for _, obj := range p.Pack {
+		if obj != p.CurArmor && obj != p.CurWeapon &&
+			obj != p.CurRing[Left] && obj != p.CurRing[Right] &&
+			g.isMagic(obj) {
+			if nobj++; g.rnd(nobj) == 0 {
+				steal = obj
+			}
+		}
+	}
+
+	if steal == nil {
+		return false
+	}
+
+	g.removeMon(mp.Pos, g.Level.MonsterAt(mp.Pos.Y, mp.Pos.X), false)
+	g.leavePack(steal, false, false)
+	g.msg("she stole %s!", g.inventoryName(steal, true))
+
+	return true
 }
 
 // swing returns true if the swing hits (fight.c swing).
 func (g *RogueGame) swing(atLvl, opArm, wplus int) bool {
 	res := g.rnd(20)
 	need := (20 - atLvl) - opArm
+
 	return res+wplus >= need
 }
 
-// rollEm rolls several attacks (fight.c roll_em).
+// rollAttacks rolls several attacks (fight.c roll_em).
-func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool {
+func (g *RogueGame) rollAttacks(thatt, thdef *Creature, weap *Object, hurl bool) bool {
-	p := &g.Player
 	att := &thatt.Stats
 	def := &thdef.Stats
-	var attacks DiceSpec
+
-	var hplus, dplus int
+	var (
+		attacks      DiceSpec
+		hplus, dplus int
+	)
+
 	if weap == nil {
 		attacks = att.Dmg
 	} else {
-		hplus = weap.HPlus
+		attacks, hplus, dplus = g.weaponAttack(weap, hurl)
-		dplus = weap.DPlus
+	}
+	// If the creature being attacked is not running (asleep or held) then
+	// the attacker gets a plus four bonus to hit.
+	if !thdef.Flags.Has(Awake) {
+		hplus += 4
+	}
+
+	defArm := g.defenderArmor(thdef)
+	didHit := false
+
+	for _, atk := range attacks {
+		if g.swing(att.Lvl, defArm, hplus+g.data.strPlus[att.Str]) {
+			proll := g.roll(atk.Count, atk.Sides)
+
+			damage := dplus + proll + g.data.addDam[att.Str]
+			if damage > 0 {
+				def.HP -= damage
+			}
+
+			didHit = true
+		}
+	}
+
+	return didHit
+}
+
+// weaponAttack picks the dice and to-hit/damage bonuses a weapon swings
+// with: ring bonuses when wielded, and launcher pairing for hurled
+// missiles (the weapon preamble of fight.c roll_em).
+func (g *RogueGame) weaponAttack(weap *Object, hurl bool) (DiceSpec, int, int) {
+	p := &g.Player
+
+	hplus := weap.HPlus
+
+	dplus := weap.DPlus
 	if weap == p.CurWeapon {
-			if p.IsRing(Left, RingIncreaseDamage) {
+		hplus, dplus = g.wieldedRingBonus(hplus, dplus)
-				dplus += p.CurRing[Left].Bonus
-			} else if p.IsRing(Left, RingDexterity) {
-				hplus += p.CurRing[Left].Bonus
 	}
-			if p.IsRing(Right, RingIncreaseDamage) {
+
-				dplus += p.CurRing[Right].Bonus
+	attacks := weap.Damage
-			} else if p.IsRing(Right, RingDexterity) {
-				hplus += p.CurRing[Right].Bonus
-			}
-		}
-		attacks = weap.Damage
 	if hurl {
 		if weap.Flags.Has(Missile) && p.CurWeapon != nil &&
 			WeaponKind(p.CurWeapon.Which) == weap.Launch {
@@ -348,36 +463,52 @@ func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool
 			attacks = weap.HurlDmg
 		}
 	}
+
+	return attacks, hplus, dplus
 }
-	// If the creature being attacked is not running (asleep or held) then
+
-	// the attacker gets a plus four bonus to hit.
+// wieldedRingBonus folds damage and dexterity ring bonuses into the
-	if !thdef.Flags.Has(Awake) {
+// wielded weapon's to-hit/damage pluses (fight.c roll_em).
-		hplus += 4
+func (g *RogueGame) wieldedRingBonus(hplus, dplus int) (int, int) {
+	p := &g.Player
+	if p.IsRing(Left, RingIncreaseDamage) {
+		dplus += p.CurRing[Left].Bonus
+	} else if p.IsRing(Left, RingDexterity) {
+		hplus += p.CurRing[Left].Bonus
 	}
+
+	if p.IsRing(Right, RingIncreaseDamage) {
+		dplus += p.CurRing[Right].Bonus
+	} else if p.IsRing(Right, RingDexterity) {
+		hplus += p.CurRing[Right].Bonus
+	}
+
+	return hplus, dplus
+}
+
+// defenderArmor computes the defender's effective armor class: worn
+// armor and protection rings when the hero defends (the def_arm
+// computation of fight.c roll_em).
+func (g *RogueGame) defenderArmor(thdef *Creature) int {
+	p := &g.Player
+	def := &thdef.Stats
+
 	defArm := def.ArmorClass
 	if def == &p.Stats {
 		if p.CurArmor != nil {
 			defArm = p.CurArmor.ArmorClass
 		}
+
 		if p.IsRing(Left, RingProtection) {
 			defArm -= p.CurRing[Left].Bonus
 		}
+
 		if p.IsRing(Right, RingProtection) {
 			defArm -= p.CurRing[Right].Bonus
 		}
 	}
-	didHit := false
+
-	for _, atk := range attacks {
+	return defArm
-		if g.swing(att.Lvl, defArm, hplus+strPlus[att.Str]) {
-			proll := g.roll(atk.Count, atk.Sides)
-			damage := dplus + proll + addDam[att.Str]
-			if damage > 0 {
-				def.HP -= damage
-			}
-			didHit = true
-		}
-	}
-	return didHit
 }
 
 // cAtoi parses a leading integer like C atoi: trailing non-digits are
@@ -387,7 +518,9 @@ func cAtoi(s string) int {
 	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
 		i++
 	}
+
 	n, _ := strconv.Atoi(s[:i])
+
 	return n
 }
 
@@ -398,9 +531,11 @@ func prname(mname string, upper bool) string {
 	if out == "" {
 		out = "you"
 	}
+
 	if upper {
 		out = string(toUpper(out[0])) + out[1:]
 	}
+
 	return out
 }
 
@@ -409,12 +544,15 @@ func (g *RogueGame) thunk(weap *Object, mname string, noend bool) {
 	if g.ToDeath {
 		return
 	}
+
 	if weap.Kind == KindWeapon {
-		g.addmsg("the %s hits ", g.Items.Weapons[weap.Which].Name)
+		g.addmsgf("the %s hits ", g.Items.Weapons[weap.Which].Name)
 	} else {
-		g.addmsg("you hit ")
+		g.addmsgf("you hit ")
 	}
-	g.addmsg("%s", mname)
+
+	g.addmsgf("%s", mname)
+
 	if !noend {
 		g.endmsg()
 	}
@@ -425,7 +563,9 @@ func (g *RogueGame) hit(er, ee string, noend bool) {
 	if g.ToDeath {
 		return
 	}
-	g.addmsg("%s", prname(er, true))
+
+	g.addmsgf("%s", prname(er, true))
+
 	var s string
 	if g.Options.Terse {
 		s = " hit"
@@ -434,12 +574,16 @@ func (g *RogueGame) hit(er, ee string, noend bool) {
 		if er != "" {
 			i += 4
 		}
-		s = hNames[i]
+
+		s = g.data.hNames[i]
 	}
-	g.addmsg("%s", s)
+
+	g.addmsgf("%s", s)
+
 	if !g.Options.Terse {
-		g.addmsg("%s", prname(ee, false))
+		g.addmsgf("%s", prname(ee, false))
 	}
+
 	if !noend {
 		g.endmsg()
 	}
@@ -450,18 +594,24 @@ func (g *RogueGame) miss(er, ee string, noend bool) {
 	if g.ToDeath {
 		return
 	}
-	g.addmsg("%s", prname(er, true))
+
+	g.addmsgf("%s", prname(er, true))
+
 	i := 0
 	if !g.Options.Terse {
 		i = g.rnd(4)
 	}
+
 	if er != "" {
 		i += 4
 	}
-	g.addmsg("%s", mNames[i])
+
+	g.addmsgf("%s", g.data.mNames[i])
+
 	if !g.Options.Terse {
-		g.addmsg(" %s", prname(ee, false))
+		g.addmsgf(" %s", prname(ee, false))
 	}
+
 	if !noend {
 		g.endmsg()
 	}
@@ -472,12 +622,15 @@ func (g *RogueGame) bounce(weap *Object, mname string, noend bool) {
 	if g.ToDeath {
 		return
 	}
+
 	if weap.Kind == KindWeapon {
-		g.addmsg("the %s misses ", g.Items.Weapons[weap.Which].Name)
+		g.addmsgf("the %s misses ", g.Items.Weapons[weap.Which].Name)
 	} else {
-		g.addmsg("you missed ")
+		g.addmsgf("you missed ")
 	}
-	g.addmsg("%s", mname)
+
+	g.addmsgf("%s", mname)
+
 	if !noend {
 		g.endmsg()
 	}
@@ -489,15 +642,19 @@ func (g *RogueGame) removeMon(mp Coord, tp *Monster, waskill bool) {
 	for _, obj := range pack {
 		obj.Pos = tp.Pos
 		detachObj(&tp.Pack, obj)
+
 		if waskill {
 			g.fall(obj, false)
 		}
 	}
+
 	g.Level.SetMonsterAt(mp.Y, mp.X, nil)
 	g.mvaddch(mp.Y, mp.X, tp.OldCh)
-	detachMon(&g.Level.Monsters, tp)
+	g.Level.RemoveMonster(tp)
+
 	if tp.On(Targeted) {
 		g.Kamikaze = false
+
 		g.ToDeath = false
 		if g.Options.FightFlush {
 			g.flushType()
@@ -510,6 +667,38 @@ func (g *RogueGame) killed(tp *Monster, pr bool) {
 	p := &g.Player
 	p.Stats.Exp += tp.Stats.Exp
 
+	g.killedSpecial(tp)
+	// Get rid of the monster.
+	mname := g.setMname(tp)
+	g.removeMon(tp.Pos, tp, true)
+
+	if pr {
+		if g.HasHit {
+			g.addmsgf(".  Defeated ")
+			g.HasHit = false
+		} else {
+			if !g.Options.Terse {
+				g.addmsgf("you have ")
+			}
+
+			g.addmsgf("defeated ")
+		}
+
+		g.msg("%s", mname)
+	}
+	// Do adjustments if he went up a level
+	g.checkLevel()
+
+	if g.Options.FightFlush {
+		g.flushType()
+	}
+}
+
+// killedSpecial handles deaths with side effects: a flytrap releases its
+// grip and a leprechaun drops its gold (the switch of fight.c killed).
+func (g *RogueGame) killedSpecial(tp *Monster) {
+	p := &g.Player
+
 	// If the monster was a venus flytrap, un-hold him
 	switch tp.Type {
 	case 'F':
@@ -521,36 +710,19 @@ func (g *RogueGame) killed(tp *Monster, pr bool) {
 		if ok {
 			tp.Room.Gold = pos
 		}
+
 		if ok && g.Depth >= g.MaxDepth {
 			gold := newObject()
 			gold.Kind = KindGold
+
 			gold.GoldValue = g.goldCalc()
 			if g.save(VsMagic) {
 				gold.GoldValue += g.goldCalc() + g.goldCalc() + g.goldCalc() + g.goldCalc()
 			}
+
 			attachObj(&tp.Pack, gold)
 		}
 	}
-	// Get rid of the monster.
-	mname := g.setMname(tp)
-	g.removeMon(tp.Pos, tp, true)
-	if pr {
-		if g.HasHit {
-			g.addmsg(".  Defeated ")
-			g.HasHit = false
-		} else {
-			if !g.Options.Terse {
-				g.addmsg("you have ")
-			}
-			g.addmsg("defeated ")
-		}
-		g.msg("%s", mname)
-	}
-	// Do adjustments if he went up a level
-	g.checkLevel()
-	if g.Options.FightFlush {
-		g.flushType()
-	}
 }
 
 // flushType flushes typeahead for the fight_flush option (mach_dep.c

game/fight_test.go

@@ -6,10 +6,12 @@ import "testing"
 // look() state the way playit() does before the first command.
 func mkGame(t *testing.T, seed int32) *RogueGame {
 	t.Helper()
-	g := NewGame(Config{Seed: seed, Term: &testTerm{}})
+
+	g := New(Params{Seed: seed, Term: &testTerm{}})
 	g.NewLevel()
 	g.Oldpos = g.Player.Pos
-	g.Oldrp = g.roomin(g.Player.Pos)
+	g.Oldrp = g.roomIn(g.Player.Pos)
+
 	return g
 }
 
@@ -18,6 +20,7 @@ func spawnAdjacent(g *RogueGame, typ byte) *Monster {
 	pos := Coord{X: g.Player.Pos.X + 1, Y: g.Player.Pos.Y}
 	tp := &Monster{}
 	g.newMonster(tp, typ, pos)
+
 	return tp
 }
 
@@ -29,9 +32,10 @@ func TestRollEmParsesMultiAttackDice(t *testing.T) {
 	// With attacker level 20 vs armor 10, swing always hits
 	// (rnd(20)+wplus >= (20-20)-10 is always true), so three attacks of
 	// 1x4 + str bonus 1 each must deal between 6 and 15 damage.
-	if !g.rollEm(att, def, nil, false) {
+	if !g.rollAttacks(att, def, nil, false) {
 		t.Fatal("attack with guaranteed swing missed")
 	}
+
 	dmg := 1000 - def.Stats.HP
 	if dmg < 6 || dmg > 15 {
 		t.Errorf("three 1x4+1 attacks dealt %d damage, want 6..15", dmg)
@@ -45,12 +49,15 @@ func TestFightKillsMonster(t *testing.T) {
 	g.Player.Stats.Lvl = 20 // always hits
 	before := len(g.Level.Monsters)
 	g.fight(tp.Pos, g.Player.CurWeapon, false)
+
 	if len(g.Level.Monsters) != before-1 {
 		t.Error("monster not removed after fatal fight")
 	}
+
 	if g.Level.MonsterAt(tp.Pos.Y, tp.Pos.X) != nil {
 		t.Error("map still records dead monster")
 	}
+
 	if g.Player.Stats.Exp == 0 {
 		t.Error("no experience for the kill")
 	}
@@ -61,45 +68,36 @@ func TestAttackHurtsPlayer(t *testing.T) {
 	tp := spawnAdjacent(g, 'T') // troll: 1x8/1x8/2x6
 	tp.Stats.Lvl = 20           // always hits
 	tp.Flags.Clear(Cancelled)
+
 	hpBefore := g.Player.Stats.HP
 	g.Player.Stats.HP = 500
 	g.Player.Stats.MaxHP = 500
 	g.attack(tp)
+
 	if g.Player.Stats.HP >= 500 {
 		t.Errorf("player HP unchanged (%d -> %d)", hpBefore, g.Player.Stats.HP)
 	}
 }
 
-func TestDeathUnwindsWithGameEnd(t *testing.T) {
-	g := mkGame(t, 11)
-	defer func() {
-		r := recover()
-		if _, ok := r.(gameEnd); !ok {
-			t.Fatalf("death did not unwind with gameEnd, got %v", r)
-		}
-		if g.Playing {
-			t.Error("still playing after death")
-		}
-	}()
-	g.Options.Tombstone = false
-	g.death('K')
-}
-
 func TestRunnersChaseHero(t *testing.T) {
 	g := mkGame(t, 3)
 	// Place a hobgoblin a few squares away in the hero's room and set it
 	// running at the hero.
 	p := &g.Player
+
 	pos := Coord{X: p.Pos.X + 3, Y: p.Pos.Y}
 	if !stepOk(g.Level.Char(pos.Y, pos.X)) || g.Level.MonsterAt(pos.Y, pos.X) != nil {
 		t.Skip("no clear lane on this seed")
 	}
+
 	tp := &Monster{}
 	g.newMonster(tp, 'H', pos)
 	tp.Flags.Set(Awake)
 	tp.Dest = &p.Pos
 	d0 := distCp(tp.Pos, p.Pos)
+
 	g.runners(0)
+
 	if d1 := distCp(tp.Pos, p.Pos); d1 >= d0 {
 		t.Errorf("monster did not close distance: %d -> %d", d0, d1)
 	}

game/game.go

@@ -31,9 +31,9 @@ type Options struct {
 	InvType    int  // inven: inventory style (InvOver/InvSlow/InvClear)
 }
 
-// Config carries everything needed to construct a game.
+// Params carries everything needed to construct a game.
-type Config struct {
+type Params struct {
-	Seed      int32    // dungeon number; the caller derives it (time+pid or SEED env)
+	Seed      int32    // dungeon number; caller derives it (time+pid or SEED)
 	Name      string   // player name (overridden by ROGUEOPTS name=)
 	RogueOpts string   // the ROGUEOPTS environment string
 	Home      string   // home directory (save file default location)
@@ -44,7 +44,7 @@ type Config struct {
 
 // RogueGame is one complete game of Rogue: every piece of state that was a
 // global (or file-scope static) in the C sources, plus the terminal it is
-// played on. Construct with NewGame, then call Run.
+// played on. Construct with New, then call Run.
 //
 // The struct grows with the port; fields appear in the phase that ports the
 // code owning them.
@@ -110,7 +110,7 @@ type RogueGame struct {
 
 	// screen / messages
 	scr         *Screen
-	Msgs        MsgLine
+	Msgs        MessageLine
 	statusCache statusCache
 	invPage     invPage // things.c discovery-list pagination statics
 
@@ -138,23 +138,27 @@ type RogueGame struct {
 
 	rogueOpts string // the ROGUEOPTS string, re-parsed by playit as in C
 	restored  bool   // game came from a save file; Run skips setup
+
+	// data is the game's copy of the static tables (extern.c and friends).
+	data *gameData
 }
 
-// NewGame builds a game from cfg, seeds the RNG, and randomizes the item
+// New builds a game from params, seeds the RNG, and randomizes the item
 // appearance tables (the front half of main.c main(); the player roll-up
 // and first level arrive with later porting phases).
-func NewGame(cfg Config) *RogueGame {
+func New(params Params) *RogueGame {
 	g := &RogueGame{
-		Rng:       &Rng{Seed: cfg.Seed},
+		data:      newGameData(),
-		Dnum:      int(cfg.Seed),
+		Rng:       &Rng{Seed: params.Seed},
-		Whoami:    cfg.Name,
+		Dnum:      int(params.Seed),
+		Whoami:    params.Name,
 		Fruit:     "slime-mold",
-		Home:      cfg.Home,
+		Home:      params.Home,
-		Wizard:    cfg.Wizard,
+		Wizard:    params.Wizard,
-		NoScore:   cfg.Wizard,
+		NoScore:   params.Wizard,
 		Playing:   true,
 		Depth:     1,
-		ScorePath: cfg.ScorePath,
+		ScorePath: params.ScorePath,
 		LastScore: -1,
 	}
 	g.Options = Options{
@@ -164,17 +168,21 @@ func NewGame(cfg Config) *RogueGame {
 	}
 	g.InvDescribe = true
 	g.Msgs.SaveMsg = true
-	g.scr = NewScreen(cfg.Term)
+	g.scr = NewScreen(params.Term)
-	g.FileName = cfg.Home + "/rogue.save"
+	g.Msgs.attach(g.scr, g.look, g.readchar)
-	g.rogueOpts = cfg.RogueOpts
+	g.FileName = params.Home + "/rogue.save"
-	if cfg.Wizard {
+
+	g.rogueOpts = params.RogueOpts
+	if params.Wizard {
 		g.Player.Flags.Set(SenseMonsters)
 	}
-	if cfg.RogueOpts != "" {
+
-		g.ParseOpts(cfg.RogueOpts)
+	if params.RogueOpts != "" {
+		g.ParseOpts(params.RogueOpts)
 	}
 
-	g.Monsters = monsterTable
+	g.Monsters = g.data.monsterTable
+
 	g.Items.Group = 2 // weapons.c: int group = 2
 	for i := range g.Level.Passages {
 		g.Level.Passages[i].Flags = Gone | Dark
@@ -186,21 +194,26 @@ func NewGame(cfg Config) *RogueGame {
 	g.initColors()    // set up colors of potions
 	g.initStones()    // set up stone settings of rings
 	g.initMaterials() // set up materials of wands
+
 	return g
 }
 
 // Run plays the game to its end: the back half of main.c main() plus
-// playit(). It returns after death, victory, quitting, or saving.
+// playit(). It does not return — the game ends by exiting the process
-func (g *RogueGame) Run() (err error) {
+// (see myExit); one game run is one process.
-	defer func() {
+func (g *RogueGame) Run() {
-		if r := recover(); r != nil {
+	g.startLevel()
-			if _, ok := r.(gameEnd); ok {
+	g.playit()
-				return // normal game over / save exit
 }
-			panic(r)
+
+// startLevel draws the first level and starts the standing daemons and
+// fuses for a fresh game; a restored game brings its own (the back half
+// of main.c main()).
+func (g *RogueGame) startLevel() {
+	if g.restored {
+		return
 	}
-	}()
+
-	if !g.restored {
 	g.NewLevel() // draw current level
 	// Start up daemons and fuses
 	g.StartDaemon(DRunners, 0, After)
@@ -208,12 +221,23 @@ func (g *RogueGame) Run() (err error) {
 	g.Fuse(DSwander, 0, wanderTime(g), After)
 	g.StartDaemon(DStomach, 0, After)
 }
-	g.playit()
-	return nil
-}
 
 // playit is the main loop of the program (main.c playit).
 func (g *RogueGame) playit() {
+	g.prePlay()
+
+	for g.Playing {
+		g.command() // command execution
+	}
+
+	g.endit()
+}
+
+// prePlay does the option and position setup at the top of playit,
+// before the command loop (main.c playit). It is split out so tests can
+// drive a bounded number of turns; the loop itself never returns,
+// because game-over exits the process.
+func (g *RogueGame) prePlay() {
 	// set up defaults for modern terminals: curses' md_hasclreol() is
 	// always true, so the C default inventory style applies
 	if !g.restored {
@@ -226,11 +250,7 @@ func (g *RogueGame) playit() {
 	}
 
 	g.Oldpos = g.Player.Pos
-	g.Oldrp = g.roomin(g.Player.Pos)
+	g.Oldrp = g.roomIn(g.Player.Pos)
-	for g.Playing {
-		g.command() // command execution
-	}
-	g.endit()
 }
 
 // endit exits the game (main.c endit).
@@ -242,7 +262,7 @@ func (g *RogueGame) endit() {
 func (g *RogueGame) fatal(s string) {
 	g.mvaddstr(NumLines-2, 0, s)
 	g.refresh()
-	g.myExit(0)
+	g.myExit()
 }
 
 // quit has the player make certain, then exits (main.c quit). The final
@@ -252,17 +272,21 @@ func (g *RogueGame) quit(int) {
 	if !g.QComm {
 		g.Msgs.Mpos = 0
 	}
+
 	oy, ox := g.scr.Std.GetYX()
 	g.msg("really quit?")
+
 	if g.readchar() == 'y' {
 		g.clear()
-		g.scr.Std.MvPrintw(NumLines-2, 0, "You quit with %d gold pieces", g.Player.Purse)
+		g.scr.Std.MvPrintwf(NumLines-2, 0, "You quit with %d gold pieces", g.Player.Purse)
 		g.move(NumLines-1, 0)
 		g.refresh()
 		g.score(g.Player.Purse, 1, 0)
-		g.myExit(0)
+		g.myExit()
+
 		return
 	}
+
 	g.move(0, 0)
 	g.clrtoeol()
 	g.status()

game/init.go

@@ -8,7 +8,7 @@ import "strings"
 // initPlayer rolls her up (init.c init_player).
 func (g *RogueGame) initPlayer() {
 	p := &g.Player
-	p.MaxStats = initStats
+	p.MaxStats = g.data.initStats
 	p.Stats = p.MaxStats
 	p.FoodLeft = HungerTime
 	// Give him some food
@@ -20,7 +20,7 @@ func (g *RogueGame) initPlayer() {
 	obj = newObject()
 	obj.Kind = KindArmor
 	obj.Which = int(ArmorRingMail)
-	obj.ArmorClass = aClass[ArmorRingMail] - 1
+	obj.ArmorClass = g.data.aClass[ArmorRingMail] - 1
 	obj.Flags.Set(Known)
 	obj.Count = 1
 	p.CurArmor = obj
@@ -50,36 +50,42 @@ func (g *RogueGame) initPlayer() {
 // initColors initializes the potion color scheme for this game
 // (init.c init_colors).
 func (g *RogueGame) initColors() {
-	used := make([]bool, len(rainbow))
+	used := make([]bool, len(g.data.rainbow))
-	for i := PotionKind(0); i < NumPotionTypes; i++ {
+
+	for i := range NumPotionTypes {
 		var j int
 		for {
-			j = g.rnd(len(rainbow))
+			j = g.rnd(len(g.data.rainbow))
 			if !used[j] {
 				break
 			}
 		}
+
 		used[j] = true
-		g.Items.PotColors[i] = rainbow[j]
+		g.Items.PotColors[i] = g.data.rainbow[j]
 	}
 }
 
 // initNames generates the names of the various scrolls (init.c init_names).
 func (g *RogueGame) initNames() {
-	for i := ScrollKind(0); i < NumScrollTypes; i++ {
+	for i := range NumScrollTypes {
 		var cp strings.Builder
+
 		nwords := g.rnd(3) + 2
 		for ; nwords > 0; nwords-- {
 			nsyl := g.rnd(3) + 1
 			for ; nsyl > 0; nsyl-- {
-				sp := sylls[g.rnd(len(sylls))]
+				sp := g.data.sylls[g.rnd(len(g.data.sylls))]
 				if cp.Len()+len(sp) > MaxNameLen {
 					break
 				}
+
 				cp.WriteString(sp)
 			}
+
 			cp.WriteByte(' ')
 		}
+
 		g.Items.ScrNames[i] = strings.TrimSuffix(cp.String(), " ")
 	}
 }
@@ -87,47 +93,54 @@ func (g *RogueGame) initNames() {
 // initStones initializes the ring stone setting scheme for this game
 // (init.c init_stones).
 func (g *RogueGame) initStones() {
-	used := make([]bool, len(stoneTable))
+	used := make([]bool, len(g.data.stoneTable))
-	for i := RingKind(0); i < NumRingTypes; i++ {
+
+	for i := range NumRingTypes {
 		var j int
 		for {
-			j = g.rnd(len(stoneTable))
+			j = g.rnd(len(g.data.stoneTable))
 			if !used[j] {
 				break
 			}
 		}
+
 		used[j] = true
-		g.Items.RingStones[i] = stoneTable[j].Name
+		g.Items.RingStones[i] = g.data.stoneTable[j].Name
-		g.Items.Rings[i].Worth += stoneTable[j].Value
+		g.Items.Rings[i].Worth += g.data.stoneTable[j].Value
 	}
 }
 
 // initMaterials initializes the construction materials for wands and staffs
 // (init.c init_materials).
 func (g *RogueGame) initMaterials() {
-	used := make([]bool, len(woods))
+	used := make([]bool, len(g.data.woods))
-	metused := make([]bool, len(metals))
+	metused := make([]bool, len(g.data.metals))
-	for i := WandKind(0); i < NumWandTypes; i++ {
+
+	for i := range NumWandTypes {
 		var str string
+
 		for {
 			if g.rnd(2) == 0 {
-				j := g.rnd(len(metals))
+				j := g.rnd(len(g.data.metals))
 				if !metused[j] {
-					g.Items.WandType[i] = "wand"
+					g.Items.WandType[i] = wandName
-					str = metals[j]
+					str = g.data.metals[j]
 					metused[j] = true
+
 					break
 				}
 			} else {
-				j := g.rnd(len(woods))
+				j := g.rnd(len(g.data.woods))
 				if !used[j] {
-					g.Items.WandType[i] = "staff"
+					g.Items.WandType[i] = staffName
-					str = woods[j]
+					str = g.data.woods[j]
 					used[j] = true
+
 					break
 				}
 			}
 		}
+
 		g.Items.WandMade[i] = str
 	}
 }
@@ -143,13 +156,13 @@ func sumProbs(info []ObjInfo) {
 // initProbs copies the base tables into the game and initializes the
 // probabilities for the various items (init.c init_probs).
 func (g *RogueGame) initProbs() {
-	g.Items.Things = baseThings
+	g.Items.Things = g.data.baseThings
-	g.Items.Potions = basePotInfo
+	g.Items.Potions = g.data.basePotInfo
-	g.Items.Scrolls = baseScrInfo
+	g.Items.Scrolls = g.data.baseScrInfo
-	g.Items.Rings = baseRingInfo
+	g.Items.Rings = g.data.baseRingInfo
-	g.Items.Sticks = baseWsInfo
+	g.Items.Sticks = g.data.baseWsInfo
-	g.Items.Weapons = baseWeapInfo
+	g.Items.Weapons = g.data.baseWeapInfo
-	g.Items.Armors = baseArmInfo
+	g.Items.Armors = g.data.baseArmInfo
 
 	sumProbs(g.Items.Things[:])
 	sumProbs(g.Items.Potions[:])
@@ -164,7 +177,8 @@ func (g *RogueGame) initProbs() {
 // hallucinating (init.c pick_color).
 func (g *RogueGame) pickColor(col string) string {
 	if g.Player.On(Hallucinating) {
-		return rainbow[g.rnd(len(rainbow))]
+		return g.data.rainbow[g.rnd(len(g.data.rainbow))]
 	}
+
 	return col
 }

game/io.go

@@ -10,9 +10,11 @@ import (
 // maxMsg is io.c MAXMSG: how much message fits before --More--.
 const maxMsg = NumCols - len("--More--") - 1
 
-// MsgLine is the io.c message machinery: the static msgbuf/newpos pair plus
+// MessageLine is the io.c message machinery: the static msgbuf/newpos
-// the related globals (mpos, huh, and the message-behavior flags).
+// pair plus the related globals (mpos, huh, and the message-behavior
-type MsgLine struct {
+// flags). It owns the top line of the screen; attach wires in the
+// display and input it needs.
+type MessageLine struct {
 	buf      strings.Builder // msgbuf
 	newpos   int
 	Mpos     int    // where cursor is on top line
@@ -20,84 +22,137 @@ type MsgLine struct {
 	SaveMsg  bool   // remember last msg
 	LowerMsg bool   // messages should start w/lower case
 	MsgEsc   bool   // check for ESC from msg's --More--
+
+	scr      *Screen           // the top line lives on scr.Std
+	look     func(wakeup bool) // redraw before a --More-- (misc.c look)
+	readChar func() byte       // input for --More-- prompts
 }
 
 // Msg displays a message at the top of the screen (io.c msg). It returns
-// Escape if the player escaped out of a --More--, ^Escape otherwise (the C
+// Escape if the player escaped out of a --More--, ^Escape otherwise (the
-// convention: callers compare against ESCAPE).
+// C convention: callers compare against ESCAPE).
-func (g *RogueGame) msg(format string, a ...any) int {
+func (m *MessageLine) Msg(format string, a ...any) int {
 	// if the string is "", just clear the line
 	if format == "" {
-		g.move(0, 0)
+		m.scr.Std.Move(0, 0)
-		g.clrtoeol()
+		m.scr.Std.Clrtoeol()
-		g.Msgs.Mpos = 0
+		m.Mpos = 0
+
 		return ^Escape
 	}
 	// otherwise add to the message and flush it out
-	g.doadd(format, a...)
+	m.doaddf(format, a...)
-	return g.endmsg()
+
+	return m.End()
 }
 
-// addmsg adds things to the current message (io.c addmsg).
+// Addf adds things to the current message (io.c addmsg).
-func (g *RogueGame) addmsg(format string, a ...any) {
+func (m *MessageLine) Addf(format string, a ...any) {
-	g.doadd(format, a...)
+	m.doaddf(format, a...)
 }
 
-// endmsg displays a new msg, giving the player a chance to see the previous
+// End displays a new msg, giving the player a chance to see the previous
 // one if it is up there with the --More-- (io.c endmsg).
-func (g *RogueGame) endmsg() int {
+func (m *MessageLine) End() int {
-	m := &g.Msgs
 	if m.SaveMsg {
 		m.Huh = m.buf.String()
 	}
-	if m.Mpos != 0 {
+
-		g.look(false)
+	if m.Mpos != 0 && m.promptMore() == Escape {
-		g.mvaddstr(0, m.Mpos, "--More--")
-		g.refresh()
-		if !m.MsgEsc {
-			g.waitFor(' ')
-		} else {
-			for {
-				ch := g.readchar()
-				if ch == ' ' {
-					break
-				}
-				if ch == Escape {
-					m.buf.Reset()
-					m.Mpos = 0
-					m.newpos = 0
 		return Escape
 	}
-			}
-		}
-	}
 	// All messages should start with uppercase, except ones that start
 	// with a pack addressing character
 	out := m.buf.String()
 	if len(out) > 0 && isLower(out[0]) && !m.LowerMsg &&
-		!(len(out) > 1 && out[1] == ')') {
+		(len(out) <= 1 || out[1] != ')') {
 		out = string(toUpper(out[0])) + out[1:]
 	}
-	g.mvaddstr(0, 0, out)
+
-	g.clrtoeol()
+	m.scr.Std.MvAddStr(0, 0, out)
+	m.scr.Std.Clrtoeol()
+
 	m.Mpos = m.newpos
 	m.newpos = 0
 	m.buf.Reset()
-	g.refresh()
+	m.scr.Refresh()
+
 	return ^Escape
 }
 
-// doadd performs an add onto the message buffer (io.c doadd).
+// promptMore shows the --More-- prompt and waits for the reader to
-func (g *RogueGame) doadd(format string, a ...any) {
+// acknowledge; Escape means the player bailed out (the Mpos block of
-	m := &g.Msgs
+// io.c endmsg).
+func (m *MessageLine) promptMore() int {
+	m.look(false)
+	m.scr.Std.MvAddStr(0, m.Mpos, "--More--")
+	m.scr.Refresh()
+
+	if !m.MsgEsc {
+		m.waitForSpace()
+
+		return ^Escape
+	}
+
+	for {
+		ch := m.readChar()
+		if ch == ' ' {
+			return ^Escape
+		}
+
+		if ch == Escape {
+			m.buf.Reset()
+			m.Mpos = 0
+			m.newpos = 0
+
+			return Escape
+		}
+	}
+}
+
+// attach wires the message line to its display and input; NewGame and
+// Restore call it once the screen and game exist.
+func (m *MessageLine) attach(scr *Screen, look func(bool), readChar func() byte) {
+	m.scr = scr
+	m.look = look
+	m.readChar = readChar
+}
+
+// waitForSpace absorbs input until the player types a space: the
+// --More-- acknowledgement (io.c wait_for).
+func (m *MessageLine) waitForSpace() {
+	for {
+		if m.readChar() == ' ' {
+			return
+		}
+	}
+}
+
+// doaddf performs an add onto the message buffer (io.c doadd).
+func (m *MessageLine) doaddf(format string, a ...any) {
 	s := fmt.Sprintf(format, a...)
 	if len(s)+m.newpos >= maxMsg {
-		g.endmsg()
+		m.End()
 	}
+
 	m.buf.WriteString(s)
 	m.newpos = m.buf.Len()
 }
 
+// msg, addmsgf, and endmsg are the game-side shorthands for the message
+// line; the machinery lives on MessageLine.
+func (g *RogueGame) msg(format string, a ...any) int {
+	return g.Msgs.Msg(format, a...)
+}
+
+func (g *RogueGame) addmsgf(format string, a ...any) {
+	g.Msgs.Addf(format, a...)
+}
+
+func (g *RogueGame) endmsg() {
+	g.Msgs.End()
+}
+
 // stepOk returns true if it is ok to step on ch (io.c step_ok).
 func stepOk(ch byte) bool {
 	switch ch {
@@ -114,8 +169,10 @@ func (g *RogueGame) readchar() byte {
 	ch := g.scr.term.ReadChar()
 	if ch == 3 { // ^C
 		g.quit(0)
+
 		return 27
 	}
+
 	return ch
 }
 
@@ -133,8 +190,6 @@ type statusCache struct {
 	init    bool
 }
 
-var hungerStateName = [...]string{"", "Hungry", "Weak", "Faint"}
-
 // status displays the important stats line, keeping the cursor where it was
 // (io.c status).
 func (g *RogueGame) status() {
@@ -146,17 +201,19 @@ func (g *RogueGame) status() {
 	if p.CurArmor != nil {
 		temp = p.CurArmor.ArmorClass
 	}
-	if s.init && s.hp == p.Stats.HP && s.exp == p.Stats.Exp &&
+
-		s.pur == p.Purse && s.arm == temp && s.str == p.Stats.Str &&
+	if g.statusUnchanged(temp) {
-		s.lvl == g.Depth && s.hungry == p.HungryState && !g.StatMsg {
 		return
 	}
+
 	s.init = true
 	s.arm = temp
 
 	oy, ox := g.scr.Std.GetYX()
+
 	if s.hp != p.Stats.MaxHP {
 		s.hp = p.Stats.MaxHP
+
 		s.hpwidth = 0
 		for t := p.Stats.MaxHP; t != 0; t /= 10 {
 			s.hpwidth++
@@ -175,7 +232,7 @@ func (g *RogueGame) status() {
 		"Level: %d  Gold: %-5d  Hp: %*d(%*d)  Str: %2d(%d)  Arm: %-2d  Exp: %d/%d  %s",
 		g.Depth, p.Purse, s.hpwidth, p.Stats.HP, s.hpwidth, p.Stats.MaxHP,
 		p.Stats.Str, p.MaxStats.Str, 10-s.arm, p.Stats.Lvl, p.Stats.Exp,
-		hungerStateName[p.HungryState])
+		g.data.hungerStateName[p.HungryState])
 	if g.StatMsg {
 		g.move(0, 0)
 		g.msg("%s", line)
@@ -183,10 +240,23 @@ func (g *RogueGame) status() {
 		g.move(StatLine, 0)
 		g.addstr(line)
 	}
+
 	g.clrtoeol()
 	g.move(oy, ox)
 }
 
+// statusUnchanged reports whether the status line still shows current
+// values, so it need not be redrawn (the shadow-variable check of io.c
+// status). temp is the effective armor class.
+func (g *RogueGame) statusUnchanged(temp int) bool {
+	s := &g.statusCache
+	p := &g.Player
+
+	return s.init && s.hp == p.Stats.HP && s.exp == p.Stats.Exp &&
+		s.pur == p.Purse && s.arm == temp && s.str == p.Stats.Str &&
+		s.lvl == g.Depth && s.hungry == p.HungryState && !g.StatMsg
+}
+
 // waitFor sits around until the guy types the right key (io.c wait_for).
 func (g *RogueGame) waitFor(ch byte) {
 	if ch == '\n' {
@@ -197,7 +267,11 @@ func (g *RogueGame) waitFor(ch byte) {
 			}
 		}
 	}
-	for g.readchar() != ch {
+
+	for {
+		if g.readchar() == ch {
+			return
+		}
 	}
 }
 
@@ -221,11 +295,13 @@ func toUpper(c byte) byte {
 	if isLower(c) {
 		return c - 'a' + 'A'
 	}
+
 	return c
 }
 func toLower(c byte) byte {
 	if isUpper(c) {
 		return c - 'A' + 'a'
 	}
+
 	return c
 }

game/level.go

@@ -47,9 +47,33 @@ func (l *Level) VisibleChar(y, x int) byte {
 	if m := l.MonsterAt(y, x); m != nil {
 		return m.Disguise
 	}
+
 	return l.Char(y, x)
 }
 
+// ObjectAt finds the unclaimed object at (y, x) (misc.c find_obj).
+func (l *Level) ObjectAt(y, x int) *Object {
+	for _, obj := range l.Objects {
+		if obj.Pos.Y == y && obj.Pos.X == x {
+			return obj
+		}
+	}
+
+	return nil
+}
+
+// AddObject puts an object on the level (list.c attach on lvl_obj).
+func (l *Level) AddObject(obj *Object) { attachObj(&l.Objects, obj) }
+
+// RemoveObject takes an object off the level (list.c detach on lvl_obj).
+func (l *Level) RemoveObject(obj *Object) { detachObj(&l.Objects, obj) }
+
+// AddMonster puts a monster on the level (list.c attach on mlist).
+func (l *Level) AddMonster(m *Monster) { attachMon(&l.Monsters, m) }
+
+// RemoveMonster takes a monster off the level (list.c detach on mlist).
+func (l *Level) RemoveMonster(m *Monster) { detachMon(&l.Monsters, m) }
+
 // goldCalc is the GOLDCALC macro: how much a gold pile is worth at depth.
 func (g *RogueGame) goldCalc() int {
 	return g.rnd(50+10*g.Depth) + 2

game/misc.go

@@ -4,84 +4,151 @@ package game
 // and small utilities. call_it arrives with the scroll/potion phase (it
 // needs the get_str line editor).
 
+// lookScan carries the state of one look() glance while it examines the
+// nine squares around the hero.
+type lookScan struct {
+	hero              Coord
+	pch               byte       // map character under the hero
+	pfl               PlaceFlags // map flags under the hero
+	wakeup            bool
+	doorStop          bool // door-stop checking applies (mid-run)
+	sy, sx, ey, ex    int
+	sumhero, diffhero int
+	passcount         int
+}
+
 // look takes a quick glance all around the player (misc.c look).
 func (g *RogueGame) look(wakeup bool) {
 	p := &g.Player
 	hero := p.Pos
-	passcount := 0
 	rp := p.Room
+
 	if g.Oldpos != hero {
 		g.eraseLamp(g.Oldpos, g.Oldrp)
 		g.Oldpos = hero
 		g.Oldrp = rp
 	}
-	ey := hero.Y + 1
-	ex := hero.X + 1
-	sx := hero.X - 1
-	sy := hero.Y - 1
-	sumhero, diffhero := 0, 0
-	if g.DoorStop && !g.Firstmove && g.Running {
-		sumhero = hero.Y + hero.X
-		diffhero = hero.Y - hero.X
-	}
-	pp := g.Level.At(hero.Y, hero.X)
-	pch := pp.Ch
-	pfl := pp.Flags
 
-	for y := sy; y <= ey; y++ {
+	s := lookScan{
+		hero:   hero,
+		wakeup: wakeup,
+		sy:     hero.Y - 1,
+		sx:     hero.X - 1,
+		ey:     hero.Y + 1,
+		ex:     hero.X + 1,
+	}
+
+	s.doorStop = g.DoorStop && !g.Firstmove
+	if s.doorStop && g.Running {
+		s.sumhero = hero.Y + hero.X
+		s.diffhero = hero.Y - hero.X
+	}
+
+	pp := g.Level.At(hero.Y, hero.X)
+	s.pch = pp.Ch
+	s.pfl = pp.Flags
+
+	g.lookAround(&s)
+
+	if s.doorStop && s.passcount > 1 {
+		g.Running = false
+	}
+
+	if !g.Running || !g.Options.Jump {
+		g.mvaddch(hero.Y, hero.X, PlayerCh)
+	}
+}
+
+// lookAround runs the nine-square scan of look().
+func (g *RogueGame) lookAround(s *lookScan) {
+	for y := s.sy; y <= s.ey; y++ {
 		if y <= 0 || y >= NumLines-1 {
 			continue
 		}
-		for x := sx; x <= ex; x++ {
+
+		for x := s.sx; x <= s.ex; x++ {
 			if x < 0 || x >= NumCols {
 				continue
 			}
-			if !p.On(Blind) {
+
-				if y == hero.Y && x == hero.X {
+			g.lookCell(s, y, x)
-					continue
+		}
 	}
 }
 
+// lookCell examines one square around the hero: visibility rules, trip
+// and monster rendering, drawing, and run-stop checks (the loop body of
+// misc.c look).
+func (g *RogueGame) lookCell(s *lookScan, y, x int) {
 	pp := g.Level.At(y, x)
-			ch := pp.Ch
+	if g.lookSkips(s, pp, y, x) {
-			if ch == ' ' { // nothing need be done with a ' '
+		return
-				continue
-			}
-			fp := &pp.Flags
-			if pch != Door && ch != Door {
-				if (pfl & FPassage) != (*fp & FPassage) {
-					continue
-				}
-			}
-			if (fp.Has(FPassage) || ch == Door) && (pfl.Has(FPassage) || pch == Door) {
-				if hero.X != x && hero.Y != y &&
-					!stepOk(g.Level.Char(y, hero.X)) && !stepOk(g.Level.Char(hero.Y, x)) {
-					continue
-				}
 	}
 
 	tp := pp.Monst
-			if tp == nil {
+
-				ch = g.tripCh(y, x, ch)
+	ch, skip := g.lookCellChar(s, tp, y, x, pp.Ch)
-			} else if p.On(SenseMonsters) && tp.On(Invisible) {
+	if skip {
-				if g.DoorStop && !g.Firstmove {
+		return
-					g.Running = false
 	}
-				continue
+
-			} else {
+	if !g.lookShow(s, tp, ch, y, x) {
-				if wakeup {
+		return
-					g.wakeMonster(y, x)
 	}
-				if g.seeMonst(tp) {
+
-					if p.On(Hallucinating) {
+	if s.doorStop && g.Running {
-						ch = byte(g.rnd(26) + 'A')
+		g.lookRunCheck(s, ch, y, x)
-					} else {
-						ch = tp.Disguise
 	}
 }
+
+// lookSkips reports whether look ignores this square entirely: the
+// hero's own square when sighted, blank rock, passage squares of
+// another network, and diagonals the hero could not step to (the guard
+// chain of the misc.c look loop).
+func (g *RogueGame) lookSkips(s *lookScan, pp *Place, y, x int) bool {
+	if !g.Player.On(Blind) && y == s.hero.Y && x == s.hero.X {
+		return true
 	}
-			if p.On(Blind) && (y != hero.Y || x != hero.X) {
+
-				continue
+	if pp.Ch == ' ' { // nothing need be done with a ' '
+		return true
+	}
+
+	return lookForeignPassage(s, pp.Flags, pp.Ch) ||
+		g.lookDiagonalBlocked(s, pp.Flags, pp.Ch, y, x)
+}
+
+// lookForeignPassage hides passage squares belonging to a different
+// passage network than the hero's (misc.c look).
+func lookForeignPassage(s *lookScan, fp PlaceFlags, ch byte) bool {
+	if s.pch != Door && ch != Door {
+		return (s.pfl & FPassage) != (fp & FPassage)
+	}
+
+	return false
+}
+
+// lookDiagonalBlocked hides diagonal door/passage squares the hero could
+// not actually step to (misc.c look).
+func (g *RogueGame) lookDiagonalBlocked(s *lookScan, fp PlaceFlags, ch byte, y, x int) bool {
+	if !fp.Has(FPassage) && ch != Door {
+		return false
+	}
+
+	if !s.pfl.Has(FPassage) && s.pch != Door {
+		return false
+	}
+
+	return s.hero.X != x && s.hero.Y != y &&
+		!stepOk(g.Level.Char(y, s.hero.X)) && !stepOk(g.Level.Char(s.hero.Y, x))
+}
+
+// lookShow draws the square if it changed; it reports false when a
+// blind hero cannot see it at all (the draw part of the look loop).
+func (g *RogueGame) lookShow(s *lookScan, tp *Monster, ch byte, y, x int) bool {
+	p := &g.Player
+	if p.On(Blind) && (y != s.hero.Y || x != s.hero.X) {
+		return false
 	}
 
 	g.move(y, x)
@@ -94,63 +161,88 @@ func (g *RogueGame) look(wakeup bool) {
 		g.addch(ch)
 	}
 
-			if g.DoorStop && !g.Firstmove && g.Running {
+	return true
-				switch g.RunCh {
-				case 'h':
-					if x == ex {
-						continue
 }
-				case 'j':
+
-					if y == sy {
+// lookCellChar picks what the square shows: trip rendering for empty
-						continue
+// squares, waking and disguises for monsters. skip means the square is
+// not drawn at all (the monster switch of the look loop).
+func (g *RogueGame) lookCellChar(s *lookScan, tp *Monster, y, x int, ch byte) (byte, bool) {
+	p := &g.Player
+
+	switch {
+	case tp == nil:
+		return g.tripCh(y, x, ch), false
+	case p.On(SenseMonsters) && tp.On(Invisible):
+		if g.DoorStop && !g.Firstmove {
+			g.Running = false
 		}
-				case 'k':
+
-					if y == ey {
+		return ch, true
-						continue
+	default:
+		if s.wakeup {
+			g.wakeMonster(y, x)
 		}
-				case 'l':
+
-					if x == sx {
+		if g.seeMonst(tp) {
-						continue
+			if p.On(Hallucinating) {
+				return g.randomMonsterLetter(), false
 			}
-				case 'y':
+
-					if (y+x)-sumhero >= 1 {
+			return tp.Disguise, false
-						continue
 		}
-				case 'u':
+
-					if (y-x)-diffhero >= 1 {
+		return ch, false
-						continue
-					}
-				case 'n':
-					if (y+x)-sumhero <= -1 {
-						continue
-					}
-				case 'b':
-					if (y-x)-diffhero <= -1 {
-						continue
 	}
 }
+
+// lookRunCheck decides whether what this square shows should stop a run
+// (the DoorStop tail of the misc.c look loop). Squares on the running
+// edge are ignored.
+func (g *RogueGame) lookRunCheck(s *lookScan, ch byte, y, x int) {
+	if s.atRunEdge(g.RunCh, y, x) {
+		return
+	}
+
 	switch ch {
 	case Door:
-					if x == hero.X || y == hero.Y {
+		if x == s.hero.X || y == s.hero.Y {
 			g.Running = false
 		}
 	case Passage:
-					if x == hero.X || y == hero.Y {
+		if x == s.hero.X || y == s.hero.Y {
-						passcount++
+			s.passcount++
 		}
 	case Floor, '|', '-', ' ':
 	default:
 		g.Running = false
 	}
 }
+
+// atRunEdge reports whether (y, x) sits on the leading edge of the run
+// direction, where door-stop checking does not apply (the first RunCh
+// switch of the misc.c look loop).
+func (s *lookScan) atRunEdge(runCh byte, y, x int) bool {
+	switch runCh {
+	case 'h':
+		return x == s.ex
+	case 'j':
+		return y == s.sy
+	case 'k':
+		return y == s.ey
+	case 'l':
+		return x == s.sx
+	case 'y':
+		return (y+x)-s.sumhero >= 1
+	case 'u':
+		return (y-x)-s.diffhero >= 1
+	case 'n':
+		return (y+x)-s.sumhero <= -1
+	case 'b':
+		return (y-x)-s.diffhero <= -1
 	}
-	}
+
-	if g.DoorStop && !g.Firstmove && passcount > 1 {
+	return false
-		g.Running = false
-	}
-	if !g.Running || !g.Options.Jump {
-		g.mvaddch(hero.Y, hero.X, PlayerCh)
-	}
 }
 
 // tripCh returns the character for this space, taking into account whether
@@ -165,26 +257,30 @@ func (g *RogueGame) tripCh(y, x int, ch byte) byte {
 			}
 		}
 	}
+
 	return ch
 }
 
 // eraseLamp erases the area shown by a lamp in a dark room
 // (misc.c erase_lamp).
 func (g *RogueGame) eraseLamp(pos Coord, rp *Room) {
-	if !(g.Options.SeeFloor && rp.Flags&(Gone|Dark) == Dark &&
+	if !g.Options.SeeFloor || rp.Flags&(Gone|Dark) != Dark ||
-		!g.Player.On(Blind)) {
+		g.Player.On(Blind) {
 		return
 	}
 
 	ey := pos.Y + 1
 	ex := pos.X + 1
+
 	sy := pos.Y - 1
 	for x := pos.X - 1; x <= ex; x++ {
 		for y := sy; y <= ey; y++ {
 			if y == g.Player.Pos.Y && x == g.Player.Pos.X {
 				continue
 			}
+
 			g.move(y, x)
+
 			if g.inch() == Floor {
 				g.addch(' ')
 			}
@@ -198,53 +294,53 @@ func (g *RogueGame) showFloor() bool {
 	if g.Player.Room.Flags&(Gone|Dark) == Dark && !g.Player.On(Blind) {
 		return g.Options.SeeFloor
 	}
-	return true
-}
 
-// findObj finds the unclaimed object at (y, x) (misc.c find_obj).
+	return true
-func (g *RogueGame) findObj(y, x int) *Object {
-	for _, obj := range g.Level.Objects {
-		if obj.Pos.Y == y && obj.Pos.X == x {
-			return obj
-		}
-	}
-	return nil
 }
 
 // eat lets her try to eat something (misc.c eat).
 func (g *RogueGame) eat() {
-	obj := g.getItem("eat", KindFood)
+	obj, ok := g.promptPackItem("eat", KindFood)
-	if obj == nil {
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindFood {
 		if !g.Options.Terse {
 			g.msg("ugh, you would get ill if you ate that")
 		} else {
 			g.msg("that's Inedible!")
 		}
+
 		return
 	}
+
 	p := &g.Player
 	if p.FoodLeft < 0 {
 		p.FoodLeft = 0
 	}
+
 	if p.FoodLeft += HungerTime - 200 + g.rnd(400); p.FoodLeft > StomachSize {
 		p.FoodLeft = StomachSize
 	}
+
 	p.HungryState = 0
 	if obj == p.CurWeapon {
 		p.CurWeapon = nil
 	}
-	if obj.Which == 1 {
+
+	switch {
+	case obj.Which == 1:
 		g.msg("my, that was a yummy %s", g.Fruit)
-	} else if g.rnd(100) > 70 {
+	case g.rnd(100) > 70:
 		p.Stats.Exp++
+
 		g.msg("%s, this food tastes awful", g.chooseStr("bummer", "yuk"))
 		g.checkLevel()
-	} else {
+	default:
 		g.msg("%s, that tasted good", g.chooseStr("oh, wow", "yum"))
 	}
+
 	g.leavePack(obj, false, false)
 }
 
@@ -252,38 +348,46 @@ func (g *RogueGame) eat() {
 // check_level).
 func (g *RogueGame) checkLevel() {
 	p := &g.Player
+
 	var i int
-	for i = 0; eLevels[i] != 0; i++ {
+	for i = 0; g.data.eLevels[i] != 0; i++ {
-		if eLevels[i] > p.Stats.Exp {
+		if g.data.eLevels[i] > p.Stats.Exp {
 			break
 		}
 	}
+
 	i++
 	olevel := p.Stats.Lvl
+
 	p.Stats.Lvl = i
 	if i > olevel {
 		add := g.roll(i-olevel, 10)
 		p.Stats.MaxHP += add
 		p.Stats.HP += add
+
 		g.msg("welcome to level %d", i)
 	}
 }
 
-// chgStr modifies the player's strength, keeping track of the highest it
+// changeStrength modifies the player's strength, keeping track of the
-// has been (misc.c chg_str).
+// highest it has been (misc.c chg_str).
-func (g *RogueGame) chgStr(amt int) {
+func (g *RogueGame) changeStrength(amt int) {
 	if amt == 0 {
 		return
 	}
+
 	p := &g.Player
 	addStr(&p.Stats.Str, amt)
+
 	comp := p.Stats.Str
 	if p.IsRing(Left, RingAddStrength) {
 		addStr(&comp, -p.CurRing[Left].Bonus)
 	}
+
 	if p.IsRing(Right, RingAddStrength) {
 		addStr(&comp, -p.CurRing[Right].Bonus)
 	}
+
 	if comp > p.MaxStats.Str {
 		p.MaxStats.Str = comp
 	}
@@ -303,24 +407,29 @@ func (g *RogueGame) addHaste(potion bool) bool {
 	p := &g.Player
 	if p.On(Hasted) {
 		g.NoCommand += g.rnd(8)
+
 		p.Flags.Clear(Awake | Hasted)
 		g.Extinguish(DNohaste)
 		g.msg("you faint from exhaustion")
+
 		return false
 	}
+
 	p.Flags.Set(Hasted)
+
 	if potion {
 		g.Fuse(DNohaste, 0, g.rnd(4)+4, After)
 	}
+
 	return true
 }
 
 // aggravate aggravates all the monsters on this level (misc.c aggravate).
 func (g *RogueGame) aggravate() {
-	// runto() can splice the monster list while we walk it, so iterate a copy.
+	// runTo() can splice the monster list while we walk it, so iterate a copy.
 	monsters := append([]*Monster(nil), g.Level.Monsters...)
 	for _, mp := range monsters {
-		g.runto(mp.Pos)
+		g.runTo(mp.Pos)
 	}
 }
 
@@ -330,10 +439,12 @@ func vowelstr(str string) string {
 	if str == "" {
 		return ""
 	}
+
 	switch str[0] {
 	case 'a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U':
 		return "n"
 	}
+
 	return ""
 }
 
@@ -343,21 +454,25 @@ func (g *RogueGame) isCurrent(obj *Object) bool {
 	if obj == nil {
 		return false
 	}
+
 	p := &g.Player
 	if obj == p.CurArmor || obj == p.CurWeapon ||
 		obj == p.CurRing[Left] || obj == p.CurRing[Right] {
 		if !g.Options.Terse {
-			g.addmsg("That's already ")
+			g.addmsgf("That's already ")
 		}
+
 		g.msg("in use")
+
 		return true
 	}
+
 	return false
 }
 
-// getDir sets up the direction coordinate for use in various "prefix"
+// promptDirection sets up the direction coordinate for use in various
-// commands (misc.c get_dir).
+// "prefix" commands (misc.c get_dir).
-func (g *RogueGame) getDir() bool {
+func (g *RogueGame) promptDirection() bool {
 	if g.Again && g.LastDir != 0 {
 		g.Delta = g.lastDelt
 		g.DirCh = g.LastDir
@@ -367,53 +482,76 @@ func (g *RogueGame) getDir() bool {
 			prompt = "which direction? "
 			g.msg("%s", prompt)
 		}
+
 		for {
-			gotit := true
+			g.DirCh = g.readchar()
-			switch g.DirCh = g.readchar(); g.DirCh {
+			if g.DirCh == Escape {
-			case 'h', 'H':
-				g.Delta = Coord{X: -1, Y: 0}
-			case 'j', 'J':
-				g.Delta = Coord{X: 0, Y: 1}
-			case 'k', 'K':
-				g.Delta = Coord{X: 0, Y: -1}
-			case 'l', 'L':
-				g.Delta = Coord{X: 1, Y: 0}
-			case 'y', 'Y':
-				g.Delta = Coord{X: -1, Y: -1}
-			case 'u', 'U':
-				g.Delta = Coord{X: 1, Y: -1}
-			case 'b', 'B':
-				g.Delta = Coord{X: -1, Y: 1}
-			case 'n', 'N':
-				g.Delta = Coord{X: 1, Y: 1}
-			case Escape:
 				g.LastDir = 0
 				g.resetLast()
+
 				return false
-			default:
-				g.Msgs.Mpos = 0
-				g.msg("%s", prompt)
-				gotit = false
 			}
-			if gotit {
+
+			if d, ok := deltaFor(g.DirCh); ok {
+				g.Delta = d
+
 				break
 			}
+
+			g.Msgs.Mpos = 0
+			g.msg("%s", prompt)
 		}
+
 		g.DirCh = toLower(g.DirCh)
 		g.LastDir = g.DirCh
 		g.lastDelt = g.Delta
 	}
+
 	if g.Player.On(Confused) && g.rnd(5) == 0 {
+		g.confuseDirection()
+	}
+
+	g.Msgs.Mpos = 0
+
+	return true
+}
+
+// confuseDirection randomizes the chosen direction for a confused hero
+// (the ISHUH tail of misc.c get_dir).
+func (g *RogueGame) confuseDirection() {
 	for {
 		g.Delta.Y = g.rnd(3) - 1
+
 		g.Delta.X = g.rnd(3) - 1
 		if g.Delta.Y != 0 || g.Delta.X != 0 {
-				break
+			return
 		}
 	}
 }
-	g.Msgs.Mpos = 0
+
-	return true
+// deltaFor maps a direction key to its movement delta; ok is false for
+// keys that are not directions (the switch of misc.c get_dir).
+func deltaFor(ch byte) (Coord, bool) {
+	switch ch {
+	case 'h', 'H':
+		return Coord{X: -1, Y: 0}, true
+	case 'j', 'J':
+		return Coord{X: 0, Y: 1}, true
+	case 'k', 'K':
+		return Coord{X: 0, Y: -1}, true
+	case 'l', 'L':
+		return Coord{X: 1, Y: 0}, true
+	case 'y', 'Y':
+		return Coord{X: -1, Y: -1}, true
+	case 'u', 'U':
+		return Coord{X: 1, Y: -1}, true
+	case 'b', 'B':
+		return Coord{X: -1, Y: 1}, true
+	case 'n', 'N':
+		return Coord{X: 1, Y: 1}, true
+	}
+
+	return Coord{}, false
 }
 
 // callIt calls an object something after use (misc.c call_it).
@@ -422,6 +560,7 @@ func (g *RogueGame) callIt(info *ObjInfo) {
 		info.Guess = ""
 	} else if info.Guess == "" {
 		g.msg("%s", g.chooseTerse("call it: ", "what do you want to call it? "))
+
 		buf := ""
 		if g.getStr(&buf, g.scr.Std) == Norm {
 			if buf != "" {
@@ -431,21 +570,17 @@ func (g *RogueGame) callIt(info *ObjInfo) {
 	}
 }
 
-// thingList is misc.c rnd_thing()'s static table.
-var thingList = []byte{
-	Potion, Scroll, Ring, Stick, Food, Weapon, Armor, Stairs, Gold, Amulet,
-}
-
 // rndThing picks a random thing appropriate for this level (misc.c
 // rnd_thing).
 func (g *RogueGame) rndThing() byte {
 	var i int
 	if g.Depth >= AmuletLevel {
-		i = g.rnd(len(thingList))
+		i = g.rnd(len(g.data.thingList))
 	} else {
-		i = g.rnd(len(thingList) - 1)
+		i = g.rnd(len(g.data.thingList) - 1)
 	}
-	return thingList[i]
+
+	return g.data.thingList[i]
 }
 
 // chooseStr picks the first or second string depending on whether the
@@ -454,6 +589,7 @@ func (g *RogueGame) chooseStr(ts, ns string) string {
 	if g.Player.On(Hallucinating) {
 		return ts
 	}
+
 	return ns
 }
 
@@ -463,8 +599,10 @@ func unctrl(ch byte) string {
 	if ch < ' ' {
 		return "^" + string(ch+'@')
 	}
+
 	if ch == 0x7f {
 		return "^?"
 	}
+
 	return string(ch)
 }

game/monsters.go

@@ -2,33 +2,24 @@ package game
 
 // monsters.c — monster creation and saving throws.
 
-// lvlMons and wandMons list monsters in rough order of vorpalness; zero
-// entries in wandMons never wander (monsters.c).
-var lvlMons = [26]byte{
-	'K', 'E', 'B', 'S', 'H', 'I', 'R', 'O', 'Z', 'L', 'C', 'Q', 'A',
-	'N', 'Y', 'F', 'T', 'W', 'P', 'X', 'U', 'M', 'V', 'G', 'J', 'D',
-}
-
-var wandMons = [26]byte{
-	'K', 'E', 'B', 'S', 'H', 0, 'R', 'O', 'Z', 0, 'C', 'Q', 'A',
-	0, 'Y', 0, 'T', 'W', 'P', 0, 'U', 'M', 'V', 'G', 'J', 0,
-}
-
 // randMonster picks a monster to show up; the lower the level, the meaner
 // the monster (monsters.c randmonster).
 func (g *RogueGame) randMonster(wander bool) byte {
-	mons := &lvlMons
+	mons := &g.data.lvlMons
 	if wander {
-		mons = &wandMons
+		mons = &g.data.wandMons
 	}
+
 	for {
 		d := g.Depth + (g.rnd(10) - 6)
 		if d < 0 {
 			d = g.rnd(5)
 		}
+
 		if d > 25 {
 			d = g.rnd(5) + 21
 		}
+
 		if mons[d] != 0 {
 			return mons[d]
 		}
@@ -38,17 +29,15 @@ func (g *RogueGame) randMonster(wander bool) byte {
 // newMonster picks a new monster and adds it to the list (monsters.c
 // new_monster).
 func (g *RogueGame) newMonster(tp *Monster, typ byte, cp Coord) {
-	levAdd := g.Depth - AmuletLevel
+	levAdd := max(g.Depth-AmuletLevel, 0)
-	if levAdd < 0 {
+
-		levAdd = 0
+	g.Level.AddMonster(tp)
-	}
-	attachMon(&g.Level.Monsters, tp)
 	tp.Type = typ
 	tp.Disguise = typ
 	tp.Pos = cp
 	g.move(cp.Y, cp.X)
 	tp.OldCh = g.inch()
-	tp.Room = g.roomin(cp)
+	tp.Room = g.roomIn(cp)
 	g.Level.SetMonsterAt(cp.Y, cp.X, tp)
 	mp := &g.Monsters[tp.Type-'A']
 	tp.Stats.Lvl = mp.Stats.Lvl + levAdd
@@ -58,15 +47,19 @@ func (g *RogueGame) newMonster(tp *Monster, typ byte, cp Coord) {
 	tp.Stats.Dmg = mp.Stats.Dmg
 	tp.Stats.Str = mp.Stats.Str
 	tp.Stats.Exp = mp.Stats.Exp + levAdd*10 + expAdd(tp)
+
 	tp.Flags = mp.Flags
 	if g.Depth > 29 {
 		tp.Flags.Set(Hasted)
 	}
+
 	tp.Turn = true
 	tp.Pack = nil
+
 	if g.Player.IsWearing(RingAggravateMonsters) {
-		g.runto(cp)
+		g.runTo(cp)
 	}
+
 	if typ == 'X' {
 		tp.Disguise = g.rndThing()
 	}
@@ -81,11 +74,13 @@ func expAdd(tp *Monster) int {
 	} else {
 		mod = tp.Stats.MaxHP / 6
 	}
+
 	if tp.Stats.Lvl > 9 {
 		mod *= 20
 	} else if tp.Stats.Lvl > 6 {
 		mod *= 4
 	}
+
 	return mod
 }
 
@@ -93,73 +88,115 @@ func expAdd(tp *Monster) int {
 // (monsters.c wanderer).
 func (g *RogueGame) wanderer() {
 	tp := &Monster{}
+
 	var cp Coord
 	for {
-		cp, _ = g.findFloor(nil, 0, true)
+		cp, _ = g.findFloor(true)
-		if g.roomin(cp) != g.Player.Room {
+		if g.roomIn(cp) != g.Player.Room {
 			break
 		}
 	}
+
 	g.newMonster(tp, g.randMonster(true), cp)
+
 	if g.Player.On(SenseMonsters) {
 		g.standout()
+
 		if !g.Player.On(Hallucinating) {
 			g.addch(tp.Type)
 		} else {
-			g.addch(byte(g.rnd(26) + 'A'))
+			g.addch(g.randomMonsterLetter())
 		}
+
 		g.standend()
 	}
-	g.runto(tp.Pos)
+
+	g.runTo(tp.Pos)
 }
 
 // wakeMonster is what to do when the hero steps next to a monster
 // (monsters.c wake_monster).
-func (g *RogueGame) wakeMonster(y, x int) *Monster {
+func (g *RogueGame) wakeMonster(y, x int) {
 	p := &g.Player
+
 	tp := g.Level.MonsterAt(y, x)
 	if tp == nil {
 		panic("can't find monster in wake_monster")
 	}
-	ch := tp.Type
+
 	// Every time he sees a mean monster, it might start chasing him
-	if !tp.On(Awake) && g.rnd(3) != 0 && tp.On(Mean) && !tp.On(Held) &&
+	if g.meanWakes(tp) {
-		!p.IsWearing(RingStealth) && !p.On(Levitating) {
 		tp.Dest = &p.Pos
 		tp.Flags.Set(Awake)
 	}
-	if ch == 'M' && !p.On(Blind) && !p.On(Hallucinating) &&
+
-		!tp.On(Found) && !tp.On(Cancelled) && tp.On(Awake) {
+	if g.medusaCatches(tp) {
-		rp := p.Room
+		g.medusaGaze(tp, y, x)
-		if (rp != nil && !rp.Flags.Has(Dark)) ||
-			distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
-			tp.Flags.Set(Found)
-			if !g.save(VsMagic) {
-				if p.On(Confused) {
-					g.Lengthen(DUnconfuse, g.spread(HuhDuration))
-				} else {
-					g.Fuse(DUnconfuse, 0, g.spread(HuhDuration), After)
-				}
-				p.Flags.Set(Confused)
-				mname := g.setMname(tp)
-				g.addmsg("%s", mname)
-				if mname != "it" {
-					g.addmsg("'")
-				}
-				g.msg("s gaze has confused you")
-			}
-		}
 	}
 	// Let greedy ones guard gold
 	if tp.On(Greedy) && !tp.On(Awake) {
 		tp.Flags.Set(Awake)
+
 		if p.Room.GoldVal != 0 {
 			tp.Dest = &p.Room.Gold
 		} else {
 			tp.Dest = &p.Pos
 		}
 	}
-	return tp
+}
+
+// meanWakes decides whether a sleeping mean monster starts the chase
+// (monsters.c wake_monster). The waking roll happens for any sleeping
+// monster, as in C.
+func (g *RogueGame) meanWakes(tp *Monster) bool {
+	p := &g.Player
+
+	return !tp.On(Awake) && g.rnd(3) != 0 && tp.On(Mean) && !tp.On(Held) &&
+		!p.IsWearing(RingStealth) && !p.On(Levitating)
+}
+
+// medusaCatches reports an uncovered, awake medusa the hero can see
+// (monsters.c wake_monster).
+func (g *RogueGame) medusaCatches(tp *Monster) bool {
+	p := &g.Player
+
+	return tp.Type == 'M' && !p.On(Blind) && !p.On(Hallucinating) &&
+		!tp.On(Found) && !tp.On(Cancelled) && tp.On(Awake)
+}
+
+// medusaGaze confuses the hero when the medusa's gaze lands (the M
+// block of monsters.c wake_monster).
+func (g *RogueGame) medusaGaze(tp *Monster, y, x int) {
+	p := &g.Player
+
+	rp := p.Room
+	if (rp == nil || rp.Flags.Has(Dark)) &&
+		distance(y, x, p.Pos.Y, p.Pos.X) >= LampDist {
+		return
+	}
+
+	tp.Flags.Set(Found)
+
+	if g.save(VsMagic) {
+		return
+	}
+
+	if p.On(Confused) {
+		g.Lengthen(DUnconfuse, g.spread(HuhDuration))
+	} else {
+		g.Fuse(DUnconfuse, 0, g.spread(HuhDuration), After)
+	}
+
+	p.Flags.Set(Confused)
+
+	mname := g.setMname(tp)
+	g.addmsgf("%s", mname)
+
+	if mname != "it" {
+		g.addmsgf("'")
+	}
+
+	g.msg("s gaze has confused you")
 }
 
 // givePack gives a pack to a monster if it deserves one (monsters.c
@@ -174,6 +211,7 @@ func (g *RogueGame) givePack(tp *Monster) {
 // save_throw).
 func (g *RogueGame) saveThrow(which int, st *Stats) bool {
 	need := 14 + which - st.Lvl/2
+
 	return g.roll(1, 20) >= need
 }
 
@@ -185,9 +223,17 @@ func (g *RogueGame) save(which int) bool {
 		if p.IsRing(Left, RingProtection) {
 			which -= p.CurRing[Left].Bonus
 		}
+
 		if p.IsRing(Right, RingProtection) {
 			which -= p.CurRing[Right].Bonus
 		}
 	}
+
 	return g.saveThrow(which, &p.Stats)
 }
+
+// randomMonsterLetter picks a random monster display letter, used by the
+// hallucination effects (the C rnd(26)+'A' idiom).
+func (g *RogueGame) randomMonsterLetter() byte {
+	return byte(g.rnd(26) + 'A') //nolint:gosec // G115: 'A'..'Z' fits a byte
+}

game/move.go

@@ -2,55 +2,148 @@ package game
 
 // move.c — hero movement commands.
 
-// doRun starts the hero running (move.c do_run).
+// startRun starts the hero running (move.c do_run).
-func (g *RogueGame) doRun(ch byte) {
+func (g *RogueGame) startRun(ch byte) {
 	g.Running = true
 	g.After = false
 	g.RunCh = ch
 }
 
-// doMove checks that a move is legal and handles the consequences —
+// moveHero checks that a move is legal and handles the consequences —
-// fighting, picking up, etc. (move.c do_move).
+// fighting, picking up, etc. (move.c do_move). The C `goto over`
-func (g *RogueGame) doMove(dy, dx int) {
+// re-check after a passage turn is the retry loop.
+func (g *RogueGame) moveHero(dy, dx int) {
 	p := &g.Player
+
 	g.Firstmove = false
 	if g.NoMove > 0 {
 		g.NoMove--
 		g.msg("you are still stuck in the bear trap")
+
 		return
 	}
 	// Do a confused move (maybe)
 	var nh Coord
 	if p.On(Confused) && g.rnd(5) != 0 {
-		nh = g.rndmove(&p.Creature)
+		nh = g.randomStep(&p.Creature)
 		if nh == p.Pos {
 			g.After = false
 			g.Running = false
 			g.ToDeath = false
+
 			return
 		}
 	} else {
 		nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
 	}
 
-over:
+	for {
-	// Check if he tried to move off the screen or make an illegal diagonal
+		ch, fl, stop := g.moveTarget(nh)
-	// move, and stop him if he did.
+		if stop {
-	hitBound := nh.X < 0 || nh.X >= NumCols || nh.Y <= 0 || nh.Y >= NumLines-1
+			return
-	var ch byte
+		}
-	var fl PlaceFlags
+
-	if !hitBound {
+		turned, ndy, ndx := g.moveResolve(nh, ch, fl, dy, dx)
+		if !turned {
+			return
+		}
+
+		// the C goto over: re-check the turned move
+		dy, dx = ndy, ndx
+
+		g.turnRefresh()
+
+		nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
+	}
+}
+
+// moveResolve acts on the square the hero stepped at: a wall may turn a
+// passage runner (reported with the new deltas); anything else completes
+// or refuses the move (the switch of move.c do_move).
+func (g *RogueGame) moveResolve(nh Coord, ch byte, fl PlaceFlags, dy, dx int) (bool, int, int) {
+	switch ch {
+	case ' ', '|', '-':
+		if turn, ndy, ndx := g.passageTurn(dy, dx); turn {
+			return true, ndy, ndx
+		}
+
+		g.Running = false
+		g.After = false
+	default:
+		g.moveEnter(nh, fl, ch)
+	}
+
+	return false, 0, 0
+}
+
+// moveEnter completes a step onto a walkable square: doors, traps,
+// passages, floor, and things (the entry arms of the move.c do_move
+// switch).
+func (g *RogueGame) moveEnter(nh Coord, fl PlaceFlags, ch byte) {
+	p := &g.Player
+
+	switch ch {
+	case Door:
+		g.Running = false
+		if g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Has(FPassage) {
+			g.enterRoom(nh)
+		}
+	case Trap:
+		tr := g.springTrap(nh)
+		if tr == TrapDoor || tr == TrapTeleport {
+			return
+		}
+	case Passage:
+		// when you're in a corridor, you don't know if you're in a maze
+		// room or not, and there ain't no way to find out if you're
+		// leaving a maze room, so it is necessary to always recalculate
+		// proom.
+		p.Room = g.roomIn(p.Pos)
+	case Floor:
+		if !fl.Has(FReal) {
+			g.springTrap(p.Pos)
+		}
+	default:
+		g.moveOnto(nh, fl, ch)
+
+		return
+	}
+
+	g.finishMove(nh, fl)
+}
+
+// offMap reports coordinates outside the walkable map (move.c do_move).
+func offMap(nh Coord) bool {
+	return nh.X < 0 || nh.X >= NumCols || nh.Y <= 0 || nh.Y >= NumLines-1
+}
+
+// moveTarget inspects the square the hero is stepping onto: bounds and
+// diagonal legality, hidden traps underfoot, and being held. stop means
+// the move is refused (the checks of move.c do_move).
+func (g *RogueGame) moveTarget(nh Coord) (byte, PlaceFlags, bool) {
+	p := &g.Player
+
+	// Check if he tried to move off the screen or make an illegal
+	// diagonal move, and stop him if he did.
+	if offMap(nh) {
+		return ' ', 0, false // fall into the wall case
+	}
+
 	if !g.diagOk(p.Pos, nh) {
 		g.After = false
 		g.Running = false
-			return
+
+		return 0, 0, true
 	}
+
 	if g.Running && p.Pos == nh {
 		g.After = false
 		g.Running = false
 	}
-		fl = *g.Level.FlagsAt(nh.Y, nh.X)
+
-		ch = g.Level.VisibleChar(nh.Y, nh.X)
+	fl := *g.Level.FlagsAt(nh.Y, nh.X)
+
+	ch := g.Level.VisibleChar(nh.Y, nh.X)
 	if !fl.Has(FReal) && ch == Floor {
 		if !p.On(Levitating) {
 			ch = Trap
@@ -59,82 +152,21 @@ over:
 		}
 	} else if p.On(Held) && ch != 'F' {
 		g.msg("you are being held")
-			return
+
+		return 0, 0, true
 	}
+
+	return ch, fl, false
 }
-	if hitBound {
+
-		ch = ' ' // fall into the wall case below
+// moveOnto handles stepping at a monster or onto an item (the default
-	}
+// arm of the move.c do_move switch).
-	switch ch {
+func (g *RogueGame) moveOnto(nh Coord, fl PlaceFlags, ch byte) {
-	case ' ', '|', '-':
+	p := &g.Player
-		if g.Options.PassGo && g.Running && p.Room.Flags.Has(Gone) &&
-			!p.On(Blind) {
-			var b1, b2 bool
-			switch g.RunCh {
-			case 'h', 'l':
-				b1 = p.Pos.Y != 1 && g.turnOk(p.Pos.Y-1, p.Pos.X)
-				b2 = p.Pos.Y != NumLines-2 && g.turnOk(p.Pos.Y+1, p.Pos.X)
-				if b1 != b2 {
-					if b1 {
-						g.RunCh = 'k'
-						dy = -1
-					} else {
-						g.RunCh = 'j'
-						dy = 1
-					}
-					dx = 0
-					g.turnref()
-					nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
-					goto over
-				}
-			case 'j', 'k':
-				b1 = p.Pos.X != 0 && g.turnOk(p.Pos.Y, p.Pos.X-1)
-				b2 = p.Pos.X != NumCols-1 && g.turnOk(p.Pos.Y, p.Pos.X+1)
-				if b1 != b2 {
-					if b1 {
-						g.RunCh = 'h'
-						dx = -1
-					} else {
-						g.RunCh = 'l'
-						dx = 1
-					}
-					dy = 0
-					g.turnref()
-					nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
-					goto over
-				}
-			}
-		}
-		g.Running = false
-		g.After = false
-	case Door:
-		g.Running = false
-		if g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Has(FPassage) {
-			g.enterRoom(nh)
-		}
-		g.moveStuff(nh, fl)
-	case Trap:
-		tr := g.beTrapped(nh)
-		if tr == TrapDoor || tr == TrapTeleport {
-			return
-		}
-		g.moveStuff(nh, fl)
-	case Passage:
-		// when you're in a corridor, you don't know if you're in a maze
-		// room or not, and there ain't no way to find out if you're
-		// leaving a maze room, so it is necessary to always recalculate
-		// proom.
-		p.Room = g.roomin(p.Pos)
-		g.moveStuff(nh, fl)
-	case Floor:
-		if !fl.Has(FReal) {
-			g.beTrapped(p.Pos)
-		}
-		g.moveStuff(nh, fl)
-	default:
 	if ch == Stairs {
 		g.SeenStairs = true
 	}
+
 	g.Running = false
 	if isUpper(ch) || g.Level.MonsterAt(nh.Y, nh.X) != nil {
 		g.fight(nh, p.CurWeapon, false)
@@ -142,18 +174,90 @@ over:
 		if ch != Stairs {
 			g.Take = ch
 		}
-			g.moveStuff(nh, fl)
+
-		}
+		g.finishMove(nh, fl)
 	}
 }
 
-// moveStuff is the move_stuff label in do_move: complete the step.
+// passageTurn checks whether a runner in a gone-room passage should turn
-func (g *RogueGame) moveStuff(nh Coord, fl PlaceFlags) {
+// the corner instead of stopping at a wall (the PASSGO block of move.c
+// do_move). It reports whether to turn and the new deltas, updating RunCh.
+func (g *RogueGame) passageTurn(dy, dx int) (bool, int, int) {
+	p := &g.Player
+	if !g.Options.PassGo || !g.Running || !p.Room.Flags.Has(Gone) ||
+		p.On(Blind) {
+		return false, dy, dx
+	}
+
+	switch g.RunCh {
+	case 'h', 'l':
+		if turn, ndy := g.passageTurnVertical(); turn {
+			return true, ndy, 0
+		}
+	case 'j', 'k':
+		if turn, ndx := g.passageTurnHorizontal(); turn {
+			return true, 0, ndx
+		}
+	}
+
+	return false, dy, dx
+}
+
+// passageTurnVertical decides whether a horizontal runner turns up or
+// down at a corner (move.c do_move).
+func (g *RogueGame) passageTurnVertical() (bool, int) {
+	p := &g.Player
+
+	b1 := p.Pos.Y != 1 && g.turnOk(p.Pos.Y-1, p.Pos.X)
+
+	b2 := p.Pos.Y != NumLines-2 && g.turnOk(p.Pos.Y+1, p.Pos.X)
+	if b1 == b2 {
+		return false, 0
+	}
+
+	if b1 {
+		g.RunCh = 'k'
+
+		return true, -1
+	}
+
+	g.RunCh = 'j'
+
+	return true, 1
+}
+
+// passageTurnHorizontal decides whether a vertical runner turns left or
+// right at a corner (move.c do_move).
+func (g *RogueGame) passageTurnHorizontal() (bool, int) {
+	p := &g.Player
+
+	b1 := p.Pos.X != 0 && g.turnOk(p.Pos.Y, p.Pos.X-1)
+
+	b2 := p.Pos.X != NumCols-1 && g.turnOk(p.Pos.Y, p.Pos.X+1)
+	if b1 == b2 {
+		return false, 0
+	}
+
+	if b1 {
+		g.RunCh = 'h'
+
+		return true, -1
+	}
+
+	g.RunCh = 'l'
+
+	return true, 1
+}
+
+// finishMove is the move_stuff label in do_move: complete the step.
+func (g *RogueGame) finishMove(nh Coord, fl PlaceFlags) {
 	p := &g.Player
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())
+
 	if fl.Has(FPassage) && g.Level.Char(g.Oldpos.Y, g.Oldpos.X) == Door {
 		g.leaveRoom(nh)
 	}
+
 	p.Pos = nh
 }
 
@@ -161,17 +265,21 @@ func (g *RogueGame) moveStuff(nh Coord, fl PlaceFlags) {
 // (move.c turn_ok).
 func (g *RogueGame) turnOk(y, x int) bool {
 	pp := g.Level.At(y, x)
+
 	return pp.Ch == Door || pp.Flags&(FReal|FPassage) == (FReal|FPassage)
 }
 
-// turnref decides whether to refresh at a passage turning (move.c turnref).
+// turnRefresh decides whether to refresh at a passage turning (move.c
-func (g *RogueGame) turnref() {
+// turnref).
+func (g *RogueGame) turnRefresh() {
 	p := &g.Player
+
 	pp := g.Level.At(p.Pos.Y, p.Pos.X)
 	if !pp.Flags.Has(FSeen) {
 		if g.Options.Jump {
 			g.refresh()
 		}
+
 		pp.Flags.Set(FSeen)
 	}
 }
@@ -182,6 +290,7 @@ func (g *RogueGame) doorOpen(rp *Room) {
 	if rp.Flags.Has(Gone) {
 		return
 	}
+
 	for y := rp.Pos.Y; y < rp.Pos.Y+rp.Max.Y; y++ {
 		for x := rp.Pos.X; x < rp.Pos.X+rp.Max.X; x++ {
 			if isUpper(g.Level.VisibleChar(y, x)) {
@@ -191,42 +300,68 @@ func (g *RogueGame) doorOpen(rp *Room) {
 	}
 }
 
-// beTrapped makes him pay for stepping on a trap (move.c be_trapped).
+// springTrap makes him pay for stepping on a trap (move.c be_trapped).
-func (g *RogueGame) beTrapped(tc Coord) TrapKind {
+func (g *RogueGame) springTrap(tc Coord) TrapKind {
 	p := &g.Player
 	if p.On(Levitating) {
 		return TrapRust // anything that's not a door or teleport
 	}
+
 	g.Running = false
 	g.Count = 0
 	pp := g.Level.At(tc.Y, tc.X)
 	pp.Ch = Trap
 	tr := TrapKind(pp.Flags & FTrapMask)
 	pp.Flags.Set(FSeen)
-	switch tr {
+
-	case TrapDoor:
+	if h := g.data.trapHandlers[tr]; h != nil {
+		h(g, tc)
+	}
+
+	g.flushType()
+
+	return tr
+}
+
+// The per-trap effect handlers, dispatched through
+// gameData.trapHandlers. Each is one case of the C be_trapped switch.
+
+func (g *RogueGame) trapFall(Coord) {
 	g.Depth++
 	g.NewLevel()
 	g.msg("you fell into a trap!")
-	case TrapBear:
+}
+
+func (g *RogueGame) trapBear(Coord) {
 	g.NoMove += g.spread(3) // BEARTIME
 	g.msg("you are caught in a bear trap")
-	case TrapMystery:
+}
-		switch g.rnd(11) {
+
+func (g *RogueGame) trapMystery(Coord) {
+	which := g.rnd(11)
+	switch which {
 	case 0:
 		g.msg("you are suddenly in a parallel dimension")
 	case 1:
-			g.msg("the light in here suddenly seems %s", rainbow[g.rnd(len(rainbow))])
+		g.msg("the light in here suddenly seems %s", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 	case 2:
 		g.msg("you feel a sting in the side of your neck")
 	case 3:
 		g.msg("multi-colored lines swirl around you, then fade")
 	case 4:
-			g.msg("a %s light flashes in your eyes", rainbow[g.rnd(len(rainbow))])
+		g.msg("a %s light flashes in your eyes", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 	case 5:
 		g.msg("a spike shoots past your ear!")
+	default:
+		g.trapMysteryMore(which)
+	}
+}
+
+// trapMysteryMore holds the back half of the mystery-trap messages.
+func (g *RogueGame) trapMysteryMore(which int) {
+	switch which {
 	case 6:
-			g.msg("%s sparks dance across your armor", rainbow[g.rnd(len(rainbow))])
+		g.msg("%s sparks dance across your armor", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 	case 7:
 		g.msg("you suddenly feel very thirsty")
 	case 8:
@@ -234,13 +369,19 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 	case 9:
 		g.msg("time now seems to be going slower")
 	case 10:
-			g.msg("you pack turns %s!", rainbow[g.rnd(len(rainbow))])
+		g.msg("you pack turns %s!", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 	}
-	case TrapSleep:
+}
+
+func (g *RogueGame) trapSleep(Coord) {
 	g.NoCommand += g.spread(5) // SLEEPTIME
-		p.Flags.Clear(Awake)
+
+	g.Player.Flags.Clear(Awake)
 	g.msg("a strange white mist envelops you and you fall asleep")
-	case TrapArrow:
+}
+
+func (g *RogueGame) trapArrow(Coord) {
+	p := &g.Player
 	if g.swing(p.Stats.Lvl-1, p.Stats.ArmorClass, 1) {
 		p.Stats.HP -= g.roll(1, 6)
 		if p.Stats.HP <= 0 {
@@ -257,36 +398,44 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 		g.fall(arrow, false)
 		g.msg("an arrow shoots past you")
 	}
-	case TrapTeleport:
+}
+
+func (g *RogueGame) trapTeleport(tc Coord) {
 	// since the hero's leaving, look() won't put a TRAP down for us,
 	// so we have to do it ourself
 	g.teleport()
 	g.mvaddch(tc.Y, tc.X, Trap)
-	case TrapDart:
+}
+
+func (g *RogueGame) trapDart(Coord) {
+	p := &g.Player
 	if !g.swing(p.Stats.Lvl+1, p.Stats.ArmorClass, 1) {
 		g.msg("a small dart whizzes by your ear and vanishes")
-		} else {
+
+		return
+	}
+
 	p.Stats.HP -= g.roll(1, 4)
 	if p.Stats.HP <= 0 {
 		g.msg("a poisoned dart killed you")
 		g.death('d')
 	}
+
 	if !p.IsWearing(RingSustainStrength) && !g.save(VsPoison) {
-				g.chgStr(-1)
+		g.changeStrength(-1)
-			}
-			g.msg("a small dart just hit you in the shoulder")
-		}
-	case TrapRust:
-		g.msg("a gush of water hits you on the head")
-		g.rustArmor(p.CurArmor)
-	}
-	g.flushType()
-	return tr
 	}
 
-// rndmove moves in a random direction if the monster/person is confused
+	g.msg("a small dart just hit you in the shoulder")
-// (move.c rndmove).
+}
-func (g *RogueGame) rndmove(who *Creature) Coord {
+
+func (g *RogueGame) trapRust(Coord) {
+	g.msg("a gush of water hits you on the head")
+	g.rustArmor(g.Player.CurArmor)
+}
+
+// randomStep moves in a random direction if the monster/person is
+// confused (move.c rndmove).
+func (g *RogueGame) randomStep(who *Creature) Coord {
 	ret := Coord{
 		Y: who.Pos.Y + g.rnd(3) - 1,
 		X: who.Pos.X + g.rnd(3) - 1,
@@ -296,25 +445,32 @@ func (g *RogueGame) rndmove(who *Creature) Coord {
 	if ret == who.Pos {
 		return ret
 	}
+
 	if !g.diagOk(who.Pos, ret) {
 		return who.Pos
 	}
+
 	ch := g.Level.VisibleChar(ret.Y, ret.X)
 	if !stepOk(ch) {
 		return who.Pos
 	}
+
 	if ch == Scroll {
 		var found *Object
+
 		for _, obj := range g.Level.Objects {
 			if ret.Y == obj.Pos.Y && ret.X == obj.Pos.X {
 				found = obj
+
 				break
 			}
 		}
+
 		if found != nil && found.ScrollKind() == ScrollScareMonster {
 			return who.Pos
 		}
 	}
+
 	return ret
 }
 
@@ -332,6 +488,7 @@ func (g *RogueGame) rustArmor(arm *Object) {
 		}
 	} else {
 		arm.ArmorClass++
+
 		if !g.Options.Terse {
 			g.msg("your armor appears to be weaker now. Oh my!")
 		} else {

game/newlevel.go

@@ -13,6 +13,7 @@ const (
 func (g *RogueGame) NewLevel() {
 	p := &g.Player
 	p.Flags.Clear(Held) // unhold when you go down just in case
+
 	if g.Depth > g.MaxDepth {
 		g.MaxDepth = g.Depth
 	}
@@ -20,61 +21,65 @@ func (g *RogueGame) NewLevel() {
 	for i := range g.Level.Places {
 		g.Level.Places[i] = Place{Ch: ' ', Flags: FReal}
 	}
+
 	g.clear()
 	// Free up the monsters on the last level; the objects and their packs
 	// go with them (the garbage collector is our free_list).
 	g.Level.Monsters = nil
 	g.Level.Objects = nil
-	g.doRooms()    // Draw rooms
+	g.digRooms()    // Draw rooms
-	g.doPassages() // Draw passages
+	g.digPassages() // Draw passages
+
 	p.NoFood++
+
 	g.putThings() // Place objects (if any)
 	// Place the traps
 	if g.rnd(10) < g.Depth {
-		g.Level.TrapCount = g.rnd(g.Depth/4) + 1
+		g.Level.TrapCount = min(g.rnd(g.Depth/4)+1, MaxTraps)
-		if g.Level.TrapCount > MaxTraps {
+
-			g.Level.TrapCount = MaxTraps
-		}
 		for i := g.Level.TrapCount; i > 0; i-- {
 			// not only wouldn't it be NICE to have traps in mazes (not
 			// that we care about being nice), since the trap number is
 			// stored where the passage number is, we can't actually do it.
 			var stairs Coord
 			for {
-				stairs, _ = g.findFloor(nil, 0, false)
+				stairs, _ = g.findFloor(false)
 				if g.Level.Char(stairs.Y, stairs.X) == Floor {
 					break
 				}
 			}
+
 			sp := g.Level.FlagsAt(stairs.Y, stairs.X)
 			sp.Clear(FReal)
-			*sp |= PlaceFlags(g.rnd(NumTrapTypes))
+			*sp |= PlaceFlags(g.rnd(NumTrapTypes)) //nolint:gosec // G115: 0..7 fits
 		}
 	}
 	// Place the staircase down.
-	stairs, _ := g.findFloor(nil, 0, false)
+	stairs, _ := g.findFloor(false)
 	g.Level.Stairs = stairs
 	g.Level.SetChar(stairs.Y, stairs.X, Stairs)
 	g.SeenStairs = false
 
 	for _, tp := range g.Level.Monsters {
-		tp.Room = g.roomin(tp.Pos)
+		tp.Room = g.roomIn(tp.Pos)
 	}
 
-	hero, _ := g.findFloor(nil, 0, true)
+	hero, _ := g.findFloor(true)
 	p.Pos = hero
 	g.enterRoom(hero)
 	g.mvaddch(hero.Y, hero.X, PlayerCh)
+
 	if p.On(SenseMonsters) {
 		g.turnSee(false)
 	}
+
 	if p.On(Hallucinating) {
 		g.visuals(0)
 	}
 }
 
-// rndRoom picks a room that is really there (new_level.c rnd_room).
+// randomRoom picks a room that is really there (new_level.c rnd_room).
-func (g *RogueGame) rndRoom() int {
+func (g *RogueGame) randomRoom() int {
 	for {
 		rm := g.rnd(MaxRooms)
 		if !g.Level.Rooms[rm].Flags.Has(Gone) {
@@ -93,16 +98,16 @@ func (g *RogueGame) putThings() {
 	}
 	// check for treasure rooms, and if so, put it in.
 	if g.rnd(treasRoomChance) == 0 {
-		g.treasRoom()
+		g.treasureRoom()
 	}
 	// Do MAXOBJ attempts to put things on a level
-	for i := 0; i < MaxObj; i++ {
+	for range MaxObj {
 		if g.rnd(100) < 36 {
 			// Pick a new object and link it in the list
 			obj := g.newThing()
-			attachObj(&g.Level.Objects, obj)
+			g.Level.AddObject(obj)
 			// Put it somewhere
-			obj.Pos, _ = g.findFloor(nil, 0, false)
+			obj.Pos, _ = g.findFloor(false)
 			g.Level.SetChar(obj.Pos.Y, obj.Pos.X, obj.Kind.Glyph())
 		}
 	}
@@ -110,42 +115,40 @@ func (g *RogueGame) putThings() {
 	// yet, put it somewhere on the ground
 	if g.Depth >= AmuletLevel && !g.HasAmulet {
 		obj := newObject()
-		attachObj(&g.Level.Objects, obj)
+		g.Level.AddObject(obj)
 		obj.Damage = dice("0x0")
 		obj.HurlDmg = dice("0x0")
 		obj.ArmorClass = 11
 		obj.Kind = KindAmulet
 		// Put it somewhere
-		obj.Pos, _ = g.findFloor(nil, 0, false)
+		obj.Pos, _ = g.findFloor(false)
 		g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Amulet)
 	}
 }
 
-// treasRoom adds a treasure room (new_level.c treas_room).
+// treasureRoom adds a treasure room (new_level.c treas_room).
-func (g *RogueGame) treasRoom() {
+func (g *RogueGame) treasureRoom() {
-	rp := &g.Level.Rooms[g.rndRoom()]
+	rp := &g.Level.Rooms[g.randomRoom()]
-	spots := (rp.Max.Y-2)*(rp.Max.X-2) - minTreas
+
-	if spots > maxTreas-minTreas {
+	spots := min((rp.Max.Y-2)*(rp.Max.X-2)-minTreas, maxTreas-minTreas)
-		spots = maxTreas - minTreas
+
-	}
 	numMonst := g.rnd(spots) + minTreas
 	for nm := numMonst; nm > 0; nm-- {
 		mp, _ := g.findFloorIn(rp, 2*maxTries, false)
 		tp := g.newThing()
 		tp.Pos = mp
-		attachObj(&g.Level.Objects, tp)
+		g.Level.AddObject(tp)
 		g.Level.SetChar(mp.Y, mp.X, tp.Kind.Glyph())
 	}
 
 	// fill up room with monsters from the next level down
-	nm := g.rnd(spots) + minTreas
+	nm := max(g.rnd(spots)+minTreas, numMonst+2)
-	if nm < numMonst+2 {
+
-		nm = numMonst + 2
-	}
 	spots = (rp.Max.Y - 2) * (rp.Max.X - 2)
 	if nm > spots {
 		nm = spots
 	}
+
 	g.Depth++
 	for ; nm > 0; nm-- {
 		if mp, ok := g.findFloorIn(rp, maxTries, true); ok {
@@ -155,5 +158,6 @@ func (g *RogueGame) treasRoom() {
 			g.givePack(tp)
 		}
 	}
+
 	g.Depth--
 }

game/newlevel_test.go

@@ -7,24 +7,30 @@ import (
 
 func genLevel(t *testing.T, seed int32) *RogueGame {
 	t.Helper()
-	g := NewGame(Config{Seed: seed})
+
+	g := New(Params{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++ {
+	for y := range NumLines {
+		for x := range NumCols {
 			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()
 }
 
@@ -32,6 +38,19 @@ func TestNewLevelInvariants(t *testing.T) {
 	for _, seed := range []int32{1, 12345, 2026, 99999} {
 		g := genLevel(t, seed)
 
+		checkHeroPlacement(t, g, seed)
+		checkRoomsDrawn(t, g, seed)
+		checkMonstersPlaced(t, g, seed)
+		checkObjectsPlaced(t, g, seed)
+		checkStartingKit(t, g, seed)
+	}
+}
+
+// checkHeroPlacement verifies the staircase and hero landed on valid,
+// unoccupied cells.
+func checkHeroPlacement(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
+
 	// The staircase is somewhere real.
 	st := g.Level.Stairs
 	if g.Level.Char(st.Y, st.X) != Stairs {
@@ -44,35 +63,53 @@ func TestNewLevelInvariants(t *testing.T) {
 		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)
 	}
+}
+
+// checkRoomsDrawn verifies rooms and floor/passages appear on the map.
+func checkRoomsDrawn(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
 
-		// 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)
 	}
+}
+
+// checkMonstersPlaced verifies every monster is indexed on the map and
+// placed in a room.
+func checkMonstersPlaced(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
 
-		// 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)
 		}
 	}
+}
+
+// checkObjectsPlaced verifies every level object sits on a cell
+// displaying its type (items can share cells only with monsters standing
+// on them).
+func checkObjectsPlaced(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
 
-		// 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.Kind.Glyph() &&
@@ -81,29 +118,37 @@ func TestNewLevelInvariants(t *testing.T) {
 				seed, obj.Kind, obj.Pos.Y, obj.Pos.X, ch)
 		}
 	}
+}
+
+// checkStartingKit verifies the player has her starting kit: food, armor,
+// mace, bow, arrows.
+func checkStartingKit(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
 
-		// 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.WeaponKind() != WeaponMace {
 		t.Errorf("seed %d: not wielding the starting mace", seed)
 	}
+
 	if g.Player.CurArmor == nil ||
 		g.Player.CurArmor.ArmorKind() != ArmorRingMail {
 		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")
@@ -114,10 +159,11 @@ func TestNewLevelDeterministic(t *testing.T) {
 // 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})
+		g := New(Params{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)

game/object.go

@@ -5,6 +5,7 @@ package game
 // category (ObjectKind) from its display character (Glyph).
 type ObjectKind int
 
+// Item categories.
 const (
 	KindNone ObjectKind = iota
 	KindPotion
@@ -25,35 +26,49 @@ const (
 	KindRingOrStick ObjectKind = -2
 )
 
-// kindGlyphs maps each kind to the character Rogue draws for it.
+// Category words shared by ObjectKind.String, the discovery list, and the
-var kindGlyphs = [...]byte{
+// ident table. (The bare identifiers Potion, Scroll, Ring, Gold are the
-	KindNone:   ' ',
+// glyph byte constants.)
-	KindPotion: Potion,
+const (
-	KindScroll: Scroll,
+	potionName = "potion"
-	KindFood:   Food,
+	scrollName = "scroll"
-	KindWeapon: Weapon,
+	ringName   = "ring"
-	KindArmor:  Armor,
+	goldName   = "gold"
-	KindRing:   Ring,
+)
-	KindWand:   Stick,
-	KindAmulet: Amulet,
-	KindGold:   Gold,
-}
 
 // Glyph returns the map/display character for this kind of object.
 func (k ObjectKind) Glyph() byte {
-	if k < 0 || int(k) >= len(kindGlyphs) {
+	switch k {
-		return ' '
+	case KindPotion:
+		return Potion
+	case KindScroll:
+		return Scroll
+	case KindFood:
+		return Food
+	case KindWeapon:
+		return Weapon
+	case KindArmor:
+		return Armor
+	case KindRing:
+		return Ring
+	case KindWand:
+		return Stick
+	case KindAmulet:
+		return Amulet
+	case KindGold:
+		return Gold
 	}
-	return kindGlyphs[k]
+
+	return ' '
 }
 
 // String names the category the way the C type_name() did.
 func (k ObjectKind) String() string {
 	switch k {
 	case KindPotion:
-		return "potion"
+		return potionName
 	case KindScroll:
-		return "scroll"
+		return scrollName
 	case KindFood:
 		return "food"
 	case KindWeapon:
@@ -61,27 +76,36 @@ func (k ObjectKind) String() string {
 	case KindArmor:
 		return "suit of armor"
 	case KindRing:
-		return "ring"
+		return ringName
-	case KindWand:
+	default:
-		return "wand or staff"
+		return k.stringRest()
-	case KindAmulet:
-		return "amulet"
-	case KindGold:
-		return "gold"
-	case KindRingOrStick:
-		return "ring, wand or staff"
 	}
-	return "bizarre thing"
 }
 
 // objectKindForGlyph is the reverse of Glyph: what category of item does a
 // map character denote. Returns KindNone for non-item characters.
 func objectKindForGlyph(ch byte) ObjectKind {
-	for k, g := range kindGlyphs {
+	switch ch {
-		if g == ch && ObjectKind(k) != KindNone {
+	case Potion:
-			return ObjectKind(k)
+		return KindPotion
-		}
+	case Scroll:
+		return KindScroll
+	case Food:
+		return KindFood
+	case Weapon:
+		return KindWeapon
+	case Armor:
+		return KindArmor
+	case Ring:
+		return KindRing
+	case Stick:
+		return KindWand
+	case Amulet:
+		return KindAmulet
+	case Gold:
+		return KindGold
 	}
+
 	return KindNone
 }
 
@@ -91,6 +115,23 @@ func (k ObjectKind) MergesInPack() bool {
 	return k == KindPotion || k == KindScroll || k == KindFood
 }
 
+// stringRest names the remaining kinds, including the ring-or-stick
+// prompt pseudo-kind (the tail of the C type_name switch).
+func (k ObjectKind) stringRest() string {
+	switch k {
+	case KindWand:
+		return "wand or staff"
+	case KindAmulet:
+		return "amulet"
+	case KindGold:
+		return goldName
+	case KindRingOrStick:
+		return "ring, wand or staff"
+	}
+
+	return "bizarre thing"
+}
+
 // Object is the _o arm of the C THING union: anything that can lie on the
 // floor or ride in a pack.
 type Object struct {
@@ -148,6 +189,7 @@ func detachObj(list *[]*Object, item *Object) {
 	for i, o := range *list {
 		if o == item {
 			*list = append((*list)[:i], (*list)[i+1:]...)
+
 			return
 		}
 	}

game/options.go

@@ -28,6 +28,7 @@ type optDesc struct {
 // optList builds the options.c optlist for this game.
 func (g *RogueGame) optList() []optDesc {
 	o := &g.Options
+
 	return []optDesc{
 		{"terse", "Terse output", optBool, &o.Terse, nil, nil},
 		{"flush", "Flush typeahead during battle", optBool, &o.FightFlush, nil, nil},
@@ -46,6 +47,7 @@ func (g *RogueGame) optList() []optDesc {
 func (g *RogueGame) option() {
 	hw := g.scr.Hw
 	optlist := g.optList()
+
 	hw.Clear()
 	// Display current values of options
 	for i := range optlist {
@@ -56,9 +58,11 @@ func (g *RogueGame) option() {
 	}
 	// Set values
 	hw.Move(0, 0)
+
 	for i := 0; i < len(optlist); i++ {
 		op := &optlist[i]
 		g.prOptname(op)
+
 		retval := g.getOpt(op)
 		if retval != Norm {
 			if retval == Quit {
@@ -70,6 +74,7 @@ func (g *RogueGame) option() {
 				i -= 2
 			} else { // trying to back up beyond the top
 				hw.Move(0, 0)
+
 				i--
 			}
 		}
@@ -84,18 +89,19 @@ func (g *RogueGame) option() {
 
 // prOptname prints out the option name prompt (options.c pr_optname).
 func (g *RogueGame) prOptname(op *optDesc) {
-	g.scr.Hw.Printw("%s (\"%s\"): ", op.prompt, op.name)
+	g.scr.Hw.Printwf("%s (\"%s\"): ", op.prompt, op.name)
 }
 
 // putOpt prints an option's current value (options.c put_bool/put_str/
 // put_inv_t).
 func (g *RogueGame) putOpt(op *optDesc) {
 	hw := g.scr.Hw
+
 	switch op.kind {
 	case optBool, optSeeFloor:
 		hw.AddStr(boolStr(*op.boolP))
 	case optInvT:
-		hw.AddStr(invTName[*op.intP])
+		hw.AddStr(g.data.invTName[*op.intP])
 	case optStr:
 		hw.AddStr(*op.strP)
 	}
@@ -105,6 +111,7 @@ func boolStr(b bool) string {
 	if b {
 		return "True"
 	}
+
 	return "False"
 }
 
@@ -129,9 +136,11 @@ func (g *RogueGame) getBool(bp *bool) int {
 	win := g.scr.Hw
 	oy, ox := win.GetYX()
 	win.AddStr(boolStr(*bp))
+
 	for {
 		win.Move(oy, ox)
 		g.scr.RefreshWin(win)
+
 		switch g.readchar() {
 		case 't', 'T':
 			*bp = true
@@ -145,13 +154,17 @@ func (g *RogueGame) getBool(bp *bool) int {
 		default:
 			win.Move(oy, ox+10)
 			win.AddStr("(T or F)")
+
 			continue
 		}
+
 		break
 	}
+
 	win.Move(oy, ox)
 	win.AddStr(boolStr(*bp))
 	win.AddCh('\n')
+
 	return Norm
 }
 
@@ -159,10 +172,12 @@ func (g *RogueGame) getBool(bp *bool) int {
 // get_sf).
 func (g *RogueGame) getSf(bp *bool) int {
 	wasSf := g.Options.SeeFloor
+
 	retval := g.getBool(bp)
 	if retval == Quit {
 		return Quit
 	}
+
 	if wasSf != g.Options.SeeFloor {
 		if !g.Options.SeeFloor {
 			g.Options.SeeFloor = true
@@ -172,6 +187,7 @@ func (g *RogueGame) getSf(bp *bool) int {
 			g.look(false)
 		}
 	}
+
 	return Norm
 }
 
@@ -183,57 +199,36 @@ func (g *RogueGame) getStr(opt *string, win *Window) int {
 	oy, ox := win.GetYX()
 	g.scr.RefreshWin(win)
 	// loop reading in the string, and put it in a temporary buffer
-	var buf []byte
+	var (
-	var c byte
+		buf []byte
+		c   byte
+	)
 	for {
 		c = g.readchar()
-		if c == '\n' || c == '\r' || c == Escape {
+		if endsInput(c) || (len(buf) == 0 && c == '-' && !onStd) {
 			break
 		}
-		if c == 8 || c == 0x7f { // erase character
+
-			if len(buf) > 0 {
+		buf = g.getStrEdit(win, buf, c, oy, ox)
-				buf = buf[:len(buf)-1]
-				win.Move(oy, ox+len(displayStr(buf)))
-			}
-			win.Clrtoeol()
-			g.scr.RefreshWin(win)
-			continue
-		}
-		if c == CTRL('U') { // kill character
-			buf = buf[:0]
-			win.Move(oy, ox)
-			win.Clrtoeol()
-			g.scr.RefreshWin(win)
-			continue
-		}
-		if len(buf) == 0 {
-			if c == '-' && !onStd {
-				break
-			}
-			if c == '~' {
-				buf = append(buf, g.Home...)
-				win.AddStr(g.Home)
-				win.Clrtoeol()
-				g.scr.RefreshWin(win)
-				continue
-			}
-		}
-		if len(buf) >= MaxInp || !(isPrint(c) || c == ' ') {
-			continue // C beeps here
-		}
-		buf = append(buf, c)
-		win.AddStr(unctrl(c))
-		win.Clrtoeol()
-		g.scr.RefreshWin(win)
 	}
+
 	if len(buf) > 0 { // only change option if something has been typed
 		*opt = strucpy(string(buf))
 	}
-	win.MvPrintw(oy, ox, "%s\n", *opt)
+
+	win.MvPrintwf(oy, ox, "%s\n", *opt)
 	g.scr.RefreshWin(win)
+
 	if onStd {
 		g.Msgs.Mpos += len(buf)
 	}
+
+	return getStrResult(c)
+}
+
+// getStrResult maps the terminating key to the C return code (options.c
+// get_str).
+func getStrResult(c byte) int {
 	switch c {
 	case '-':
 		return Minus
@@ -244,12 +239,59 @@ func (g *RogueGame) getStr(opt *string, win *Window) int {
 	}
 }
 
+// endsInput reports the keys that finish line input (options.c get_str).
+func endsInput(c byte) bool {
+	return c == '\n' || c == '\r' || c == Escape
+}
+
+// getStrErase deletes the last character of the buffer (options.c
+// get_str).
+func getStrErase(win *Window, buf []byte, oy, ox int) []byte {
+	if len(buf) > 0 {
+		buf = buf[:len(buf)-1]
+		win.Move(oy, ox+len(displayStr(buf)))
+	}
+
+	win.Clrtoeol()
+
+	return buf
+}
+
+// getStrEdit applies one key to the line editor's buffer: erase, kill,
+// home expansion, or a typed character (options.c get_str).
+func (g *RogueGame) getStrEdit(win *Window, buf []byte, c byte, oy, ox int) []byte {
+	switch {
+	case c == 8 || c == 0x7f:
+		buf = getStrErase(win, buf, oy, ox)
+	case c == CTRL('U'): // kill character
+		buf = buf[:0]
+
+		win.Move(oy, ox)
+		win.Clrtoeol()
+	case len(buf) == 0 && c == '~':
+		buf = append(buf, g.Home...)
+		win.AddStr(g.Home)
+		win.Clrtoeol()
+	case len(buf) >= MaxInp || (!isPrint(c) && c != ' '):
+		return buf // C beeps here
+	default:
+		buf = append(buf, c)
+		win.AddStr(unctrl(c))
+		win.Clrtoeol()
+	}
+
+	g.scr.RefreshWin(win)
+
+	return buf
+}
+
 // displayStr renders a buffer the way the input echo did.
 func displayStr(buf []byte) string {
 	var sb strings.Builder
 	for _, c := range buf {
 		sb.WriteString(unctrl(c))
 	}
+
 	return sb.String()
 }
 
@@ -257,10 +299,12 @@ func displayStr(buf []byte) string {
 func (g *RogueGame) getInvT(ip *int) int {
 	win := g.scr.Hw
 	oy, ox := win.GetYX()
-	win.AddStr(invTName[*ip])
+	win.AddStr(g.data.invTName[*ip])
+
 	for {
 		win.Move(oy, ox)
 		g.scr.RefreshWin(win)
+
 		switch g.readchar() {
 		case 'o', 'O':
 			*ip = InvOver
@@ -276,11 +320,15 @@ func (g *RogueGame) getInvT(ip *int) int {
 		default:
 			win.Move(oy, ox+15)
 			win.AddStr("(O, S, or C)")
+
 			continue
 		}
+
 		break
 	}
-	win.MvPrintw(oy, ox, "%s\n", invTName[*ip])
+
+	win.MvPrintwf(oy, ox, "%s\n", g.data.invTName[*ip])
+
 	return Norm
 }
 
@@ -289,31 +337,68 @@ func (g *RogueGame) getInvT(ip *int) int {
 // "noname" (false), strings as "name=..." (options.c parse_opts).
 func (g *RogueGame) ParseOpts(str string) {
 	optlist := g.optList()
+
 	for str != "" {
 		// Get option name
 		i := 0
 		for i < len(str) && isAlpha(str[i]) {
 			i++
 		}
-		name := str[:i]
+
-		rest := str[i:]
+		rest := g.parseOptName(optlist, str[:i], str[i:])
-		matched := false
+		// skip to start of next option name
+		for rest != "" && !isAlpha(rest[0]) {
+			rest = rest[1:]
+		}
+
+		str = rest
+	}
+}
+
+// parseOptName applies one named option, returning the unconsumed
+// remainder: "name" turns a boolean on, "noname" turns it off, and
+// string options consume a value (the option scan of options.c
+// parse_opts).
+func (g *RogueGame) parseOptName(optlist []optDesc, name, rest string) string {
 	for oi := range optlist {
 		op := &optlist[oi]
+
 		isBoolOpt := op.kind == optBool || op.kind == optSeeFloor
 		if strings.HasPrefix(op.name, name) && name != "" {
-				matched = true
 			if isBoolOpt {
 				*op.boolP = true
-				} else {
+
+				return rest
+			}
+
+			return g.parseOptValue(op, rest)
+		}
+
+		if isBoolOpt && strings.HasPrefix(name, "no") &&
+			strings.HasPrefix(op.name, name[2:]) {
+			*op.boolP = false
+
+			return rest
+		}
+	}
+
+	return rest
+}
+
+// parseOptValue consumes an option's "=value" from rest, storing it,
+// and returns the remainder (the string arm of options.c parse_opts).
+func (g *RogueGame) parseOptValue(op *optDesc, rest string) string {
 	// Skip to start of string value
 	for rest != "" && rest[0] == '=' {
 		rest = rest[1:]
 	}
+
 	val := rest
+
 	var prefix string
 	if val != "" && val[0] == '~' {
 		prefix = g.Home
+
 		val = val[1:]
 		for val != "" && val[0] == '/' {
 			val = val[1:]
@@ -324,39 +409,33 @@ func (g *RogueGame) ParseOpts(str string) {
 	if end < 0 {
 		end = len(val)
 	}
+
 	word := val[:end]
-					rest = val[end:]
+
 	if op.kind == optInvT {
-						// check for type of inventory
+		g.parseInvType(op, word)
-						w := word
-						if w != "" {
-							w = string(toUpper(w[0])) + w[1:]
-						}
-						for ti, tn := range invTName {
-							if strings.HasPrefix(tn, w) {
-								*op.intP = ti
-								break
-							}
-						}
 	} else {
 		*op.strP = prefix + strucpy(word)
 	}
+
+	return val[end:]
 }
-				break
+
-			} else if isBoolOpt && strings.HasPrefix(name, "no") &&
+// parseInvType matches an inventory-style name by prefix (options.c
-				strings.HasPrefix(op.name, name[2:]) {
+// parse_opts).
-				matched = true
+func (g *RogueGame) parseInvType(op *optDesc, word string) {
-				*op.boolP = false
+	// check for type of inventory
+	if word != "" {
+		word = string(toUpper(word[0])) + word[1:]
+	}
+
+	for ti, tn := range g.data.invTName {
+		if strings.HasPrefix(tn, word) {
+			*op.intP = ti
+
 			break
 		}
 	}
-		_ = matched
-		// skip to start of next option name
-		for rest != "" && !isAlpha(rest[0]) {
-			rest = rest[1:]
-		}
-		str = rest
-	}
 }
 
 // strucpy copies a string keeping only printable characters, capped at
@@ -365,11 +444,14 @@ func strucpy(s string) string {
 	if len(s) > MaxInp {
 		s = s[:MaxInp]
 	}
+
 	var sb strings.Builder
-	for i := 0; i < len(s); i++ {
+
+	for i := range len(s) {
 		if isPrint(s[i]) || s[i] == ' ' {
 			sb.WriteByte(s[i])
 		}
 	}
+
 	return sb.String()
 }

game/pack.go

@@ -7,99 +7,24 @@ package game
 func (g *RogueGame) addPack(obj *Object, silent bool) {
 	p := &g.Player
 	fromFloor := false
+
 	if obj == nil {
-		if obj = g.findObj(p.Pos.Y, p.Pos.X); obj == nil {
+		if obj = g.Level.ObjectAt(p.Pos.Y, p.Pos.X); obj == nil {
 			return
 		}
+
 		fromFloor = true
 	}
 
 	// Check for and deal with scare monster scrolls
-	if obj.Kind == KindScroll && obj.ScrollKind() == ScrollScareMonster && obj.Flags.Has(WasFound) {
+	if g.pickupScareScroll(obj) {
-		detachObj(&g.Level.Objects, obj)
-		g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
-		if p.Room.Flags.Has(Gone) {
-			g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
-		} else {
-			g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
-		}
-		g.msg("the scroll turns to dust as you pick it up")
 		return
 	}
 
-	if len(p.Pack) == 0 {
+	obj, ok := g.packInsert(obj, fromFloor)
-		p.Pack = append(p.Pack, obj)
+	if !ok {
-		obj.PackCh = g.packChar()
-		p.Inpack++
-	} else {
-		// Walk the pack looking for the insertion point, keeping items of
-		// one type together and merging stackable/grouped items — a direct
-		// translation of the C linked-list walk. lp is the index to insert
-		// after; -1 after a merge means no insertion.
-		lp := -1
-		merged := false
-		for i := 0; i < len(p.Pack); i++ {
-			if p.Pack[i].Kind != obj.Kind {
-				lp = i
-				continue
-			}
-			// found the group of our type: scan for matching subtype
-			for p.Pack[i].Kind == obj.Kind && p.Pack[i].Which != obj.Which {
-				lp = i
-				if i+1 >= len(p.Pack) {
-					break
-				}
-				i++
-			}
-			op := p.Pack[i]
-			if op.Kind == obj.Kind && op.Which == obj.Which {
-				if op.Kind.MergesInPack() {
-					if !g.packRoom(fromFloor, obj) {
 		return
 	}
-					op.Count++
-					obj = op
-					lp = -1
-					merged = true
-				} else if obj.Group != 0 {
-					lp = i
-					for p.Pack[i].Kind == obj.Kind &&
-						p.Pack[i].Which == obj.Which &&
-						p.Pack[i].Group != obj.Group {
-						lp = i
-						if i+1 >= len(p.Pack) {
-							break
-						}
-						i++
-					}
-					op = p.Pack[i]
-					if op.Kind == obj.Kind && op.Which == obj.Which &&
-						op.Group == obj.Group {
-						op.Count += obj.Count
-						p.Inpack--
-						if !g.packRoom(fromFloor, obj) {
-							return
-						}
-						obj = op
-						lp = -1
-						merged = true
-					}
-				} else {
-					lp = i
-				}
-			}
-			break
-		}
-
-		if !merged && lp != -1 {
-			if !g.packRoom(fromFloor, obj) {
-				return
-			}
-			obj.PackCh = g.packChar()
-			p.Pack = append(p.Pack[:lp+1],
-				append([]*Object{obj}, p.Pack[lp+1:]...)...)
-		}
-	}
 
 	obj.Flags.Set(WasFound)
 
@@ -117,119 +42,260 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 	// Notify the user
 	if !silent {
 		if !g.Options.Terse {
-			g.addmsg("you now have ")
+			g.addmsgf("you now have ")
 		}
-		g.msg("%s (%c)", g.invName(obj, !g.Options.Terse), obj.PackCh)
+
+		g.msg("%s (%c)", g.inventoryName(obj, !g.Options.Terse), obj.PackCh)
 	}
 }
 
+// pickupScareScroll crumbles a found scare monster scroll when it is
+// picked up again; it reports whether it did (pack.c add_pack).
+func (g *RogueGame) pickupScareScroll(obj *Object) bool {
+	if obj.Kind != KindScroll || obj.ScrollKind() != ScrollScareMonster ||
+		!obj.Flags.Has(WasFound) {
+		return false
+	}
+
+	p := &g.Player
+
+	g.Level.RemoveObject(obj)
+	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
+
+	if p.Room.Flags.Has(Gone) {
+		g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
+	} else {
+		g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
+	}
+
+	g.msg("the scroll turns to dust as you pick it up")
+
+	return true
+}
+
+// packInsert places the object in the pack, keeping items of one type
+// together and merging stackable and grouped items — a translation of
+// the C linked-list walk in pack.c add_pack. It returns the pack entry
+// the object ended up as; ok is false when the pack has no room.
+func (g *RogueGame) packInsert(obj *Object, fromFloor bool) (*Object, bool) {
+	p := &g.Player
+	if len(p.Pack) == 0 {
+		p.Pack = append(p.Pack, obj)
+		obj.PackCh = p.nextPackChar()
+		p.Inpack++
+
+		return obj, true
+	}
+
+	merged := false
+
+	// lp is the index to insert after; -1 after a merge means no
+	// insertion.
+	i, lp := packScanKind(p.Pack, obj.Kind)
+	if i < len(p.Pack) {
+		i, lp = packScanWhich(p.Pack, obj, i, lp)
+
+		if op := p.Pack[i]; op.Kind == obj.Kind && op.Which == obj.Which {
+			var ok bool
+
+			obj, lp, merged, ok = g.packMatch(obj, op, i, fromFloor)
+			if !ok {
+				return nil, false
+			}
+		}
+	}
+
+	if !merged && lp != -1 {
+		if !g.packRoom(fromFloor, obj) {
+			return nil, false
+		}
+
+		obj.PackCh = p.nextPackChar()
+		p.Pack = append(p.Pack[:lp+1],
+			append([]*Object{obj}, p.Pack[lp+1:]...)...)
+	}
+
+	return obj, true
+}
+
+// packScanKind scans to the first pack entry of this kind, returning
+// its index (or the pack length) and the entry to insert after (the
+// outer scan of pack.c add_pack).
+func packScanKind(pack []*Object, kind ObjectKind) (int, int) {
+	lp := -1
+
+	i := 0
+	for ; i < len(pack); i++ {
+		if pack[i].Kind == kind {
+			break
+		}
+
+		lp = i
+	}
+
+	return i, lp
+}
+
+// packScanWhich scans within the kind group for the matching subtype
+// (the inner scan of pack.c add_pack).
+func packScanWhich(pack []*Object, obj *Object, i, lp int) (int, int) {
+	for pack[i].Kind == obj.Kind && pack[i].Which != obj.Which {
+		lp = i
+		if i+1 >= len(pack) {
+			break
+		}
+
+		i++
+	}
+
+	return i, lp
+}
+
+// packMatch merges the object with a matching pack entry when possible:
+// stackables merge counts, grouped missiles rejoin their bundle, and
+// anything else marks the insertion point (the matched-subtype switch
+// of pack.c add_pack). It returns the resulting entry, the insert-after
+// index, whether a merge happened, and ok false when the pack is full.
+func (g *RogueGame) packMatch(obj, op *Object, i int, fromFloor bool) (*Object, int, bool, bool) {
+	switch {
+	case op.Kind.MergesInPack():
+		if !g.packRoom(fromFloor, obj) {
+			return nil, 0, false, false
+		}
+
+		op.Count++
+
+		return op, -1, true, true
+	case obj.Group != 0:
+		return g.packMatchGroup(obj, i, fromFloor)
+	default:
+		return obj, i, false, true
+	}
+}
+
+// packMatchGroup rejoins a grouped missile bundle with its group entry
+// (the o_group arm of pack.c add_pack).
+func (g *RogueGame) packMatchGroup(obj *Object, i int, fromFloor bool) (*Object, int, bool, bool) {
+	p := &g.Player
+
+	lp := i
+	for p.Pack[i].Kind == obj.Kind &&
+		p.Pack[i].Which == obj.Which &&
+		p.Pack[i].Group != obj.Group {
+		lp = i
+		if i+1 >= len(p.Pack) {
+			break
+		}
+
+		i++
+	}
+
+	op := p.Pack[i]
+	if op.Kind == obj.Kind && op.Which == obj.Which &&
+		op.Group == obj.Group {
+		op.Count += obj.Count
+		p.Inpack--
+
+		if !g.packRoom(fromFloor, obj) {
+			return nil, 0, false, false
+		}
+
+		return op, -1, true, true
+	}
+
+	return obj, lp, false, true
+}
+
 // packRoom sees if there's room in the pack; if not, prints an appropriate
 // message (pack.c pack_room).
 func (g *RogueGame) packRoom(fromFloor bool, obj *Object) bool {
 	p := &g.Player
 	if p.Inpack++; p.Inpack > MaxPack {
 		if !g.Options.Terse {
-			g.addmsg("there's ")
+			g.addmsgf("there's ")
 		}
-		g.addmsg("no room")
+
+		g.addmsgf("no room")
+
 		if !g.Options.Terse {
-			g.addmsg(" in your pack")
+			g.addmsgf(" in your pack")
 		}
+
 		g.endmsg()
+
 		if fromFloor {
 			g.moveMsg(obj)
 		}
+
 		p.Inpack = MaxPack
+
 		return false
 	}
 
 	if fromFloor {
-		detachObj(&g.Level.Objects, obj)
+		g.Level.RemoveObject(obj)
 		g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
+
 		if p.Room.Flags.Has(Gone) {
 			g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
 		} else {
 			g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
 		}
 	}
+
 	return true
 }
 
-// leavePack takes an item out of the pack (pack.c leave_pack).
+// leavePack takes an item out of the pack (pack.c leave_pack), keeping
+// the repeat-command bookkeeping; the pack surgery is
+// Player.removeFromPack.
 func (g *RogueGame) leavePack(obj *Object, newobj, all bool) *Object {
-	p := &g.Player
-	p.Inpack--
-	nobj := obj
 	if obj.Count > 1 && !all {
 		g.LastPick = obj
-		obj.Count--
-		if obj.Group != 0 {
-			p.Inpack++
-		}
-		if newobj {
-			copied := *obj
-			nobj = &copied
-			nobj.Count = 1
-		}
 	} else {
 		g.LastPick = nil
-		p.PackUsed[obj.PackCh-'a'] = false
-		detachObj(&p.Pack, obj)
-	}
-	return nobj
 	}
 
-// packChar returns the next unused pack character (pack.c pack_char).
+	return g.Player.removeFromPack(obj, newobj, all)
-func (g *RogueGame) packChar() byte {
-	p := &g.Player
-	for i := range p.PackUsed {
-		if !p.PackUsed[i] {
-			p.PackUsed[i] = true
-			return byte(i) + 'a'
-		}
-	}
-	return byte(len(p.PackUsed)) + 'a' // C would walk off the array here
 }
 
 // inventory lists what is in the pack; returns true if there is something
 // of the given type (pack.c inventory).
 func (g *RogueGame) inventory(list []*Object, kind ObjectKind) bool {
 	g.NObjs = 0
+
 	for _, item := range list {
-		if kind != KindNone && kind != item.Kind &&
+		if !matchesFilter(kind, item) {
-			!(kind == KindCallable && item.Kind != KindFood &&
-				item.Kind != KindAmulet) &&
-			!(kind == KindRingOrStick &&
-				(item.Kind == KindRing || item.Kind == KindWand)) {
 			continue
 		}
+
 		g.NObjs++
 		g.Msgs.MsgEsc = true
-		line := string(item.PackCh) + ") " + g.invName(item, false)
+
+		line := string(item.PackCh) + ") " + g.inventoryName(item, false)
 		if g.addLine("%s", line) == Escape {
 			g.Msgs.MsgEsc = false
 			g.msg("")
+
 			return true
 		}
+
 		g.Msgs.MsgEsc = false
 	}
+
 	if g.NObjs == 0 {
-		if g.Options.Terse {
 		if kind == KindNone {
-				g.msg("empty handed")
+			g.msg("%s", g.chooseTerse("empty handed", "you are empty handed"))
 		} else {
-				g.msg("nothing appropriate")
+			g.msg("%s", g.chooseTerse("nothing appropriate",
-			}
+				"you don't have anything appropriate"))
-		} else {
-			if kind == KindNone {
-				g.msg("you are empty handed")
-			} else {
-				g.msg("you don't have anything appropriate")
-			}
 		}
+
 		return false
 	}
+
 	g.endLine()
+
 	return true
 }
 
@@ -240,31 +306,53 @@ func (g *RogueGame) pickUp(ch byte) {
 		return
 	}
 
-	obj := g.findObj(p.Pos.Y, p.Pos.X)
+	obj := g.Level.ObjectAt(p.Pos.Y, p.Pos.X)
 	if g.MoveOn {
 		g.moveMsg(obj)
+
 		return
 	}
+
 	switch ch {
 	case Gold:
 		if obj == nil {
 			return
 		}
+
 		g.money(obj.GoldValue)
-		detachObj(&g.Level.Objects, obj)
+		g.Level.RemoveObject(obj)
+
 		p.Room.GoldVal = 0
 	default:
 		g.addPack(nil, false)
 	}
 }
 
+// matchesFilter reports whether an item passes a get_item/inventory kind
+// filter (the C condition in pack.c inventory, untangled): KindNone takes
+// everything, KindCallable takes anything nameable (not food, not the
+// amulet), KindRingOrStick takes rings and wands.
+func matchesFilter(kind ObjectKind, item *Object) bool {
+	switch kind {
+	case KindNone:
+		return true
+	case KindCallable:
+		return item.Kind != KindFood && item.Kind != KindAmulet
+	case KindRingOrStick:
+		return item.Kind == KindRing || item.Kind == KindWand
+	default:
+		return item.Kind == kind
+	}
+}
+
 // moveMsg prints the message if you are just moving onto an object
 // (pack.c move_msg).
 func (g *RogueGame) moveMsg(obj *Object) {
 	if !g.Options.Terse {
-		g.addmsg("you ")
+		g.addmsgf("you ")
 	}
-	g.msg("moved onto %s", g.invName(obj, true))
+
+	g.msg("moved onto %s", g.inventoryName(obj, true))
 }
 
 // pickyInven allows the player to inventory a single item (pack.c
@@ -273,51 +361,55 @@ func (g *RogueGame) pickyInven() {
 	p := &g.Player
 	if len(p.Pack) == 0 {
 		g.msg("you aren't carrying anything")
+
 		return
 	}
+
 	if len(p.Pack) == 1 {
-		g.msg("a) %s", g.invName(p.Pack[0], false))
+		g.msg("a) %s", g.inventoryName(p.Pack[0], false))
+
 		return
 	}
+
 	g.msg("%s", g.chooseTerse("item: ", "which item do you wish to inventory: "))
 	g.Msgs.Mpos = 0
+
 	mch := g.readchar()
 	if mch == Escape {
 		g.msg("")
+
 		return
 	}
+
 	for _, obj := range p.Pack {
 		if mch == obj.PackCh {
-			g.msg("%c) %s", mch, g.invName(obj, false))
+			g.msg("%c) %s", mch, g.inventoryName(obj, false))
+
 			return
 		}
 	}
+
 	g.msg("'%s' not in pack", unctrl(mch))
 }
 
-// getItem picks something out of a pack for a purpose (pack.c get_item).
+// promptPackItem picks something out of a pack for a purpose (pack.c
-func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
+// get_item); the second result reports whether the player chose an
+// item.
+func (g *RogueGame) promptPackItem(purpose string, kind ObjectKind) (*Object, bool) {
 	p := &g.Player
 	if len(p.Pack) == 0 {
 		g.msg("you aren't carrying anything")
-		return nil
+
+		return nil, false
 	}
+
 	if g.Again {
-		if g.LastPick != nil {
+		return g.repeatLastItem()
-			return g.LastPick
-		}
-		g.msg("you ran out")
-		return nil
 	}
+
 	for {
-		if !g.Options.Terse {
+		g.promptItemPurpose(purpose)
-			g.addmsg("which object do you want to ")
+
-		}
-		g.addmsg("%s", purpose)
-		if g.Options.Terse {
-			g.addmsg(" what")
-		}
-		g.msg("? (* for list): ")
 		ch := g.readchar()
 		g.Msgs.Mpos = 0
 		// Give the poor player a chance to abort the command
@@ -325,40 +417,77 @@ func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
 			g.resetLast()
 			g.After = false
 			g.msg("")
-			return nil
+
+			return nil, false
 		}
+
 		g.NObjs = 1 // normal case: person types one char
 		if ch == '*' {
 			g.Msgs.Mpos = 0
 			if !g.inventory(p.Pack, kind) {
 				g.After = false
-				return nil
+
+				return nil, false
 			}
+
 			continue
 		}
+
 		for _, obj := range p.Pack {
 			if obj.PackCh == ch {
-				return obj
+				return obj, true
 			}
 		}
+
 		g.msg("'%s' is not a valid item", unctrl(ch))
 	}
 }
 
+// repeatLastItem replays the previous selection for the repeat command
+// (pack.c get_item).
+func (g *RogueGame) repeatLastItem() (*Object, bool) {
+	if g.LastPick != nil {
+		return g.LastPick, true
+	}
+
+	g.msg("you ran out")
+
+	return nil, false
+}
+
+// promptItemPurpose prints the "which object do you want to ...?"
+// prompt (pack.c get_item).
+func (g *RogueGame) promptItemPurpose(purpose string) {
+	if !g.Options.Terse {
+		g.addmsgf("which object do you want to ")
+	}
+
+	g.addmsgf("%s", purpose)
+
+	if g.Options.Terse {
+		g.addmsgf(" what")
+	}
+
+	g.msg("? (* for list): ")
+}
+
 // money adds or subtracts gold from the pack (pack.c money).
 func (g *RogueGame) money(value int) {
 	p := &g.Player
 	p.Purse += value
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
+
 	if p.Room.Flags.Has(Gone) {
 		g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
 	} else {
 		g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
 	}
+
 	if value > 0 {
 		if !g.Options.Terse {
-			g.addmsg("you found ")
+			g.addmsgf("you found ")
 		}
+
 		g.msg("%d gold pieces", value)
 	}
 }
@@ -369,9 +498,11 @@ func (g *RogueGame) floorCh() byte {
 	if g.Player.Room.Flags.Has(Gone) {
 		return Passage
 	}
+
 	if g.showFloor() {
 		return Floor
 	}
+
 	return ' '
 }
 
@@ -382,6 +513,7 @@ func (g *RogueGame) floorAt() byte {
 	if ch == Floor {
 		ch = g.floorCh()
 	}
+
 	return ch
 }
 
@@ -398,5 +530,6 @@ func (g *RogueGame) chooseTerse(terse, verbose string) string {
 	if g.Options.Terse {
 		return terse
 	}
+
 	return verbose
 }

game/passages.go

@@ -2,221 +2,269 @@ package game
 
 // passages.c — draw the connecting passages.
 
-// rdesConn is the hardcoded 3x3 room adjacency matrix from do_passages.
+// digPassages draws all the passages on a level (passages.c do_passages).
-var rdesConn = [MaxRooms][MaxRooms]bool{
+func (g *RogueGame) digPassages() {
-	{false, true, false, true, false, false, false, false, false},
+	var (
-	{true, false, true, false, true, false, false, false, false},
+		isconn  [MaxRooms][MaxRooms]bool
-	{false, true, false, false, false, true, false, false, false},
+		ingraph [MaxRooms]bool
-	{true, false, false, false, true, false, true, false, false},
+	)
-	{false, true, false, true, false, true, false, true, false},
-	{false, false, true, false, true, false, false, false, true},
-	{false, false, false, true, false, false, false, true, false},
-	{false, false, false, false, true, false, true, false, true},
-	{false, false, false, false, false, true, false, true, false},
-}
-
-// doPassages draws all the passages on a level (passages.c do_passages).
-func (g *RogueGame) doPassages() {
-	var isconn [MaxRooms][MaxRooms]bool
-	var ingraph [MaxRooms]bool
 
 	// starting with one room, connect it to a random adjacent room and
 	// then pick a new room to start with.
 	roomcount := 1
 	r1 := g.rnd(MaxRooms)
 	ingraph[r1] = true
-	for {
+
+	for roomcount < MaxRooms {
 		// find a room to connect with
-		j := 0
+		r2 := g.pickNeighbor(r1, func(i int) bool { return !ingraph[i] })
-		r2 := -1
+		if r2 < 0 {
-		for i := 0; i < MaxRooms; i++ {
+			// if no adjacent rooms are outside the graph, pick a new
-			if rdesConn[r1][i] && !ingraph[i] {
+			// room to look from
-				if j++; g.rnd(j) == 0 {
-					r2 = i
-				}
-			}
-		}
-		if j == 0 {
-			// if no adjacent rooms are outside the graph, pick a new room
-			// to look from
 			for {
 				r1 = g.rnd(MaxRooms)
 				if ingraph[r1] {
 					break
 				}
 			}
-		} else {
+
+			continue
+		}
 		// otherwise, connect new room to the graph, and draw a tunnel
 		// to it
 		ingraph[r2] = true
-			g.conn(r1, r2)
+		g.connectRooms(r1, r2)
 		isconn[r1][r2] = true
 		isconn[r2][r1] = true
 		roomcount++
 	}
-		if roomcount >= MaxRooms {
-			break
-		}
-	}
 
 	// attempt to add passages to the graph a random number of times so that
 	// there isn't always just one unique passage through it.
 	for roomcount = g.rnd(5); roomcount > 0; roomcount-- {
 		r1 = g.rnd(MaxRooms) // a random room to look from
-		// find an adjacent room not already connected
+		// find an adjacent room not already connected; if there is one,
+		// connect it and look for the next added passage
+		r2 := g.pickNeighbor(r1, func(i int) bool { return !isconn[r1][i] })
+		if r2 >= 0 {
+			g.connectRooms(r1, r2)
+			isconn[r1][r2] = true
+			isconn[r2][r1] = true
+		}
+	}
+
+	g.numberPassages()
+}
+
+// pickNeighbor reservoir-picks an adjacent room for which ok holds, or
+// -1 when there is none (passages.c do_passages).
+func (g *RogueGame) pickNeighbor(r1 int, ok func(int) bool) int {
 	j := 0
 	r2 := -1
-		for i := 0; i < MaxRooms; i++ {
+
-			if rdesConn[r1][i] && !isconn[r1][i] {
+	for i := range MaxRooms {
+		if g.data.rdesConn[r1][i] && ok(i) {
 			if j++; g.rnd(j) == 0 {
 				r2 = i
 			}
 		}
 	}
-		// if there is one, connect it and look for the next added passage
+
-		if j != 0 {
+	return r2
-			g.conn(r1, r2)
-			isconn[r1][r2] = true
-			isconn[r2][r1] = true
-		}
-	}
-	g.passnum()
 }
 
-// conn draws a corridor from a room in a certain direction (passages.c
+// corridorPlan is the movement setup connectRooms computes before it
-// conn).
+// digs (the local variables of passages.c conn).
-func (g *RogueGame) conn(r1, r2 int) {
+type corridorPlan struct {
-	var rm int
+	rpf, rpt               *Room // the rooms being joined
-	var direc byte
+	del                    Coord // direction of move
-	if r1 < r2 {
+	turnDelta              Coord // direction to turn
-		rm = r1
+	spos, epos             Coord // start and end of move
-		if r1+1 == r2 {
+	distance, turnDistance int   // how far to move and to turn
-			direc = 'r'
-		} else {
-			direc = 'd'
 }
-	} else {
-		rm = r2
-		if r2+1 == r1 {
-			direc = 'r'
-		} else {
-			direc = 'd'
-		}
-	}
-	rpf := &g.Level.Rooms[rm]
 
-	// Set up the movement variables, in two cases: first drawing one down.
+// connectRooms draws a corridor from a room in a certain direction
-	var rpt *Room
+// (passages.c conn).
-	var del, turnDelta, spos, epos Coord
+func (g *RogueGame) connectRooms(r1, r2 int) {
-	var distance, turnDistance int
+	rm, direc := connOrient(r1, r2)
+
+	var plan corridorPlan
 	if direc == 'd' {
-		rmt := rm + 3             // room # of dest
+		plan = g.connPlanDown(rm)
-		rpt = &g.Level.Rooms[rmt] // room pointer of dest
-		del = Coord{X: 0, Y: 1}   // direction of move
-		spos = rpf.Pos            // start of move
-		epos = rpt.Pos            // end of move
-		if !rpf.Flags.Has(Gone) { // if not gone pick door pos
-			for {
-				spos.X = rpf.Pos.X + g.rnd(rpf.Max.X-2) + 1
-				spos.Y = rpf.Pos.Y + rpf.Max.Y - 1
-				if !(rpf.Flags.Has(Maze) && !g.Level.FlagsAt(spos.Y, spos.X).Has(FPassage)) {
-					break
-				}
-			}
-		}
-		if !rpt.Flags.Has(Gone) {
-			for {
-				epos.X = rpt.Pos.X + g.rnd(rpt.Max.X-2) + 1
-				if !(rpt.Flags.Has(Maze) && !g.Level.FlagsAt(epos.Y, epos.X).Has(FPassage)) {
-					break
-				}
-			}
-		}
-		distance = abs(spos.Y-epos.Y) - 1 // distance to move
-		turnDelta.Y = 0                   // direction to turn
-		if spos.X < epos.X {
-			turnDelta.X = 1
 	} else {
-			turnDelta.X = -1
+		plan = g.connPlanRight(rm)
-		}
-		turnDistance = abs(spos.X - epos.X) // how far to turn
-	} else { // setup for moving right
-		rmt := rm + 1
-		rpt = &g.Level.Rooms[rmt]
-		del = Coord{X: 1, Y: 0}
-		spos = rpf.Pos
-		epos = rpt.Pos
-		if !rpf.Flags.Has(Gone) {
-			for {
-				spos.X = rpf.Pos.X + rpf.Max.X - 1
-				spos.Y = rpf.Pos.Y + g.rnd(rpf.Max.Y-2) + 1
-				if !(rpf.Flags.Has(Maze) && !g.Level.FlagsAt(spos.Y, spos.X).Has(FPassage)) {
-					break
-				}
-			}
-		}
-		if !rpt.Flags.Has(Gone) {
-			for {
-				epos.Y = rpt.Pos.Y + g.rnd(rpt.Max.Y-2) + 1
-				if !(rpt.Flags.Has(Maze) && !g.Level.FlagsAt(epos.Y, epos.X).Has(FPassage)) {
-					break
-				}
-			}
-		}
-		distance = abs(spos.X-epos.X) - 1
-		if spos.Y < epos.Y {
-			turnDelta.Y = 1
-		} else {
-			turnDelta.Y = -1
-		}
-		turnDelta.X = 0
-		turnDistance = abs(spos.Y - epos.Y)
 	}
 
-	turnSpot := g.rnd(distance-1) + 1 // where turn starts
+	turnSpot := g.rnd(plan.distance-1) + 1 // where turn starts
 
 	// Draw in the doors on either side of the passage or just put #'s if
 	// the rooms are gone.
-	if !rpf.Flags.Has(Gone) {
+	g.connEnd(plan.rpf, plan.spos)
-		g.door(rpf, spos)
+	g.connEnd(plan.rpt, plan.epos)
-	} else {
+
-		g.putpass(spos)
+	g.digCorridor(plan, turnSpot)
 }
+
+// connOrient picks the upper-left room of the pair and the digging
+// direction: right for horizontal neighbors, down otherwise (passages.c
+// conn).
+func connOrient(r1, r2 int) (int, byte) {
+	rm := min(r1, r2)
+	if abs(r1-r2) == 1 {
+		return rm, 'r'
+	}
+
+	return rm, 'd'
+}
+
+// connPlanDown sets up the movement variables for a corridor drawn
+// downward (passages.c conn).
+func (g *RogueGame) connPlanDown(rm int) corridorPlan {
+	rpf := &g.Level.Rooms[rm]
+	rpt := &g.Level.Rooms[rm+3] // room pointer of dest
+
+	plan := corridorPlan{
+		rpf:  rpf,
+		rpt:  rpt,
+		del:  Coord{X: 0, Y: 1}, // direction of move
+		spos: rpf.Pos,           // start of move
+		epos: rpt.Pos,           // end of move
+	}
+
+	if !rpf.Flags.Has(Gone) { // if not gone pick door pos
+		for {
+			plan.spos.X = rpf.Pos.X + g.rnd(rpf.Max.X-2) + 1
+
+			plan.spos.Y = rpf.Pos.Y + rpf.Max.Y - 1
+			if !rpf.Flags.Has(Maze) ||
+				g.Level.FlagsAt(plan.spos.Y, plan.spos.X).Has(FPassage) {
+				break
+			}
+		}
+	}
+
 	if !rpt.Flags.Has(Gone) {
-		g.door(rpt, epos)
+		for {
-	} else {
+			plan.epos.X = rpt.Pos.X + g.rnd(rpt.Max.X-2) + 1
-		g.putpass(epos)
+			if !rpt.Flags.Has(Maze) ||
+				g.Level.FlagsAt(plan.epos.Y, plan.epos.X).Has(FPassage) {
+				break
 			}
-	// Get ready to move...
+		}
-	curr := spos
+	}
+
+	plan.distance = abs(plan.spos.Y-plan.epos.Y) - 1 // distance to move
+
+	plan.turnDelta.Y = 0 // direction to turn
+	if plan.spos.X < plan.epos.X {
+		plan.turnDelta.X = 1
+	} else {
+		plan.turnDelta.X = -1
+	}
+
+	plan.turnDistance = abs(plan.spos.X - plan.epos.X) // how far to turn
+
+	return plan
+}
+
+// connPlanRight sets up the movement variables for a corridor drawn to
+// the right (passages.c conn).
+func (g *RogueGame) connPlanRight(rm int) corridorPlan {
+	rpf := &g.Level.Rooms[rm]
+	rpt := &g.Level.Rooms[rm+1]
+
+	plan := corridorPlan{
+		rpf:  rpf,
+		rpt:  rpt,
+		del:  Coord{X: 1, Y: 0},
+		spos: rpf.Pos,
+		epos: rpt.Pos,
+	}
+
+	if !rpf.Flags.Has(Gone) {
+		for {
+			plan.spos.X = rpf.Pos.X + rpf.Max.X - 1
+
+			plan.spos.Y = rpf.Pos.Y + g.rnd(rpf.Max.Y-2) + 1
+			if !rpf.Flags.Has(Maze) ||
+				g.Level.FlagsAt(plan.spos.Y, plan.spos.X).Has(FPassage) {
+				break
+			}
+		}
+	}
+
+	if !rpt.Flags.Has(Gone) {
+		for {
+			plan.epos.Y = rpt.Pos.Y + g.rnd(rpt.Max.Y-2) + 1
+			if !rpt.Flags.Has(Maze) ||
+				g.Level.FlagsAt(plan.epos.Y, plan.epos.X).Has(FPassage) {
+				break
+			}
+		}
+	}
+
+	plan.distance = abs(plan.spos.X-plan.epos.X) - 1
+	if plan.spos.Y < plan.epos.Y {
+		plan.turnDelta.Y = 1
+	} else {
+		plan.turnDelta.Y = -1
+	}
+
+	plan.turnDelta.X = 0
+	plan.turnDistance = abs(plan.spos.Y - plan.epos.Y)
+
+	return plan
+}
+
+// connEnd draws a corridor end: a door on a real room, a passage square
+// on a gone one (passages.c conn).
+func (g *RogueGame) connEnd(rp *Room, pos Coord) {
+	if !rp.Flags.Has(Gone) {
+		g.door(rp, pos)
+	} else {
+		g.putPassage(pos)
+	}
+}
+
+// digCorridor digs from spos to epos, turning at turnSpot (the digging
+// loop of passages.c conn).
+func (g *RogueGame) digCorridor(plan corridorPlan, turnSpot int) {
+	curr := plan.spos
+	distance := plan.distance
+	turnDistance := plan.turnDistance
+
 	for distance > 0 {
 		// Move to new position
-		curr.X += del.X
+		curr.X += plan.del.X
-		curr.Y += del.Y
+		curr.Y += plan.del.Y
 		// Check if we are at the turn place, if so do the turn
 		if distance == turnSpot {
 			for ; turnDistance > 0; turnDistance-- {
-				g.putpass(curr)
+				g.putPassage(curr)
-				curr.X += turnDelta.X
+				curr.X += plan.turnDelta.X
-				curr.Y += turnDelta.Y
+				curr.Y += plan.turnDelta.Y
 			}
 		}
 		// Continue digging along
-		g.putpass(curr)
+		g.putPassage(curr)
+
 		distance--
 	}
-	curr.X += del.X
+
-	curr.Y += del.Y
+	curr.X += plan.del.X
-	if curr != epos {
+
+	curr.Y += plan.del.Y
+	if curr != plan.epos {
 		g.msg("warning, connectivity problem on this level")
 	}
 }
 
-// putpass adds a passage character or secret passage here (passages.c
+// putPassage adds a passage character or secret passage here (passages.c
 // putpass).
-func (g *RogueGame) putpass(cp Coord) {
+func (g *RogueGame) putPassage(cp Coord) {
 	pp := g.Level.At(cp.Y, cp.X)
 	pp.Flags.Set(FPassage)
+
 	if g.rnd(10)+1 < g.Depth && g.rnd(40) == 0 {
 		pp.Flags.Clear(FReal)
 	} else {
@@ -240,6 +288,7 @@ func (g *RogueGame) door(rm *Room, cp Coord) {
 		} else {
 			pp.Ch = '|'
 		}
+
 		pp.Flags.Clear(FReal)
 	} else {
 		pp.Ch = Door
@@ -250,79 +299,100 @@ func (g *RogueGame) door(rm *Room, cp Coord) {
 // (passages.c add_pass).
 func (g *RogueGame) addPass() {
 	for y := 1; y < NumLines-1; y++ {
-		for x := 0; x < NumCols; x++ {
+		for x := range NumCols {
-			pp := g.Level.At(y, x)
+			g.addPassSpot(g.Level.At(y, x), y, x)
-			if pp.Flags.Has(FPassage) || pp.Ch == Door ||
+		}
-				(!pp.Flags.Has(FReal) && (pp.Ch == '|' || pp.Ch == '-')) {
+	}
+}
+
+// addPassSpot shows one passage or door square for the wizard (the loop
+// body of passages.c add_pass).
+func (g *RogueGame) addPassSpot(pp *Place, y, x int) {
+	if !pp.Flags.Has(FPassage) && !hiddenExit(pp.Flags, pp.Ch) {
+		return
+	}
+
 	ch := pp.Ch
 	if pp.Flags.Has(FPassage) {
 		ch = Passage
 	}
+
 	pp.Flags.Set(FSeen)
 	g.move(y, x)
-				if pp.Monst != nil {
+
+	switch {
+	case pp.Monst != nil:
 		pp.Monst.OldCh = pp.Ch
-				} else if pp.Flags.Has(FReal) {
+	case pp.Flags.Has(FReal):
 		g.addch(ch)
-				} else {
+	default:
 		g.standout()
+
 		if pp.Flags.Has(FPassage) {
 			g.addch(Passage)
 		} else {
 			g.addch(Door)
 		}
+
 		g.standend()
 	}
 }
-		}
+
-	}
+// hiddenExit reports a door, or a secret door still drawn as a wall
+// (passages.c add_pass / numpass).
+func hiddenExit(fp PlaceFlags, ch byte) bool {
+	return ch == Door || (!fp.Has(FReal) && (ch == '|' || ch == '-'))
 }
 
-// passnum assigns a number to each passageway (passages.c passnum).
+// numberPassages assigns a number to each passageway (passages.c passnum).
-func (g *RogueGame) passnum() {
+func (g *RogueGame) numberPassages() {
 	g.pnum = 0
+
 	g.newpnum = false
 	for i := range g.Level.Passages {
 		g.Level.Passages[i].Exits = g.Level.Passages[i].Exits[:0]
 	}
+
 	for i := range g.Level.Rooms {
 		rp := &g.Level.Rooms[i]
 		for j := range rp.Exits {
 			g.newpnum = true
-			g.numpass(rp.Exits[j].Y, rp.Exits[j].X)
+			g.numberPassage(rp.Exits[j].Y, rp.Exits[j].X)
 		}
 	}
 }
 
-// numpass numbers a passageway square and its brethren (passages.c
+// numberPassage numbers a passageway square and its brethren (passages.c
 // numpass).
-func (g *RogueGame) numpass(y, x int) {
+func (g *RogueGame) numberPassage(y, x int) {
 	if x >= NumCols || x < 0 || y >= NumLines || y <= 0 {
 		return
 	}
+
 	fp := g.Level.FlagsAt(y, x)
 	if fp.Has(FPassNum) {
 		return
 	}
+
 	if g.newpnum {
 		g.pnum++
 		g.newpnum = false
 	}
 	// check to see if it is a door or secret door, i.e., a new exit, or a
 	// numerable type of place
-	if ch := g.Level.Char(y, x); ch == Door ||
+	if hiddenExit(*fp, g.Level.Char(y, x)) {
-		(!fp.Has(FReal) && (ch == '|' || ch == '-')) {
 		rp := &g.Level.Passages[g.pnum]
 		rp.Exits = append(rp.Exits, Coord{Y: y, X: x})
 	} else if !fp.Has(FPassage) {
 		return
 	}
-	*fp |= PlaceFlags(g.pnum)
+
+	*fp |= PlaceFlags(g.pnum) //nolint:gosec // G115: pnum < MaxPass=13
 	// recurse on the surrounding places
-	g.numpass(y+1, x)
+	g.numberPassage(y+1, x)
-	g.numpass(y-1, x)
+	g.numberPassage(y-1, x)
-	g.numpass(y, x+1)
+	g.numberPassage(y, x+1)
-	g.numpass(y, x-1)
+	g.numberPassage(y, x-1)
 }
 
 // abs is C abs() for ints.
@@ -330,5 +400,6 @@ func abs(n int) int {
 	if n < 0 {
 		return -n
 	}
+
 	return n
 }

game/potions.go

@@ -13,99 +13,117 @@ type pact struct {
 	straight string
 }
 
-// pActions is potions.c p_actions[]. The P_SEEINVIS message is dynamic
-// (it names the fruit) and is computed in doPot.
-var pActions = [NumPotionTypes]pact{
-	PotionConfusion: {Confused, DUnconfuse, HuhDuration,
-		"what a tripy feeling!",
-		"wait, what's going on here. Huh? What? Who?"},
-	PotionLSD: {Hallucinating, DComeDown, SeeDuration,
-		"Oh, wow!  Everything seems so cosmic!",
-		"Oh, wow!  Everything seems so cosmic!"},
-	PotionSeeInvisible: {CanSeeInvisible, DUnsee, SeeDuration, "", ""},
-	PotionBlindness: {Blind, DSight, SeeDuration,
-		"oh, bummer!  Everything is dark!  Help!",
-		"a cloak of darkness falls around you"},
-	PotionLevitation: {Levitating, DLand, HealTime,
-		"oh, wow!  You're floating in the air!",
-		"you start to float in the air"},
-}
-
 // quaff drinks a potion from the pack (potions.c quaff).
 func (g *RogueGame) quaff() {
 	p := &g.Player
-	obj := g.getItem("quaff", KindPotion)
+	obj, ok := g.promptPackItem("quaff", KindPotion)
 	// Make certain that it is something that we want to drink
-	if obj == nil {
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindPotion {
 		if !g.Options.Terse {
 			g.msg("yuk! Why would you want to drink that?")
 		} else {
 			g.msg("that's undrinkable")
 		}
+
 		return
 	}
+
 	if obj == p.CurWeapon {
 		p.CurWeapon = nil
 	}
 
 	// Calculate the effect it has on the poor guy.
 	trip := p.On(Hallucinating)
+
 	g.leavePack(obj, false, false)
-	switch obj.PotionKind() {
+
-	case PotionConfusion:
+	if h := g.data.quaffHandlers[obj.PotionKind()]; h != nil {
-		g.doPot(PotionConfusion, !trip)
+		h(g, trip)
-	case PotionPoison:
+	}
+
+	g.status()
+	// Throw the item away
+	g.callIt(&g.Items.Potions[obj.Which])
+}
+
+// The per-potion effect handlers, dispatched through
+// gameData.quaffHandlers. Each is one case of the C quaff switch.
+
+func (g *RogueGame) quaffConfusion(trip bool) {
+	g.applyPotionFuse(PotionConfusion, !trip)
+}
+
+func (g *RogueGame) quaffPoison(bool) {
 	g.Items.Potions[PotionPoison].Know = true
-		if p.IsWearing(RingSustainStrength) {
+	if g.Player.IsWearing(RingSustainStrength) {
 		g.msg("you feel momentarily sick")
 	} else {
-			g.chgStr(-(g.rnd(3) + 1))
+		g.changeStrength(-(g.rnd(3) + 1))
 		g.msg("you feel very sick now")
 		g.comeDown(0)
 	}
-	case PotionHealing:
+}
+
+func (g *RogueGame) quaffHealing(bool) {
+	p := &g.Player
+
 	g.Items.Potions[PotionHealing].Know = true
 	if p.Stats.HP += g.roll(p.Stats.Lvl, 4); p.Stats.HP > p.Stats.MaxHP {
 		p.Stats.MaxHP++
 		p.Stats.HP = p.Stats.MaxHP
 	}
+
 	g.sight(0)
 	g.msg("you begin to feel better")
-	case PotionGainStrength:
+}
+
+func (g *RogueGame) quaffGainStrength(bool) {
 	g.Items.Potions[PotionGainStrength].Know = true
-		g.chgStr(1)
+	g.changeStrength(1)
 	g.msg("you feel stronger, now.  What bulging muscles!")
-	case PotionDetectMonsters:
+}
-		p.Flags.Set(SenseMonsters)
+
+func (g *RogueGame) quaffDetectMonsters(bool) {
+	g.Player.Flags.Set(SenseMonsters)
 	g.Fuse(DTurnSee, 1, HuhDuration, After)
+
 	if !g.turnSee(false) {
 		g.msg("you have a %s feeling for a moment, then it passes",
 			g.chooseStr("normal", "strange"))
 	}
-	case PotionDetectMagic:
+}
+
+func (g *RogueGame) quaffDetectMagic(bool) {
 	// Potion of magic detection.  Show the potions and scrolls
 	show := false
+
 	if len(g.Level.Objects) > 0 {
 		g.scr.Hw.Clear()
+
 		for _, tp := range g.Level.Objects {
-				if tp.isMagic() {
+			if g.isMagic(tp) {
 				show = true
+
 				g.scr.Hw.MvAddCh(tp.Pos.Y, tp.Pos.X, Magic)
 				g.Items.Potions[PotionDetectMagic].Know = true
 			}
 		}
+
 		for _, mp := range g.Level.Monsters {
 			for _, tp := range mp.Pack {
-					if tp.isMagic() {
+				if g.isMagic(tp) {
 					show = true
+
 					g.scr.Hw.MvAddCh(mp.Pos.Y, mp.Pos.X, Magic)
 				}
 			}
 		}
 	}
+
 	if show {
 		g.Items.Potions[PotionDetectMagic].Know = true
 		g.showWin("You sense the presence of magic on this level.--More--")
@@ -113,85 +131,115 @@ func (g *RogueGame) quaff() {
 		g.msg("you have a %s feeling for a moment, then it passes",
 			g.chooseStr("normal", "strange"))
 	}
-	case PotionLSD:
+}
+
+func (g *RogueGame) quaffLSD(trip bool) {
+	p := &g.Player
 	if !trip {
 		if p.On(SenseMonsters) {
 			g.turnSee(false)
 		}
+
 		g.StartDaemon(DVisuals, 0, Before)
 		g.SeenStairs = g.seenStairs()
 	}
-		g.doPot(PotionLSD, true)
+
-	case PotionSeeInvisible:
+	g.applyPotionFuse(PotionLSD, true)
-		show := p.On(CanSeeInvisible)
+}
-		g.doPot(PotionSeeInvisible, false)
+
+func (g *RogueGame) quaffSeeInvisible(bool) {
+	show := g.Player.On(CanSeeInvisible)
+
+	g.applyPotionFuse(PotionSeeInvisible, false)
+
 	if !show {
 		g.invisOn()
 	}
+
 	g.sight(0)
-	case PotionRaiseLevel:
+}
+
+func (g *RogueGame) quaffRaiseLevel(bool) {
 	g.Items.Potions[PotionRaiseLevel].Know = true
 	g.msg("you suddenly feel much more skillful")
 	g.raiseLevel()
-	case PotionExtraHealing:
+}
+
+func (g *RogueGame) quaffExtraHealing(bool) {
+	p := &g.Player
+
 	g.Items.Potions[PotionExtraHealing].Know = true
 	if p.Stats.HP += g.roll(p.Stats.Lvl, 8); p.Stats.HP > p.Stats.MaxHP {
 		if p.Stats.HP > p.Stats.MaxHP+p.Stats.Lvl+1 {
 			p.Stats.MaxHP++
 		}
+
 		p.Stats.MaxHP++
 		p.Stats.HP = p.Stats.MaxHP
 	}
+
 	g.sight(0)
 	g.comeDown(0)
 	g.msg("you begin to feel much better")
-	case PotionHaste:
+}
+
+func (g *RogueGame) quaffHaste(bool) {
 	g.Items.Potions[PotionHaste].Know = true
+
 	g.After = false
 	if g.addHaste(true) {
 		g.msg("you feel yourself moving much faster")
 	}
-	case PotionRestoreStrength:
+}
+
+func (g *RogueGame) quaffRestoreStrength(bool) {
+	p := &g.Player
 	if p.IsRing(Left, RingAddStrength) {
 		addStr(&p.Stats.Str, -p.CurRing[Left].Bonus)
 	}
+
 	if p.IsRing(Right, RingAddStrength) {
 		addStr(&p.Stats.Str, -p.CurRing[Right].Bonus)
 	}
+
 	if p.Stats.Str < p.MaxStats.Str {
 		p.Stats.Str = p.MaxStats.Str
 	}
+
 	if p.IsRing(Left, RingAddStrength) {
 		addStr(&p.Stats.Str, p.CurRing[Left].Bonus)
 	}
+
 	if p.IsRing(Right, RingAddStrength) {
 		addStr(&p.Stats.Str, p.CurRing[Right].Bonus)
 	}
+
 	g.msg("hey, this tastes great.  It make you feel warm all over")
-	case PotionBlindness:
-		g.doPot(PotionBlindness, true)
-	case PotionLevitation:
-		g.doPot(PotionLevitation, true)
 }
-	g.status()
+
-	// Throw the item away
+func (g *RogueGame) quaffBlindness(bool) {
-	g.callIt(&g.Items.Potions[obj.Which])
+	g.applyPotionFuse(PotionBlindness, true)
+}
+
+func (g *RogueGame) quaffLevitation(bool) {
+	g.applyPotionFuse(PotionLevitation, true)
 }
 
 // raiseLevel: the guy just magically went up a level (potions.c
 // raise_level).
 func (g *RogueGame) raiseLevel() {
-	g.Player.Stats.Exp = eLevels[g.Player.Stats.Lvl-1] + 1
+	g.Player.Stats.Exp = g.data.eLevels[g.Player.Stats.Lvl-1] + 1
 	g.checkLevel()
 }
 
-// doPot does a potion with standard setup: it uses a fuse and turns on a
+// applyPotionFuse does a potion with standard setup: it uses a fuse and
-// flag (potions.c do_pot).
+// turns on a flag (potions.c do_pot).
-func (g *RogueGame) doPot(kind PotionKind, knowit bool) {
+func (g *RogueGame) applyPotionFuse(kind PotionKind, knowit bool) {
-	pp := &pActions[kind]
+	pp := &g.data.pActions[kind]
 	if !g.Items.Potions[kind].Know {
 		g.Items.Potions[kind].Know = knowit
 	}
+
 	t := g.spread(pp.time)
 	if !g.Player.On(pp.flags) {
 		g.Player.Flags.Set(pp.flags)
@@ -200,24 +248,28 @@ func (g *RogueGame) doPot(kind PotionKind, knowit bool) {
 	} else {
 		g.Lengthen(pp.daemon, t)
 	}
+
 	high, straight := pp.high, pp.straight
+
 	if kind == PotionSeeInvisible {
 		s := fmt.Sprintf("this potion tastes like %s juice", g.Fruit)
 		high, straight = s, s
 	}
+
 	g.msg("%s", g.chooseStr(high, straight))
 }
 
 // isMagic reports whether an object radiates magic (potions.c is_magic).
-func (o *Object) isMagic() bool {
+func (g *RogueGame) isMagic(o *Object) bool {
 	switch o.Kind {
 	case KindArmor:
-		return o.Flags.Has(Protected) || o.ArmorClass != aClass[o.Which]
+		return o.Flags.Has(Protected) || o.ArmorClass != g.data.aClass[o.Which]
 	case KindWeapon:
 		return o.HPlus != 0 || o.DPlus != 0
 	case KindPotion, KindScroll, KindWand, KindRing, KindAmulet:
 		return true
 	}
+
 	return false
 }
 
@@ -225,6 +277,7 @@ func (o *Object) isMagic() bool {
 // invis_on).
 func (g *RogueGame) invisOn() {
 	g.Player.Flags.Set(CanSeeInvisible)
+
 	for _, mp := range g.Level.Monsters {
 		if mp.On(Invisible) && g.seeMonst(mp) && !g.Player.On(Hallucinating) {
 			g.mvaddch(mp.Pos.Y, mp.Pos.X, mp.Disguise)
@@ -236,44 +289,62 @@ func (g *RogueGame) invisOn() {
 // turn_see).
 func (g *RogueGame) turnSee(turnOff bool) bool {
 	addNew := false
+
 	for _, mp := range g.Level.Monsters {
 		g.move(mp.Pos.Y, mp.Pos.X)
+
 		canSee := g.seeMonst(mp)
 		if turnOff {
 			if !canSee {
 				g.addch(mp.OldCh)
 			}
-		} else {
+		} else if g.showSensed(mp, canSee) {
-			if !canSee {
-				g.standout()
-			}
-			if !g.Player.On(Hallucinating) {
-				g.addch(mp.Type)
-			} else {
-				g.addch(byte(g.rnd(26) + 'A'))
-			}
-			if !canSee {
-				g.standend()
 			addNew = true
 		}
 	}
-	}
+
 	if turnOff {
 		g.Player.Flags.Clear(SenseMonsters)
 	} else {
 		g.Player.Flags.Set(SenseMonsters)
 	}
+
 	return addNew
 }
 
+// showSensed draws one monster for monster sense, standout when it is
+// otherwise invisible; it reports whether the monster was newly revealed
+// (the turn-on arm of the C turn_see loop).
+func (g *RogueGame) showSensed(mp *Monster, canSee bool) bool {
+	if !canSee {
+		g.standout()
+	}
+
+	if !g.Player.On(Hallucinating) {
+		g.addch(mp.Type)
+	} else {
+		g.addch(g.randomMonsterLetter())
+	}
+
+	if !canSee {
+		g.standend()
+
+		return true
+	}
+
+	return false
+}
+
 // seenStairs reports whether the player has seen the stairs (potions.c
 // seen_stairs).
 func (g *RogueGame) seenStairs() bool {
 	st := g.Level.Stairs
 	g.move(st.Y, st.X)
+
 	if g.inch() == Stairs { // it's on the map
 		return true
 	}
+
 	if g.Player.Pos == st { // it's under him
 		return true
 	}
@@ -282,9 +353,11 @@ func (g *RogueGame) seenStairs() bool {
 		if g.seeMonst(tp) && tp.On(Awake) { // visible and awake:
 			return true // it must have moved there
 		}
+
 		if g.Player.On(SenseMonsters) && tp.OldCh == Stairs {
 			return true
 		}
 	}
+
 	return false
 }

game/rings.go

@@ -7,17 +7,16 @@ import "fmt"
 // ringOn puts a ring on a hand (rings.c ring_on).
 func (g *RogueGame) ringOn() {
 	p := &g.Player
-	obj := g.getItem("put on", KindRing)
+	obj, ok := g.promptPackItem("put on", KindRing)
 	// Make certain that it is something that we want to wear
-	if obj == nil {
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindRing {
-		if !g.Options.Terse {
+		g.msg("%s", g.chooseTerse("not a ring",
-			g.msg("it would be difficult to wrap that around a finger")
+			"it would be difficult to wrap that around a finger"))
-		} else {
+
-			g.msg("not a ring")
-		}
 		return
 	}
 
@@ -26,30 +25,17 @@ func (g *RogueGame) ringOn() {
 		return
 	}
 
-	var ring int
+	ring := g.pickRingHand()
-	switch {
+	if ring < 0 {
-	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
-		if ring = g.gethand(); ring < 0 {
-			return
-		}
-	case p.CurRing[Left] == nil:
-		ring = Left
-	case p.CurRing[Right] == nil:
-		ring = Right
-	default:
-		if !g.Options.Terse {
-			g.msg("you already have a ring on each hand")
-		} else {
-			g.msg("wearing two")
-		}
 		return
 	}
+
 	p.CurRing[ring] = obj
 
 	// Calculate the effect it has on the poor guy.
 	switch obj.RingKind() {
 	case RingAddStrength:
-		g.chgStr(obj.Bonus)
+		g.changeStrength(obj.Bonus)
 	case RingSeeInvisible:
 		g.invisOn()
 	case RingAggravateMonsters:
@@ -57,15 +43,38 @@ func (g *RogueGame) ringOn() {
 	}
 
 	if !g.Options.Terse {
-		g.addmsg("you are now wearing ")
+		g.addmsgf("you are now wearing ")
+	}
+
+	g.msg("%s (%c)", g.inventoryName(obj, true), obj.PackCh)
+}
+
+// pickRingHand chooses the hand for a new ring, asking when both are
+// free; negative aborts (rings.c ring_on).
+func (g *RogueGame) pickRingHand() int {
+	p := &g.Player
+
+	switch {
+	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
+		return g.gethand()
+	case p.CurRing[Left] == nil:
+		return Left
+	case p.CurRing[Right] == nil:
+		return Right
+	default:
+		g.msg("%s", g.chooseTerse("wearing two",
+			"you already have a ring on each hand"))
+
+		return -1
 	}
-	g.msg("%s (%c)", g.invName(obj, true), obj.PackCh)
 }
 
 // ringOff takes off a ring (rings.c ring_off).
 func (g *RogueGame) ringOff() {
 	p := &g.Player
+
 	var ring int
+
 	switch {
 	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
 		if g.Options.Terse {
@@ -73,6 +82,7 @@ func (g *RogueGame) ringOff() {
 		} else {
 			g.msg("you aren't wearing any rings")
 		}
+
 		return
 	case p.CurRing[Left] == nil:
 		ring = Right
@@ -83,14 +93,18 @@ func (g *RogueGame) ringOff() {
 			return
 		}
 	}
+
 	g.Msgs.Mpos = 0
+
 	obj := p.CurRing[ring]
 	if obj == nil {
 		g.msg("not wearing such a ring")
+
 		return
 	}
+
 	if g.dropCheck(obj) {
-		g.msg("was wearing %s(%c)", g.invName(obj, true), obj.PackCh)
+		g.msg("was wearing %s(%c)", g.inventoryName(obj, true), obj.PackCh)
 	}
 }
 
@@ -102,17 +116,22 @@ func (g *RogueGame) gethand() int {
 		} else {
 			g.msg("left hand or right hand? ")
 		}
+
 		c := g.readchar()
 		if c == Escape {
 			return -1
 		}
+
 		g.Msgs.Mpos = 0
+
 		if c == 'l' || c == 'L' {
 			return Left
 		}
+
 		if c == 'r' || c == 'R' {
 			return Right
 		}
+
 		if g.Options.Terse {
 			g.msg("L or R")
 		} else {
@@ -121,25 +140,6 @@ func (g *RogueGame) gethand() int {
 	}
 }
 
-// ringUses is the rings.c ring_eat static uses[] table: how much food each
-// ring type uses up per turn (negative = a 1-in-n chance of 1).
-var ringUses = [NumRingTypes]int{
-	1,  // R_PROTECT
-	1,  // R_ADDSTR
-	1,  // R_SUSTSTR
-	-3, // R_SEARCH
-	-5, // R_SEEINVIS
-	0,  // R_NOP
-	0,  // R_AGGR
-	-3, // R_ADDHIT
-	-3, // R_ADDDAM
-	2,  // R_REGEN
-	-2, // R_DIGEST
-	0,  // R_TELEPORT
-	1,  // R_STEALTH
-	1,  // R_SUSTARM
-}
-
 // ringEat reports how much food the ring on the given hand uses up
 // (rings.c ring_eat).
 func (g *RogueGame) ringEat(hand int) int {
@@ -147,7 +147,8 @@ func (g *RogueGame) ringEat(hand int) int {
 	if ring == nil {
 		return 0
 	}
-	eat := ringUses[ring.RingKind()]
+
+	eat := g.data.ringUses[ring.RingKind()]
 	if eat < 0 {
 		if g.rnd(-eat) == 0 {
 			eat = 1
@@ -155,20 +156,25 @@ func (g *RogueGame) ringEat(hand int) int {
 			eat = 0
 		}
 	}
+
 	if ring.RingKind() == RingSlowDigestion {
 		eat = -eat
 	}
+
 	return eat
 }
 
-// ringNum prints ring bonuses (rings.c ring_num).
+// ringNum prints ring bonuses (rings.c ring_num). The unused game
-func ringNum(g *RogueGame, obj *Object) string {
+// parameter keeps the nameit prfunc signature.
+func ringNum(_ *RogueGame, obj *Object) string {
 	if !obj.Flags.Has(Known) {
 		return ""
 	}
+
 	switch obj.RingKind() {
 	case RingProtection, RingAddStrength, RingIncreaseDamage, RingDexterity:
 		return fmt.Sprintf(" [%s]", num(obj.Bonus, 0, Ring))
 	}
+
 	return ""
 }

game/rip.go

@@ -2,76 +2,71 @@ package game
 
 import (
 	"fmt"
+	"os"
 	"time"
 )
 
 // rip.c — the fun ends: death or a total win.
 //
-// The C functions here call exit(); the port panics with a gameEnd sentinel
+// The C functions here call exit(). One game run is one process, so the
-// that Run recovers, so the terminal is restored by normal unwinding.
+// port does the same: myExit restores the terminal and exits directly.
 
-// gameEnd is the sentinel carried by the panic that replaces my_exit().
+// myExit leaves the process properly (main.c my_exit): it restores the
-type gameEnd struct{ status int }
+// terminal and ends the process. Every C caller exited with status 0.
-
+func (g *RogueGame) myExit() {
-// myExit leaves the process properly (main.c my_exit): it unwinds to Run.
+	g.scr.Fini()
-func (g *RogueGame) myExit(st int) {
+	os.Exit(0)
-	g.Playing = false
-	panic(gameEnd{status: st})
-}
-
-var ripArt = []string{
-	"                       __________",
-	"                      /          \\",
-	"                     /    REST    \\",
-	"                    /      IN      \\",
-	"                   /     PEACE      \\",
-	"                  /                  \\",
-	"                  |                  |",
-	"                  |                  |",
-	"                  |   killed by a    |",
-	"                  |                  |",
-	"                  |       1980       |",
-	"                 *|     *  *  *      | *",
-	"         ________)/\\\\_//(\\/(/\\)/\\//\\/|_)_______",
 }
 
 // death does something really fun when he dies (rip.c death).
 func (g *RogueGame) death(monst byte) {
 	p := &g.Player
 	p.Purse -= p.Purse / 10
+
 	g.clear()
+
 	killer := g.killname(monst, false)
 	if !g.Options.Tombstone {
-		g.scr.Std.MvPrintw(NumLines-2, 0, "Killed by ")
+		g.scr.Std.MvPrintwf(NumLines-2, 0, "Killed by ")
+
 		if monst != 's' && monst != 'h' {
 			g.printw("a%s ", vowelstr(killer))
 		}
+
 		g.printw("%s with %d gold", killer, p.Purse)
 	} else {
 		year := time.Now().Year()
-		for i, line := range ripArt {
+
+		for i, line := range g.data.ripArt {
 			g.scr.Std.MvAddStr(8+i, 0, line)
 		}
+
 		g.mvaddstr(17, center(killer), killer)
+
 		if monst == 's' || monst == 'h' {
 			g.mvaddch(16, 32, ' ')
 		} else {
 			g.mvaddstr(16, 33, vowelstr(killer))
 		}
+
 		g.mvaddstr(14, center(g.Whoami), g.Whoami)
+
 		au := fmt.Sprintf("%d Au", p.Purse)
 		g.mvaddstr(15, center(au), au)
 		g.mvaddstr(18, 26, fmt.Sprintf("%4d", year))
 	}
+
 	g.mvaddstr(NumLines-1, 0, "[Press return to continue]")
 	g.refresh()
+
 	flags := 0
 	if g.HasAmulet {
 		flags = 3
 	}
+
 	g.score(p.Purse, flags, monst)
 	g.waitFor('\n')
-	g.myExit(0)
+	g.myExit()
 }
 
 // center returns the column to center the given string on the tombstone
@@ -85,6 +80,7 @@ func (g *RogueGame) totalWinner() {
 	p := &g.Player
 	g.clear()
 	g.standout()
+
 	banner := []string{
 		"                                                               ",
 		"  @   @               @   @           @          @@@  @     @  ",
@@ -100,6 +96,7 @@ func (g *RogueGame) totalWinner() {
 	for i, line := range banner {
 		g.scr.Std.MvAddStr(i, 0, line)
 	}
+
 	g.standend()
 	g.scr.Std.MvAddStr(10, 0, "You have joined the elite ranks of those who have escaped the")
 	g.scr.Std.MvAddStr(11, 0, "Dungeons of Doom alive.  You journey home and sell all your loot at")
@@ -110,11 +107,31 @@ func (g *RogueGame) totalWinner() {
 	g.clear()
 	g.mvaddstr(0, 0, "   Worth  Item")
 	g.move(1, 0)
+
 	oldpurse := p.Purse
 	line := 1
+
 	for _, obj := range p.Pack {
-		worth := 0
+		worth := g.objectWorth(obj)
+
+		g.scr.Std.MvPrintwf(line, 0, "%c) %5d  %s", obj.PackCh, worth,
+			g.inventoryName(obj, false))
+		line++
+		p.Purse += worth
+	}
+
+	g.scr.Std.MvPrintwf(line, 0, "   %5d  Gold Pieces          ", oldpurse)
+	g.refresh()
+	g.score(p.Purse, 2, ' ')
+	g.myExit()
+}
+
+// objectWorth appraises one pack item on the way out, marking it known
+// (the switch of rip.c total_winner).
+func (g *RogueGame) objectWorth(obj *Object) int {
 	it := &g.Items
+	worth := 0
+
 	switch obj.Kind {
 	case KindFood:
 		worth = 2 * obj.Count
@@ -125,25 +142,46 @@ func (g *RogueGame) totalWinner() {
 	case KindArmor:
 		worth = it.Armors[obj.Which].Worth
 		worth += (9 - obj.ArmorClass) * 100
-			worth += 10 * (aClass[obj.Which] - obj.ArmorClass)
+		worth += 10 * (g.data.aClass[obj.Which] - obj.ArmorClass)
 		obj.Flags.Set(Known)
 	case KindScroll:
-			op := &it.Scrolls[obj.Which]
+		worth = loreWorth(&it.Scrolls[obj.Which], obj.Count)
-			worth = op.Worth * obj.Count
-			if !op.Know {
-				worth /= 2
-			}
-			op.Know = true
 	case KindPotion:
-			op := &it.Potions[obj.Which]
+		worth = loreWorth(&it.Potions[obj.Which], obj.Count)
-			worth = op.Worth * obj.Count
+	case KindRing:
+		worth = g.ringWorth(obj)
+	case KindWand:
+		worth = g.wandWorth(obj)
+	case KindAmulet:
+		worth = 1000
+	}
+
+	if worth < 0 {
+		worth = 0
+	}
+
+	return worth
+}
+
+// loreWorth appraises a scroll or potion, halved when unidentified, and
+// identifies it (rip.c total_winner).
+func loreWorth(op *ObjInfo, count int) int {
+	worth := op.Worth * count
 	if !op.Know {
 		worth /= 2
 	}
+
 	op.Know = true
-		case KindRing:
+
-			op := &it.Rings[obj.Which]
+	return worth
-			worth = op.Worth
+}
+
+// ringWorth appraises a ring: bonus rings gain by their bonus, cursed
+// ones are junk (rip.c total_winner).
+func (g *RogueGame) ringWorth(obj *Object) int {
+	op := &g.Items.Rings[obj.Which]
+	worth := op.Worth
+
 	if obj.RingKind() == RingAddStrength || obj.RingKind() == RingIncreaseDamage ||
 		obj.RingKind() == RingProtection || obj.RingKind() == RingDexterity {
 		if obj.Bonus > 0 {
@@ -152,85 +190,76 @@ func (g *RogueGame) totalWinner() {
 			worth = 10
 		}
 	}
+
 	if !obj.Flags.Has(Known) {
 		worth /= 2
 	}
+
 	obj.Flags.Set(Known)
+
 	op.Know = true
-		case KindWand:
+
-			op := &it.Sticks[obj.Which]
+	return worth
-			worth = op.Worth
+}
+
+// wandWorth appraises a wand or staff by its charges (rip.c
+// total_winner).
+func (g *RogueGame) wandWorth(obj *Object) int {
+	op := &g.Items.Sticks[obj.Which]
+	worth := op.Worth
+
 	worth += 20 * obj.Charges
 	if !obj.Flags.Has(Known) {
 		worth /= 2
 	}
-			obj.Flags.Set(Known)
-			op.Know = true
-		case KindAmulet:
-			worth = 1000
-		}
-		if worth < 0 {
-			worth = 0
-		}
-		g.scr.Std.MvPrintw(line, 0, "%c) %5d  %s", obj.PackCh, worth,
-			g.invName(obj, false))
-		line++
-		p.Purse += worth
-	}
-	g.scr.Std.MvPrintw(line, 0, "   %5d  Gold Pieces          ", oldpurse)
-	g.refresh()
-	g.score(p.Purse, 2, ' ')
-	g.myExit(0)
-}
 
-// killnameTable is the rip.c nlist[]: special death causes.
+	obj.Flags.Set(Known)
-var killnameTable = []helpEntry{
+
-	{'a', "arrow", true},
+	op.Know = true
-	{'b', "bolt", true},
+
-	{'d', "dart", true},
+	return worth
-	{'h', "hypothermia", false},
-	{'s', "starvation", false},
 }
 
 // killname converts a code to a monster name (rip.c killname).
 func (g *RogueGame) killname(monst byte, doart bool) string {
-	var sp string
+	var (
-	var article bool
+		sp      string
+		article bool
+	)
+
 	if isUpper(monst) {
 		sp = g.Monsters[monst-'A'].Name
 		article = true
 	} else {
 		sp = "Wally the Wonder Badger"
 		article = false
-		for _, hp := range killnameTable {
+
+		for _, hp := range g.data.killnameTable {
 			if hp.Ch == monst {
 				sp = hp.Desc
 				article = hp.Print
+
 				break
 			}
 		}
 	}
+
 	if doart && article {
 		return "a" + vowelstr(sp) + " " + sp
 	}
+
 	return sp
 }
 
 // DeathDemo implements the -d command line option (main.c): burn some
-// random numbers to break patterns, then die a random death.
+// random numbers to break patterns, then die a random death. It does not
+// return — death exits the process.
 func (g *RogueGame) DeathDemo() {
-	defer func() {
-		if r := recover(); r != nil {
-			if _, ok := r.(gameEnd); ok {
-				return
-			}
-			panic(r)
-		}
-	}()
 	dnum := g.rnd(100)
 	for dnum--; dnum > 0; dnum-- {
 		g.rnd(100)
 	}
+
 	g.Player.Purse = g.rnd(100) + 1
 	g.Depth = g.rnd(100) + 1
 	g.death(g.deathMonst())
@@ -245,5 +274,6 @@ func (g *RogueGame) deathMonst() byte {
 		'Y', 'Z', 'a', 'b', 'h', 'd', 's',
 		' ', // generates the "Wally the Wonder Badger" message
 	}
+
 	return poss[g.rnd(len(poss))]
 }

game/rng.go

@@ -11,21 +11,17 @@ type Rng struct {
 	Seed int32
 }
 
-// next steps the generator and returns the next raw value (the RN macro).
-func (r *Rng) next() int {
-	r.Seed = r.Seed*11109 + 13849
-	return int(r.Seed>>16) & 0xffff
-}
-
 // Rnd picks a very random number in [0, rng) (main.c rnd).
 func (r *Rng) Rnd(rng int) int {
 	if rng == 0 {
 		return 0
 	}
+
 	v := r.next()
 	if v < 0 {
 		v = -v
 	}
+
 	return v % rng
 }
 
@@ -35,9 +31,17 @@ func (r *Rng) Roll(number, sides int) int {
 	for ; number > 0; number-- {
 		dtotal += r.Rnd(sides) + 1
 	}
+
 	return dtotal
 }
 
+// next steps the generator and returns the next raw value (the RN macro).
+func (r *Rng) next() int {
+	r.Seed = r.Seed*11109 + 13849
+
+	return int(r.Seed>>16) & 0xffff
+}
+
 // rnd is the ported code's spelling of C rnd(): every call site in the C
 // sources reads rnd(x), and keeping that shape makes cross-checking easy.
 func (g *RogueGame) rnd(rng int) int { return g.Rng.Rnd(rng) }

game/rng_test.go

@@ -46,6 +46,7 @@ func TestRndZeroDoesNotStep(t *testing.T) {
 	if got := r.Rnd(0); got != 0 {
 		t.Fatalf("rnd(0) = %d, want 0", got)
 	}
+
 	if r.Seed != 42 {
 		t.Fatalf("rnd(0) stepped the generator: seed = %d, want 42", r.Seed)
 	}
@@ -58,6 +59,7 @@ func TestSpreadSmallValues(t *testing.T) {
 	if got := g.spread(1); got != 1 {
 		t.Errorf("spread(1) = %d, want 1", got)
 	}
+
 	if got := g.spread(2); got != 2 {
 		t.Errorf("spread(2) = %d, want 2", got)
 	}

game/rooms.go

@@ -17,10 +17,11 @@ type mazeState struct {
 
 const goldGrp = 1
 
-// doRooms creates rooms and corridors with a connectivity graph (rooms.c
+// digRooms creates rooms and corridors with a connectivity graph (rooms.c
 // do_rooms).
-func (g *RogueGame) doRooms() {
+func (g *RogueGame) digRooms() {
 	var bsze Coord // maximum room size
+
 	bsze.X = NumCols / 3
 	bsze.Y = NumLines / 3
 	// Clear things for a new level
@@ -32,76 +33,119 @@ func (g *RogueGame) doRooms() {
 	}
 	// Put the gone rooms, if any, on the level
 	leftOut := g.rnd(4)
-	for i := 0; i < leftOut; i++ {
+	for range leftOut {
-		g.Level.Rooms[g.rndRoom()].Flags.Set(Gone)
+		g.Level.Rooms[g.randomRoom()].Flags.Set(Gone)
 	}
 	// dig and populate all the rooms on the level
 	for i := range g.Level.Rooms {
+		g.digRoom(i, bsze)
+	}
+}
+
+// digRoom digs and populates one room (the loop body of rooms.c
+// do_rooms).
+func (g *RogueGame) digRoom(i int, bsze Coord) {
 	rp := &g.Level.Rooms[i]
 	// Find upper left corner of box that this room goes in
 	top := Coord{X: (i%3)*bsze.X + 1, Y: (i / 3) * bsze.Y}
+
 	if rp.Flags.Has(Gone) {
-			// Place a gone room.  Make certain that there is a blank line
+		g.placeGoneRoom(rp, top, bsze)
-			// for passage drawing.
+
-			for {
+		return
-				rp.Pos.X = top.X + g.rnd(bsze.X-2) + 1
-				rp.Pos.Y = top.Y + g.rnd(bsze.Y-2) + 1
-				rp.Max.X = -NumCols
-				rp.Max.Y = -NumLines
-				if rp.Pos.Y > 0 && rp.Pos.Y < NumLines-1 {
-					break
-				}
-			}
-			continue
 	}
 	// set room type
 	if g.rnd(10) < g.Depth-1 {
 		rp.Flags.Set(Dark) // dark room
+
 		if g.rnd(15) == 0 {
 			rp.Flags = Maze // maze room
 		}
 	}
 	// Find a place and size for a random room
 	if rp.Flags.Has(Maze) {
+		placeMazeRoom(rp, top, bsze)
+	} else {
+		g.placeNormalRoom(rp, top, bsze)
+	}
+
+	g.drawRoom(rp)
+	g.roomGold(rp)
+	g.roomMonster(rp)
+}
+
+// placeGoneRoom places a gone room, making certain that there is a
+// blank line for passage drawing (rooms.c do_rooms).
+func (g *RogueGame) placeGoneRoom(rp *Room, top, bsze Coord) {
+	for {
+		rp.Pos.X = top.X + g.rnd(bsze.X-2) + 1
+		rp.Pos.Y = top.Y + g.rnd(bsze.Y-2) + 1
+		rp.Max.X = -NumCols
+
+		rp.Max.Y = -NumLines
+		if rp.Pos.Y > 0 && rp.Pos.Y < NumLines-1 {
+			return
+		}
+	}
+}
+
+// placeMazeRoom sizes a maze room to fill its box (rooms.c do_rooms).
+func placeMazeRoom(rp *Room, top, bsze Coord) {
 	rp.Max.X = bsze.X - 1
+
 	rp.Max.Y = bsze.Y - 1
 	if rp.Pos.X = top.X; rp.Pos.X == 1 {
 		rp.Pos.X = 0
 	}
+
 	if rp.Pos.Y = top.Y; rp.Pos.Y == 0 {
 		rp.Pos.Y++
 		rp.Max.Y--
 	}
-		} else {
+}
+
+// placeNormalRoom rolls a place and size for an ordinary room (rooms.c
+// do_rooms).
+func (g *RogueGame) placeNormalRoom(rp *Room, top, bsze Coord) {
 	for {
 		rp.Max.X = g.rnd(bsze.X-4) + 4
 		rp.Max.Y = g.rnd(bsze.Y-4) + 4
 		rp.Pos.X = top.X + g.rnd(bsze.X-rp.Max.X)
+
 		rp.Pos.Y = top.Y + g.rnd(bsze.Y-rp.Max.Y)
 		if rp.Pos.Y != 0 {
-					break
+			return
 		}
 	}
 }
-		g.drawRoom(rp)
+
-		// Put the gold in
+// roomGold maybe puts a gold pile in the room (rooms.c do_rooms).
-		if g.rnd(2) == 0 && (!g.HasAmulet || g.Depth >= g.MaxDepth) {
+func (g *RogueGame) roomGold(rp *Room) {
+	if g.rnd(2) != 0 || (g.HasAmulet && g.Depth < g.MaxDepth) {
+		return
+	}
+
 	gold := newObject()
 	rp.GoldVal = g.goldCalc()
 	gold.GoldValue = rp.GoldVal
 	rp.Gold, _ = g.findFloorIn(rp, 0, false)
 	gold.Pos = rp.Gold
 	g.Level.SetChar(rp.Gold.Y, rp.Gold.X, Gold)
+
 	gold.Flags = Stackable
 	gold.Group = goldGrp
 	gold.Kind = KindGold
-			attachObj(&g.Level.Objects, gold)
+	g.Level.AddObject(gold)
 }
-		// Put the monster in
+
+// roomMonster maybe puts a monster in the room; gold attracts them
+// (rooms.c do_rooms).
+func (g *RogueGame) roomMonster(rp *Room) {
 	prob := 25
 	if rp.GoldVal > 0 {
 		prob = 80
 	}
+
 	if g.rnd(100) < prob {
 		tp := &Monster{}
 		mp, _ := g.findFloorIn(rp, 0, true)
@@ -109,15 +153,16 @@ func (g *RogueGame) doRooms() {
 		g.givePack(tp)
 	}
 }
-}
 
 // drawRoom draws a box around a room and lays down the floor for normal
 // rooms; for maze rooms, draws the maze (rooms.c draw_room).
 func (g *RogueGame) drawRoom(rp *Room) {
 	if rp.Flags.Has(Maze) {
-		g.doMaze(rp)
+		g.digMaze(rp)
+
 		return
 	}
+
 	g.vert(rp, rp.Pos.X)             // Draw left side
 	g.vert(rp, rp.Pos.X+rp.Max.X-1)  // Draw right side
 	g.horiz(rp, rp.Pos.Y)            // Draw top
@@ -145,8 +190,8 @@ func (g *RogueGame) horiz(rp *Room, starty int) {
 	}
 }
 
-// doMaze digs a maze (rooms.c do_maze).
+// digMaze digs a maze (rooms.c do_maze).
-func (g *RogueGame) doMaze(rp *Room) {
+func (g *RogueGame) digMaze(rp *Room) {
 	m := &g.maze
 	for y := range m.maze {
 		for x := range m.maze[y] {
@@ -162,65 +207,84 @@ func (g *RogueGame) doMaze(rp *Room) {
 	starty := (g.rnd(rp.Max.Y) / 2) * 2
 	startx := (g.rnd(rp.Max.X) / 2) * 2
 	pos := Coord{Y: starty + m.starty, X: startx + m.startx}
-	g.putpass(pos)
+	g.putPassage(pos)
 	g.dig(starty, startx)
 }
 
 // dig digs out from around where we are now, if possible (rooms.c dig).
 func (g *RogueGame) dig(y, x int) {
 	m := &g.maze
-	del := [4]Coord{{X: 2, Y: 0}, {X: -2, Y: 0}, {X: 0, Y: 2}, {X: 0, Y: -2}}
 
 	for {
+		nexty, nextx, ok := g.digPick(y, x)
+		if !ok {
+			return
+		}
+
+		g.accountMaze(y, x, nexty, nextx)
+		g.accountMaze(nexty, nextx, y, x)
+
+		g.putPassage(digWallGap(m, y, x, nexty, nextx))
+		g.putPassage(Coord{Y: nexty + m.starty, X: nextx + m.startx})
+		g.dig(nexty, nextx)
+	}
+}
+
+// digPick reservoir-picks the next unvisited maze cell; ok is false
+// when the digger is boxed in (the candidate scan of rooms.c dig).
+func (g *RogueGame) digPick(y, x int) (int, int, bool) {
+	m := &g.maze
+	del := [4]Coord{{X: 2, Y: 0}, {X: -2, Y: 0}, {X: 0, Y: 2}, {X: 0, Y: -2}}
+
 	cnt := 0
+
 	var nexty, nextx int
+
 	for _, cp := range del {
 		newy := y + cp.Y
+
 		newx := x + cp.X
 		if newy < 0 || newy > m.maxy || newx < 0 || newx > m.maxx {
 			continue
 		}
+
 		if g.Level.FlagsAt(newy+m.starty, newx+m.startx).Has(FPassage) {
 			continue
 		}
+
 		if cnt++; g.rnd(cnt) == 0 {
 			nexty = newy
 			nextx = newx
 		}
 	}
-		if cnt == 0 {
+
-			return
+	return nexty, nextx, cnt != 0
-		}
-		g.accntMaze(y, x, nexty, nextx)
-		g.accntMaze(nexty, nextx, y, x)
-		var pos Coord
-		if nexty == y {
-			pos.Y = y + m.starty
-			if nextx-x < 0 {
-				pos.X = nextx + m.startx + 1
-			} else {
-				pos.X = nextx + m.startx - 1
-			}
-		} else {
-			pos.X = x + m.startx
-			if nexty-y < 0 {
-				pos.Y = nexty + m.starty + 1
-			} else {
-				pos.Y = nexty + m.starty - 1
-			}
-		}
-		g.putpass(pos)
-		pos.Y = nexty + m.starty
-		pos.X = nextx + m.startx
-		g.putpass(pos)
-		g.dig(nexty, nextx)
-	}
 }
 
-// accntMaze accounts for maze exits (rooms.c accnt_maze).
+// digWallGap picks the wall square to knock out between two maze cells
-func (g *RogueGame) accntMaze(y, x, ny, nx int) {
+// (rooms.c dig).
+func digWallGap(m *mazeState, y, x, nexty, nextx int) Coord {
+	if nexty == y {
+		pos := Coord{Y: y + m.starty, X: nextx + m.startx - 1}
+		if nextx-x < 0 {
+			pos.X = nextx + m.startx + 1
+		}
+
+		return pos
+	}
+
+	pos := Coord{X: x + m.startx, Y: nexty + m.starty - 1}
+	if nexty-y < 0 {
+		pos.Y = nexty + m.starty + 1
+	}
+
+	return pos
+}
+
+// accountMaze accounts for maze exits (rooms.c accnt_maze).
+func (g *RogueGame) accountMaze(y, x, ny, nx int) {
 	sp := &g.maze.maze[y][x]
-	for i := 0; i < sp.nexits; i++ {
+	for i := range sp.nexits {
 		if sp.exits[i].Y == ny && sp.exits[i].X == nx {
 			return
 		}
@@ -233,18 +297,21 @@ func (g *RogueGame) accntMaze(y, x, ny, nx int) {
 	}
 }
 
-// rndPos picks a random spot in a room (rooms.c rnd_pos).
+// randomPos picks a random spot in a room (rooms.c rnd_pos).
-func (g *RogueGame) rndPos(rp *Room) Coord {
+func (g *RogueGame) randomPos(rp *Room) Coord {
 	var cp Coord
+
 	cp.X = rp.Pos.X + g.rnd(rp.Max.X-2) + 1
 	cp.Y = rp.Pos.Y + g.rnd(rp.Max.Y-2) + 1
+
 	return cp
 }
 
 // findFloor finds a valid floor spot, picking a new random room each time
-// around the loop (rooms.c find_floor with rp == NULL).
+// around the loop; it retries forever (rooms.c find_floor with rp == NULL
-func (g *RogueGame) findFloor(rp *Room, limit int, monst bool) (Coord, bool) {
+// — every such C call site passed FALSE for the limit).
-	return g.findFloorImpl(rp, limit, monst, rp == nil)
+func (g *RogueGame) findFloor(monst bool) (Coord, bool) {
+	return g.findFloorImpl(nil, 0, monst, true)
 }
 
 // findFloorIn finds a valid floor spot in this room (rooms.c find_floor
@@ -253,14 +320,22 @@ func (g *RogueGame) findFloorIn(rp *Room, limit int, monst bool) (Coord, bool) {
 	return g.findFloorImpl(rp, limit, monst, false)
 }
 
+// floorChar is what an empty spot looks like in a room: passage in a
+// maze, floor otherwise (rooms.c find_floor).
+func floorChar(rp *Room) byte {
+	if rp.Flags.Has(Maze) {
+		return Passage
+	}
+
+	return Floor
+}
+
 func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Coord, bool) {
 	var compchar byte
 	if !pickroom {
-		compchar = Floor
+		compchar = floorChar(rp)
-		if rp.Flags.Has(Maze) {
-			compchar = Passage
-		}
 	}
+
 	cnt := limit
 	for {
 		if limit != 0 {
@@ -268,14 +343,14 @@ func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Co
 				return Coord{}, false
 			}
 		}
+
 		if pickroom {
-			rp = &g.Level.Rooms[g.rndRoom()]
+			rp = &g.Level.Rooms[g.randomRoom()]
-			compchar = Floor
+			compchar = floorChar(rp)
-			if rp.Flags.Has(Maze) {
-				compchar = Passage
 		}
-		}
+
-		cp := g.rndPos(rp)
+		cp := g.randomPos(rp)
+
 		pp := g.Level.At(cp.Y, cp.X)
 		if monst {
 			if pp.Monst == nil && stepOk(pp.Ch) {
@@ -291,14 +366,26 @@ func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Co
 // enter_room).
 func (g *RogueGame) enterRoom(cp Coord) {
 	p := &g.Player
-	rp := g.roomin(cp)
+	rp := g.roomIn(cp)
 	p.Room = rp
 	g.doorOpen(rp)
+
 	if !rp.Flags.Has(Dark) && !p.On(Blind) {
 		for y := rp.Pos.Y; y < rp.Max.Y+rp.Pos.Y; y++ {
 			g.move(y, rp.Pos.X)
+
 			for x := rp.Pos.X; x < rp.Max.X+rp.Pos.X; x++ {
+				g.enterRoomCell(y, x)
+			}
+		}
+	}
+}
+
+// enterRoomCell draws one square of a room being lit on entry (the loop
+// body of rooms.c enter_room).
+func (g *RogueGame) enterRoomCell(y, x int) {
 	tp := g.Level.MonsterAt(y, x)
+
 	ch := g.Level.Char(y, x)
 	if tp == nil {
 		if g.inch() != ch {
@@ -306,23 +393,24 @@ func (g *RogueGame) enterRoom(cp Coord) {
 		} else {
 			g.move(y, x+1)
 		}
-				} else {
+
+		return
+	}
+
 	tp.OldCh = ch
-					if !g.seeMonst(tp) {
+	if g.seeMonst(tp) {
-						if p.On(SenseMonsters) {
+		g.addch(tp.Disguise)
+
+		return
+	}
+
+	if g.Player.On(SenseMonsters) {
 		g.standout()
 		g.addch(tp.Disguise)
 		g.standend()
 	} else {
 		g.addch(ch)
 	}
-					} else {
-						g.addch(tp.Disguise)
-					}
-				}
-			}
-		}
-	}
 }
 
 // leaveRoom is the code for when we exit a room (rooms.c leave_room).
@@ -335,6 +423,7 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 	}
 
 	var floor byte
+
 	switch {
 	case rp.Flags.Has(Gone):
 		floor = Passage
@@ -347,7 +436,18 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 	p.Room = &g.Level.Passages[*g.Level.FlagsAt(cp.Y, cp.X)&FPassNum]
 	for y := rp.Pos.Y; y < rp.Max.Y+rp.Pos.Y; y++ {
 		for x := rp.Pos.X; x < rp.Max.X+rp.Pos.X; x++ {
+			g.leaveRoomCell(floor, y, x)
+		}
+	}
+
+	g.doorOpen(rp)
+}
+
+// leaveRoomCell hides one square of a room being left (the loop body of
+// rooms.c leave_room).
+func (g *RogueGame) leaveRoomCell(floor byte, y, x int) {
 	g.move(y, x)
+
 	switch ch := g.inch(); ch {
 	case Floor:
 		if floor == ' ' {
@@ -356,13 +456,18 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 	default:
 		// to check for monster, we have to strip out the standout
 		// bit (our Window returns the bare character already)
-				if isUpper(ch) {
+		if !isUpper(ch) {
-					if p.On(SenseMonsters) {
+			return
+		}
+
+		if g.Player.On(SenseMonsters) {
 			g.standout()
 			g.addch(ch)
 			g.standend()
-						break
+
+			return
 		}
+
 		pp := g.Level.At(y, x)
 		if pp.Ch == Door {
 			g.addch(Door)
@@ -371,7 +476,3 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 		}
 	}
 }
-		}
-	}
-	g.doorOpen(rp)
-}

game/run_test.go

@@ -1,104 +1,204 @@
 package game
 
 import (
+	"path/filepath"
 	"strings"
 	"testing"
 )
 
-// TestRunScriptedSession drives a complete game through Run(): a few
+// fortify makes the hero effectively immortal for a crash-sweep drive:
-// moves, a rest, an inventory, then Q-quit answered yes.
+// game-over now calls myExit and os.Exit(0) (step 8), which would kill the
-func TestRunScriptedSession(t *testing.T) {
+// test binary, so every death vector is neutralized. Re-applied each turn
-	tt := &testTerm{input: []byte("hjkl.i Qy")}
+// because combat, digestion, freezing, and level drain chip away at these.
-	g := NewGame(Config{Seed: 99, Term: tt})
+func fortify(g *RogueGame) {
-	if err := g.Run(); err != nil {
+	p := &g.Player
-		t.Fatalf("Run: %v", err)
+	p.Stats.HP = 30000    // survive combat, arrow/dart traps, bolts
+	p.Stats.MaxHP = 30000 // survive vampire max-hp drain
+	p.Stats.Exp = 30000   // survive wraith level drain (death when exp hits 0)
+	p.FoodLeft = 30000    // never starve
+	g.NoCommand = 0       // never freeze to death (ice monster / sleep trap)
+	g.NoMove = 0          // never stay stuck in a bear trap
 }
-	if g.Playing {
+
-		t.Error("still playing after quit")
+// driveTurns runs the game's per-turn loop up to n times, doing the same
-	}
+// first-level and pre-play setup Run() does. Run() itself no longer
-	// After quitting, the scoreboard is the last thing shown (in C it went
+// returns — game-over exits the process — so tests drive command()
-	// to stdout after endwin; here it is drawn on the screen).
+// directly, with short scripts that avoid quitting, saving, or playing
-	found := false
+// long enough to starve, any of which would exit the test binary.
-	for y := 0; y < NumLines; y++ {
+func driveTurns(t *testing.T, g *RogueGame, n int) {
-		if strings.Contains(g.scr.Std.Line(y), "Top Ten") {
+	t.Helper()
-			found = true
+
-		}
+	g.startLevel()
-	}
+	g.prePlay()
-	if !found {
+
-		t.Error("score list not on screen after quit")
+	for range n {
+		g.command()
 	}
 }
 
-// TestRunManyTurns mashes movement keys for a while as a crash sweep of
+// TestRunDownStairs stands the hero on the staircase and descends via the
-// the whole turn loop (daemons, hunger, monsters, combat), ending with a
+// '>' command through the real turn loop, then checks the level changed.
-// quit. The input alternates directions so the hero bumps around rooms.
-func TestRunManyTurns(t *testing.T) {
-	// Spaces between commands double as answers to any --More-- prompts;
-	// without them a single prompt would swallow the rest of the script
-	// (wait_for eats everything that isn't a space).
-	var script []byte
-	moves := []byte("h h j j k k l l y u b n s s . . ")
-	for range 200 {
-		script = append(script, moves...)
-	}
-	script = append(script, " Q y Qy"...)
-	tt := &testTerm{input: script}
-	g := NewGame(Config{Seed: 31337, Term: tt})
-	if err := g.Run(); err != nil {
-		t.Fatalf("Run: %v", err)
-	}
-	if g.Playing {
-		t.Error("session did not end")
-	}
-}
-
-// TestRunDownStairs walks the hero onto the stairs by teleporting there in
-// wizard style, then descends and keeps playing.
 func TestRunDownStairs(t *testing.T) {
-	tt := &testTerm{input: []byte(">..Qy")}
+	// '>' is a free action (After=false), so it is followed by a paying
-	g := NewGame(Config{Seed: 7, Term: tt})
+	// rest ('.') to end the command() call; without a paying action the
+	// turn loop would spin forever on the auto-fed prompt input.
+	tt := &testTerm{input: []byte(">.")}
+	g := New(Params{Seed: 7, Term: tt})
 	g.NewLevel()
 	g.Player.Pos = g.Level.Stairs // stand on the stairs
-	g.restored = true             // keep Run from regenerating the level
+	g.restored = true             // keep startLevel from regenerating
 	g.Daemons = DaemonList{}      // and give it a fresh daemon table
 	g.StartDaemon(DRunners, 0, After)
 	g.StartDaemon(DDoctor, 0, After)
 	g.Fuse(DSwander, 0, wanderTime(g), After)
 	g.StartDaemon(DStomach, 0, After)
-	if err := g.Run(); err != nil {
+
-		t.Fatalf("Run: %v", err)
+	driveTurns(t, g, 1)
-	}
+
 	if g.Depth != 2 {
 		t.Errorf("depth = %d after descending, want 2", g.Depth)
 	}
 }
 
-// TestSaveCommandRoundTrip saves via the 'S' command (as a player would)
+// TestScoreRendersList checks that the scoreboard is drawn on the screen
-// and restores the game.
+// (in C it went to stdout after endwin; here it stays on the screen). The
-func TestSaveCommandRoundTrip(t *testing.T) {
+// quit and death paths that normally show it now exit the process, so the
-	// The C get_str caps input at MAXINP=50 characters, so the save path
+// display is exercised through score() directly.
-	// must be short: work from the temp directory.
+func TestScoreRendersList(t *testing.T) {
-	t.Chdir(t.TempDir())
+	g := New(Params{Seed: 1, Term: &testTerm{}})
-	path := "cmd.save"
+	g.Player.Purse = 100
-	// 'S' with no default file name goes straight to the name prompt.
+
-	script := "S" + path + "\n"
+	g.score(g.Player.Purse, 1, 0) // flags 1 = quit; posts the top-ten list
-	tt := &testTerm{input: []byte(script)}
+
-	g := NewGame(Config{Seed: 55, Term: tt})
+	found := false
-	g.FileName = "" // force the name prompt
+
-	if err := g.Run(); err != nil {
+	for y := range NumLines {
-		t.Fatalf("Run: %v", err)
+		if strings.Contains(g.scr.Std.Line(y), "Top Ten") {
+			found = true
+		}
 	}
 
-	h, err := Restore(path, Config{Term: &testTerm{}})
+	if !found {
+		t.Error("score list not on screen")
+	}
+}
+
+// TestDeepPlaythrough drives a fortified hero through the real command loop:
+// quaff/read/zap on the first level, then descend through the staircase to
+// depth 8, saving and restoring mid-way. It is a crash sweep of the turn
+// engine, deep level generation, item effects, and mid-game save/restore.
+// The hero is fortified so no death exits the process (step 8), and the fixed
+// seed keeps it deterministic.
+func TestDeepPlaythrough(t *testing.T) {
+	g := New(Params{Seed: 4242, Wizard: true, Term: &testTerm{}})
+	g.startLevel()
+	g.prePlay()
+	fortify(g)
+
+	// Stock and use one of each consumable through the command dispatch.
+	pot := give(g, &Object{Kind: KindPotion, Which: int(PotionHealing)})
+	scr := give(g, &Object{Kind: KindScroll, Which: int(ScrollMagicMapping)})
+
+	wand := newObject()
+	wand.Kind = KindWand
+	wand.Which = int(WandLight)
+	wand.Charges = 5
+	zap := give(g, wand)
+
+	setInput(t, g, 'q', pot) // quaff healing
+	g.command()
+	setInput(t, g, 'r', scr) // read magic mapping
+	g.command()
+	setInput(t, g, 'z', 'h', zap) // zap the light wand west
+	g.command()
+	fortify(g)
+
+	// Each consumable identifies itself on use, confirming the q/r/z
+	// commands actually ran through dispatch (not aborted on a bad prompt).
+	if !g.Items.Potions[PotionHealing].Know {
+		t.Error("quaff command did not identify the healing potion")
+	}
+
+	if !g.Items.Scrolls[ScrollMagicMapping].Know {
+		t.Error("read command did not identify the magic-mapping scroll")
+	}
+
+	if !g.Items.Sticks[WandLight].Know {
+		t.Error("zap command did not identify the light wand")
+	}
+
+	const wantDepth = 8
+
+	for g.Depth < wantDepth {
+		g.Player.Pos = g.Level.Stairs // stand on the stairs
+		setInput(t, g, '>', '.')      // '>' descends (free), '.' pays the turn
+		g.command()
+		fortify(g)
+
+		if g.Depth == 4 {
+			g = saveAndRestore(t, g)
+			fortify(g)
+		}
+	}
+
+	if g.Depth != wantDepth {
+		t.Errorf("depth = %d after descending, want %d", g.Depth, wantDepth)
+	}
+
+	if g.Player.Stats.HP <= 0 {
+		t.Error("hero died during the playthrough")
+	}
+}
+
+// TestTurnLoopCrashSweep mashes movement, search, and rest through the real
+// turn loop for many turns on several seeds, exercising combat, monster AI,
+// and traps. The hero is fortified each turn so nothing exits the process,
+// and the fixed seeds keep it deterministic; the point is to surface panics.
+func TestTurnLoopCrashSweep(t *testing.T) {
+	// A generous mix of movement, search, and rest. The spaces between
+	// commands double as answers to any --More-- prompt (wait_for eats
+	// everything up to a space); without them one prompt would swallow the
+	// rest of the script. The script is long enough that the bounded drive
+	// never exhausts it (which would spin on the auto-fed prompt input).
+	script := []byte(strings.Repeat("h j k l y u b n s . ", 400))
+
+	for _, seed := range []int32{1, 99, 2026, 31337} {
+		g := New(Params{Seed: seed, Term: &testTerm{input: script}})
+		g.startLevel()
+		g.prePlay()
+
+		for range 200 {
+			fortify(g)
+			g.command()
+		}
+
+		if g.Player.Stats.HP <= 0 {
+			t.Errorf("seed %d: hero died despite fortify", seed)
+		}
+	}
+}
+
+// saveAndRestore snapshots the game to a file, restores it, checks the key
+// state survived, and returns the restored game ready to keep playing.
+func saveAndRestore(t *testing.T, g *RogueGame) *RogueGame {
+	t.Helper()
+
+	path := filepath.Join(t.TempDir(), "deep.save")
+
+	saveErr := g.saveFile(path)
+	if saveErr != nil {
+		t.Fatalf("saveFile: %v", saveErr)
+	}
+
+	h, err := Restore(path, Params{Wizard: true, Term: &testTerm{}})
 	if err != nil {
 		t.Fatalf("Restore: %v", err)
 	}
+
 	if h.Depth != g.Depth || h.Player.Purse != g.Player.Purse {
-		t.Error("restored game does not match saved game")
+		t.Errorf("restored game diverged: depth %d/%d purse %d/%d",
-	}
+			h.Depth, g.Depth, h.Player.Purse, g.Player.Purse)
-	// The restored game must be playable.
-	h.scr.term.(*testTerm).input = []byte("..Qy")
-	if err := h.Run(); err != nil {
-		t.Fatalf("restored Run: %v", err)
 	}
+
+	return h
 }

game/save.go

@@ -2,6 +2,7 @@ package game
 
 import (
 	"encoding/gob"
+	"errors"
 	"fmt"
 	"os"
 )
@@ -131,16 +132,19 @@ func (g *RogueGame) roomIdx(rp *Room) int {
 	if rp == nil {
 		return -1
 	}
+
 	for i := range g.Level.Rooms {
 		if rp == &g.Level.Rooms[i] {
 			return i
 		}
 	}
+
 	for i := range g.Level.Passages {
 		if rp == &g.Level.Passages[i] {
 			return 100 + i
 		}
 	}
+
 	return -1
 }
 
@@ -152,6 +156,7 @@ func (g *RogueGame) roomAt(i int) *Room {
 	case i >= 0:
 		return &g.Level.Rooms[i]
 	}
+
 	return nil
 }
 
@@ -160,18 +165,60 @@ func (g *RogueGame) packIdx(obj *Object) int {
 	if obj == nil {
 		return -1
 	}
+
 	for i, o := range g.Player.Pack {
 		if o == obj {
 			return i
 		}
 	}
+
 	return -1
 }
 
 // snapshot captures the complete game state.
 func (g *RogueGame) snapshot() *SaveState {
-	p := &g.Player
+	st := g.snapshotHeader()
-	st := &SaveState{
+
+	// the map, sans monster pointers (rebuilt on load)
+	st.Places = make([]savedPlace, len(g.Level.Places))
+	for i := range g.Level.Places {
+		st.Places[i] = savedPlace{
+			Ch:    g.Level.Places[i].Ch,
+			Flags: g.Level.Places[i].Flags,
+		}
+	}
+
+	// level objects by value; remember their pointers for dest encoding
+	objAt := make(map[*Object]int, len(g.Level.Objects))
+	for i, o := range g.Level.Objects {
+		st.Objects = append(st.Objects, *o)
+		objAt[o] = i
+	}
+
+	st.Player = g.snapshotPlayer()
+
+	// monsters, with chase targets as (kind, index) references
+	for _, m := range g.Level.Monsters {
+		sc := savedCreature{
+			Pos: m.Pos, Turn: m.Turn, Type: m.Type, Disguise: m.Disguise,
+			OldCh: m.OldCh, Flags: m.Flags, Stats: m.Stats,
+			RoomIdx: g.roomIdx(m.Room),
+		}
+		for _, o := range m.Pack {
+			sc.Pack = append(sc.Pack, *o)
+		}
+
+		st.Monsters = append(st.Monsters, sc)
+		st.Dests = append(st.Dests, g.destRefFor(m, objAt))
+	}
+
+	return st
+}
+
+// snapshotHeader captures the scalar game state (the field list of
+// state.c rs_save_file).
+func (g *RogueGame) snapshotHeader() *SaveState {
+	return &SaveState{
 		Version:    saveFormatVersion,
 		Seed:       g.Rng.Seed,
 		Dnum:       g.Dnum,
@@ -219,25 +266,14 @@ func (g *RogueGame) snapshot() *SaveState {
 		AllScore:   g.AllScore,
 		Screen:     g.scr.Std.Contents(),
 	}
-
-	// the map, sans monster pointers (rebuilt on load)
-	st.Places = make([]savedPlace, len(g.Level.Places))
-	for i := range g.Level.Places {
-		st.Places[i] = savedPlace{
-			Ch:    g.Level.Places[i].Ch,
-			Flags: g.Level.Places[i].Flags,
-		}
 }
 
-	// level objects by value; remember their pointers for dest encoding
+// snapshotPlayer captures the player, equipment as pack indices (the
-	objAt := make(map[*Object]int, len(g.Level.Objects))
+// player half of snapshot).
-	for i, o := range g.Level.Objects {
+func (g *RogueGame) snapshotPlayer() savedPlayer {
-		st.Objects = append(st.Objects, *o)
+	p := &g.Player
-		objAt[o] = i
-	}
 
-	// the player
+	sp := savedPlayer{
-	st.Player = savedPlayer{
 		Body: savedCreature{
 			Pos: p.Pos, Turn: p.Turn, Type: p.Type, Disguise: p.Disguise,
 			OldCh: p.OldCh, Flags: p.Flags, Stats: p.Stats,
@@ -253,55 +289,72 @@ func (g *RogueGame) snapshot() *SaveState {
 		MaxStats: p.MaxStats, VfHit: p.VfHit,
 	}
 	for _, o := range p.Pack {
-		st.Player.Body.Pack = append(st.Player.Body.Pack, *o)
+		sp.Body.Pack = append(sp.Body.Pack, *o)
 	}
 
-	// monsters, with chase targets as (kind, index) references
+	return sp
-	for _, m := range g.Level.Monsters {
-		sc := savedCreature{
-			Pos: m.Pos, Turn: m.Turn, Type: m.Type, Disguise: m.Disguise,
-			OldCh: m.OldCh, Flags: m.Flags, Stats: m.Stats,
-			RoomIdx: g.roomIdx(m.Room),
 }
-		for _, o := range m.Pack {
-			sc.Pack = append(sc.Pack, *o)
-		}
-		st.Monsters = append(st.Monsters, sc)
 
-		ref := destRef{}
+// destRefFor encodes a monster's chase target as a (kind, index)
+// reference: the hero, another monster, a level object, or room gold
+// (state.c rs_write_thing).
+func (g *RogueGame) destRefFor(m *Monster, objAt map[*Object]int) destRef {
 	switch {
 	case m.Dest == nil:
-		case m.Dest == &p.Pos:
+		return destRef{}
-			ref = destRef{Kind: 1}
+	case m.Dest == &g.Player.Pos:
-		default:
+		return destRef{Kind: 1}
+	}
+
 	for mi, om := range g.Level.Monsters {
 		if m.Dest == &om.Pos {
-					ref = destRef{Kind: 2, Idx: mi}
+			return destRef{Kind: 2, Idx: mi}
 		}
 	}
-			if ref.Kind == 0 {
+
 	for _, oo := range g.Level.Objects {
 		if m.Dest == &oo.Pos {
-						ref = destRef{Kind: 3, Idx: objAt[oo]}
+			return destRef{Kind: 3, Idx: objAt[oo]}
 		}
 	}
-			}
+
-			if ref.Kind == 0 {
 	for ri := range g.Level.Rooms {
 		if m.Dest == &g.Level.Rooms[ri].Gold {
-						ref = destRef{Kind: 4, Idx: ri}
+			return destRef{Kind: 4, Idx: ri}
 		}
 	}
-			}
+
-		}
+	return destRef{}
-		st.Dests = append(st.Dests, ref)
-	}
-	return st
 }
 
 // applySnapshot rebuilds live game state from a snapshot.
 func (g *RogueGame) applySnapshot(st *SaveState) {
-	p := &g.Player
+	g.applyHeader(st)
+
+	for i := range g.Level.Places {
+		g.Level.Places[i] = Place{
+			Ch:    st.Places[i].Ch,
+			Flags: st.Places[i].Flags,
+		}
+	}
+
+	// level objects
+	g.Level.Objects = nil
+	for i := range st.Objects {
+		o := st.Objects[i]
+		g.Level.Objects = append(g.Level.Objects, &o)
+	}
+
+	g.applyPlayer(st)
+	g.applyMonsters(st)
+	g.applyDests(st)
+
+	g.scr.Std.SetContents(st.Screen)
+}
+
+// applyHeader restores the scalar game state (the field list of
+// applySnapshot).
+func (g *RogueGame) applyHeader(st *SaveState) {
 	g.Rng.Seed = st.Seed
 	g.Dnum = st.Dnum
 	g.Whoami = st.Whoami
@@ -316,6 +369,12 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	g.Level.Passages = st.Passages
 	g.Level.Stairs = st.Stairs
 	g.Level.TrapCount = st.TrapCount
+	g.applyTurnState(st)
+}
+
+// applyTurnState restores the in-turn command state (the second half of
+// applyHeader).
+func (g *RogueGame) applyTurnState(st *SaveState) {
 	g.After = st.After
 	g.Again = st.Again
 	g.NoScore = st.NoScoreF
@@ -346,22 +405,12 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	g.LastScore = st.LastScore
 	g.AllScore = st.AllScore
 	g.Playing = true
-
-	for i := range g.Level.Places {
-		g.Level.Places[i] = Place{
-			Ch:    st.Places[i].Ch,
-			Flags: st.Places[i].Flags,
-		}
 }
 
-	// level objects
+// applyPlayer restores the player, resolving equipment pack indices
-	g.Level.Objects = nil
+// (the player half of applySnapshot).
-	for i := range st.Objects {
+func (g *RogueGame) applyPlayer(st *SaveState) {
-		o := st.Objects[i]
+	p := &g.Player
-		g.Level.Objects = append(g.Level.Objects, &o)
-	}
-
-	// the player
 	sp := &st.Player
 	p.Pos = sp.Body.Pos
 	p.Turn = sp.Body.Turn
@@ -371,15 +420,18 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	p.Flags = sp.Body.Flags
 	p.Stats = sp.Body.Stats
 	p.Room = g.roomAt(sp.Body.RoomIdx)
+
 	p.Pack = nil
 	for i := range sp.Body.Pack {
 		o := sp.Body.Pack[i]
 		p.Pack = append(p.Pack, &o)
 	}
+
 	pick := func(i int) *Object {
 		if i < 0 || i >= len(p.Pack) {
 			return nil
 		}
+
 		return p.Pack[i]
 	}
 	p.CurArmor = pick(sp.CurArmor)
@@ -395,11 +447,15 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	p.NoFood = sp.NoFood
 	p.MaxStats = sp.MaxStats
 	p.VfHit = sp.VfHit
+}
 
-	// monsters, their map index, and their chase targets
+// applyMonsters rebuilds the monster list and its map index from a
+// snapshot (the monster half of applySnapshot).
+func (g *RogueGame) applyMonsters(st *SaveState) {
 	g.Level.Monsters = nil
 	for i := range st.Monsters {
 		sc := &st.Monsters[i]
+
 		m := &Monster{Creature: Creature{
 			Pos: sc.Pos, Turn: sc.Turn, Type: sc.Type, Disguise: sc.Disguise,
 			OldCh: sc.OldCh, Flags: sc.Flags, Stats: sc.Stats,
@@ -409,14 +465,21 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 			o := sc.Pack[j]
 			m.Pack = append(m.Pack, &o)
 		}
+
 		g.Level.Monsters = append(g.Level.Monsters, m)
 		g.Level.SetMonsterAt(m.Pos.Y, m.Pos.X, m)
 	}
+}
+
+// applyDests re-aims the monsters' chase targets from their (kind,
+// index) references (the fixup half of applySnapshot).
+func (g *RogueGame) applyDests(st *SaveState) {
 	for i, ref := range st.Dests {
 		m := g.Level.Monsters[i]
+
 		switch ref.Kind {
 		case 1:
-			m.Dest = &p.Pos
+			m.Dest = &g.Player.Pos
 		case 2:
 			m.Dest = &g.Level.Monsters[ref.Idx].Pos
 		case 3:
@@ -425,136 +488,236 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 			m.Dest = &g.Level.Rooms[ref.Idx].Gold
 		}
 	}
-
-	g.scr.Std.SetContents(st.Screen)
 }
 
-// saveGame implements the "save game" command (save.c save_game). The C
+// saveAnswer is a yes/no/escape prompt result in the save-game flow.
-// goto over/gotfile flow becomes the useDefault flag.
+type saveAnswer int
+
+// The saveGame prompt outcomes.
+const (
+	saveYes saveAnswer = iota
+	saveNo
+	saveAbort
+)
+
+// saveGame implements the "save game" command (save.c save_game). The
+// labeled prompt loop stands in for the C goto over/gotfile flow.
 func (g *RogueGame) saveGame() {
 	g.Msgs.Mpos = 0
-over:
+
-	useDefault := false
+prompt:
-	if g.FileName != "" {
-		var c byte
 	for {
-			g.msg("save file (%s)? ", g.FileName)
+		useDefault := false
-			c = g.readchar()
+
-			g.Msgs.Mpos = 0
+		if g.FileName != "" {
-			if c == Escape {
+			a := g.askDefaultSave()
-				g.msg("")
+			if a == saveAbort {
 				return
 			}
-			if c == 'n' || c == 'N' || c == 'y' || c == 'Y' {
+
-				break
+			useDefault = a == saveYes
-			}
-			g.msg("please answer Y or N")
-		}
-		if c == 'y' || c == 'Y' {
-			g.addstr("Yes\n")
-			g.refresh()
-			useDefault = true
-		}
 		}
 
 		for {
-		var buf string
+			buf, ok := g.saveFileName(useDefault)
-		if useDefault {
+			if !ok {
-			buf = g.FileName
-			useDefault = false
-		} else {
-			g.Msgs.Mpos = 0
-			g.msg("file name: ")
-			if g.getStr(&buf, g.scr.Std) == Quit {
-				g.msg("")
 				return
 			}
-			g.Msgs.Mpos = 0
+
+			useDefault = false
+
+			a := g.saveCheckOverwrite(buf)
+			if a == saveAbort {
+				return
 			}
+
+			if a == saveNo {
+				continue prompt // the C goto over: start again
+			}
+
+			g.FileName = buf
+
+			err := g.saveFile(g.FileName)
+			if err != nil {
+				g.msg("%s", err.Error())
+
+				continue
+			}
+
+			break prompt
+		}
+	}
+
+	g.myExit()
+}
+
+// askDefaultSave asks whether to save to the current file name (save.c
+// save_game).
+func (g *RogueGame) askDefaultSave() saveAnswer {
+	for {
+		g.msg("save file (%s)? ", g.FileName)
+		c := g.readchar()
+
+		g.Msgs.Mpos = 0
+
+		switch c {
+		case Escape:
+			g.msg("")
+
+			return saveAbort
+		case 'y', 'Y':
+			g.addstr("Yes\n")
+			g.refresh()
+
+			return saveYes
+		case 'n', 'N':
+			return saveNo
+		}
+
+		g.msg("please answer Y or N")
+	}
+}
+
+// saveFileName picks the save path: the default, or a prompted one; ok
+// is false when the player quit the prompt (save.c save_game).
+func (g *RogueGame) saveFileName(useDefault bool) (string, bool) {
+	if useDefault {
+		return g.FileName, true
+	}
+
+	g.Msgs.Mpos = 0
+	g.msg("file name: ")
+
+	buf := ""
+	if g.getStr(&buf, g.scr.Std) == Quit {
+		g.msg("")
+
+		return "", false
+	}
+
+	g.Msgs.Mpos = 0
+
+	return buf, true
+}
+
+// saveCheckOverwrite guards an existing file: saveNo restarts the whole
+// prompt, saveAbort quits (save.c save_game).
+func (g *RogueGame) saveCheckOverwrite(buf string) saveAnswer {
 	// test to see if the file exists
-		if _, err := os.Stat(buf); err == nil {
+	_, statErr := os.Stat(buf)
+	if statErr != nil {
+		return saveYes
+	}
+
+	answer := g.askOverwrite()
+	if answer != saveYes {
+		return answer
+	}
+
+	g.msg("file name: %s", buf)
+	_ = os.Remove(g.FileName) // best effort, as in C (md_unlink)
+
+	return saveYes
+}
+
+// askOverwrite asks whether to overwrite the existing file (save.c
+// save_game).
+func (g *RogueGame) askOverwrite() saveAnswer {
 	for {
 		g.msg("File exists.  Do you wish to overwrite it?")
 		g.Msgs.Mpos = 0
-				c := g.readchar()
+
-				if c == Escape {
+		switch g.readchar() {
+		case Escape:
 			g.msg("")
-					return
+
-				}
+			return saveAbort
-				if c == 'y' || c == 'Y' {
+		case 'y', 'Y':
-					break
+			return saveYes
-				}
+		case 'n', 'N':
-				if c == 'n' || c == 'N' {
+			return saveNo
-					goto over
-				}
-				g.msg("Please answer Y or N")
-			}
-			g.msg("file name: %s", buf)
-			os.Remove(g.FileName)
-		}
-		g.FileName = buf
-		if err := g.saveFile(g.FileName); err != nil {
-			g.msg("%s", err.Error())
-			continue
-		}
-		break
-	}
-	g.myExit(0)
 		}
 
-// saveFile writes the saved game (save.c save_file).
+		g.msg("Please answer Y or N")
+	}
+}
+
+// saveFile writes the saved game (save.c save_file). A failed write means
+// a corrupt save, so the file is removed before reporting the error.
 func (g *RogueGame) saveFile(path string) error {
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o400)
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o400) //nolint:gosec,lll // G304: user-chosen save path
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+
-	if err := gob.NewEncoder(f).Encode(g.snapshot()); err != nil {
+	encErr := gob.NewEncoder(f).Encode(g.snapshot())
-		os.Remove(path)
+	closeErr := f.Close()
-		return err
+
+	if encErr != nil || closeErr != nil {
+		_ = os.Remove(path) // don't leave a corrupt save behind
+
+		if encErr != nil {
+			return encErr
 		}
+
+		return closeErr
+	}
+
 	return os.Chmod(path, 0o400)
 }
 
 // AutoSave silently saves to the current file name; used on SIGHUP/SIGTERM
-// (save.c auto_save).
+// (save.c auto_save). Best effort by design: it runs on the way out of a
+// dying process.
 func (g *RogueGame) AutoSave() {
 	if g.FileName != "" {
-		os.Remove(g.FileName)
+		_ = os.Remove(g.FileName)
-		g.saveFile(g.FileName)
+		_ = g.saveFile(g.FileName)
 	}
 }
 
+// ErrSaveOutOfDate reports a save file from an incompatible version.
+var ErrSaveOutOfDate = errors.New("sorry, saved game is out of date")
+
 // Restore restores a saved game from a file (save.c restore). The file is
 // deleted, as in C, to defeat restarting from the same save.
-func Restore(path string, cfg Config) (*RogueGame, error) {
+func Restore(path string, params Params) (*RogueGame, error) {
-	f, err := os.Open(path)
+	f, err := os.Open(path) //nolint:gosec // G304: the save path is user-chosen by design
 	if err != nil {
 		return nil, err
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }() // read-only handle
+
 	var st SaveState
-	if err := gob.NewDecoder(f).Decode(&st); err != nil {
+
-		return nil, fmt.Errorf("%s: corrupt or incompatible save file: %w", path, err)
+	decErr := gob.NewDecoder(f).Decode(&st)
+	if decErr != nil {
+		return nil, fmt.Errorf("%s: corrupt or incompatible save file: %w",
+			path, decErr)
 	}
+
 	if st.Version != saveFormatVersion {
-		return nil, fmt.Errorf("sorry, saved game is out of date")
+		return nil, ErrSaveOutOfDate
 	}
 
 	g := &RogueGame{
+		data:      newGameData(),
 		Rng:       &Rng{},
 		Playing:   true,
-		ScorePath: cfg.ScorePath,
+		ScorePath: params.ScorePath,
 		FileName:  path,
-		rogueOpts: cfg.RogueOpts,
+		rogueOpts: params.RogueOpts,
 		restored:  true,
 	}
-	g.scr = NewScreen(cfg.Term)
+	g.scr = NewScreen(params.Term)
+	g.Msgs.attach(g.scr, g.look, g.readchar)
 	g.applySnapshot(&st)
 
 	// defeat multiple restarting from the same place
-	if err := os.Remove(path); err != nil {
+	rmErr := os.Remove(path)
-		return nil, fmt.Errorf("cannot unlink file: %w", err)
+	if rmErr != nil {
+		return nil, fmt.Errorf("cannot unlink file: %w", rmErr)
 	}
+
 	return g, nil
 }

game/save_test.go

@@ -15,6 +15,7 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 	g.HasAmulet = true
 	g.Items.Potions[PotionHealing].Know = true
 	g.Items.Scrolls[ScrollMagicMapping].Guess = "map???"
+
 	g.Monsters['F'-'A'].Stats.Dmg = dice("3x1") // mutated bestiary must survive
 	if len(g.Level.Monsters) > 0 {
 		g.Level.Monsters[0].Flags.Set(Awake)
@@ -22,72 +23,111 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 	}
 
 	path := filepath.Join(t.TempDir(), "rogue.save")
-	if err := g.saveFile(path); err != nil {
+
-		t.Fatalf("saveFile: %v", err)
+	saveErr := g.saveFile(path)
+	if saveErr != nil {
+		t.Fatalf("saveFile: %v", saveErr)
 	}
 
-	h, err := Restore(path, Config{Term: &testTerm{}})
+	h, err := Restore(path, Params{Term: &testTerm{}})
 	if err != nil {
 		t.Fatalf("Restore: %v", err)
 	}
 
-	if _, err := os.Stat(path); !os.IsNotExist(err) {
+	_, statErr := os.Stat(path)
+	if !os.IsNotExist(statErr) {
 		t.Error("save file not deleted on restore (C anti-restart rule)")
 	}
 
+	checkRestoredState(t, g, h)
+	checkRestoredMonsters(t, g, h)
+	checkEquipmentAliasing(t, g, h)
+}
+
+// checkRestoredState verifies the scalar state survived the round trip.
+func checkRestoredState(t *testing.T, g, h *RogueGame) {
+	t.Helper()
+
 	if h.Player.Purse != 123 || h.Player.FoodLeft != 777 {
 		t.Errorf("player state lost: purse=%d food=%d",
 			h.Player.Purse, h.Player.FoodLeft)
 	}
+
 	if !h.HasAmulet {
 		t.Error("amulet flag lost")
 	}
+
 	if !h.Items.Potions[PotionHealing].Know {
 		t.Error("potion identification lost")
 	}
+
 	if h.Items.Scrolls[ScrollMagicMapping].Guess != "map???" {
 		t.Error("scroll guess lost")
 	}
+
 	if h.Monsters['F'-'A'].Stats.Dmg.String() != "3x1" {
 		t.Error("mutated bestiary lost")
 	}
+
 	if h.Rng.Seed != g.Rng.Seed {
 		t.Error("RNG state lost")
 	}
+
 	if renderMap(h) != renderMap(g) {
 		t.Error("restored level map differs")
 	}
+}
+
+// checkRestoredMonsters verifies the monster list and its pointer fixups
+// survived the round trip.
+func checkRestoredMonsters(t *testing.T, g, h *RogueGame) {
+	t.Helper()
+
 	if len(h.Level.Monsters) != len(g.Level.Monsters) {
 		t.Fatalf("monster count %d != %d",
 			len(h.Level.Monsters), len(g.Level.Monsters))
 	}
-	if len(g.Level.Monsters) > 0 {
+
+	if len(g.Level.Monsters) == 0 {
+		return
+	}
+
 	m := h.Level.Monsters[0]
 	if m.Dest != &h.Player.Pos {
 		t.Error("monster chase target not re-aliased to the hero")
 	}
+
 	if h.Level.MonsterAt(m.Pos.Y, m.Pos.X) != m {
 		t.Error("map monster index not rebuilt")
 	}
+
 	if m.Room == nil {
 		t.Error("monster room pointer not rebuilt")
 	}
 }
-	// Equipment aliasing: the wielded mace must be the same *Object as the
+
-	// one in the pack.
+// checkEquipmentAliasing verifies the wielded mace is the same *Object as
+// the one in the pack.
+func checkEquipmentAliasing(t *testing.T, g, h *RogueGame) {
+	t.Helper()
+
 	st := g.snapshot()
 	t.Logf("snapshot indices: weapon=%d armor=%d rings=%v packlen=%d",
 		st.Player.CurWeapon, st.Player.CurArmor, st.Player.CurRing,
 		len(st.Player.Body.Pack))
 	t.Logf("restored: CurWeapon=%p pack has %d items", h.Player.CurWeapon,
 		len(h.Player.Pack))
+
 	found := false
+
 	for i, o := range h.Player.Pack {
 		t.Logf("  pack[%d]=%p type=%v which=%d", i, o, o.Kind, o.Which)
+
 		if o == h.Player.CurWeapon {
 			found = true
 		}
 	}
+
 	if !found {
 		t.Error("restored CurWeapon is not aliased into the pack")
 	}
@@ -98,15 +138,24 @@ func TestRestoreRejectsWrongVersion(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "rogue.save")
 	st := g.snapshot()
 	st.Version = "0.0.0"
-	f, err := os.Create(path)
+
+	f, err := os.Create(path) //nolint:gosec // G304: test temp path
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := gob.NewEncoder(f).Encode(st); err != nil {
+
-		t.Fatal(err)
+	encErr := gob.NewEncoder(f).Encode(st)
+	if encErr != nil {
+		t.Fatal(encErr)
 	}
-	f.Close()
+
-	if _, err := Restore(path, Config{}); err == nil {
+	closeErr := f.Close()
+	if closeErr != nil {
+		t.Fatal(closeErr)
+	}
+
+	_, restoreErr := Restore(path, Params{})
+	if restoreErr == nil {
 		t.Error("restore accepted an out-of-date save")
 	}
 }

game/score.go

@@ -25,29 +25,28 @@ type ScoreEnt struct {
 	Time    int64
 }
 
-var scoreReasons = [4]string{
-	"killed",
-	"quit",
-	"A total winner",
-	"killed with Amulet",
-}
-
 // rdScore reads the scoreboard file (save.c rd_score).
 func (g *RogueGame) rdScore() []ScoreEnt {
 	topTen := make([]ScoreEnt, numScores)
 	if g.ScorePath == "" {
 		return topTen
 	}
+
 	f, err := os.Open(g.ScorePath)
 	if err != nil {
 		return topTen
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }() // read-only handle
+
 	var onDisk []ScoreEnt
-	if err := gob.NewDecoder(f).Decode(&onDisk); err != nil {
+
-		return topTen
+	decErr := gob.NewDecoder(f).Decode(&onDisk)
+	if decErr != nil {
+		return topTen // unreadable scoreboard reads as empty, as in C
 	}
+
 	copy(topTen, onDisk)
+
 	return topTen
 }
 
@@ -57,29 +56,45 @@ func (g *RogueGame) wrScore(topTen []ScoreEnt) {
 		return
 	}
 	// lock_sc/unlock_sc: exclusive-create lock file with stale takeover.
+	// The whole scoreboard write is best effort, as it was in C: a shared
+	// scoreboard must never take the game down.
 	lock := g.ScorePath + ".lck"
 	for range 5 {
-		lf, err := os.OpenFile(lock, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o644)
+		lf, err := os.OpenFile(lock, //nolint:gosec // G304: configured path
+			os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
 		if err == nil {
-			lf.Close()
+			_ = lf.Close()
-			defer os.Remove(lock)
+
+			defer func() { _ = os.Remove(lock) }()
+
 			break
 		}
-		if fi, serr := os.Stat(lock); serr == nil &&
+
-			time.Since(fi.ModTime()) > 10*time.Second {
+		fi, statErr := os.Stat(lock)
-			os.Remove(lock)
+		if statErr == nil && time.Since(fi.ModTime()) > staleLockAge {
+			_ = os.Remove(lock)
+
 			continue
 		}
+
 		time.Sleep(time.Second)
 	}
-	f, err := os.OpenFile(g.ScorePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
+
+	f, err := os.OpenFile(g.ScorePath,
+		os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
 	if err != nil {
 		return
 	}
-	defer f.Close()
+
-	gob.NewEncoder(f).Encode(topTen)
+	_ = gob.NewEncoder(f).Encode(topTen)
+	_ = f.Close()
 }
 
+// staleLockAge is how old a scoreboard lock file may be before another
+// process assumes its owner died and takes it over (mach_dep.c lock_sc
+// aged its lock the same way).
+const staleLockAge = 10 * time.Second
+
 // score figures the score and posts it (rip.c score). flags -1 means just
 // display the list (the -s command line option).
 func (g *RogueGame) score(amount, flags int, monst byte) {
@@ -93,37 +108,50 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 	// Insert her in list if need be
 	ins := -1
 	if !g.NoScore && flags >= 0 {
+		ins = g.scoreInsert(topTen, amount, flags, monst)
+	}
+
+	lines, highlight := g.scoreLines(topTen, ins)
+	g.showScores(lines, highlight)
+
+	// Update the list file
+	if ins >= 0 {
+		g.wrScore(topTen)
+	}
+}
+
+// scoreInsert slots the new score into the top ten, honoring the
+// one-score-per-losing-uid rule; -1 means it did not place (the
+// insertion half of rip.c score).
+func (g *RogueGame) scoreInsert(topTen []ScoreEnt, amount, flags int, monst byte) int {
 	uid := os.Getuid()
-		scp := len(topTen)
+
-		for i := range topTen {
+	scp := g.scoreSlot(topTen, amount, flags, uid)
-			if amount > topTen[i].Score {
+	if scp >= len(topTen) {
-				scp = i
+		return -1
-				break
-			} else if !g.AllScore && flags != 2 &&
-				topTen[i].UID == uid && topTen[i].Flags != 2 {
-				// only one score per nowin uid
-				scp = len(topTen)
-				break
 	}
-		}
+
-		if scp < len(topTen) {
 	sc2 := len(topTen) - 1
 	if flags != 2 && !g.AllScore {
 		for i := scp; i < len(topTen); i++ {
 			if topTen[i].UID == uid && topTen[i].Flags != 2 {
 				sc2 = i
+
 				break
 			}
 		}
 	}
+
 	for sc2 > scp {
 		topTen[sc2] = topTen[sc2-1]
 		sc2--
 	}
+
 	lvl := g.Depth
 	if flags == 2 {
 		lvl = g.MaxDepth
 	}
+
 	topTen[scp] = ScoreEnt{
 		UID:     uid,
 		Score:   amount,
@@ -133,59 +161,93 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 		Level:   lvl,
 		Time:    time.Now().Unix(),
 	}
-			ins = scp
+
+	return scp
+}
+
+// scoreSlot finds where the new score lands: len(topTen) when it does
+// not place, or when this uid already holds a losing score (the scan of
+// rip.c score).
+func (g *RogueGame) scoreSlot(topTen []ScoreEnt, amount, flags, uid int) int {
+	for i := range topTen {
+		if amount > topTen[i].Score {
+			return i
+		}
+
+		if !g.AllScore && flags != 2 &&
+			topTen[i].UID == uid && topTen[i].Flags != 2 {
+			// only one score per nowin uid
+			return len(topTen)
 		}
 	}
 
-	// Build the list display
+	return len(topTen)
+}
+
+// scoreLines formats the scoreboard, noting which display line holds
+// the freshly inserted score (the display half of rip.c score).
+func (g *RogueGame) scoreLines(topTen []ScoreEnt, ins int) ([]string, int) {
 	label := "Rogueists"
 	if g.AllScore {
 		label = "Scores"
 	}
+
 	lines := []string{
 		fmt.Sprintf("Top Ten %s:", label),
 		"   Score Name",
 	}
 	highlight := -1
+
 	for i := range topTen {
 		scp := &topTen[i]
 		if scp.Score == 0 {
 			break
 		}
+
 		line := fmt.Sprintf("%2d %5d %s: %s on level %d", i+1,
-			scp.Score, scp.Name, scoreReasons[scp.Flags], scp.Level)
+			scp.Score, scp.Name, g.data.scoreReasons[scp.Flags], scp.Level)
 		if scp.Flags == 0 || scp.Flags == 3 {
-			line += fmt.Sprintf(" by %s", g.killname(scp.Monster, true))
+			line += " by " + g.killname(scp.Monster, true)
 		}
+
 		line += "."
+
 		if i == ins {
 			highlight = len(lines)
 		}
+
 		lines = append(lines, line)
 	}
 
-	if g.scr != nil && g.scr.term != nil {
+	return lines, highlight
+}
+
+// showScores prints the scoreboard on the screen when there is one,
+// else to standard output (rip.c score).
+func (g *RogueGame) showScores(lines []string, highlight int) {
+	if g.scr == nil || g.scr.term == nil {
+		for _, line := range lines {
+			_, _ = fmt.Fprintln(os.Stdout, line) // CLI output
+		}
+
+		return
+	}
+
 	g.clear()
+
 	for i, line := range lines {
 		if i == highlight {
 			g.standout()
 		}
+
 		g.mvaddstr(i, 0, line)
+
 		if i == highlight {
 			g.standend()
 		}
 	}
-		g.refresh()
-	} else {
-		for _, line := range lines {
-			fmt.Println(line)
-		}
-	}
 
-	// Update the list file
+	g.refresh()
-	if ins >= 0 {
-		g.wrScore(topTen)
-	}
 }
 
 // ShowScores implements the -s command line option: print the scoreboard

game/screen.go

@@ -16,6 +16,9 @@ type Terminal interface {
 	// ReadChar blocks for the next key, translated to Rogue's input bytes
 	// (arrows become hjkl, control keys their C0 codes).
 	ReadChar() byte
+	// Fini restores the device to its pre-game state (curses endwin). The
+	// game calls it on its way out, since one game run is one process.
+	Fini()
 }
 
 // cell is one screen position.
@@ -37,26 +40,28 @@ type Window struct {
 func NewWindow(rows, cols int) *Window {
 	w := &Window{rows: rows, cols: cols, cells: make([]cell, rows*cols)}
 	w.Clear()
+
 	return w
 }
 
-func (w *Window) at(y, x int) *cell { return &w.cells[y*w.cols+x] }
-
 // Move positions the cursor (curses move/wmove).
 func (w *Window) Move(y, x int) { w.cy, w.cx = y, x }
 
 // GetYX reports the cursor position (curses getyx).
-func (w *Window) GetYX() (y, x int) { return w.cy, w.cx }
+func (w *Window) GetYX() (int, int) { return w.cy, w.cx }
 
 // AddCh writes a character at the cursor and advances it (curses addch).
 func (w *Window) AddCh(ch byte) {
 	if ch == '\n' {
 		w.cy, w.cx = w.cy+1, 0
+
 		return
 	}
+
 	if w.cy < 0 || w.cy >= w.rows || w.cx < 0 || w.cx >= w.cols {
 		return
 	}
+
 	*w.at(w.cy, w.cx) = cell{ch: ch, standout: w.standout}
 	if w.cx++; w.cx >= w.cols {
 		w.cx = 0
@@ -68,7 +73,7 @@ func (w *Window) AddCh(ch byte) {
 
 // AddStr writes a string at the cursor (curses addstr).
 func (w *Window) AddStr(s string) {
-	for i := 0; i < len(s); i++ {
+	for i := range len(s) {
 		w.AddCh(s[i])
 	}
 }
@@ -85,15 +90,15 @@ func (w *Window) MvAddStr(y, x int, s string) {
 	w.AddStr(s)
 }
 
-// Printw writes formatted text at the cursor (curses printw).
+// Printwf writes formatted text at the cursor (curses printw).
-func (w *Window) Printw(format string, a ...any) {
+func (w *Window) Printwf(format string, a ...any) {
 	w.AddStr(fmt.Sprintf(format, a...))
 }
 
-// MvPrintw moves then writes formatted text (curses mvprintw).
+// MvPrintwf moves then writes formatted text (curses mvprintw).
-func (w *Window) MvPrintw(y, x int, format string, a ...any) {
+func (w *Window) MvPrintwf(y, x int, format string, a ...any) {
 	w.Move(y, x)
-	w.Printw(format, a...)
+	w.Printwf(format, a...)
 }
 
 // Inch returns the character under the cursor (curses inch, sans
@@ -102,12 +107,14 @@ func (w *Window) Inch() byte {
 	if w.cy < 0 || w.cy >= w.rows || w.cx < 0 || w.cx >= w.cols {
 		return ' '
 	}
+
 	return w.at(w.cy, w.cx).ch
 }
 
 // MvInch moves then reads (curses mvinch).
 func (w *Window) MvInch(y, x int) byte {
 	w.Move(y, x)
+
 	return w.Inch()
 }
 
@@ -120,6 +127,7 @@ func (w *Window) Clear() {
 	for i := range w.cells {
 		w.cells[i] = cell{ch: ' '}
 	}
+
 	w.cy, w.cx = 0, 0
 }
 
@@ -128,6 +136,7 @@ func (w *Window) Clrtoeol() {
 	if w.cy < 0 || w.cy >= w.rows {
 		return
 	}
+
 	for x := w.cx; x < w.cols; x++ {
 		*w.at(w.cy, x) = cell{ch: ' '}
 	}
@@ -138,13 +147,14 @@ func (w *Window) CopyFrom(src *Window) {
 	copy(w.cells, src.cells)
 }
 
-// Size reports the window dimensions.
+// Size reports the window dimensions as rows, columns.
-func (w *Window) Size() (rows, cols int) { return w.rows, w.cols }
+func (w *Window) Size() (int, int) { return w.rows, w.cols }
 
 // CellAt reports the character and standout attribute at a position; used
 // by Terminal implementations to render the window.
-func (w *Window) CellAt(y, x int) (ch byte, standout bool) {
+func (w *Window) CellAt(y, x int) (byte, bool) {
 	c := w.at(y, x)
+
 	return c.ch, c.standout
 }
 
@@ -155,6 +165,7 @@ func (w *Window) Contents() []byte {
 	for i, c := range w.cells {
 		out[i] = c.ch
 	}
+
 	return out
 }
 
@@ -171,12 +182,16 @@ func (w *Window) SetContents(data []byte) {
 // victory screens.
 func (w *Window) Line(y int) string {
 	buf := make([]byte, w.cols)
-	for x := 0; x < w.cols; x++ {
+	for x := range w.cols {
 		buf[x] = w.at(y, x).ch
 	}
+
 	return string(buf)
 }
 
+// at addresses the cell at (y, x) in the backing array.
+func (w *Window) at(y, x int) *cell { return &w.cells[y*w.cols+x] }
+
 // Screen bundles the two windows the game draws on with the device that
 // shows them.
 type Screen struct {
@@ -201,6 +216,13 @@ func (s *Screen) Refresh() {
 	}
 }
 
+// Fini restores the terminal device, if there is one (curses endwin).
+func (s *Screen) Fini() {
+	if s.term != nil {
+		s.term.Fini()
+	}
+}
+
 // RefreshWin pushes an arbitrary window to the device (curses wrefresh).
 func (s *Screen) RefreshWin(w *Window) {
 	if s.term != nil {
@@ -217,7 +239,7 @@ func (g *RogueGame) mvaddch(y, x int, c byte) { g.scr.Std.MvAddCh(y, x, c) }
 func (g *RogueGame) mvaddstr(y, x int, s string) {
 	g.scr.Std.MvAddStr(y, x, s)
 }
-func (g *RogueGame) printw(f string, a ...any) { g.scr.Std.Printw(f, a...) }
+func (g *RogueGame) printw(f string, a ...any) { g.scr.Std.Printwf(f, a...) }
 func (g *RogueGame) inch() byte                { return g.scr.Std.Inch() }
 func (g *RogueGame) mvinch(y, x int) byte      { return g.scr.Std.MvInch(y, x) }
 func (g *RogueGame) standout()                 { g.scr.Std.Standout(true) }

game/scrolls.go

@@ -2,30 +2,23 @@ package game
 
 // scrolls.c — read a scroll and let it happen.
 
-// idType maps identify scrolls to the kind of item they identify
-// (scrolls.c static id_type).
-var idType = [ScrollIdentifyRingOrStick + 1]ObjectKind{
-	ScrollIdentifyPotion:      KindPotion,
-	ScrollIdentifyScroll:      KindScroll,
-	ScrollIdentifyWeapon:      KindWeapon,
-	ScrollIdentifyArmor:       KindArmor,
-	ScrollIdentifyRingOrStick: KindRingOrStick,
-}
-
 // readScroll reads a scroll from the pack and does the appropriate thing
 // (scrolls.c read_scroll).
 func (g *RogueGame) readScroll() {
 	p := &g.Player
-	obj := g.getItem("read", KindScroll)
+
-	if obj == nil {
+	obj, ok := g.promptPackItem("read", KindScroll)
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindScroll {
 		if !g.Options.Terse {
 			g.msg("there is nothing on it to read")
 		} else {
 			g.msg("nothing to read")
 		}
+
 		return
 	}
 	// Calculate the effect it has on the poor guy.
@@ -35,61 +28,117 @@ func (g *RogueGame) readScroll() {
 	// Get rid of the thing
 	g.leavePack(obj, false, false)
 
-	switch obj.ScrollKind() {
+	if h := g.data.readHandlers[obj.ScrollKind()]; h != nil {
-	case ScrollMonsterConfusion:
+		h(g, obj)
+	}
+
+	g.look(true) // put the result of the scroll on the screen
+	g.status()
+
+	g.callIt(&g.Items.Scrolls[obj.Which])
+}
+
+// The per-scroll effect handlers, dispatched through
+// gameData.readHandlers. Each is one case of the C read_scroll switch.
+
+func (g *RogueGame) readMonsterConfusion(*Object) {
 	// Scroll of monster confusion.  Give him that power.
-		p.Flags.Set(CanConfuse)
+	g.Player.Flags.Set(CanConfuse)
 	g.msg("your hands begin to glow %s", g.pickColor("red"))
-	case ScrollEnchantArmor:
+}
+
+func (g *RogueGame) readEnchantArmor(*Object) {
+	p := &g.Player
 	if p.CurArmor != nil {
 		p.CurArmor.ArmorClass--
 		p.CurArmor.Flags.Clear(Cursed)
 		g.msg("your armor glows %s for a moment", g.pickColor("silver"))
 	}
-	case ScrollHoldMonster:
+}
+
+func (g *RogueGame) readHoldMonster(*Object) {
 	// Hold monster scroll.  Stop all monsters within two spaces from
 	// chasing after the hero.
-		held := 0
+	held := g.holdMonstersNear()
-		for x := p.Pos.X - 2; x <= p.Pos.X+2; x++ {
+
-			if x < 0 || x >= NumCols {
-				continue
-			}
-			for y := p.Pos.Y - 2; y <= p.Pos.Y+2; y++ {
-				if y < 0 || y > NumLines-1 {
-					continue
-				}
-				if mp := g.Level.MonsterAt(y, x); mp != nil && mp.On(Awake) {
-					mp.Flags.Clear(Awake)
-					mp.Flags.Set(Held)
-					held++
-				}
-			}
-		}
 	if held > 0 {
-			g.addmsg("the monster")
+		g.addmsgf("the monster")
+
 		if held > 1 {
-				g.addmsg("s around you")
+			g.addmsgf("s around you")
 		}
-			g.addmsg(" freeze")
+
+		g.addmsgf(" freeze")
+
 		if held == 1 {
-				g.addmsg("s")
+			g.addmsgf("s")
 		}
+
 		g.endmsg()
 		g.Items.Scrolls[ScrollHoldMonster].Know = true
 	} else {
 		g.msg("you feel a strange sense of loss")
 	}
-	case ScrollSleep:
+}
+
+// holdMonstersNear freezes every awake monster within two spaces of the
+// hero and reports how many froze (the scan of the C S_HOLD case).
+func (g *RogueGame) holdMonstersNear() int {
+	p := &g.Player
+	held := 0
+
+	for x := p.Pos.X - 2; x <= p.Pos.X+2; x++ {
+		if x < 0 || x >= NumCols {
+			continue
+		}
+
+		for y := p.Pos.Y - 2; y <= p.Pos.Y+2; y++ {
+			if y < 0 || y > NumLines-1 {
+				continue
+			}
+
+			if mp := g.Level.MonsterAt(y, x); mp != nil && mp.On(Awake) {
+				mp.Flags.Clear(Awake)
+				mp.Flags.Set(Held)
+
+				held++
+			}
+		}
+	}
+
+	return held
+}
+
+func (g *RogueGame) readSleep(*Object) {
 	// Scroll which makes you fall asleep
 	g.Items.Scrolls[ScrollSleep].Know = true
 	g.NoCommand += g.rnd(g.spread(5)) + 4 // SLEEPTIME
-		p.Flags.Clear(Awake)
+
+	g.Player.Flags.Clear(Awake)
 	g.msg("you fall asleep")
-	case ScrollCreateMonster:
+}
+
+func (g *RogueGame) readCreateMonster(*Object) {
 	// Create a monster: first look in a circle around him, next try
 	// his room, otherwise give up
+	mp, ok := g.createMonsterSpot()
+	if !ok {
+		g.msg("you hear a faint cry of anguish in the distance")
+	} else {
+		tp := &Monster{}
+		g.newMonster(tp, g.randMonster(false), mp)
+	}
+}
+
+// createMonsterSpot reservoir-samples a legal spot around the hero for a
+// created monster; ok is false when every neighbor is blocked (the scan
+// of the C S_CREATE case).
+func (g *RogueGame) createMonsterSpot() (Coord, bool) {
+	p := &g.Player
 	i := 0
+
 	var mp Coord
+
 	for y := p.Pos.Y - 1; y <= p.Pos.Y+1; y++ {
 		for x := p.Pos.X - 1; x <= p.Pos.X+1; x++ {
 			// Don't put a monster on top of the player.
@@ -99,68 +148,75 @@ func (g *RogueGame) readScroll() {
 			// Or anything else nasty
 			if ch := g.Level.VisibleChar(y, x); stepOk(ch) {
 				if ch == Scroll {
-						if fo := g.findObj(y, x); fo != nil && fo.ScrollKind() == ScrollScareMonster {
+					if fo := g.Level.ObjectAt(y, x); fo != nil && fo.ScrollKind() == ScrollScareMonster {
 						continue
 					}
 				}
+
 				if i++; g.rnd(i) == 0 {
 					mp = Coord{Y: y, X: x}
 				}
 			}
 		}
 	}
-		if i == 0 {
+
-			g.msg("you hear a faint cry of anguish in the distance")
+	return mp, i != 0
-		} else {
-			tp := &Monster{}
-			g.newMonster(tp, g.randMonster(false), mp)
 }
-	case ScrollIdentifyPotion, ScrollIdentifyScroll, ScrollIdentifyWeapon, ScrollIdentifyArmor, ScrollIdentifyRingOrStick:
+
+func (g *RogueGame) readIdentify(obj *Object) {
 	// Identify, let him figure something out
 	g.Items.Scrolls[obj.Which].Know = true
 	g.msg("this scroll is an %s scroll", g.Items.Scrolls[obj.Which].Name)
-		g.whatis(true, idType[obj.ScrollKind()])
+	g.whatis(true, g.data.idType[obj.ScrollKind()])
-	case ScrollMagicMapping:
+}
+
+func (g *RogueGame) readMagicMapping(*Object) {
 	// Scroll of magic mapping.
 	g.Items.Scrolls[ScrollMagicMapping].Know = true
 	g.msg("oh, now this scroll has a map on it")
 	// take all the things we want to keep hidden out of the window
 	for y := 1; y < NumLines-1; y++ {
-			for x := 0; x < NumCols; x++ {
+		for x := range NumCols {
+			g.revealSpot(y, x)
+		}
+	}
+}
+
+// revealSpot uncovers one map cell for magic mapping and draws it (the
+// loop body of the C SCR_MAP case).
+func (g *RogueGame) revealSpot(y, x int) {
 	pp := g.Level.At(y, x)
+
+	ch := revealChar(pp)
+	if ch != ' ' {
+		if tp := pp.Monst; tp != nil {
+			tp.OldCh = ch
+			if !g.Player.On(SenseMonsters) {
+				g.mvaddch(y, x, ch)
+			}
+		} else {
+			g.mvaddch(y, x, ch)
+		}
+	}
+}
+
+// revealChar decides what magic mapping shows at a cell, making secret
+// doors, hidden passages, and hidden traps real as a side effect; ' '
+// means show nothing (the switch of the C SCR_MAP loop).
+func revealChar(pp *Place) byte {
 	ch := pp.Ch
 	pass := false
+
 	switch ch {
 	case Door, Stairs:
 	case '-', '|':
-					if !pp.Flags.Has(FReal) {
+		ch = revealWall(pp)
-						ch = Door
-						pp.Ch = Door
-						pp.Flags.Set(FReal)
-					}
 	case ' ':
-					if pp.Flags.Has(FReal) {
+		pass = revealSolid(pp)
-						// def: hidden things in walls stay hidden
-						if pp.Flags.Has(FPassage) {
-							pass = true
-						} else {
-							ch = ' '
-						}
-					} else {
-						pp.Flags.Set(FReal)
-						pp.Ch = Passage
-						pass = true
-					}
 	case Passage:
 		pass = true
 	case Floor:
-					if pp.Flags.Has(FReal) {
+		ch = revealFloor(pp)
-						ch = ' '
-					} else {
-						ch = Trap
-						pp.Ch = Trap
-						pp.Flags.Set(FSeen | FReal)
-					}
 	default:
 		if pp.Flags.Has(FPassage) {
 			pass = true
@@ -168,78 +224,138 @@ func (g *RogueGame) readScroll() {
 			ch = ' '
 		}
 	}
+
 	if pass {
 		if !pp.Flags.Has(FReal) {
 			pp.Ch = Passage
 		}
+
 		pp.Flags.Set(FSeen | FReal)
+
 		ch = Passage
 	}
-				if ch != ' ' {
+
-					if tp := pp.Monst; tp != nil {
+	return ch
-						tp.OldCh = ch
-						if !p.On(SenseMonsters) {
-							g.mvaddch(y, x, ch)
 }
-					} else {
+
-						g.mvaddch(y, x, ch)
+// revealWall handles a wall cell for magic mapping: a secret door
+// becomes a real door (the '-'/'|' arm).
+func revealWall(pp *Place) byte {
+	if !pp.Flags.Has(FReal) {
+		pp.Ch = Door
+		pp.Flags.Set(FReal)
+
+		return Door
 	}
+
+	return pp.Ch
 }
+
+// revealSolid handles a blank cell for magic mapping, reporting whether
+// it is passage: hidden passages become real; hidden things in walls
+// stay hidden (the ' ' arm).
+func revealSolid(pp *Place) bool {
+	if pp.Flags.Has(FReal) {
+		return pp.Flags.Has(FPassage)
 	}
+
+	pp.Flags.Set(FReal)
+	pp.Ch = Passage
+
+	return true
 }
-	case ScrollFoodDetection:
+
+// revealFloor handles a floor cell for magic mapping: a hidden trap
+// becomes a real, seen trap; real floor shows nothing (the FLOOR arm).
+func revealFloor(pp *Place) byte {
+	if pp.Flags.Has(FReal) {
+		return ' '
+	}
+
+	pp.Ch = Trap
+	pp.Flags.Set(FSeen | FReal)
+
+	return Trap
+}
+
+func (g *RogueGame) readFoodDetection(*Object) {
 	// Food detection
 	found := false
+
 	g.scr.Hw.Clear()
+
 	for _, fo := range g.Level.Objects {
 		if fo.Kind == KindFood {
 			found = true
+
 			g.scr.Hw.MvAddCh(fo.Pos.Y, fo.Pos.X, Food)
 		}
 	}
+
 	if found {
 		g.Items.Scrolls[ScrollFoodDetection].Know = true
 		g.showWin("Your nose tingles and you smell food.--More--")
 	} else {
 		g.msg("your nose tingles")
 	}
-	case ScrollTeleportation:
+}
+
+func (g *RogueGame) readTeleportation(*Object) {
 	// Scroll of teleportation: make him disappear and reappear
+	p := &g.Player
 	curRoom := p.Room
+
 	g.teleport()
+
 	if curRoom != p.Room {
 		g.Items.Scrolls[ScrollTeleportation].Know = true
 	}
-	case ScrollEnchantWeapon:
+}
+
+func (g *RogueGame) readEnchantWeapon(*Object) {
+	p := &g.Player
 	if p.CurWeapon == nil || p.CurWeapon.Kind != KindWeapon {
 		g.msg("you feel a strange sense of loss")
 	} else {
 		p.CurWeapon.Flags.Clear(Cursed)
+
 		if g.rnd(2) == 0 {
 			p.CurWeapon.HPlus++
 		} else {
 			p.CurWeapon.DPlus++
 		}
+
 		g.msg("your %s glows %s for a moment",
 			g.Items.Weapons[p.CurWeapon.Which].Name, g.pickColor("blue"))
 	}
-	case ScrollScareMonster:
+}
+
+func (g *RogueGame) readScareMonster(*Object) {
 	// Reading it is a mistake and produces laughter at her poor boo
 	// boo.
 	g.msg("you hear maniacal laughter in the distance")
-	case ScrollRemoveCurse:
+}
+
+func (g *RogueGame) readRemoveCurse(*Object) {
+	p := &g.Player
+
 	uncurse(p.CurArmor)
 	uncurse(p.CurWeapon)
 	uncurse(p.CurRing[Left])
 	uncurse(p.CurRing[Right])
 	g.msg("%s", g.chooseStr("you feel in touch with the Universal Onenes",
 		"you feel as if somebody is watching over you"))
-	case ScrollAggravateMonsters:
+}
+
+func (g *RogueGame) readAggravateMonsters(*Object) {
 	// This scroll aggravates all the monsters on the current level
 	// and sets them running towards the hero
 	g.aggravate()
 	g.msg("you hear a high pitched humming noise")
-	case ScrollProtectArmor:
+}
+
+func (g *RogueGame) readProtectArmor(*Object) {
+	p := &g.Player
 	if p.CurArmor != nil {
 		p.CurArmor.Flags.Set(Protected)
 		g.msg("your armor is covered by a shimmering %s shield",
@@ -248,11 +364,6 @@ func (g *RogueGame) readScroll() {
 		g.msg("you feel a strange sense of loss")
 	}
 }
-	g.look(true) // put the result of the scroll on the screen
-	g.status()
-
-	g.callIt(&g.Items.Scrolls[obj.Which])
-}
 
 // uncurse uncurses an item (scrolls.c uncurse).
 func uncurse(obj *Object) {

game/seedcompat_test.go

@@ -0,0 +1,98 @@
+package game
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+// dumpItemTables formats a game's per-seed item appearance tables in the
+// same layout the instrumented C reference prints: the potion colors,
+// scroll names, ring stones, and wand/staff materials, each generated by
+// consuming the RNG in a fixed order during New().
+func dumpItemTables(seed int32, g *RogueGame) string {
+	var b strings.Builder
+
+	fmt.Fprintf(&b, "SEED %d\n", seed)
+
+	fmt.Fprintln(&b, "POTIONS")
+
+	for _, c := range g.Items.PotColors {
+		fmt.Fprintln(&b, c)
+	}
+
+	fmt.Fprintln(&b, "SCROLLS")
+
+	for _, s := range g.Items.ScrNames {
+		fmt.Fprintln(&b, s)
+	}
+
+	fmt.Fprintln(&b, "RINGS")
+
+	for _, s := range g.Items.RingStones {
+		fmt.Fprintln(&b, s)
+	}
+
+	fmt.Fprintln(&b, "STICKS")
+
+	for i := range g.Items.WandType {
+		fmt.Fprintf(&b, "%s %s\n", g.Items.WandType[i], g.Items.WandMade[i])
+	}
+
+	return b.String()
+}
+
+// TestSeedCompatItemTables proves the port's seed-compatibility claim: for
+// the same seed, the Go game generates the exact per-seed item appearance
+// tables as the C reference on modern-rogue. That requires the LCG and its
+// consumption order through the whole init sequence (init_probs →
+// init_player → init_names → init_colors → init_stones → init_materials) to
+// match C byte for byte. The golden is captured from an instrumented build
+// of the C game (testdata/README.md).
+func TestSeedCompatItemTables(t *testing.T) {
+	golden, err := os.ReadFile("testdata/item_tables.golden")
+	if err != nil {
+		t.Fatalf("read golden: %v", err)
+	}
+
+	// These must match the seeds the golden was generated from
+	// (testdata/README.md).
+	seeds := []int32{1, 42, 12345, 99999}
+
+	var got strings.Builder
+
+	for _, seed := range seeds {
+		g := New(Params{Seed: seed, Wizard: true})
+		got.WriteString(dumpItemTables(seed, g))
+	}
+
+	if got.String() != string(golden) {
+		t.Errorf("Go item tables diverge from the C reference at %s",
+			firstDiff(string(golden), got.String()))
+	}
+}
+
+// firstDiff returns a description of the first line where want and got
+// differ, for a readable failure.
+func firstDiff(want, got string) string {
+	wl := strings.Split(want, "\n")
+	gl := strings.Split(got, "\n")
+
+	for i := 0; i < len(wl) || i < len(gl); i++ {
+		w, g := "", ""
+		if i < len(wl) {
+			w = wl[i]
+		}
+
+		if i < len(gl) {
+			g = gl[i]
+		}
+
+		if w != g {
+			return fmt.Sprintf("line %d: C=%q Go=%q", i+1, w, g)
+		}
+	}
+
+	return "no line difference (trailing content?)"
+}

game/sticks.go

@@ -4,25 +4,77 @@ import "fmt"
 
 // sticks.c — zap wands and staffs.
 
+// The two ws_type strings a stick can be made as.
+const (
+	wandName  = "wand"
+	staffName = "staff"
+)
+
 // doZap performs a zap with a wand (sticks.c do_zap).
 func (g *RogueGame) doZap() {
-	p := &g.Player
+	obj, ok := g.promptPackItem("zap with", KindWand)
-	obj := g.getItem("zap with", KindWand)
+	if !ok {
-	if obj == nil {
 		return
 	}
+
 	if obj.Kind != KindWand {
 		g.After = false
 		g.msg("you can't zap with that!")
+
 		return
 	}
+
 	if obj.Charges == 0 {
 		g.msg("nothing happens")
+
 		return
 	}
-	switch obj.WandKind() {
+
-	case WandLight:
+	if h := g.data.zapHandlers[obj.WandKind()]; h != nil {
+		if !h(g, obj) {
+			return // the zap aborted; no charge is used
+		}
+	}
+
+	obj.Charges--
+}
+
+// zapRayMonster walks the zap ray from the hero to the first blocking
+// spot and returns the monster standing there, if any (the shared
+// preamble of the C monster-affecting zap cases).
+func (g *RogueGame) zapRayMonster() *Monster {
+	p := &g.Player
+
+	y := p.Pos.Y
+
+	x := p.Pos.X
+	for stepOk(g.Level.VisibleChar(y, x)) {
+		y += g.Delta.Y
+		x += g.Delta.X
+	}
+
+	return g.Level.MonsterAt(y, x)
+}
+
+// zapVictim is zapRayMonster plus the flytrap release the C code does
+// before the invisibility-family effects.
+func (g *RogueGame) zapVictim() *Monster {
+	tp := g.zapRayMonster()
+	if tp != nil && tp.Type == 'F' {
+		g.Player.Flags.Clear(Held)
+	}
+
+	return tp
+}
+
+// The per-wand effect handlers, dispatched through gameData.zapHandlers.
+// Each is one case of the C do_zap switch; returning false aborts the
+// zap without using a charge.
+
+func (g *RogueGame) zapLight(*Object) bool {
 	// Reddy Kilowatt wand.  Light up the room
+	p := &g.Player
+
 	g.Items.Sticks[WandLight].Know = true
 	if p.Room.Flags.Has(Gone) {
 		g.msg("the corridor glows and then fades")
@@ -30,70 +82,107 @@ func (g *RogueGame) doZap() {
 		p.Room.Flags.Clear(Dark)
 		// Light the room and put the player back up
 		g.enterRoom(p.Pos)
-			g.addmsg("the room is lit")
+		g.addmsgf("the room is lit")
+
 		if !g.Options.Terse {
-				g.addmsg(" by a shimmering %s light", g.pickColor("blue"))
+			g.addmsgf(" by a shimmering %s light", g.pickColor("blue"))
 		}
+
 		g.endmsg()
 	}
-	case WandDrainLife:
+
+	return true
+}
+
+func (g *RogueGame) zapDrainLife(*Object) bool {
 	// take away 1/2 of hero's hit points, then take it away evenly
 	// from the monsters in the room (or next to hero if he is in a
 	// passage)
-		if p.Stats.HP < 2 {
+	if g.Player.Stats.HP < 2 {
 		g.msg("you are too weak to use it")
-			return
+
+		return false
 	}
+
 	g.drain()
-	case WandInvisibility, WandPolymorph, WandTeleportAway, WandTeleportTo, WandCancellation:
+
-		y := p.Pos.Y
+	return true
-		x := p.Pos.X
-		for stepOk(g.Level.VisibleChar(y, x)) {
-			y += g.Delta.Y
-			x += g.Delta.X
 }
-		if tp := g.Level.MonsterAt(y, x); tp != nil {
+
-			monster := tp.Type
+func (g *RogueGame) zapInvisibility(*Object) bool {
-			if monster == 'F' {
+	if tp := g.zapVictim(); tp != nil {
-				p.Flags.Clear(Held)
-			}
-			switch obj.WandKind() {
-			case WandInvisibility:
 		tp.Flags.Set(Invisible)
-				if g.cansee(y, x) {
+
-					g.mvaddch(y, x, tp.OldCh)
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
+			g.mvaddch(tp.Pos.Y, tp.Pos.X, tp.OldCh)
 		}
-			case WandPolymorph:
+	}
+
+	return true
+}
+
+func (g *RogueGame) zapPolymorph(*Object) bool {
+	tp := g.zapVictim()
+	if tp == nil {
+		return true
+	}
+
+	y, x := tp.Pos.Y, tp.Pos.X
+
 	pp := tp.Pack
-				detachMon(&g.Level.Monsters, tp)
+	g.Level.RemoveMonster(tp)
+
 	if g.seeMonst(tp) {
 		g.mvaddch(y, x, g.Level.Char(y, x))
 	}
+
 	oldch := tp.OldCh
 	g.Delta.Y = y
 	g.Delta.X = x
-				monster = byte(g.rnd(26) + 'A')
+	monster := g.randomMonsterLetter()
 	g.newMonster(tp, monster, g.Delta)
+
 	if g.seeMonst(tp) {
 		g.mvaddch(y, x, monster)
 	}
+
 	tp.OldCh = oldch
+
 	tp.Pack = pp
 	if g.seeMonst(tp) {
 		g.Items.Sticks[WandPolymorph].Know = true
 	}
-			case WandCancellation:
+
+	return true
+}
+
+func (g *RogueGame) zapCancellation(*Object) bool {
+	if tp := g.zapVictim(); tp != nil {
 		tp.Flags.Set(Cancelled)
 		tp.Flags.Clear(Invisible | CanConfuse)
+
 		tp.Disguise = tp.Type
 		if g.seeMonst(tp) {
-					g.mvaddch(y, x, tp.Disguise)
+			g.mvaddch(tp.Pos.Y, tp.Pos.X, tp.Disguise)
 		}
-			case WandTeleportAway, WandTeleportTo:
+	}
+
+	return true
+}
+
+func (g *RogueGame) zapTeleport(obj *Object) bool {
+	p := &g.Player
+
+	tp := g.zapVictim()
+	if tp == nil {
+		return true
+	}
+
 	var newPos Coord
+
 	if obj.WandKind() == WandTeleportAway {
 		for {
-						newPos, _ = g.findFloor(nil, 0, true)
+			newPos, _ = g.findFloor(true)
 			if newPos != p.Pos {
 				break
 			}
@@ -102,59 +191,87 @@ func (g *RogueGame) doZap() {
 		newPos.Y = p.Pos.Y + g.Delta.Y
 		newPos.X = p.Pos.X + g.Delta.X
 	}
+
 	tp.Dest = &p.Pos
 	tp.Flags.Set(Awake)
 	g.relocate(tp, newPos)
+
+	return true
 }
-		}
+
-	case WandMagicMissile:
+func (g *RogueGame) zapMagicMissile(*Object) bool {
+	p := &g.Player
+
 	g.Items.Sticks[WandMagicMissile].Know = true
 	bolt := newObject()
 	bolt.Kind = KindGold // C set o_type='*': draws a '*' and is not a weapon
 	bolt.HurlDmg = dice("1x4")
 	bolt.HPlus = 100
 	bolt.DPlus = 1
+
 	bolt.Flags = Missile
 	if p.CurWeapon != nil {
 		bolt.Launch = WeaponKind(p.CurWeapon.Which)
 	}
+
 	g.doMotion(bolt, g.Delta.Y, g.Delta.X)
+
 	if tp := g.Level.MonsterAt(bolt.Pos.Y, bolt.Pos.X); tp != nil &&
 		!g.saveThrow(VsMagic, &tp.Stats) {
 		g.hitMonster(bolt.Pos, bolt)
 	} else if g.Options.Terse {
-			g.msg("missle vanishes")
+		g.msg("missle vanishes") //nolint:misspell // C's spelling, kept faithfully
 	} else {
-			g.msg("the missle vanishes with a puff of smoke")
+		g.msg("the missle vanishes with a puff of smoke") //nolint:misspell // C's spelling
 	}
-	case WandHasteMonster, WandSlowMonster:
+
-		y := p.Pos.Y
+	return true
-		x := p.Pos.X
-		for stepOk(g.Level.VisibleChar(y, x)) {
-			y += g.Delta.Y
-			x += g.Delta.X
 }
-		if tp := g.Level.MonsterAt(y, x); tp != nil {
+
+func (g *RogueGame) zapSpeed(obj *Object) bool {
+	tp := g.zapRayMonster()
+	if tp == nil {
+		return true
+	}
+
 	if obj.WandKind() == WandHasteMonster {
+		hasteTarget(tp)
+	} else {
+		slowTarget(tp)
+	}
+
+	g.Delta.Y = tp.Pos.Y
+	g.Delta.X = tp.Pos.X
+	g.runTo(g.Delta)
+
+	return true
+}
+
+// hasteTarget cancels a slow or applies a haste (the WS_HASTE_M arm of
+// do_zap).
+func hasteTarget(tp *Monster) {
 	if tp.On(Slowed) {
 		tp.Flags.Clear(Slowed)
 	} else {
 		tp.Flags.Set(Hasted)
 	}
-			} else {
+}
+
+// slowTarget cancels a haste or applies a slow (the WS_SLOW_M arm of
+// do_zap).
+func slowTarget(tp *Monster) {
 	if tp.On(Hasted) {
 		tp.Flags.Clear(Hasted)
 	} else {
 		tp.Flags.Set(Slowed)
 	}
+
 	tp.Turn = true
 }
-			g.Delta.Y = y
+
-			g.Delta.X = x
+func (g *RogueGame) zapBolt(obj *Object) bool {
-			g.runto(g.Delta)
-		}
-	case WandLightning, WandFire, WandCold:
 	var name string
+
 	switch obj.WandKind() {
 	case WandLightning:
 		name = "bolt"
@@ -163,11 +280,11 @@ func (g *RogueGame) doZap() {
 	default:
 		name = "ice"
 	}
-		g.fireBolt(p.Pos, &g.Delta, name)
+
+	g.fireBolt(g.Player.Pos, &g.Delta, name)
 	g.Items.Sticks[obj.Which].Know = true
-	case WandNothing:
+
-	}
+	return true
-	obj.Charges--
 }
 
 // drain does the drain-hit-points-from-player schtick (sticks.c drain).
@@ -178,20 +295,24 @@ func (g *RogueGame) drain() {
 	if g.Level.Char(p.Pos.Y, p.Pos.X) == Door {
 		corp = &g.Level.Passages[*g.Level.FlagsAt(p.Pos.Y, p.Pos.X)&FPassNum]
 	}
+
 	inpass := p.Room.Flags.Has(Gone)
+
 	var drainee []*Monster
+
 	for _, mp := range g.Level.Monsters {
-		if mp.Room == p.Room || mp.Room == corp ||
+		if g.drainReaches(mp, corp, inpass) {
-			(inpass && g.Level.Char(mp.Pos.Y, mp.Pos.X) == Door &&
-				&g.Level.Passages[*g.Level.FlagsAt(mp.Pos.Y, mp.Pos.X)&FPassNum] == p.Room) {
 			drainee = append(drainee, mp)
 		}
 	}
+
 	cnt := len(drainee)
 	if cnt == 0 {
 		g.msg("you have a tingling feeling")
+
 		return
 	}
+
 	p.Stats.HP /= 2
 	cnt = p.Stats.HP / cnt
 	// Now zot all of the monsters
@@ -199,11 +320,23 @@ func (g *RogueGame) drain() {
 		if mp.Stats.HP -= cnt; mp.Stats.HP <= 0 {
 			g.killed(mp, g.seeMonst(mp))
 		} else {
-			g.runto(mp.Pos)
+			g.runTo(mp.Pos)
 		}
 	}
 }
 
+// drainReaches reports whether the drain-life wand reaches this monster:
+// the hero's room, the passage behind the door he stands on, or — when
+// he is in a passage — a door of that same passage (the drainee
+// condition of sticks.c drain).
+func (g *RogueGame) drainReaches(mp *Monster, corp *Room, inpass bool) bool {
+	p := &g.Player
+
+	return mp.Room == p.Room || mp.Room == corp ||
+		(inpass && g.Level.Char(mp.Pos.Y, mp.Pos.X) == Door &&
+			&g.Level.Passages[*g.Level.FlagsAt(mp.Pos.Y, mp.Pos.X)&FPassNum] == p.Room)
+}
+
 // fireBolt fires a bolt in a given direction from a specific starting
 // place (sticks.c fire_bolt).
 func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
@@ -217,99 +350,45 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 	bolt.HPlus = 100
 	bolt.DPlus = 0
 	g.Items.Weapons[WeaponFlame].Name = name
-	var dirch byte
+
-	switch dir.Y + dir.X {
+	dirch := boltDirChar(*dir)
-	case 0:
-		dirch = '/'
-	case 1, -1:
-		if dir.Y == 0 {
-			dirch = '-'
-		} else {
-			dirch = '|'
-		}
-	case 2, -2:
-		dirch = '\\'
-	}
 	pos := start
 	hitHero := !fromHero
 	used := false
 	changed := false
+
 	var spotpos []Coord
 	for len(spotpos) < BoltLength && !used {
 		pos.Y += dir.Y
 		pos.X += dir.X
 		spotpos = append(spotpos, pos)
+
 		ch := g.Level.VisibleChar(pos.Y, pos.X)
-		bounce := false
+		if boltBounces(ch, p.Pos, pos) {
-		switch ch {
-		case Door:
-			// this code is necessary if the hero is on a door and he
-			// fires at the wall the door is in, it would otherwise loop
-			// infinitely
-			if p.Pos != pos {
-				bounce = true
-			}
-		case '|', '-', ' ':
-			bounce = true
-		}
-		if bounce {
 			if !changed {
 				hitHero = !hitHero
 			}
+
 			changed = false
 			dir.Y = -dir.Y
 			dir.X = -dir.X
 			spotpos = spotpos[:len(spotpos)-1]
+
 			g.msg("the %s bounces", name)
+
 			continue
 		}
+
 		if tp := g.Level.MonsterAt(pos.Y, pos.X); !hitHero && tp != nil {
 			hitHero = true
 			changed = !changed
-			tp.OldCh = g.Level.Char(pos.Y, pos.X)
+			used = g.boltStrikesMonster(tp, bolt, pos, ch, name, fromHero)
-			if !g.saveThrow(VsMagic, &tp.Stats) {
-				bolt.Pos = pos
-				used = true
-				if tp.Type == 'D' && name == "flame" {
-					g.addmsg("the flame bounces")
-					if !g.Options.Terse {
-						g.addmsg(" off the dragon")
-					}
-					g.endmsg()
-				} else {
-					g.hitMonster(pos, bolt)
-				}
-			} else if ch != 'M' || tp.Disguise == 'M' {
-				if fromHero {
-					g.runto(pos)
-				}
-				if g.Options.Terse {
-					g.msg("%s misses", name)
-				} else {
-					g.msg("the %s whizzes past %s", name, g.setMname(tp))
-				}
-			}
 		} else if hitHero && pos == p.Pos {
 			hitHero = false
 			changed = !changed
-			if !g.save(VsMagic) {
+			used = g.boltStrikesHero(start, name, fromHero)
-				if p.Stats.HP -= g.roll(6, 6); p.Stats.HP <= 0 {
-					if fromHero {
-						g.death('b')
-					} else {
-						g.death(g.Level.MonsterAt(start.Y, start.X).Type)
-					}
-				}
-				used = true
-				if g.Options.Terse {
-					g.msg("the %s hits", name)
-				} else {
-					g.msg("you are hit by the %s", name)
-				}
-			} else {
-				g.msg("the %s whizzes by you", name)
-			}
 		}
+
 		g.mvaddch(pos.Y, pos.X, dirch)
 		g.refresh()
 	}
@@ -319,13 +398,112 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 	}
 }
 
+// boltDirChar picks the character a traveling bolt is drawn with for its
+// direction (the dirch switch of sticks.c fire_bolt).
+func boltDirChar(dir Coord) byte {
+	switch dir.Y + dir.X {
+	case 0:
+		return '/'
+	case 1, -1:
+		if dir.Y == 0 {
+			return '-'
+		}
+
+		return '|'
+	case 2, -2:
+		return '\\'
+	}
+
+	return 0 // unreachable for the eight legal directions, as in C
+}
+
+// boltBounces reports whether a bolt bounces off this spot: walls, and
+// any door except the one the hero stands on (which would otherwise loop
+// infinitely, per the C comment in fire_bolt).
+func boltBounces(ch byte, heroPos, pos Coord) bool {
+	switch ch {
+	case Door:
+		return heroPos != pos
+	case '|', '-', ' ':
+		return true
+	}
+
+	return false
+}
+
+// boltStrikesMonster resolves a bolt arriving on a monster's square (the
+// monster arm of the fire_bolt loop). It reports whether the bolt was
+// used up.
+func (g *RogueGame) boltStrikesMonster(tp *Monster, bolt *Object, pos Coord, ch byte, name string, fromHero bool) bool {
+	tp.OldCh = g.Level.Char(pos.Y, pos.X)
+	if !g.saveThrow(VsMagic, &tp.Stats) {
+		bolt.Pos = pos
+
+		if tp.Type == 'D' && name == "flame" {
+			g.addmsgf("the flame bounces")
+
+			if !g.Options.Terse {
+				g.addmsgf(" off the dragon")
+			}
+
+			g.endmsg()
+		} else {
+			g.hitMonster(pos, bolt)
+		}
+
+		return true
+	}
+
+	if ch != 'M' || tp.Disguise == 'M' {
+		if fromHero {
+			g.runTo(pos)
+		}
+
+		if g.Options.Terse {
+			g.msg("%s misses", name)
+		} else {
+			g.msg("the %s whizzes past %s", name, g.setMname(tp))
+		}
+	}
+
+	return false
+}
+
+// boltStrikesHero resolves a bolt arriving on the hero (the hero arm of
+// the fire_bolt loop). It reports whether the bolt was used up.
+func (g *RogueGame) boltStrikesHero(start Coord, name string, fromHero bool) bool {
+	p := &g.Player
+	if g.save(VsMagic) {
+		g.msg("the %s whizzes by you", name)
+
+		return false
+	}
+
+	if p.Stats.HP -= g.roll(6, 6); p.Stats.HP <= 0 {
+		if fromHero {
+			g.death('b')
+		} else {
+			g.death(g.Level.MonsterAt(start.Y, start.X).Type)
+		}
+	}
+
+	if g.Options.Terse {
+		g.msg("the %s hits", name)
+	} else {
+		g.msg("you are hit by the %s", name)
+	}
+
+	return true
+}
+
 // fixStick sets up a new wand or staff (sticks.c fix_stick).
 func (g *RogueGame) fixStick(cur *Object) {
-	if g.Items.WandType[cur.Which] == "staff" {
+	if g.Items.WandType[cur.Which] == staffName {
 		cur.Damage = dice("2x3")
 	} else {
 		cur.Damage = dice("1x1")
 	}
+
 	cur.HurlDmg = dice("1x1")
 
 	switch cur.WandKind() {
@@ -342,8 +520,10 @@ func chargeStr(g *RogueGame, obj *Object) string {
 	if !obj.Flags.Has(Known) {
 		return ""
 	}
+
 	if g.Options.Terse {
 		return fmt.Sprintf(" [%d]", obj.Charges)
 	}
+
 	return fmt.Sprintf(" [%d charges]", obj.Charges)
 }

game/tables.go

@@ -1,15 +1,174 @@
 package game
 
-// This file is the immutable data from extern.c and init.c: tables that are
+// tables.go — the static data tables the C game kept as file-scope globals
-// never written after program start. Per-game mutable copies (the ObjInfo
+// (extern.c, init.c, and assorted per-file statics). The port gathers them
-// tables, whose probabilities are re-summed and whose Know/Guess fields
+// into gameData: every RogueGame carries its own copy, so the package holds
-// change during play) are cloned into RogueGame.Items by NewGame.
+// no package-level state. Per-game mutable copies (the ObjInfo tables,
+// whose probabilities are re-summed and whose Know/Guess fields change
+// during play) are cloned into RogueGame.Items by NewGame.
 
+// helpEntry is rogue.h struct h_list.
+type helpEntry struct {
+	Ch    byte
+	Desc  string
+	Print bool
+}
+
+// gameData is the bundle of static tables, built by newGameData and hung on
+// RogueGame as g.data. Nothing in it mutates during play: the one table the
+// C code writes to (the venus flytrap damage hack) operates on the game's
+// Monsters copy, not on this template.
+type gameData struct {
 	// initStats is the C INIT_STATS: the player's starting statistics.
-var initStats = Stats{Str: 16, Exp: 0, Lvl: 1, ArmorClass: 10, HP: 12, Dmg: dice("1x4"), MaxHP: 12}
+	initStats Stats
 
 	// aClass is extern.c a_class[]: armor class for each armor type.
-var aClass = [NumArmorTypes]int{
+	aClass [NumArmorTypes]int
+
+	// eLevels is extern.c e_levels[]: experience thresholds per level; the
+	// zero terminates the table as in C.
+	eLevels []int
+
+	// trName is extern.c tr_name[]: names of the traps.
+	trName [NumTrapTypes]string
+
+	// invTName is extern.c inv_t_name[]: the inventory style names.
+	invTName []string
+
+	// monsterTable is extern.c monsters[26]: all monster kinds, indexed by
+	// letter - 'A'. Monster strength (XX in C) is always 10; HP (___ in C)
+	// is rolled from the level at creation time.
+	monsterTable [26]MonsterKind
+
+	// Base ObjInfo tables (extern.c). These are templates: NewGame copies
+	// them into ItemLore before initProbs converts Prob to cumulative form.
+	baseThings   [NumThings]ObjInfo
+	baseArmInfo  [NumArmorTypes]ObjInfo
+	basePotInfo  [NumPotionTypes]ObjInfo
+	baseRingInfo [NumRingTypes]ObjInfo
+	baseScrInfo  [NumScrollTypes]ObjInfo
+	baseWeapInfo [NumWeaponTypes + 1]ObjInfo
+	baseWsInfo   [NumWandTypes]ObjInfo
+
+	// rainbow is init.c rainbow[]: the possible potion colors.
+	rainbow []string
+
+	// sylls is init.c sylls[]: syllables for generated scroll names.
+	sylls []string
+
+	// stoneTable is init.c stones[]: ring stones and their worth.
+	stoneTable []Stone
+
+	// woods is init.c wood[]: what staffs are made of.
+	woods []string
+
+	// metals is init.c metal[]: what wands are made of.
+	metals []string
+
+	// helpStr is extern.c helpstr[]: the '?' command help text.
+	helpStr []helpEntry
+
+	// hNames are the strings for hitting; the first four are used when the
+	// player strikes, the second four for monsters (fight.c h_names).
+	hNames [8]string
+
+	// mNames are the strings for missing (fight.c m_names).
+	mNames [8]string
+
+	// strPlus adjusts hit probabilities due to strength (fight.c str_plus).
+	strPlus [32]int
+
+	// addDam adjusts damage done due to strength (fight.c add_dam).
+	addDam [32]int
+
+	// lvlMons and wandMons list monsters in rough order of vorpalness;
+	// zero entries in wandMons never wander (monsters.c).
+	lvlMons  [26]byte
+	wandMons [26]byte
+
+	// ringUses is the rings.c ring_eat static uses[] table: how much food
+	// each ring type uses up per turn (negative = a 1-in-n chance of 1).
+	ringUses [NumRingTypes]int
+
+	// initWeaps is the weapons.c init_dam[] table.
+	initWeaps [NumWeaponTypes]weaponSetup
+
+	// pActions is potions.c p_actions[]. The P_SEEINVIS message is dynamic
+	// (it names the fruit) and is computed in applyPotionFuse.
+	pActions [NumPotionTypes]pact
+
+	// idType maps identify scrolls to the kind of item they identify
+	// (scrolls.c static id_type).
+	idType [ScrollIdentifyRingOrStick + 1]ObjectKind
+
+	// rdesConn is the hardcoded 3x3 room adjacency matrix from
+	// passages.c do_passages.
+	rdesConn [MaxRooms][MaxRooms]bool
+
+	// thingList is misc.c rnd_thing()'s static table.
+	thingList []byte
+
+	// identList is command.c's static ident_list.
+	identList []helpEntry
+
+	// hungerStateName is io.c state_name[].
+	hungerStateName [4]string
+
+	// ripArt is the rip.c rip[] tombstone art.
+	ripArt []string
+
+	// killnameTable is the rip.c nlist[]: special death causes.
+	killnameTable []helpEntry
+
+	// scoreReasons is the rip.c reason[] scoreboard strings.
+	scoreReasons [4]string
+
+	// quaffHandlers dispatches each potion kind to its effect method:
+	// the cases of the potions.c quaff switch. The bool is trip — was
+	// the hero hallucinating when the potion went down.
+	quaffHandlers [NumPotionTypes]func(g *RogueGame, trip bool)
+
+	// readHandlers dispatches each scroll kind to its effect method:
+	// the cases of the scrolls.c read_scroll switch. The handler gets
+	// the scroll being read (the identify family needs its subtype).
+	readHandlers [NumScrollTypes]func(g *RogueGame, obj *Object)
+
+	// zapHandlers dispatches each wand kind to its effect method: the
+	// cases of the sticks.c do_zap switch. A false return aborts the
+	// zap without using a charge (drain life on a too-weak hero).
+	zapHandlers [NumWandTypes]func(g *RogueGame, obj *Object) bool
+
+	// hitHandlers dispatches a monster's special power when its hit
+	// lands, indexed by monster letter - 'A': the cases of the fight.c
+	// attack switch. A true return means the monster removed itself.
+	hitHandlers [26]func(g *RogueGame, mp *Monster, mname string) bool
+
+	// commandHandlers dispatches the ordinary command keys: the simple
+	// cases of the big command.c switch. Keys that re-dispatch (runs,
+	// fight, repeat, move-on) and wizard keys stay in dispatchKey.
+	commandHandlers map[byte]func(g *RogueGame)
+
+	// trapHandlers dispatches each sprung trap to its effect method:
+	// the cases of the move.c be_trapped switch.
+	trapHandlers [NumTrapTypes]func(g *RogueGame, tc Coord)
+
+	// daemonHandlers dispatches DaemonIDs to their callbacks: the C
+	// d_func function pointers (daemons.c / daemon.c).
+	daemonHandlers [DTurnSee + 1]func(g *RogueGame, arg int)
+}
+
+// ripWall is the repeated blank wall line of the tombstone art.
+const ripWall = "                  |                  |"
+
+// newGameData builds the static tables. Each game gets a fresh copy, which
+// keeps the package free of globals.
+//
+//nolint:funlen,maintidx // a single composite literal holding every C data table
+func newGameData() *gameData {
+	return &gameData{
+		initStats: Stats{Str: 16, Exp: 0, Lvl: 1, ArmorClass: 10, HP: 12, Dmg: dice("1x4"), MaxHP: 12},
+
+		aClass: [NumArmorTypes]int{
 			8, // LEATHER
 			7, // RING_MAIL
 			7, // STUDDED_LEATHER
@@ -18,17 +177,14 @@ var aClass = [NumArmorTypes]int{
 			4, // SPLINT_MAIL
 			4, // BANDED_MAIL
 			3, // PLATE_MAIL
-}
+		},
 
-// eLevels is extern.c e_levels[]: experience thresholds per level; the
+		eLevels: []int{
-// zero terminates the table as in C.
-var eLevels = []int{
 			10, 20, 40, 80, 160, 320, 640, 1300, 2600, 5200, 13000, 26000,
 			50000, 100000, 200000, 400000, 800000, 2000000, 4000000, 8000000, 0,
-}
+		},
 
-// trName is extern.c tr_name[]: names of the traps.
+		trName: [NumTrapTypes]string{
-var trName = [NumTrapTypes]string{
 			"a trapdoor",
 			"an arrow trap",
 			"a sleeping gas trap",
@@ -37,15 +193,11 @@ var trName = [NumTrapTypes]string{
 			"a poison dart trap",
 			"a rust trap",
 			"a mysterious trap",
-}
+		},
 
-// invTName is extern.c inv_t_name[]: the inventory style names.
+		invTName: []string{"Overwrite", "Slow", "Clear"},
-var invTName = []string{"Overwrite", "Slow", "Clear"}
 
-// monsterTable is extern.c monsters[26]: all monster kinds, indexed by
+		monsterTable: [26]MonsterKind{
-// letter - 'A'. Monster strength (XX in C) is always 10; HP (___ in C) is
-// rolled from the level at creation time.
-var monsterTable = [26]MonsterKind{
 			/* Name             CARRY  FLAGS                          str exp  lvl arm hp  dmg */
 			{"aquator", 0, Mean, Stats{10, 20, 5, 2, 1, dice("0x0/0x0"), 0}},
 			{"bat", 0, Flying, Stats{10, 1, 1, 3, 1, dice("1x2"), 0}},
@@ -73,12 +225,9 @@ var monsterTable = [26]MonsterKind{
 			{"xeroc", 30, 0, Stats{10, 100, 7, 7, 1, dice("4x4"), 0}},
 			{"yeti", 30, 0, Stats{10, 50, 4, 6, 1, dice("1x6/1x6"), 0}},
 			{"zombie", 0, Mean, Stats{10, 6, 2, 8, 1, dice("1x8"), 0}},
-}
+		},
 
-// Base ObjInfo tables (extern.c). These are templates: NewGame copies them
+		baseThings: [NumThings]ObjInfo{
-// into ItemLore before initProbs converts Prob to cumulative form.
-
-var baseThings = [NumThings]ObjInfo{
 			{Prob: 26}, // potion
 			{Prob: 36}, // scroll
 			{Prob: 16}, // food
@@ -86,9 +235,9 @@ var baseThings = [NumThings]ObjInfo{
 			{Prob: 7},  // armor
 			{Prob: 4},  // ring
 			{Prob: 4},  // stick
-}
+		},
 
-var baseArmInfo = [NumArmorTypes]ObjInfo{
+		baseArmInfo: [NumArmorTypes]ObjInfo{
 			{Name: "leather armor", Prob: 20, Worth: 20},
 			{Name: "ring mail", Prob: 15, Worth: 25},
 			{Name: "studded leather armor", Prob: 15, Worth: 20},
@@ -97,9 +246,9 @@ var baseArmInfo = [NumArmorTypes]ObjInfo{
 			{Name: "splint mail", Prob: 10, Worth: 80},
 			{Name: "banded mail", Prob: 10, Worth: 90},
 			{Name: "plate mail", Prob: 5, Worth: 150},
-}
+		},
 
-var basePotInfo = [NumPotionTypes]ObjInfo{
+		basePotInfo: [NumPotionTypes]ObjInfo{
 			{Name: "confusion", Prob: 7, Worth: 5},
 			{Name: "hallucination", Prob: 8, Worth: 5},
 			{Name: "poison", Prob: 8, Worth: 5},
@@ -114,9 +263,9 @@ var basePotInfo = [NumPotionTypes]ObjInfo{
 			{Name: "restore strength", Prob: 13, Worth: 130},
 			{Name: "blindness", Prob: 5, Worth: 5},
 			{Name: "levitation", Prob: 6, Worth: 75},
-}
+		},
 
-var baseRingInfo = [NumRingTypes]ObjInfo{
+		baseRingInfo: [NumRingTypes]ObjInfo{
 			{Name: "protection", Prob: 9, Worth: 400},
 			{Name: "add strength", Prob: 9, Worth: 400},
 			{Name: "sustain strength", Prob: 5, Worth: 280},
@@ -131,9 +280,9 @@ var baseRingInfo = [NumRingTypes]ObjInfo{
 			{Name: "teleportation", Prob: 5, Worth: 30},
 			{Name: "stealth", Prob: 7, Worth: 470},
 			{Name: "maintain armor", Prob: 5, Worth: 380},
-}
+		},
 
-var baseScrInfo = [NumScrollTypes]ObjInfo{
+		baseScrInfo: [NumScrollTypes]ObjInfo{
 			{Name: "monster confusion", Prob: 7, Worth: 140},
 			{Name: "magic mapping", Prob: 4, Worth: 150},
 			{Name: "hold monster", Prob: 2, Worth: 180},
@@ -152,9 +301,9 @@ var baseScrInfo = [NumScrollTypes]ObjInfo{
 			{Name: "remove curse", Prob: 7, Worth: 105},
 			{Name: "aggravate monsters", Prob: 3, Worth: 20},
 			{Name: "protect armor", Prob: 2, Worth: 250},
-}
+		},
 
-var baseWeapInfo = [NumWeaponTypes + 1]ObjInfo{
+		baseWeapInfo: [NumWeaponTypes + 1]ObjInfo{
 			{Name: "mace", Prob: 11, Worth: 8},
 			{Name: "long sword", Prob: 11, Worth: 15},
 			{Name: "short bow", Prob: 12, Worth: 15},
@@ -165,9 +314,9 @@ var baseWeapInfo = [NumWeaponTypes + 1]ObjInfo{
 			{Name: "shuriken", Prob: 12, Worth: 5},
 			{Name: "spear", Prob: 12, Worth: 5},
 			{}, // DO NOT REMOVE: fake entry for dragon's breath
-}
+		},
 
-var baseWsInfo = [NumWandTypes]ObjInfo{
+		baseWsInfo: [NumWandTypes]ObjInfo{
 			{Name: "light", Prob: 12, Worth: 250},
 			{Name: "invisibility", Prob: 6, Worth: 5},
 			{Name: "lightning", Prob: 3, Worth: 330},
@@ -182,18 +331,17 @@ var baseWsInfo = [NumWandTypes]ObjInfo{
 			{Name: "teleport away", Prob: 6, Worth: 340},
 			{Name: "teleport to", Prob: 6, Worth: 50},
 			{Name: "cancellation", Prob: 5, Worth: 280},
-}
+		},
 
-// rainbow is init.c rainbow[]: the possible potion colors.
+		rainbow: []string{
-var rainbow = []string{
 			"amber", "aquamarine", "black", "blue", "brown", "clear", "crimson",
 			"cyan", "ecru", "gold", "green", "grey", "magenta", "orange", "pink",
 			"plaid", "purple", "red", "silver", "tan", "tangerine", "topaz",
 			"turquoise", "vermilion", "violet", "white", "yellow",
-}
+		},
 
-// sylls is init.c sylls[]: syllables for generated scroll names.
+		//nolint:misspell // "ther" is a C scroll syllable, kept faithfully
-var sylls = []string{
+		sylls: []string{
 			"a", "ab", "ag", "aks", "ala", "an", "app", "arg", "arze", "ash",
 			"bek", "bie", "bit", "bjor", "blu", "bot", "bu", "byt", "comp",
 			"con", "cos", "cre", "dalf", "dan", "den", "do", "e", "eep", "el",
@@ -210,10 +358,9 @@ var sylls = []string{
 			"uni", "ur", "val", "viv", "vly", "vom", "wah", "wed", "werg",
 			"wex", "whon", "wun", "xo", "y", "yot", "yu", "zant", "zeb", "zim",
 			"zok", "zon", "zum",
-}
+		},
 
-// stoneTable is init.c stones[]: ring stones and their worth.
+		stoneTable: []Stone{
-var stoneTable = []Stone{
 			{"agate", 25}, {"alexandrite", 40}, {"amethyst", 50},
 			{"carnelian", 40}, {"diamond", 300}, {"emerald", 300},
 			{"germanium", 225}, {"granite", 5}, {"garnet", 50},
@@ -223,35 +370,25 @@ var stoneTable = []Stone{
 			{"ruby", 350}, {"sapphire", 285}, {"stibotantalite", 200},
 			{"tiger eye", 50}, {"topaz", 60}, {"turquoise", 70},
 			{"taaffeite", 300}, {"zircon", 80},
-}
+		},
 
-// woods is init.c wood[]: what staffs are made of.
+		woods: []string{
-var woods = []string{
 			"avocado wood", "balsa", "bamboo", "banyan", "birch", "cedar",
 			"cherry", "cinnibar", "cypress", "dogwood", "driftwood", "ebony",
 			"elm", "eucalyptus", "fall", "hemlock", "holly", "ironwood",
 			"kukui wood", "mahogany", "manzanita", "maple", "oaken",
 			"persimmon wood", "pecan", "pine", "poplar", "redwood", "rosewood",
 			"spruce", "teak", "walnut", "zebrawood",
-}
+		},
 
-// metals is init.c metal[]: what wands are made of.
+		metals: []string{
-var metals = []string{
 			"aluminum", "beryllium", "bone", "brass", "bronze", "copper",
 			"electrum", "gold", "iron", "lead", "magnesium", "mercury",
 			"nickel", "pewter", "platinum", "steel", "silver", "silicon",
 			"tin", "titanium", "tungsten", "zinc",
-}
+		},
 
-// helpEntry is rogue.h struct h_list.
+		helpStr: []helpEntry{
-type helpEntry struct {
-	Ch    byte
-	Desc  string
-	Print bool
-}
-
-// helpStr is extern.c helpstr[]: the '?' command help text.
-var helpStr = []helpEntry{
 			{'?', "	prints help", true},
 			{'/', "	identify object", true},
 			{'h', "	left", true},
@@ -317,6 +454,401 @@ var helpStr = []helpEntry{
 			{'!', "	shell escape", true},
 			{'F', "<dir>	fight till either of you dies", true},
 			{'v', "	print version number", true},
+		},
+
+		hNames: [8]string{
+			" scored an excellent hit on ",
+			" hit ",
+			" have injured ",
+			" swing and hit ",
+			" scored an excellent hit on ",
+			" hit ",
+			" has injured ",
+			" swings and hits ",
+		},
+
+		mNames: [8]string{
+			" miss",
+			" swing and miss",
+			" barely miss",
+			" don't hit",
+			" misses",
+			" swings and misses",
+			" barely misses",
+			" doesn't hit",
+		},
+
+		strPlus: [32]int{
+			-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+			1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
+		},
+
+		addDam: [32]int{
+			-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3,
+			3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6,
+		},
+
+		lvlMons: [26]byte{
+			'K', 'E', 'B', 'S', 'H', 'I', 'R', 'O', 'Z', 'L', 'C', 'Q', 'A',
+			'N', 'Y', 'F', 'T', 'W', 'P', 'X', 'U', 'M', 'V', 'G', 'J', 'D',
+		},
+
+		wandMons: [26]byte{
+			'K', 'E', 'B', 'S', 'H', 0, 'R', 'O', 'Z', 0, 'C', 'Q', 'A',
+			0, 'Y', 0, 'T', 'W', 'P', 0, 'U', 'M', 'V', 'G', 'J', 0,
+		},
+
+		ringUses: [NumRingTypes]int{
+			1,  // R_PROTECT
+			1,  // R_ADDSTR
+			1,  // R_SUSTSTR
+			-3, // R_SEARCH
+			-5, // R_SEEINVIS
+			0,  // R_NOP
+			0,  // R_AGGR
+			-3, // R_ADDHIT
+			-3, // R_ADDDAM
+			2,  // R_REGEN
+			-2, // R_DIGEST
+			0,  // R_TELEPORT
+			1,  // R_STEALTH
+			1,  // R_SUSTARM
+		},
+
+		initWeaps: [NumWeaponTypes]weaponSetup{
+			{dice("2x4"), dice("1x3"), noWeapon, 0},                    // WeaponMace
+			{dice("3x4"), dice("1x2"), noWeapon, 0},                    // Long sword
+			{dice("1x1"), dice("1x1"), noWeapon, 0},                    // WeaponBow
+			{dice("1x1"), dice("2x3"), WeaponBow, Stackable | Missile}, // WeaponArrow
+			{dice("1x6"), dice("1x4"), noWeapon, Missile},              // WeaponDagger
+			{dice("4x4"), dice("1x2"), noWeapon, 0},                    // 2h sword
+			{dice("1x1"), dice("1x3"), noWeapon, Stackable | Missile},  // WeaponDart
+			{dice("1x2"), dice("2x4"), noWeapon, Stackable | Missile},  // Shuriken
+			{dice("2x3"), dice("1x6"), noWeapon, Missile},              // WeaponSpear
+		},
+
+		pActions: [NumPotionTypes]pact{
+			PotionConfusion: {Confused, DUnconfuse, HuhDuration,
+				"what a tripy feeling!",
+				"wait, what's going on here. Huh? What? Who?"},
+			PotionLSD: {Hallucinating, DComeDown, SeeDuration,
+				"Oh, wow!  Everything seems so cosmic!",
+				"Oh, wow!  Everything seems so cosmic!"},
+			PotionSeeInvisible: {CanSeeInvisible, DUnsee, SeeDuration, "", ""},
+			PotionBlindness: {Blind, DSight, SeeDuration,
+				"oh, bummer!  Everything is dark!  Help!",
+				"a cloak of darkness falls around you"},
+			PotionLevitation: {Levitating, DLand, HealTime,
+				"oh, wow!  You're floating in the air!",
+				"you start to float in the air"},
+		},
+
+		idType: [ScrollIdentifyRingOrStick + 1]ObjectKind{
+			ScrollIdentifyPotion:      KindPotion,
+			ScrollIdentifyScroll:      KindScroll,
+			ScrollIdentifyWeapon:      KindWeapon,
+			ScrollIdentifyArmor:       KindArmor,
+			ScrollIdentifyRingOrStick: KindRingOrStick,
+		},
+
+		rdesConn: [MaxRooms][MaxRooms]bool{
+			{false, true, false, true, false, false, false, false, false},
+			{true, false, true, false, true, false, false, false, false},
+			{false, true, false, false, false, true, false, false, false},
+			{true, false, false, false, true, false, true, false, false},
+			{false, true, false, true, false, true, false, true, false},
+			{false, false, true, false, true, false, false, false, true},
+			{false, false, false, true, false, false, false, true, false},
+			{false, false, false, false, true, false, true, false, true},
+			{false, false, false, false, false, true, false, true, false},
+		},
+
+		thingList: []byte{
+			Potion, Scroll, Ring, Stick, Food, Weapon, Armor, Stairs, Gold, Amulet,
+		},
+
+		identList: []helpEntry{
+			{'|', "wall of a room", false},
+			{'-', "wall of a room", false},
+			{Gold, goldName, false},
+			{Stairs, "a staircase", false},
+			{Door, "door", false},
+			{Floor, "room floor", false},
+			{PlayerCh, "you", false},
+			{Passage, "passage", false},
+			{Trap, "trap", false},
+			{Potion, potionName, false},
+			{Scroll, scrollName, false},
+			{Food, "food", false},
+			{Weapon, "weapon", false},
+			{' ', "solid rock", false},
+			{Armor, "armor", false},
+			{Amulet, "the Amulet of Yendor", false},
+			{Ring, ringName, false},
+			{Stick, "wand or staff", false},
+		},
+
+		hungerStateName: [4]string{"", "Hungry", "Weak", "Faint"},
+
+		ripArt: []string{
+			"                       __________",
+			"                      /          \\",
+			"                     /    REST    \\",
+			"                    /      IN      \\",
+			"                   /     PEACE      \\",
+			"                  /                  \\",
+			ripWall,
+			ripWall,
+			"                  |   killed by a    |",
+			ripWall,
+			"                  |       1980       |",
+			"                 *|     *  *  *      | *",
+			"         ________)/\\\\_//(\\/(/\\)/\\//\\/|_)_______",
+		},
+
+		killnameTable: []helpEntry{
+			{'a', "arrow", true},
+			{'b', "bolt", true},
+			{'d', "dart", true},
+			{'h', "hypothermia", false},
+			{'s', "starvation", false},
+		},
+
+		scoreReasons: [4]string{
+			"killed",
+			"quit",
+			"A total winner",
+			"killed with Amulet",
+		},
+
+		quaffHandlers: [NumPotionTypes]func(*RogueGame, bool){
+			PotionConfusion:       (*RogueGame).quaffConfusion,
+			PotionLSD:             (*RogueGame).quaffLSD,
+			PotionPoison:          (*RogueGame).quaffPoison,
+			PotionGainStrength:    (*RogueGame).quaffGainStrength,
+			PotionSeeInvisible:    (*RogueGame).quaffSeeInvisible,
+			PotionHealing:         (*RogueGame).quaffHealing,
+			PotionDetectMonsters:  (*RogueGame).quaffDetectMonsters,
+			PotionDetectMagic:     (*RogueGame).quaffDetectMagic,
+			PotionRaiseLevel:      (*RogueGame).quaffRaiseLevel,
+			PotionExtraHealing:    (*RogueGame).quaffExtraHealing,
+			PotionHaste:           (*RogueGame).quaffHaste,
+			PotionRestoreStrength: (*RogueGame).quaffRestoreStrength,
+			PotionBlindness:       (*RogueGame).quaffBlindness,
+			PotionLevitation:      (*RogueGame).quaffLevitation,
+		},
+
+		readHandlers: [NumScrollTypes]func(*RogueGame, *Object){
+			ScrollMonsterConfusion:    (*RogueGame).readMonsterConfusion,
+			ScrollMagicMapping:        (*RogueGame).readMagicMapping,
+			ScrollHoldMonster:         (*RogueGame).readHoldMonster,
+			ScrollSleep:               (*RogueGame).readSleep,
+			ScrollEnchantArmor:        (*RogueGame).readEnchantArmor,
+			ScrollIdentifyPotion:      (*RogueGame).readIdentify,
+			ScrollIdentifyScroll:      (*RogueGame).readIdentify,
+			ScrollIdentifyWeapon:      (*RogueGame).readIdentify,
+			ScrollIdentifyArmor:       (*RogueGame).readIdentify,
+			ScrollIdentifyRingOrStick: (*RogueGame).readIdentify,
+			ScrollScareMonster:        (*RogueGame).readScareMonster,
+			ScrollFoodDetection:       (*RogueGame).readFoodDetection,
+			ScrollTeleportation:       (*RogueGame).readTeleportation,
+			ScrollEnchantWeapon:       (*RogueGame).readEnchantWeapon,
+			ScrollCreateMonster:       (*RogueGame).readCreateMonster,
+			ScrollRemoveCurse:         (*RogueGame).readRemoveCurse,
+			ScrollAggravateMonsters:   (*RogueGame).readAggravateMonsters,
+			ScrollProtectArmor:        (*RogueGame).readProtectArmor,
+		},
+
+		zapHandlers: [NumWandTypes]func(*RogueGame, *Object) bool{
+			WandLight:        (*RogueGame).zapLight,
+			WandInvisibility: (*RogueGame).zapInvisibility,
+			WandLightning:    (*RogueGame).zapBolt,
+			WandFire:         (*RogueGame).zapBolt,
+			WandCold:         (*RogueGame).zapBolt,
+			WandPolymorph:    (*RogueGame).zapPolymorph,
+			WandMagicMissile: (*RogueGame).zapMagicMissile,
+			WandHasteMonster: (*RogueGame).zapSpeed,
+			WandSlowMonster:  (*RogueGame).zapSpeed,
+			WandDrainLife:    (*RogueGame).zapDrainLife,
+			WandTeleportAway: (*RogueGame).zapTeleport,
+			WandTeleportTo:   (*RogueGame).zapTeleport,
+			WandCancellation: (*RogueGame).zapCancellation,
+		},
+
+		hitHandlers: [26]func(*RogueGame, *Monster, string) bool{
+			0:         (*RogueGame).hitAquator, // 'A' - 'A'
+			'F' - 'A': (*RogueGame).hitFlytrap,
+			'I' - 'A': (*RogueGame).hitIceMonster,
+			'L' - 'A': (*RogueGame).hitLeprechaun,
+			'N' - 'A': (*RogueGame).hitNymph,
+			'R' - 'A': (*RogueGame).hitRattlesnake,
+			'V' - 'A': (*RogueGame).hitLifeDrainer,
+			'W' - 'A': (*RogueGame).hitLifeDrainer,
+		},
+
+		commandHandlers: map[byte]func(*RogueGame){
+			',': (*RogueGame).pickupCommand,
+			'!': (*RogueGame).shell,
+			'h': func(g *RogueGame) { g.moveHero(0, -1) },
+			'j': func(g *RogueGame) { g.moveHero(1, 0) },
+			'k': func(g *RogueGame) { g.moveHero(-1, 0) },
+			'l': func(g *RogueGame) { g.moveHero(0, 1) },
+			'y': func(g *RogueGame) { g.moveHero(-1, -1) },
+			'u': func(g *RogueGame) { g.moveHero(-1, 1) },
+			'b': func(g *RogueGame) { g.moveHero(1, -1) },
+			'n': func(g *RogueGame) { g.moveHero(1, 1) },
+			'H': func(g *RogueGame) { g.startRun('h') },
+			'J': func(g *RogueGame) { g.startRun('j') },
+			'K': func(g *RogueGame) { g.startRun('k') },
+			'L': func(g *RogueGame) { g.startRun('l') },
+			'Y': func(g *RogueGame) { g.startRun('y') },
+			'U': func(g *RogueGame) { g.startRun('u') },
+			'B': func(g *RogueGame) { g.startRun('b') },
+			'N': func(g *RogueGame) { g.startRun('n') },
+			't': func(g *RogueGame) {
+				if !g.promptDirection() {
+					g.After = false
+				} else {
+					g.missile(g.Delta.Y, g.Delta.X)
+				}
+			},
+			'q': (*RogueGame).quaff,
+			'Q': func(g *RogueGame) {
+				g.After = false
+				g.QComm = true
+				g.quit(0)
+				g.QComm = false
+			},
+			'i': func(g *RogueGame) {
+				g.After = false
+				g.inventory(g.Player.Pack, 0)
+			},
+			'I': func(g *RogueGame) {
+				g.After = false
+				g.pickyInven()
+			},
+			'd': (*RogueGame).dropIt,
+			'r': (*RogueGame).readScroll,
+			'e': (*RogueGame).eat,
+			'w': (*RogueGame).wield,
+			'W': (*RogueGame).wear,
+			'T': (*RogueGame).takeOff,
+			'P': (*RogueGame).ringOn,
+			'R': (*RogueGame).ringOff,
+			'o': func(g *RogueGame) {
+				g.option()
+				g.After = false
+			},
+			'c': func(g *RogueGame) {
+				g.call()
+				g.After = false
+			},
+			'>': func(g *RogueGame) {
+				g.After = false
+				g.dLevel()
+			},
+			'<': func(g *RogueGame) {
+				g.After = false
+				g.uLevel()
+			},
+			'?': func(g *RogueGame) {
+				g.After = false
+				g.help()
+			},
+			'/': func(g *RogueGame) {
+				g.After = false
+				g.identify()
+			},
+			's': (*RogueGame).search,
+			'z': func(g *RogueGame) {
+				if g.promptDirection() {
+					g.doZap()
+				} else {
+					g.After = false
+				}
+			},
+			'D': func(g *RogueGame) {
+				g.After = false
+				g.discovered()
+			},
+			CTRL('P'): func(g *RogueGame) {
+				g.After = false
+				g.msg("%s", g.Msgs.Huh)
+			},
+			CTRL('R'): func(g *RogueGame) {
+				g.After = false
+				g.refresh()
+			},
+			'v': func(g *RogueGame) {
+				g.After = false
+				g.msg("version %s. (mctesq was here)", Release)
+			},
+			'S': func(g *RogueGame) {
+				g.After = false
+				g.saveGame()
+			},
+			'.': func(*RogueGame) {
+				// rest command
+			},
+			' ': func(g *RogueGame) {
+				g.After = false // "legal" illegal command
+			},
+			'^': (*RogueGame).identifyTrapCommand,
+			Escape: func(g *RogueGame) {
+				g.DoorStop = false
+				g.Count = 0
+				g.After = false
+				g.Again = false
+			},
+			')': func(g *RogueGame) {
+				g.current(g.Player.CurWeapon, "wielding", "")
+			},
+			']': func(g *RogueGame) {
+				g.current(g.Player.CurArmor, "wearing", "")
+			},
+			'=': func(g *RogueGame) {
+				g.current(g.Player.CurRing[Left], "wearing",
+					g.chooseTerse("(L)", "on left hand"))
+				g.current(g.Player.CurRing[Right], "wearing",
+					g.chooseTerse("(R)", "on right hand"))
+			},
+			'@': func(g *RogueGame) {
+				g.StatMsg = true
+				g.status()
+				g.StatMsg = false
+				g.After = false
+			},
+		},
+
+		trapHandlers: [NumTrapTypes]func(*RogueGame, Coord){
+			TrapDoor:     (*RogueGame).trapFall,
+			TrapArrow:    (*RogueGame).trapArrow,
+			TrapSleep:    (*RogueGame).trapSleep,
+			TrapBear:     (*RogueGame).trapBear,
+			TrapTeleport: (*RogueGame).trapTeleport,
+			TrapDart:     (*RogueGame).trapDart,
+			TrapRust:     (*RogueGame).trapRust,
+			TrapMystery:  (*RogueGame).trapMystery,
+		},
+
+		daemonHandlers: [DTurnSee + 1]func(*RogueGame, int){
+			DRollwand:  (*RogueGame).rollwand,
+			DDoctor:    (*RogueGame).doctor,
+			DStomach:   (*RogueGame).stomach,
+			DRunners:   (*RogueGame).runners,
+			DSwander:   (*RogueGame).swander,
+			DNohaste:   (*RogueGame).nohaste,
+			DUnconfuse: (*RogueGame).unconfuse,
+			DUnsee:     (*RogueGame).unsee,
+			DSight:     (*RogueGame).sight,
+			DVisuals:   (*RogueGame).visuals,
+			DComeDown:  (*RogueGame).comeDown,
+			DLand:      (*RogueGame).land,
+			DTurnSee: func(g *RogueGame, arg int) {
+				g.turnSee(arg != 0)
+			},
+		},
+	}
 }
 
 // Version strings (vers.c). The encstr/statlist XOR keys are not ported:

game/tables_test.go

@@ -9,16 +9,20 @@ func TestProbabilitiesSumTo100(t *testing.T) {
 		for _, oi := range info {
 			s += oi.Prob
 		}
+
 		return s
 	}
+
+	data := newGameData()
+
 	tables := map[string][]ObjInfo{
-		"things":  baseThings[:],
+		"things":  data.baseThings[:],
-		"potions": basePotInfo[:],
+		"potions": data.basePotInfo[:],
-		"scrolls": baseScrInfo[:],
+		"scrolls": data.baseScrInfo[:],
-		"rings":   baseRingInfo[:],
+		"rings":   data.baseRingInfo[:],
-		"sticks":  baseWsInfo[:],
+		"sticks":  data.baseWsInfo[:],
-		"weapons": baseWeapInfo[:NumWeaponTypes], // excludes the flame entry
+		"weapons": data.baseWeapInfo[:NumWeaponTypes], // excludes the flame entry
-		"armor":   baseArmInfo[:],
+		"armor":   data.baseArmInfo[:],
 	}
 	for name, tab := range tables {
 		if s := sum(tab); s != 100 {
@@ -28,11 +32,13 @@ func TestProbabilitiesSumTo100(t *testing.T) {
 }
 
 func TestInitProbsCumulative(t *testing.T) {
-	g := NewGame(Config{Seed: 1})
+	g := New(Params{Seed: 1})
+
 	last := g.Items.Potions[NumPotionTypes-1].Prob
 	if last != 100 {
 		t.Errorf("cumulative potion probability ends at %d, want 100", last)
 	}
+
 	for i := PotionKind(1); i < NumPotionTypes; i++ {
 		if g.Items.Potions[i].Prob < g.Items.Potions[i-1].Prob {
 			t.Errorf("potion probs not nondecreasing at %d", i)
@@ -41,46 +47,77 @@ func TestInitProbsCumulative(t *testing.T) {
 }
 
 func TestNewGameRandomizesAppearances(t *testing.T) {
-	g := NewGame(Config{Seed: 12345})
+	g := New(Params{Seed: 12345})
-	seen := map[string]bool{}
+
-	for i, c := range g.Items.PotColors {
+	checkPotionColors(t, g)
-		if c == "" {
+	checkScrollNames(t, g)
-			t.Fatalf("potion %d has no color", i)
+	checkWandMaterials(t, g)
-		}
-		if seen[c] {
-			t.Errorf("potion color %q assigned twice", c)
-		}
-		seen[c] = true
-	}
-	for i, n := range g.Items.ScrNames {
-		if n == "" {
-			t.Fatalf("scroll %d has no name", i)
-		}
-		if len(n) > MaxNameLen+1 {
-			t.Errorf("scroll name %q longer than C buffer allows", n)
-		}
-	}
-	for i := range g.Items.WandType {
-		if g.Items.WandType[i] != "wand" && g.Items.WandType[i] != "staff" {
-			t.Errorf("stick %d has type %q", i, g.Items.WandType[i])
-		}
-		if g.Items.WandMade[i] == "" {
-			t.Errorf("stick %d has no material", i)
-		}
-	}
 
 	// Determinism: same seed, same appearances.
-	h := NewGame(Config{Seed: 12345})
+	h := New(Params{Seed: 12345})
 	if h.Items != g.Items {
 		t.Error("two games with the same seed produced different item lore")
 	}
 }
 
+// checkPotionColors verifies every potion has a distinct color.
+func checkPotionColors(t *testing.T, g *RogueGame) {
+	t.Helper()
+
+	seen := map[string]bool{}
+
+	for i, c := range g.Items.PotColors {
+		if c == "" {
+			t.Fatalf("potion %d has no color", i)
+		}
+
+		if seen[c] {
+			t.Errorf("potion color %q assigned twice", c)
+		}
+
+		seen[c] = true
+	}
+}
+
+// checkScrollNames verifies every scroll has a name within the C buffer
+// limit.
+func checkScrollNames(t *testing.T, g *RogueGame) {
+	t.Helper()
+
+	for i, n := range g.Items.ScrNames {
+		if n == "" {
+			t.Fatalf("scroll %d has no name", i)
+		}
+
+		if len(n) > MaxNameLen+1 {
+			t.Errorf("scroll name %q longer than C buffer allows", n)
+		}
+	}
+}
+
+// checkWandMaterials verifies every stick has a wand/staff type and a
+// material.
+func checkWandMaterials(t *testing.T, g *RogueGame) {
+	t.Helper()
+
+	for i := range g.Items.WandType {
+		if g.Items.WandType[i] != wandName && g.Items.WandType[i] != staffName {
+			t.Errorf("stick %d has type %q", i, g.Items.WandType[i])
+		}
+
+		if g.Items.WandMade[i] == "" {
+			t.Errorf("stick %d has no material", i)
+		}
+	}
+}
+
 func TestMonsterTable(t *testing.T) {
-	if monsterTable[0].Name != "aquator" || monsterTable[25].Name != "zombie" {
+	data := newGameData()
+	if data.monsterTable[0].Name != "aquator" || data.monsterTable[25].Name != "zombie" {
 		t.Error("monster table order broken")
 	}
-	if monsterTable['D'-'A'].Name != "dragon" {
+
+	if data.monsterTable['D'-'A'].Name != "dragon" {
 		t.Error("letter indexing broken")
 	}
 }

game/term_test.go

@@ -11,15 +11,20 @@ type testTerm struct {
 
 func (t *testTerm) Render(*Window) {}
 
+func (t *testTerm) Fini() {}
+
 func (t *testTerm) ReadChar() byte {
 	if t.pos < len(t.input) {
 		c := t.input[t.pos]
 		t.pos++
+
 		return c
 	}
+
 	t.tick++
 	if t.tick%2 == 0 {
 		return '\n'
 	}
+
 	return ' '
 }

game/testdata/README.md

@@ -0,0 +1,27 @@
+# Seed-compatibility golden
+
+`item_tables.golden` is the per-seed item appearance tables (potion colors,
+scroll names, ring stones, wand/staff materials) captured from the **C
+reference** on the `modern-rogue` branch, for the seeds in the `seeds` list in
+`TestSeedCompatItemTables`. That test regenerates the same tables from the Go
+port and checks they match byte for byte — proving the LCG and its consumption
+order through the whole init sequence (`init_probs` → `init_player` →
+`init_names` → `init_colors` → `init_stones` → `init_materials`) agree with C.
+
+## Regenerating the golden
+
+`c_seedcompat.patch` adds a `DUMP` mode to the C `main.c`: with `DUMP` set it
+forces the RNG seed from `SEED`, runs the item-table init in the normal order,
+prints the tables, and exits before `initscr` (so no terminal is needed).
+
+```sh
+# from a checkout of the C reference (modern-rogue branch):
+git archive modern-rogue | tar -x -C /tmp/rogue-c
+cd /tmp/rogue-c
+patch -p1 < .../game/testdata/c_seedcompat.patch
+./configure && make
+for s in 1 42 12345 99999; do DUMP=1 SEED=$s ./rogue; done \
+    > .../game/testdata/item_tables.golden
+```
+
+The seed list must match the `seeds` slice in `TestSeedCompatItemTables`.

game/testdata/c_seedcompat.patch

@@ -0,0 +1,37 @@
+--- a/main.c	2026-07-24 03:02:38
++++ b/main.c	2026-07-24 02:48:31
+@@ -63,6 +63,34 @@
+ #endif
+ 	dnum = lowtime + md_getpid();
+     seed = dnum;
++
++    /* SEEDCOMPAT: dump the per-game item appearance tables for a fixed
++     * seed and exit, without initscr. The init sequence and everything
++     * it consumes from rnd() mirror the normal startup (main.c), so the
++     * tables are exactly what a real game with SEED would show. */
++    if (getenv("DUMP") != NULL)
++    {
++	int di;
++	char *sv = getenv("SEED");
++	if (sv != NULL)
++	    seed = atoi(sv);
++	printf("SEED %d\n", seed);
++	init_probs();
++	init_player();
++	init_names();
++	init_colors();
++	init_stones();
++	init_materials();
++	printf("POTIONS\n");
++	for (di = 0; di < MAXPOTIONS; di++) printf("%s\n", p_colors[di]);
++	printf("SCROLLS\n");
++	for (di = 0; di < MAXSCROLLS; di++) printf("%s\n", s_names[di]);
++	printf("RINGS\n");
++	for (di = 0; di < MAXRINGS; di++) printf("%s\n", r_stones[di]);
++	printf("STICKS\n");
++	for (di = 0; di < MAXSTICKS; di++) printf("%s %s\n", ws_type[di], ws_made[di]);
++	exit(0);
++    }
+ 
+     open_score();
+ 

game/testdata/item_tables.golden

@@ -0,0 +1,260 @@
+SEED 1
+POTIONS
+tangerine
+white
+ecru
+gold
+amber
+violet
+vermilion
+pink
+aquamarine
+plaid
+clear
+orange
+cyan
+tan
+SCROLLS
+miwhon garsnanih
+xomimi roke eshwedshu
+potwexrol ipbjorod turs evsnelg
+bekornan oxyfatox
+iv wexpo wun
+ha sefnelgtue whon pay
+alari wedit
+zantmon umzonski umwhonjo yot
+bluoxun rokkho yottrol sta
+vomarg microgcomp iteulkshu mung
+jo urokeep yuskiun
+ox xozantaks klisstaevs ag
+ipnih bek
+shu ami erk
+nejti zim
+iprol mic ishoxyvom fagan
+reacreti oodrol
+bytsri solsa tabu fri
+RINGS
+agate
+zircon
+jade
+tiger eye
+onyx
+germanium
+lapis lazuli
+emerald
+taaffeite
+kryptonite
+garnet
+ruby
+turquoise
+pearl
+STICKS
+wand steel
+wand platinum
+staff redwood
+staff pine
+wand silicon
+staff spruce
+staff pecan
+wand bone
+staff maple
+wand zinc
+wand iron
+wand pewter
+wand electrum
+staff dogwood
+SEED 42
+POTIONS
+blue
+green
+grey
+amber
+violet
+gold
+pink
+tan
+purple
+yellow
+plaid
+magenta
+turquoise
+cyan
+SCROLLS
+bek itod oxytaod oxy
+tarhovzant cre sname oxroy
+plemik ganod hyd wergerkpot
+hyd sol um bekzok
+esh eep ganmung
+anera ishsa ingala mon
+alasniklech viv
+yunejorn garro con nej
+dotrolther gopum eltitrol trolmonsri
+nes alazum
+itegopmung ti
+ere haeta wergla
+nejerecre poipi iprea
+ha falechrhov
+monskiwex sabitla frido
+rhovmar sno
+mar bekurzant satbuzum
+somon sri
+RINGS
+carnelian
+onyx
+jade
+granite
+stibotantalite
+kryptonite
+lapis lazuli
+germanium
+garnet
+tiger eye
+opal
+topaz
+agate
+peridot
+STICKS
+staff birch
+staff ebony
+staff redwood
+wand gold
+wand copper
+wand aluminum
+wand titanium
+wand mercury
+staff cypress
+staff bamboo
+staff dogwood
+wand silicon
+staff zebrawood
+wand beryllium
+SEED 12345
+POTIONS
+purple
+black
+grey
+brown
+plaid
+violet
+vermilion
+ecru
+orange
+turquoise
+tan
+magenta
+silver
+gold
+SCROLLS
+readalf shuplu ivnin
+plelaiv solel skibyt monha
+xo wun
+wedyfri o ewhonxo favompay
+eep zantreanelg
+plu buxo
+un zontabdan
+bie snik
+ulkitzant bluri
+apporg ash posnevly dennepwex
+u urval rol
+arzepotsno snovly pay snoropay
+pottox erewed faoxro
+ther sun ulkipo mik
+argzebfri elgrekli tuenepzon sehturssef
+isheep blumur
+wedash yuzimsun
+plupofri ski rejo fa
+RINGS
+onyx
+tiger eye
+alexandrite
+turquoise
+pearl
+emerald
+germanium
+sapphire
+zircon
+ruby
+granite
+stibotantalite
+opal
+diamond
+STICKS
+wand silicon
+staff ironwood
+staff holly
+wand gold
+staff mahogany
+wand iron
+wand brass
+wand pewter
+staff hemlock
+staff cherry
+staff elm
+wand mercury
+staff banyan
+staff dogwood
+SEED 99999
+POTIONS
+aquamarine
+plaid
+gold
+black
+vermilion
+red
+cyan
+tan
+orange
+violet
+brown
+clear
+silver
+green
+SCROLLS
+zant jocompan vomervly
+mur shusat prok
+prokmurklis oxysriklis
+ingcre prokbu whonengarg kli
+kli bot
+rokcoswerg ipsolsan klisvlypay
+glen yot whontox
+lechme markho fazim
+dalfsunbie micjosef cre comp
+vlyfumi bjorzantbot werg
+po argfidcos klipones
+ashtemarg ycrezim dalfiv whon
+turs unmisa zimpo therdo
+miccompuni uni neswex sef
+odwexing elwergmur mung
+itcon rhov nejmic lech
+garturs engseh ganish
+oodta whonorgsno monabmik vomyeng
+RINGS
+obsidian
+moonstone
+jade
+carnelian
+tiger eye
+taaffeite
+turquoise
+stibotantalite
+agate
+ruby
+onyx
+topaz
+germanium
+granite
+STICKS
+wand titanium
+wand brass
+wand silicon
+staff zebrawood
+wand mercury
+staff dogwood
+wand pewter
+staff cinnibar
+staff kukui wood
+staff banyan
+wand magnesium
+wand gold
+staff maple
+wand nickel

game/things.go

@@ -9,105 +9,163 @@ import (
 
 // invName returns the name of something as it would appear in an inventory
 // (things.c inv_name).
-func (g *RogueGame) invName(obj *Object, drop bool) string {
+func (g *RogueGame) inventoryName(obj *Object, drop bool) string {
 	var pb strings.Builder
+
 	which := obj.Which
 	it := &g.Items
+
 	switch obj.Kind {
 	case KindPotion:
-		g.nameit(&pb, obj, "potion", it.PotColors[which], &it.Potions[which], nullstr)
+		g.nameit(&pb, obj, potionName, it.PotColors[which], &it.Potions[which], nullstr)
 	case KindRing:
-		g.nameit(&pb, obj, "ring", it.RingStones[which], &it.Rings[which], ringNum)
+		g.nameit(&pb, obj, ringName, it.RingStones[which], &it.Rings[which], ringNum)
 	case KindWand:
 		g.nameit(&pb, obj, it.WandType[which], it.WandMade[which], &it.Sticks[which], chargeStr)
 	case KindScroll:
-		if obj.Count == 1 {
+		g.nameScroll(&pb, obj)
-			pb.WriteString("A scroll ")
-		} else {
-			fmt.Fprintf(&pb, "%d scrolls ", obj.Count)
-		}
-		op := &it.Scrolls[which]
-		if op.Know {
-			fmt.Fprintf(&pb, "of %s", op.Name)
-		} else if op.Guess != "" {
-			fmt.Fprintf(&pb, "called %s", op.Guess)
-		} else {
-			fmt.Fprintf(&pb, "titled '%s'", it.ScrNames[which])
-		}
 	case KindFood:
-		if which == 1 {
+		g.nameFood(&pb, obj)
-			if obj.Count == 1 {
-				fmt.Fprintf(&pb, "A%s %s", vowelstr(g.Fruit), g.Fruit)
-			} else {
-				fmt.Fprintf(&pb, "%d %ss", obj.Count, g.Fruit)
-			}
-		} else {
-			if obj.Count == 1 {
-				pb.WriteString("Some food")
-			} else {
-				fmt.Fprintf(&pb, "%d rations of food", obj.Count)
-			}
-		}
 	case KindWeapon:
-		sp := it.Weapons[which].Name
+		g.nameWeapon(&pb, obj)
-		if obj.Count > 1 {
-			fmt.Fprintf(&pb, "%d ", obj.Count)
-		} else {
-			fmt.Fprintf(&pb, "A%s ", vowelstr(sp))
-		}
-		if obj.Flags.Has(Known) {
-			fmt.Fprintf(&pb, "%s %s", num(obj.HPlus, obj.DPlus, Weapon), sp)
-		} else {
-			pb.WriteString(sp)
-		}
-		if obj.Count > 1 {
-			pb.WriteString("s")
-		}
-		if obj.Label != "" {
-			fmt.Fprintf(&pb, " called %s", obj.Label)
-		}
 	case KindArmor:
-		sp := it.Armors[which].Name
+		g.nameArmor(&pb, obj)
-		if obj.Flags.Has(Known) {
-			fmt.Fprintf(&pb, "%s %s [", num(aClass[which]-obj.ArmorClass, 0, Armor), sp)
-			if !g.Options.Terse {
-				pb.WriteString("protection ")
-			}
-			fmt.Fprintf(&pb, "%d]", 10-obj.ArmorClass)
-		} else {
-			pb.WriteString(sp)
-		}
-		if obj.Label != "" {
-			fmt.Fprintf(&pb, " called %s", obj.Label)
-		}
 	case KindAmulet:
 		pb.WriteString("The Amulet of Yendor")
 	case KindGold:
 		fmt.Fprintf(&pb, "%d Gold pieces", obj.GoldValue)
 	}
 
-	out := pb.String()
+	return fixNameCase(g.describeWorn(obj, pb.String()), drop)
-	if g.InvDescribe {
+}
+
+// nameScroll writes a scroll's inventory name (things.c inv_name).
+func (g *RogueGame) nameScroll(pb *strings.Builder, obj *Object) {
+	if obj.Count == 1 {
+		pb.WriteString("A scroll ")
+	} else {
+		fmt.Fprintf(pb, "%d scrolls ", obj.Count)
+	}
+
+	op := &g.Items.Scrolls[obj.Which]
+
+	switch {
+	case op.Know:
+		fmt.Fprintf(pb, "of %s", op.Name)
+	case op.Guess != "":
+		fmt.Fprintf(pb, "called %s", op.Guess)
+	default:
+		fmt.Fprintf(pb, "titled '%s'", g.Items.ScrNames[obj.Which])
+	}
+}
+
+// nameFood writes a food item's inventory name; which 1 is the fruit
+// (things.c inv_name).
+func (g *RogueGame) nameFood(pb *strings.Builder, obj *Object) {
+	if obj.Which == 1 {
+		if obj.Count == 1 {
+			fmt.Fprintf(pb, "A%s %s", vowelstr(g.Fruit), g.Fruit)
+		} else {
+			fmt.Fprintf(pb, "%d %ss", obj.Count, g.Fruit)
+		}
+
+		return
+	}
+
+	if obj.Count == 1 {
+		pb.WriteString("Some food")
+	} else {
+		fmt.Fprintf(pb, "%d rations of food", obj.Count)
+	}
+}
+
+// nameWeapon writes a weapon's inventory name (things.c inv_name).
+func (g *RogueGame) nameWeapon(pb *strings.Builder, obj *Object) {
+	sp := g.Items.Weapons[obj.Which].Name
+
+	if obj.Count > 1 {
+		fmt.Fprintf(pb, "%d ", obj.Count)
+	} else {
+		fmt.Fprintf(pb, "A%s ", vowelstr(sp))
+	}
+
+	if obj.Flags.Has(Known) {
+		fmt.Fprintf(pb, "%s %s", num(obj.HPlus, obj.DPlus, Weapon), sp)
+	} else {
+		pb.WriteString(sp)
+	}
+
+	if obj.Count > 1 {
+		pb.WriteString("s")
+	}
+
+	if obj.Label != "" {
+		fmt.Fprintf(pb, " called %s", obj.Label)
+	}
+}
+
+// nameArmor writes an armor's inventory name (things.c inv_name).
+func (g *RogueGame) nameArmor(pb *strings.Builder, obj *Object) {
+	sp := g.Items.Armors[obj.Which].Name
+	if obj.Flags.Has(Known) {
+		fmt.Fprintf(pb, "%s %s [",
+			num(g.data.aClass[obj.Which]-obj.ArmorClass, 0, Armor), sp)
+
+		if !g.Options.Terse {
+			pb.WriteString("protection ")
+		}
+
+		fmt.Fprintf(pb, "%d]", 10-obj.ArmorClass)
+	} else {
+		pb.WriteString(sp)
+	}
+
+	if obj.Label != "" {
+		fmt.Fprintf(pb, " called %s", obj.Label)
+	}
+}
+
+// describeWorn appends the equipped-status notes to an inventory name
+// (things.c inv_name).
+func (g *RogueGame) describeWorn(obj *Object, out string) string {
+	if !g.InvDescribe {
+		return out
+	}
+
 	p := &g.Player
 	if obj == p.CurArmor {
 		out += " (being worn)"
 	}
+
 	if obj == p.CurWeapon {
 		out += " (weapon in hand)"
 	}
-		if obj == p.CurRing[Left] {
+
+	switch obj {
+	case p.CurRing[Left]:
 		out += " (on left hand)"
-		} else if obj == p.CurRing[Right] {
+	case p.CurRing[Right]:
 		out += " (on right hand)"
 	}
+
+	return out
 }
-	if out != "" {
+
+// fixNameCase upper- or lowercases the leading letter to suit the
+// sentence it will land in (things.c inv_name).
+func fixNameCase(out string, drop bool) string {
+	if out == "" {
+		return out
+	}
+
 	if drop && isUpper(out[0]) {
-			out = string(toLower(out[0])) + out[1:]
+		return string(toLower(out[0])) + out[1:]
-		} else if !drop && isLower(out[0]) {
-			out = string(toUpper(out[0])) + out[1:]
 	}
+
+	if !drop && isLower(out[0]) {
+		return string(toUpper(out[0])) + out[1:]
 	}
+
 	return out
 }
 
@@ -115,29 +173,36 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 // leavePack/detach vocabulary collision).
 func (g *RogueGame) dropIt() {
 	p := &g.Player
+
 	ch := g.Level.Char(p.Pos.Y, p.Pos.X)
 	if ch != Floor && ch != Passage {
 		g.After = false
 		g.msg("there is something there already")
+
 		return
 	}
-	obj := g.getItem("drop", KindNone)
+
-	if obj == nil {
+	obj, ok := g.promptPackItem("drop", KindNone)
+	if !ok {
 		return
 	}
+
 	if !g.dropCheck(obj) {
 		return
 	}
+
 	obj = g.leavePack(obj, true, !obj.Kind.MergesInPack())
 	// Link it into the level object list
-	attachObj(&g.Level.Objects, obj)
+	g.Level.AddObject(obj)
 	g.Level.SetChar(p.Pos.Y, p.Pos.X, obj.Kind.Glyph())
 	g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Set(FDropped)
+
 	obj.Pos = p.Pos
 	if obj.Kind == KindAmulet {
 		g.HasAmulet = false
 	}
-	g.msg("dropped %s", g.invName(obj, true))
+
+	g.msg("dropped %s", g.inventoryName(obj, true))
 }
 
 // dropCheck does special checks for dropping or unwielding|unwearing|
@@ -146,36 +211,53 @@ func (g *RogueGame) dropCheck(obj *Object) bool {
 	if obj == nil {
 		return true
 	}
+
 	p := &g.Player
 	if obj != p.CurArmor && obj != p.CurWeapon &&
 		obj != p.CurRing[Left] && obj != p.CurRing[Right] {
 		return true
 	}
+
 	if obj.Flags.Has(Cursed) {
 		g.msg("you can't.  It appears to be cursed")
+
 		return false
 	}
-	if obj == p.CurWeapon {
+
+	switch obj {
+	case p.CurWeapon:
 		p.CurWeapon = nil
-	} else if obj == p.CurArmor {
+	case p.CurArmor:
 		g.wasteTime()
+
 		p.CurArmor = nil
-	} else {
+	default:
+		g.dropRing(obj)
+	}
+
+	return true
+}
+
+// dropRing takes a worn ring off with its side effects (things.c
+// dropcheck).
+func (g *RogueGame) dropRing(obj *Object) {
+	p := &g.Player
+
 	hand := Right
 	if obj == p.CurRing[Left] {
 		hand = Left
 	}
+
 	p.CurRing[hand] = nil
+
 	switch obj.RingKind() {
 	case RingAddStrength:
-			g.chgStr(-obj.Bonus)
+		g.changeStrength(-obj.Bonus)
 	case RingSeeInvisible:
 		g.unsee(0)
 		g.Extinguish(DUnsee)
 	}
 }
-	return true
-}
 
 // newThing returns a new random thing for the dungeon (things.c new_thing).
 func (g *RogueGame) newThing() *Object {
@@ -193,6 +275,7 @@ func (g *RogueGame) newThing() *Object {
 	} else {
 		kind = pickOne(g, g.Items.Things[:])
 	}
+
 	switch kind {
 	case 0:
 		cur.Kind = KindPotion
@@ -201,33 +284,67 @@ func (g *RogueGame) newThing() *Object {
 		cur.Kind = KindScroll
 		cur.Which = pickOne(g, g.Items.Scrolls[:])
 	case 2:
+		g.newFoodThing(cur)
+	case 3:
+		g.newWeaponThing(cur)
+	case 4:
+		g.newArmorThing(cur)
+	case 5:
+		g.newRingThing(cur)
+	case 6:
+		cur.Kind = KindWand
+		cur.Which = pickOne(g, g.Items.Sticks[:])
+		g.fixStick(cur)
+	}
+
+	return cur
+}
+
+// newFoodThing rolls food, one time in ten the fruit (things.c
+// new_thing).
+func (g *RogueGame) newFoodThing(cur *Object) {
 	cur.Kind = KindFood
+
 	g.Player.NoFood = 0
 	if g.rnd(10) != 0 {
 		cur.Which = 0
 	} else {
 		cur.Which = 1
 	}
-	case 3:
+}
+
+// newWeaponThing rolls a weapon, sometimes cursed or blessed (things.c
+// new_thing).
+func (g *RogueGame) newWeaponThing(cur *Object) {
 	g.initWeapon(cur, WeaponKind(pickOne(g, g.Items.Weapons[:NumWeaponTypes])))
+
 	if r := g.rnd(100); r < 10 {
 		cur.Flags.Set(Cursed)
 		cur.HPlus -= g.rnd(3) + 1
 	} else if r < 15 {
 		cur.HPlus += g.rnd(3) + 1
 	}
-	case 4:
+}
+
+// newArmorThing rolls armor, sometimes cursed or blessed (things.c
+// new_thing).
+func (g *RogueGame) newArmorThing(cur *Object) {
 	cur.Kind = KindArmor
 	cur.Which = pickOne(g, g.Items.Armors[:])
-		cur.ArmorClass = aClass[cur.Which]
+
+	cur.ArmorClass = g.data.aClass[cur.Which]
 	if r := g.rnd(100); r < 20 {
 		cur.Flags.Set(Cursed)
 		cur.ArmorClass += g.rnd(3) + 1
 	} else if r < 28 {
 		cur.ArmorClass -= g.rnd(3) + 1
 	}
-	case 5:
+}
+
+// newRingThing rolls a ring, cursing the bad ones (things.c new_thing).
+func (g *RogueGame) newRingThing(cur *Object) {
 	cur.Kind = KindRing
+
 	cur.Which = pickOne(g, g.Items.Rings[:])
 	switch cur.RingKind() {
 	case RingAddStrength, RingProtection, RingDexterity, RingIncreaseDamage:
@@ -238,12 +355,6 @@ func (g *RogueGame) newThing() *Object {
 	case RingAggravateMonsters, RingTeleportation:
 		cur.Flags.Set(Cursed)
 	}
-	case 6:
-		cur.Kind = KindWand
-		cur.Which = pickOne(g, g.Items.Sticks[:])
-		g.fixStick(cur)
-	}
-	return cur
 }
 
 // pickOne picks an item out of a list of possible objects using their
@@ -255,6 +366,7 @@ func pickOne(g *RogueGame, info []ObjInfo) int {
 			return idx
 		}
 	}
+
 	return 0 // bad pick_one: C resets to the start of the table
 }
 
@@ -272,20 +384,27 @@ type invPage struct {
 // (things.c discovered).
 func (g *RogueGame) discovered() {
 	var ch byte
+
 	for {
 		discList := false
+
 		if !g.Options.Terse {
-			g.addmsg("for ")
+			g.addmsgf("for ")
 		}
-		g.addmsg("what type")
+
+		g.addmsgf("what type")
+
 		if !g.Options.Terse {
-			g.addmsg(" of object do you want a list")
+			g.addmsgf(" of object do you want a list")
 		}
+
 		g.msg("? (* for all)")
+
 		ch = g.readchar()
 		switch ch {
 		case Escape:
 			g.msg("")
+
 			return
 		case Potion, Scroll, Ring, Stick, '*':
 			discList = true
@@ -297,10 +416,12 @@ func (g *RogueGame) discovered() {
 					Potion, Scroll, Ring, Stick)
 			}
 		}
+
 		if discList {
 			break
 		}
 	}
+
 	if ch == '*' {
 		g.printDisc(Potion)
 		g.addLine("")
@@ -320,6 +441,7 @@ func (g *RogueGame) discovered() {
 // (things.c print_disc).
 func (g *RogueGame) printDisc(typ byte) {
 	var info []ObjInfo
+
 	switch typ {
 	case Scroll:
 		info = g.Items.Scrolls[:]
@@ -330,18 +452,23 @@ func (g *RogueGame) printDisc(typ byte) {
 	case Stick:
 		info = g.Items.Sticks[:]
 	}
+
 	order := make([]int, len(info))
 	g.setOrder(order)
+
 	obj := Object{Count: 1}
 	numFound := 0
+
 	for i := range info {
 		if info[order[i]].Know || info[order[i]].Guess != "" {
 			obj.Kind = objectKindForGlyph(typ)
 			obj.Which = order[i]
-			g.addLine("%s", g.invName(&obj, false))
+			g.addLine("%s", g.inventoryName(&obj, false))
+
 			numFound++
 		}
 	}
+
 	if numFound == 0 {
 		g.addLine("%s", g.nothing(typ))
 	}
@@ -353,6 +480,7 @@ func (g *RogueGame) setOrder(order []int) {
 	for i := range order {
 		order[i] = i
 	}
+
 	for i := len(order); i > 0; i-- {
 		r := g.rnd(i)
 		order[i-1], order[r] = order[r], order[i-1]
@@ -366,8 +494,8 @@ const flushSentinel = "\x00"
 
 func (g *RogueGame) addLine(format string, a ...any) int {
 	pg := &g.invPage
-	prompt := "--Press space to continue--"
 	isFlush := format == flushSentinel
+
 	var line string
 	if !isFlush {
 		line = fmt.Sprintf(format, a...)
@@ -375,41 +503,68 @@ func (g *RogueGame) addLine(format string, a ...any) int {
 
 	if pg.lineCnt == 0 {
 		g.scr.Hw.Clear()
+
 		if g.Options.InvType == InvSlow {
 			g.Msgs.Mpos = 0
 		}
 	}
+
 	if g.Options.InvType == InvSlow {
+		return g.addLineSlow(line, isFlush)
+	}
+
+	g.addLinePaged(line, isFlush)
+
+	return ^Escape
+}
+
+// addLineSlow shows one discovery line as a message (the slow-inventory
+// arm of things.c add_line).
+func (g *RogueGame) addLineSlow(line string, isFlush bool) int {
 	if !isFlush && line != "" {
 		if g.msg("%s", line) == Escape {
 			return Escape
 		}
 	}
-		pg.lineCnt++
+
-	} else {
+	g.invPage.lineCnt++
+
+	return ^Escape
+}
+
+// addLinePaged accumulates discovery lines into the paged window,
+// prompting between full pages (the windowed arm of things.c add_line).
+func (g *RogueGame) addLinePaged(line string, isFlush bool) {
+	pg := &g.invPage
+	prompt := "--Press space to continue--"
+
 	if !pg.init {
 		pg.maxlen = len(prompt)
 		pg.init = true
 	}
+
 	if pg.lineCnt >= NumLines-1 || isFlush {
+		g.addLinePageBreak(prompt, isFlush)
+	}
+
+	if !isFlush && (pg.lineCnt != 0 || line != "") {
+		g.scr.Hw.MvAddStr(pg.lineCnt, 0, line)
+
+		pg.lineCnt++
+		if pg.maxlen < len(line) {
+			pg.maxlen = len(line)
+		}
+
+		pg.lastLine = line
+	}
+}
+
+// addLinePageBreak prompts at a full page and starts a fresh one
+// (things.c add_line).
+func (g *RogueGame) addLinePageBreak(prompt string, isFlush bool) {
+	pg := &g.invPage
 	if g.Options.InvType == InvOver && isFlush && !pg.newpage {
-				// Overlay the accumulated list in a box at the top right
+		g.addLineOverlay(prompt)
-				// of the screen, prompt, and restore what was beneath.
-				g.msg("")
-				g.refresh()
-				saved := NewWindow(NumLines, NumCols)
-				saved.CopyFrom(g.scr.Std)
-				lx := NumCols - pg.maxlen - 2
-				for y := 0; y <= pg.lineCnt; y++ {
-					for x := 0; x <= pg.maxlen; x++ {
-						g.scr.Std.MvAddCh(y, lx+x, g.scr.Hw.MvInch(y, x))
-					}
-				}
-				g.scr.Std.MvAddStr(pg.lineCnt, lx, prompt)
-				g.refresh()
-				g.waitFor(' ')
-				g.scr.Std.CopyFrom(saved)
-				g.refresh()
 	} else {
 		g.scr.Hw.MvAddStr(NumLines-1, 0, prompt)
 		g.scr.RefreshWin(g.scr.Hw)
@@ -417,20 +572,36 @@ func (g *RogueGame) addLine(format string, a ...any) int {
 		g.scr.Hw.Clear()
 		g.refresh()
 	}
+
 	pg.newpage = true
 	pg.lineCnt = 0
 	pg.maxlen = len(prompt)
 }
-		if !isFlush && !(pg.lineCnt == 0 && line == "") {
+
-			g.scr.Hw.MvAddStr(pg.lineCnt, 0, line)
+// addLineOverlay draws the accumulated list in a box at the top right
-			pg.lineCnt++
+// of the screen, prompts, and restores what was beneath (things.c
-			if pg.maxlen < len(line) {
+// add_line).
-				pg.maxlen = len(line)
+func (g *RogueGame) addLineOverlay(prompt string) {
-			}
+	pg := &g.invPage
-			pg.lastLine = line
+
+	g.msg("")
+	g.refresh()
+
+	saved := NewWindow(NumLines, NumCols)
+	saved.CopyFrom(g.scr.Std)
+
+	lx := NumCols - pg.maxlen - 2
+	for y := 0; y <= pg.lineCnt; y++ {
+		for x := 0; x <= pg.maxlen; x++ {
+			g.scr.Std.MvAddCh(y, lx+x, g.scr.Hw.MvInch(y, x))
 		}
 	}
-	return ^Escape
+
+	g.scr.Std.MvAddStr(pg.lineCnt, lx, prompt)
+	g.refresh()
+	g.waitFor(' ')
+	g.scr.Std.CopyFrom(saved)
+	g.refresh()
 }
 
 // flushLine is add_line(NULL): force out the accumulated page.
@@ -447,6 +618,7 @@ func (g *RogueGame) endLine() {
 			g.flushLine()
 		}
 	}
+
 	pg.lineCnt = 0
 	pg.newpage = false
 }
@@ -459,20 +631,24 @@ func (g *RogueGame) nothing(typ byte) string {
 	} else {
 		out = "Haven't discovered anything"
 	}
+
 	if typ != '*' {
 		var tystr string
+
 		switch typ {
 		case Potion:
-			tystr = "potion"
+			tystr = potionName
 		case Scroll:
-			tystr = "scroll"
+			tystr = scrollName
 		case Ring:
-			tystr = "ring"
+			tystr = ringName
 		case Stick:
 			tystr = "stick"
 		}
+
 		out += fmt.Sprintf(" about any %ss", tystr)
 	}
+
 	return out
 }
 
@@ -480,20 +656,22 @@ func (g *RogueGame) nothing(typ byte) string {
 // (things.c nameit).
 func (g *RogueGame) nameit(pb *strings.Builder, obj *Object, typ, which string,
 	op *ObjInfo, prfunc func(*RogueGame, *Object) string) {
-	if op.Know || op.Guess != "" {
+	switch {
+	case op.Know || op.Guess != "":
 		if obj.Count == 1 {
 			fmt.Fprintf(pb, "A %s ", typ)
 		} else {
 			fmt.Fprintf(pb, "%d %ss ", obj.Count, typ)
 		}
+
 		if op.Know {
 			fmt.Fprintf(pb, "of %s%s(%s)", op.Name, prfunc(g, obj), which)
 		} else {
 			fmt.Fprintf(pb, "called %s%s(%s)", op.Guess, prfunc(g, obj), which)
 		}
-	} else if obj.Count == 1 {
+	case obj.Count == 1:
 		fmt.Fprintf(pb, "A%s %s %s", vowelstr(which), which, typ)
-	} else {
+	default:
 		fmt.Fprintf(pb, "%d %s %ss", obj.Count, which, typ)
 	}
 }
@@ -505,13 +683,17 @@ func nullstr(*RogueGame, *Object) string { return "" }
 // pr_list).
 func (g *RogueGame) prList() {
 	if !g.Options.Terse {
-		g.addmsg("for ")
+		g.addmsgf("for ")
 	}
-	g.addmsg("what type")
+
+	g.addmsgf("what type")
+
 	if !g.Options.Terse {
-		g.addmsg(" of object do you want a list")
+		g.addmsgf(" of object do you want a list")
 	}
+
 	g.msg("? ")
+
 	ch := g.readchar()
 	switch ch {
 	case Potion:
@@ -533,14 +715,17 @@ func (g *RogueGame) prList() {
 // (things.c pr_spec).
 func (g *RogueGame) prSpec(info []ObjInfo) {
 	lastprob := 0
+
 	i := byte('0')
 	for idx := range info {
 		if i == '9'+1 {
 			i = 'a'
 		}
+
 		g.addLine("%c: %s (%d%%)", i, info[idx].Name, info[idx].Prob-lastprob)
 		lastprob = info[idx].Prob
 		i++
 	}
+
 	g.endLine()
 }

game/types.go

@@ -90,22 +90,29 @@ const (
 	VsMagic        = 3
 )
 
-// Flags for rooms (rogue.h)
+// RoomFlags are the room state bits (rogue.h room flags).
 type RoomFlags int16
 
+// Room state bits (rogue.h ISDARK/ISGONE/ISMAZE).
 const (
 	Dark RoomFlags = 1 << iota // room is dark
 	Gone                       // room is gone (a corridor)
 	Maze                       // room is a maze
 )
 
-func (f RoomFlags) Has(b RoomFlags) bool { return f&b != 0 }
+// Has reports whether any of the given bits are set.
+func (f *RoomFlags) Has(b RoomFlags) bool { return *f&b != 0 }
+
+// Set turns the given bits on.
 func (f *RoomFlags) Set(b RoomFlags) { *f |= b }
+
+// Clear turns the given bits off.
 func (f *RoomFlags) Clear(b RoomFlags) { *f &^= b }
 
-// Flags for objects (rogue.h)
+// ObjFlags are the object state bits (rogue.h object flags).
 type ObjFlags int32
 
+// Object state bits (rogue.h).
 const (
 	Cursed    ObjFlags = 1 << iota // ISCURSED: object is cursed
 	Known                          // ISKNOW: player knows details about the object
@@ -115,15 +122,22 @@ const (
 	Protected                      // ISPROT: armor is permanently protected
 )
 
-func (f ObjFlags) Has(b ObjFlags) bool { return f&b != 0 }
+// Has reports whether any of the given bits are set.
+func (f *ObjFlags) Has(b ObjFlags) bool { return *f&b != 0 }
+
+// Set turns the given bits on.
 func (f *ObjFlags) Set(b ObjFlags) { *f |= b }
+
+// Clear turns the given bits off.
 func (f *ObjFlags) Clear(b ObjFlags) { *f &^= b }
 
-// Flags for creatures (rogue.h). The C bit collisions are deliberate and
+// CreatureFlags are the creature state bits (rogue.h creature flags). The
-// preserved: one name of each pair applies to monsters, the other to the
+// C bit collisions are deliberate and preserved: one name of each pair
-// hero, and they never coexist on one creature.
+// applies to monsters, the other to the hero, and they never coexist on
+// one creature.
 type CreatureFlags int32
 
+// Creature state bits (rogue.h).
 const (
 	CanConfuse      CreatureFlags = 0o000001 // CANHUH: creature can confuse
 	CanSeeInvisible CreatureFlags = 0o000002 // CANSEE: creature can see invisible creatures
@@ -146,13 +160,20 @@ const (
 	Slowed          CreatureFlags = 0o100000 // ISSLOW: creature has been slowed
 )
 
-func (f CreatureFlags) Has(b CreatureFlags) bool { return f&b != 0 }
+// Has reports whether any of the given bits are set.
+func (f *CreatureFlags) Has(b CreatureFlags) bool { return *f&b != 0 }
+
+// Set turns the given bits on.
 func (f *CreatureFlags) Set(b CreatureFlags) { *f |= b }
+
+// Clear turns the given bits off.
 func (f *CreatureFlags) Clear(b CreatureFlags) { *f &^= b }
 
-// Flags for the level map (rogue.h)
+// PlaceFlags are the per-map-cell bits (rogue.h level map flags). The low
+// bits double as the passage number (FPassNum) or trap kind (FTrapMask).
 type PlaceFlags uint8
 
+// Map cell bits (rogue.h).
 const (
 	FPassage  PlaceFlags = 0x80 // F_PASS: is a passageway
 	FSeen     PlaceFlags = 0x40 // have seen this spot before
@@ -163,14 +184,20 @@ const (
 	FTrapMask PlaceFlags = 0x07 // F_TMASK: trap number mask
 )
 
-func (f PlaceFlags) Has(b PlaceFlags) bool { return f&b != 0 }
+// Has reports whether any of the given bits are set.
+func (f *PlaceFlags) Has(b PlaceFlags) bool { return *f&b != 0 }
+
+// Set turns the given bits on.
 func (f *PlaceFlags) Set(b PlaceFlags) { *f |= b }
+
+// Clear turns the given bits off.
 func (f *PlaceFlags) Clear(b PlaceFlags) { *f &^= b }
 
 // TrapKind identifies a trap (rogue.h trap types). The kind is stored in
 // the low bits of a map cell's PlaceFlags (FTrapMask).
 type TrapKind int
 
+// Trap kinds (rogue.h T_* constants).
 const (
 	TrapDoor     TrapKind = 0
 	TrapArrow    TrapKind = 1
@@ -183,15 +210,6 @@ const (
 	NumTrapTypes          = 8
 )
 
-// String returns the trap's display name, article included, as the C
-// tr_name table had it.
-func (t TrapKind) String() string {
-	if t < 0 || t >= NumTrapTypes {
-		return "a bizarre trap"
-	}
-	return trName[t]
-}
-
 // PotionKind identifies a potion (rogue.h potion types).
 type PotionKind int
 
@@ -214,14 +232,6 @@ const (
 	NumPotionTypes
 )
 
-// String returns the potion's true name ("healing", "haste self", ...).
-func (p PotionKind) String() string {
-	if p < 0 || p >= NumPotionTypes {
-		return "strange potion"
-	}
-	return basePotInfo[p].Name
-}
-
 // ScrollKind identifies a scroll (rogue.h scroll types).
 type ScrollKind int
 
@@ -248,14 +258,6 @@ const (
 	NumScrollTypes
 )
 
-// String returns the scroll's true name ("magic mapping", ...).
-func (s ScrollKind) String() string {
-	if s < 0 || s >= NumScrollTypes {
-		return "strange scroll"
-	}
-	return baseScrInfo[s].Name
-}
-
 // WeaponKind identifies a weapon (rogue.h weapon types).
 type WeaponKind int
 
@@ -271,16 +273,11 @@ const (
 	WeaponShuriken
 	WeaponSpear
 	WeaponFlame // fake entry for dragon breath (ick)
-	NumWeaponTypes = WeaponFlame
 )
 
-// String returns the weapon's name ("mace", "two handed sword", ...).
+// NumWeaponTypes counts the real weapons; the flame pseudo-weapon sits
-func (w WeaponKind) String() string {
+// just past them in the tables (C's MAXWEAPONS == FLAME).
-	if w < 0 || w > WeaponFlame {
+const NumWeaponTypes = WeaponFlame
-		return "strange weapon"
-	}
-	return baseWeapInfo[w].Name
-}
 
 // ArmorKind identifies a suit of armor (rogue.h armor types).
 type ArmorKind int
@@ -298,14 +295,6 @@ const (
 	NumArmorTypes
 )
 
-// String returns the armor's name ("ring mail", "plate mail", ...).
-func (a ArmorKind) String() string {
-	if a < 0 || a >= NumArmorTypes {
-		return "strange armor"
-	}
-	return baseArmInfo[a].Name
-}
-
 // RingKind identifies a ring (rogue.h ring types).
 type RingKind int
 
@@ -328,14 +317,6 @@ const (
 	NumRingTypes
 )
 
-// String returns the ring's true name ("add strength", "stealth", ...).
-func (r RingKind) String() string {
-	if r < 0 || r >= NumRingTypes {
-		return "strange ring"
-	}
-	return baseRingInfo[r].Name
-}
-
 // WandKind identifies a wand or staff (rogue.h rod/wand/staff types).
 type WandKind int
 
@@ -358,14 +339,6 @@ const (
 	NumWandTypes
 )
 
-// String returns the wand/staff's true name ("lightning", ...).
-func (w WandKind) String() string {
-	if w < 0 || w >= NumWandTypes {
-		return "strange stick"
-	}
-	return baseWsInfo[w].Name
-}
-
 // Coord is a position on the level (rogue.h coord). A value type: the C
 // ce(a,b) macro is plain == here.
 type Coord struct {
@@ -425,6 +398,7 @@ func CTRL(c byte) byte { return c & 0o37 }
 func distance(y1, x1, y2, x2 int) int {
 	dx := x2 - x1
 	dy := y2 - y1
+
 	return dx*dx + dy*dy
 }
 
@@ -439,5 +413,6 @@ func sign(nm int) int {
 	case nm > 0:
 		return 1
 	}
+
 	return 0
 }

game/weapons.go

@@ -9,13 +9,15 @@ const noWeapon WeaponKind = -1
 // missile fires a missile in a given direction (weapons.c missile).
 func (g *RogueGame) missile(ydelta, xdelta int) {
 	// Get which thing we are hurling
-	obj := g.getItem("throw", KindWeapon)
+	obj, ok := g.promptPackItem("throw", KindWeapon)
-	if obj == nil {
+	if !ok {
 		return
 	}
+
 	if !g.dropCheck(obj) || g.isCurrent(obj) {
 		return
 	}
+
 	obj = g.leavePack(obj, true, false)
 	g.doMotion(obj, ydelta, xdelta)
 	// AHA! Here it has hit something.  If it is a wall or a door, or if
@@ -33,51 +35,64 @@ func (g *RogueGame) doMotion(obj *Object, ydelta, xdelta int) {
 	// Come fly with us ...
 	obj.Pos = p.Pos
 	for {
-		// Erase the old one
+		g.eraseFlight(obj, p.Pos)
-		if obj.Pos != p.Pos && g.cansee(obj.Pos.Y, obj.Pos.X) && !g.Options.Terse {
+		// Get the new position
+		obj.Pos.Y += ydelta
+		obj.Pos.X += xdelta
+
+		ch := g.Level.VisibleChar(obj.Pos.Y, obj.Pos.X)
+		if !stepOk(ch) || ch == Door {
+			break
+		}
+		// It hasn't hit anything yet, so display it if it's alright.
+		if g.canSee(obj.Pos.Y, obj.Pos.X) && !g.Options.Terse {
+			g.mvaddch(obj.Pos.Y, obj.Pos.X, obj.Kind.Glyph())
+			g.refresh()
+		}
+	}
+}
+
+// eraseFlight erases a flying object from its current square, unless it
+// still sits on the hero (the erase step of weapons.c do_motion).
+func (g *RogueGame) eraseFlight(obj *Object, heroPos Coord) {
+	if obj.Pos == heroPos || !g.canSee(obj.Pos.Y, obj.Pos.X) || g.Options.Terse {
+		return
+	}
+
 	ch := g.Level.Char(obj.Pos.Y, obj.Pos.X)
 	if ch == Floor && !g.showFloor() {
 		ch = ' '
 	}
+
 	g.mvaddch(obj.Pos.Y, obj.Pos.X, ch)
 }
-		// Get the new position
-		obj.Pos.Y += ydelta
-		obj.Pos.X += xdelta
-		ch := g.Level.VisibleChar(obj.Pos.Y, obj.Pos.X)
-		if stepOk(ch) && ch != Door {
-			// It hasn't hit anything yet, so display it if it's alright.
-			if g.cansee(obj.Pos.Y, obj.Pos.X) && !g.Options.Terse {
-				g.mvaddch(obj.Pos.Y, obj.Pos.X, obj.Kind.Glyph())
-				g.refresh()
-			}
-			continue
-		}
-		break
-	}
-}
 
 // fall drops an item someplace around here (weapons.c fall).
 func (g *RogueGame) fall(obj *Object, pr bool) {
 	if fpos, ok := g.fallpos(obj.Pos); ok {
 		pp := g.Level.At(fpos.Y, fpos.X)
 		pp.Ch = obj.Kind.Glyph()
+
 		obj.Pos = fpos
-		if g.cansee(fpos.Y, fpos.X) {
+		if g.canSee(fpos.Y, fpos.X) {
 			if pp.Monst != nil {
 				pp.Monst.OldCh = obj.Kind.Glyph()
 			} else {
 				g.mvaddch(fpos.Y, fpos.X, obj.Kind.Glyph())
 			}
 		}
-		attachObj(&g.Level.Objects, obj)
+
+		g.Level.AddObject(obj)
+
 		return
 	}
+
 	if pr {
 		if g.HasHit {
 			g.endmsg()
 			g.HasHit = false
 		}
+
 		g.msg("the %s vanishes as it hits the ground",
 			g.Items.Weapons[obj.Which].Name)
 	}
@@ -92,56 +107,58 @@ func (g *RogueGame) hitMonster(mp Coord, obj *Object) bool {
 // wield pulls out a certain weapon (weapons.c wield).
 func (g *RogueGame) wield() {
 	p := &g.Player
+
 	oweapon := p.CurWeapon
 	if !g.dropCheck(p.CurWeapon) {
 		p.CurWeapon = oweapon
+
 		return
 	}
+
 	p.CurWeapon = oweapon
-	obj := g.getItem("wield", KindWeapon)
+
-	if obj == nil {
+	obj, ok := g.promptPackItem("wield", KindWeapon)
+	if !ok {
 		g.After = false
+
 		return
 	}
+
 	if obj.Kind == KindArmor {
 		g.msg("you can't wield armor")
 		g.After = false
-		return
+
-	}
-	if g.isCurrent(obj) {
-		g.After = false
 		return
 	}
 
-	sp := g.invName(obj, true)
+	if g.isCurrent(obj) {
-	p.CurWeapon = obj
+		g.After = false
-	if !g.Options.Terse {
+
-		g.addmsg("you are now ")
+		return
 	}
+
+	sp := g.inventoryName(obj, true)
+	p.CurWeapon = obj
+
+	if !g.Options.Terse {
+		g.addmsgf("you are now ")
+	}
+
 	g.msg("wielding %s (%c)", sp, obj.PackCh)
 }
 
-// initWeaps is the weapons.c init_dam[] table.
+// weaponSetup is one row of the weapons.c init_dam[] table (see
-var initWeaps = [NumWeaponTypes]struct {
+// gameData.initWeaps).
+type weaponSetup struct {
 	dam    DiceSpec   // damage when wielded
 	hrl    DiceSpec   // damage when thrown
 	launch WeaponKind // launching weapon
 	flags  ObjFlags
-}{
-	{dice("2x4"), dice("1x3"), noWeapon, 0},                    // WeaponMace
-	{dice("3x4"), dice("1x2"), noWeapon, 0},                    // Long sword
-	{dice("1x1"), dice("1x1"), noWeapon, 0},                    // WeaponBow
-	{dice("1x1"), dice("2x3"), WeaponBow, Stackable | Missile}, // WeaponArrow
-	{dice("1x6"), dice("1x4"), noWeapon, Missile},              // WeaponDagger
-	{dice("4x4"), dice("1x2"), noWeapon, 0},                    // 2h sword
-	{dice("1x1"), dice("1x3"), noWeapon, Stackable | Missile},  // WeaponDart
-	{dice("1x2"), dice("2x4"), noWeapon, Stackable | Missile},  // Shuriken
-	{dice("2x3"), dice("1x6"), noWeapon, Missile},              // WeaponSpear
 }
 
 // initWeapon sets up a new weapon (weapons.c init_weapon).
 func (g *RogueGame) initWeapon(weap *Object, which WeaponKind) {
-	iwp := &initWeaps[which]
+	iwp := &g.data.initWeaps[which]
 	weap.Kind = KindWeapon
 	weap.Which = int(which)
 	weap.Damage = iwp.dam
@@ -149,16 +166,19 @@ func (g *RogueGame) initWeapon(weap *Object, which WeaponKind) {
 	weap.Launch = iwp.launch
 	weap.Flags = iwp.flags
 	weap.HPlus = 0
+
 	weap.DPlus = 0
-	if which == WeaponDagger {
+
+	switch {
+	case which == WeaponDagger:
 		weap.Count = g.rnd(4) + 2
 		weap.Group = g.Items.Group
 		g.Items.Group++
-	} else if weap.Flags.Has(Stackable) {
+	case weap.Flags.Has(Stackable):
 		weap.Count = g.rnd(8) + 8
 		weap.Group = g.Items.Group
 		g.Items.Group++
-	} else {
+	default:
 		weap.Count = 1
 		weap.Group = 0
 	}
@@ -170,6 +190,7 @@ func num(n1, n2 int, typ byte) string {
 	if typ == Weapon {
 		out += fmt.Sprintf(",%+d", n2)
 	}
+
 	return out
 }
 
@@ -177,7 +198,9 @@ func num(n1, n2 int, typ byte) string {
 // (weapons.c fallpos).
 func (g *RogueGame) fallpos(pos Coord) (Coord, bool) {
 	var newpos Coord
+
 	cnt := 0
+
 	for y := pos.Y - 1; y <= pos.Y+1; y++ {
 		for x := pos.X - 1; x <= pos.X+1; x++ {
 			// check to make certain the spot is empty, if it is, put the
@@ -187,6 +210,7 @@ func (g *RogueGame) fallpos(pos Coord) (Coord, bool) {
 				y < 0 || x < 0 {
 				continue
 			}
+
 			ch := g.Level.Char(y, x)
 			if ch == Floor || ch == Passage {
 				if cnt++; g.rnd(cnt) == 0 {
@@ -196,5 +220,6 @@ func (g *RogueGame) fallpos(pos Coord) (Coord, bool) {
 			}
 		}
 	}
+
 	return newpos, cnt != 0
 }

game/wizard.go

@@ -8,50 +8,86 @@ package game
 // create_obj).
 func (g *RogueGame) createObj() {
 	obj := newObject()
+
 	g.msg("type of item: ")
 	obj.Kind = objectKindForGlyph(g.readchar())
 	g.Msgs.Mpos = 0
 	g.msg("which %c do you want? (0-f)", obj.Kind.Glyph())
+
 	ch := g.readchar()
 	if isDigit(ch) {
 		obj.Which = int(ch - '0')
 	} else {
 		obj.Which = int(ch-'a') + 10
 	}
+
 	obj.Group = 0
 	obj.Count = 1
 	g.Msgs.Mpos = 0
-	switch {
+
-	case obj.Kind == KindWeapon || obj.Kind == KindArmor:
+	switch obj.Kind {
+	case KindWeapon, KindArmor:
+		g.createWeaponArmor(obj)
+	case KindRing:
+		g.createRing(obj)
+	case KindWand:
+		g.fixStick(obj)
+	case KindGold:
+		g.msg("how much?")
+
+		buf := ""
+		if g.getStr(&buf, g.scr.Std) == Norm {
+			obj.GoldValue = cAtoi(buf)
+		}
+	}
+
+	g.addPack(obj, false)
+}
+
+// createWeaponArmor sets up a wizard-created weapon or armor with an
+// optional blessing (the weapon/armor arm of wizard.c create_obj).
+func (g *RogueGame) createWeaponArmor(obj *Object) {
 	g.msg("blessing? (+,-,n)")
 	bless := g.readchar()
 	g.Msgs.Mpos = 0
+
 	if bless == '-' {
 		obj.Flags.Set(Cursed)
 	}
+
 	if obj.Kind == KindWeapon {
 		g.initWeapon(obj, WeaponKind(obj.Which))
+
 		if bless == '-' {
 			obj.HPlus -= g.rnd(3) + 1
 		}
+
 		if bless == '+' {
 			obj.HPlus += g.rnd(3) + 1
 		}
-		} else {
+
-			obj.ArmorClass = aClass[obj.Which]
+		return
+	}
+
+	obj.ArmorClass = g.data.aClass[obj.Which]
 	if bless == '-' {
 		obj.ArmorClass += g.rnd(3) + 1
 	}
+
 	if bless == '+' {
 		obj.ArmorClass -= g.rnd(3) + 1
 	}
 }
-	case obj.Kind == KindRing:
+
+// createRing sets up a wizard-created ring, prompting for a bonus on
+// the bonus rings (the ring arm of wizard.c create_obj).
+func (g *RogueGame) createRing(obj *Object) {
 	switch obj.RingKind() {
 	case RingProtection, RingAddStrength, RingDexterity, RingIncreaseDamage:
 		g.msg("blessing? (+,-,n)")
 		bless := g.readchar()
 		g.Msgs.Mpos = 0
+
 		if bless == '-' {
 			obj.Flags.Set(Cursed)
 			obj.Bonus = -1
@@ -61,34 +97,28 @@ func (g *RogueGame) createObj() {
 	case RingAggravateMonsters, RingTeleportation:
 		obj.Flags.Set(Cursed)
 	}
-	case obj.Kind == KindWand:
-		g.fixStick(obj)
-	case obj.Kind == KindGold:
-		g.msg("how much?")
-		buf := ""
-		if g.getStr(&buf, g.scr.Std) == Norm {
-			obj.GoldValue = cAtoi(buf)
-		}
-	}
-	g.addPack(obj, false)
 }
 
 // showMap prints out the whole map for the wizard (wizard.c show_map).
 func (g *RogueGame) showMap() {
 	hw := g.scr.Hw
 	hw.Clear()
+
 	for y := 1; y < NumLines-1; y++ {
-		for x := 0; x < NumCols; x++ {
+		for x := range NumCols {
-			real := g.Level.FlagsAt(y, x).Has(FReal)
+			isReal := g.Level.FlagsAt(y, x).Has(FReal)
-			if !real {
+			if !isReal {
 				hw.Standout(true)
 			}
+
 			hw.MvAddCh(y, x, g.Level.Char(y, x))
-			if !real {
+
+			if !isReal {
 				hw.Standout(false)
 			}
 		}
 	}
+
 	g.showWin("---More (level map)---")
 }
 
@@ -97,30 +127,12 @@ func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
 	p := &g.Player
 	if len(p.Pack) == 0 {
 		g.msg("you don't have anything in your pack to identify")
+
 		return
 	}
 
-	var obj *Object
+	obj, ok := g.whatisPick(insist, kind)
-	for {
+	if !ok {
-		obj = g.getItem("identify", kind)
-		if !insist {
-			break
-		}
-		if g.NObjs == 0 {
-			return
-		}
-		if obj == nil {
-			g.msg("you must identify something")
-		} else if kind != KindNone && obj.Kind != kind &&
-			!(kind == KindRingOrStick &&
-				(obj.Kind == KindRing || obj.Kind == KindWand)) {
-			g.msg("you must identify a %s", kind)
-		} else {
-			break
-		}
-	}
-
-	if obj == nil {
 		return
 	}
 
@@ -136,7 +148,39 @@ func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
 	case KindRing:
 		setKnow(obj, g.Items.Rings[:])
 	}
-	g.msg("%s", g.invName(obj, false))
+
+	g.msg("%s", g.inventoryName(obj, false))
+}
+
+// whatisPick prompts for the item to identify, re-asking until a
+// matching one is chosen when insist is set; ok is false when the
+// player gives up (the prompt loop of wizard.c whatis).
+func (g *RogueGame) whatisPick(insist bool, kind ObjectKind) (*Object, bool) {
+	for {
+		obj, _ := g.promptPackItem("identify", kind)
+
+		if !insist {
+			return obj, obj != nil
+		}
+
+		if g.NObjs == 0 {
+			return nil, false
+		}
+
+		if obj == nil {
+			g.msg("you must identify something")
+
+			continue
+		}
+
+		if !matchesFilter(kind, obj) {
+			g.msg("you must identify a %s", kind)
+
+			continue
+		}
+
+		return obj, true
+	}
 }
 
 // setKnow sets things up when we really know what a thing is (wizard.c
@@ -154,15 +198,18 @@ func setKnow(obj *Object, info []ObjInfo) {
 func (g *RogueGame) teleport() {
 	p := &g.Player
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())
-	c, _ := g.findFloor(nil, 0, true)
+
-	if g.roomin(c) != p.Room {
+	c, _ := g.findFloor(true)
+	if g.roomIn(c) != p.Room {
 		g.leaveRoom(p.Pos)
 		p.Pos = c
 		g.enterRoom(p.Pos)
 	} else {
 		p.Pos = c
+
 		g.look(true)
 	}
+
 	g.mvaddch(p.Pos.Y, p.Pos.X, PlayerCh)
 	// turn off ISHELD in case teleportation was done while fighting a
 	// Flytrap
@@ -171,6 +218,7 @@ func (g *RogueGame) teleport() {
 		p.VfHit = 0
 		g.Monsters['F'-'A'].Stats.Dmg = dice("000x0")
 	}
+
 	g.NoMove = 0
 	g.Count = 0
 	g.Running = false

term/tcell.go

@@ -5,6 +5,8 @@
 package term
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -21,6 +23,9 @@ type Tcell struct {
 	last   *game.Window // last rendered window, for resize redraws
 }
 
+// ErrScreenTooSmall reports a terminal below the required 80x24.
+var ErrScreenTooSmall = errors.New("screen too small")
+
 // New initializes the terminal. The screen must be at least 80x24, as the
 // C game required.
 func New() (*Tcell, error) {
@@ -28,16 +33,22 @@ func New() (*Tcell, error) {
 	if err != nil {
 		return nil, err
 	}
-	if err := s.Init(); err != nil {
+
-		return nil, err
+	initErr := s.Init()
+	if initErr != nil {
+		return nil, initErr
 	}
+
 	w, h := s.Size()
 	if h < game.NumLines || w < game.NumCols {
 		s.Fini()
-		return nil, fmt.Errorf("sorry, the screen must be at least %dx%d",
+
-			game.NumLines, game.NumCols)
+		return nil, fmt.Errorf("sorry, %w: %dx%d required",
+			ErrScreenTooSmall, game.NumCols, game.NumLines)
 	}
+
 	s.HideCursor()
+
 	return &Tcell{screen: s}, nil
 }
 
@@ -49,17 +60,21 @@ func (t *Tcell) Fini() {
 // Render blits a game window to the terminal (curses refresh).
 func (t *Tcell) Render(w *game.Window) {
 	t.last = w
+
 	rows, cols := w.Size()
-	for y := 0; y < rows; y++ {
+	for y := range rows {
-		for x := 0; x < cols; x++ {
+		for x := range cols {
 			ch, standout := w.CellAt(y, x)
+
 			style := tcell.StyleDefault
 			if standout {
 				style = style.Reverse(true)
 			}
+
 			t.screen.SetContent(x, y, rune(ch), nil, style)
 		}
 	}
+
 	t.screen.Show()
 }
 
@@ -74,62 +89,114 @@ func (t *Tcell) ReadChar() byte {
 				t.Render(t.last)
 			}
 		case *tcell.EventKey:
-			switch ev.Key() {
+			if b, ok := translateKey(ev); ok {
-			case tcell.KeyUp:
+				return b
-				return 'k'
-			case tcell.KeyDown:
-				return 'j'
-			case tcell.KeyLeft:
-				return 'h'
-			case tcell.KeyRight:
-				return 'l'
-			case tcell.KeyHome:
-				return 'y'
-			case tcell.KeyPgUp:
-				return 'u'
-			case tcell.KeyEnd:
-				return 'b'
-			case tcell.KeyPgDn:
-				return 'n'
-			case tcell.KeyEnter:
-				return '\n'
-			case tcell.KeyEscape:
-				return game.Escape
-			case tcell.KeyBackspace, tcell.KeyBackspace2:
-				return 8
-			case tcell.KeyDelete:
-				return 0x7f
-			case tcell.KeyTab:
-				return '\t'
-			case tcell.KeyCtrlC:
-				return 3
-			default:
-				if ev.Key() >= tcell.KeyCtrlA && ev.Key() <= tcell.KeyCtrlZ {
-					return byte(ev.Key())
-				}
-				if r := ev.Rune(); r > 0 && r < 0x80 {
-					return byte(r)
-				}
 			}
 		}
 	}
 }
 
+// translateKey converts a key event to a game input byte; ok is false
+// for keys the C game does not understand.
+func translateKey(ev *tcell.EventKey) (byte, bool) {
+	if b, ok := namedKey(ev.Key()); ok {
+		return b, true
+	}
+
+	if ev.Key() >= tcell.KeyCtrlA && ev.Key() <= tcell.KeyCtrlZ {
+		return byte(ev.Key()), true //nolint:gosec // G115: 1..26 fits
+	}
+
+	if r := ev.Rune(); r > 0 && r < 0x80 {
+		return byte(r), true
+	}
+
+	return 0, false
+}
+
+// namedKey translates tcell's navigation and editing keys to the single
+// bytes the C game reads (arrows become hjkl, etc.); ok is false for
+// keys handled elsewhere.
+func namedKey(k tcell.Key) (byte, bool) {
+	if b, ok := motionKey(k); ok {
+		return b, true
+	}
+
+	return editingKey(k)
+}
+
+// motionKey translates the arrow and paging keys to Rogue's movement
+// letters (tcell.go ReadChar).
+func motionKey(k tcell.Key) (byte, bool) {
+	switch k {
+	case tcell.KeyUp:
+		return 'k', true
+	case tcell.KeyDown:
+		return 'j', true
+	case tcell.KeyLeft:
+		return 'h', true
+	case tcell.KeyRight:
+		return 'l', true
+	case tcell.KeyHome:
+		return 'y', true
+	case tcell.KeyPgUp:
+		return 'u', true
+	case tcell.KeyEnd:
+		return 'b', true
+	case tcell.KeyPgDn:
+		return 'n', true
+	}
+
+	return 0, false
+}
+
+// editingKey translates the editing and control keys to their C0 codes
+// (tcell.go ReadChar).
+func editingKey(k tcell.Key) (byte, bool) {
+	switch k {
+	case tcell.KeyEnter:
+		return '\n', true
+	case tcell.KeyEscape:
+		return game.Escape, true
+	case tcell.KeyBackspace, tcell.KeyBackspace2:
+		return 8, true
+	case tcell.KeyDelete:
+		return 0x7f, true
+	case tcell.KeyTab:
+		return '\t', true
+	case tcell.KeyCtrlC:
+		return 3, true
+	}
+
+	return 0, false
+}
+
 // ShellEscape suspends the screen and runs the user's shell (main.c
 // shell + md_shellescape).
 func (t *Tcell) ShellEscape() {
-	if err := t.screen.Suspend(); err != nil {
+	err := t.screen.Suspend()
+	if err != nil {
 		return
 	}
+
 	shell := os.Getenv("SHELL")
 	if shell == "" {
 		shell = "/bin/sh"
 	}
-	fmt.Println("[Entering shell; exit to return to the game]")
+
-	cmd := exec.Command(shell)
+	_, _ = fmt.Fprintln(os.Stdout,
+		"[Entering shell; exit to return to the game]")
+
+	// The shell session has no deadline by design; Background context.
+	cmd := exec.CommandContext(context.Background(), //nolint:gosec // G204: the user's own $SHELL
+		shell)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.Run()
+	_ = cmd.Run() // best effort: the shell is the user's business
-	t.screen.Resume()
+
+	resumeErr := t.screen.Resume()
+	if resumeErr != nil {
+		panic(resumeErr) // terminal resume failure is unrecoverable
+	}
 }