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

@@ -16,6 +16,10 @@ linters:
     - 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:

MEMORY.md

@@ -1,40 +1,41 @@
 # Project Memory
 
-Working notes for agents on this repo. Read this alongside TODO.md
+Working notes for agents on this repo. Read this alongside TODO.md (which holds
-(which holds the step queue and workflow) before starting work.
+the step queue and workflow) before starting work.
 
 ## Error handling
 
-Panicking on bad/unexpected errors is allowed and preferred over
+Panicking on bad/unexpected errors is allowed and preferred over threading
-threading unlikely error returns through game code — e.g. write-side
+unlikely error returns through game code — e.g. write-side Close/encode failures
-Close/encode failures where continuing would mean corrupt state. The
+where continuing would mean corrupt state. The game already unwinds C's exit()
-game already unwinds C's exit() calls via a gameEnd panic recovered in
+calls via a gameEnd panic recovered in Run. Return errors where a caller
-Run. Return errors where a caller genuinely handles them (save-file
+genuinely handles them (save-file prompts, restore validation). Reserve
-prompts, restore validation). Reserve deliberate `_ =` discards for
+deliberate `_ =` discards for true best-effort paths (scorefile writes,
-true best-effort paths (scorefile writes, signal-time autosave), always
+signal-time autosave), always with a comment saying why.
-with a comment saying why.
 
 ## Linting
 
-The .golangci.yml is the house standard and may only be modified with
+The .golangci.yml is the house standard and may only be modified with sneak's
-sneak's explicit permission. To disable a linter, ask, explaining what
+explicit permission. To disable a linter, ask, explaining what the linter does;
-the linter does; he approves specific exceptions, which are recorded
+he approves specific exceptions, which are recorded in the config's
-in the config's "Repo-specific exceptions" block with the approval
+"Repo-specific exceptions" block with the approval date. Approved so far:
-date. Approved so far: paralleltest (2026-07-06). Line-level //nolint
+paralleltest (2026-07-06); testpackage, exhaustive, and mnd (2026-07-07). The
-with a reason is used sparingly for C-faithfulness (e.g. the authentic
+complexity linters (cyclop, gocognit, nestif) are enabled and clean as of
-"missle" message spellings) and provably-safe gosec conversions; each
+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
+Behavior must not change during the idiomatic-Go refactor unless a TODO step
-TODO step says so. The 80x24 seed-compatible gameplay, message text
+says so. The 80x24 seed-compatible gameplay, message text (including original
-(including original typos), RNG call order, and C quirks (documented
+typos), RNG call order, and C quirks (documented in tests like
-in tests like TestHoldScrollGreedyMonsterQuirk) are contract. Doc
+TestHoldScrollGreedyMonsterQuirk) are contract. Doc comments keep their "(file.c
-comments keep their "(file.c func_name)" breadcrumbs.
+func_name)" breadcrumbs.
 
 ## Debugging
 
-Write real, committed test files with t.Logf output and run plain
+Write real, committed test files with t.Logf output and run plain `go test -v`;
-`go test -v`; no throwaway scratch scripts. Successful debug probes
+no throwaway scratch scripts. Successful debug probes become regression tests.
-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,130 +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
 
-Finish adopting the house Go linting standards. Done so far (branch
+Broaden unit test coverage where playtesting finds thin spots (rings, sticks,
-refactor/lint-adoption): .golangci.yml copied verbatim from the
+wizard commands).
-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). Remaining findings
-are all in linters awaiting sneak's exception decision: mnd (288),
-gochecknoglobals (37), cyclop (36), nestif (30), gocognit (23),
-exhaustive (22), goconst (16), testpackage (9). Blocked on that
-decision; either disable with approval or scope the fixes.
 
 # 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

@@ -21,18 +21,20 @@ func main() {
 	os.Exit(run())
 }
 
-// run carries the real main so that deferred terminal restoration runs
+// run does the real work and returns an exit code. It only returns on a
-// before the process exits (os.Exit skips defers).
+// 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()
 
-	cfg := loadConfig()
+	params := loadParams()
 
 	if *scores {
-		game.NewGame(cfg).ShowScores()
+		game.New(params).ShowScores()
 
 		return 0
 	}
@@ -45,46 +47,39 @@ func run() int {
 	}
 	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)
 
 			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 0
 	}
 
 	installAutosave(g, t)
 
-	runErr := g.Run()
+	g.Run() // does not return: the game ends by exiting the process
-	if runErr != nil {
-		t.Fini()
-		fmt.Fprintln(os.Stderr, runErr)
-
-		return 1
-	}
 
 	return 0
 }
 
-// loadConfig gathers the game configuration from the environment: home
+// loadParams gathers the game parameters from the environment: home
 // directory, ROGUEOPTS, user name, wizard mode, and the dungeon seed
 // (main.c's startup).
-func loadConfig() game.Config {
+func loadParams() game.Params {
 	home, _ := os.UserHomeDir()
 
 	name := ""
@@ -96,7 +91,7 @@ func loadConfig() game.Config {
 
 	wizard := os.Getenv("ROGUE_WIZARD") != ""
 
-	return game.Config{
+	return game.Params{
 		Seed:      chooseSeed(wizard),
 		Name:      name,
 		RogueOpts: os.Getenv("ROGUEOPTS"),
@@ -133,6 +128,6 @@ func chooseSeed(wizard bool) int32 {
 
 	// 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) + //nolint:gosec // G115: deliberate wrap
+	return int32(time.Now().Unix()&0x7fffffff) +
-		int32(os.Getpid()&0x7fffffff) //nolint:gosec // G115: deliberate wrap
+		int32(os.Getpid()&0x7fffffff)
 }

game/armor.go

@@ -6,8 +6,8 @@ package game
 func (g *RogueGame) wear() {
 	p := &g.Player
 
-	obj := g.getItem("wear", KindArmor)
+	obj, ok := g.promptPackItem("wear", KindArmor)
-	if obj == nil {
+	if !ok {
 		return
 	}
 
@@ -32,7 +32,7 @@ func (g *RogueGame) wear() {
 
 	g.wasteTime()
 	obj.Flags.Set(Known)
-	sp := g.invName(obj, true)
+	sp := g.inventoryName(obj, true)
 	p.CurArmor = obj
 
 	if !g.Options.Terse {
@@ -70,7 +70,7 @@ func (g *RogueGame) takeOff() {
 		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,26 +9,7 @@ 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 {
@@ -37,24 +18,52 @@ func (g *RogueGame) runners(int) {
 	}
 }
 
-// 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
@@ -62,8 +71,8 @@ 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)
 
@@ -86,12 +95,48 @@ 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 {
@@ -102,17 +147,28 @@ func (g *RogueGame) doChase(th *Monster) int {
 	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 {
@@ -121,91 +177,85 @@ over:
 			}
 		}
 
-		if door {
+		if !door {
-			rer = &g.Level.Passages[*g.Level.FlagsAt(th.Pos.Y, th.Pos.X)&FPassNum]
+			return this, false
-			door = false
-
-			goto over
 		}
-	} else {
-		this = *th.Dest
-		// For dragons check and see if (a) the hero is on a straight line
-		// from it, and (b) that it is within shooting distance, but
-		// outside of striking range.
-		if th.Type == 'D' && (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)) &&
-			distCp(th.Pos, p.Pos) <= BoltLength*BoltLength &&
-			!th.On(Cancelled) && g.rnd(dragonShot) == 0 {
-			g.Delta.Y = sign(p.Pos.Y - th.Pos.Y)
 
-			g.Delta.X = sign(p.Pos.X - th.Pos.X)
+		rer = &g.Level.Passages[*g.Level.FlagsAt(th.Pos.Y, th.Pos.X)&FPassNum]
-			if g.HasHit {
+		door = false
-				g.endmsg()
+		// the C goto over: redo with the passage as room
-			}
-
-			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
-		}
 	}
-	// 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 this == p.Pos {
-			return g.attack(th)
-		} else if this == *th.Dest {
-			for _, obj := range g.Level.Objects {
-				if th.Dest == &obj.Pos {
-					detachObj(&g.Level.Objects, obj)
-					attachObj(&th.Pack, obj)
 
-					if th.Room.Flags.Has(Gone) {
+// dragonBreath checks whether a dragon shoots flame at the hero instead
-						g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Passage)
+// of moving, and shoots it (the D block of chase.c do_chase).
-					} else {
+func (g *RogueGame) dragonBreath(th *Monster) bool {
-						g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Floor)
+	if th.Type != 'D' || !g.dragonShoots(th) {
-					}
+		return false
-
-					th.Dest = g.findDest(th)
-
-					break
-				}
-			}
-
-			if th.Type != 'F' {
-				stoprun = true
-			}
-		}
-	} else {
-		if th.Type == 'F' {
-			return 0
-		}
 	}
 
-	g.relocate(th, g.chRet)
+	p := &g.Player
-	// And stop running if need be
+
-	if stoprun && th.Pos == *th.Dest {
+	g.Delta.Y = sign(p.Pos.Y - th.Pos.Y)
-		th.Flags.Clear(Awake)
+
+	g.Delta.X = sign(p.Pos.X - th.Pos.X)
+	if g.HasHit {
+		g.endmsg()
 	}
 
-	return 0
+	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 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
+	}
+
+	return distCp(th.Pos, p.Pos) <= BoltLength*BoltLength &&
+		!th.On(Cancelled) && g.rnd(dragonShot) == 0
+}
+
+// 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 {
+			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
+		}
+	}
 }
 
 // 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
@@ -214,88 +264,109 @@ 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.
-		curdist = distCp(er, ee)
-		g.chRet = er
 
-		ey := er.Y + 1
+	return curdist != 0 && g.chRet != g.Player.Pos
-		if ey >= NumLines-1 {
+}
-			ey = NumLines - 2
+
+// 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
+	}
+
+	for x := er.X - 1; x <= ex; x++ {
+		if x < 0 {
+			continue
 		}
 
-		ex := er.X + 1
+		for y := er.Y - 1; y <= ey; y++ {
-		if ex >= NumCols {
+			g.chaseTry(&s, y, x)
-			ex = NumCols - 1
-		}
-
-		for x := er.X - 1; x <= ex; x++ {
-			if x < 0 {
-				continue
-			}
-
-			for y := er.Y - 1; y <= ey; y++ {
-				tryp := Coord{X: x, Y: y}
-				if !g.diagOk(er, tryp) {
-					continue
-				}
-
-				ch := g.Level.VisibleChar(y, x)
-				if stepOk(ch) {
-					// 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 {
-						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
-						}
-					}
-					// 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
-					}
-					// If we didn't find any scrolls at this place or it
-					// wasn't a scare scroll, then this place counts
-					thisdist := distance(y, x, ee.Y, ee.X)
-					if thisdist < curdist {
-						plcnt = 1
-						g.chRet = tryp
-						curdist = thisdist
-					} else if thisdist == curdist {
-						if plcnt++; g.rnd(plcnt) == 0 {
-							g.chRet = tryp
-							curdist = thisdist
-						}
-					}
-				}
-			}
 		}
 	}
 
-	return curdist != 0 && g.chRet != p.Pos
+	return s.curdist
 }
 
-// setOldch sets the oldch character for the monster (chase.c set_oldch).
+// chaseTry scores one candidate square, reservoir-sampling among ties
-func (g *RogueGame) setOldch(tp *Monster, cp Coord) {
+// (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(s.er, tryp) {
+		return
+	}
+
+	ch := g.Level.VisibleChar(y, x)
+	if !stepOk(ch) {
+		return
+	}
+	// 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' {
+		return
+	}
+	// If we didn't find any scrolls at this place or it wasn't a scare
+	// scroll, then this place counts
+	thisdist := distance(y, x, s.ee.Y, s.ee.X)
+	if thisdist < s.curdist {
+		s.plcnt = 1
+		g.chRet = tryp
+		s.curdist = thisdist
+	} else if thisdist == s.curdist {
+		if s.plcnt++; g.rnd(s.plcnt) == 0 {
+			g.chRet = tryp
+			s.curdist = thisdist
+		}
+	}
+}
+
+// scareScrollAt reports whether the object lying at (y, x) is a scare
+// 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
 	}
@@ -341,8 +412,8 @@ func (g *RogueGame) seeMonst(mp *Monster) bool {
 	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
@@ -353,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]
@@ -387,9 +458,9 @@ func (g *RogueGame) diagOk(sp, ep Coord) bool {
 	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
@@ -408,7 +479,7 @@ func (g *RogueGame) cansee(y, x int) bool {
 	}
 	// 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)
 }
@@ -426,22 +497,23 @@ func (g *RogueGame) findDest(tp *Monster) *Coord {
 			continue
 		}
 
-		if g.roomin(obj.Pos) == tp.Room && g.rnd(100) < prob {
+		if g.roomIn(obj.Pos) == tp.Room && g.rnd(100) < prob &&
-			claimed := false
+			!g.objectClaimed(obj) {
-
+			return &obj.Pos
-			for _, other := range g.Level.Monsters {
-				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

@@ -50,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...)

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
@@ -141,50 +117,9 @@ func (g *RogueGame) stomach(int) {
 
 	origHungry := p.HungryState
 	if p.FoodLeft <= 0 {
-		if p.FoodLeft--; p.FoodLeft < -StarveTime {
+		g.stomachFaint()
-			g.death('s')
-		}
-		// the hero is fainting
-		if g.NoCommand != 0 || g.rnd(5) != 0 {
-			return
-		}
-
-		g.NoCommand += g.rnd(8) + 4
-		p.HungryState = 3
-
-		if !g.Options.Terse {
-			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 {
-		oldfood := p.FoodLeft
+		g.stomachDigest()
-
-		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 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 {
-				g.msg("%s", g.chooseStr("you are getting the munchies",
-					"you are starting to get hungry"))
-			}
-		}
 	}
 
 	if p.HungryState != origHungry {
@@ -196,6 +131,61 @@ func (g *RogueGame) stomach(int) {
 	}
 }
 
+// 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')
+	}
+	// the hero is fainting
+	if g.NoCommand != 0 || g.rnd(5) != 0 {
+		return
+	}
+
+	g.NoCommand += g.rnd(8) + 4
+	p.HungryState = 3
+
+	if !g.Options.Terse {
+		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"))
+}
+
+// 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 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 {
+			g.msg("%s", g.chooseStr("you are getting the munchies",
+				"you are starting to get hungry"))
+		}
+	}
+}
+
 // comeDown takes the hero down off her acid trip (daemons.c come_down).
 func (g *RogueGame) comeDown(int) {
 	p := &g.Player
@@ -212,7 +202,7 @@ 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())
 		}
 	}
@@ -223,7 +213,7 @@ func (g *RogueGame) comeDown(int) {
 	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 {
@@ -242,24 +232,29 @@ func (g *RogueGame) comeDown(int) {
 // 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)

game/dice_test.go

@@ -32,15 +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

@@ -7,10 +7,10 @@ import "testing"
 func mkGameInput(t *testing.T) *RogueGame {
 	t.Helper()
 
-	g := NewGame(Config{Seed: 5, Term: &testTerm{}})
+	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
 }
@@ -183,7 +183,7 @@ func TestZapSlowMonster(t *testing.T) {
 }
 
 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 {

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 {
@@ -84,66 +47,82 @@ 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) {
-		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!",
+	if g.revealXeroc(tp) && !thrown {
-			"wait!  That's a xeroc!"))
+		return false
-
-		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)
 
-		if thrown {
+		return true
-			g.thunk(weap, mname, g.Options.Terse)
-		} else {
-			g.hit("", mname, g.Options.Terse)
-		}
-
-		if p.On(CanConfuse) {
-			didHit = 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) {
-			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
+	if thrown {
+		g.bounce(weap, mname, g.Options.Terse)
+	} else {
+		g.miss("", mname, g.Options.Terse)
+	}
+
+	return false
 }
 
-// attack has the monster attack the player (fight.c attack). Returns -1 if
+// revealXeroc lets him know it was really a xeroc (if it was one); it
-// the monster removed itself from the level during its own attack.
+// reports whether one was unmasked (the X block of fight.c fight).
-func (g *RogueGame) attack(mp *Monster) int {
+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) {
+		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 confused && !p.On(Blind) {
+		g.msg("%s appears confused", mname)
+	}
+}
+
+// attack has the monster attack the player (fight.c attack). The result
+// reports that the monster took itself off the level during its own
+// 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.
@@ -167,184 +146,10 @@ func (g *RogueGame) attack(mp *Monster) int {
 	oldhp := p.Stats.HP
 	removed := false
 
-	if g.rollEm(&mp.Creature, &p.Creature, nil, false) {
+	if g.rollAttacks(&mp.Creature, &p.Creature, nil, false) {
-		if mp.Type != 'I' {
+		removed = g.monsterHit(mp, mname, oldhp)
-			if g.HasHit {
+	} else {
-				g.addmsgf(".  ")
+		g.monsterMiss(mp, mname)
-			}
-
-			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 ...
-		} else if !g.Kamikaze {
-			oldhp -= p.Stats.HP
-			if oldhp > g.MaxHit {
-				g.MaxHit = oldhp
-			}
-
-			if p.Stats.HP <= g.MaxHit {
-				g.ToDeath = false
-			}
-		}
-
-		if !mp.On(Cancelled) {
-			switch mp.Type {
-			case 'A':
-				// 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.addmsgf("you are frozen")
-
-					if !g.Options.Terse {
-						g.addmsgf(" 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")
-						}
-					}
-				}
-			case 'W', 'V':
-				// Wraiths might drain energy levels, and Vampires can
-				// steal max_hp
-				chance := 30
-				if mp.Type == 'W' {
-					chance = 15
-				}
-
-				if g.rnd(100) < chance {
-					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 = 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.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 {
@@ -354,11 +159,236 @@ func (g *RogueGame) attack(mp *Monster) int {
 	g.Count = 0
 	g.status()
 
-	if removed {
+	return removed
-		return -1
+}
+
+// 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.addmsgf(".  ")
+		}
+
+		g.hit(mname, "", false)
+	} else if g.HasHit {
+		g.endmsg()
 	}
 
-	return 0
+	g.HasHit = false
+	if p.Stats.HP <= 0 {
+		g.death(mp.Type) // Bye bye life ...
+	} else if !g.Kamikaze {
+		oldhp -= p.Stats.HP
+		if oldhp > g.MaxHit {
+			g.MaxHit = oldhp
+		}
+
+		if p.Stats.HP <= g.MaxHit {
+			g.ToDeath = false
+		}
+	}
+
+	if !mp.On(Cancelled) {
+		if h := g.data.hitHandlers[mp.Type-'A']; h != nil {
+			return h(g, mp, mname)
+		}
+	}
+
+	return false
+}
+
+// monsterMiss handles a monster's whiffed swing (the miss arm of
+// fight.c attack); ice monsters miss silently.
+func (g *RogueGame) monsterMiss(mp *Monster, mname string) {
+	if mp.Type == 'I' {
+		return
+	}
+
+	p := &g.Player
+
+	if g.HasHit {
+		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)
+}
+
+// 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
+}
+
+func (g *RogueGame) hitIceMonster(_ *Monster, mname string) bool {
+	// The ice monster freezes you
+	g.Player.Flags.Clear(Awake)
+
+	if g.NoCommand == 0 {
+		g.addmsgf("you are frozen")
+
+		if !g.Options.Terse {
+			g.addmsgf(" by the %s", mname)
+		}
+
+		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).
@@ -369,9 +399,8 @@ func (g *RogueGame) swing(atLvl, opArm, wplus int) bool {
 	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
 
@@ -383,34 +412,7 @@ func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool
 	if weap == nil {
 		attacks = att.Dmg
 	} else {
-		hplus = weap.HPlus
+		attacks, hplus, dplus = g.weaponAttack(weap, hurl)
-
-		dplus = weap.DPlus
-		if weap == p.CurWeapon {
-			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
-			}
-		}
-
-		attacks = weap.Damage
-		if hurl {
-			if weap.Flags.Has(Missile) && p.CurWeapon != nil &&
-				WeaponKind(p.CurWeapon.Which) == weap.Launch {
-				attacks = weap.HurlDmg
-				hplus += p.CurWeapon.HPlus
-				dplus += p.CurWeapon.DPlus
-			} else if weap.Launch < 0 {
-				attacks = weap.HurlDmg
-			}
-		}
 	}
 	// If the creature being attacked is not running (asleep or held) then
 	// the attacker gets a plus four bonus to hit.
@@ -418,6 +420,79 @@ func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool
 		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 {
+		hplus, dplus = g.wieldedRingBonus(hplus, dplus)
+	}
+
+	attacks := weap.Damage
+	if hurl {
+		if weap.Flags.Has(Missile) && p.CurWeapon != nil &&
+			WeaponKind(p.CurWeapon.Which) == weap.Launch {
+			attacks = weap.HurlDmg
+			hplus += p.CurWeapon.HPlus
+			dplus += p.CurWeapon.DPlus
+		} else if weap.Launch < 0 {
+			attacks = weap.HurlDmg
+		}
+	}
+
+	return attacks, hplus, dplus
+}
+
+// wieldedRingBonus folds damage and dexterity ring bonuses into the
+// wielded weapon's to-hit/damage pluses (fight.c roll_em).
+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 {
@@ -433,22 +508,7 @@ func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool
 		}
 	}
 
-	didHit := false
+	return defArm
-
-	for _, atk := range attacks {
-		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
@@ -515,7 +575,7 @@ func (g *RogueGame) hit(er, ee string, noend bool) {
 			i += 4
 		}
 
-		s = hNames[i]
+		s = g.data.hNames[i]
 	}
 
 	g.addmsgf("%s", s)
@@ -546,7 +606,7 @@ func (g *RogueGame) miss(er, ee string, noend bool) {
 		i += 4
 	}
 
-	g.addmsgf("%s", mNames[i])
+	g.addmsgf("%s", g.data.mNames[i])
 
 	if !g.Options.Terse {
 		g.addmsgf(" %s", prname(ee, false))
@@ -590,7 +650,7 @@ func (g *RogueGame) removeMon(mp Coord, tp *Monster, waskill bool) {
 
 	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
@@ -607,30 +667,7 @@ func (g *RogueGame) killed(tp *Monster, pr bool) {
 	p := &g.Player
 	p.Stats.Exp += tp.Stats.Exp
 
-	// If the monster was a venus flytrap, un-hold him
+	g.killedSpecial(tp)
-	switch tp.Type {
-	case 'F':
-		p.Flags.Clear(Held)
-		p.VfHit = 0
-		g.Monsters['F'-'A'].Stats.Dmg = dice("000x0")
-	case 'L':
-		pos, ok := g.fallpos(tp.Pos)
-		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)
@@ -657,6 +694,37 @@ func (g *RogueGame) killed(tp *Monster, pr bool) {
 	}
 }
 
+// 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':
+		p.Flags.Clear(Held)
+		p.VfHit = 0
+		g.Monsters['F'-'A'].Stats.Dmg = dice("000x0")
+	case 'L':
+		pos, ok := g.fallpos(tp.Pos)
+		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)
+		}
+	}
+}
+
 // flushType flushes typeahead for the fight_flush option (mach_dep.c
 // flush_type / curses flushinp).
 func (g *RogueGame) flushType() {

game/fight_test.go

@@ -7,10 +7,10 @@ import "testing"
 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
 }
@@ -32,7 +32,7 @@ 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")
 	}
 
@@ -79,24 +79,6 @@ func TestAttackHurtsPlayer(t *testing.T) {
 	}
 }
 
-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

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,19 +168,20 @@ 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.FileName = params.Home + "/rogue.save"
 
-	g.rogueOpts = cfg.RogueOpts
+	g.rogueOpts = params.RogueOpts
-	if cfg.Wizard {
+	if params.Wizard {
 		g.Player.Flags.Set(SenseMonsters)
 	}
 
-	if cfg.RogueOpts != "" {
+	if params.RogueOpts != "" {
-		g.ParseOpts(cfg.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 {
@@ -194,37 +199,45 @@ func NewGame(cfg Config) *RogueGame {
 }
 
 // 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() error {
+// (see myExit); one game run is one process.
-	// A gameEnd panic is the port's my_exit(): recovering it here makes
+func (g *RogueGame) Run() {
-	// Run return normally (zero values), restoring the terminal via the
+	g.startLevel()
-	// caller's defers.
+	g.playit()
-	defer func() {
+}
-		if r := recover(); r != nil {
-			if _, ok := r.(gameEnd); ok {
-				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 {
+	if g.restored {
-		g.NewLevel() // draw current level
+		return
-		// Start up daemons and fuses
-		g.StartDaemon(DRunners, 0, After)
-		g.StartDaemon(DDoctor, 0, After)
-		g.Fuse(DSwander, 0, wanderTime(g), After)
-		g.StartDaemon(DStomach, 0, After)
 	}
 
-	g.playit()
+	g.NewLevel() // draw current level
-
+	// Start up daemons and fuses
-	return nil
+	g.StartDaemon(DRunners, 0, After)
+	g.StartDaemon(DDoctor, 0, After)
+	g.Fuse(DSwander, 0, wanderTime(g), After)
+	g.StartDaemon(DStomach, 0, After)
 }
 
 // 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 {
@@ -237,13 +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).

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,19 +50,19 @@ 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 := 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]
 	}
 }
 
@@ -75,7 +75,7 @@ func (g *RogueGame) initNames() {
 		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
 				}
@@ -93,47 +93,47 @@ 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 := 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 := 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
@@ -156,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[:])
@@ -177,7 +177,7 @@ 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,62 +22,44 @@ 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.doaddf(format, a...)
+	m.doaddf(format, a...)
 
-	return g.endmsg()
+	return m.End()
 }
 
-// addmsgf adds things to the current message (io.c addmsg).
+// Addf adds things to the current message (io.c addmsg).
-func (g *RogueGame) addmsgf(format string, a ...any) {
+func (m *MessageLine) Addf(format string, a ...any) {
-	g.doaddf(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 {
+	if m.Mpos != 0 && m.promptMore() == Escape {
-		g.look(false)
+		return 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
@@ -85,30 +69,90 @@ func (g *RogueGame) endmsg() int {
 		out = string(toUpper(out[0])) + out[1:]
 	}
 
-	g.mvaddstr(0, 0, out)
+	m.scr.Std.MvAddStr(0, 0, out)
-	g.clrtoeol()
+	m.scr.Std.Clrtoeol()
 
 	m.Mpos = m.newpos
 	m.newpos = 0
 	m.buf.Reset()
-	g.refresh()
+	m.scr.Refresh()
 
 	return ^Escape
 }
 
-// doaddf performs an add onto the message buffer (io.c doadd).
+// promptMore shows the --More-- prompt and waits for the reader to
-func (g *RogueGame) doaddf(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 {
@@ -146,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() {
@@ -160,9 +202,7 @@ func (g *RogueGame) status() {
 		temp = p.CurArmor.ArmorClass
 	}
 
-	if s.init && s.hp == p.Stats.HP && s.exp == p.Stats.Exp &&
+	if g.statusUnchanged(temp) {
-		s.pur == p.Purse && s.arm == temp && s.str == p.Stats.Str &&
-		s.lvl == g.Depth && s.hungry == p.HungryState && !g.StatMsg {
 		return
 	}
 
@@ -192,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)
@@ -205,6 +245,18 @@ func (g *RogueGame) status() {
 	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' {

game/level.go

@@ -51,6 +51,29 @@ func (l *Level) VisibleChar(y, x int) byte {
 	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,11 +4,23 @@ 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 {
@@ -17,151 +29,28 @@ func (g *RogueGame) look(wakeup bool) {
 		g.Oldrp = rp
 	}
 
-	ey := hero.Y + 1
+	s := lookScan{
-	ex := hero.X + 1
+		hero:   hero,
-	sx := hero.X - 1
+		wakeup: wakeup,
-	sy := hero.Y - 1
+		sy:     hero.Y - 1,
+		sx:     hero.X - 1,
+		ey:     hero.Y + 1,
+		ex:     hero.X + 1,
+	}
 
-	sumhero, diffhero := 0, 0
+	s.doorStop = g.DoorStop && !g.Firstmove
-	if g.DoorStop && !g.Firstmove && g.Running {
+	if s.doorStop && g.Running {
-		sumhero = hero.Y + hero.X
+		s.sumhero = hero.Y + hero.X
-		diffhero = hero.Y - hero.X
+		s.diffhero = hero.Y - hero.X
 	}
 
 	pp := g.Level.At(hero.Y, hero.X)
-	pch := pp.Ch
+	s.pch = pp.Ch
-	pfl := pp.Flags
+	s.pfl = pp.Flags
 
-	for y := sy; y <= ey; y++ {
+	g.lookAround(&s)
-		if y <= 0 || y >= NumLines-1 {
-			continue
-		}
 
-		for x := sx; x <= ex; x++ {
+	if s.doorStop && s.passcount > 1 {
-			if x < 0 || x >= NumCols {
-				continue
-			}
-
-			if !p.On(Blind) {
-				if y == hero.Y && x == hero.X {
-					continue
-				}
-			}
-
-			pp := g.Level.At(y, x)
-
-			ch := pp.Ch
-			if ch == ' ' { // nothing need be done with a ' '
-				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
-
-			switch {
-			case tp == nil:
-				ch = g.tripCh(y, x, ch)
-			case p.On(SenseMonsters) && tp.On(Invisible):
-				if g.DoorStop && !g.Firstmove {
-					g.Running = false
-				}
-
-				continue
-			default:
-				if wakeup {
-					g.wakeMonster(y, x)
-				}
-
-				if g.seeMonst(tp) {
-					if p.On(Hallucinating) {
-						ch = g.randomMonsterLetter()
-					} else {
-						ch = tp.Disguise
-					}
-				}
-			}
-
-			if p.On(Blind) && (y != hero.Y || x != hero.X) {
-				continue
-			}
-
-			g.move(y, x)
-
-			if p.Room.Flags.Has(Dark) && !g.Options.SeeFloor && ch == Floor {
-				ch = ' '
-			}
-
-			if tp != nil || ch != g.inch() {
-				g.addch(ch)
-			}
-
-			if g.DoorStop && !g.Firstmove && g.Running {
-				switch g.RunCh {
-				case 'h':
-					if x == ex {
-						continue
-					}
-				case 'j':
-					if y == sy {
-						continue
-					}
-				case 'k':
-					if y == ey {
-						continue
-					}
-				case 'l':
-					if x == sx {
-						continue
-					}
-				case 'y':
-					if (y+x)-sumhero >= 1 {
-						continue
-					}
-				case 'u':
-					if (y-x)-diffhero >= 1 {
-						continue
-					}
-				case 'n':
-					if (y+x)-sumhero <= -1 {
-						continue
-					}
-				case 'b':
-					if (y-x)-diffhero <= -1 {
-						continue
-					}
-				}
-
-				switch ch {
-				case Door:
-					if x == hero.X || y == hero.Y {
-						g.Running = false
-					}
-				case Passage:
-					if x == hero.X || y == hero.Y {
-						passcount++
-					}
-				case Floor, '|', '-', ' ':
-				default:
-					g.Running = false
-				}
-			}
-		}
-	}
-
-	if g.DoorStop && !g.Firstmove && passcount > 1 {
 		g.Running = false
 	}
 
@@ -170,6 +59,192 @@ func (g *RogueGame) look(wakeup bool) {
 	}
 }
 
+// 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 := s.sx; x <= s.ex; x++ {
+			if x < 0 || x >= NumCols {
+				continue
+			}
+
+			g.lookCell(s, y, x)
+		}
+	}
+}
+
+// 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)
+	if g.lookSkips(s, pp, y, x) {
+		return
+	}
+
+	tp := pp.Monst
+
+	ch, skip := g.lookCellChar(s, tp, y, x, pp.Ch)
+	if skip {
+		return
+	}
+
+	if !g.lookShow(s, tp, ch, y, x) {
+		return
+	}
+
+	if s.doorStop && g.Running {
+		g.lookRunCheck(s, ch, y, x)
+	}
+}
+
+// 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 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)
+
+	if p.Room.Flags.Has(Dark) && !g.Options.SeeFloor && ch == Floor {
+		ch = ' '
+	}
+
+	if tp != nil || ch != g.inch() {
+		g.addch(ch)
+	}
+
+	return true
+}
+
+// lookCellChar picks what the square shows: trip rendering for empty
+// 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
+		}
+
+		return ch, true
+	default:
+		if s.wakeup {
+			g.wakeMonster(y, x)
+		}
+
+		if g.seeMonst(tp) {
+			if p.On(Hallucinating) {
+				return g.randomMonsterLetter(), false
+			}
+
+			return tp.Disguise, false
+		}
+
+		return ch, false
+	}
+}
+
+// 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 == s.hero.X || y == s.hero.Y {
+			g.Running = false
+		}
+	case Passage:
+		if x == s.hero.X || y == s.hero.Y {
+			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
+	}
+
+	return false
+}
+
 // tripCh returns the character for this space, taking into account whether
 // or not the player is tripping (misc.c trip_ch).
 func (g *RogueGame) tripCh(y, x int, ch byte) byte {
@@ -223,21 +298,10 @@ func (g *RogueGame) showFloor() bool {
 	return true
 }
 
-// findObj finds the unclaimed object at (y, x) (misc.c find_obj).
-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
 	}
 
@@ -286,8 +350,8 @@ 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
 		}
 	}
@@ -305,9 +369,9 @@ func (g *RogueGame) checkLevel() {
 	}
 }
 
-// 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
 	}
@@ -362,10 +426,10 @@ func (g *RogueGame) addHaste(potion bool) bool {
 
 // 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)
 	}
 }
 
@@ -406,9 +470,9 @@ func (g *RogueGame) isCurrent(obj *Object) bool {
 	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
@@ -420,40 +484,22 @@ func (g *RogueGame) getDir() bool {
 		}
 
 		for {
-			gotit := true
+			g.DirCh = g.readchar()
-
+			if g.DirCh == Escape {
-			switch g.DirCh = g.readchar(); g.DirCh {
-			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)
@@ -462,14 +508,7 @@ func (g *RogueGame) getDir() bool {
 	}
 
 	if g.Player.On(Confused) && g.rnd(5) == 0 {
-		for {
+		g.confuseDirection()
-			g.Delta.Y = g.rnd(3) - 1
-
-			g.Delta.X = g.rnd(3) - 1
-			if g.Delta.Y != 0 || g.Delta.X != 0 {
-				break
-			}
-		}
 	}
 
 	g.Msgs.Mpos = 0
@@ -477,6 +516,44 @@ func (g *RogueGame) getDir() bool {
 	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 {
+			return
+		}
+	}
+}
+
+// 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).
 func (g *RogueGame) callIt(info *ObjInfo) {
 	if info.Know {
@@ -493,22 +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

game/monsters.go

@@ -2,24 +2,12 @@ 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 {
@@ -43,13 +31,13 @@ func (g *RogueGame) randMonster(wander bool) byte {
 func (g *RogueGame) newMonster(tp *Monster, typ byte, cp Coord) {
 	levAdd := max(g.Depth-AmuletLevel, 0)
 
-	attachMon(&g.Level.Monsters, tp)
+	g.Level.AddMonster(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
@@ -69,7 +57,7 @@ func (g *RogueGame) newMonster(tp *Monster, typ byte, cp Coord) {
 	tp.Pack = nil
 
 	if g.Player.IsWearing(RingAggravateMonsters) {
-		g.runto(cp)
+		g.runTo(cp)
 	}
 
 	if typ == 'X' {
@@ -104,7 +92,7 @@ func (g *RogueGame) wanderer() {
 	var cp Coord
 	for {
 		cp, _ = g.findFloor(true)
-		if g.roomin(cp) != g.Player.Room {
+		if g.roomIn(cp) != g.Player.Room {
 			break
 		}
 	}
@@ -123,12 +111,12 @@ func (g *RogueGame) wanderer() {
 		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)
@@ -136,40 +124,14 @@ func (g *RogueGame) wakeMonster(y, x int) *Monster {
 		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) &&
+	if g.medusaCatches(tp) {
-		!tp.On(Found) && !tp.On(Cancelled) && tp.On(Awake) {
+		g.medusaGaze(tp, y, x)
-		rp := p.Room
-		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.addmsgf("%s", mname)
-
-				if mname != "it" {
-					g.addmsgf("'")
-				}
-
-				g.msg("s gaze has confused you")
-			}
-		}
 	}
 	// Let greedy ones guard gold
 	if tp.On(Greedy) && !tp.On(Awake) {
@@ -181,8 +143,60 @@ func (g *RogueGame) wakeMonster(y, x int) *Monster {
 			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

game/move.go

@@ -2,16 +2,17 @@ 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
@@ -24,7 +25,7 @@ func (g *RogueGame) doMove(dy, dx int) {
 	// 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
@@ -36,150 +37,220 @@ func (g *RogueGame) doMove(dy, dx int) {
 		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
-
-	var (
-		ch byte
-		fl PlaceFlags
-	)
-
-	if !hitBound {
-		if !g.diagOk(p.Pos, nh) {
-			g.After = false
-			g.Running = false
-
 			return
 		}
 
-		if g.Running && p.Pos == nh {
+		turned, ndy, ndx := g.moveResolve(nh, ch, fl, dy, dx)
-			g.After = false
+		if !turned {
-			g.Running = false
-		}
-
-		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
-				g.Level.SetChar(nh.Y, nh.X, Trap)
-				g.Level.FlagsAt(nh.Y, nh.X).Set(FReal)
-			}
-		} else if p.On(Held) && ch != 'F' {
-			g.msg("you are being held")
-
 			return
 		}
-	}
 
-	if hitBound {
+		// the C goto over: re-check the turned move
-		ch = ' ' // fall into the wall case below
+		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 g.Options.PassGo && g.Running && p.Room.Flags.Has(Gone) &&
+		if turn, ndy, ndx := g.passageTurn(dy, dx); turn {
-			!p.On(Blind) {
+			return true, ndy, ndx
-			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
+	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)
 		}
-
-		g.moveStuff(nh, fl)
 	case Trap:
-		tr := g.beTrapped(nh)
+		tr := g.springTrap(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)
+		p.Room = g.roomIn(p.Pos)
-		g.moveStuff(nh, fl)
 	case Floor:
 		if !fl.Has(FReal) {
-			g.beTrapped(p.Pos)
+			g.springTrap(p.Pos)
 		}
-
-		g.moveStuff(nh, fl)
 	default:
-		if ch == Stairs {
+		g.moveOnto(nh, fl, ch)
-			g.SeenStairs = true
-		}
 
+		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
-		if isUpper(ch) || g.Level.MonsterAt(nh.Y, nh.X) != nil {
-			g.fight(nh, p.CurWeapon, false)
-		} else {
-			if ch != Stairs {
-				g.Take = ch
-			}
 
-			g.moveStuff(nh, fl)
+		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)
+	if !fl.Has(FReal) && ch == Floor {
+		if !p.On(Levitating) {
+			ch = Trap
+			g.Level.SetChar(nh.Y, nh.X, Trap)
+			g.Level.FlagsAt(nh.Y, nh.X).Set(FReal)
 		}
+	} else if p.On(Held) && ch != 'F' {
+		g.msg("you are being held")
+
+		return 0, 0, true
+	}
+
+	return ch, fl, false
+}
+
+// moveOnto handles stepping at a monster or onto an item (the default
+// arm of the move.c do_move switch).
+func (g *RogueGame) moveOnto(nh Coord, fl PlaceFlags, ch byte) {
+	p := &g.Player
+	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)
+	} else {
+		if ch != Stairs {
+			g.Take = ch
+		}
+
+		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())
 
@@ -198,8 +269,9 @@ func (g *RogueGame) turnOk(y, x int) bool {
 	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)
@@ -228,8 +300,8 @@ 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
@@ -242,85 +314,8 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 	tr := TrapKind(pp.Flags & FTrapMask)
 	pp.Flags.Set(FSeen)
 
-	switch tr {
+	if h := g.data.trapHandlers[tr]; h != nil {
-	case TrapDoor:
+		h(g, tc)
-		g.Depth++
-		g.NewLevel()
-		g.msg("you fell into a trap!")
-	case TrapBear:
-		g.NoMove += g.spread(3) // BEARTIME
-		g.msg("you are caught in a bear trap")
-	case TrapMystery:
-		switch g.rnd(11) {
-		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))])
-		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))])
-		case 5:
-			g.msg("a spike shoots past your ear!")
-		case 6:
-			g.msg("%s sparks dance across your armor", rainbow[g.rnd(len(rainbow))])
-		case 7:
-			g.msg("you suddenly feel very thirsty")
-		case 8:
-			g.msg("you feel time speed up suddenly")
-		case 9:
-			g.msg("time now seems to be going slower")
-		case 10:
-			g.msg("you pack turns %s!", rainbow[g.rnd(len(rainbow))])
-		}
-	case TrapSleep:
-		g.NoCommand += g.spread(5) // SLEEPTIME
-
-		p.Flags.Clear(Awake)
-		g.msg("a strange white mist envelops you and you fall asleep")
-	case TrapArrow:
-		if g.swing(p.Stats.Lvl-1, p.Stats.ArmorClass, 1) {
-			p.Stats.HP -= g.roll(1, 6)
-			if p.Stats.HP <= 0 {
-				g.msg("an arrow killed you")
-				g.death('a')
-			} else {
-				g.msg("oh no! An arrow shot you")
-			}
-		} else {
-			arrow := newObject()
-			g.initWeapon(arrow, WeaponArrow)
-			arrow.Count = 1
-			arrow.Pos = p.Pos
-			g.fall(arrow, false)
-			g.msg("an arrow shoots past you")
-		}
-	case TrapTeleport:
-		// 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:
-		if !g.swing(p.Stats.Lvl+1, p.Stats.ArmorClass, 1) {
-			g.msg("a small dart whizzes by your ear and vanishes")
-		} else {
-			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.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()
@@ -328,9 +323,119 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 	return tr
 }
 
-// rndmove moves in a random direction if the monster/person is confused
+// The per-trap effect handlers, dispatched through
-// (move.c rndmove).
+// gameData.trapHandlers. Each is one case of the C be_trapped switch.
-func (g *RogueGame) rndmove(who *Creature) Coord {
+
+func (g *RogueGame) trapFall(Coord) {
+	g.Depth++
+	g.NewLevel()
+	g.msg("you fell into a trap!")
+}
+
+func (g *RogueGame) trapBear(Coord) {
+	g.NoMove += g.spread(3) // BEARTIME
+	g.msg("you are caught in a bear trap")
+}
+
+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", 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", 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", g.data.rainbow[g.rnd(len(g.data.rainbow))])
+	case 7:
+		g.msg("you suddenly feel very thirsty")
+	case 8:
+		g.msg("you feel time speed up suddenly")
+	case 9:
+		g.msg("time now seems to be going slower")
+	case 10:
+		g.msg("you pack turns %s!", g.data.rainbow[g.rnd(len(g.data.rainbow))])
+	}
+}
+
+func (g *RogueGame) trapSleep(Coord) {
+	g.NoCommand += g.spread(5) // SLEEPTIME
+
+	g.Player.Flags.Clear(Awake)
+	g.msg("a strange white mist envelops you and you fall asleep")
+}
+
+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 {
+			g.msg("an arrow killed you")
+			g.death('a')
+		} else {
+			g.msg("oh no! An arrow shot you")
+		}
+	} else {
+		arrow := newObject()
+		g.initWeapon(arrow, WeaponArrow)
+		arrow.Count = 1
+		arrow.Pos = p.Pos
+		g.fall(arrow, false)
+		g.msg("an arrow shoots past you")
+	}
+}
+
+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)
+}
+
+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")
+
+		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.changeStrength(-1)
+	}
+
+	g.msg("a small dart just hit you in the shoulder")
+}
+
+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,

game/newlevel.go

@@ -27,8 +27,8 @@ func (g *RogueGame) NewLevel() {
 	// 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++
 
@@ -61,7 +61,7 @@ func (g *RogueGame) NewLevel() {
 	g.SeenStairs = false
 
 	for _, tp := range g.Level.Monsters {
-		tp.Room = g.roomin(tp.Pos)
+		tp.Room = g.roomIn(tp.Pos)
 	}
 
 	hero, _ := g.findFloor(true)
@@ -78,8 +78,8 @@ func (g *RogueGame) NewLevel() {
 	}
 }
 
-// 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) {
@@ -98,14 +98,14 @@ 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 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(false)
 			g.Level.SetChar(obj.Pos.Y, obj.Pos.X, obj.Kind.Glyph())
@@ -115,7 +115,7 @@ 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
@@ -126,9 +126,9 @@ func (g *RogueGame) putThings() {
 	}
 }
 
-// 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 := min((rp.Max.Y-2)*(rp.Max.X-2)-minTreas, maxTreas-minTreas)
 
@@ -137,7 +137,7 @@ func (g *RogueGame) treasRoom() {
 		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())
 	}
 

game/newlevel_test.go

@@ -8,7 +8,7 @@ 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
@@ -38,75 +38,106 @@ func TestNewLevelInvariants(t *testing.T) {
 	for _, seed := range []int32{1, 12345, 2026, 99999} {
 		g := genLevel(t, seed)
 
-		// The staircase is somewhere real.
+		checkHeroPlacement(t, g, seed)
-		st := g.Level.Stairs
+		checkRoomsDrawn(t, g, seed)
-		if g.Level.Char(st.Y, st.X) != Stairs {
+		checkMonstersPlaced(t, g, seed)
-			t.Errorf("seed %d: no staircase at recorded stairs position", 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 {
+		t.Errorf("seed %d: no staircase at recorded stairs position", seed)
+	}
+
+	// The hero stands on a walkable, monster-free cell.
+	hp := g.Player.Pos
+	if !stepOk(g.Level.Char(hp.Y, hp.X)) {
+		t.Errorf("seed %d: hero on unwalkable cell %q", seed,
+			g.Level.Char(hp.Y, hp.X))
+	}
+
+	if g.Level.MonsterAt(hp.Y, hp.X) != nil {
+		t.Errorf("seed %d: hero standing on a monster", seed)
+	}
+
+	if g.Player.Room == nil {
+		t.Errorf("seed %d: hero not in any room", seed)
+	}
+}
+
+// checkRoomsDrawn verifies rooms and floor/passages appear on the map.
+func checkRoomsDrawn(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
+
+	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()
+
+	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)
 		}
 
-		// The hero stands on a walkable, monster-free cell.
+		if mon.Room == nil {
-		hp := g.Player.Pos
+			t.Errorf("seed %d: monster %c has no room", seed, mon.Type)
-		if !stepOk(g.Level.Char(hp.Y, hp.X)) {
-			t.Errorf("seed %d: hero on unwalkable cell %q", seed,
-				g.Level.Char(hp.Y, hp.X))
 		}
+	}
+}
 
-		if g.Level.MonsterAt(hp.Y, hp.X) != nil {
+// checkObjectsPlaced verifies every level object sits on a cell
-			t.Errorf("seed %d: hero standing on a monster", seed)
+// displaying its type (items can share cells only with monsters standing
+// on them).
+func checkObjectsPlaced(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
+
+	for _, obj := range g.Level.Objects {
+		ch := g.Level.Char(obj.Pos.Y, obj.Pos.X)
+		if ch != obj.Kind.Glyph() &&
+			g.Level.MonsterAt(obj.Pos.Y, obj.Pos.X) == nil {
+			t.Errorf("seed %d: object %v at (%d,%d) but map shows %q",
+				seed, obj.Kind, obj.Pos.Y, obj.Pos.X, ch)
 		}
+	}
+}
 
-		if g.Player.Room == nil {
+// checkStartingKit verifies the player has her starting kit: food, armor,
-			t.Errorf("seed %d: hero not in any room", seed)
+// mace, bow, arrows.
-		}
+func checkStartingKit(t *testing.T, g *RogueGame, seed int32) {
+	t.Helper()
 
-		// Some rooms exist and are drawn.
+	if len(g.Player.Pack) != 5 {
-		m := renderMap(g)
+		t.Errorf("seed %d: starting pack has %d items, want 5",
-		if !strings.Contains(m, "|") || !strings.Contains(m, "-") {
+			seed, len(g.Player.Pack))
-			t.Errorf("seed %d: no room walls drawn", seed)
+	}
-		}
 
-		if !strings.Contains(m, ".") && !strings.Contains(m, "#") {
+	if g.Player.CurWeapon == nil ||
-			t.Errorf("seed %d: no floor or passages drawn", seed)
+		g.Player.CurWeapon.WeaponKind() != WeaponMace {
-		}
+		t.Errorf("seed %d: not wielding the starting mace", seed)
+	}
 
-		// Every monster is indexed on the map and placed in a room.
+	if g.Player.CurArmor == nil ||
-		for _, mon := range g.Level.Monsters {
+		g.Player.CurArmor.ArmorKind() != ArmorRingMail {
-			if g.Level.MonsterAt(mon.Pos.Y, mon.Pos.X) != mon {
+		t.Errorf("seed %d: not wearing the starting ring mail", seed)
-				t.Errorf("seed %d: monster %c not indexed at its position",
-					seed, mon.Type)
-			}
-
-			if mon.Room == nil {
-				t.Errorf("seed %d: monster %c has no room", seed, mon.Type)
-			}
-		}
-
-		// Every level object sits on a cell displaying its type (items can
-		// share cells only with monsters standing on them).
-		for _, obj := range g.Level.Objects {
-			ch := g.Level.Char(obj.Pos.Y, obj.Pos.X)
-			if ch != obj.Kind.Glyph() &&
-				g.Level.MonsterAt(obj.Pos.Y, obj.Pos.X) == nil {
-				t.Errorf("seed %d: object %v at (%d,%d) but map shows %q",
-					seed, obj.Kind, obj.Pos.Y, obj.Pos.X, ch)
-			}
-		}
-
-		// The player has her starting kit: food, armor, mace, bow, arrows.
-		if len(g.Player.Pack) != 5 {
-			t.Errorf("seed %d: starting pack has %d items, want 5",
-				seed, len(g.Player.Pack))
-		}
-
-		if g.Player.CurWeapon == nil ||
-			g.Player.CurWeapon.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)
-		}
 	}
 }
 
@@ -128,7 +159,7 @@ 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()

game/object.go

@@ -26,36 +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:
@@ -63,27 +76,34 @@ 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
@@ -95,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 {

game/options.go

@@ -101,7 +101,7 @@ func (g *RogueGame) putOpt(op *optDesc) {
 	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)
 	}
@@ -205,55 +205,11 @@ func (g *RogueGame) getStr(opt *string, win *Window) int {
 	)
 	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
+		buf = g.getStrEdit(win, buf, c, oy, ox)
-			if len(buf) > 0 {
-				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
@@ -267,6 +223,12 @@ func (g *RogueGame) getStr(opt *string, win *Window) int {
 		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
@@ -277,6 +239,52 @@ 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
@@ -291,7 +299,7 @@ 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)
@@ -319,7 +327,7 @@ func (g *RogueGame) getInvT(ip *int) int {
 		break
 	}
 
-	win.MvPrintwf(oy, ox, "%s\n", invTName[*ip])
+	win.MvPrintwf(oy, ox, "%s\n", g.data.invTName[*ip])
 
 	return Norm
 }
@@ -337,75 +345,7 @@ func (g *RogueGame) ParseOpts(str string) {
 			i++
 		}
 
-		name := str[:i]
+		rest := g.parseOptName(optlist, str[:i], str[i:])
-		rest := str[i:]
-		matched := false
-
-		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 {
-					// 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:]
-						}
-					}
-					// Skip to end of string value
-					end := strings.IndexByte(val, ',')
-					if end < 0 {
-						end = len(val)
-					}
-
-					word := val[:end]
-					rest = val[end:]
-
-					if op.kind == optInvT {
-						// check for type of inventory
-						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)
-					}
-				}
-
-				break
-			} else if isBoolOpt && strings.HasPrefix(name, "no") &&
-				strings.HasPrefix(op.name, name[2:]) {
-				matched = true
-				*op.boolP = false
-
-				break
-			}
-		}
-
-		_ = matched
 		// skip to start of next option name
 		for rest != "" && !isAlpha(rest[0]) {
 			rest = rest[1:]
@@ -415,6 +355,89 @@ func (g *RogueGame) ParseOpts(str string) {
 	}
 }
 
+// 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 != "" {
+			if isBoolOpt {
+				*op.boolP = true
+
+				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:]
+		}
+	}
+	// Skip to end of string value
+	end := strings.IndexByte(val, ',')
+	if end < 0 {
+		end = len(val)
+	}
+
+	word := val[:end]
+
+	if op.kind == optInvT {
+		g.parseInvType(op, word)
+	} else {
+		*op.strP = prefix + strucpy(word)
+	}
+
+	return val[end:]
+}
+
+// parseInvType matches an inventory-style name by prefix (options.c
+// parse_opts).
+func (g *RogueGame) parseInvType(op *optDesc, word string) {
+	// 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
+		}
+	}
+}
+
 // strucpy copies a string keeping only printable characters, capped at
 // MAXINP (options.c strucpy).
 func strucpy(s string) string {

game/pack.go

@@ -9,7 +9,7 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 	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
 		}
 
@@ -17,105 +17,13 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 	}
 
 	// 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()
+		return
-		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 {
-				switch {
-				case op.Kind.MergesInPack():
-					if !g.packRoom(fromFloor, obj) {
-						return
-					}
-
-					op.Count++
-					obj = op
-					lp = -1
-					merged = true
-				case 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
-					}
-				default:
-					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)
@@ -137,10 +45,167 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 			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 {
@@ -168,7 +233,7 @@ func (g *RogueGame) packRoom(fromFloor bool, obj *Object) bool {
 	}
 
 	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) {
@@ -181,46 +246,17 @@ func (g *RogueGame) packRoom(fromFloor bool, obj *Object) bool {
 	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
+	return g.Player.removeFromPack(obj, newobj, all)
-}
-
-// packChar returns the next unused pack character (pack.c pack_char).
-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
@@ -236,7 +272,7 @@ func (g *RogueGame) inventory(list []*Object, kind ObjectKind) bool {
 		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("")
@@ -248,18 +284,11 @@ func (g *RogueGame) inventory(list []*Object, kind ObjectKind) bool {
 	}
 
 	if g.NObjs == 0 {
-		if g.Options.Terse {
+		if kind == KindNone {
-			if kind == KindNone {
+			g.msg("%s", g.chooseTerse("empty handed", "you are empty handed"))
-				g.msg("empty handed")
-			} else {
-				g.msg("nothing appropriate")
-			}
 		} else {
-			if kind == KindNone {
+			g.msg("%s", g.chooseTerse("nothing appropriate",
-				g.msg("you are empty handed")
+				"you don't have anything appropriate"))
-			} else {
-				g.msg("you don't have anything appropriate")
-			}
 		}
 
 		return false
@@ -277,7 +306,7 @@ 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)
 
@@ -291,7 +320,7 @@ func (g *RogueGame) pickUp(ch byte) {
 		}
 
 		g.money(obj.GoldValue)
-		detachObj(&g.Level.Objects, obj)
+		g.Level.RemoveObject(obj)
 
 		p.Room.GoldVal = 0
 	default:
@@ -323,7 +352,7 @@ func (g *RogueGame) moveMsg(obj *Object) {
 		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
@@ -337,7 +366,7 @@ func (g *RogueGame) pickyInven() {
 	}
 
 	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
 	}
@@ -354,7 +383,7 @@ func (g *RogueGame) pickyInven() {
 
 	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
 		}
@@ -363,37 +392,24 @@ func (g *RogueGame) pickyInven() {
 	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.addmsgf("which object do you want to ")
-		}
 
-		g.addmsgf("%s", purpose)
-
-		if g.Options.Terse {
-			g.addmsgf(" what")
-		}
-
-		g.msg("? (* for list): ")
 		ch := g.readchar()
 		g.Msgs.Mpos = 0
 		// Give the poor player a chance to abort the command
@@ -402,7 +418,7 @@ func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
 			g.After = false
 			g.msg("")
 
-			return nil
+			return nil, false
 		}
 
 		g.NObjs = 1 // normal case: person types one char
@@ -411,7 +427,7 @@ func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
 			if !g.inventory(p.Pack, kind) {
 				g.After = false
 
-				return nil
+				return nil, false
 			}
 
 			continue
@@ -419,7 +435,7 @@ func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
 
 		for _, obj := range p.Pack {
 			if obj.PackCh == ch {
-				return obj
+				return obj, true
 			}
 		}
 
@@ -427,6 +443,34 @@ func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
 	}
 }
 
+// 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

game/passages.go

@@ -2,21 +2,8 @@ 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},
-	{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},
-}
-
-// doPassages draws all the passages on a level (passages.c do_passages).
-func (g *RogueGame) doPassages() {
 	var (
 		isconn  [MaxRooms][MaxRooms]bool
 		ingraph [MaxRooms]bool
@@ -28,223 +15,253 @@ func (g *RogueGame) doPassages() {
 	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 {
-
+			// if no adjacent rooms are outside the graph, pick a new
-		for i := range MaxRooms {
+			// room to look from
-			if rdesConn[r1][i] && !ingraph[i] {
-				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 {
-			// otherwise, connect new room to the graph, and draw a tunnel
-			// to it
-			ingraph[r2] = true //nolint:gosec // G602: rnd(MaxRooms) bounded
-			g.conn(r1, r2)
-			isconn[r1][r2] = true
-			isconn[r2][r1] = true //nolint:gosec // G602: rnd(MaxRooms) bounded
-			roomcount++
-		}
 
-		if roomcount >= MaxRooms {
+			continue
-			break
 		}
+		// otherwise, connect new room to the graph, and draw a tunnel
+		// to it
+		ingraph[r2] = true
+		g.connectRooms(r1, r2)
+		isconn[r1][r2] = true
+		isconn[r2][r1] = true
+		roomcount++
 	}
 
 	// 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,
-		j := 0
+		// connect it and look for the next added passage
-		r2 := -1
+		r2 := g.pickNeighbor(r1, func(i int) bool { return !isconn[r1][i] })
-
+		if r2 >= 0 {
-		for i := range MaxRooms {
+			g.connectRooms(r1, r2)
-			if rdesConn[r1][i] && !isconn[r1][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 {
-			g.conn(r1, r2)
 			isconn[r1][r2] = true
-			isconn[r2][r1] = true //nolint:gosec // G602: rnd(MaxRooms) bounded
+			isconn[r2][r1] = true
 		}
 	}
 
-	g.passnum()
+	g.numberPassages()
 }
 
-// conn draws a corridor from a room in a certain direction (passages.c
+// pickNeighbor reservoir-picks an adjacent room for which ok holds, or
-// conn).
+// -1 when there is none (passages.c do_passages).
-func (g *RogueGame) conn(r1, r2 int) {
+func (g *RogueGame) pickNeighbor(r1 int, ok func(int) bool) int {
-	var (
+	j := 0
-		rm    int
+	r2 := -1
-		direc byte
-	)
 
-	if r1 < r2 {
+	for i := range MaxRooms {
-		rm = r1
+		if g.data.rdesConn[r1][i] && ok(i) {
-		if r1+1 == r2 {
+			if j++; g.rnd(j) == 0 {
-			direc = 'r'
+				r2 = i
-		} else {
+			}
-			direc = 'd'
-		}
-	} else {
-		rm = r2
-		if r2+1 == r1 {
-			direc = 'r'
-		} else {
-			direc = 'd'
 		}
 	}
 
-	rpf := &g.Level.Rooms[rm]
+	return r2
+}
 
-	// Set up the movement variables, in two cases: first drawing one down.
+// corridorPlan is the movement setup connectRooms computes before it
-	var (
+// digs (the local variables of passages.c conn).
-		rpt                        *Room
+type corridorPlan struct {
-		del, turnDelta, spos, epos Coord
+	rpf, rpt               *Room // the rooms being joined
-		distance, turnDistance     int
+	del                    Coord // direction of move
-	)
+	turnDelta              Coord // direction to turn
+	spos, epos             Coord // start and end of move
+	distance, turnDistance int   // how far to move and to turn
+}
 
+// connectRooms draws a corridor from a room in a certain direction
+// (passages.c conn).
+func (g *RogueGame) connectRooms(r1, r2 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
+	} else {
-		del = Coord{X: 0, Y: 1}   // direction of move
+		plan = g.connPlanRight(rm)
-		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
-		}
-
-		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.X += plan.del.X
 
-	curr.Y += del.Y
+	curr.Y += plan.del.Y
-	if curr != epos {
+	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)
 
@@ -283,40 +300,52 @@ func (g *RogueGame) door(rm *Room, cp Coord) {
 func (g *RogueGame) addPass() {
 	for y := 1; y < NumLines-1; y++ {
 		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 == '-')) {
-				ch := pp.Ch
-				if pp.Flags.Has(FPassage) {
-					ch = Passage
-				}
-
-				pp.Flags.Set(FSeen)
-				g.move(y, x)
-
-				switch {
-				case pp.Monst != nil:
-					pp.Monst.OldCh = pp.Ch
-				case pp.Flags.Has(FReal):
-					g.addch(ch)
-				default:
-					g.standout()
-
-					if pp.Flags.Has(FPassage) {
-						g.addch(Passage)
-					} else {
-						g.addch(Door)
-					}
-
-					g.standend()
-				}
-			}
 		}
 	}
 }
 
-// passnum assigns a number to each passageway (passages.c passnum).
+// addPassSpot shows one passage or door square for the wizard (the loop
-func (g *RogueGame) passnum() {
+// 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)
+
+	switch {
+	case pp.Monst != nil:
+		pp.Monst.OldCh = pp.Ch
+	case pp.Flags.Has(FReal):
+		g.addch(ch)
+	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 == '-'))
+}
+
+// numberPassages assigns a number to each passageway (passages.c passnum).
+func (g *RogueGame) numberPassages() {
 	g.pnum = 0
 
 	g.newpnum = false
@@ -328,14 +357,14 @@ func (g *RogueGame) passnum() {
 		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
 	}
@@ -351,8 +380,7 @@ func (g *RogueGame) numpass(y, x int) {
 	}
 	// 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) {
@@ -361,10 +389,10 @@ func (g *RogueGame) numpass(y, x int) {
 
 	*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.

game/potions.go

@@ -13,30 +13,12 @@ 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
 	}
 
@@ -59,145 +41,8 @@ func (g *RogueGame) quaff() {
 
 	g.leavePack(obj, false, false)
 
-	switch obj.PotionKind() {
+	if h := g.data.quaffHandlers[obj.PotionKind()]; h != nil {
-	case PotionConfusion:
+		h(g, trip)
-		g.doPot(PotionConfusion, !trip)
-	case PotionPoison:
-		g.Items.Potions[PotionPoison].Know = true
-		if p.IsWearing(RingSustainStrength) {
-			g.msg("you feel momentarily sick")
-		} else {
-			g.chgStr(-(g.rnd(3) + 1))
-			g.msg("you feel very sick now")
-			g.comeDown(0)
-		}
-	case PotionHealing:
-		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:
-		g.Items.Potions[PotionGainStrength].Know = true
-		g.chgStr(1)
-		g.msg("you feel stronger, now.  What bulging muscles!")
-	case PotionDetectMonsters:
-		p.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:
-		// 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() {
-					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() {
-						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--")
-		} else {
-			g.msg("you have a %s feeling for a moment, then it passes",
-				g.chooseStr("normal", "strange"))
-		}
-	case PotionLSD:
-		if !trip {
-			if p.On(SenseMonsters) {
-				g.turnSee(false)
-			}
-
-			g.StartDaemon(DVisuals, 0, Before)
-			g.SeenStairs = g.seenStairs()
-		}
-
-		g.doPot(PotionLSD, true)
-	case PotionSeeInvisible:
-		show := p.On(CanSeeInvisible)
-
-		g.doPot(PotionSeeInvisible, false)
-
-		if !show {
-			g.invisOn()
-		}
-
-		g.sight(0)
-	case PotionRaiseLevel:
-		g.Items.Potions[PotionRaiseLevel].Know = true
-		g.msg("you suddenly feel much more skillful")
-		g.raiseLevel()
-	case PotionExtraHealing:
-		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:
-		g.Items.Potions[PotionHaste].Know = true
-
-		g.After = false
-		if g.addHaste(true) {
-			g.msg("you feel yourself moving much faster")
-		}
-	case PotionRestoreStrength:
-		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()
@@ -205,17 +50,192 @@ func (g *RogueGame) quaff() {
 	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 g.Player.IsWearing(RingSustainStrength) {
+		g.msg("you feel momentarily sick")
+	} else {
+		g.changeStrength(-(g.rnd(3) + 1))
+		g.msg("you feel very sick now")
+		g.comeDown(0)
+	}
+}
+
+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")
+}
+
+func (g *RogueGame) quaffGainStrength(bool) {
+	g.Items.Potions[PotionGainStrength].Know = true
+	g.changeStrength(1)
+	g.msg("you feel stronger, now.  What bulging muscles!")
+}
+
+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"))
+	}
+}
+
+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 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 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--")
+	} else {
+		g.msg("you have a %s feeling for a moment, then it passes",
+			g.chooseStr("normal", "strange"))
+	}
+}
+
+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.applyPotionFuse(PotionLSD, true)
+}
+
+func (g *RogueGame) quaffSeeInvisible(bool) {
+	show := g.Player.On(CanSeeInvisible)
+
+	g.applyPotionFuse(PotionSeeInvisible, false)
+
+	if !show {
+		g.invisOn()
+	}
+
+	g.sight(0)
+}
+
+func (g *RogueGame) quaffRaiseLevel(bool) {
+	g.Items.Potions[PotionRaiseLevel].Know = true
+	g.msg("you suddenly feel much more skillful")
+	g.raiseLevel()
+}
+
+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")
+}
+
+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")
+	}
+}
+
+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")
+}
+
+func (g *RogueGame) quaffBlindness(bool) {
+	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
 	}
@@ -240,10 +260,10 @@ func (g *RogueGame) doPot(kind PotionKind, knowit bool) {
 }
 
 // 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:
@@ -278,22 +298,8 @@ func (g *RogueGame) turnSee(turnOff bool) bool {
 			if !canSee {
 				g.addch(mp.OldCh)
 			}
-		} else {
+		} else if g.showSensed(mp, canSee) {
-			if !canSee {
+			addNew = true
-				g.standout()
-			}
-
-			if !g.Player.On(Hallucinating) {
-				g.addch(mp.Type)
-			} else {
-				g.addch(g.randomMonsterLetter())
-			}
-
-			if !canSee {
-				g.standend()
-
-				addNew = true
-			}
 		}
 	}
 
@@ -306,6 +312,29 @@ func (g *RogueGame) turnSee(turnOff bool) bool {
 	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 {

game/rings.go

@@ -7,18 +7,15 @@ 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
 	}
@@ -28,24 +25,8 @@ func (g *RogueGame) ringOn() {
 		return
 	}
 
-	var ring int
+	ring := g.pickRingHand()
-
+	if ring < 0 {
-	switch {
-	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
 	}
 
@@ -54,7 +35,7 @@ func (g *RogueGame) ringOn() {
 	// 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:
@@ -65,7 +46,27 @@ func (g *RogueGame) ringOn() {
 		g.addmsgf("you are now wearing ")
 	}
 
-	g.msg("%s (%c)", g.invName(obj, true), obj.PackCh)
+	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
+	}
 }
 
 // ringOff takes off a ring (rings.c ring_off).
@@ -103,7 +104,7 @@ func (g *RogueGame) ringOff() {
 	}
 
 	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)
 	}
 }
 
@@ -139,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 {
@@ -166,7 +148,7 @@ func (g *RogueGame) ringEat(hand int) int {
 		return 0
 	}
 
-	eat := ringUses[ring.RingKind()]
+	eat := g.data.ringUses[ring.RingKind()]
 	if eat < 0 {
 		if g.rnd(-eat) == 0 {
 			eat = 1

game/rip.go

@@ -2,39 +2,20 @@ 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{}
+// terminal and ends the process. Every C caller exited with status 0.
-
-// myExit leaves the process properly (main.c my_exit): it unwinds to Run.
-// Every C caller exited with status 0; abnormal exits panic for real.
 func (g *RogueGame) myExit() {
-	g.Playing = false
+	g.scr.Fini()
-
+	os.Exit(0)
-	panic(gameEnd{})
-}
-
-var ripArt = []string{
-	"                       __________",
-	"                      /          \\",
-	"                     /    REST    \\",
-	"                    /      IN      \\",
-	"                   /     PEACE      \\",
-	"                  /                  \\",
-	"                  |                  |",
-	"                  |                  |",
-	"                  |   killed by a    |",
-	"                  |                  |",
-	"                  |       1980       |",
-	"                 *|     *  *  *      | *",
-	"         ________)/\\\\_//(\\/(/\\)/\\//\\/|_)_______",
 }
 
 // death does something really fun when he dies (rip.c death).
@@ -56,7 +37,7 @@ func (g *RogueGame) death(monst byte) {
 	} 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)
 		}
 
@@ -131,81 +112,10 @@ func (g *RogueGame) totalWinner() {
 	line := 1
 
 	for _, obj := range p.Pack {
-		worth := 0
+		worth := g.objectWorth(obj)
-		it := &g.Items
-
-		switch obj.Kind {
-		case KindFood:
-			worth = 2 * obj.Count
-		case KindWeapon:
-			worth = it.Weapons[obj.Which].Worth
-			worth *= 3*(obj.HPlus+obj.DPlus) + obj.Count
-			obj.Flags.Set(Known)
-		case KindArmor:
-			worth = it.Armors[obj.Which].Worth
-			worth += (9 - obj.ArmorClass) * 100
-			worth += 10 * (aClass[obj.Which] - obj.ArmorClass)
-			obj.Flags.Set(Known)
-		case KindScroll:
-			op := &it.Scrolls[obj.Which]
-
-			worth = op.Worth * obj.Count
-			if !op.Know {
-				worth /= 2
-			}
-
-			op.Know = true
-		case KindPotion:
-			op := &it.Potions[obj.Which]
-
-			worth = op.Worth * obj.Count
-			if !op.Know {
-				worth /= 2
-			}
-
-			op.Know = true
-		case KindRing:
-			op := &it.Rings[obj.Which]
-			worth = op.Worth
-
-			if obj.RingKind() == RingAddStrength || obj.RingKind() == RingIncreaseDamage ||
-				obj.RingKind() == RingProtection || obj.RingKind() == RingDexterity {
-				if obj.Bonus > 0 {
-					worth += obj.Bonus * 100
-				} else {
-					worth = 10
-				}
-			}
-
-			if !obj.Flags.Has(Known) {
-				worth /= 2
-			}
-
-			obj.Flags.Set(Known)
-
-			op.Know = true
-		case KindWand:
-			op := &it.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.MvPrintwf(line, 0, "%c) %5d  %s", obj.PackCh, worth,
-			g.invName(obj, false))
+			g.inventoryName(obj, false))
 		line++
 		p.Purse += worth
 	}
@@ -216,13 +126,98 @@ func (g *RogueGame) totalWinner() {
 	g.myExit()
 }
 
-// killnameTable is the rip.c nlist[]: special death causes.
+// objectWorth appraises one pack item on the way out, marking it known
-var killnameTable = []helpEntry{
+// (the switch of rip.c total_winner).
-	{'a', "arrow", true},
+func (g *RogueGame) objectWorth(obj *Object) int {
-	{'b', "bolt", true},
+	it := &g.Items
-	{'d', "dart", true},
+	worth := 0
-	{'h', "hypothermia", false},
+
-	{'s', "starvation", false},
+	switch obj.Kind {
+	case KindFood:
+		worth = 2 * obj.Count
+	case KindWeapon:
+		worth = it.Weapons[obj.Which].Worth
+		worth *= 3*(obj.HPlus+obj.DPlus) + obj.Count
+		obj.Flags.Set(Known)
+	case KindArmor:
+		worth = it.Armors[obj.Which].Worth
+		worth += (9 - obj.ArmorClass) * 100
+		worth += 10 * (g.data.aClass[obj.Which] - obj.ArmorClass)
+		obj.Flags.Set(Known)
+	case KindScroll:
+		worth = loreWorth(&it.Scrolls[obj.Which], obj.Count)
+	case KindPotion:
+		worth = loreWorth(&it.Potions[obj.Which], 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
+
+	return 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 {
+			worth += obj.Bonus * 100
+		} else {
+			worth = 10
+		}
+	}
+
+	if !obj.Flags.Has(Known) {
+		worth /= 2
+	}
+
+	obj.Flags.Set(Known)
+
+	op.Know = true
+
+	return 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
+
+	return worth
 }
 
 // killname converts a code to a monster name (rip.c killname).
@@ -239,7 +234,7 @@ func (g *RogueGame) killname(monst byte, doart bool) string {
 		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
@@ -257,18 +252,9 @@ func (g *RogueGame) killname(monst byte, doart bool) string {
 }
 
 // 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)

game/rooms.go

@@ -17,9 +17,9 @@ 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
@@ -34,91 +34,123 @@ func (g *RogueGame) doRooms() {
 	// Put the gone rooms, if any, on the level
 	leftOut := g.rnd(4)
 	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 {
-		rp := &g.Level.Rooms[i]
+		g.digRoom(i, bsze)
-		// 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) {
+// digRoom digs and populates one room (the loop body of rooms.c
-			// Place a gone room.  Make certain that there is a blank line
+// do_rooms).
-			// for passage drawing.
+func (g *RogueGame) digRoom(i int, bsze Coord) {
-			for {
+	rp := &g.Level.Rooms[i]
-				rp.Pos.X = top.X + g.rnd(bsze.X-2) + 1
+	// Find upper left corner of box that this room goes in
-				rp.Pos.Y = top.Y + g.rnd(bsze.Y-2) + 1
+	top := Coord{X: (i%3)*bsze.X + 1, Y: (i / 3) * bsze.Y}
-				rp.Max.X = -NumCols
 
-				rp.Max.Y = -NumLines
+	if rp.Flags.Has(Gone) {
-				if rp.Pos.Y > 0 && rp.Pos.Y < NumLines-1 {
+		g.placeGoneRoom(rp, top, bsze)
-					break
-				}
-			}
 
-			continue
+		return
+	}
+	// 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
 		}
-		// set room type
+	}
-		if g.rnd(10) < g.Depth-1 {
+	// Find a place and size for a random room
-			rp.Flags.Set(Dark) // dark room
+	if rp.Flags.Has(Maze) {
+		placeMazeRoom(rp, top, bsze)
+	} else {
+		g.placeNormalRoom(rp, top, bsze)
+	}
 
-			if g.rnd(15) == 0 {
+	g.drawRoom(rp)
-				rp.Flags = Maze // maze room
+	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
 		}
-		// Find a place and size for a random room
+	}
-		if rp.Flags.Has(Maze) {
+}
-			rp.Max.X = bsze.X - 1
 
-			rp.Max.Y = bsze.Y - 1
+// placeMazeRoom sizes a maze room to fill its box (rooms.c do_rooms).
-			if rp.Pos.X = top.X; rp.Pos.X == 1 {
+func placeMazeRoom(rp *Room, top, bsze Coord) {
-				rp.Pos.X = 0
+	rp.Max.X = bsze.X - 1
-			}
 
-			if rp.Pos.Y = top.Y; rp.Pos.Y == 0 {
+	rp.Max.Y = bsze.Y - 1
-				rp.Pos.Y++
+	if rp.Pos.X = top.X; rp.Pos.X == 1 {
-				rp.Max.Y--
+		rp.Pos.X = 0
-			}
+	}
-		} else {
-			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 = top.Y; rp.Pos.Y == 0 {
-				if rp.Pos.Y != 0 {
+		rp.Pos.Y++
-					break
+		rp.Max.Y--
-				}
+	}
-			}
+}
+
+// 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 {
+			return
 		}
+	}
+}
 
-		g.drawRoom(rp)
+// roomGold maybe puts a gold pile in the room (rooms.c do_rooms).
-		// Put the gold in
+func (g *RogueGame) roomGold(rp *Room) {
-		if g.rnd(2) == 0 && (!g.HasAmulet || g.Depth >= g.MaxDepth) {
+	if g.rnd(2) != 0 || (g.HasAmulet && g.Depth < g.MaxDepth) {
-			gold := newObject()
+		return
-			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 := newObject()
-			gold.Group = goldGrp
+	rp.GoldVal = g.goldCalc()
-			gold.Kind = KindGold
+	gold.GoldValue = rp.GoldVal
-			attachObj(&g.Level.Objects, gold)
+	rp.Gold, _ = g.findFloorIn(rp, 0, false)
-		}
+	gold.Pos = rp.Gold
-		// Put the monster in
+	g.Level.SetChar(rp.Gold.Y, rp.Gold.X, Gold)
-		prob := 25
-		if rp.GoldVal > 0 {
-			prob = 80
-		}
 
-		if g.rnd(100) < prob {
+	gold.Flags = Stackable
-			tp := &Monster{}
+	gold.Group = goldGrp
-			mp, _ := g.findFloorIn(rp, 0, true)
+	gold.Kind = KindGold
-			g.newMonster(tp, g.randMonster(false), mp)
+	g.Level.AddObject(gold)
-			g.givePack(tp)
+}
-		}
+
+// 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)
+		g.newMonster(tp, g.randMonster(false), mp)
+		g.givePack(tp)
 	}
 }
 
@@ -126,7 +158,7 @@ func (g *RogueGame) doRooms() {
 // 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
 	}
@@ -158,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] {
@@ -175,72 +207,82 @@ 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 {
-		cnt := 0
+		nexty, nextx, ok := g.digPick(y, x)
-
+		if !ok {
-		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
 		}
 
-		g.accntMaze(y, x, nexty, nextx)
+		g.accountMaze(y, x, nexty, nextx)
-		g.accntMaze(nexty, nextx, y, x)
+		g.accountMaze(nexty, nextx, y, x)
 
-		var pos Coord
+		g.putPassage(digWallGap(m, y, x, nexty, nextx))
-		if nexty == y {
+		g.putPassage(Coord{Y: nexty + m.starty, X: nextx + m.startx})
-			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).
+// digPick reservoir-picks the next unvisited maze cell; ok is false
-func (g *RogueGame) accntMaze(y, x, ny, nx int) {
+// 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
+		}
+	}
+
+	return nexty, nextx, cnt != 0
+}
+
+// digWallGap picks the wall square to knock out between two maze cells
+// (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 := range sp.nexits {
 		if sp.exits[i].Y == ny && sp.exits[i].X == nx {
@@ -255,8 +297,8 @@ 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
@@ -278,13 +320,20 @@ 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
@@ -296,15 +345,11 @@ func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Co
 		}
 
 		if pickroom {
-			rp = &g.Level.Rooms[g.rndRoom()]
+			rp = &g.Level.Rooms[g.randomRoom()]
-
+			compchar = floorChar(rp)
-			compchar = Floor
-			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 {
@@ -321,7 +366,7 @@ 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)
 
@@ -330,34 +375,44 @@ func (g *RogueGame) enterRoom(cp Coord) {
 			g.move(y, rp.Pos.X)
 
 			for x := rp.Pos.X; x < rp.Max.X+rp.Pos.X; x++ {
-				tp := g.Level.MonsterAt(y, x)
+				g.enterRoomCell(y, x)
-
-				ch := g.Level.Char(y, x)
-				if tp == nil {
-					if g.inch() != ch {
-						g.addch(ch)
-					} else {
-						g.move(y, x+1)
-					}
-				} else {
-					tp.OldCh = ch
-					if !g.seeMonst(tp) {
-						if p.On(SenseMonsters) {
-							g.standout()
-							g.addch(tp.Disguise)
-							g.standend()
-						} else {
-							g.addch(ch)
-						}
-					} else {
-						g.addch(tp.Disguise)
-					}
-				}
 			}
 		}
 	}
 }
 
+// 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 {
+			g.addch(ch)
+		} else {
+			g.move(y, x+1)
+		}
+
+		return
+	}
+
+	tp.OldCh = ch
+	if g.seeMonst(tp) {
+		g.addch(tp.Disguise)
+
+		return
+	}
+
+	if g.Player.On(SenseMonsters) {
+		g.standout()
+		g.addch(tp.Disguise)
+		g.standend()
+	} else {
+		g.addch(ch)
+	}
+}
+
 // leaveRoom is the code for when we exit a room (rooms.c leave_room).
 func (g *RogueGame) leaveRoom(cp Coord) {
 	p := &g.Player
@@ -381,35 +436,43 @@ 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.move(y, x)
+			g.leaveRoomCell(floor, y, x)
-
-			switch ch := g.inch(); ch {
-			case Floor:
-				if floor == ' ' {
-					g.addch(' ')
-				}
-			default:
-				// to check for monster, we have to strip out the standout
-				// bit (our Window returns the bare character already)
-				if isUpper(ch) {
-					if p.On(SenseMonsters) {
-						g.standout()
-						g.addch(ch)
-						g.standend()
-
-						break
-					}
-
-					pp := g.Level.At(y, x)
-					if pp.Ch == Door {
-						g.addch(Door)
-					} else {
-						g.addch(floor)
-					}
-				}
-			}
 		}
 	}
 
 	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 == ' ' {
+			g.addch(' ')
+		}
+	default:
+		// to check for monster, we have to strip out the standout
+		// bit (our Window returns the bare character already)
+		if !isUpper(ch) {
+			return
+		}
+
+		if g.Player.On(SenseMonsters) {
+			g.standout()
+			g.addch(ch)
+			g.standend()
+
+			return
+		}
+
+		pp := g.Level.At(y, x)
+		if pp.Ch == Door {
+			g.addch(Door)
+		} else {
+			g.addch(floor)
+		}
+	}
+}

game/run_test.go

@@ -1,27 +1,75 @@
 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.
+func fortify(g *RogueGame) {
+	p := &g.Player
+	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
+}
 
-	g := NewGame(Config{Seed: 99, Term: tt})
+// 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
+// returns — game-over exits the process — so tests drive command()
+// directly, with short scripts that avoid quitting, saving, or playing
+// long enough to starve, any of which would exit the test binary.
+func driveTurns(t *testing.T, g *RogueGame, n int) {
+	t.Helper()
 
-	err := g.Run()
+	g.startLevel()
-	if err != nil {
+	g.prePlay()
-		t.Fatalf("Run: %v", err)
+
+	for range n {
+		g.command()
 	}
+}
 
-	if g.Playing {
+// TestRunDownStairs stands the hero on the staircase and descends via the
-		t.Error("still playing after quit")
+// '>' command through the real turn loop, then checks the level changed.
+func TestRunDownStairs(t *testing.T) {
+	// '>' is a free action (After=false), so it is followed by a paying
+	// 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 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)
+
+	driveTurns(t, g, 1)
+
+	if g.Depth != 2 {
+		t.Errorf("depth = %d after descending, want 2", g.Depth)
 	}
-	// After quitting, the scoreboard is the last thing shown (in C it went
+}
-	// to stdout after endwin; here it is drawn on the screen).
+
+// TestScoreRendersList checks that the scoreboard is drawn on the screen
+// (in C it went to stdout after endwin; here it stays on the screen). The
+// quit and death paths that normally show it now exit the process, so the
+// display is exercised through score() directly.
+func TestScoreRendersList(t *testing.T) {
+	g := New(Params{Seed: 1, Term: &testTerm{}})
+	g.Player.Purse = 100
+
+	g.score(g.Player.Purse, 1, 0) // flags 1 = quit; posts the top-ten list
+
 	found := false
 
 	for y := range NumLines {
@@ -31,96 +79,126 @@ func TestRunScriptedSession(t *testing.T) {
 	}
 
 	if !found {
-		t.Error("score list not on screen after quit")
+		t.Error("score list not on screen")
 	}
 }
 
-// TestRunManyTurns mashes movement keys for a while as a crash sweep of
+// TestDeepPlaythrough drives a fortified hero through the real command loop:
-// the whole turn loop (daemons, hunger, monsters, combat), ending with a
+// quaff/read/zap on the first level, then descend through the staircase to
-// quit. The input alternates directions so the hero bumps around rooms.
+// depth 8, saving and restoring mid-way. It is a crash sweep of the turn
-func TestRunManyTurns(t *testing.T) {
+// engine, deep level generation, item effects, and mid-game save/restore.
-	// Spaces between commands double as answers to any --More-- prompts;
+// The hero is fortified so no death exits the process (step 8), and the fixed
-	// without them a single prompt would swallow the rest of the script
+// seed keeps it deterministic.
-	// (wait_for eats everything that isn't a space).
+func TestDeepPlaythrough(t *testing.T) {
-	moves := []byte("h j k l y u b n s .")
+	g := New(Params{Seed: 4242, Wizard: true, Term: &testTerm{}})
-	script := make([]byte, 0, len(moves)*200+7)
+	g.startLevel()
+	g.prePlay()
+	fortify(g)
 
-	for range 200 {
+	// Stock and use one of each consumable through the command dispatch.
-		script = append(script, moves...)
+	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")
 	}
 
-	script = append(script, " Q y Qy"...)
+	if !g.Items.Scrolls[ScrollMagicMapping].Know {
-	tt := &testTerm{input: script}
+		t.Error("read command did not identify the magic-mapping scroll")
-
-	g := NewGame(Config{Seed: 31337, Term: tt})
-
-	err := g.Run()
-	if err != nil {
-		t.Fatalf("Run: %v", err)
 	}
 
-	if g.Playing {
+	if !g.Items.Sticks[WandLight].Know {
-		t.Error("session did not end")
+		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")
 	}
 }
 
-// TestRunDownStairs walks the hero onto the stairs by teleporting there in
+// TestTurnLoopCrashSweep mashes movement, search, and rest through the real
-// wizard style, then descends and keeps playing.
+// turn loop for many turns on several seeds, exercising combat, monster AI,
-func TestRunDownStairs(t *testing.T) {
+// and traps. The hero is fortified each turn so nothing exits the process,
-	tt := &testTerm{input: []byte(">..Qy")}
+// and the fixed seeds keep it deterministic; the point is to surface panics.
-	g := NewGame(Config{Seed: 7, Term: tt})
+func TestTurnLoopCrashSweep(t *testing.T) {
-	g.NewLevel()
+	// A generous mix of movement, search, and rest. The spaces between
-	g.Player.Pos = g.Level.Stairs // stand on the stairs
+	// commands double as answers to any --More-- prompt (wait_for eats
-	g.restored = true             // keep Run from regenerating the level
+	// everything up to a space); without them one prompt would swallow the
-	g.Daemons = DaemonList{}      // and give it a fresh daemon table
+	// rest of the script. The script is long enough that the bounded drive
-	g.StartDaemon(DRunners, 0, After)
+	// never exhausts it (which would spin on the auto-fed prompt input).
-	g.StartDaemon(DDoctor, 0, After)
+	script := []byte(strings.Repeat("h j k l y u b n s . ", 400))
-	g.Fuse(DSwander, 0, wanderTime(g), After)
-	g.StartDaemon(DStomach, 0, After)
 
-	err := g.Run()
+	for _, seed := range []int32{1, 99, 2026, 31337} {
-	if err != nil {
+		g := New(Params{Seed: seed, Term: &testTerm{input: script}})
-		t.Fatalf("Run: %v", err)
+		g.startLevel()
-	}
+		g.prePlay()
 
-	if g.Depth != 2 {
+		for range 200 {
-		t.Errorf("depth = %d after descending, want 2", g.Depth)
+			fortify(g)
+			g.command()
+		}
+
+		if g.Player.Stats.HP <= 0 {
+			t.Errorf("seed %d: hero died despite fortify", seed)
+		}
 	}
 }
 
-// TestSaveCommandRoundTrip saves via the 'S' command (as a player would)
+// saveAndRestore snapshots the game to a file, restores it, checks the key
-// and restores the game.
+// state survived, and returns the restored game ready to keep playing.
-func TestSaveCommandRoundTrip(t *testing.T) {
+func saveAndRestore(t *testing.T, g *RogueGame) *RogueGame {
-	// The C get_str caps input at MAXINP=50 characters, so the save path
+	t.Helper()
-	// must be short: work from the temp directory.
-	t.Chdir(t.TempDir())
 
-	path := "cmd.save"
+	path := filepath.Join(t.TempDir(), "deep.save")
-	// 'S' with no default file name goes straight to the name prompt.
-	script := "S" + path + "\n"
-	tt := &testTerm{input: []byte(script)}
-	g := NewGame(Config{Seed: 55, Term: tt})
 
-	g.FileName = "" // force the name prompt
+	saveErr := g.saveFile(path)
-
+	if saveErr != nil {
-	runErr := g.Run()
+		t.Fatalf("saveFile: %v", saveErr)
-	if runErr != nil {
-		t.Fatalf("Run: %v", runErr)
 	}
 
-	h, err := Restore(path, Config{Term: &testTerm{}})
+	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.
-	setInput(t, h, []byte("..Qy")...)
 
-	restoredErr := h.Run()
+	return h
-	if restoredErr != nil {
-		t.Fatalf("restored Run: %v", restoredErr)
-	}
 }

game/save.go

@@ -177,8 +177,48 @@ func (g *RogueGame) packIdx(obj *Object) int {
 
 // 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,
@@ -226,25 +266,14 @@ func (g *RogueGame) snapshot() *SaveState {
 		AllScore:   g.AllScore,
 		Screen:     g.scr.Std.Contents(),
 	}
+}
 
-	// the map, sans monster pointers (rebuilt on load)
+// snapshotPlayer captures the player, equipment as pack indices (the
-	st.Places = make([]savedPlace, len(g.Level.Places))
+// player half of snapshot).
-	for i := range g.Level.Places {
+func (g *RogueGame) snapshotPlayer() savedPlayer {
-		st.Places[i] = savedPlace{
+	p := &g.Player
-			Ch:    g.Level.Places[i].Ch,
-			Flags: g.Level.Places[i].Flags,
-		}
-	}
 
-	// level objects by value; remember their pointers for dest encoding
+	sp := savedPlayer{
-	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
-	}
-
-	// the player
-	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,
@@ -260,61 +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)
+// destRefFor encodes a monster's chase target as a (kind, index)
-
+// reference: the hero, another monster, a level object, or room gold
-		ref := destRef{}
+// (state.c rs_write_thing).
-
+func (g *RogueGame) destRefFor(m *Monster, objAt map[*Object]int) destRef {
-		switch {
+	switch {
-		case m.Dest == nil:
+	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}
-				}
-			}
-
-			if ref.Kind == 0 {
-				for _, oo := range g.Level.Objects {
-					if m.Dest == &oo.Pos {
-						ref = 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}
-					}
-				}
-			}
-		}
-
-		st.Dests = append(st.Dests, ref)
 	}
 
-	return st
+	for mi, om := range g.Level.Monsters {
+		if m.Dest == &om.Pos {
+			return destRef{Kind: 2, Idx: mi}
+		}
+	}
+
+	for _, oo := range g.Level.Objects {
+		if m.Dest == &oo.Pos {
+			return destRef{Kind: 3, Idx: objAt[oo]}
+		}
+	}
+
+	for ri := range g.Level.Rooms {
+		if m.Dest == &g.Level.Rooms[ri].Gold {
+			return destRef{Kind: 4, Idx: ri}
+		}
+	}
+
+	return destRef{}
 }
 
 // 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
@@ -329,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
@@ -359,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 {
+// applyPlayer restores the player, resolving equipment pack indices
-		g.Level.Places[i] = Place{
+// (the player half of applySnapshot).
-			Ch:    st.Places[i].Ch,
+func (g *RogueGame) applyPlayer(st *SaveState) {
-			Flags: st.Places[i].Flags,
+	p := &g.Player
-		}
-	}
-
-	// level objects
-	g.Level.Objects = nil
-	for i := range st.Objects {
-		o := st.Objects[i]
-		g.Level.Objects = append(g.Level.Objects, &o)
-	}
-
-	// the player
 	sp := &st.Player
 	p.Pos = sp.Body.Pos
 	p.Turn = sp.Body.Turn
@@ -411,8 +447,11 @@ 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]
@@ -430,13 +469,17 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 		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:
@@ -445,108 +488,160 @@ 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:
+prompt:
-	useDefault := false
+	for {
+		useDefault := false
 
-	if g.FileName != "" {
+		if g.FileName != "" {
-		var c byte
+			a := g.askDefaultSave()
+			if a == saveAbort {
+				return
+			}
+
+			useDefault = a == saveYes
+		}
 
 		for {
-			g.msg("save file (%s)? ", g.FileName)
+			buf, ok := g.saveFileName(useDefault)
-			c = g.readchar()
+			if !ok {
-
-			g.Msgs.Mpos = 0
-			if c == Escape {
-				g.msg("")
-
 				return
 			}
 
-			if c == 'n' || c == 'N' || c == 'y' || c == 'Y' {
-				break
-			}
-
-			g.msg("please answer Y or N")
-		}
-
-		if c == 'y' || c == 'Y' {
-			g.addstr("Yes\n")
-			g.refresh()
-
-			useDefault = true
-		}
-	}
-
-	for {
-		var buf string
-		if useDefault {
-			buf = g.FileName
 			useDefault = false
-		} else {
-			g.Msgs.Mpos = 0
-			g.msg("file name: ")
-
-			if g.getStr(&buf, g.scr.Std) == Quit {
-				g.msg("")
 
+			a := g.saveCheckOverwrite(buf)
+			if a == saveAbort {
 				return
 			}
 
-			g.Msgs.Mpos = 0
+			if a == saveNo {
-		}
+				continue prompt // the C goto over: start again
-		// test to see if the file exists
-		_, statErr := os.Stat(buf)
-		if statErr == nil {
-			for {
-				g.msg("File exists.  Do you wish to overwrite it?")
-				g.Msgs.Mpos = 0
-
-				c := g.readchar()
-				if c == Escape {
-					g.msg("")
-
-					return
-				}
-
-				if c == 'y' || c == 'Y' {
-					break
-				}
-
-				if c == 'n' || c == 'N' {
-					goto over
-				}
-
-				g.msg("Please answer Y or N")
 			}
 
-			g.msg("file name: %s", buf)
+			g.FileName = buf
-			_ = os.Remove(g.FileName) // best effort, as in C (md_unlink)
+
+			err := g.saveFile(g.FileName)
+			if err != nil {
+				g.msg("%s", err.Error())
+
+				continue
+			}
+
+			break prompt
 		}
-
-		g.FileName = buf
-
-		err := g.saveFile(g.FileName)
-		if err != nil {
-			g.msg("%s", err.Error())
-
-			continue
-		}
-
-		break
 	}
 
 	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
+	_, 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
+
+		switch g.readchar() {
+		case Escape:
+			g.msg("")
+
+			return saveAbort
+		case 'y', 'Y':
+			return saveYes
+		case 'n', 'N':
+			return saveNo
+		}
+
+		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 {
@@ -586,7 +681,7 @@ 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) //nolint:gosec // G304: the save path is user-chosen by design
 	if err != nil {
 		return nil, err
@@ -606,14 +701,16 @@ func Restore(path string, cfg Config) (*RogueGame, error) {
 	}
 
 	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

game/save_test.go

@@ -29,7 +29,7 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 		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)
 	}
@@ -39,6 +39,15 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 		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)
@@ -67,28 +76,41 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 	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 {
-		m := h.Level.Monsters[0]
+		return
-		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.
+	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")
+	}
+}
+
+// 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,
@@ -132,7 +154,7 @@ func TestRestoreRejectsWrongVersion(t *testing.T) {
 		t.Fatal(closeErr)
 	}
 
-	_, restoreErr := Restore(path, Config{})
+	_, restoreErr := Restore(path, Params{})
 	if restoreErr == nil {
 		t.Error("restore accepted an out-of-date save")
 	}

game/score.go

@@ -25,13 +25,6 @@ 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)
@@ -114,61 +107,86 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 	topTen := g.rdScore()
 	// Insert her in list if need be
 	ins := -1
-
 	if !g.NoScore && flags >= 0 {
-		uid := os.Getuid()
+		ins = g.scoreInsert(topTen, amount, flags, monst)
+	}
 
-		scp := len(topTen)
+	lines, highlight := g.scoreLines(topTen, ins)
-		for i := range topTen {
+	g.showScores(lines, highlight)
-			if amount > topTen[i].Score {
-				scp = i
 
-				break
+	// Update the list file
-			} else if !g.AllScore && flags != 2 &&
+	if ins >= 0 {
-				topTen[i].UID == uid && topTen[i].Flags != 2 {
+		g.wrScore(topTen)
-				// only one score per nowin uid
+	}
-				scp = len(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 := g.scoreSlot(topTen, amount, flags, uid)
+	if scp >= len(topTen) {
+		return -1
+	}
+
+	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
 			}
 		}
-
-		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,
-				Flags:   flags,
-				Monster: monst,
-				Name:    g.Whoami,
-				Level:   lvl,
-				Time:    time.Now().Unix(),
-			}
-			ins = scp
-		}
 	}
 
-	// Build the list display
+	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,
+		Flags:   flags,
+		Monster: monst,
+		Name:    g.Whoami,
+		Level:   lvl,
+		Time:    time.Now().Unix(),
+	}
+
+	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)
+		}
+	}
+
+	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"
@@ -187,7 +205,7 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 		}
 
 		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 += " by " + g.killname(scp.Monster, true)
 		}
@@ -201,32 +219,35 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 		lines = append(lines, line)
 	}
 
-	if g.scr != nil && g.scr.term != nil {
+	return lines, highlight
-		g.clear()
+}
 
-		for i, line := range lines {
+// showScores prints the scoreboard on the screen when there is one,
-			if i == highlight {
+// else to standard output (rip.c score).
-				g.standout()
+func (g *RogueGame) showScores(lines []string, highlight int) {
-			}
+	if g.scr == nil || g.scr.term == nil {
-
-			g.mvaddstr(i, 0, line)
-
-			if i == highlight {
-				g.standend()
-			}
-		}
-
-		g.refresh()
-	} else {
 		for _, line := range lines {
 			_, _ = fmt.Fprintln(os.Stdout, line) // CLI output
 		}
+
+		return
 	}
 
-	// Update the list file
+	g.clear()
-	if ins >= 0 {
+
-		g.wrScore(topTen)
+	for i, line := range lines {
+		if i == highlight {
+			g.standout()
+		}
+
+		g.mvaddstr(i, 0, line)
+
+		if i == highlight {
+			g.standend()
+		}
 	}
+
+	g.refresh()
 }
 
 // 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.
@@ -213,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 {

game/scrolls.go

@@ -2,23 +2,13 @@ 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)
+	obj, ok := g.promptPackItem("read", KindScroll)
-	if obj == nil {
+	if !ok {
 		return
 	}
 
@@ -38,245 +28,8 @@ 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)
-		// Scroll of monster confusion.  Give him that power.
-		p.Flags.Set(CanConfuse)
-		g.msg("your hands begin to glow %s", g.pickColor("red"))
-	case ScrollEnchantArmor:
-		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:
-		// Hold monster scroll.  Stop all monsters within two spaces from
-		// chasing after the hero.
-		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++
-				}
-			}
-		}
-
-		if held > 0 {
-			g.addmsgf("the monster")
-
-			if held > 1 {
-				g.addmsgf("s around you")
-			}
-
-			g.addmsgf(" freeze")
-
-			if held == 1 {
-				g.addmsgf("s")
-			}
-
-			g.endmsg()
-			g.Items.Scrolls[ScrollHoldMonster].Know = true
-		} else {
-			g.msg("you feel a strange sense of loss")
-		}
-	case ScrollSleep:
-		// 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.msg("you fall asleep")
-	case ScrollCreateMonster:
-		// Create a monster: first look in a circle around him, next try
-		// his room, otherwise give up
-		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.
-				if y == p.Pos.Y && x == p.Pos.X {
-					continue
-				}
-				// 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 {
-							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")
-		} else {
-			tp := &Monster{}
-			g.newMonster(tp, g.randMonster(false), mp)
-		}
-	case ScrollIdentifyPotion, ScrollIdentifyScroll, ScrollIdentifyWeapon, ScrollIdentifyArmor, ScrollIdentifyRingOrStick:
-		// 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()])
-	case ScrollMagicMapping:
-		// 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 := range NumCols {
-				pp := g.Level.At(y, x)
-				ch := pp.Ch
-				pass := false
-
-				switch ch {
-				case Door, Stairs:
-				case '-', '|':
-					if !pp.Flags.Has(FReal) {
-						ch = Door
-						pp.Ch = Door
-						pp.Flags.Set(FReal)
-					}
-				case ' ':
-					if pp.Flags.Has(FReal) {
-						// 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 = ' '
-					} else {
-						ch = Trap
-						pp.Ch = Trap
-						pp.Flags.Set(FSeen | FReal)
-					}
-				default:
-					if pp.Flags.Has(FPassage) {
-						pass = true
-					} else {
-						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 {
-						tp.OldCh = ch
-						if !p.On(SenseMonsters) {
-							g.mvaddch(y, x, ch)
-						}
-					} else {
-						g.mvaddch(y, x, ch)
-					}
-				}
-			}
-		}
-	case ScrollFoodDetection:
-		// 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:
-		// Scroll of teleportation: make him disappear and reappear
-		curRoom := p.Room
-
-		g.teleport()
-
-		if curRoom != p.Room {
-			g.Items.Scrolls[ScrollTeleportation].Know = true
-		}
-	case ScrollEnchantWeapon:
-		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:
-		// Reading it is a mistake and produces laughter at her poor boo
-		// boo.
-		g.msg("you hear maniacal laughter in the distance")
-	case ScrollRemoveCurse:
-		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:
-		// 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:
-		if p.CurArmor != nil {
-			p.CurArmor.Flags.Set(Protected)
-			g.msg("your armor is covered by a shimmering %s shield",
-				g.pickColor("gold"))
-		} else {
-			g.msg("you feel a strange sense of loss")
-		}
 	}
 
 	g.look(true) // put the result of the scroll on the screen
@@ -285,6 +38,333 @@ func (g *RogueGame) readScroll() {
 	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.
+	g.Player.Flags.Set(CanConfuse)
+	g.msg("your hands begin to glow %s", g.pickColor("red"))
+}
+
+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"))
+	}
+}
+
+func (g *RogueGame) readHoldMonster(*Object) {
+	// Hold monster scroll.  Stop all monsters within two spaces from
+	// chasing after the hero.
+	held := g.holdMonstersNear()
+
+	if held > 0 {
+		g.addmsgf("the monster")
+
+		if held > 1 {
+			g.addmsgf("s around you")
+		}
+
+		g.addmsgf(" freeze")
+
+		if held == 1 {
+			g.addmsgf("s")
+		}
+
+		g.endmsg()
+		g.Items.Scrolls[ScrollHoldMonster].Know = true
+	} else {
+		g.msg("you feel a strange sense of loss")
+	}
+}
+
+// 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
+
+	g.Player.Flags.Clear(Awake)
+	g.msg("you fall asleep")
+}
+
+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.
+			if y == p.Pos.Y && x == p.Pos.X {
+				continue
+			}
+			// Or anything else nasty
+			if ch := g.Level.VisibleChar(y, x); stepOk(ch) {
+				if ch == Scroll {
+					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}
+				}
+			}
+		}
+	}
+
+	return mp, i != 0
+}
+
+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, g.data.idType[obj.ScrollKind()])
+}
+
+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 := 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 '-', '|':
+		ch = revealWall(pp)
+	case ' ':
+		pass = revealSolid(pp)
+	case Passage:
+		pass = true
+	case Floor:
+		ch = revealFloor(pp)
+	default:
+		if pp.Flags.Has(FPassage) {
+			pass = true
+		} else {
+			ch = ' '
+		}
+	}
+
+	if pass {
+		if !pp.Flags.Has(FReal) {
+			pp.Ch = Passage
+		}
+
+		pp.Flags.Set(FSeen | FReal)
+
+		ch = Passage
+	}
+
+	return 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
+}
+
+// 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")
+	}
+}
+
+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
+	}
+}
+
+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"))
+	}
+}
+
+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")
+}
+
+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"))
+}
+
+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")
+}
+
+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",
+			g.pickColor("gold"))
+	} else {
+		g.msg("you feel a strange sense of loss")
+	}
+}
+
 // uncurse uncurses an item (scrolls.c uncurse).
 func uncurse(obj *Object) {
 	if obj != nil {

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,12 +4,16 @@ 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)
-
+	if !ok {
-	obj := g.getItem("zap with", KindWand)
-	if obj == nil {
 		return
 	}
 
@@ -26,182 +30,263 @@ func (g *RogueGame) doZap() {
 		return
 	}
 
-	switch obj.WandKind() {
+	if h := g.data.zapHandlers[obj.WandKind()]; h != nil {
-	case WandLight:
+		if !h(g, obj) {
-		// Reddy Kilowatt wand.  Light up the room
+			return // the zap aborted; no charge is used
-		g.Items.Sticks[WandLight].Know = true
-		if p.Room.Flags.Has(Gone) {
-			g.msg("the corridor glows and then fades")
-		} else {
-			p.Room.Flags.Clear(Dark)
-			// Light the room and put the player back up
-			g.enterRoom(p.Pos)
-			g.addmsgf("the room is lit")
-
-			if !g.Options.Terse {
-				g.addmsgf(" by a shimmering %s light", g.pickColor("blue"))
-			}
-
-			g.endmsg()
 		}
-	case WandDrainLife:
-		// 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 {
-			g.msg("you are too weak to use it")
-
-			return
-		}
-
-		g.drain()
-	case WandInvisibility, WandPolymorph, WandTeleportAway, WandTeleportTo, WandCancellation:
-		y := p.Pos.Y
-
-		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
-			if monster == 'F' {
-				p.Flags.Clear(Held)
-			}
-
-			switch obj.WandKind() {
-			case WandInvisibility:
-				tp.Flags.Set(Invisible)
-
-				if g.cansee(y, x) {
-					g.mvaddch(y, x, tp.OldCh)
-				}
-			case WandPolymorph:
-				pp := tp.Pack
-				detachMon(&g.Level.Monsters, 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 = 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:
-				tp.Flags.Set(Cancelled)
-				tp.Flags.Clear(Invisible | CanConfuse)
-
-				tp.Disguise = tp.Type
-				if g.seeMonst(tp) {
-					g.mvaddch(y, x, tp.Disguise)
-				}
-			case WandTeleportAway, WandTeleportTo:
-				var newPos Coord
-
-				if obj.WandKind() == WandTeleportAway {
-					for {
-						newPos, _ = g.findFloor(true)
-						if newPos != p.Pos {
-							break
-						}
-					}
-				} else {
-					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)
-			}
-		}
-	case WandMagicMissile:
-		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") //nolint:misspell // C's spelling, kept faithfully
-		} else {
-			g.msg("the missle vanishes with a puff of smoke") //nolint:misspell // C's spelling
-		}
-	case WandHasteMonster, WandSlowMonster:
-		y := p.Pos.Y
-
-		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 {
-			if obj.WandKind() == WandHasteMonster {
-				if tp.On(Slowed) {
-					tp.Flags.Clear(Slowed)
-				} else {
-					tp.Flags.Set(Hasted)
-				}
-			} else {
-				if tp.On(Hasted) {
-					tp.Flags.Clear(Hasted)
-				} else {
-					tp.Flags.Set(Slowed)
-				}
-
-				tp.Turn = true
-			}
-
-			g.Delta.Y = y
-			g.Delta.X = x
-			g.runto(g.Delta)
-		}
-	case WandLightning, WandFire, WandCold:
-		var name string
-
-		switch obj.WandKind() {
-		case WandLightning:
-			name = "bolt"
-		case WandFire:
-			name = "flame"
-		default:
-			name = "ice"
-		}
-
-		g.fireBolt(p.Pos, &g.Delta, name)
-		g.Items.Sticks[obj.Which].Know = true
-	case WandNothing:
 	}
 
 	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")
+	} else {
+		p.Room.Flags.Clear(Dark)
+		// Light the room and put the player back up
+		g.enterRoom(p.Pos)
+		g.addmsgf("the room is lit")
+
+		if !g.Options.Terse {
+			g.addmsgf(" by a shimmering %s light", g.pickColor("blue"))
+		}
+
+		g.endmsg()
+	}
+
+	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 g.Player.Stats.HP < 2 {
+		g.msg("you are too weak to use it")
+
+		return false
+	}
+
+	g.drain()
+
+	return true
+}
+
+func (g *RogueGame) zapInvisibility(*Object) bool {
+	if tp := g.zapVictim(); tp != nil {
+		tp.Flags.Set(Invisible)
+
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
+			g.mvaddch(tp.Pos.Y, tp.Pos.X, tp.OldCh)
+		}
+	}
+
+	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
+	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 := 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
+	}
+
+	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(tp.Pos.Y, tp.Pos.X, tp.Disguise)
+		}
+	}
+
+	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(true)
+			if newPos != p.Pos {
+				break
+			}
+		}
+	} else {
+		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
+}
+
+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") //nolint:misspell // C's spelling, kept faithfully
+	} else {
+		g.msg("the missle vanishes with a puff of smoke") //nolint:misspell // C's spelling
+	}
+
+	return true
+}
+
+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)
+	}
+}
+
+// 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
+}
+
+func (g *RogueGame) zapBolt(obj *Object) bool {
+	var name string
+
+	switch obj.WandKind() {
+	case WandLightning:
+		name = "bolt"
+	case WandFire:
+		name = "flame"
+	default:
+		name = "ice"
+	}
+
+	g.fireBolt(g.Player.Pos, &g.Delta, name)
+	g.Items.Sticks[obj.Which].Know = true
+
+	return true
+}
+
 // drain does the drain-hit-points-from-player schtick (sticks.c drain).
 func (g *RogueGame) drain() {
 	p := &g.Player
@@ -216,9 +301,7 @@ func (g *RogueGame) drain() {
 	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)
 		}
 	}
@@ -237,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) {
@@ -256,21 +351,7 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 	bolt.DPlus = 0
 	g.Items.Weapons[WeaponFlame].Name = name
 
-	var dirch byte
+	dirch := boltDirChar(*dir)
-
-	switch dir.Y + dir.X {
-	case 0:
-		dirch = '/'
-	case 1, -1:
-		if dir.Y == 0 {
-			dirch = '-'
-		} else {
-			dirch = '|'
-		}
-	case 2, -2:
-		dirch = '\\'
-	}
-
 	pos := start
 	hitHero := !fromHero
 	used := false
@@ -281,22 +362,9 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 		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
 			}
@@ -314,57 +382,11 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 		if tp := g.Level.MonsterAt(pos.Y, pos.X); !hitHero && tp != nil {
 			hitHero = true
 			changed = !changed
-
+			used = g.boltStrikesMonster(tp, bolt, pos, ch, name, fromHero)
-			tp.OldCh = g.Level.Char(pos.Y, pos.X)
-			if !g.saveThrow(VsMagic, &tp.Stats) {
-				bolt.Pos = pos
-				used = true
-
-				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)
-				}
-			} 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
-
+			used = g.boltStrikesHero(start, name, fromHero)
-			if !g.save(VsMagic) {
-				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)
@@ -376,9 +398,107 @@ 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")

game/tables_test.go

@@ -13,14 +13,16 @@ func TestProbabilitiesSumTo100(t *testing.T) {
 		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 {
@@ -30,7 +32,7 @@ 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 {
@@ -45,7 +47,23 @@ func TestInitProbsCumulative(t *testing.T) {
 }
 
 func TestNewGameRandomizesAppearances(t *testing.T) {
-	g := NewGame(Config{Seed: 12345})
+	g := New(Params{Seed: 12345})
+
+	checkPotionColors(t, g)
+	checkScrollNames(t, g)
+	checkWandMaterials(t, g)
+
+	// Determinism: same seed, same appearances.
+	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 {
@@ -59,6 +77,12 @@ func TestNewGameRandomizesAppearances(t *testing.T) {
 
 		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 == "" {
@@ -69,9 +93,15 @@ func TestNewGameRandomizesAppearances(t *testing.T) {
 			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] != "wand" && g.Items.WandType[i] != "staff" {
+		if g.Items.WandType[i] != wandName && g.Items.WandType[i] != staffName {
 			t.Errorf("stick %d has type %q", i, g.Items.WandType[i])
 		}
 
@@ -79,20 +109,15 @@ func TestNewGameRandomizesAppearances(t *testing.T) {
 			t.Errorf("stick %d has no material", i)
 		}
 	}
-
-	// Determinism: same seed, same appearances.
-	h := NewGame(Config{Seed: 12345})
-	if h.Items != g.Items {
-		t.Error("two games with the same seed produced different item lore")
-	}
 }
 
 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,6 +11,8 @@ 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]

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,7 +9,7 @@ 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
@@ -17,113 +17,153 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 
 	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]
-
-		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'", 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).
-		p := &g.Player
+func (g *RogueGame) nameScroll(pb *strings.Builder, obj *Object) {
-		if obj == p.CurArmor {
+	if obj.Count == 1 {
-			out += " (being worn)"
+		pb.WriteString("A scroll ")
-		}
+	} else {
-
+		fmt.Fprintf(pb, "%d scrolls ", obj.Count)
-		if obj == p.CurWeapon {
-			out += " (weapon in hand)"
-		}
-
-		switch obj {
-		case p.CurRing[Left]:
-			out += " (on left hand)"
-		case p.CurRing[Right]:
-			out += " (on right hand)"
-		}
 	}
 
-	if out != "" {
+	op := &g.Items.Scrolls[obj.Which]
-		if drop && isUpper(out[0]) {
+
-			out = string(toLower(out[0])) + out[1:]
+	switch {
-		} else if !drop && isLower(out[0]) {
+	case op.Know:
-			out = string(toUpper(out[0])) + out[1:]
+		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)"
+	}
+
+	switch obj {
+	case p.CurRing[Left]:
+		out += " (on left hand)"
+	case p.CurRing[Right]:
+		out += " (on right hand)"
+	}
+
+	return 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]) {
+		return string(toLower(out[0])) + out[1:]
+	}
+
+	if !drop && isLower(out[0]) {
+		return string(toUpper(out[0])) + out[1:]
 	}
 
 	return out
@@ -142,8 +182,8 @@ func (g *RogueGame) dropIt() {
 		return
 	}
 
-	obj := g.getItem("drop", KindNone)
+	obj, ok := g.promptPackItem("drop", KindNone)
-	if obj == nil {
+	if !ok {
 		return
 	}
 
@@ -153,7 +193,7 @@ func (g *RogueGame) dropIt() {
 
 	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)
 
@@ -162,7 +202,7 @@ func (g *RogueGame) dropIt() {
 		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|
@@ -192,25 +232,33 @@ func (g *RogueGame) dropCheck(obj *Object) bool {
 
 		p.CurArmor = nil
 	default:
-		hand := Right
+		g.dropRing(obj)
-		if obj == p.CurRing[Left] {
-			hand = Left
-		}
-
-		p.CurRing[hand] = nil
-
-		switch obj.RingKind() {
-		case RingAddStrength:
-			g.chgStr(-obj.Bonus)
-		case RingSeeInvisible:
-			g.unsee(0)
-			g.Extinguish(DUnsee)
-		}
 	}
 
 	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.changeStrength(-obj.Bonus)
+	case RingSeeInvisible:
+		g.unsee(0)
+		g.Extinguish(DUnsee)
+	}
+}
+
 // newThing returns a new random thing for the dungeon (things.c new_thing).
 func (g *RogueGame) newThing() *Object {
 	cur := newObject()
@@ -236,47 +284,13 @@ func (g *RogueGame) newThing() *Object {
 		cur.Kind = KindScroll
 		cur.Which = pickOne(g, g.Items.Scrolls[:])
 	case 2:
-		cur.Kind = KindFood
+		g.newFoodThing(cur)
-
-		g.Player.NoFood = 0
-		if g.rnd(10) != 0 {
-			cur.Which = 0
-		} else {
-			cur.Which = 1
-		}
 	case 3:
-		g.initWeapon(cur, WeaponKind(pickOne(g, g.Items.Weapons[:NumWeaponTypes])))
+		g.newWeaponThing(cur)
-
-		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:
-		cur.Kind = KindArmor
+		g.newArmorThing(cur)
-		cur.Which = pickOne(g, g.Items.Armors[:])
-
-		cur.ArmorClass = 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:
-		cur.Kind = KindRing
+		g.newRingThing(cur)
-
-		cur.Which = pickOne(g, g.Items.Rings[:])
-		switch cur.RingKind() {
-		case RingAddStrength, RingProtection, RingDexterity, RingIncreaseDamage:
-			if cur.Bonus = g.rnd(3); cur.Bonus == 0 {
-				cur.Bonus = -1
-				cur.Flags.Set(Cursed)
-			}
-		case RingAggravateMonsters, RingTeleportation:
-			cur.Flags.Set(Cursed)
-		}
 	case 6:
 		cur.Kind = KindWand
 		cur.Which = pickOne(g, g.Items.Sticks[:])
@@ -286,6 +300,63 @@ func (g *RogueGame) newThing() *Object {
 	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
+	}
+}
+
+// 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
+	}
+}
+
+// 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 = 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
+	}
+}
+
+// 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:
+		if cur.Bonus = g.rnd(3); cur.Bonus == 0 {
+			cur.Bonus = -1
+			cur.Flags.Set(Cursed)
+		}
+	case RingAggravateMonsters, RingTeleportation:
+		cur.Flags.Set(Cursed)
+	}
+}
+
 // pickOne picks an item out of a list of possible objects using their
 // cumulative probabilities (things.c pick_one).
 func pickOne(g *RogueGame, info []ObjInfo) int {
@@ -392,7 +463,7 @@ func (g *RogueGame) printDisc(typ byte) {
 		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++
 		}
@@ -423,7 +494,6 @@ 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
@@ -440,69 +510,100 @@ func (g *RogueGame) addLine(format string, a ...any) int {
 	}
 
 	if g.Options.InvType == InvSlow {
-		if !isFlush && line != "" {
+		return g.addLineSlow(line, isFlush)
-			if g.msg("%s", line) == Escape {
+	}
-				return Escape
-			}
-		}
 
-		pg.lineCnt++
+	g.addLinePaged(line, isFlush)
-	} else {
-		if !pg.init {
-			pg.maxlen = len(prompt)
-			pg.init = true
-		}
 
-		if pg.lineCnt >= NumLines-1 || isFlush {
+	return ^Escape
-			if g.Options.InvType == InvOver && isFlush && !pg.newpage {
+}
-				// Overlay the accumulated list in a box at the top right
-				// of the screen, prompt, and restore what was beneath.
-				g.msg("")
-				g.refresh()
 
-				saved := NewWindow(NumLines, NumCols)
+// addLineSlow shows one discovery line as a message (the slow-inventory
-				saved.CopyFrom(g.scr.Std)
+// arm of things.c add_line).
-
+func (g *RogueGame) addLineSlow(line string, isFlush bool) int {
-				lx := NumCols - pg.maxlen - 2
+	if !isFlush && line != "" {
-				for y := 0; y <= pg.lineCnt; y++ {
+		if g.msg("%s", line) == Escape {
-					for x := 0; x <= pg.maxlen; x++ {
+			return Escape
-						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)
-				g.waitFor(' ')
-				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)
-
-			pg.lineCnt++
-			if pg.maxlen < len(line) {
-				pg.maxlen = len(line)
-			}
-
-			pg.lastLine = line
 		}
 	}
 
+	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 {
+		g.addLineOverlay(prompt)
+	} else {
+		g.scr.Hw.MvAddStr(NumLines-1, 0, prompt)
+		g.scr.RefreshWin(g.scr.Hw)
+		g.waitFor(' ')
+		g.scr.Hw.Clear()
+		g.refresh()
+	}
+
+	pg.newpage = true
+	pg.lineCnt = 0
+	pg.maxlen = len(prompt)
+}
+
+// addLineOverlay draws the accumulated list in a box at the top right
+// of the screen, prompts, and restores what was beneath (things.c
+// add_line).
+func (g *RogueGame) addLineOverlay(prompt string) {
+	pg := &g.invPage
+
+	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()
+}
+
 // flushLine is add_line(NULL): force out the accumulated page.
 func (g *RogueGame) flushLine() int { return g.addLine(flushSentinel) }
 
@@ -536,11 +637,11 @@ func (g *RogueGame) nothing(typ byte) 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"
 		}

game/types.go

@@ -210,16 +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
 
@@ -242,15 +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
 
@@ -277,15 +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
 
@@ -307,15 +279,6 @@ const (
 // just past them in the tables (C's MAXWEAPONS == FLAME).
 const NumWeaponTypes = WeaponFlame
 
-// String returns the weapon's name ("mace", "two handed sword", ...).
-func (w WeaponKind) String() string {
-	if w < 0 || w > WeaponFlame {
-		return "strange weapon"
-	}
-
-	return baseWeapInfo[w].Name
-}
-
 // ArmorKind identifies a suit of armor (rogue.h armor types).
 type ArmorKind int
 
@@ -332,15 +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
 
@@ -363,15 +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
 
@@ -394,15 +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 {

game/weapons.go

@@ -9,8 +9,8 @@ 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
 	}
 
@@ -35,34 +35,38 @@ 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 {
-			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 {
+		if !stepOk(ch) || ch == Door {
-			// It hasn't hit anything yet, so display it if it's alright.
+			break
-			if g.cansee(obj.Pos.Y, obj.Pos.X) && !g.Options.Terse {
+		}
-				g.mvaddch(obj.Pos.Y, obj.Pos.X, obj.Kind.Glyph())
+		// It hasn't hit anything yet, so display it if it's alright.
-				g.refresh()
+		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
 	}
 }
 
+// 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)
+}
+
 // 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 {
@@ -70,7 +74,7 @@ func (g *RogueGame) fall(obj *Object, pr bool) {
 		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 {
@@ -78,7 +82,7 @@ func (g *RogueGame) fall(obj *Object, pr bool) {
 			}
 		}
 
-		attachObj(&g.Level.Objects, obj)
+		g.Level.AddObject(obj)
 
 		return
 	}
@@ -113,8 +117,8 @@ func (g *RogueGame) wield() {
 
 	p.CurWeapon = oweapon
 
-	obj := g.getItem("wield", KindWeapon)
+	obj, ok := g.promptPackItem("wield", KindWeapon)
-	if obj == nil {
+	if !ok {
 		g.After = false
 
 		return
@@ -133,7 +137,7 @@ func (g *RogueGame) wield() {
 		return
 	}
 
-	sp := g.invName(obj, true)
+	sp := g.inventoryName(obj, true)
 	p.CurWeapon = obj
 
 	if !g.Options.Terse {
@@ -143,27 +147,18 @@ func (g *RogueGame) wield() {
 	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

game/wizard.go

@@ -27,50 +27,9 @@ func (g *RogueGame) createObj() {
 
 	switch obj.Kind {
 	case KindWeapon, KindArmor:
-		g.msg("blessing? (+,-,n)")
+		g.createWeaponArmor(obj)
-		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]
-			if bless == '-' {
-				obj.ArmorClass += g.rnd(3) + 1
-			}
-
-			if bless == '+' {
-				obj.ArmorClass -= g.rnd(3) + 1
-			}
-		}
 	case KindRing:
-		switch obj.RingKind() {
+		g.createRing(obj)
-		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
-			} else {
-				obj.Bonus = g.rnd(2) + 1
-			}
-		case RingAggravateMonsters, RingTeleportation:
-			obj.Flags.Set(Cursed)
-		}
 	case KindWand:
 		g.fixStick(obj)
 	case KindGold:
@@ -85,6 +44,61 @@ func (g *RogueGame) createObj() {
 	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
+		}
+
+		return
+	}
+
+	obj.ArmorClass = g.data.aClass[obj.Which]
+	if bless == '-' {
+		obj.ArmorClass += g.rnd(3) + 1
+	}
+
+	if bless == '+' {
+		obj.ArmorClass -= g.rnd(3) + 1
+	}
+}
+
+// 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
+		} else {
+			obj.Bonus = g.rnd(2) + 1
+		}
+	case RingAggravateMonsters, RingTeleportation:
+		obj.Flags.Set(Cursed)
+	}
+}
+
 // showMap prints out the whole map for the wizard (wizard.c show_map).
 func (g *RogueGame) showMap() {
 	hw := g.scr.Hw
@@ -117,34 +131,8 @@ func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
 		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")
-
-			continue
-		}
-
-		if !matchesFilter(kind, obj) {
-			g.msg("you must identify a %s", kind)
-
-			continue
-		}
-
-		break
-	}
-
-	if obj == nil {
 		return
 	}
 
@@ -161,7 +149,38 @@ func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
 		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
@@ -181,7 +200,7 @@ func (g *RogueGame) teleport() {
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())
 
 	c, _ := g.findFloor(true)
-	if g.roomin(c) != p.Room {
+	if g.roomIn(c) != p.Room {
 		g.leaveRoom(p.Pos)
 		p.Pos = c
 		g.enterRoom(p.Pos)

term/tcell.go

@@ -89,48 +89,88 @@ 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()) //nolint:gosec // G115: 1..26 fits
-				}
-
-				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() {