Merge refactor/god-object-extraction (refactor step 6)

Refactor step 6. MessageLine (was MsgLine) owns the msg/addmsg/endmsg
machinery, wired to its screen, pre---More-- redraw, and input via
attach(); RogueGame keeps one-line msg/addmsgf/endmsg shorthands so
the ~400 call sites are unchanged. Player gains nextPackChar and
removeFromPack (the state half of pack.c leave_pack); leavePack keeps
only the LastPick repeat-command tracking. Level gains ObjectAt
(misc.c find_obj) and AddObject/RemoveObject/AddMonster/RemoveMonster,
replacing direct attach/detach calls on the level lists. Inventory and
pickup UI flows stay on RogueGame: display and orchestration, not
state surgery. Behavior and RNG order unchanged; suite green.

.golangci.yml

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

MEMORY.md

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

TODO.md

@@ -29,12 +29,64 @@ Refactor ground rules:
 
 # Next Step
 
-Adopt the house Go linting standards: copy .golangci.yml from the
-prompts repo and bring game/, term/, and cmd/ lint-clean (the port is
-greenfield code, so no exemptions apply).
+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. This step also
+clears the outstanding cyclop/gocognit/nestif lint findings.
 
 # Completed Steps
 
+- 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
@@ -76,45 +128,27 @@ greenfield code, so no exemptions apply).
 
 # Future Steps
 
-1. Refactor step 4: method renames, movement/world subsystem
-   (doMove→moveHero, beTrapped→springTrap, rndmove→randomStep,
-   doRooms/doPassages/doMaze→digRooms/digPassages/digMaze,
-   chgStr→changeStrength, ...); remove the goto/label flows in doMove,
-   dispatch, and saveGame in favor of loops and helpers.
-2. Refactor step 5: method renames, items/combat/UI subsystems
-   (invName→inventoryName, rollEm→rollAttacks, doPot→applyPotionFuse,
-   getItem→promptPackItem returning (obj, ok), getDir→promptDirection);
-   int status codes (attack returning -1) become named results. Two or
-   three commits, one subsystem each.
-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
+1. 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
+2. 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
+3. 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
+4. 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
+5. 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)
+6. Tag a release once a full game (Amulet retrieval and score entry)
    completes without defects.
-11. Full-terminal-size support (deferred by explicit decision
+7. 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
+8. Note: this repo is exempt from the standard policy scaffold. Do not
    add Makefile, Dockerfile, or REPO_POLICIES.md.

cmd/rogue/main.go

@@ -18,61 +18,45 @@ import (
 )
 
 func main() {
+	os.Exit(run())
+}
+
+// run carries the real main so that deferred terminal restoration runs
+// before the process exits (os.Exit skips defers).
+func run() int {
 	scores := flag.Bool("s", false, "print the scoreboard and exit")
 	deathDemo := flag.Bool("d", false, "die a random death (demo)")
+
 	flag.Parse()
 
-	home, _ := os.UserHomeDir()
-
-	// get options from environment (main.c)
-	rogueOpts := os.Getenv("ROGUEOPTS")
-	name := ""
-	if u, err := user.Current(); err == nil {
-		name = u.Username
-	}
-
-	wizard := os.Getenv("ROGUE_WIZARD") != ""
-	// dungeon number: SEED for reproducible dungeons (wizard mode in C),
-	// else time+pid
-	var seed int32
-	if env := os.Getenv("SEED"); env != "" && wizard {
-		n, _ := strconv.Atoi(env)
-		seed = int32(n)
-	} else {
-		seed = int32(time.Now().Unix()) + int32(os.Getpid())
-	}
-
-	cfg := game.Config{
-		Seed:      seed,
-		Name:      name,
-		RogueOpts: rogueOpts,
-		Home:      home,
-		ScorePath: home + "/.rogue.scores",
-		Wizard:    wizard,
-	}
+	cfg := loadConfig()
 
 	if *scores {
-		g := game.NewGame(cfg)
-		g.ShowScores()
-		return
+		game.NewGame(cfg).ShowScores()
+
+		return 0
 	}
 
 	t, err := term.New()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
+
+		return 1
 	}
 	defer t.Fini()
+
 	cfg.Term = t
 
 	var g *game.RogueGame
+
 	if args := flag.Args(); len(args) == 1 && !*deathDemo {
 		// restore a saved game
 		g, err = game.Restore(args[0], cfg)
 		if err != nil {
 			t.Fini()
 			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
+
+			return 1
 		}
 	} else {
 		g = game.NewGame(cfg)
@@ -80,22 +64,75 @@ func main() {
 
 	if *deathDemo {
 		g.DeathDemo()
-		return
+
+		return 0
 	}
 
-	// SIGHUP/SIGTERM autosave (save.c auto_save)
+	installAutosave(g, t)
+
+	runErr := g.Run()
+	if runErr != nil {
+		t.Fini()
+		fmt.Fprintln(os.Stderr, runErr)
+
+		return 1
+	}
+
+	return 0
+}
+
+// loadConfig gathers the game configuration from the environment: home
+// directory, ROGUEOPTS, user name, wizard mode, and the dungeon seed
+// (main.c's startup).
+func loadConfig() game.Config {
+	home, _ := os.UserHomeDir()
+
+	name := ""
+
+	u, userErr := user.Current()
+	if userErr == nil {
+		name = u.Username
+	}
+
+	wizard := os.Getenv("ROGUE_WIZARD") != ""
+
+	return game.Config{
+		Seed:      chooseSeed(wizard),
+		Name:      name,
+		RogueOpts: os.Getenv("ROGUEOPTS"),
+		Home:      home,
+		ScorePath: home + "/.rogue.scores",
+		Wizard:    wizard,
+	}
+}
+
+// installAutosave saves the game and exits on SIGHUP/SIGTERM (save.c
+// auto_save).
+func installAutosave(g *game.RogueGame, t *term.Tcell) {
 	sig := make(chan os.Signal, 1)
+
 	signal.Notify(sig, syscall.SIGHUP, syscall.SIGTERM)
+
 	go func() {
 		<-sig
 		g.AutoSave()
 		t.Fini()
 		os.Exit(0)
 	}()
-
-	if err := g.Run(); err != nil {
-		t.Fini()
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
+}
+
+// chooseSeed picks the dungeon number: SEED for reproducible dungeons
+// (wizard mode, as in the C game), else time+pid (main.c).
+func chooseSeed(wizard bool) int32 {
+	if env := os.Getenv("SEED"); env != "" && wizard {
+		n, err := strconv.ParseInt(env, 10, 32)
+		if err == nil {
+			return int32(n)
+		}
+	}
+
+	// The C game computed `lowtime + getpid()` in int; the truncation to
+	// 32 bits is the same wraparound the C int arithmetic performed.
+	return int32(time.Now().Unix()&0x7fffffff) +
+		int32(os.Getpid()&0x7fffffff)
 }

game/armor.go

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

game/chase.go

@@ -11,42 +11,51 @@ func (g *RogueGame) runners(int) {
 	for _, tp := range list {
 		if !tp.On(Held) && tp.On(Awake) {
 			origPos := tp.Pos
+
 			wastarget := tp.On(Targeted)
-			if g.moveMonst(tp) == -1 {
+			if removed := g.moveMonster(tp); removed {
 				continue
 			}
+
 			if tp.On(Flying) && distCp(g.Player.Pos, tp.Pos) >= 3 {
-				if g.moveMonst(tp) == -1 {
+				if removed := g.moveMonster(tp); removed {
 					continue
 				}
 			}
+
 			if wastarget && origPos != tp.Pos {
 				tp.Flags.Clear(Targeted)
+
 				g.ToDeath = false
 			}
 		}
 	}
+
 	if g.HasHit {
 		g.endmsg()
 		g.HasHit = false
 	}
 }
 
-// moveMonst executes a single turn of running for a monster (chase.c
-// move_monst). Returns -1 if the monster died or left the level.
-func (g *RogueGame) moveMonst(tp *Monster) int {
+// 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 {
-			return -1
+		if g.chaseStep(tp) {
+			return true
 		}
 	}
+
 	if tp.On(Hasted) {
-		if g.doChase(tp) == -1 {
-			return -1
+		if g.chaseStep(tp) {
+			return true
 		}
 	}
+
 	tp.Turn = !tp.Turn
-	return 0
+
+	return false
 }
 
 // relocate makes the monster's new location be the specified one, updating
@@ -54,18 +63,21 @@ func (g *RogueGame) moveMonst(tp *Monster) int {
 func (g *RogueGame) relocate(th *Monster, newLoc Coord) {
 	if newLoc != th.Pos {
 		g.mvaddch(th.Pos.Y, th.Pos.X, th.OldCh)
-		th.Room = g.roomin(newLoc)
-		g.setOldch(th, newLoc)
+		th.Room = g.roomIn(newLoc)
+		g.setOldChar(th, newLoc)
 		oroom := th.Room
 		g.Level.SetMonsterAt(th.Pos.Y, th.Pos.X, nil)
 
 		if oroom != th.Room {
 			th.Dest = g.findDest(th)
 		}
+
 		th.Pos = newLoc
 		g.Level.SetMonsterAt(newLoc.Y, newLoc.X, th)
 	}
+
 	g.move(newLoc.Y, newLoc.X)
+
 	if g.seeMonst(th) {
 		g.addch(th.Disguise)
 	} else if g.Player.On(SenseMonsters) {
@@ -75,9 +87,10 @@ func (g *RogueGame) relocate(th *Monster, newLoc Coord) {
 	}
 }
 
-// doChase makes one thing chase another (chase.c do_chase). Returns -1 if
-// the chaser died in the attempt.
-func (g *RogueGame) doChase(th *Monster) int {
+// chaseStep makes one thing chase another (chase.c do_chase). removed
+// reports that the chaser died or left the level in the attempt (the C
+// -1 return).
+func (g *RogueGame) chaseStep(th *Monster) (removed bool) {
 	p := &g.Player
 	stoprun := false // true means we are there
 	mindist := 32767
@@ -86,19 +99,21 @@ func (g *RogueGame) doChase(th *Monster) int {
 	if th.On(Greedy) && rer.GoldVal == 0 {
 		th.Dest = &p.Pos // if gold has been taken, run after hero
 	}
+
 	var ree *Room // find room of chasee
 	if th.Dest == &p.Pos {
 		ree = p.Room
 	} else {
-		ree = g.roomin(*th.Dest)
+		ree = g.roomIn(*th.Dest)
 	}
 	// We don't count doors as inside rooms for this routine
 	door := g.Level.Char(th.Pos.Y, th.Pos.X) == Door
+
 	var this Coord
 
-over:
-	// If the object of our desire is in a different room, and we are not
-	// in a corridor, run to the door nearest to our goal.
+	for {
+		// If the object of our desire is in a different room, and we are
+		// not in a corridor, run to the door nearest to our goal.
 		if rer != ree {
 			for i := range rer.Exits {
 				curdist := distCp(*th.Dest, rer.Exits[i])
@@ -107,36 +122,45 @@ over:
 					mindist = curdist
 				}
 			}
+
 			if door {
 				rer = &g.Level.Passages[*g.Level.FlagsAt(th.Pos.Y, th.Pos.X)&FPassNum]
 				door = false
-			goto over
+
+				continue // the C goto over: redo with the passage as room
 			}
 		} else {
 			this = *th.Dest
-		// For dragons check and see if (a) the hero is on a straight line
-		// from it, and (b) that it is within shooting distance, but
-		// outside of striking range.
+			// 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)
 				if g.HasHit {
 					g.endmsg()
 				}
+
 				g.fireBolt(th.Pos, &g.Delta, "flame")
 				g.Running = false
 				g.Count = 0
+
 				g.Quiet = 0
 				if g.ToDeath && !th.On(Targeted) {
 					g.ToDeath = false
 					g.Kamikaze = false
 				}
-			return 0
+
+				return false
 			}
 		}
+
+		break
+	}
 	// 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) {
@@ -145,32 +169,38 @@ over:
 		} else if this == *th.Dest {
 			for _, obj := range g.Level.Objects {
 				if th.Dest == &obj.Pos {
-					detachObj(&g.Level.Objects, obj)
+					g.Level.RemoveObject(obj)
 					attachObj(&th.Pack, obj)
+
 					if th.Room.Flags.Has(Gone) {
 						g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Passage)
 					} else {
 						g.Level.SetChar(obj.Pos.Y, obj.Pos.X, Floor)
 					}
+
 					th.Dest = g.findDest(th)
+
 					break
 				}
 			}
+
 			if th.Type != 'F' {
 				stoprun = true
 			}
 		}
 	} else {
 		if th.Type == 'F' {
-			return 0
+			return false
 		}
 	}
+
 	g.relocate(th, g.chRet)
 	// And stop running if need be
 	if stoprun && th.Pos == *th.Dest {
 		th.Flags.Clear(Awake)
 	}
-	return 0
+
+	return false
 }
 
 // chase finds the spot for the chaser to move closer to the chasee
@@ -180,6 +210,7 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 	p := &g.Player
 	er := tp.Pos
 	plcnt := 1
+
 	var curdist int
 
 	// If the thing is confused, let it move randomly. Invisible Stalkers
@@ -188,7 +219,7 @@ 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 {
@@ -206,6 +237,7 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 		if ey >= NumLines-1 {
 			ey = NumLines - 2
 		}
+
 		ex := er.X + 1
 		if ex >= NumCols {
 			ex = NumCols - 1
@@ -215,11 +247,13 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 			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
@@ -227,12 +261,15 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 					// 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
 						}
@@ -258,15 +295,18 @@ func (g *RogueGame) chase(tp *Monster, ee Coord) bool {
 			}
 		}
 	}
+
 	return curdist != 0 && g.chRet != p.Pos
 }
 
-// setOldch sets the oldch character for the monster (chase.c set_oldch).
-func (g *RogueGame) setOldch(tp *Monster, cp Coord) {
+// setOldChar sets the oldch character for the monster (chase.c set_oldch).
+func (g *RogueGame) setOldChar(tp *Monster, cp Coord) {
 	if tp.Pos == cp {
 		return
 	}
+
 	sch := tp.OldCh
+
 	tp.OldCh = g.mvinch(cp.Y, cp.X)
 	if !g.Player.On(Blind) {
 		if (sch == Floor || tp.OldCh == Floor) && tp.Room.Flags.Has(Dark) {
@@ -284,25 +324,30 @@ func (g *RogueGame) seeMonst(mp *Monster) bool {
 	if p.On(Blind) {
 		return false
 	}
+
 	if mp.On(Invisible) && !p.On(CanSeeInvisible) {
 		return false
 	}
+
 	y, x := mp.Pos.Y, mp.Pos.X
 	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
 		if y != p.Pos.Y && x != p.Pos.X &&
 			!stepOk(g.Level.Char(y, p.Pos.X)) && !stepOk(g.Level.Char(p.Pos.Y, x)) {
 			return false
 		}
+
 		return true
 	}
+
 	if mp.Room != p.Room {
 		return false
 	}
+
 	return !mp.Room.Flags.Has(Dark)
 }
 
-// runto sets a monster running after the hero (chase.c runto).
-func (g *RogueGame) runto(runner Coord) {
+// runTo sets a monster running after the hero (chase.c runto).
+func (g *RogueGame) runTo(runner Coord) {
 	tp := g.Level.MonsterAt(runner.Y, runner.X)
 	if tp == nil {
 		return
@@ -313,9 +358,9 @@ func (g *RogueGame) runto(runner Coord) {
 	tp.Dest = g.findDest(tp)
 }
 
-// roomin finds what room some coordinates are in; nil means they aren't in
+// roomIn finds what room some coordinates are in; nil means they aren't in
 // any room (chase.c roomin).
-func (g *RogueGame) roomin(cp Coord) *Room {
+func (g *RogueGame) roomIn(cp Coord) *Room {
 	fp := *g.Level.FlagsAt(cp.Y, cp.X)
 	if fp.Has(FPassage) {
 		return &g.Level.Passages[fp&FPassNum]
@@ -330,6 +375,7 @@ func (g *RogueGame) roomin(cp Coord) *Room {
 	}
 
 	g.msg("in some bizarre place (%d, %d)", cp.Y, cp.X)
+
 	return nil
 }
 
@@ -338,19 +384,22 @@ func (g *RogueGame) diagOk(sp, ep Coord) bool {
 	if ep.X < 0 || ep.X >= NumCols || ep.Y <= 0 || ep.Y >= NumLines-1 {
 		return false
 	}
+
 	if ep.X == sp.X || ep.Y == sp.Y {
 		return true
 	}
+
 	return stepOk(g.Level.Char(ep.Y, sp.X)) && stepOk(g.Level.Char(sp.Y, ep.X))
 }
 
-// cansee returns true if the hero can see a certain coordinate (chase.c
+// canSee returns true if the hero can see a certain coordinate (chase.c
 // cansee).
-func (g *RogueGame) cansee(y, x int) bool {
+func (g *RogueGame) canSee(y, x int) bool {
 	p := &g.Player
 	if p.On(Blind) {
 		return false
 	}
+
 	if distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
 		if g.Level.FlagsAt(y, x).Has(FPassage) {
 			if y != p.Pos.Y && x != p.Pos.X &&
@@ -359,11 +408,13 @@ func (g *RogueGame) cansee(y, x int) bool {
 				return false
 			}
 		}
+
 		return true
 	}
 	// We can only see if the hero is in the same room as the coordinate
 	// and the room is lit, or if it is close.
-	rer := g.roomin(Coord{X: x, Y: y})
+	rer := g.roomIn(Coord{X: x, Y: y})
+
 	return rer == p.Room && !rer.Flags.Has(Dark)
 }
 
@@ -374,22 +425,28 @@ func (g *RogueGame) findDest(tp *Monster) *Coord {
 	if prob <= 0 || tp.Room == g.Player.Room || g.seeMonst(tp) {
 		return &g.Player.Pos
 	}
+
 	for _, obj := range g.Level.Objects {
 		if obj.Kind == KindScroll && obj.ScrollKind() == ScrollScareMonster {
 			continue
 		}
-		if g.roomin(obj.Pos) == tp.Room && g.rnd(100) < prob {
+
+		if g.roomIn(obj.Pos) == tp.Room && g.rnd(100) < prob {
 			claimed := false
+
 			for _, other := range g.Level.Monsters {
 				if other.Dest == &obj.Pos {
 					claimed = true
+
 					break
 				}
 			}
+
 			if !claimed {
 				return &obj.Pos
 			}
 		}
 	}
+
 	return &g.Player.Pos
 }

game/command.go

@@ -6,6 +6,7 @@ package game
 // bracketing (command.c command).
 func (g *RogueGame) command() {
 	p := &g.Player
+
 	ntimes := 1 // number of player moves
 	if p.On(Hasted) {
 		ntimes++
@@ -13,6 +14,7 @@ func (g *RogueGame) command() {
 	// Let the daemons start up
 	g.DoDaemons(Before)
 	g.DoFuses(Before)
+
 	for ; ntimes > 0; ntimes-- {
 		g.Again = false
 		if g.HasHit {
@@ -26,29 +28,37 @@ func (g *RogueGame) command() {
 		}
 
 		g.look(true)
+
 		if !g.Running {
 			g.DoorStop = false
 		}
+
 		g.status()
 		g.LastScore = p.Purse
 		g.move(p.Pos.Y, p.Pos.X)
-		if !((g.Running || g.Count != 0) && g.Options.Jump) {
+
+		if (!g.Running && g.Count == 0) || !g.Options.Jump {
 			g.refresh() // draw screen
 		}
+
 		g.Take = 0
 		g.After = true
 		// Read command or continue run
 		if g.Wizard {
 			g.NoScore = true
 		}
+
 		var ch byte
+
 		if g.NoCommand == 0 {
-			if g.Running || g.ToDeath {
+			switch {
+			case g.Running || g.ToDeath:
 				ch = g.RunCh
-			} else if g.Count != 0 {
+			case g.Count != 0:
 				ch = g.countCh
-			} else {
+			default:
 				ch = g.readchar()
+
 				g.MoveOn = false
 				if g.Msgs.Mpos != 0 { // erase message if its there
 					g.msg("")
@@ -57,6 +67,7 @@ func (g *RogueGame) command() {
 		} else {
 			ch = '.'
 		}
+
 		if g.NoCommand != 0 {
 			if g.NoCommand--; g.NoCommand == 0 {
 				p.Flags.Set(Awake)
@@ -67,14 +78,14 @@ func (g *RogueGame) command() {
 			g.newCount = false
 			if isDigit(ch) {
 				g.Count = 0
+
 				g.newCount = true
 				for isDigit(ch) {
-					g.Count = g.Count*10 + int(ch-'0')
-					if g.Count > 255 {
-						g.Count = 255
-					}
+					g.Count = min(g.Count*10+int(ch-'0'), 255)
+
 					ch = g.readchar()
 				}
+
 				g.countCh = ch
 				// turn off count for commands which don't make sense
 				// to repeat
@@ -93,8 +104,9 @@ func (g *RogueGame) command() {
 			if g.Count != 0 && !g.Running {
 				g.Count--
 			}
+
 			if ch != 'a' && ch != Escape &&
-				!(g.Running || g.Count != 0 || g.ToDeath) {
+				!g.Running && g.Count == 0 && !g.ToDeath {
 				g.LLastComm = g.LastComm
 				g.LLastDir = g.LastDir
 				g.LLastPick = g.LastPick
@@ -102,6 +114,7 @@ func (g *RogueGame) command() {
 				g.LastDir = 0
 				g.LastPick = nil
 			}
+
 			g.dispatch(ch)
 			// turn off flags if no longer needed
 			if !g.Running {
@@ -112,20 +125,25 @@ func (g *RogueGame) command() {
 		if g.Take != 0 {
 			g.pickUp(g.Take)
 		}
+
 		if !g.Running {
 			g.DoorStop = false
 		}
+
 		if !g.After {
 			ntimes++
 		}
 	}
+
 	g.DoDaemons(After)
 	g.DoFuses(After)
+
 	if p.IsRing(Left, RingSearching) {
 		g.search()
 	} else if p.IsRing(Left, RingTeleportation) && g.rnd(50) == 0 {
 		g.teleport()
 	}
+
 	if p.IsRing(Right, RingSearching) {
 		g.search()
 	} else if p.IsRing(Right, RingTeleportation) && g.rnd(50) == 0 {
@@ -133,108 +151,125 @@ func (g *RogueGame) command() {
 	}
 }
 
-// dispatch runs one command character (the big switch in command.c,
-// including its `goto over` re-dispatch).
+// dispatch runs one command character (the big switch in command.c; the
+// loop stands in for its `goto over` re-dispatch).
 func (g *RogueGame) dispatch(ch byte) {
 	p := &g.Player
-over:
+
+	for {
 		switch ch {
 		case ',':
 			var found *Object
+
 			for _, obj := range g.Level.Objects {
 				if obj.Pos.Y == p.Pos.Y && obj.Pos.X == p.Pos.X {
 					found = obj
+
 					break
 				}
 			}
+
 			if found != nil {
 				if !g.levitCheck() {
 					g.pickUp(found.Kind.Glyph())
 				}
 			} else {
 				if !g.Options.Terse {
-				g.addmsg("there is ")
+					g.addmsgf("there is ")
 				}
-			g.addmsg("nothing here")
+
+				g.addmsgf("nothing here")
+
 				if !g.Options.Terse {
-				g.addmsg(" to pick up")
+					g.addmsgf(" to pick up")
 				}
+
 				g.endmsg()
 			}
 		case '!':
 			g.shell()
 		case 'h':
-		g.doMove(0, -1)
+			g.moveHero(0, -1)
 		case 'j':
-		g.doMove(1, 0)
+			g.moveHero(1, 0)
 		case 'k':
-		g.doMove(-1, 0)
+			g.moveHero(-1, 0)
 		case 'l':
-		g.doMove(0, 1)
+			g.moveHero(0, 1)
 		case 'y':
-		g.doMove(-1, -1)
+			g.moveHero(-1, -1)
 		case 'u':
-		g.doMove(-1, 1)
+			g.moveHero(-1, 1)
 		case 'b':
-		g.doMove(1, -1)
+			g.moveHero(1, -1)
 		case 'n':
-		g.doMove(1, 1)
+			g.moveHero(1, 1)
 		case 'H':
-		g.doRun('h')
+			g.startRun('h')
 		case 'J':
-		g.doRun('j')
+			g.startRun('j')
 		case 'K':
-		g.doRun('k')
+			g.startRun('k')
 		case 'L':
-		g.doRun('l')
+			g.startRun('l')
 		case 'Y':
-		g.doRun('y')
+			g.startRun('y')
 		case 'U':
-		g.doRun('u')
+			g.startRun('u')
 		case 'B':
-		g.doRun('b')
+			g.startRun('b')
 		case 'N':
-		g.doRun('n')
+			g.startRun('n')
 		case CTRL('H'), CTRL('J'), CTRL('K'), CTRL('L'),
 			CTRL('Y'), CTRL('U'), CTRL('B'), CTRL('N'):
 			if !p.On(Blind) {
 				g.DoorStop = true
 				g.Firstmove = true
 			}
+
 			if g.Count != 0 && !g.newCount {
 				ch = g.direction
 			} else {
 				ch += 'A' - CTRL('A')
 				g.direction = ch
 			}
-		goto over
+
+			continue // the C goto over: re-dispatch as the run command
 		case 'F', 'f':
 			if ch == 'F' {
 				g.Kamikaze = true
 			}
-		if !g.getDir() {
+
+			if !g.promptDirection() {
 				g.After = false
+
 				break
 			}
+
 			g.Delta.Y += p.Pos.Y
 			g.Delta.X += p.Pos.X
+
 			mp := g.Level.MonsterAt(g.Delta.Y, g.Delta.X)
 			if mp == nil || (!g.seeMonst(mp) && !p.On(SenseMonsters)) {
 				if !g.Options.Terse {
-				g.addmsg("I see ")
+					g.addmsgf("I see ")
 				}
+
 				g.msg("no monster there")
 				g.After = false
 			} else if g.diagOk(p.Pos, g.Delta) {
 				g.ToDeath = true
 				g.MaxHit = 0
+
 				mp.Flags.Set(Targeted)
+
 				g.RunCh = g.DirCh
 				ch = g.DirCh
-			goto over
+
+				continue // the C goto over: fight by running at it
 			}
 		case 't':
-		if !g.getDir() {
+			if !g.promptDirection() {
 				g.After = false
 			} else {
 				g.missile(g.Delta.Y, g.Delta.X)
@@ -246,7 +281,8 @@ over:
 			} else {
 				ch = g.LastComm
 				g.Again = true
-			goto over
+
+				continue // the C goto over: replay the last command
 			}
 		case 'q':
 			g.quaff()
@@ -298,7 +334,7 @@ over:
 		case 's':
 			g.search()
 		case 'z':
-		if g.getDir() {
+			if g.promptDirection() {
 				g.doZap()
 			} else {
 				g.After = false
@@ -324,19 +360,22 @@ over:
 			g.After = false // "legal" illegal command
 		case '^':
 			g.After = false
-		if g.getDir() {
+			if g.promptDirection() {
 				g.Delta.Y += p.Pos.Y
 				g.Delta.X += p.Pos.X
+
 				fp := g.Level.FlagsAt(g.Delta.Y, g.Delta.X)
 				if !g.Options.Terse {
-				g.addmsg("You have found ")
+					g.addmsgf("You have found ")
 				}
-			if g.Level.Char(g.Delta.Y, g.Delta.X) != Trap {
+
+				switch {
+				case g.Level.Char(g.Delta.Y, g.Delta.X) != Trap:
 					g.msg("no trap there")
-			} else if p.On(Hallucinating) {
-				g.msg("%s", trName[g.rnd(NumTrapTypes)])
-			} else {
-				g.msg("%s", trName[*fp&FTrapMask])
+				case p.On(Hallucinating):
+					g.msg("%s", g.data.trName[g.rnd(NumTrapTypes)])
+				default:
+					g.msg("%s", g.data.trName[*fp&FTrapMask])
 					fp.Set(FSeen)
 				}
 			}
@@ -347,12 +386,13 @@ over:
 			g.Again = false
 		case 'm':
 			g.MoveOn = true
-		if !g.getDir() {
+			if !g.promptDirection() {
 				g.After = false
 			} else {
 				ch = g.DirCh
 				g.countCh = g.DirCh
-			goto over
+
+				continue // the C goto over: move onto it without pickup
 			}
 		case ')':
 			g.current(p.CurWeapon, "wielding", "")
@@ -376,11 +416,15 @@ over:
 				g.illcom(ch)
 			}
 		}
+
+		return
+	}
 }
 
 // wizardCommand handles the MASTER debug commands (command.c).
 func (g *RogueGame) wizardCommand(ch byte) {
 	p := &g.Player
+
 	switch ch {
 	case '|':
 		g.msg("@ %d,%d", p.Pos.Y, p.Pos.X)
@@ -409,7 +453,7 @@ func (g *RogueGame) wizardCommand(ch byte) {
 	case CTRL('X'):
 		g.turnSee(p.On(SenseMonsters))
 	case CTRL('~'):
-		if item := g.getItem("charge", KindWand); item != nil {
+		if item, ok := g.promptPackItem("charge", KindWand); ok {
 			item.Charges = 10000
 		}
 	case CTRL('I'):
@@ -452,62 +496,81 @@ func (g *RogueGame) search() {
 	p := &g.Player
 	ey := p.Pos.Y + 1
 	ex := p.Pos.X + 1
+
 	probinc := 0
 	if p.On(Hallucinating) {
 		probinc = 3
 	}
+
 	if p.On(Blind) {
 		probinc += 2
 	}
+
 	found := false
+
 	for y := p.Pos.Y - 1; y <= ey; y++ {
 		for x := p.Pos.X - 1; x <= ex; x++ {
 			if y == p.Pos.Y && x == p.Pos.X {
 				continue
 			}
+
 			fp := g.Level.FlagsAt(y, x)
 			if fp.Has(FReal) {
 				continue
 			}
+
 			foundone := false
+
 			switch g.Level.Char(y, x) {
 			case '|', '-':
 				if g.rnd(5+probinc) != 0 {
 					break
 				}
+
 				g.Level.SetChar(y, x, Door)
 				g.msg("a secret door")
+
 				foundone = true
 			case Floor:
 				if g.rnd(2+probinc) != 0 {
 					break
 				}
+
 				g.Level.SetChar(y, x, Trap)
+
 				if !g.Options.Terse {
-					g.addmsg("you found ")
+					g.addmsgf("you found ")
 				}
+
 				if p.On(Hallucinating) {
-					g.msg("%s", trName[g.rnd(NumTrapTypes)])
+					g.msg("%s", g.data.trName[g.rnd(NumTrapTypes)])
 				} else {
-					g.msg("%s", trName[*fp&FTrapMask])
+					g.msg("%s", g.data.trName[*fp&FTrapMask])
 					fp.Set(FSeen)
 				}
+
 				foundone = true
 			case ' ':
 				if g.rnd(3+probinc) != 0 {
 					break
 				}
+
 				g.Level.SetChar(y, x, Passage)
+
 				foundone = true
 			}
+
 			if foundone {
 				found = true
+
 				fp.Set(FReal)
+
 				g.Count = 0
 				g.Running = false
 			}
 		}
 	}
+
 	if found {
 		g.look(false)
 	}
@@ -523,28 +586,35 @@ func (g *RogueGame) help() {
 	// typed a funny character.
 	if helpch != '*' {
 		g.move(0, 0)
-		for _, strp := range helpStr {
+
+		for _, strp := range g.data.helpStr {
 			if strp.Ch == helpch {
 				g.Msgs.LowerMsg = true
 				g.msg("%s%s", unctrl(strp.Ch), strp.Desc)
 				g.Msgs.LowerMsg = false
+
 				return
 			}
 		}
+
 		g.msg("unknown character '%s'", unctrl(helpch))
+
 		return
 	}
 	// Here we print help for everything, then wait before we return to
 	// command mode.
 	numprint := 0
-	for _, strp := range helpStr {
+
+	for _, strp := range g.data.helpStr {
 		if strp.Print {
 			numprint++
 		}
 	}
+
 	if numprint&1 == 1 { // round odd numbers up
 		numprint++
 	}
+
 	numprint /= 2
 	if numprint > NumLines-1 {
 		numprint = NumLines - 1
@@ -552,24 +622,32 @@ func (g *RogueGame) help() {
 
 	hw := g.scr.Hw
 	hw.Clear()
+
 	cnt := 0
-	for _, strp := range helpStr {
+
+	for _, strp := range g.data.helpStr {
 		if !strp.Print {
 			continue
 		}
+
 		x := 0
 		if cnt >= numprint {
 			x = NumCols / 2
 		}
+
 		hw.Move(cnt%numprint, x)
+
 		if strp.Ch != 0 {
 			hw.AddStr(unctrl(strp.Ch))
 		}
+
 		hw.AddStr(strp.Desc)
+
 		if cnt++; cnt >= numprint*2 {
 			break
 		}
 	}
+
 	hw.MvAddStr(NumLines-1, 0, "--Press space to continue--")
 	g.scr.RefreshWin(hw)
 	g.waitFor(' ')
@@ -577,49 +655,33 @@ func (g *RogueGame) help() {
 	g.refresh()
 }
 
-// identList is command.c's static ident_list.
-var identList = []helpEntry{
-	{'|', "wall of a room", false},
-	{'-', "wall of a room", false},
-	{Gold, "gold", false},
-	{Stairs, "a staircase", false},
-	{Door, "door", false},
-	{Floor, "room floor", false},
-	{PlayerCh, "you", false},
-	{Passage, "passage", false},
-	{Trap, "trap", false},
-	{Potion, "potion", false},
-	{Scroll, "scroll", false},
-	{Food, "food", false},
-	{Weapon, "weapon", false},
-	{' ', "solid rock", false},
-	{Armor, "armor", false},
-	{Amulet, "the Amulet of Yendor", false},
-	{Ring, "ring", false},
-	{Stick, "wand or staff", false},
-}
-
 // identify tells the player what a certain thing is (command.c identify).
 func (g *RogueGame) identify() {
 	g.msg("what do you want identified? ")
 	ch := g.readchar()
+
 	g.Msgs.Mpos = 0
 	if ch == Escape {
 		g.msg("")
+
 		return
 	}
+
 	var str string
 	if isUpper(ch) {
 		str = g.Monsters[ch-'A'].Name
 	} else {
 		str = "unknown character"
-		for _, hp := range identList {
+
+		for _, hp := range g.data.identList {
 			if hp.Ch == ch {
 				str = hp.Desc
+
 				break
 			}
 		}
 	}
+
 	g.msg("'%s': %s", unctrl(ch), str)
 }
 
@@ -628,6 +690,7 @@ func (g *RogueGame) dLevel() {
 	if g.levitCheck() {
 		return
 	}
+
 	if g.Level.Char(g.Player.Pos.Y, g.Player.Pos.X) != Stairs {
 		g.msg("I see no way down")
 	} else {
@@ -642,12 +705,14 @@ func (g *RogueGame) uLevel() {
 	if g.levitCheck() {
 		return
 	}
+
 	if g.Level.Char(g.Player.Pos.Y, g.Player.Pos.X) == Stairs {
 		if g.HasAmulet {
 			g.Depth--
 			if g.Depth == 0 {
 				g.totalWinner()
 			}
+
 			g.NewLevel()
 			g.msg("you feel a wrenching sensation in your gut")
 		} else {
@@ -664,23 +729,30 @@ func (g *RogueGame) levitCheck() bool {
 	if !g.Player.On(Levitating) {
 		return false
 	}
+
 	g.msg("You can't.  You're floating off the ground!")
+
 	return true
 }
 
 // call allows a user to call a potion, scroll, or ring something
 // (command.c call).
 func (g *RogueGame) call() {
-	obj := g.getItem("call", KindCallable)
+	obj, ok := g.promptPackItem("call", KindCallable)
 	// Make certain that it is something that we want to name
-	if obj == nil {
+	if !ok {
 		return
 	}
-	var op *ObjInfo
-	var elsewise string
-	var know *bool
-	var guess *string
+
+	var (
+		op       *ObjInfo
+		elsewise string
+		know     *bool
+		guess    *string
+	)
+
 	it := &g.Items
+
 	switch obj.Kind {
 	case KindRing:
 		op = &it.Rings[obj.Which]
@@ -696,14 +768,18 @@ func (g *RogueGame) call() {
 		elsewise = it.WandMade[obj.Which]
 	case KindFood:
 		g.msg("you can't call that anything")
+
 		return
 	default:
 		guess = &obj.Label
 		elsewise = obj.Label
 	}
+
 	fromGuess := false
+
 	if op != nil {
 		know = &op.Know
+
 		guess = &op.Guess
 		if *guess != "" {
 			elsewise = *guess
@@ -712,16 +788,21 @@ func (g *RogueGame) call() {
 	} else {
 		fromGuess = elsewise != "" && elsewise == *guess
 	}
+
 	if know != nil && *know {
 		g.msg("that has already been identified")
+
 		return
 	}
+
 	if fromGuess {
 		if !g.Options.Terse {
-			g.addmsg("Was ")
+			g.addmsgf("Was ")
 		}
+
 		g.msg("called \"%s\"", elsewise)
 	}
+
 	g.msg("%s", g.chooseTerse("call it: ", "what do you want to call it? "))
 
 	buf := elsewise
@@ -735,23 +816,29 @@ func (g *RogueGame) current(cur *Object, how, where string) {
 	g.After = false
 	if cur != nil {
 		if !g.Options.Terse {
-			g.addmsg("you are %s (", how)
+			g.addmsgf("you are %s (", how)
 		}
+
 		g.InvDescribe = false
-		g.addmsg("%c) %s", cur.PackCh, g.invName(cur, true))
+		g.addmsgf("%c) %s", cur.PackCh, g.inventoryName(cur, true))
+
 		g.InvDescribe = true
 		if where != "" {
-			g.addmsg(" %s", where)
+			g.addmsgf(" %s", where)
 		}
+
 		g.endmsg()
 	} else {
 		if !g.Options.Terse {
-			g.addmsg("you are ")
+			g.addmsgf("you are ")
 		}
-		g.addmsg("%s nothing", how)
+
+		g.addmsgf("%s nothing", how)
+
 		if where != "" {
-			g.addmsg(" %s", where)
+			g.addmsgf(" %s", where)
 		}
+
 		g.endmsg()
 	}
 }
@@ -762,7 +849,9 @@ func (g *RogueGame) shell() {
 	g.After = false
 	if se, ok := g.scr.term.(interface{ ShellEscape() }); ok {
 		g.InShell = true
+
 		se.ShellEscape()
+
 		g.InShell = false
 		g.refresh()
 	} else {

game/creature.go

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

game/daemon.go

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

game/daemons.go

@@ -45,6 +45,7 @@ func (g *RogueGame) doctor(int) {
 	p := &g.Player
 	lv := p.Stats.Lvl
 	ohp := p.Stats.HP
+
 	g.Quiet++
 	if lv < 8 {
 		if g.Quiet+(lv<<1) > 20 {
@@ -53,16 +54,20 @@ func (g *RogueGame) doctor(int) {
 	} else if g.Quiet >= 3 {
 		p.Stats.HP += g.rnd(lv-7) + 1
 	}
+
 	if p.IsRing(Left, RingRegeneration) {
 		p.Stats.HP++
 	}
+
 	if p.IsRing(Right, RingRegeneration) {
 		p.Stats.HP++
 	}
+
 	if ohp != p.Stats.HP {
 		if p.Stats.HP > p.Stats.MaxHP {
 			p.Stats.HP = p.Stats.MaxHP
 		}
+
 		g.Quiet = 0
 	}
 }
@@ -82,6 +87,7 @@ func (g *RogueGame) rollwand(int) {
 			g.KillDaemon(DRollwand)
 			g.Fuse(DSwander, 0, wanderTime(g), Before)
 		}
+
 		g.Daemons.Between = 0
 	}
 }
@@ -103,6 +109,7 @@ func (g *RogueGame) unsee(int) {
 			g.mvaddch(th.Pos.Y, th.Pos.X, th.OldCh)
 		}
 	}
+
 	g.Player.Flags.Clear(CanSeeInvisible)
 }
 
@@ -112,9 +119,11 @@ func (g *RogueGame) sight(int) {
 	if p.On(Blind) {
 		g.Extinguish(DSight)
 		p.Flags.Clear(Blind)
+
 		if !p.Room.Flags.Has(Gone) {
 			g.enterRoom(p.Pos)
 		}
+
 		g.msg("%s", g.chooseStr("far out!  Everything is all cosmic again",
 			"the veil of darkness lifts"))
 	}
@@ -129,6 +138,7 @@ func (g *RogueGame) nohaste(int) {
 // stomach digests the hero's food (daemons.c stomach).
 func (g *RogueGame) stomach(int) {
 	p := &g.Player
+
 	origHungry := p.HungryState
 	if p.FoodLeft <= 0 {
 		if p.FoodLeft--; p.FoodLeft < -StarveTime {
@@ -138,29 +148,36 @@ func (g *RogueGame) stomach(int) {
 		if g.NoCommand != 0 || g.rnd(5) != 0 {
 			return
 		}
+
 		g.NoCommand += g.rnd(8) + 4
 		p.HungryState = 3
+
 		if !g.Options.Terse {
-			g.addmsg("%s", g.chooseStr(
+			g.addmsgf("%s", g.chooseStr(
 				"the munchies overpower your motor capabilities.  ",
 				"you feel too weak from lack of food.  "))
 		}
+
 		g.msg("%s", g.chooseStr("You freak out", "You faint"))
 	} else {
 		oldfood := p.FoodLeft
+
 		amulet := 0
 		if g.HasAmulet {
 			amulet = 1
 		}
+
 		p.FoodLeft -= g.ringEat(Left) + g.ringEat(Right) + 1 - amulet
 
 		if p.FoodLeft < MoreTime && oldfood >= MoreTime {
 			p.HungryState = 2
+
 			g.msg("%s", g.chooseStr(
-				"the munchies are interfering with your motor capabilites",
+				"the munchies are interfering with your motor capabilities",
 				"you are starting to feel weak"))
 		} else if p.FoodLeft < 2*MoreTime && oldfood >= 2*MoreTime {
 			p.HungryState = 1
+
 			if g.Options.Terse {
 				g.msg("%s", g.chooseStr("getting the munchies", "getting hungry"))
 			} else {
@@ -169,8 +186,10 @@ func (g *RogueGame) stomach(int) {
 			}
 		}
 	}
+
 	if p.HungryState != origHungry {
 		p.Flags.Clear(Awake)
+
 		g.Running = false
 		g.ToDeath = false
 		g.Count = 0
@@ -193,16 +212,18 @@ func (g *RogueGame) comeDown(int) {
 
 	// undo the things
 	for _, tp := range g.Level.Objects {
-		if g.cansee(tp.Pos.Y, tp.Pos.X) {
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
 			g.mvaddch(tp.Pos.Y, tp.Pos.X, tp.Kind.Glyph())
 		}
 	}
 
 	// undo the monsters
 	seemonst := p.On(SenseMonsters)
+
 	for _, tp := range g.Level.Monsters {
 		g.move(tp.Pos.Y, tp.Pos.X)
-		if g.cansee(tp.Pos.Y, tp.Pos.X) {
+
+		if g.canSee(tp.Pos.Y, tp.Pos.X) {
 			if !tp.On(Invisible) || p.On(CanSeeInvisible) {
 				g.addch(tp.Disguise)
 			} else {
@@ -214,6 +235,7 @@ func (g *RogueGame) comeDown(int) {
 			g.standend()
 		}
 	}
+
 	g.msg("Everything looks SO boring now.")
 }
 
@@ -226,29 +248,31 @@ func (g *RogueGame) visuals(int) {
 	}
 	// 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)
+
 	for _, tp := range g.Level.Monsters {
 		g.move(tp.Pos.Y, tp.Pos.X)
+
 		if g.seeMonst(tp) {
 			if tp.Type == 'X' && tp.Disguise != 'X' {
 				g.addch(g.rndThing())
 			} else {
-				g.addch(byte(g.rnd(26) + 'A'))
+				g.addch(g.randomMonsterLetter())
 			}
 		} else if seemonst {
 			g.standout()
-			g.addch(byte(g.rnd(26) + 'A'))
+			g.addch(g.randomMonsterLetter())
 			g.standend()
 		}
 	}

game/dice.go

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

game/dice_test.go

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

game/effects_test.go

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

game/fight.go

@@ -4,43 +4,6 @@ import "strconv"
 
 // fight.c — all the fighting gets done here.
 
-// hNames are the strings for hitting; the first four are used when the
-// player strikes, the second four for monsters (fight.c h_names).
-var hNames = [8]string{
-	" scored an excellent hit on ",
-	" hit ",
-	" have injured ",
-	" swing and hit ",
-	" scored an excellent hit on ",
-	" hit ",
-	" has injured ",
-	" swings and hits ",
-}
-
-// mNames are the strings for missing (fight.c m_names).
-var mNames = [8]string{
-	" miss",
-	" swing and miss",
-	" barely miss",
-	" don't hit",
-	" misses",
-	" swings and misses",
-	" barely misses",
-	" doesn't hit",
-}
-
-// strPlus adjusts hit probabilities due to strength (fight.c str_plus).
-var strPlus = [32]int{
-	-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
-	1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
-}
-
-// addDam adjusts damage done due to strength (fight.c add_dam).
-var addDam = [32]int{
-	-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3,
-	3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6,
-}
-
 // setMname returns the monster name for the given monster (fight.c
 // set_mname).
 func (g *RogueGame) setMname(tp *Monster) string {
@@ -48,20 +11,27 @@ func (g *RogueGame) setMname(tp *Monster) string {
 		if g.Options.Terse {
 			return "it"
 		}
+
 		return "something"
 	}
+
 	var mname string
+
 	if g.Player.On(Hallucinating) {
-		ch := int(g.mvinch(tp.Pos.Y, tp.Pos.X))
-		if !isUpper(byte(ch)) {
-			ch = g.rnd(26)
+		var idx int
+
+		ch := g.mvinch(tp.Pos.Y, tp.Pos.X)
+		if isUpper(ch) {
+			idx = int(ch - 'A')
 		} else {
-			ch -= 'A'
+			idx = g.rnd(26)
 		}
-		mname = g.Monsters[ch].Name
+
+		mname = g.Monsters[idx].Name
 	} else {
 		mname = g.Monsters[tp.Type-'A'].Name
 	}
+
 	return "the " + mname
 }
 
@@ -77,42 +47,51 @@ 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, byte(g.rnd(26)+'A'))
+			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!"))
+
 		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
+
 		if thrown {
 			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 {
@@ -121,40 +100,47 @@ func (g *RogueGame) fight(mp Coord, weap *Object, thrown bool) bool {
 			g.miss("", mname, g.Options.Terse)
 		}
 	}
+
 	return didHit
 }
 
-// attack has the monster attack the player (fight.c attack). Returns -1 if
-// the monster removed itself from the level during its own attack.
-func (g *RogueGame) attack(mp *Monster) int {
+// attack has the monster attack the player (fight.c attack). removed
+// reports that the monster took itself off the level during its own
+// attack (the C -1 return).
+func (g *RogueGame) attack(mp *Monster) (removed bool) {
 	p := &g.Player
 	// Since this is an attack, stop running and any healing that was
 	// going on at the time.
 	g.Running = false
 	g.Count = 0
+
 	g.Quiet = 0
 	if g.ToDeath && !mp.On(Targeted) {
 		g.ToDeath = false
 		g.Kamikaze = false
 	}
+
 	if mp.Type == 'X' && mp.Disguise != 'X' && !p.On(Blind) {
 		mp.Disguise = 'X'
 		if p.On(Hallucinating) {
-			g.mvaddch(mp.Pos.Y, mp.Pos.X, byte(g.rnd(26)+'A'))
+			g.mvaddch(mp.Pos.Y, mp.Pos.X, g.randomMonsterLetter())
 		}
 	}
+
 	mname := g.setMname(mp)
 	oldhp := p.Stats.HP
-	removed := false
-	if g.rollEm(&mp.Creature, &p.Creature, nil, false) {
+
+	if g.rollAttacks(&mp.Creature, &p.Creature, nil, false) {
 		if mp.Type != 'I' {
 			if g.HasHit {
-				g.addmsg(".  ")
+				g.addmsgf(".  ")
 			}
+
 			g.hit(mname, "", false)
 		} else if g.HasHit {
 			g.endmsg()
 		}
+
 		g.HasHit = false
 		if p.Stats.HP <= 0 {
 			g.death(mp.Type) // Bye bye life ...
@@ -163,10 +149,12 @@ func (g *RogueGame) attack(mp *Monster) int {
 			if oldhp > g.MaxHit {
 				g.MaxHit = oldhp
 			}
+
 			if p.Stats.HP <= g.MaxHit {
 				g.ToDeath = false
 			}
 		}
+
 		if !mp.On(Cancelled) {
 			switch mp.Type {
 			case 'A':
@@ -175,13 +163,17 @@ func (g *RogueGame) attack(mp *Monster) int {
 			case 'I':
 				// The ice monster freezes you
 				p.Flags.Clear(Awake)
+
 				if g.NoCommand == 0 {
-					g.addmsg("you are frozen")
+					g.addmsgf("you are frozen")
+
 					if !g.Options.Terse {
-						g.addmsg(" by the %s", mname)
+						g.addmsgf(" by the %s", mname)
 					}
+
 					g.endmsg()
 				}
+
 				g.NoCommand += g.rnd(2) + 2
 				if g.NoCommand > BoreLevel {
 					g.death('h')
@@ -190,7 +182,8 @@ func (g *RogueGame) attack(mp *Monster) int {
 				// Rattlesnakes have poisonous bites
 				if !g.save(VsPoison) {
 					if !p.IsWearing(RingSustainStrength) {
-						g.chgStr(-1)
+						g.changeStrength(-1)
+
 						if !g.Options.Terse {
 							g.msg("you feel a bite in your leg and now feel weaker")
 						} else {
@@ -211,36 +204,45 @@ func (g *RogueGame) attack(mp *Monster) int {
 				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
+							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")
 				}
 			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')
@@ -248,15 +250,20 @@ func (g *RogueGame) attack(mp *Monster) int {
 			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")
 				}
@@ -264,66 +271,79 @@ func (g *RogueGame) attack(mp *Monster) int {
 				// 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() {
+						g.isMagic(obj) {
 						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))
+					g.msg("she stole %s!", g.inventoryName(steal, true))
 				}
 			}
 		}
 	} else if mp.Type != 'I' {
 		if g.HasHit {
-			g.addmsg(".  ")
+			g.addmsgf(".  ")
 			g.HasHit = false
 		}
+
 		if mp.Type == 'F' {
 			p.Stats.HP -= p.VfHit
 			if p.Stats.HP <= 0 {
 				g.death(mp.Type) // Bye bye life ...
 			}
 		}
+
 		g.miss(mname, "", false)
 	}
+
 	if g.Options.FightFlush && !g.ToDeath {
 		g.flushType()
 	}
+
 	g.Count = 0
 	g.status()
-	if removed {
-		return -1
-	}
-	return 0
+
+	return removed
 }
 
 // swing returns true if the swing hits (fight.c swing).
 func (g *RogueGame) swing(atLvl, opArm, wplus int) bool {
 	res := g.rnd(20)
 	need := (20 - atLvl) - opArm
+
 	return res+wplus >= need
 }
 
-// rollEm rolls several attacks (fight.c roll_em).
-func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool {
+// rollAttacks rolls several attacks (fight.c roll_em).
+func (g *RogueGame) rollAttacks(thatt, thdef *Creature, weap *Object, hurl bool) bool {
 	p := &g.Player
 	att := &thatt.Stats
 	def := &thdef.Stats
-	var attacks DiceSpec
-	var hplus, dplus int
+
+	var (
+		attacks      DiceSpec
+		hplus, dplus int
+	)
+
 	if weap == nil {
 		attacks = att.Dmg
 	} else {
 		hplus = weap.HPlus
+
 		dplus = weap.DPlus
 		if weap == p.CurWeapon {
 			if p.IsRing(Left, RingIncreaseDamage) {
@@ -331,12 +351,14 @@ func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool
 			} 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 &&
@@ -354,29 +376,37 @@ func (g *RogueGame) rollEm(thatt, thdef *Creature, weap *Object, hurl bool) bool
 	if !thdef.Flags.Has(Awake) {
 		hplus += 4
 	}
+
 	defArm := def.ArmorClass
 	if def == &p.Stats {
 		if p.CurArmor != nil {
 			defArm = p.CurArmor.ArmorClass
 		}
+
 		if p.IsRing(Left, RingProtection) {
 			defArm -= p.CurRing[Left].Bonus
 		}
+
 		if p.IsRing(Right, RingProtection) {
 			defArm -= p.CurRing[Right].Bonus
 		}
 	}
+
 	didHit := false
+
 	for _, atk := range attacks {
-		if g.swing(att.Lvl, defArm, hplus+strPlus[att.Str]) {
+		if g.swing(att.Lvl, defArm, hplus+g.data.strPlus[att.Str]) {
 			proll := g.roll(atk.Count, atk.Sides)
-			damage := dplus + proll + addDam[att.Str]
+
+			damage := dplus + proll + g.data.addDam[att.Str]
 			if damage > 0 {
 				def.HP -= damage
 			}
+
 			didHit = true
 		}
 	}
+
 	return didHit
 }
 
@@ -387,7 +417,9 @@ func cAtoi(s string) int {
 	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
 		i++
 	}
+
 	n, _ := strconv.Atoi(s[:i])
+
 	return n
 }
 
@@ -398,9 +430,11 @@ func prname(mname string, upper bool) string {
 	if out == "" {
 		out = "you"
 	}
+
 	if upper {
 		out = string(toUpper(out[0])) + out[1:]
 	}
+
 	return out
 }
 
@@ -409,12 +443,15 @@ func (g *RogueGame) thunk(weap *Object, mname string, noend bool) {
 	if g.ToDeath {
 		return
 	}
+
 	if weap.Kind == KindWeapon {
-		g.addmsg("the %s hits ", g.Items.Weapons[weap.Which].Name)
+		g.addmsgf("the %s hits ", g.Items.Weapons[weap.Which].Name)
 	} else {
-		g.addmsg("you hit ")
+		g.addmsgf("you hit ")
 	}
-	g.addmsg("%s", mname)
+
+	g.addmsgf("%s", mname)
+
 	if !noend {
 		g.endmsg()
 	}
@@ -425,7 +462,9 @@ func (g *RogueGame) hit(er, ee string, noend bool) {
 	if g.ToDeath {
 		return
 	}
-	g.addmsg("%s", prname(er, true))
+
+	g.addmsgf("%s", prname(er, true))
+
 	var s string
 	if g.Options.Terse {
 		s = " hit"
@@ -434,12 +473,16 @@ func (g *RogueGame) hit(er, ee string, noend bool) {
 		if er != "" {
 			i += 4
 		}
-		s = hNames[i]
+
+		s = g.data.hNames[i]
 	}
-	g.addmsg("%s", s)
+
+	g.addmsgf("%s", s)
+
 	if !g.Options.Terse {
-		g.addmsg("%s", prname(ee, false))
+		g.addmsgf("%s", prname(ee, false))
 	}
+
 	if !noend {
 		g.endmsg()
 	}
@@ -450,18 +493,24 @@ func (g *RogueGame) miss(er, ee string, noend bool) {
 	if g.ToDeath {
 		return
 	}
-	g.addmsg("%s", prname(er, true))
+
+	g.addmsgf("%s", prname(er, true))
+
 	i := 0
 	if !g.Options.Terse {
 		i = g.rnd(4)
 	}
+
 	if er != "" {
 		i += 4
 	}
-	g.addmsg("%s", mNames[i])
+
+	g.addmsgf("%s", g.data.mNames[i])
+
 	if !g.Options.Terse {
-		g.addmsg(" %s", prname(ee, false))
+		g.addmsgf(" %s", prname(ee, false))
 	}
+
 	if !noend {
 		g.endmsg()
 	}
@@ -472,12 +521,15 @@ func (g *RogueGame) bounce(weap *Object, mname string, noend bool) {
 	if g.ToDeath {
 		return
 	}
+
 	if weap.Kind == KindWeapon {
-		g.addmsg("the %s misses ", g.Items.Weapons[weap.Which].Name)
+		g.addmsgf("the %s misses ", g.Items.Weapons[weap.Which].Name)
 	} else {
-		g.addmsg("you missed ")
+		g.addmsgf("you missed ")
 	}
-	g.addmsg("%s", mname)
+
+	g.addmsgf("%s", mname)
+
 	if !noend {
 		g.endmsg()
 	}
@@ -489,15 +541,19 @@ func (g *RogueGame) removeMon(mp Coord, tp *Monster, waskill bool) {
 	for _, obj := range pack {
 		obj.Pos = tp.Pos
 		detachObj(&tp.Pack, obj)
+
 		if waskill {
 			g.fall(obj, false)
 		}
 	}
+
 	g.Level.SetMonsterAt(mp.Y, mp.X, nil)
 	g.mvaddch(mp.Y, mp.X, tp.OldCh)
-	detachMon(&g.Level.Monsters, tp)
+	g.Level.RemoveMonster(tp)
+
 	if tp.On(Targeted) {
 		g.Kamikaze = false
+
 		g.ToDeath = false
 		if g.Options.FightFlush {
 			g.flushType()
@@ -521,33 +577,40 @@ func (g *RogueGame) killed(tp *Monster, pr bool) {
 		if ok {
 			tp.Room.Gold = pos
 		}
+
 		if ok && g.Depth >= g.MaxDepth {
 			gold := newObject()
 			gold.Kind = KindGold
+
 			gold.GoldValue = g.goldCalc()
 			if g.save(VsMagic) {
 				gold.GoldValue += g.goldCalc() + g.goldCalc() + g.goldCalc() + g.goldCalc()
 			}
+
 			attachObj(&tp.Pack, gold)
 		}
 	}
 	// Get rid of the monster.
 	mname := g.setMname(tp)
 	g.removeMon(tp.Pos, tp, true)
+
 	if pr {
 		if g.HasHit {
-			g.addmsg(".  Defeated ")
+			g.addmsgf(".  Defeated ")
 			g.HasHit = false
 		} else {
 			if !g.Options.Terse {
-				g.addmsg("you have ")
+				g.addmsgf("you have ")
 			}
-			g.addmsg("defeated ")
+
+			g.addmsgf("defeated ")
 		}
+
 		g.msg("%s", mname)
 	}
 	// Do adjustments if he went up a level
 	g.checkLevel()
+
 	if g.Options.FightFlush {
 		g.flushType()
 	}

game/fight_test.go

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

game/game.go

@@ -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,6 +138,9 @@ 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
@@ -145,6 +148,7 @@ type RogueGame struct {
 // and first level arrive with later porting phases).
 func NewGame(cfg Config) *RogueGame {
 	g := &RogueGame{
+		data:      newGameData(),
 		Rng:       &Rng{Seed: cfg.Seed},
 		Dnum:      int(cfg.Seed),
 		Whoami:    cfg.Name,
@@ -165,16 +169,20 @@ func NewGame(cfg Config) *RogueGame {
 	g.InvDescribe = true
 	g.Msgs.SaveMsg = true
 	g.scr = NewScreen(cfg.Term)
+	g.Msgs.attach(g.scr, g.look, g.readchar)
 	g.FileName = cfg.Home + "/rogue.save"
+
 	g.rogueOpts = cfg.RogueOpts
 	if cfg.Wizard {
 		g.Player.Flags.Set(SenseMonsters)
 	}
+
 	if cfg.RogueOpts != "" {
 		g.ParseOpts(cfg.RogueOpts)
 	}
 
-	g.Monsters = monsterTable
+	g.Monsters = g.data.monsterTable
+
 	g.Items.Group = 2 // weapons.c: int group = 2
 	for i := range g.Level.Passages {
 		g.Level.Passages[i].Flags = Gone | Dark
@@ -186,20 +194,26 @@ func NewGame(cfg Config) *RogueGame {
 	g.initColors()    // set up colors of potions
 	g.initStones()    // set up stone settings of rings
 	g.initMaterials() // set up materials of wands
+
 	return g
 }
 
 // Run plays the game to its end: the back half of main.c main() plus
 // playit(). It returns after death, victory, quitting, or saving.
-func (g *RogueGame) Run() (err error) {
+func (g *RogueGame) Run() error {
+	// A gameEnd panic is the port's my_exit(): recovering it here makes
+	// Run return normally (zero values), restoring the terminal via the
+	// caller's defers.
 	defer func() {
 		if r := recover(); r != nil {
 			if _, ok := r.(gameEnd); ok {
 				return // normal game over / save exit
 			}
+
 			panic(r)
 		}
 	}()
+
 	if !g.restored {
 		g.NewLevel() // draw current level
 		// Start up daemons and fuses
@@ -208,7 +222,9 @@ func (g *RogueGame) Run() (err error) {
 		g.Fuse(DSwander, 0, wanderTime(g), After)
 		g.StartDaemon(DStomach, 0, After)
 	}
+
 	g.playit()
+
 	return nil
 }
 
@@ -226,10 +242,12 @@ 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()
 }
 
@@ -242,7 +260,7 @@ func (g *RogueGame) endit() {
 func (g *RogueGame) fatal(s string) {
 	g.mvaddstr(NumLines-2, 0, s)
 	g.refresh()
-	g.myExit(0)
+	g.myExit()
 }
 
 // quit has the player make certain, then exits (main.c quit). The final
@@ -252,17 +270,21 @@ func (g *RogueGame) quit(int) {
 	if !g.QComm {
 		g.Msgs.Mpos = 0
 	}
+
 	oy, ox := g.scr.Std.GetYX()
 	g.msg("really quit?")
+
 	if g.readchar() == 'y' {
 		g.clear()
-		g.scr.Std.MvPrintw(NumLines-2, 0, "You quit with %d gold pieces", g.Player.Purse)
+		g.scr.Std.MvPrintwf(NumLines-2, 0, "You quit with %d gold pieces", g.Player.Purse)
 		g.move(NumLines-1, 0)
 		g.refresh()
 		g.score(g.Player.Purse, 1, 0)
-		g.myExit(0)
+		g.myExit()
+
 		return
 	}
+
 	g.move(0, 0)
 	g.clrtoeol()
 	g.status()

game/init.go

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

game/io.go

@@ -10,9 +10,11 @@ import (
 // maxMsg is io.c MAXMSG: how much message fits before --More--.
 const maxMsg = NumCols - len("--More--") - 1
 
-// MsgLine is the io.c message machinery: the static msgbuf/newpos pair plus
-// the related globals (mpos, huh, and the message-behavior flags).
-type MsgLine struct {
+// MessageLine is the io.c message machinery: the static msgbuf/newpos
+// pair plus the related globals (mpos, huh, and the message-behavior
+// 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,52 +22,61 @@ 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
-// convention: callers compare against ESCAPE).
-func (g *RogueGame) msg(format string, a ...any) int {
+// Escape if the player escaped out of a --More--, ^Escape otherwise (the
+// C convention: callers compare against ESCAPE).
+func (m *MessageLine) Msg(format string, a ...any) int {
 	// if the string is "", just clear the line
 	if format == "" {
-		g.move(0, 0)
-		g.clrtoeol()
-		g.Msgs.Mpos = 0
+		m.scr.Std.Move(0, 0)
+		m.scr.Std.Clrtoeol()
+		m.Mpos = 0
+
 		return ^Escape
 	}
 	// otherwise add to the message and flush it out
-	g.doadd(format, a...)
-	return g.endmsg()
+	m.doaddf(format, a...)
+
+	return m.End()
 }
 
-// addmsg adds things to the current message (io.c addmsg).
-func (g *RogueGame) addmsg(format string, a ...any) {
-	g.doadd(format, a...)
+// Addf adds things to the current message (io.c addmsg).
+func (m *MessageLine) Addf(format string, a ...any) {
+	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 {
-	m := &g.Msgs
+func (m *MessageLine) End() int {
 	if m.SaveMsg {
 		m.Huh = m.buf.String()
 	}
+
 	if m.Mpos != 0 {
-		g.look(false)
-		g.mvaddstr(0, m.Mpos, "--More--")
-		g.refresh()
+		m.look(false)
+		m.scr.Std.MvAddStr(0, m.Mpos, "--More--")
+		m.scr.Refresh()
+
 		if !m.MsgEsc {
-			g.waitFor(' ')
+			m.waitForSpace()
 		} else {
 			for {
-				ch := g.readchar()
+				ch := m.readChar()
 				if ch == ' ' {
 					break
 				}
+
 				if ch == Escape {
 					m.buf.Reset()
 					m.Mpos = 0
 					m.newpos = 0
+
 					return Escape
 				}
 			}
@@ -75,29 +86,64 @@ func (g *RogueGame) endmsg() int {
 	// with a pack addressing character
 	out := m.buf.String()
 	if len(out) > 0 && isLower(out[0]) && !m.LowerMsg &&
-		!(len(out) > 1 && out[1] == ')') {
+		(len(out) <= 1 || out[1] != ')') {
 		out = string(toUpper(out[0])) + out[1:]
 	}
-	g.mvaddstr(0, 0, out)
-	g.clrtoeol()
+
+	m.scr.Std.MvAddStr(0, 0, out)
+	m.scr.Std.Clrtoeol()
+
 	m.Mpos = m.newpos
 	m.newpos = 0
 	m.buf.Reset()
-	g.refresh()
+	m.scr.Refresh()
+
 	return ^Escape
 }
 
-// doadd performs an add onto the message buffer (io.c doadd).
-func (g *RogueGame) doadd(format string, a ...any) {
-	m := &g.Msgs
+// attach wires the message line to its display and input; NewGame and
+// Restore call it once the screen and game exist.
+func (m *MessageLine) attach(scr *Screen, look func(bool), readChar func() byte) {
+	m.scr = scr
+	m.look = look
+	m.readChar = readChar
+}
+
+// waitForSpace absorbs input until the player types a space: the
+// --More-- acknowledgement (io.c wait_for).
+func (m *MessageLine) waitForSpace() {
+	for {
+		if m.readChar() == ' ' {
+			return
+		}
+	}
+}
+
+// doaddf performs an add onto the message buffer (io.c doadd).
+func (m *MessageLine) doaddf(format string, a ...any) {
 	s := fmt.Sprintf(format, a...)
 	if len(s)+m.newpos >= maxMsg {
-		g.endmsg()
+		m.End()
 	}
+
 	m.buf.WriteString(s)
 	m.newpos = m.buf.Len()
 }
 
+// msg, addmsgf, and endmsg are the game-side shorthands for the message
+// line; the machinery lives on MessageLine.
+func (g *RogueGame) msg(format string, a ...any) int {
+	return g.Msgs.Msg(format, a...)
+}
+
+func (g *RogueGame) addmsgf(format string, a ...any) {
+	g.Msgs.Addf(format, a...)
+}
+
+func (g *RogueGame) endmsg() {
+	g.Msgs.End()
+}
+
 // stepOk returns true if it is ok to step on ch (io.c step_ok).
 func stepOk(ch byte) bool {
 	switch ch {
@@ -114,8 +160,10 @@ func (g *RogueGame) readchar() byte {
 	ch := g.scr.term.ReadChar()
 	if ch == 3 { // ^C
 		g.quit(0)
+
 		return 27
 	}
+
 	return ch
 }
 
@@ -133,8 +181,6 @@ type statusCache struct {
 	init    bool
 }
 
-var hungerStateName = [...]string{"", "Hungry", "Weak", "Faint"}
-
 // status displays the important stats line, keeping the cursor where it was
 // (io.c status).
 func (g *RogueGame) status() {
@@ -146,17 +192,21 @@ func (g *RogueGame) status() {
 	if p.CurArmor != nil {
 		temp = p.CurArmor.ArmorClass
 	}
+
 	if s.init && s.hp == p.Stats.HP && s.exp == p.Stats.Exp &&
 		s.pur == p.Purse && s.arm == temp && s.str == p.Stats.Str &&
 		s.lvl == g.Depth && s.hungry == p.HungryState && !g.StatMsg {
 		return
 	}
+
 	s.init = true
 	s.arm = temp
 
 	oy, ox := g.scr.Std.GetYX()
+
 	if s.hp != p.Stats.MaxHP {
 		s.hp = p.Stats.MaxHP
+
 		s.hpwidth = 0
 		for t := p.Stats.MaxHP; t != 0; t /= 10 {
 			s.hpwidth++
@@ -175,7 +225,7 @@ func (g *RogueGame) status() {
 		"Level: %d  Gold: %-5d  Hp: %*d(%*d)  Str: %2d(%d)  Arm: %-2d  Exp: %d/%d  %s",
 		g.Depth, p.Purse, s.hpwidth, p.Stats.HP, s.hpwidth, p.Stats.MaxHP,
 		p.Stats.Str, p.MaxStats.Str, 10-s.arm, p.Stats.Lvl, p.Stats.Exp,
-		hungerStateName[p.HungryState])
+		g.data.hungerStateName[p.HungryState])
 	if g.StatMsg {
 		g.move(0, 0)
 		g.msg("%s", line)
@@ -183,6 +233,7 @@ func (g *RogueGame) status() {
 		g.move(StatLine, 0)
 		g.addstr(line)
 	}
+
 	g.clrtoeol()
 	g.move(oy, ox)
 }
@@ -197,7 +248,11 @@ func (g *RogueGame) waitFor(ch byte) {
 			}
 		}
 	}
-	for g.readchar() != ch {
+
+	for {
+		if g.readchar() == ch {
+			return
+		}
 	}
 }
 
@@ -221,11 +276,13 @@ func toUpper(c byte) byte {
 	if isLower(c) {
 		return c - 'a' + 'A'
 	}
+
 	return c
 }
 func toLower(c byte) byte {
 	if isUpper(c) {
 		return c - 'A' + 'a'
 	}
+
 	return c
 }

game/level.go

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

game/misc.go

@@ -10,20 +10,24 @@ func (g *RogueGame) look(wakeup bool) {
 	hero := p.Pos
 	passcount := 0
 	rp := p.Room
+
 	if g.Oldpos != hero {
 		g.eraseLamp(g.Oldpos, g.Oldrp)
 		g.Oldpos = hero
 		g.Oldrp = rp
 	}
+
 	ey := hero.Y + 1
 	ex := hero.X + 1
 	sx := hero.X - 1
 	sy := hero.Y - 1
+
 	sumhero, diffhero := 0, 0
 	if g.DoorStop && !g.Firstmove && g.Running {
 		sumhero = hero.Y + hero.X
 		diffhero = hero.Y - hero.X
 	}
+
 	pp := g.Level.At(hero.Y, hero.X)
 	pch := pp.Ch
 	pfl := pp.Flags
@@ -32,10 +36,12 @@ func (g *RogueGame) look(wakeup bool) {
 		if y <= 0 || y >= NumLines-1 {
 			continue
 		}
+
 		for x := sx; x <= ex; x++ {
 			if x < 0 || x >= NumCols {
 				continue
 			}
+
 			if !p.On(Blind) {
 				if y == hero.Y && x == hero.X {
 					continue
@@ -43,16 +49,19 @@ func (g *RogueGame) look(wakeup bool) {
 			}
 
 			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)) {
@@ -61,25 +70,30 @@ func (g *RogueGame) look(wakeup bool) {
 			}
 
 			tp := pp.Monst
-			if tp == nil {
+
+			switch {
+			case tp == nil:
 				ch = g.tripCh(y, x, ch)
-			} else if p.On(SenseMonsters) && tp.On(Invisible) {
+			case p.On(SenseMonsters) && tp.On(Invisible):
 				if g.DoorStop && !g.Firstmove {
 					g.Running = false
 				}
+
 				continue
-			} else {
+			default:
 				if wakeup {
 					g.wakeMonster(y, x)
 				}
+
 				if g.seeMonst(tp) {
 					if p.On(Hallucinating) {
-						ch = byte(g.rnd(26) + 'A')
+						ch = g.randomMonsterLetter()
 					} else {
 						ch = tp.Disguise
 					}
 				}
 			}
+
 			if p.On(Blind) && (y != hero.Y || x != hero.X) {
 				continue
 			}
@@ -129,6 +143,7 @@ func (g *RogueGame) look(wakeup bool) {
 						continue
 					}
 				}
+
 				switch ch {
 				case Door:
 					if x == hero.X || y == hero.Y {
@@ -145,9 +160,11 @@ func (g *RogueGame) look(wakeup bool) {
 			}
 		}
 	}
+
 	if g.DoorStop && !g.Firstmove && passcount > 1 {
 		g.Running = false
 	}
+
 	if !g.Running || !g.Options.Jump {
 		g.mvaddch(hero.Y, hero.X, PlayerCh)
 	}
@@ -165,26 +182,30 @@ func (g *RogueGame) tripCh(y, x int, ch byte) byte {
 			}
 		}
 	}
+
 	return ch
 }
 
 // eraseLamp erases the area shown by a lamp in a dark room
 // (misc.c erase_lamp).
 func (g *RogueGame) eraseLamp(pos Coord, rp *Room) {
-	if !(g.Options.SeeFloor && rp.Flags&(Gone|Dark) == Dark &&
-		!g.Player.On(Blind)) {
+	if !g.Options.SeeFloor || rp.Flags&(Gone|Dark) != Dark ||
+		g.Player.On(Blind) {
 		return
 	}
 
 	ey := pos.Y + 1
 	ex := pos.X + 1
+
 	sy := pos.Y - 1
 	for x := pos.X - 1; x <= ex; x++ {
 		for y := sy; y <= ey; y++ {
 			if y == g.Player.Pos.Y && x == g.Player.Pos.X {
 				continue
 			}
+
 			g.move(y, x)
+
 			if g.inch() == Floor {
 				g.addch(' ')
 			}
@@ -198,53 +219,53 @@ func (g *RogueGame) showFloor() bool {
 	if g.Player.Room.Flags&(Gone|Dark) == Dark && !g.Player.On(Blind) {
 		return g.Options.SeeFloor
 	}
-	return true
-}
 
-// findObj finds the unclaimed object at (y, x) (misc.c find_obj).
-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
+	return true
 }
 
 // eat lets her try to eat something (misc.c eat).
 func (g *RogueGame) eat() {
-	obj := g.getItem("eat", KindFood)
-	if obj == nil {
+	obj, ok := g.promptPackItem("eat", KindFood)
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindFood {
 		if !g.Options.Terse {
 			g.msg("ugh, you would get ill if you ate that")
 		} else {
 			g.msg("that's Inedible!")
 		}
+
 		return
 	}
+
 	p := &g.Player
 	if p.FoodLeft < 0 {
 		p.FoodLeft = 0
 	}
+
 	if p.FoodLeft += HungerTime - 200 + g.rnd(400); p.FoodLeft > StomachSize {
 		p.FoodLeft = StomachSize
 	}
+
 	p.HungryState = 0
 	if obj == p.CurWeapon {
 		p.CurWeapon = nil
 	}
-	if obj.Which == 1 {
+
+	switch {
+	case obj.Which == 1:
 		g.msg("my, that was a yummy %s", g.Fruit)
-	} else if g.rnd(100) > 70 {
+	case g.rnd(100) > 70:
 		p.Stats.Exp++
+
 		g.msg("%s, this food tastes awful", g.chooseStr("bummer", "yuk"))
 		g.checkLevel()
-	} else {
+	default:
 		g.msg("%s, that tasted good", g.chooseStr("oh, wow", "yum"))
 	}
+
 	g.leavePack(obj, false, false)
 }
 
@@ -252,38 +273,46 @@ func (g *RogueGame) eat() {
 // check_level).
 func (g *RogueGame) checkLevel() {
 	p := &g.Player
+
 	var i int
-	for i = 0; eLevels[i] != 0; i++ {
-		if eLevels[i] > p.Stats.Exp {
+	for i = 0; g.data.eLevels[i] != 0; i++ {
+		if g.data.eLevels[i] > p.Stats.Exp {
 			break
 		}
 	}
+
 	i++
 	olevel := p.Stats.Lvl
+
 	p.Stats.Lvl = i
 	if i > olevel {
 		add := g.roll(i-olevel, 10)
 		p.Stats.MaxHP += add
 		p.Stats.HP += add
+
 		g.msg("welcome to level %d", i)
 	}
 }
 
-// chgStr modifies the player's strength, keeping track of the highest it
-// has been (misc.c chg_str).
-func (g *RogueGame) chgStr(amt int) {
+// changeStrength modifies the player's strength, keeping track of the
+// highest it has been (misc.c chg_str).
+func (g *RogueGame) changeStrength(amt int) {
 	if amt == 0 {
 		return
 	}
+
 	p := &g.Player
 	addStr(&p.Stats.Str, amt)
+
 	comp := p.Stats.Str
 	if p.IsRing(Left, RingAddStrength) {
 		addStr(&comp, -p.CurRing[Left].Bonus)
 	}
+
 	if p.IsRing(Right, RingAddStrength) {
 		addStr(&comp, -p.CurRing[Right].Bonus)
 	}
+
 	if comp > p.MaxStats.Str {
 		p.MaxStats.Str = comp
 	}
@@ -303,24 +332,29 @@ func (g *RogueGame) addHaste(potion bool) bool {
 	p := &g.Player
 	if p.On(Hasted) {
 		g.NoCommand += g.rnd(8)
+
 		p.Flags.Clear(Awake | Hasted)
 		g.Extinguish(DNohaste)
 		g.msg("you faint from exhaustion")
+
 		return false
 	}
+
 	p.Flags.Set(Hasted)
+
 	if potion {
 		g.Fuse(DNohaste, 0, g.rnd(4)+4, After)
 	}
+
 	return true
 }
 
 // aggravate aggravates all the monsters on this level (misc.c aggravate).
 func (g *RogueGame) aggravate() {
-	// runto() can splice the monster list while we walk it, so iterate a copy.
+	// runTo() can splice the monster list while we walk it, so iterate a copy.
 	monsters := append([]*Monster(nil), g.Level.Monsters...)
 	for _, mp := range monsters {
-		g.runto(mp.Pos)
+		g.runTo(mp.Pos)
 	}
 }
 
@@ -330,10 +364,12 @@ func vowelstr(str string) string {
 	if str == "" {
 		return ""
 	}
+
 	switch str[0] {
 	case 'a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U':
 		return "n"
 	}
+
 	return ""
 }
 
@@ -343,21 +379,25 @@ func (g *RogueGame) isCurrent(obj *Object) bool {
 	if obj == nil {
 		return false
 	}
+
 	p := &g.Player
 	if obj == p.CurArmor || obj == p.CurWeapon ||
 		obj == p.CurRing[Left] || obj == p.CurRing[Right] {
 		if !g.Options.Terse {
-			g.addmsg("That's already ")
+			g.addmsgf("That's already ")
 		}
+
 		g.msg("in use")
+
 		return true
 	}
+
 	return false
 }
 
-// getDir sets up the direction coordinate for use in various "prefix"
-// commands (misc.c get_dir).
-func (g *RogueGame) getDir() bool {
+// promptDirection sets up the direction coordinate for use in various
+// "prefix" commands (misc.c get_dir).
+func (g *RogueGame) promptDirection() bool {
 	if g.Again && g.LastDir != 0 {
 		g.Delta = g.lastDelt
 		g.DirCh = g.LastDir
@@ -367,8 +407,10 @@ func (g *RogueGame) getDir() bool {
 			prompt = "which direction? "
 			g.msg("%s", prompt)
 		}
+
 		for {
 			gotit := true
+
 			switch g.DirCh = g.readchar(); g.DirCh {
 			case 'h', 'H':
 				g.Delta = Coord{X: -1, Y: 0}
@@ -389,30 +431,38 @@ func (g *RogueGame) getDir() bool {
 			case Escape:
 				g.LastDir = 0
 				g.resetLast()
+
 				return false
 			default:
 				g.Msgs.Mpos = 0
 				g.msg("%s", prompt)
+
 				gotit = false
 			}
+
 			if gotit {
 				break
 			}
 		}
+
 		g.DirCh = toLower(g.DirCh)
 		g.LastDir = g.DirCh
 		g.lastDelt = g.Delta
 	}
+
 	if g.Player.On(Confused) && g.rnd(5) == 0 {
 		for {
 			g.Delta.Y = g.rnd(3) - 1
+
 			g.Delta.X = g.rnd(3) - 1
 			if g.Delta.Y != 0 || g.Delta.X != 0 {
 				break
 			}
 		}
 	}
+
 	g.Msgs.Mpos = 0
+
 	return true
 }
 
@@ -422,6 +472,7 @@ func (g *RogueGame) callIt(info *ObjInfo) {
 		info.Guess = ""
 	} else if info.Guess == "" {
 		g.msg("%s", g.chooseTerse("call it: ", "what do you want to call it? "))
+
 		buf := ""
 		if g.getStr(&buf, g.scr.Std) == Norm {
 			if buf != "" {
@@ -431,21 +482,17 @@ func (g *RogueGame) callIt(info *ObjInfo) {
 	}
 }
 
-// thingList is misc.c rnd_thing()'s static table.
-var thingList = []byte{
-	Potion, Scroll, Ring, Stick, Food, Weapon, Armor, Stairs, Gold, Amulet,
-}
-
 // rndThing picks a random thing appropriate for this level (misc.c
 // rnd_thing).
 func (g *RogueGame) rndThing() byte {
 	var i int
 	if g.Depth >= AmuletLevel {
-		i = g.rnd(len(thingList))
+		i = g.rnd(len(g.data.thingList))
 	} else {
-		i = g.rnd(len(thingList) - 1)
+		i = g.rnd(len(g.data.thingList) - 1)
 	}
-	return thingList[i]
+
+	return g.data.thingList[i]
 }
 
 // chooseStr picks the first or second string depending on whether the
@@ -454,6 +501,7 @@ func (g *RogueGame) chooseStr(ts, ns string) string {
 	if g.Player.On(Hallucinating) {
 		return ts
 	}
+
 	return ns
 }
 
@@ -463,8 +511,10 @@ func unctrl(ch byte) string {
 	if ch < ' ' {
 		return "^" + string(ch+'@')
 	}
+
 	if ch == 0x7f {
 		return "^?"
 	}
+
 	return string(ch)
 }

game/monsters.go

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

game/move.go

@@ -2,54 +2,66 @@ package game
 
 // move.c — hero movement commands.
 
-// doRun starts the hero running (move.c do_run).
-func (g *RogueGame) doRun(ch byte) {
+// startRun starts the hero running (move.c do_run).
+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 —
-// fighting, picking up, etc. (move.c do_move).
-func (g *RogueGame) doMove(dy, dx int) {
+// moveHero checks that a move is legal and handles the consequences —
+// fighting, picking up, etc. (move.c do_move). The C `goto over`
+// re-check after a passage turn is the retry loop.
+func (g *RogueGame) moveHero(dy, dx int) {
 	p := &g.Player
+
 	g.Firstmove = false
 	if g.NoMove > 0 {
 		g.NoMove--
 		g.msg("you are still stuck in the bear trap")
+
 		return
 	}
 	// Do a confused move (maybe)
 	var nh Coord
 	if p.On(Confused) && g.rnd(5) != 0 {
-		nh = g.rndmove(&p.Creature)
+		nh = g.randomStep(&p.Creature)
 		if nh == p.Pos {
 			g.After = false
 			g.Running = false
 			g.ToDeath = false
+
 			return
 		}
 	} else {
 		nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
 	}
 
-over:
-	// Check if he tried to move off the screen or make an illegal diagonal
-	// move, and stop him if he did.
+	for {
+		// Check if he tried to move off the screen or make an illegal
+		// diagonal move, and stop him if he did.
 		hitBound := nh.X < 0 || nh.X >= NumCols || nh.Y <= 0 || nh.Y >= NumLines-1
-	var ch byte
-	var fl PlaceFlags
+
+		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 {
 				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) {
@@ -59,20 +71,93 @@ over:
 				}
 			} else if p.On(Held) && ch != 'F' {
 				g.msg("you are being held")
+
 				return
 			}
 		}
+
 		if hitBound {
 			ch = ' ' // fall into the wall case below
 		}
+
 		switch ch {
 		case ' ', '|', '-':
-		if g.Options.PassGo && g.Running && p.Room.Flags.Has(Gone) &&
-			!p.On(Blind) {
+			if turn, ndy, ndx := g.passageTurn(dy, dx); turn {
+				dy, dx = ndy, ndx
+
+				g.turnRefresh()
+
+				nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
+
+				continue // the C goto over: re-check the turned move
+			}
+
+			g.Running = false
+			g.After = false
+		case Door:
+			g.Running = false
+			if g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Has(FPassage) {
+				g.enterRoom(nh)
+			}
+
+			g.finishMove(nh, fl)
+		case Trap:
+			tr := g.springTrap(nh)
+			if tr == TrapDoor || tr == TrapTeleport {
+				return
+			}
+
+			g.finishMove(nh, fl)
+		case Passage:
+			// when you're in a corridor, you don't know if you're in a maze
+			// room or not, and there ain't no way to find out if you're
+			// leaving a maze room, so it is necessary to always recalculate
+			// proom.
+			p.Room = g.roomIn(p.Pos)
+			g.finishMove(nh, fl)
+		case Floor:
+			if !fl.Has(FReal) {
+				g.springTrap(p.Pos)
+			}
+
+			g.finishMove(nh, fl)
+		default:
+			if ch == Stairs {
+				g.SeenStairs = true
+			}
+
+			g.Running = false
+			if isUpper(ch) || g.Level.MonsterAt(nh.Y, nh.X) != nil {
+				g.fight(nh, p.CurWeapon, false)
+			} else {
+				if ch != Stairs {
+					g.Take = ch
+				}
+
+				g.finishMove(nh, fl)
+			}
+		}
+
+		return
+	}
+}
+
+// passageTurn checks whether a runner in a gone-room passage should turn
+// 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
+	}
+
 	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 {
@@ -82,13 +167,12 @@ over:
 				g.RunCh = 'j'
 				dy = 1
 			}
-					dx = 0
-					g.turnref()
-					nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
-					goto over
+
+			return true, dy, 0
 		}
 	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 {
@@ -98,62 +182,23 @@ over:
 				g.RunCh = 'l'
 				dx = 1
 			}
-					dy = 0
-					g.turnref()
-					nh = Coord{Y: p.Pos.Y + dy, X: p.Pos.X + dx}
-					goto over
-				}
-			}
-		}
-		g.Running = false
-		g.After = false
-	case Door:
-		g.Running = false
-		if g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Has(FPassage) {
-			g.enterRoom(nh)
-		}
-		g.moveStuff(nh, fl)
-	case Trap:
-		tr := g.beTrapped(nh)
-		if tr == TrapDoor || tr == TrapTeleport {
-			return
-		}
-		g.moveStuff(nh, fl)
-	case Passage:
-		// when you're in a corridor, you don't know if you're in a maze
-		// room or not, and there ain't no way to find out if you're
-		// leaving a maze room, so it is necessary to always recalculate
-		// proom.
-		p.Room = g.roomin(p.Pos)
-		g.moveStuff(nh, fl)
-	case Floor:
-		if !fl.Has(FReal) {
-			g.beTrapped(p.Pos)
-		}
-		g.moveStuff(nh, fl)
-	default:
-		if ch == Stairs {
-			g.SeenStairs = true
-		}
-		g.Running = false
-		if isUpper(ch) || g.Level.MonsterAt(nh.Y, nh.X) != nil {
-			g.fight(nh, p.CurWeapon, false)
-		} else {
-			if ch != Stairs {
-				g.Take = ch
-			}
-			g.moveStuff(nh, fl)
+
+			return true, 0, dx
 		}
 	}
+
+	return false, dy, dx
 }
 
-// moveStuff is the move_stuff label in do_move: complete the step.
-func (g *RogueGame) moveStuff(nh Coord, fl PlaceFlags) {
+// finishMove is the move_stuff label in do_move: complete the step.
+func (g *RogueGame) finishMove(nh Coord, fl PlaceFlags) {
 	p := &g.Player
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())
+
 	if fl.Has(FPassage) && g.Level.Char(g.Oldpos.Y, g.Oldpos.X) == Door {
 		g.leaveRoom(nh)
 	}
+
 	p.Pos = nh
 }
 
@@ -161,17 +206,21 @@ func (g *RogueGame) moveStuff(nh Coord, fl PlaceFlags) {
 // (move.c turn_ok).
 func (g *RogueGame) turnOk(y, x int) bool {
 	pp := g.Level.At(y, x)
+
 	return pp.Ch == Door || pp.Flags&(FReal|FPassage) == (FReal|FPassage)
 }
 
-// turnref decides whether to refresh at a passage turning (move.c turnref).
-func (g *RogueGame) turnref() {
+// turnRefresh decides whether to refresh at a passage turning (move.c
+// turnref).
+func (g *RogueGame) turnRefresh() {
 	p := &g.Player
+
 	pp := g.Level.At(p.Pos.Y, p.Pos.X)
 	if !pp.Flags.Has(FSeen) {
 		if g.Options.Jump {
 			g.refresh()
 		}
+
 		pp.Flags.Set(FSeen)
 	}
 }
@@ -182,6 +231,7 @@ func (g *RogueGame) doorOpen(rp *Room) {
 	if rp.Flags.Has(Gone) {
 		return
 	}
+
 	for y := rp.Pos.Y; y < rp.Pos.Y+rp.Max.Y; y++ {
 		for x := rp.Pos.X; x < rp.Pos.X+rp.Max.X; x++ {
 			if isUpper(g.Level.VisibleChar(y, x)) {
@@ -191,18 +241,20 @@ func (g *RogueGame) doorOpen(rp *Room) {
 	}
 }
 
-// beTrapped makes him pay for stepping on a trap (move.c be_trapped).
-func (g *RogueGame) beTrapped(tc Coord) TrapKind {
+// springTrap makes him pay for stepping on a trap (move.c be_trapped).
+func (g *RogueGame) springTrap(tc Coord) TrapKind {
 	p := &g.Player
 	if p.On(Levitating) {
 		return TrapRust // anything that's not a door or teleport
 	}
+
 	g.Running = false
 	g.Count = 0
 	pp := g.Level.At(tc.Y, tc.X)
 	pp.Ch = Trap
 	tr := TrapKind(pp.Flags & FTrapMask)
 	pp.Flags.Set(FSeen)
+
 	switch tr {
 	case TrapDoor:
 		g.Depth++
@@ -216,17 +268,17 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 		case 0:
 			g.msg("you are suddenly in a parallel dimension")
 		case 1:
-			g.msg("the light in here suddenly seems %s", rainbow[g.rnd(len(rainbow))])
+			g.msg("the light in here suddenly seems %s", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 		case 2:
 			g.msg("you feel a sting in the side of your neck")
 		case 3:
 			g.msg("multi-colored lines swirl around you, then fade")
 		case 4:
-			g.msg("a %s light flashes in your eyes", rainbow[g.rnd(len(rainbow))])
+			g.msg("a %s light flashes in your eyes", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 		case 5:
 			g.msg("a spike shoots past your ear!")
 		case 6:
-			g.msg("%s sparks dance across your armor", rainbow[g.rnd(len(rainbow))])
+			g.msg("%s sparks dance across your armor", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 		case 7:
 			g.msg("you suddenly feel very thirsty")
 		case 8:
@@ -234,10 +286,11 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 		case 9:
 			g.msg("time now seems to be going slower")
 		case 10:
-			g.msg("you pack turns %s!", rainbow[g.rnd(len(rainbow))])
+			g.msg("you pack turns %s!", g.data.rainbow[g.rnd(len(g.data.rainbow))])
 		}
 	case TrapSleep:
 		g.NoCommand += g.spread(5) // SLEEPTIME
+
 		p.Flags.Clear(Awake)
 		g.msg("a strange white mist envelops you and you fall asleep")
 	case TrapArrow:
@@ -271,22 +324,26 @@ func (g *RogueGame) beTrapped(tc Coord) TrapKind {
 				g.msg("a poisoned dart killed you")
 				g.death('d')
 			}
+
 			if !p.IsWearing(RingSustainStrength) && !g.save(VsPoison) {
-				g.chgStr(-1)
+				g.changeStrength(-1)
 			}
+
 			g.msg("a small dart just hit you in the shoulder")
 		}
 	case TrapRust:
 		g.msg("a gush of water hits you on the head")
 		g.rustArmor(p.CurArmor)
 	}
+
 	g.flushType()
+
 	return tr
 }
 
-// rndmove moves in a random direction if the monster/person is confused
-// (move.c rndmove).
-func (g *RogueGame) rndmove(who *Creature) Coord {
+// randomStep moves in a random direction if the monster/person is
+// confused (move.c rndmove).
+func (g *RogueGame) randomStep(who *Creature) Coord {
 	ret := Coord{
 		Y: who.Pos.Y + g.rnd(3) - 1,
 		X: who.Pos.X + g.rnd(3) - 1,
@@ -296,25 +353,32 @@ func (g *RogueGame) rndmove(who *Creature) Coord {
 	if ret == who.Pos {
 		return ret
 	}
+
 	if !g.diagOk(who.Pos, ret) {
 		return who.Pos
 	}
+
 	ch := g.Level.VisibleChar(ret.Y, ret.X)
 	if !stepOk(ch) {
 		return who.Pos
 	}
+
 	if ch == Scroll {
 		var found *Object
+
 		for _, obj := range g.Level.Objects {
 			if ret.Y == obj.Pos.Y && ret.X == obj.Pos.X {
 				found = obj
+
 				break
 			}
 		}
+
 		if found != nil && found.ScrollKind() == ScrollScareMonster {
 			return who.Pos
 		}
 	}
+
 	return ret
 }
 
@@ -332,6 +396,7 @@ func (g *RogueGame) rustArmor(arm *Object) {
 		}
 	} else {
 		arm.ArmorClass++
+
 		if !g.Options.Terse {
 			g.msg("your armor appears to be weaker now. Oh my!")
 		} else {

game/newlevel.go

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

game/newlevel_test.go

@@ -7,24 +7,30 @@ import (
 
 func genLevel(t *testing.T, seed int32) *RogueGame {
 	t.Helper()
+
 	g := NewGame(Config{Seed: seed})
 	g.NewLevel()
+
 	return g
 }
 
 // renderMap draws the raw level map (not the screen) as text.
 func renderMap(g *RogueGame) string {
 	var sb strings.Builder
-	for y := 0; y < NumLines; y++ {
-		for x := 0; x < NumCols; x++ {
+
+	for y := range NumLines {
+		for x := range NumCols {
 			ch := g.Level.Char(y, x)
 			if m := g.Level.MonsterAt(y, x); m != nil {
 				ch = m.Type
 			}
+
 			sb.WriteByte(ch)
 		}
+
 		sb.WriteByte('\n')
 	}
+
 	return sb.String()
 }
 
@@ -44,9 +50,11 @@ func TestNewLevelInvariants(t *testing.T) {
 			t.Errorf("seed %d: hero on unwalkable cell %q", seed,
 				g.Level.Char(hp.Y, hp.X))
 		}
+
 		if g.Level.MonsterAt(hp.Y, hp.X) != nil {
 			t.Errorf("seed %d: hero standing on a monster", seed)
 		}
+
 		if g.Player.Room == nil {
 			t.Errorf("seed %d: hero not in any room", seed)
 		}
@@ -56,6 +64,7 @@ func TestNewLevelInvariants(t *testing.T) {
 		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)
 		}
@@ -66,6 +75,7 @@ func TestNewLevelInvariants(t *testing.T) {
 				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)
 			}
@@ -87,10 +97,12 @@ func TestNewLevelInvariants(t *testing.T) {
 			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)
@@ -100,10 +112,12 @@ func TestNewLevelInvariants(t *testing.T) {
 
 func TestNewLevelDeterministic(t *testing.T) {
 	a := renderMap(genLevel(t, 12345))
+
 	b := renderMap(genLevel(t, 12345))
 	if a != b {
 		t.Error("same seed produced different levels")
 	}
+
 	c := renderMap(genLevel(t, 54321))
 	if a == c {
 		t.Error("different seeds produced identical levels")
@@ -118,6 +132,7 @@ func TestDeeperLevels(t *testing.T) {
 		for depth := 1; depth <= 30; depth++ {
 			g.Depth = depth
 			g.NewLevel()
+
 			st := g.Level.Stairs
 			if g.Level.Char(st.Y, st.X) != Stairs {
 				t.Fatalf("seed %d depth %d: missing staircase", seed, depth)

game/object.go

@@ -5,6 +5,7 @@ package game
 // category (ObjectKind) from its display character (Glyph).
 type ObjectKind int
 
+// Item categories.
 const (
 	KindNone ObjectKind = iota
 	KindPotion
@@ -25,35 +26,49 @@ const (
 	KindRingOrStick ObjectKind = -2
 )
 
-// kindGlyphs maps each kind to the character Rogue draws for it.
-var kindGlyphs = [...]byte{
-	KindNone:   ' ',
-	KindPotion: Potion,
-	KindScroll: Scroll,
-	KindFood:   Food,
-	KindWeapon: Weapon,
-	KindArmor:  Armor,
-	KindRing:   Ring,
-	KindWand:   Stick,
-	KindAmulet: Amulet,
-	KindGold:   Gold,
-}
+// Category words shared by ObjectKind.String, the discovery list, and the
+// ident table. (The bare identifiers Potion, Scroll, Ring, Gold are the
+// glyph byte constants.)
+const (
+	potionName = "potion"
+	scrollName = "scroll"
+	ringName   = "ring"
+	goldName   = "gold"
+)
 
 // Glyph returns the map/display character for this kind of object.
 func (k ObjectKind) Glyph() byte {
-	if k < 0 || int(k) >= len(kindGlyphs) {
-		return ' '
+	switch k {
+	case KindPotion:
+		return Potion
+	case KindScroll:
+		return Scroll
+	case KindFood:
+		return Food
+	case KindWeapon:
+		return Weapon
+	case KindArmor:
+		return Armor
+	case KindRing:
+		return Ring
+	case KindWand:
+		return Stick
+	case KindAmulet:
+		return Amulet
+	case KindGold:
+		return Gold
 	}
-	return kindGlyphs[k]
+
+	return ' '
 }
 
 // String names the category the way the C type_name() did.
 func (k ObjectKind) String() string {
 	switch k {
 	case KindPotion:
-		return "potion"
+		return potionName
 	case KindScroll:
-		return "scroll"
+		return scrollName
 	case KindFood:
 		return "food"
 	case KindWeapon:
@@ -61,27 +76,44 @@ func (k ObjectKind) String() string {
 	case KindArmor:
 		return "suit of armor"
 	case KindRing:
-		return "ring"
+		return ringName
 	case KindWand:
 		return "wand or staff"
 	case KindAmulet:
 		return "amulet"
 	case KindGold:
-		return "gold"
+		return goldName
 	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 {
-		if g == ch && ObjectKind(k) != KindNone {
-			return ObjectKind(k)
-		}
+	switch ch {
+	case Potion:
+		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
 }
 
@@ -148,6 +180,7 @@ func detachObj(list *[]*Object, item *Object) {
 	for i, o := range *list {
 		if o == item {
 			*list = append((*list)[:i], (*list)[i+1:]...)
+
 			return
 		}
 	}

game/options.go

@@ -28,6 +28,7 @@ type optDesc struct {
 // optList builds the options.c optlist for this game.
 func (g *RogueGame) optList() []optDesc {
 	o := &g.Options
+
 	return []optDesc{
 		{"terse", "Terse output", optBool, &o.Terse, nil, nil},
 		{"flush", "Flush typeahead during battle", optBool, &o.FightFlush, nil, nil},
@@ -46,6 +47,7 @@ func (g *RogueGame) optList() []optDesc {
 func (g *RogueGame) option() {
 	hw := g.scr.Hw
 	optlist := g.optList()
+
 	hw.Clear()
 	// Display current values of options
 	for i := range optlist {
@@ -56,9 +58,11 @@ func (g *RogueGame) option() {
 	}
 	// Set values
 	hw.Move(0, 0)
+
 	for i := 0; i < len(optlist); i++ {
 		op := &optlist[i]
 		g.prOptname(op)
+
 		retval := g.getOpt(op)
 		if retval != Norm {
 			if retval == Quit {
@@ -70,6 +74,7 @@ func (g *RogueGame) option() {
 				i -= 2
 			} else { // trying to back up beyond the top
 				hw.Move(0, 0)
+
 				i--
 			}
 		}
@@ -84,18 +89,19 @@ func (g *RogueGame) option() {
 
 // prOptname prints out the option name prompt (options.c pr_optname).
 func (g *RogueGame) prOptname(op *optDesc) {
-	g.scr.Hw.Printw("%s (\"%s\"): ", op.prompt, op.name)
+	g.scr.Hw.Printwf("%s (\"%s\"): ", op.prompt, op.name)
 }
 
 // putOpt prints an option's current value (options.c put_bool/put_str/
 // put_inv_t).
 func (g *RogueGame) putOpt(op *optDesc) {
 	hw := g.scr.Hw
+
 	switch op.kind {
 	case optBool, optSeeFloor:
 		hw.AddStr(boolStr(*op.boolP))
 	case optInvT:
-		hw.AddStr(invTName[*op.intP])
+		hw.AddStr(g.data.invTName[*op.intP])
 	case optStr:
 		hw.AddStr(*op.strP)
 	}
@@ -105,6 +111,7 @@ func boolStr(b bool) string {
 	if b {
 		return "True"
 	}
+
 	return "False"
 }
 
@@ -129,9 +136,11 @@ func (g *RogueGame) getBool(bp *bool) int {
 	win := g.scr.Hw
 	oy, ox := win.GetYX()
 	win.AddStr(boolStr(*bp))
+
 	for {
 		win.Move(oy, ox)
 		g.scr.RefreshWin(win)
+
 		switch g.readchar() {
 		case 't', 'T':
 			*bp = true
@@ -145,13 +154,17 @@ func (g *RogueGame) getBool(bp *bool) int {
 		default:
 			win.Move(oy, ox+10)
 			win.AddStr("(T or F)")
+
 			continue
 		}
+
 		break
 	}
+
 	win.Move(oy, ox)
 	win.AddStr(boolStr(*bp))
 	win.AddCh('\n')
+
 	return Norm
 }
 
@@ -159,10 +172,12 @@ func (g *RogueGame) getBool(bp *bool) int {
 // get_sf).
 func (g *RogueGame) getSf(bp *bool) int {
 	wasSf := g.Options.SeeFloor
+
 	retval := g.getBool(bp)
 	if retval == Quit {
 		return Quit
 	}
+
 	if wasSf != g.Options.SeeFloor {
 		if !g.Options.SeeFloor {
 			g.Options.SeeFloor = true
@@ -172,6 +187,7 @@ func (g *RogueGame) getSf(bp *bool) int {
 			g.look(false)
 		}
 	}
+
 	return Norm
 }
 
@@ -183,57 +199,74 @@ func (g *RogueGame) getStr(opt *string, win *Window) int {
 	oy, ox := win.GetYX()
 	g.scr.RefreshWin(win)
 	// loop reading in the string, and put it in a temporary buffer
-	var buf []byte
-	var c byte
+	var (
+		buf []byte
+		c   byte
+	)
 	for {
 		c = g.readchar()
 		if c == '\n' || c == '\r' || c == Escape {
 			break
 		}
+
 		if c == 8 || c == 0x7f { // erase character
 			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 == ' ') {
+
+		if len(buf) >= MaxInp || (!isPrint(c) && c != ' ') {
 			continue // C beeps here
 		}
+
 		buf = append(buf, c)
 		win.AddStr(unctrl(c))
 		win.Clrtoeol()
 		g.scr.RefreshWin(win)
 	}
+
 	if len(buf) > 0 { // only change option if something has been typed
 		*opt = strucpy(string(buf))
 	}
-	win.MvPrintw(oy, ox, "%s\n", *opt)
+
+	win.MvPrintwf(oy, ox, "%s\n", *opt)
 	g.scr.RefreshWin(win)
+
 	if onStd {
 		g.Msgs.Mpos += len(buf)
 	}
+
 	switch c {
 	case '-':
 		return Minus
@@ -250,6 +283,7 @@ func displayStr(buf []byte) string {
 	for _, c := range buf {
 		sb.WriteString(unctrl(c))
 	}
+
 	return sb.String()
 }
 
@@ -257,10 +291,12 @@ func displayStr(buf []byte) string {
 func (g *RogueGame) getInvT(ip *int) int {
 	win := g.scr.Hw
 	oy, ox := win.GetYX()
-	win.AddStr(invTName[*ip])
+	win.AddStr(g.data.invTName[*ip])
+
 	for {
 		win.Move(oy, ox)
 		g.scr.RefreshWin(win)
+
 		switch g.readchar() {
 		case 'o', 'O':
 			*ip = InvOver
@@ -276,11 +312,15 @@ func (g *RogueGame) getInvT(ip *int) int {
 		default:
 			win.Move(oy, ox+15)
 			win.AddStr("(O, S, or C)")
+
 			continue
 		}
+
 		break
 	}
-	win.MvPrintw(oy, ox, "%s\n", invTName[*ip])
+
+	win.MvPrintwf(oy, ox, "%s\n", g.data.invTName[*ip])
+
 	return Norm
 }
 
@@ -289,20 +329,25 @@ func (g *RogueGame) getInvT(ip *int) int {
 // "noname" (false), strings as "name=..." (options.c parse_opts).
 func (g *RogueGame) ParseOpts(str string) {
 	optlist := g.optList()
+
 	for str != "" {
 		// Get option name
 		i := 0
 		for i < len(str) && isAlpha(str[i]) {
 			i++
 		}
+
 		name := str[:i]
 		rest := str[i:]
 		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 {
@@ -310,10 +355,13 @@ func (g *RogueGame) ParseOpts(str string) {
 					for rest != "" && rest[0] == '=' {
 						rest = rest[1:]
 					}
+
 					val := rest
+
 					var prefix string
 					if val != "" && val[0] == '~' {
 						prefix = g.Home
+
 						val = val[1:]
 						for val != "" && val[0] == '/' {
 							val = val[1:]
@@ -324,17 +372,21 @@ func (g *RogueGame) ParseOpts(str string) {
 					if end < 0 {
 						end = len(val)
 					}
+
 					word := val[:end]
 					rest = val[end:]
+
 					if op.kind == optInvT {
 						// check for type of inventory
 						w := word
 						if w != "" {
 							w = string(toUpper(w[0])) + w[1:]
 						}
-						for ti, tn := range invTName {
+
+						for ti, tn := range g.data.invTName {
 							if strings.HasPrefix(tn, w) {
 								*op.intP = ti
+
 								break
 							}
 						}
@@ -342,19 +394,23 @@ func (g *RogueGame) ParseOpts(str string) {
 						*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:]
 		}
+
 		str = rest
 	}
 }
@@ -365,11 +421,14 @@ func strucpy(s string) string {
 	if len(s) > MaxInp {
 		s = s[:MaxInp]
 	}
+
 	var sb strings.Builder
-	for i := 0; i < len(s); i++ {
+
+	for i := range len(s) {
 		if isPrint(s[i]) || s[i] == ' ' {
 			sb.WriteByte(s[i])
 		}
 	}
+
 	return sb.String()
 }

game/pack.go

@@ -7,29 +7,34 @@ package game
 func (g *RogueGame) addPack(obj *Object, silent bool) {
 	p := &g.Player
 	fromFloor := false
+
 	if obj == nil {
-		if obj = g.findObj(p.Pos.Y, p.Pos.X); obj == nil {
+		if obj = g.Level.ObjectAt(p.Pos.Y, p.Pos.X); obj == nil {
 			return
 		}
+
 		fromFloor = true
 	}
 
 	// Check for and deal with scare monster scrolls
 	if obj.Kind == KindScroll && obj.ScrollKind() == ScrollScareMonster && obj.Flags.Has(WasFound) {
-		detachObj(&g.Level.Objects, obj)
+		g.Level.RemoveObject(obj)
 		g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
+
 		if p.Room.Flags.Has(Gone) {
 			g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
 		} else {
 			g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
 		}
+
 		g.msg("the scroll turns to dust as you pick it up")
+
 		return
 	}
 
 	if len(p.Pack) == 0 {
 		p.Pack = append(p.Pack, obj)
-		obj.PackCh = g.packChar()
+		obj.PackCh = p.nextPackChar()
 		p.Inpack++
 	} else {
 		// Walk the pack looking for the insertion point, keeping items of
@@ -38,9 +43,11 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 		// 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
@@ -49,19 +56,23 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 				if i+1 >= len(p.Pack) {
 					break
 				}
+
 				i++
 			}
+
 			op := p.Pack[i]
 			if op.Kind == obj.Kind && op.Which == obj.Which {
-				if op.Kind.MergesInPack() {
+				switch {
+				case op.Kind.MergesInPack():
 					if !g.packRoom(fromFloor, obj) {
 						return
 					}
+
 					op.Count++
 					obj = op
 					lp = -1
 					merged = true
-				} else if obj.Group != 0 {
+				case obj.Group != 0:
 					lp = i
 					for p.Pack[i].Kind == obj.Kind &&
 						p.Pack[i].Which == obj.Which &&
@@ -70,24 +81,29 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 						if i+1 >= len(p.Pack) {
 							break
 						}
+
 						i++
 					}
+
 					op = p.Pack[i]
 					if op.Kind == obj.Kind && op.Which == obj.Which &&
 						op.Group == obj.Group {
 						op.Count += obj.Count
 						p.Inpack--
+
 						if !g.packRoom(fromFloor, obj) {
 							return
 						}
+
 						obj = op
 						lp = -1
 						merged = true
 					}
-				} else {
+				default:
 					lp = i
 				}
 			}
+
 			break
 		}
 
@@ -95,7 +111,8 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 			if !g.packRoom(fromFloor, obj) {
 				return
 			}
-			obj.PackCh = g.packChar()
+
+			obj.PackCh = p.nextPackChar()
 			p.Pack = append(p.Pack[:lp+1],
 				append([]*Object{obj}, p.Pack[lp+1:]...)...)
 		}
@@ -117,9 +134,10 @@ func (g *RogueGame) addPack(obj *Object, silent bool) {
 	// Notify the user
 	if !silent {
 		if !g.Options.Terse {
-			g.addmsg("you now have ")
+			g.addmsgf("you now have ")
 		}
-		g.msg("%s (%c)", g.invName(obj, !g.Options.Terse), obj.PackCh)
+
+		g.msg("%s (%c)", g.inventoryName(obj, !g.Options.Terse), obj.PackCh)
 	}
 }
 
@@ -129,90 +147,77 @@ func (g *RogueGame) packRoom(fromFloor bool, obj *Object) bool {
 	p := &g.Player
 	if p.Inpack++; p.Inpack > MaxPack {
 		if !g.Options.Terse {
-			g.addmsg("there's ")
+			g.addmsgf("there's ")
 		}
-		g.addmsg("no room")
+
+		g.addmsgf("no room")
+
 		if !g.Options.Terse {
-			g.addmsg(" in your pack")
+			g.addmsgf(" in your pack")
 		}
+
 		g.endmsg()
+
 		if fromFloor {
 			g.moveMsg(obj)
 		}
+
 		p.Inpack = MaxPack
+
 		return false
 	}
 
 	if fromFloor {
-		detachObj(&g.Level.Objects, obj)
+		g.Level.RemoveObject(obj)
 		g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
+
 		if p.Room.Flags.Has(Gone) {
 			g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
 		} else {
 			g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
 		}
 	}
+
 	return true
 }
 
-// leavePack takes an item out of the pack (pack.c leave_pack).
+// leavePack takes an item out of the pack (pack.c leave_pack), keeping
+// the repeat-command bookkeeping; the pack surgery is
+// Player.removeFromPack.
 func (g *RogueGame) leavePack(obj *Object, newobj, all bool) *Object {
-	p := &g.Player
-	p.Inpack--
-	nobj := obj
 	if obj.Count > 1 && !all {
 		g.LastPick = obj
-		obj.Count--
-		if obj.Group != 0 {
-			p.Inpack++
-		}
-		if newobj {
-			copied := *obj
-			nobj = &copied
-			nobj.Count = 1
-		}
 	} else {
 		g.LastPick = nil
-		p.PackUsed[obj.PackCh-'a'] = false
-		detachObj(&p.Pack, obj)
 	}
-	return nobj
-}
 
-// packChar returns the next unused pack character (pack.c pack_char).
-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
+	return g.Player.removeFromPack(obj, newobj, all)
 }
 
 // inventory lists what is in the pack; returns true if there is something
 // of the given type (pack.c inventory).
 func (g *RogueGame) inventory(list []*Object, kind ObjectKind) bool {
 	g.NObjs = 0
+
 	for _, item := range list {
-		if kind != KindNone && kind != item.Kind &&
-			!(kind == KindCallable && item.Kind != KindFood &&
-				item.Kind != KindAmulet) &&
-			!(kind == KindRingOrStick &&
-				(item.Kind == KindRing || item.Kind == KindWand)) {
+		if !matchesFilter(kind, item) {
 			continue
 		}
+
 		g.NObjs++
 		g.Msgs.MsgEsc = true
-		line := string(item.PackCh) + ") " + g.invName(item, false)
+
+		line := string(item.PackCh) + ") " + g.inventoryName(item, false)
 		if g.addLine("%s", line) == Escape {
 			g.Msgs.MsgEsc = false
 			g.msg("")
+
 			return true
 		}
+
 		g.Msgs.MsgEsc = false
 	}
+
 	if g.NObjs == 0 {
 		if g.Options.Terse {
 			if kind == KindNone {
@@ -227,9 +232,12 @@ func (g *RogueGame) inventory(list []*Object, kind ObjectKind) bool {
 				g.msg("you don't have anything appropriate")
 			}
 		}
+
 		return false
 	}
+
 	g.endLine()
+
 	return true
 }
 
@@ -240,31 +248,53 @@ func (g *RogueGame) pickUp(ch byte) {
 		return
 	}
 
-	obj := g.findObj(p.Pos.Y, p.Pos.X)
+	obj := g.Level.ObjectAt(p.Pos.Y, p.Pos.X)
 	if g.MoveOn {
 		g.moveMsg(obj)
+
 		return
 	}
+
 	switch ch {
 	case Gold:
 		if obj == nil {
 			return
 		}
+
 		g.money(obj.GoldValue)
-		detachObj(&g.Level.Objects, obj)
+		g.Level.RemoveObject(obj)
+
 		p.Room.GoldVal = 0
 	default:
 		g.addPack(nil, false)
 	}
 }
 
+// matchesFilter reports whether an item passes a get_item/inventory kind
+// filter (the C condition in pack.c inventory, untangled): KindNone takes
+// everything, KindCallable takes anything nameable (not food, not the
+// amulet), KindRingOrStick takes rings and wands.
+func matchesFilter(kind ObjectKind, item *Object) bool {
+	switch kind {
+	case KindNone:
+		return true
+	case KindCallable:
+		return item.Kind != KindFood && item.Kind != KindAmulet
+	case KindRingOrStick:
+		return item.Kind == KindRing || item.Kind == KindWand
+	default:
+		return item.Kind == kind
+	}
+}
+
 // moveMsg prints the message if you are just moving onto an object
 // (pack.c move_msg).
 func (g *RogueGame) moveMsg(obj *Object) {
 	if !g.Options.Terse {
-		g.addmsg("you ")
+		g.addmsgf("you ")
 	}
-	g.msg("moved onto %s", g.invName(obj, true))
+
+	g.msg("moved onto %s", g.inventoryName(obj, true))
 }
 
 // pickyInven allows the player to inventory a single item (pack.c
@@ -273,50 +303,68 @@ func (g *RogueGame) pickyInven() {
 	p := &g.Player
 	if len(p.Pack) == 0 {
 		g.msg("you aren't carrying anything")
+
 		return
 	}
+
 	if len(p.Pack) == 1 {
-		g.msg("a) %s", g.invName(p.Pack[0], false))
+		g.msg("a) %s", g.inventoryName(p.Pack[0], false))
+
 		return
 	}
+
 	g.msg("%s", g.chooseTerse("item: ", "which item do you wish to inventory: "))
 	g.Msgs.Mpos = 0
+
 	mch := g.readchar()
 	if mch == Escape {
 		g.msg("")
+
 		return
 	}
+
 	for _, obj := range p.Pack {
 		if mch == obj.PackCh {
-			g.msg("%c) %s", mch, g.invName(obj, false))
+			g.msg("%c) %s", mch, g.inventoryName(obj, false))
+
 			return
 		}
 	}
+
 	g.msg("'%s' not in pack", unctrl(mch))
 }
 
-// getItem picks something out of a pack for a purpose (pack.c get_item).
-func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
+// promptPackItem picks something out of a pack for a purpose (pack.c
+// get_item); ok reports whether the player chose an item.
+func (g *RogueGame) promptPackItem(purpose string, kind ObjectKind) (obj *Object, ok 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.LastPick
+			return g.LastPick, true
 		}
+
 		g.msg("you ran out")
-		return nil
+
+		return nil, false
 	}
+
 	for {
 		if !g.Options.Terse {
-			g.addmsg("which object do you want to ")
+			g.addmsgf("which object do you want to ")
 		}
-		g.addmsg("%s", purpose)
+
+		g.addmsgf("%s", purpose)
+
 		if g.Options.Terse {
-			g.addmsg(" what")
+			g.addmsgf(" what")
 		}
+
 		g.msg("? (* for list): ")
 		ch := g.readchar()
 		g.Msgs.Mpos = 0
@@ -325,22 +373,28 @@ func (g *RogueGame) getItem(purpose string, kind ObjectKind) *Object {
 			g.resetLast()
 			g.After = false
 			g.msg("")
-			return nil
+
+			return nil, false
 		}
+
 		g.NObjs = 1 // normal case: person types one char
 		if ch == '*' {
 			g.Msgs.Mpos = 0
 			if !g.inventory(p.Pack, kind) {
 				g.After = false
-				return nil
+
+				return nil, false
 			}
+
 			continue
 		}
+
 		for _, obj := range p.Pack {
 			if obj.PackCh == ch {
-				return obj
+				return obj, true
 			}
 		}
+
 		g.msg("'%s' is not a valid item", unctrl(ch))
 	}
 }
@@ -350,15 +404,18 @@ func (g *RogueGame) money(value int) {
 	p := &g.Player
 	p.Purse += value
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorCh())
+
 	if p.Room.Flags.Has(Gone) {
 		g.Level.SetChar(p.Pos.Y, p.Pos.X, Passage)
 	} else {
 		g.Level.SetChar(p.Pos.Y, p.Pos.X, Floor)
 	}
+
 	if value > 0 {
 		if !g.Options.Terse {
-			g.addmsg("you found ")
+			g.addmsgf("you found ")
 		}
+
 		g.msg("%d gold pieces", value)
 	}
 }
@@ -369,9 +426,11 @@ func (g *RogueGame) floorCh() byte {
 	if g.Player.Room.Flags.Has(Gone) {
 		return Passage
 	}
+
 	if g.showFloor() {
 		return Floor
 	}
+
 	return ' '
 }
 
@@ -382,6 +441,7 @@ func (g *RogueGame) floorAt() byte {
 	if ch == Floor {
 		ch = g.floorCh()
 	}
+
 	return ch
 }
 
@@ -398,5 +458,6 @@ func (g *RogueGame) chooseTerse(terse, verbose string) string {
 	if g.Options.Terse {
 		return terse
 	}
+
 	return verbose
 }

game/passages.go

@@ -2,40 +2,32 @@ package game
 
 // passages.c — draw the connecting passages.
 
-// rdesConn is the hardcoded 3x3 room adjacency matrix from do_passages.
-var rdesConn = [MaxRooms][MaxRooms]bool{
-	{false, true, false, true, false, false, false, false, false},
-	{true, false, true, false, true, false, false, false, false},
-	{false, true, false, false, false, true, false, false, false},
-	{true, false, false, false, true, false, true, false, false},
-	{false, true, false, true, false, true, false, true, false},
-	{false, false, true, false, true, false, false, false, true},
-	{false, false, false, true, false, false, false, true, false},
-	{false, false, false, false, true, false, true, false, true},
-	{false, false, false, false, false, true, false, true, false},
-}
-
-// doPassages draws all the passages on a level (passages.c do_passages).
-func (g *RogueGame) doPassages() {
-	var isconn [MaxRooms][MaxRooms]bool
-	var ingraph [MaxRooms]bool
+// digPassages draws all the passages on a level (passages.c do_passages).
+func (g *RogueGame) digPassages() {
+	var (
+		isconn  [MaxRooms][MaxRooms]bool
+		ingraph [MaxRooms]bool
+	)
 
 	// starting with one room, connect it to a random adjacent room and
 	// then pick a new room to start with.
 	roomcount := 1
 	r1 := g.rnd(MaxRooms)
 	ingraph[r1] = true
+
 	for {
 		// find a room to connect with
 		j := 0
 		r2 := -1
-		for i := 0; i < MaxRooms; i++ {
-			if rdesConn[r1][i] && !ingraph[i] {
+
+		for i := range MaxRooms {
+			if g.data.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
@@ -48,12 +40,13 @@ func (g *RogueGame) doPassages() {
 		} else {
 			// otherwise, connect new room to the graph, and draw a tunnel
 			// to it
-			ingraph[r2] = true
-			g.conn(r1, r2)
+			ingraph[r2] = true //nolint:gosec // G602: rnd(MaxRooms) bounded
+			g.connectRooms(r1, r2)
 			isconn[r1][r2] = true
-			isconn[r2][r1] = true
+			isconn[r2][r1] = true //nolint:gosec // G602: rnd(MaxRooms) bounded
 			roomcount++
 		}
+
 		if roomcount >= MaxRooms {
 			break
 		}
@@ -66,8 +59,9 @@ func (g *RogueGame) doPassages() {
 		// find an adjacent room not already connected
 		j := 0
 		r2 := -1
-		for i := 0; i < MaxRooms; i++ {
-			if rdesConn[r1][i] && !isconn[r1][i] {
+
+		for i := range MaxRooms {
+			if g.data.rdesConn[r1][i] && !isconn[r1][i] {
 				if j++; g.rnd(j) == 0 {
 					r2 = i
 				}
@@ -75,19 +69,23 @@ func (g *RogueGame) doPassages() {
 		}
 		// if there is one, connect it and look for the next added passage
 		if j != 0 {
-			g.conn(r1, r2)
+			g.connectRooms(r1, r2)
 			isconn[r1][r2] = true
-			isconn[r2][r1] = true
+			isconn[r2][r1] = true //nolint:gosec // G602: rnd(MaxRooms) bounded
 		}
 	}
-	g.passnum()
+
+	g.numberPassages()
 }
 
-// conn draws a corridor from a room in a certain direction (passages.c
-// conn).
-func (g *RogueGame) conn(r1, r2 int) {
-	var rm int
-	var direc byte
+// connectRooms draws a corridor from a room in a certain direction
+// (passages.c conn).
+func (g *RogueGame) connectRooms(r1, r2 int) {
+	var (
+		rm    int
+		direc byte
+	)
+
 	if r1 < r2 {
 		rm = r1
 		if r1+1 == r2 {
@@ -103,42 +101,52 @@ func (g *RogueGame) conn(r1, r2 int) {
 			direc = 'd'
 		}
 	}
+
 	rpf := &g.Level.Rooms[rm]
 
 	// Set up the movement variables, in two cases: first drawing one down.
-	var rpt *Room
-	var del, turnDelta, spos, epos Coord
-	var distance, turnDistance int
+	var (
+		rpt                        *Room
+		del, turnDelta, spos, epos Coord
+		distance, turnDistance     int
+	)
+
 	if direc == 'd' {
 		rmt := rm + 3             // room # of dest
 		rpt = &g.Level.Rooms[rmt] // room pointer of dest
 		del = Coord{X: 0, Y: 1}   // direction of move
 		spos = rpf.Pos            // start of move
 		epos = rpt.Pos            // end of move
+
 		if !rpf.Flags.Has(Gone) { // if not gone pick door pos
 			for {
 				spos.X = rpf.Pos.X + g.rnd(rpf.Max.X-2) + 1
+
 				spos.Y = rpf.Pos.Y + rpf.Max.Y - 1
-				if !(rpf.Flags.Has(Maze) && !g.Level.FlagsAt(spos.Y, spos.X).Has(FPassage)) {
+				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)) {
+				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
@@ -146,29 +154,34 @@ func (g *RogueGame) conn(r1, r2 int) {
 		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)) {
+				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)) {
+				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)
 	}
@@ -180,12 +193,13 @@ func (g *RogueGame) conn(r1, r2 int) {
 	if !rpf.Flags.Has(Gone) {
 		g.door(rpf, spos)
 	} else {
-		g.putpass(spos)
+		g.putPassage(spos)
 	}
+
 	if !rpt.Flags.Has(Gone) {
 		g.door(rpt, epos)
 	} else {
-		g.putpass(epos)
+		g.putPassage(epos)
 	}
 	// Get ready to move...
 	curr := spos
@@ -196,27 +210,31 @@ func (g *RogueGame) conn(r1, r2 int) {
 		// 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.Y += turnDelta.Y
 			}
 		}
 		// Continue digging along
-		g.putpass(curr)
+		g.putPassage(curr)
+
 		distance--
 	}
+
 	curr.X += del.X
+
 	curr.Y += del.Y
 	if curr != epos {
 		g.msg("warning, connectivity problem on this level")
 	}
 }
 
-// putpass adds a passage character or secret passage here (passages.c
+// putPassage adds a passage character or secret passage here (passages.c
 // putpass).
-func (g *RogueGame) putpass(cp Coord) {
+func (g *RogueGame) putPassage(cp Coord) {
 	pp := g.Level.At(cp.Y, cp.X)
 	pp.Flags.Set(FPassage)
+
 	if g.rnd(10)+1 < g.Depth && g.rnd(40) == 0 {
 		pp.Flags.Clear(FReal)
 	} else {
@@ -240,6 +258,7 @@ func (g *RogueGame) door(rm *Room, cp Coord) {
 		} else {
 			pp.Ch = '|'
 		}
+
 		pp.Flags.Clear(FReal)
 	} else {
 		pp.Ch = Door
@@ -250,7 +269,7 @@ func (g *RogueGame) door(rm *Room, cp Coord) {
 // (passages.c add_pass).
 func (g *RogueGame) addPass() {
 	for y := 1; y < NumLines-1; y++ {
-		for x := 0; x < NumCols; x++ {
+		for x := range NumCols {
 			pp := g.Level.At(y, x)
 			if pp.Flags.Has(FPassage) || pp.Ch == Door ||
 				(!pp.Flags.Has(FReal) && (pp.Ch == '|' || pp.Ch == '-')) {
@@ -258,19 +277,24 @@ func (g *RogueGame) addPass() {
 				if pp.Flags.Has(FPassage) {
 					ch = Passage
 				}
+
 				pp.Flags.Set(FSeen)
 				g.move(y, x)
-				if pp.Monst != nil {
+
+				switch {
+				case pp.Monst != nil:
 					pp.Monst.OldCh = pp.Ch
-				} else if pp.Flags.Has(FReal) {
+				case pp.Flags.Has(FReal):
 					g.addch(ch)
-				} else {
+				default:
 					g.standout()
+
 					if pp.Flags.Has(FPassage) {
 						g.addch(Passage)
 					} else {
 						g.addch(Door)
 					}
+
 					g.standend()
 				}
 			}
@@ -278,32 +302,36 @@ func (g *RogueGame) addPass() {
 	}
 }
 
-// passnum assigns a number to each passageway (passages.c passnum).
-func (g *RogueGame) passnum() {
+// numberPassages assigns a number to each passageway (passages.c passnum).
+func (g *RogueGame) numberPassages() {
 	g.pnum = 0
+
 	g.newpnum = false
 	for i := range g.Level.Passages {
 		g.Level.Passages[i].Exits = g.Level.Passages[i].Exits[:0]
 	}
+
 	for i := range g.Level.Rooms {
 		rp := &g.Level.Rooms[i]
 		for j := range rp.Exits {
 			g.newpnum = true
-			g.numpass(rp.Exits[j].Y, rp.Exits[j].X)
+			g.numberPassage(rp.Exits[j].Y, rp.Exits[j].X)
 		}
 	}
 }
 
-// numpass numbers a passageway square and its brethren (passages.c
+// numberPassage numbers a passageway square and its brethren (passages.c
 // numpass).
-func (g *RogueGame) numpass(y, x int) {
+func (g *RogueGame) numberPassage(y, x int) {
 	if x >= NumCols || x < 0 || y >= NumLines || y <= 0 {
 		return
 	}
+
 	fp := g.Level.FlagsAt(y, x)
 	if fp.Has(FPassNum) {
 		return
 	}
+
 	if g.newpnum {
 		g.pnum++
 		g.newpnum = false
@@ -317,12 +345,13 @@ func (g *RogueGame) numpass(y, x int) {
 	} else if !fp.Has(FPassage) {
 		return
 	}
-	*fp |= PlaceFlags(g.pnum)
+
+	*fp |= PlaceFlags(g.pnum) //nolint:gosec // G115: pnum < MaxPass=13
 	// recurse on the surrounding places
-	g.numpass(y+1, x)
-	g.numpass(y-1, x)
-	g.numpass(y, x+1)
-	g.numpass(y, x-1)
+	g.numberPassage(y+1, x)
+	g.numberPassage(y-1, x)
+	g.numberPassage(y, x+1)
+	g.numberPassage(y, x-1)
 }
 
 // abs is C abs() for ints.
@@ -330,5 +359,6 @@ func abs(n int) int {
 	if n < 0 {
 		return -n
 	}
+
 	return n
 }

game/potions.go

@@ -13,56 +13,43 @@ type pact struct {
 	straight string
 }
 
-// pActions is potions.c p_actions[]. The P_SEEINVIS message is dynamic
-// (it names the fruit) and is computed in doPot.
-var pActions = [NumPotionTypes]pact{
-	PotionConfusion: {Confused, DUnconfuse, HuhDuration,
-		"what a tripy feeling!",
-		"wait, what's going on here. Huh? What? Who?"},
-	PotionLSD: {Hallucinating, DComeDown, SeeDuration,
-		"Oh, wow!  Everything seems so cosmic!",
-		"Oh, wow!  Everything seems so cosmic!"},
-	PotionSeeInvisible: {CanSeeInvisible, DUnsee, SeeDuration, "", ""},
-	PotionBlindness: {Blind, DSight, SeeDuration,
-		"oh, bummer!  Everything is dark!  Help!",
-		"a cloak of darkness falls around you"},
-	PotionLevitation: {Levitating, DLand, HealTime,
-		"oh, wow!  You're floating in the air!",
-		"you start to float in the air"},
-}
-
 // quaff drinks a potion from the pack (potions.c quaff).
 func (g *RogueGame) quaff() {
 	p := &g.Player
-	obj := g.getItem("quaff", KindPotion)
+	obj, ok := g.promptPackItem("quaff", KindPotion)
 	// Make certain that it is something that we want to drink
-	if obj == nil {
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindPotion {
 		if !g.Options.Terse {
 			g.msg("yuk! Why would you want to drink that?")
 		} else {
 			g.msg("that's undrinkable")
 		}
+
 		return
 	}
+
 	if obj == p.CurWeapon {
 		p.CurWeapon = nil
 	}
 
 	// Calculate the effect it has on the poor guy.
 	trip := p.On(Hallucinating)
+
 	g.leavePack(obj, false, false)
+
 	switch obj.PotionKind() {
 	case PotionConfusion:
-		g.doPot(PotionConfusion, !trip)
+		g.applyPotionFuse(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.changeStrength(-(g.rnd(3) + 1))
 			g.msg("you feel very sick now")
 			g.comeDown(0)
 		}
@@ -72,15 +59,17 @@ func (g *RogueGame) quaff() {
 			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.changeStrength(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"))
@@ -88,24 +77,30 @@ func (g *RogueGame) quaff() {
 	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() {
+				if g.isMagic(tp) {
 					show = true
+
 					g.scr.Hw.MvAddCh(tp.Pos.Y, tp.Pos.X, Magic)
 					g.Items.Potions[PotionDetectMagic].Know = true
 				}
 			}
+
 			for _, mp := range g.Level.Monsters {
 				for _, tp := range mp.Pack {
-					if tp.isMagic() {
+					if g.isMagic(tp) {
 						show = true
+
 						g.scr.Hw.MvAddCh(mp.Pos.Y, mp.Pos.X, Magic)
 					}
 				}
 			}
 		}
+
 		if show {
 			g.Items.Potions[PotionDetectMagic].Know = true
 			g.showWin("You sense the presence of magic on this level.--More--")
@@ -118,16 +113,21 @@ func (g *RogueGame) quaff() {
 			if p.On(SenseMonsters) {
 				g.turnSee(false)
 			}
+
 			g.StartDaemon(DVisuals, 0, Before)
 			g.SeenStairs = g.seenStairs()
 		}
-		g.doPot(PotionLSD, true)
+
+		g.applyPotionFuse(PotionLSD, true)
 	case PotionSeeInvisible:
 		show := p.On(CanSeeInvisible)
-		g.doPot(PotionSeeInvisible, false)
+
+		g.applyPotionFuse(PotionSeeInvisible, false)
+
 		if !show {
 			g.invisOn()
 		}
+
 		g.sight(0)
 	case PotionRaiseLevel:
 		g.Items.Potions[PotionRaiseLevel].Know = true
@@ -139,14 +139,17 @@ func (g *RogueGame) quaff() {
 			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")
@@ -155,24 +158,30 @@ func (g *RogueGame) quaff() {
 		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)
+		g.applyPotionFuse(PotionBlindness, true)
 	case PotionLevitation:
-		g.doPot(PotionLevitation, true)
+		g.applyPotionFuse(PotionLevitation, true)
 	}
+
 	g.status()
 	// Throw the item away
 	g.callIt(&g.Items.Potions[obj.Which])
@@ -181,17 +190,18 @@ func (g *RogueGame) quaff() {
 // 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
-// flag (potions.c do_pot).
-func (g *RogueGame) doPot(kind PotionKind, knowit bool) {
-	pp := &pActions[kind]
+// applyPotionFuse does a potion with standard setup: it uses a fuse and
+// turns on a flag (potions.c do_pot).
+func (g *RogueGame) applyPotionFuse(kind PotionKind, knowit bool) {
+	pp := &g.data.pActions[kind]
 	if !g.Items.Potions[kind].Know {
 		g.Items.Potions[kind].Know = knowit
 	}
+
 	t := g.spread(pp.time)
 	if !g.Player.On(pp.flags) {
 		g.Player.Flags.Set(pp.flags)
@@ -200,24 +210,28 @@ func (g *RogueGame) doPot(kind PotionKind, knowit bool) {
 	} else {
 		g.Lengthen(pp.daemon, t)
 	}
+
 	high, straight := pp.high, pp.straight
+
 	if kind == PotionSeeInvisible {
 		s := fmt.Sprintf("this potion tastes like %s juice", g.Fruit)
 		high, straight = s, s
 	}
+
 	g.msg("%s", g.chooseStr(high, straight))
 }
 
 // isMagic reports whether an object radiates magic (potions.c is_magic).
-func (o *Object) isMagic() bool {
+func (g *RogueGame) isMagic(o *Object) bool {
 	switch o.Kind {
 	case KindArmor:
-		return o.Flags.Has(Protected) || o.ArmorClass != aClass[o.Which]
+		return o.Flags.Has(Protected) || o.ArmorClass != g.data.aClass[o.Which]
 	case KindWeapon:
 		return o.HPlus != 0 || o.DPlus != 0
 	case KindPotion, KindScroll, KindWand, KindRing, KindAmulet:
 		return true
 	}
+
 	return false
 }
 
@@ -225,6 +239,7 @@ func (o *Object) isMagic() bool {
 // invis_on).
 func (g *RogueGame) invisOn() {
 	g.Player.Flags.Set(CanSeeInvisible)
+
 	for _, mp := range g.Level.Monsters {
 		if mp.On(Invisible) && g.seeMonst(mp) && !g.Player.On(Hallucinating) {
 			g.mvaddch(mp.Pos.Y, mp.Pos.X, mp.Disguise)
@@ -236,8 +251,10 @@ func (g *RogueGame) invisOn() {
 // turn_see).
 func (g *RogueGame) turnSee(turnOff bool) bool {
 	addNew := false
+
 	for _, mp := range g.Level.Monsters {
 		g.move(mp.Pos.Y, mp.Pos.X)
+
 		canSee := g.seeMonst(mp)
 		if turnOff {
 			if !canSee {
@@ -247,22 +264,27 @@ func (g *RogueGame) turnSee(turnOff bool) bool {
 			if !canSee {
 				g.standout()
 			}
+
 			if !g.Player.On(Hallucinating) {
 				g.addch(mp.Type)
 			} else {
-				g.addch(byte(g.rnd(26) + 'A'))
+				g.addch(g.randomMonsterLetter())
 			}
+
 			if !canSee {
 				g.standend()
+
 				addNew = true
 			}
 		}
 	}
+
 	if turnOff {
 		g.Player.Flags.Clear(SenseMonsters)
 	} else {
 		g.Player.Flags.Set(SenseMonsters)
 	}
+
 	return addNew
 }
 
@@ -271,9 +293,11 @@ func (g *RogueGame) turnSee(turnOff bool) bool {
 func (g *RogueGame) seenStairs() bool {
 	st := g.Level.Stairs
 	g.move(st.Y, st.X)
+
 	if g.inch() == Stairs { // it's on the map
 		return true
 	}
+
 	if g.Player.Pos == st { // it's under him
 		return true
 	}
@@ -282,9 +306,11 @@ func (g *RogueGame) seenStairs() bool {
 		if g.seeMonst(tp) && tp.On(Awake) { // visible and awake:
 			return true // it must have moved there
 		}
+
 		if g.Player.On(SenseMonsters) && tp.OldCh == Stairs {
 			return true
 		}
 	}
+
 	return false
 }

game/rings.go

@@ -7,17 +7,19 @@ 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("it would be difficult to wrap that around a finger")
 		} else {
 			g.msg("not a ring")
 		}
+
 		return
 	}
 
@@ -27,6 +29,7 @@ func (g *RogueGame) ringOn() {
 	}
 
 	var ring int
+
 	switch {
 	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
 		if ring = g.gethand(); ring < 0 {
@@ -42,14 +45,16 @@ func (g *RogueGame) ringOn() {
 		} else {
 			g.msg("wearing two")
 		}
+
 		return
 	}
+
 	p.CurRing[ring] = obj
 
 	// Calculate the effect it has on the poor guy.
 	switch obj.RingKind() {
 	case RingAddStrength:
-		g.chgStr(obj.Bonus)
+		g.changeStrength(obj.Bonus)
 	case RingSeeInvisible:
 		g.invisOn()
 	case RingAggravateMonsters:
@@ -57,15 +62,18 @@ func (g *RogueGame) ringOn() {
 	}
 
 	if !g.Options.Terse {
-		g.addmsg("you are now wearing ")
+		g.addmsgf("you are now wearing ")
 	}
-	g.msg("%s (%c)", g.invName(obj, true), obj.PackCh)
+
+	g.msg("%s (%c)", g.inventoryName(obj, true), obj.PackCh)
 }
 
 // ringOff takes off a ring (rings.c ring_off).
 func (g *RogueGame) ringOff() {
 	p := &g.Player
+
 	var ring int
+
 	switch {
 	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
 		if g.Options.Terse {
@@ -73,6 +81,7 @@ func (g *RogueGame) ringOff() {
 		} else {
 			g.msg("you aren't wearing any rings")
 		}
+
 		return
 	case p.CurRing[Left] == nil:
 		ring = Right
@@ -83,14 +92,18 @@ func (g *RogueGame) ringOff() {
 			return
 		}
 	}
+
 	g.Msgs.Mpos = 0
+
 	obj := p.CurRing[ring]
 	if obj == nil {
 		g.msg("not wearing such a ring")
+
 		return
 	}
+
 	if g.dropCheck(obj) {
-		g.msg("was wearing %s(%c)", g.invName(obj, true), obj.PackCh)
+		g.msg("was wearing %s(%c)", g.inventoryName(obj, true), obj.PackCh)
 	}
 }
 
@@ -102,17 +115,22 @@ func (g *RogueGame) gethand() int {
 		} else {
 			g.msg("left hand or right hand? ")
 		}
+
 		c := g.readchar()
 		if c == Escape {
 			return -1
 		}
+
 		g.Msgs.Mpos = 0
+
 		if c == 'l' || c == 'L' {
 			return Left
 		}
+
 		if c == 'r' || c == 'R' {
 			return Right
 		}
+
 		if g.Options.Terse {
 			g.msg("L or R")
 		} else {
@@ -121,25 +139,6 @@ func (g *RogueGame) gethand() int {
 	}
 }
 
-// ringUses is the rings.c ring_eat static uses[] table: how much food each
-// ring type uses up per turn (negative = a 1-in-n chance of 1).
-var ringUses = [NumRingTypes]int{
-	1,  // R_PROTECT
-	1,  // R_ADDSTR
-	1,  // R_SUSTSTR
-	-3, // R_SEARCH
-	-5, // R_SEEINVIS
-	0,  // R_NOP
-	0,  // R_AGGR
-	-3, // R_ADDHIT
-	-3, // R_ADDDAM
-	2,  // R_REGEN
-	-2, // R_DIGEST
-	0,  // R_TELEPORT
-	1,  // R_STEALTH
-	1,  // R_SUSTARM
-}
-
 // ringEat reports how much food the ring on the given hand uses up
 // (rings.c ring_eat).
 func (g *RogueGame) ringEat(hand int) int {
@@ -147,7 +146,8 @@ func (g *RogueGame) ringEat(hand int) int {
 	if ring == nil {
 		return 0
 	}
-	eat := ringUses[ring.RingKind()]
+
+	eat := g.data.ringUses[ring.RingKind()]
 	if eat < 0 {
 		if g.rnd(-eat) == 0 {
 			eat = 1
@@ -155,20 +155,25 @@ func (g *RogueGame) ringEat(hand int) int {
 			eat = 0
 		}
 	}
+
 	if ring.RingKind() == RingSlowDigestion {
 		eat = -eat
 	}
+
 	return eat
 }
 
-// ringNum prints ring bonuses (rings.c ring_num).
-func ringNum(g *RogueGame, obj *Object) string {
+// ringNum prints ring bonuses (rings.c ring_num). The unused game
+// parameter keeps the nameit prfunc signature.
+func ringNum(_ *RogueGame, obj *Object) string {
 	if !obj.Flags.Has(Known) {
 		return ""
 	}
+
 	switch obj.RingKind() {
 	case RingProtection, RingAddStrength, RingIncreaseDamage, RingDexterity:
 		return fmt.Sprintf(" [%s]", num(obj.Bonus, 0, Ring))
 	}
+
 	return ""
 }

game/rip.go

@@ -11,67 +11,65 @@ import (
 // that Run recovers, so the terminal is restored by normal unwinding.
 
 // gameEnd is the sentinel carried by the panic that replaces my_exit().
-type gameEnd struct{ status int }
+type gameEnd struct{}
 
 // myExit leaves the process properly (main.c my_exit): it unwinds to Run.
-func (g *RogueGame) myExit(st int) {
+// Every C caller exited with status 0; abnormal exits panic for real.
+func (g *RogueGame) myExit() {
 	g.Playing = false
-	panic(gameEnd{status: st})
-}
 
-var ripArt = []string{
-	"                       __________",
-	"                      /          \\",
-	"                     /    REST    \\",
-	"                    /      IN      \\",
-	"                   /     PEACE      \\",
-	"                  /                  \\",
-	"                  |                  |",
-	"                  |                  |",
-	"                  |   killed by a    |",
-	"                  |                  |",
-	"                  |       1980       |",
-	"                 *|     *  *  *      | *",
-	"         ________)/\\\\_//(\\/(/\\)/\\//\\/|_)_______",
+	panic(gameEnd{})
 }
 
 // death does something really fun when he dies (rip.c death).
 func (g *RogueGame) death(monst byte) {
 	p := &g.Player
 	p.Purse -= p.Purse / 10
+
 	g.clear()
+
 	killer := g.killname(monst, false)
 	if !g.Options.Tombstone {
-		g.scr.Std.MvPrintw(NumLines-2, 0, "Killed by ")
+		g.scr.Std.MvPrintwf(NumLines-2, 0, "Killed by ")
+
 		if monst != 's' && monst != 'h' {
 			g.printw("a%s ", vowelstr(killer))
 		}
+
 		g.printw("%s with %d gold", killer, p.Purse)
 	} else {
 		year := time.Now().Year()
-		for i, line := range ripArt {
+
+		for i, line := range g.data.ripArt {
 			g.scr.Std.MvAddStr(8+i, 0, line)
 		}
+
 		g.mvaddstr(17, center(killer), killer)
+
 		if monst == 's' || monst == 'h' {
 			g.mvaddch(16, 32, ' ')
 		} else {
 			g.mvaddstr(16, 33, vowelstr(killer))
 		}
+
 		g.mvaddstr(14, center(g.Whoami), g.Whoami)
+
 		au := fmt.Sprintf("%d Au", p.Purse)
 		g.mvaddstr(15, center(au), au)
 		g.mvaddstr(18, 26, fmt.Sprintf("%4d", year))
 	}
+
 	g.mvaddstr(NumLines-1, 0, "[Press return to continue]")
 	g.refresh()
+
 	flags := 0
 	if g.HasAmulet {
 		flags = 3
 	}
+
 	g.score(p.Purse, flags, monst)
 	g.waitFor('\n')
-	g.myExit(0)
+	g.myExit()
 }
 
 // center returns the column to center the given string on the tombstone
@@ -85,6 +83,7 @@ func (g *RogueGame) totalWinner() {
 	p := &g.Player
 	g.clear()
 	g.standout()
+
 	banner := []string{
 		"                                                               ",
 		"  @   @               @   @           @          @@@  @     @  ",
@@ -100,6 +99,7 @@ func (g *RogueGame) totalWinner() {
 	for i, line := range banner {
 		g.scr.Std.MvAddStr(i, 0, line)
 	}
+
 	g.standend()
 	g.scr.Std.MvAddStr(10, 0, "You have joined the elite ranks of those who have escaped the")
 	g.scr.Std.MvAddStr(11, 0, "Dungeons of Doom alive.  You journey home and sell all your loot at")
@@ -110,11 +110,14 @@ func (g *RogueGame) totalWinner() {
 	g.clear()
 	g.mvaddstr(0, 0, "   Worth  Item")
 	g.move(1, 0)
+
 	oldpurse := p.Purse
 	line := 1
+
 	for _, obj := range p.Pack {
 		worth := 0
 		it := &g.Items
+
 		switch obj.Kind {
 		case KindFood:
 			worth = 2 * obj.Count
@@ -125,25 +128,30 @@ func (g *RogueGame) totalWinner() {
 		case KindArmor:
 			worth = it.Armors[obj.Which].Worth
 			worth += (9 - obj.ArmorClass) * 100
-			worth += 10 * (aClass[obj.Which] - obj.ArmorClass)
+			worth += 10 * (g.data.aClass[obj.Which] - obj.ArmorClass)
 			obj.Flags.Set(Known)
 		case KindScroll:
 			op := &it.Scrolls[obj.Which]
+
 			worth = 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 {
@@ -152,67 +160,74 @@ func (g *RogueGame) totalWinner() {
 					worth = 10
 				}
 			}
+
 			if !obj.Flags.Has(Known) {
 				worth /= 2
 			}
+
 			obj.Flags.Set(Known)
+
 			op.Know = true
 		case KindWand:
 			op := &it.Sticks[obj.Which]
 			worth = op.Worth
+
 			worth += 20 * obj.Charges
 			if !obj.Flags.Has(Known) {
 				worth /= 2
 			}
+
 			obj.Flags.Set(Known)
+
 			op.Know = true
 		case KindAmulet:
 			worth = 1000
 		}
+
 		if worth < 0 {
 			worth = 0
 		}
-		g.scr.Std.MvPrintw(line, 0, "%c) %5d  %s", obj.PackCh, worth,
-			g.invName(obj, false))
+
+		g.scr.Std.MvPrintwf(line, 0, "%c) %5d  %s", obj.PackCh, worth,
+			g.inventoryName(obj, false))
 		line++
 		p.Purse += worth
 	}
-	g.scr.Std.MvPrintw(line, 0, "   %5d  Gold Pieces          ", oldpurse)
+
+	g.scr.Std.MvPrintwf(line, 0, "   %5d  Gold Pieces          ", oldpurse)
 	g.refresh()
 	g.score(p.Purse, 2, ' ')
-	g.myExit(0)
-}
-
-// killnameTable is the rip.c nlist[]: special death causes.
-var killnameTable = []helpEntry{
-	{'a', "arrow", true},
-	{'b', "bolt", true},
-	{'d', "dart", true},
-	{'h', "hypothermia", false},
-	{'s', "starvation", false},
+	g.myExit()
 }
 
 // killname converts a code to a monster name (rip.c killname).
 func (g *RogueGame) killname(monst byte, doart bool) string {
-	var sp string
-	var article bool
+	var (
+		sp      string
+		article bool
+	)
+
 	if isUpper(monst) {
 		sp = g.Monsters[monst-'A'].Name
 		article = true
 	} else {
 		sp = "Wally the Wonder Badger"
 		article = false
-		for _, hp := range killnameTable {
+
+		for _, hp := range g.data.killnameTable {
 			if hp.Ch == monst {
 				sp = hp.Desc
 				article = hp.Print
+
 				break
 			}
 		}
 	}
+
 	if doart && article {
 		return "a" + vowelstr(sp) + " " + sp
 	}
+
 	return sp
 }
 
@@ -224,13 +239,16 @@ func (g *RogueGame) DeathDemo() {
 			if _, ok := r.(gameEnd); ok {
 				return
 			}
+
 			panic(r)
 		}
 	}()
+
 	dnum := g.rnd(100)
 	for dnum--; dnum > 0; dnum-- {
 		g.rnd(100)
 	}
+
 	g.Player.Purse = g.rnd(100) + 1
 	g.Depth = g.rnd(100) + 1
 	g.death(g.deathMonst())
@@ -245,5 +263,6 @@ func (g *RogueGame) deathMonst() byte {
 		'Y', 'Z', 'a', 'b', 'h', 'd', 's',
 		' ', // generates the "Wally the Wonder Badger" message
 	}
+
 	return poss[g.rnd(len(poss))]
 }

game/rng.go

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

game/rng_test.go

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

game/rooms.go

@@ -17,10 +17,11 @@ type mazeState struct {
 
 const goldGrp = 1
 
-// doRooms creates rooms and corridors with a connectivity graph (rooms.c
+// digRooms creates rooms and corridors with a connectivity graph (rooms.c
 // do_rooms).
-func (g *RogueGame) doRooms() {
+func (g *RogueGame) digRooms() {
 	var bsze Coord // maximum room size
+
 	bsze.X = NumCols / 3
 	bsze.Y = NumLines / 3
 	// Clear things for a new level
@@ -32,14 +33,15 @@ func (g *RogueGame) doRooms() {
 	}
 	// Put the gone rooms, if any, on the level
 	leftOut := g.rnd(4)
-	for i := 0; i < leftOut; i++ {
-		g.Level.Rooms[g.rndRoom()].Flags.Set(Gone)
+	for range leftOut {
+		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]
 		// Find upper left corner of box that this room goes in
 		top := Coord{X: (i%3)*bsze.X + 1, Y: (i / 3) * bsze.Y}
+
 		if rp.Flags.Has(Gone) {
 			// Place a gone room.  Make certain that there is a blank line
 			// for passage drawing.
@@ -47,16 +49,19 @@ func (g *RogueGame) doRooms() {
 				rp.Pos.X = top.X + g.rnd(bsze.X-2) + 1
 				rp.Pos.Y = top.Y + g.rnd(bsze.Y-2) + 1
 				rp.Max.X = -NumCols
+
 				rp.Max.Y = -NumLines
 				if rp.Pos.Y > 0 && rp.Pos.Y < NumLines-1 {
 					break
 				}
 			}
+
 			continue
 		}
 		// set room type
 		if g.rnd(10) < g.Depth-1 {
 			rp.Flags.Set(Dark) // dark room
+
 			if g.rnd(15) == 0 {
 				rp.Flags = Maze // maze room
 			}
@@ -64,10 +69,12 @@ func (g *RogueGame) doRooms() {
 		// 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
 			if rp.Pos.X = top.X; rp.Pos.X == 1 {
 				rp.Pos.X = 0
 			}
+
 			if rp.Pos.Y = top.Y; rp.Pos.Y == 0 {
 				rp.Pos.Y++
 				rp.Max.Y--
@@ -77,12 +84,14 @@ func (g *RogueGame) doRooms() {
 				rp.Max.X = g.rnd(bsze.X-4) + 4
 				rp.Max.Y = g.rnd(bsze.Y-4) + 4
 				rp.Pos.X = top.X + g.rnd(bsze.X-rp.Max.X)
+
 				rp.Pos.Y = top.Y + g.rnd(bsze.Y-rp.Max.Y)
 				if rp.Pos.Y != 0 {
 					break
 				}
 			}
 		}
+
 		g.drawRoom(rp)
 		// Put the gold in
 		if g.rnd(2) == 0 && (!g.HasAmulet || g.Depth >= g.MaxDepth) {
@@ -92,16 +101,18 @@ func (g *RogueGame) doRooms() {
 			rp.Gold, _ = g.findFloorIn(rp, 0, false)
 			gold.Pos = rp.Gold
 			g.Level.SetChar(rp.Gold.Y, rp.Gold.X, Gold)
+
 			gold.Flags = Stackable
 			gold.Group = goldGrp
 			gold.Kind = KindGold
-			attachObj(&g.Level.Objects, gold)
+			g.Level.AddObject(gold)
 		}
 		// Put the monster in
 		prob := 25
 		if rp.GoldVal > 0 {
 			prob = 80
 		}
+
 		if g.rnd(100) < prob {
 			tp := &Monster{}
 			mp, _ := g.findFloorIn(rp, 0, true)
@@ -115,9 +126,11 @@ 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
 	}
+
 	g.vert(rp, rp.Pos.X)             // Draw left side
 	g.vert(rp, rp.Pos.X+rp.Max.X-1)  // Draw right side
 	g.horiz(rp, rp.Pos.Y)            // Draw top
@@ -145,8 +158,8 @@ func (g *RogueGame) horiz(rp *Room, starty int) {
 	}
 }
 
-// doMaze digs a maze (rooms.c do_maze).
-func (g *RogueGame) doMaze(rp *Room) {
+// digMaze digs a maze (rooms.c do_maze).
+func (g *RogueGame) digMaze(rp *Room) {
 	m := &g.maze
 	for y := range m.maze {
 		for x := range m.maze[y] {
@@ -162,7 +175,7 @@ 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)
 }
 
@@ -173,26 +186,34 @@ func (g *RogueGame) dig(y, x int) {
 
 	for {
 		cnt := 0
+
 		var nexty, nextx int
+
 		for _, cp := range del {
 			newy := y + cp.Y
+
 			newx := x + cp.X
 			if newy < 0 || newy > m.maxy || newx < 0 || newx > m.maxx {
 				continue
 			}
+
 			if g.Level.FlagsAt(newy+m.starty, newx+m.startx).Has(FPassage) {
 				continue
 			}
+
 			if cnt++; g.rnd(cnt) == 0 {
 				nexty = newy
 				nextx = newx
 			}
 		}
+
 		if cnt == 0 {
 			return
 		}
-		g.accntMaze(y, x, nexty, nextx)
-		g.accntMaze(nexty, nextx, y, x)
+
+		g.accountMaze(y, x, nexty, nextx)
+		g.accountMaze(nexty, nextx, y, x)
+
 		var pos Coord
 		if nexty == y {
 			pos.Y = y + m.starty
@@ -209,18 +230,19 @@ func (g *RogueGame) dig(y, x int) {
 				pos.Y = nexty + m.starty - 1
 			}
 		}
-		g.putpass(pos)
+
+		g.putPassage(pos)
 		pos.Y = nexty + m.starty
 		pos.X = nextx + m.startx
-		g.putpass(pos)
+		g.putPassage(pos)
 		g.dig(nexty, nextx)
 	}
 }
 
-// accntMaze accounts for maze exits (rooms.c accnt_maze).
-func (g *RogueGame) accntMaze(y, x, ny, nx int) {
+// accountMaze accounts for maze exits (rooms.c accnt_maze).
+func (g *RogueGame) accountMaze(y, x, ny, nx int) {
 	sp := &g.maze.maze[y][x]
-	for i := 0; i < sp.nexits; i++ {
+	for i := range sp.nexits {
 		if sp.exits[i].Y == ny && sp.exits[i].X == nx {
 			return
 		}
@@ -233,18 +255,21 @@ func (g *RogueGame) accntMaze(y, x, ny, nx int) {
 	}
 }
 
-// rndPos picks a random spot in a room (rooms.c rnd_pos).
-func (g *RogueGame) rndPos(rp *Room) Coord {
+// randomPos picks a random spot in a room (rooms.c rnd_pos).
+func (g *RogueGame) randomPos(rp *Room) Coord {
 	var cp Coord
+
 	cp.X = rp.Pos.X + g.rnd(rp.Max.X-2) + 1
 	cp.Y = rp.Pos.Y + g.rnd(rp.Max.Y-2) + 1
+
 	return cp
 }
 
 // findFloor finds a valid floor spot, picking a new random room each time
-// around the loop (rooms.c find_floor with rp == NULL).
-func (g *RogueGame) findFloor(rp *Room, limit int, monst bool) (Coord, bool) {
-	return g.findFloorImpl(rp, limit, monst, rp == nil)
+// around the loop; it retries forever (rooms.c find_floor with rp == NULL
+// — every such C call site passed FALSE for the limit).
+func (g *RogueGame) findFloor(monst bool) (Coord, bool) {
+	return g.findFloorImpl(nil, 0, monst, true)
 }
 
 // findFloorIn finds a valid floor spot in this room (rooms.c find_floor
@@ -261,6 +286,7 @@ func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Co
 			compchar = Passage
 		}
 	}
+
 	cnt := limit
 	for {
 		if limit != 0 {
@@ -268,14 +294,18 @@ func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Co
 				return Coord{}, false
 			}
 		}
+
 		if pickroom {
-			rp = &g.Level.Rooms[g.rndRoom()]
+			rp = &g.Level.Rooms[g.randomRoom()]
+
 			compchar = Floor
 			if rp.Flags.Has(Maze) {
 				compchar = Passage
 			}
 		}
-		cp := g.rndPos(rp)
+
+		cp := g.randomPos(rp)
+
 		pp := g.Level.At(cp.Y, cp.X)
 		if monst {
 			if pp.Monst == nil && stepOk(pp.Ch) {
@@ -291,14 +321,17 @@ func (g *RogueGame) findFloorImpl(rp *Room, limit int, monst, pickroom bool) (Co
 // enter_room).
 func (g *RogueGame) enterRoom(cp Coord) {
 	p := &g.Player
-	rp := g.roomin(cp)
+	rp := g.roomIn(cp)
 	p.Room = rp
 	g.doorOpen(rp)
+
 	if !rp.Flags.Has(Dark) && !p.On(Blind) {
 		for y := rp.Pos.Y; y < rp.Max.Y+rp.Pos.Y; y++ {
 			g.move(y, rp.Pos.X)
+
 			for x := rp.Pos.X; x < rp.Max.X+rp.Pos.X; x++ {
 				tp := g.Level.MonsterAt(y, x)
+
 				ch := g.Level.Char(y, x)
 				if tp == nil {
 					if g.inch() != ch {
@@ -335,6 +368,7 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 	}
 
 	var floor byte
+
 	switch {
 	case rp.Flags.Has(Gone):
 		floor = Passage
@@ -348,6 +382,7 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 	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)
+
 			switch ch := g.inch(); ch {
 			case Floor:
 				if floor == ' ' {
@@ -361,8 +396,10 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 						g.standout()
 						g.addch(ch)
 						g.standend()
+
 						break
 					}
+
 					pp := g.Level.At(y, x)
 					if pp.Ch == Door {
 						g.addch(Door)
@@ -373,5 +410,6 @@ func (g *RogueGame) leaveRoom(cp Coord) {
 			}
 		}
 	}
+
 	g.doorOpen(rp)
 }

game/run_test.go

@@ -9,21 +9,27 @@ import (
 // moves, a rest, an inventory, then Q-quit answered yes.
 func TestRunScriptedSession(t *testing.T) {
 	tt := &testTerm{input: []byte("hjkl.i Qy")}
+
 	g := NewGame(Config{Seed: 99, Term: tt})
-	if err := g.Run(); err != nil {
+
+	err := g.Run()
+	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
+
 	if g.Playing {
 		t.Error("still playing after quit")
 	}
 	// After quitting, the scoreboard is the last thing shown (in C it went
 	// to stdout after endwin; here it is drawn on the screen).
 	found := false
-	for y := 0; y < NumLines; y++ {
+
+	for y := range NumLines {
 		if strings.Contains(g.scr.Std.Line(y), "Top Ten") {
 			found = true
 		}
 	}
+
 	if !found {
 		t.Error("score list not on screen after quit")
 	}
@@ -36,17 +42,23 @@ func TestRunManyTurns(t *testing.T) {
 	// Spaces between commands double as answers to any --More-- prompts;
 	// without them a single prompt would swallow the rest of the script
 	// (wait_for eats everything that isn't a space).
-	var script []byte
-	moves := []byte("h h j j k k l l y u b n s s . . ")
+	moves := []byte("h j k l y u b n s .")
+	script := make([]byte, 0, len(moves)*200+7)
+
 	for range 200 {
 		script = append(script, moves...)
 	}
+
 	script = append(script, " Q y Qy"...)
 	tt := &testTerm{input: script}
+
 	g := NewGame(Config{Seed: 31337, Term: tt})
-	if err := g.Run(); err != nil {
+
+	err := g.Run()
+	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
+
 	if g.Playing {
 		t.Error("session did not end")
 	}
@@ -65,9 +77,12 @@ func TestRunDownStairs(t *testing.T) {
 	g.StartDaemon(DDoctor, 0, After)
 	g.Fuse(DSwander, 0, wanderTime(g), After)
 	g.StartDaemon(DStomach, 0, After)
-	if err := g.Run(); err != nil {
+
+	err := g.Run()
+	if err != nil {
 		t.Fatalf("Run: %v", err)
 	}
+
 	if g.Depth != 2 {
 		t.Errorf("depth = %d after descending, want 2", g.Depth)
 	}
@@ -79,26 +94,33 @@ func TestSaveCommandRoundTrip(t *testing.T) {
 	// The C get_str caps input at MAXINP=50 characters, so the save path
 	// must be short: work from the temp directory.
 	t.Chdir(t.TempDir())
+
 	path := "cmd.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
-	if err := g.Run(); err != nil {
-		t.Fatalf("Run: %v", err)
+
+	runErr := g.Run()
+	if runErr != nil {
+		t.Fatalf("Run: %v", runErr)
 	}
 
 	h, err := Restore(path, Config{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")
 	}
 	// The restored game must be playable.
-	h.scr.term.(*testTerm).input = []byte("..Qy")
-	if err := h.Run(); err != nil {
-		t.Fatalf("restored Run: %v", err)
+	setInput(t, h, []byte("..Qy")...)
+
+	restoredErr := h.Run()
+	if restoredErr != nil {
+		t.Fatalf("restored Run: %v", restoredErr)
 	}
 }

game/save.go

@@ -2,6 +2,7 @@ package game
 
 import (
 	"encoding/gob"
+	"errors"
 	"fmt"
 	"os"
 )
@@ -131,16 +132,19 @@ func (g *RogueGame) roomIdx(rp *Room) int {
 	if rp == nil {
 		return -1
 	}
+
 	for i := range g.Level.Rooms {
 		if rp == &g.Level.Rooms[i] {
 			return i
 		}
 	}
+
 	for i := range g.Level.Passages {
 		if rp == &g.Level.Passages[i] {
 			return 100 + i
 		}
 	}
+
 	return -1
 }
 
@@ -152,6 +156,7 @@ func (g *RogueGame) roomAt(i int) *Room {
 	case i >= 0:
 		return &g.Level.Rooms[i]
 	}
+
 	return nil
 }
 
@@ -160,11 +165,13 @@ func (g *RogueGame) packIdx(obj *Object) int {
 	if obj == nil {
 		return -1
 	}
+
 	for i, o := range g.Player.Pack {
 		if o == obj {
 			return i
 		}
 	}
+
 	return -1
 }
 
@@ -266,9 +273,11 @@ func (g *RogueGame) snapshot() *SaveState {
 		for _, o := range m.Pack {
 			sc.Pack = append(sc.Pack, *o)
 		}
+
 		st.Monsters = append(st.Monsters, sc)
 
 		ref := destRef{}
+
 		switch {
 		case m.Dest == nil:
 		case m.Dest == &p.Pos:
@@ -279,6 +288,7 @@ func (g *RogueGame) snapshot() *SaveState {
 					ref = destRef{Kind: 2, Idx: mi}
 				}
 			}
+
 			if ref.Kind == 0 {
 				for _, oo := range g.Level.Objects {
 					if m.Dest == &oo.Pos {
@@ -286,6 +296,7 @@ func (g *RogueGame) snapshot() *SaveState {
 					}
 				}
 			}
+
 			if ref.Kind == 0 {
 				for ri := range g.Level.Rooms {
 					if m.Dest == &g.Level.Rooms[ri].Gold {
@@ -294,8 +305,10 @@ func (g *RogueGame) snapshot() *SaveState {
 				}
 			}
 		}
+
 		st.Dests = append(st.Dests, ref)
 	}
+
 	return st
 }
 
@@ -371,15 +384,18 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	p.Flags = sp.Body.Flags
 	p.Stats = sp.Body.Stats
 	p.Room = g.roomAt(sp.Body.RoomIdx)
+
 	p.Pack = nil
 	for i := range sp.Body.Pack {
 		o := sp.Body.Pack[i]
 		p.Pack = append(p.Pack, &o)
 	}
+
 	pick := func(i int) *Object {
 		if i < 0 || i >= len(p.Pack) {
 			return nil
 		}
+
 		return p.Pack[i]
 	}
 	p.CurArmor = pick(sp.CurArmor)
@@ -400,6 +416,7 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	g.Level.Monsters = nil
 	for i := range st.Monsters {
 		sc := &st.Monsters[i]
+
 		m := &Monster{Creature: Creature{
 			Pos: sc.Pos, Turn: sc.Turn, Type: sc.Type, Disguise: sc.Disguise,
 			OldCh: sc.OldCh, Flags: sc.Flags, Stats: sc.Stats,
@@ -409,11 +426,14 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 			o := sc.Pack[j]
 			m.Pack = append(m.Pack, &o)
 		}
+
 		g.Level.Monsters = append(g.Level.Monsters, m)
 		g.Level.SetMonsterAt(m.Pos.Y, m.Pos.X, m)
 	}
+
 	for i, ref := range st.Dests {
 		m := g.Level.Monsters[i]
+
 		switch ref.Kind {
 		case 1:
 			m.Dest = &p.Pos
@@ -429,30 +449,41 @@ func (g *RogueGame) applySnapshot(st *SaveState) {
 	g.scr.Std.SetContents(st.Screen)
 }
 
-// saveGame implements the "save game" command (save.c save_game). The C
-// goto over/gotfile flow becomes the useDefault flag.
+// saveGame implements the "save game" command (save.c save_game). The
+// labeled prompt loop and the useDefault flag stand in for the C
+// goto over/gotfile flow.
 func (g *RogueGame) saveGame() {
 	g.Msgs.Mpos = 0
-over:
+
+prompt:
+	for {
 		useDefault := false
+
 		if g.FileName != "" {
 			var c byte
+
 			for {
 				g.msg("save file (%s)? ", g.FileName)
 				c = g.readchar()
+
 				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
 			}
 		}
@@ -465,83 +496,120 @@ over:
 			} else {
 				g.Msgs.Mpos = 0
 				g.msg("file name: ")
+
 				if g.getStr(&buf, g.scr.Std) == Quit {
 					g.msg("")
+
 					return
 				}
+
 				g.Msgs.Mpos = 0
 			}
 			// test to see if the file exists
-		if _, err := os.Stat(buf); err == nil {
+			_, 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
+						continue prompt // the C goto over: start again
 					}
+
 					g.msg("Please answer Y or N")
 				}
+
 				g.msg("file name: %s", buf)
-			os.Remove(g.FileName)
+				_ = os.Remove(g.FileName) // best effort, as in C (md_unlink)
 			}
+
 			g.FileName = buf
-		if err := g.saveFile(g.FileName); err != nil {
+
+			err := g.saveFile(g.FileName)
+			if err != nil {
 				g.msg("%s", err.Error())
+
 				continue
 			}
-		break
+
+			break prompt
 		}
-	g.myExit(0)
+	}
+
+	g.myExit()
 }
 
-// saveFile writes the saved game (save.c save_file).
+// saveFile writes the saved game (save.c save_file). A failed write means
+// a corrupt save, so the file is removed before reporting the error.
 func (g *RogueGame) saveFile(path string) error {
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o400)
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o400) //nolint:gosec,lll // G304: user-chosen save path
 	if err != nil {
 		return err
 	}
-	defer f.Close()
-	if err := gob.NewEncoder(f).Encode(g.snapshot()); err != nil {
-		os.Remove(path)
-		return err
+
+	encErr := gob.NewEncoder(f).Encode(g.snapshot())
+	closeErr := f.Close()
+
+	if encErr != nil || closeErr != nil {
+		_ = os.Remove(path) // don't leave a corrupt save behind
+
+		if encErr != nil {
+			return encErr
 		}
+
+		return closeErr
+	}
+
 	return os.Chmod(path, 0o400)
 }
 
 // AutoSave silently saves to the current file name; used on SIGHUP/SIGTERM
-// (save.c auto_save).
+// (save.c auto_save). Best effort by design: it runs on the way out of a
+// dying process.
 func (g *RogueGame) AutoSave() {
 	if g.FileName != "" {
-		os.Remove(g.FileName)
-		g.saveFile(g.FileName)
+		_ = os.Remove(g.FileName)
+		_ = g.saveFile(g.FileName)
 	}
 }
 
+// ErrSaveOutOfDate reports a save file from an incompatible version.
+var ErrSaveOutOfDate = errors.New("sorry, saved game is out of date")
+
 // Restore restores a saved game from a file (save.c restore). The file is
 // deleted, as in C, to defeat restarting from the same save.
 func Restore(path string, cfg Config) (*RogueGame, error) {
-	f, err := os.Open(path)
+	f, err := os.Open(path) //nolint:gosec // G304: the save path is user-chosen by design
 	if err != nil {
 		return nil, err
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }() // read-only handle
+
 	var st SaveState
-	if err := gob.NewDecoder(f).Decode(&st); err != nil {
-		return nil, fmt.Errorf("%s: corrupt or incompatible save file: %w", path, err)
+
+	decErr := gob.NewDecoder(f).Decode(&st)
+	if decErr != nil {
+		return nil, fmt.Errorf("%s: corrupt or incompatible save file: %w",
+			path, decErr)
 	}
+
 	if st.Version != saveFormatVersion {
-		return nil, fmt.Errorf("sorry, saved game is out of date")
+		return nil, ErrSaveOutOfDate
 	}
 
 	g := &RogueGame{
+		data:      newGameData(),
 		Rng:       &Rng{},
 		Playing:   true,
 		ScorePath: cfg.ScorePath,
@@ -550,11 +618,14 @@ func Restore(path string, cfg Config) (*RogueGame, error) {
 		restored:  true,
 	}
 	g.scr = NewScreen(cfg.Term)
+	g.Msgs.attach(g.scr, g.look, g.readchar)
 	g.applySnapshot(&st)
 
 	// defeat multiple restarting from the same place
-	if err := os.Remove(path); err != nil {
-		return nil, fmt.Errorf("cannot unlink file: %w", err)
+	rmErr := os.Remove(path)
+	if rmErr != nil {
+		return nil, fmt.Errorf("cannot unlink file: %w", rmErr)
 	}
+
 	return g, nil
 }

game/save_test.go

@@ -15,6 +15,7 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 	g.HasAmulet = true
 	g.Items.Potions[PotionHealing].Know = true
 	g.Items.Scrolls[ScrollMagicMapping].Guess = "map???"
+
 	g.Monsters['F'-'A'].Stats.Dmg = dice("3x1") // mutated bestiary must survive
 	if len(g.Level.Monsters) > 0 {
 		g.Level.Monsters[0].Flags.Set(Awake)
@@ -22,8 +23,10 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 	}
 
 	path := filepath.Join(t.TempDir(), "rogue.save")
-	if err := g.saveFile(path); err != nil {
-		t.Fatalf("saveFile: %v", err)
+
+	saveErr := g.saveFile(path)
+	if saveErr != nil {
+		t.Fatalf("saveFile: %v", saveErr)
 	}
 
 	h, err := Restore(path, Config{Term: &testTerm{}})
@@ -31,7 +34,8 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 		t.Fatalf("Restore: %v", err)
 	}
 
-	if _, err := os.Stat(path); !os.IsNotExist(err) {
+	_, statErr := os.Stat(path)
+	if !os.IsNotExist(statErr) {
 		t.Error("save file not deleted on restore (C anti-restart rule)")
 	}
 
@@ -39,36 +43,46 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 		t.Errorf("player state lost: purse=%d food=%d",
 			h.Player.Purse, h.Player.FoodLeft)
 	}
+
 	if !h.HasAmulet {
 		t.Error("amulet flag lost")
 	}
+
 	if !h.Items.Potions[PotionHealing].Know {
 		t.Error("potion identification lost")
 	}
+
 	if h.Items.Scrolls[ScrollMagicMapping].Guess != "map???" {
 		t.Error("scroll guess lost")
 	}
+
 	if h.Monsters['F'-'A'].Stats.Dmg.String() != "3x1" {
 		t.Error("mutated bestiary lost")
 	}
+
 	if h.Rng.Seed != g.Rng.Seed {
 		t.Error("RNG state lost")
 	}
+
 	if renderMap(h) != renderMap(g) {
 		t.Error("restored level map differs")
 	}
+
 	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 {
 		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")
 		}
@@ -81,13 +95,17 @@ func TestSaveRestoreRoundTrip(t *testing.T) {
 		len(st.Player.Body.Pack))
 	t.Logf("restored: CurWeapon=%p pack has %d items", h.Player.CurWeapon,
 		len(h.Player.Pack))
+
 	found := false
+
 	for i, o := range h.Player.Pack {
 		t.Logf("  pack[%d]=%p type=%v which=%d", i, o, o.Kind, o.Which)
+
 		if o == h.Player.CurWeapon {
 			found = true
 		}
 	}
+
 	if !found {
 		t.Error("restored CurWeapon is not aliased into the pack")
 	}
@@ -98,15 +116,24 @@ func TestRestoreRejectsWrongVersion(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "rogue.save")
 	st := g.snapshot()
 	st.Version = "0.0.0"
-	f, err := os.Create(path)
+
+	f, err := os.Create(path) //nolint:gosec // G304: test temp path
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := gob.NewEncoder(f).Encode(st); err != nil {
-		t.Fatal(err)
+
+	encErr := gob.NewEncoder(f).Encode(st)
+	if encErr != nil {
+		t.Fatal(encErr)
 	}
-	f.Close()
-	if _, err := Restore(path, Config{}); err == nil {
+
+	closeErr := f.Close()
+	if closeErr != nil {
+		t.Fatal(closeErr)
+	}
+
+	_, restoreErr := Restore(path, Config{})
+	if restoreErr == nil {
 		t.Error("restore accepted an out-of-date save")
 	}
 }

game/score.go

@@ -25,29 +25,28 @@ type ScoreEnt struct {
 	Time    int64
 }
 
-var scoreReasons = [4]string{
-	"killed",
-	"quit",
-	"A total winner",
-	"killed with Amulet",
-}
-
 // rdScore reads the scoreboard file (save.c rd_score).
 func (g *RogueGame) rdScore() []ScoreEnt {
 	topTen := make([]ScoreEnt, numScores)
 	if g.ScorePath == "" {
 		return topTen
 	}
+
 	f, err := os.Open(g.ScorePath)
 	if err != nil {
 		return topTen
 	}
-	defer f.Close()
+	defer func() { _ = f.Close() }() // read-only handle
+
 	var onDisk []ScoreEnt
-	if err := gob.NewDecoder(f).Decode(&onDisk); err != nil {
-		return topTen
+
+	decErr := gob.NewDecoder(f).Decode(&onDisk)
+	if decErr != nil {
+		return topTen // unreadable scoreboard reads as empty, as in C
 	}
+
 	copy(topTen, onDisk)
+
 	return topTen
 }
 
@@ -57,29 +56,45 @@ func (g *RogueGame) wrScore(topTen []ScoreEnt) {
 		return
 	}
 	// lock_sc/unlock_sc: exclusive-create lock file with stale takeover.
+	// The whole scoreboard write is best effort, as it was in C: a shared
+	// scoreboard must never take the game down.
 	lock := g.ScorePath + ".lck"
 	for range 5 {
-		lf, err := os.OpenFile(lock, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o644)
+		lf, err := os.OpenFile(lock, //nolint:gosec // G304: configured path
+			os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
 		if err == nil {
-			lf.Close()
-			defer os.Remove(lock)
+			_ = lf.Close()
+
+			defer func() { _ = os.Remove(lock) }()
+
 			break
 		}
-		if fi, serr := os.Stat(lock); serr == nil &&
-			time.Since(fi.ModTime()) > 10*time.Second {
-			os.Remove(lock)
+
+		fi, statErr := os.Stat(lock)
+		if statErr == nil && time.Since(fi.ModTime()) > staleLockAge {
+			_ = os.Remove(lock)
+
 			continue
 		}
+
 		time.Sleep(time.Second)
 	}
-	f, err := os.OpenFile(g.ScorePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
+
+	f, err := os.OpenFile(g.ScorePath,
+		os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
 	if err != nil {
 		return
 	}
-	defer f.Close()
-	gob.NewEncoder(f).Encode(topTen)
+
+	_ = gob.NewEncoder(f).Encode(topTen)
+	_ = f.Close()
 }
 
+// staleLockAge is how old a scoreboard lock file may be before another
+// process assumes its owner died and takes it over (mach_dep.c lock_sc
+// aged its lock the same way).
+const staleLockAge = 10 * time.Second
+
 // score figures the score and posts it (rip.c score). flags -1 means just
 // display the list (the -s command line option).
 func (g *RogueGame) score(amount, flags int, monst byte) {
@@ -92,38 +107,47 @@ 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()
+
 		scp := len(topTen)
 		for i := range topTen {
 			if amount > topTen[i].Score {
 				scp = i
+
 				break
 			} else if !g.AllScore && flags != 2 &&
 				topTen[i].UID == uid && topTen[i].Flags != 2 {
 				// only one score per nowin uid
 				scp = len(topTen)
+
 				break
 			}
 		}
+
 		if scp < len(topTen) {
 			sc2 := len(topTen) - 1
 			if flags != 2 && !g.AllScore {
 				for i := scp; i < len(topTen); i++ {
 					if topTen[i].UID == uid && topTen[i].Flags != 2 {
 						sc2 = i
+
 						break
 					}
 				}
 			}
+
 			for sc2 > scp {
 				topTen[sc2] = topTen[sc2-1]
 				sc2--
 			}
+
 			lvl := g.Depth
 			if flags == 2 {
 				lvl = g.MaxDepth
 			}
+
 			topTen[scp] = ScoreEnt{
 				UID:     uid,
 				Score:   amount,
@@ -142,43 +166,53 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 	if g.AllScore {
 		label = "Scores"
 	}
+
 	lines := []string{
 		fmt.Sprintf("Top Ten %s:", label),
 		"   Score Name",
 	}
 	highlight := -1
+
 	for i := range topTen {
 		scp := &topTen[i]
 		if scp.Score == 0 {
 			break
 		}
+
 		line := fmt.Sprintf("%2d %5d %s: %s on level %d", i+1,
-			scp.Score, scp.Name, scoreReasons[scp.Flags], scp.Level)
+			scp.Score, scp.Name, g.data.scoreReasons[scp.Flags], scp.Level)
 		if scp.Flags == 0 || scp.Flags == 3 {
-			line += fmt.Sprintf(" by %s", g.killname(scp.Monster, true))
+			line += " by " + g.killname(scp.Monster, true)
 		}
+
 		line += "."
+
 		if i == ins {
 			highlight = len(lines)
 		}
+
 		lines = append(lines, line)
 	}
 
 	if g.scr != nil && g.scr.term != nil {
 		g.clear()
+
 		for i, line := range lines {
 			if i == highlight {
 				g.standout()
 			}
+
 			g.mvaddstr(i, 0, line)
+
 			if i == highlight {
 				g.standend()
 			}
 		}
+
 		g.refresh()
 	} else {
 		for _, line := range lines {
-			fmt.Println(line)
+			_, _ = fmt.Fprintln(os.Stdout, line) // CLI output
 		}
 	}
 

game/screen.go

@@ -37,26 +37,28 @@ type Window struct {
 func NewWindow(rows, cols int) *Window {
 	w := &Window{rows: rows, cols: cols, cells: make([]cell, rows*cols)}
 	w.Clear()
+
 	return w
 }
 
-func (w *Window) at(y, x int) *cell { return &w.cells[y*w.cols+x] }
-
 // Move positions the cursor (curses move/wmove).
 func (w *Window) Move(y, x int) { w.cy, w.cx = y, x }
 
 // GetYX reports the cursor position (curses getyx).
-func (w *Window) GetYX() (y, x int) { return w.cy, w.cx }
+func (w *Window) GetYX() (int, int) { return w.cy, w.cx }
 
 // AddCh writes a character at the cursor and advances it (curses addch).
 func (w *Window) AddCh(ch byte) {
 	if ch == '\n' {
 		w.cy, w.cx = w.cy+1, 0
+
 		return
 	}
+
 	if w.cy < 0 || w.cy >= w.rows || w.cx < 0 || w.cx >= w.cols {
 		return
 	}
+
 	*w.at(w.cy, w.cx) = cell{ch: ch, standout: w.standout}
 	if w.cx++; w.cx >= w.cols {
 		w.cx = 0
@@ -68,7 +70,7 @@ func (w *Window) AddCh(ch byte) {
 
 // AddStr writes a string at the cursor (curses addstr).
 func (w *Window) AddStr(s string) {
-	for i := 0; i < len(s); i++ {
+	for i := range len(s) {
 		w.AddCh(s[i])
 	}
 }
@@ -85,15 +87,15 @@ func (w *Window) MvAddStr(y, x int, s string) {
 	w.AddStr(s)
 }
 
-// Printw writes formatted text at the cursor (curses printw).
-func (w *Window) Printw(format string, a ...any) {
+// Printwf writes formatted text at the cursor (curses printw).
+func (w *Window) Printwf(format string, a ...any) {
 	w.AddStr(fmt.Sprintf(format, a...))
 }
 
-// MvPrintw moves then writes formatted text (curses mvprintw).
-func (w *Window) MvPrintw(y, x int, format string, a ...any) {
+// MvPrintwf moves then writes formatted text (curses mvprintw).
+func (w *Window) MvPrintwf(y, x int, format string, a ...any) {
 	w.Move(y, x)
-	w.Printw(format, a...)
+	w.Printwf(format, a...)
 }
 
 // Inch returns the character under the cursor (curses inch, sans
@@ -102,12 +104,14 @@ func (w *Window) Inch() byte {
 	if w.cy < 0 || w.cy >= w.rows || w.cx < 0 || w.cx >= w.cols {
 		return ' '
 	}
+
 	return w.at(w.cy, w.cx).ch
 }
 
 // MvInch moves then reads (curses mvinch).
 func (w *Window) MvInch(y, x int) byte {
 	w.Move(y, x)
+
 	return w.Inch()
 }
 
@@ -120,6 +124,7 @@ func (w *Window) Clear() {
 	for i := range w.cells {
 		w.cells[i] = cell{ch: ' '}
 	}
+
 	w.cy, w.cx = 0, 0
 }
 
@@ -128,6 +133,7 @@ func (w *Window) Clrtoeol() {
 	if w.cy < 0 || w.cy >= w.rows {
 		return
 	}
+
 	for x := w.cx; x < w.cols; x++ {
 		*w.at(w.cy, x) = cell{ch: ' '}
 	}
@@ -138,13 +144,14 @@ func (w *Window) CopyFrom(src *Window) {
 	copy(w.cells, src.cells)
 }
 
-// Size reports the window dimensions.
-func (w *Window) Size() (rows, cols int) { return w.rows, w.cols }
+// Size reports the window dimensions as rows, columns.
+func (w *Window) Size() (int, int) { return w.rows, w.cols }
 
 // CellAt reports the character and standout attribute at a position; used
 // by Terminal implementations to render the window.
-func (w *Window) CellAt(y, x int) (ch byte, standout bool) {
+func (w *Window) CellAt(y, x int) (byte, bool) {
 	c := w.at(y, x)
+
 	return c.ch, c.standout
 }
 
@@ -155,6 +162,7 @@ func (w *Window) Contents() []byte {
 	for i, c := range w.cells {
 		out[i] = c.ch
 	}
+
 	return out
 }
 
@@ -171,12 +179,16 @@ func (w *Window) SetContents(data []byte) {
 // victory screens.
 func (w *Window) Line(y int) string {
 	buf := make([]byte, w.cols)
-	for x := 0; x < w.cols; x++ {
+	for x := range w.cols {
 		buf[x] = w.at(y, x).ch
 	}
+
 	return string(buf)
 }
 
+// at addresses the cell at (y, x) in the backing array.
+func (w *Window) at(y, x int) *cell { return &w.cells[y*w.cols+x] }
+
 // Screen bundles the two windows the game draws on with the device that
 // shows them.
 type Screen struct {
@@ -217,7 +229,7 @@ func (g *RogueGame) mvaddch(y, x int, c byte) { g.scr.Std.MvAddCh(y, x, c) }
 func (g *RogueGame) mvaddstr(y, x int, s string) {
 	g.scr.Std.MvAddStr(y, x, s)
 }
-func (g *RogueGame) printw(f string, a ...any) { g.scr.Std.Printw(f, a...) }
+func (g *RogueGame) printw(f string, a ...any) { g.scr.Std.Printwf(f, a...) }
 func (g *RogueGame) inch() byte                { return g.scr.Std.Inch() }
 func (g *RogueGame) mvinch(y, x int) byte      { return g.scr.Std.MvInch(y, x) }
 func (g *RogueGame) standout()                 { g.scr.Std.Standout(true) }

game/scrolls.go

@@ -2,30 +2,23 @@ package game
 
 // scrolls.c — read a scroll and let it happen.
 
-// idType maps identify scrolls to the kind of item they identify
-// (scrolls.c static id_type).
-var idType = [ScrollIdentifyRingOrStick + 1]ObjectKind{
-	ScrollIdentifyPotion:      KindPotion,
-	ScrollIdentifyScroll:      KindScroll,
-	ScrollIdentifyWeapon:      KindWeapon,
-	ScrollIdentifyArmor:       KindArmor,
-	ScrollIdentifyRingOrStick: KindRingOrStick,
-}
-
 // readScroll reads a scroll from the pack and does the appropriate thing
 // (scrolls.c read_scroll).
 func (g *RogueGame) readScroll() {
 	p := &g.Player
-	obj := g.getItem("read", KindScroll)
-	if obj == nil {
+
+	obj, ok := g.promptPackItem("read", KindScroll)
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindScroll {
 		if !g.Options.Terse {
 			g.msg("there is nothing on it to read")
 		} else {
 			g.msg("nothing to read")
 		}
+
 		return
 	}
 	// Calculate the effect it has on the poor guy.
@@ -50,30 +43,39 @@ func (g *RogueGame) readScroll() {
 		// 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.addmsg("the monster")
+			g.addmsgf("the monster")
+
 			if held > 1 {
-				g.addmsg("s around you")
+				g.addmsgf("s around you")
 			}
-			g.addmsg(" freeze")
+
+			g.addmsgf(" freeze")
+
 			if held == 1 {
-				g.addmsg("s")
+				g.addmsgf("s")
 			}
+
 			g.endmsg()
 			g.Items.Scrolls[ScrollHoldMonster].Know = true
 		} else {
@@ -83,13 +85,16 @@ func (g *RogueGame) readScroll() {
 		// 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.
@@ -99,16 +104,18 @@ func (g *RogueGame) readScroll() {
 				// Or anything else nasty
 				if ch := g.Level.VisibleChar(y, x); stepOk(ch) {
 					if ch == Scroll {
-						if fo := g.findObj(y, x); fo != nil && fo.ScrollKind() == ScrollScareMonster {
+						if fo := g.Level.ObjectAt(y, x); fo != nil && fo.ScrollKind() == ScrollScareMonster {
 							continue
 						}
 					}
+
 					if i++; g.rnd(i) == 0 {
 						mp = Coord{Y: y, X: x}
 					}
 				}
 			}
 		}
+
 		if i == 0 {
 			g.msg("you hear a faint cry of anguish in the distance")
 		} else {
@@ -119,17 +126,18 @@ func (g *RogueGame) readScroll() {
 		// Identify, let him figure something out
 		g.Items.Scrolls[obj.Which].Know = true
 		g.msg("this scroll is an %s scroll", g.Items.Scrolls[obj.Which].Name)
-		g.whatis(true, idType[obj.ScrollKind()])
+		g.whatis(true, g.data.idType[obj.ScrollKind()])
 	case ScrollMagicMapping:
 		// Scroll of magic mapping.
 		g.Items.Scrolls[ScrollMagicMapping].Know = true
 		g.msg("oh, now this scroll has a map on it")
 		// take all the things we want to keep hidden out of the window
 		for y := 1; y < NumLines-1; y++ {
-			for x := 0; x < NumCols; x++ {
+			for x := range NumCols {
 				pp := g.Level.At(y, x)
 				ch := pp.Ch
 				pass := false
+
 				switch ch {
 				case Door, Stairs:
 				case '-', '|':
@@ -168,13 +176,17 @@ func (g *RogueGame) readScroll() {
 						ch = ' '
 					}
 				}
+
 				if pass {
 					if !pp.Flags.Has(FReal) {
 						pp.Ch = Passage
 					}
+
 					pp.Flags.Set(FSeen | FReal)
+
 					ch = Passage
 				}
+
 				if ch != ' ' {
 					if tp := pp.Monst; tp != nil {
 						tp.OldCh = ch
@@ -190,13 +202,17 @@ func (g *RogueGame) readScroll() {
 	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--")
@@ -206,7 +222,9 @@ func (g *RogueGame) readScroll() {
 	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
 		}
@@ -215,11 +233,13 @@ func (g *RogueGame) readScroll() {
 			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"))
 		}
@@ -248,6 +268,7 @@ func (g *RogueGame) readScroll() {
 			g.msg("you feel a strange sense of loss")
 		}
 	}
+
 	g.look(true) // put the result of the scroll on the screen
 	g.status()
 

game/sticks.go

@@ -4,22 +4,34 @@ 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 := g.getItem("zap with", KindWand)
-	if obj == nil {
+
+	obj, ok := g.promptPackItem("zap with", KindWand)
+	if !ok {
 		return
 	}
+
 	if obj.Kind != KindWand {
 		g.After = false
 		g.msg("you can't zap with that!")
+
 		return
 	}
+
 	if obj.Charges == 0 {
 		g.msg("nothing happens")
+
 		return
 	}
+
 	switch obj.WandKind() {
 	case WandLight:
 		// Reddy Kilowatt wand.  Light up the room
@@ -30,10 +42,12 @@ func (g *RogueGame) doZap() {
 			p.Room.Flags.Clear(Dark)
 			// Light the room and put the player back up
 			g.enterRoom(p.Pos)
-			g.addmsg("the room is lit")
+			g.addmsgf("the room is lit")
+
 			if !g.Options.Terse {
-				g.addmsg(" by a shimmering %s light", g.pickColor("blue"))
+				g.addmsgf(" by a shimmering %s light", g.pickColor("blue"))
 			}
+
 			g.endmsg()
 		}
 	case WandDrainLife:
@@ -42,42 +56,53 @@ func (g *RogueGame) doZap() {
 		// 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) {
+
+				if g.canSee(y, x) {
 					g.mvaddch(y, x, tp.OldCh)
 				}
 			case WandPolymorph:
 				pp := tp.Pack
-				detachMon(&g.Level.Monsters, tp)
+				g.Level.RemoveMonster(tp)
+
 				if g.seeMonst(tp) {
 					g.mvaddch(y, x, g.Level.Char(y, x))
 				}
+
 				oldch := tp.OldCh
 				g.Delta.Y = y
 				g.Delta.X = x
-				monster = byte(g.rnd(26) + 'A')
+				monster = g.randomMonsterLetter()
 				g.newMonster(tp, monster, g.Delta)
+
 				if g.seeMonst(tp) {
 					g.mvaddch(y, x, monster)
 				}
+
 				tp.OldCh = oldch
+
 				tp.Pack = pp
 				if g.seeMonst(tp) {
 					g.Items.Sticks[WandPolymorph].Know = true
@@ -85,15 +110,17 @@ func (g *RogueGame) doZap() {
 			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(nil, 0, true)
+						newPos, _ = g.findFloor(true)
 						if newPos != p.Pos {
 							break
 						}
@@ -102,6 +129,7 @@ func (g *RogueGame) doZap() {
 					newPos.Y = p.Pos.Y + g.Delta.Y
 					newPos.X = p.Pos.X + g.Delta.X
 				}
+
 				tp.Dest = &p.Pos
 				tp.Flags.Set(Awake)
 				g.relocate(tp, newPos)
@@ -114,26 +142,31 @@ func (g *RogueGame) doZap() {
 		bolt.HurlDmg = dice("1x4")
 		bolt.HPlus = 100
 		bolt.DPlus = 1
+
 		bolt.Flags = Missile
 		if p.CurWeapon != nil {
 			bolt.Launch = WeaponKind(p.CurWeapon.Which)
 		}
+
 		g.doMotion(bolt, g.Delta.Y, g.Delta.X)
+
 		if tp := g.Level.MonsterAt(bolt.Pos.Y, bolt.Pos.X); tp != nil &&
 			!g.saveThrow(VsMagic, &tp.Stats) {
 			g.hitMonster(bolt.Pos, bolt)
 		} else if g.Options.Terse {
-			g.msg("missle vanishes")
+			g.msg("missle vanishes") //nolint:misspell // C's spelling, kept faithfully
 		} else {
-			g.msg("the missle vanishes with a puff of smoke")
+			g.msg("the missle vanishes with a puff of smoke") //nolint:misspell // C's spelling
 		}
 	case WandHasteMonster, WandSlowMonster:
 		y := p.Pos.Y
+
 		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) {
@@ -147,14 +180,17 @@ func (g *RogueGame) doZap() {
 				} else {
 					tp.Flags.Set(Slowed)
 				}
+
 				tp.Turn = true
 			}
+
 			g.Delta.Y = y
 			g.Delta.X = x
-			g.runto(g.Delta)
+			g.runTo(g.Delta)
 		}
 	case WandLightning, WandFire, WandCold:
 		var name string
+
 		switch obj.WandKind() {
 		case WandLightning:
 			name = "bolt"
@@ -163,10 +199,12 @@ func (g *RogueGame) doZap() {
 		default:
 			name = "ice"
 		}
+
 		g.fireBolt(p.Pos, &g.Delta, name)
 		g.Items.Sticks[obj.Which].Know = true
 	case WandNothing:
 	}
+
 	obj.Charges--
 }
 
@@ -178,8 +216,11 @@ func (g *RogueGame) drain() {
 	if g.Level.Char(p.Pos.Y, p.Pos.X) == Door {
 		corp = &g.Level.Passages[*g.Level.FlagsAt(p.Pos.Y, p.Pos.X)&FPassNum]
 	}
+
 	inpass := p.Room.Flags.Has(Gone)
+
 	var drainee []*Monster
+
 	for _, mp := range g.Level.Monsters {
 		if mp.Room == p.Room || mp.Room == corp ||
 			(inpass && g.Level.Char(mp.Pos.Y, mp.Pos.X) == Door &&
@@ -187,11 +228,14 @@ func (g *RogueGame) drain() {
 			drainee = append(drainee, mp)
 		}
 	}
+
 	cnt := len(drainee)
 	if cnt == 0 {
 		g.msg("you have a tingling feeling")
+
 		return
 	}
+
 	p.Stats.HP /= 2
 	cnt = p.Stats.HP / cnt
 	// Now zot all of the monsters
@@ -199,7 +243,7 @@ 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)
 		}
 	}
 }
@@ -217,7 +261,9 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 	bolt.HPlus = 100
 	bolt.DPlus = 0
 	g.Items.Weapons[WeaponFlame].Name = name
+
 	var dirch byte
+
 	switch dir.Y + dir.X {
 	case 0:
 		dirch = '/'
@@ -230,10 +276,12 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 	case 2, -2:
 		dirch = '\\'
 	}
+
 	pos := start
 	hitHero := !fromHero
 	used := false
 	changed := false
+
 	var spotpos []Coord
 	for len(spotpos) < BoltLength && !used {
 		pos.Y += dir.Y
@@ -241,6 +289,7 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 		spotpos = append(spotpos, pos)
 		ch := g.Level.VisibleChar(pos.Y, pos.X)
 		bounce := false
+
 		switch ch {
 		case Door:
 			// this code is necessary if the hero is on a door and he
@@ -252,37 +301,47 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 		case '|', '-', ' ':
 			bounce = true
 		}
+
 		if bounce {
 			if !changed {
 				hitHero = !hitHero
 			}
+
 			changed = false
 			dir.Y = -dir.Y
 			dir.X = -dir.X
 			spotpos = spotpos[:len(spotpos)-1]
+
 			g.msg("the %s bounces", name)
+
 			continue
 		}
+
 		if tp := g.Level.MonsterAt(pos.Y, pos.X); !hitHero && tp != nil {
 			hitHero = true
 			changed = !changed
+
 			tp.OldCh = g.Level.Char(pos.Y, pos.X)
 			if !g.saveThrow(VsMagic, &tp.Stats) {
 				bolt.Pos = pos
 				used = true
+
 				if tp.Type == 'D' && name == "flame" {
-					g.addmsg("the flame bounces")
+					g.addmsgf("the flame bounces")
+
 					if !g.Options.Terse {
-						g.addmsg(" off the dragon")
+						g.addmsgf(" off the dragon")
 					}
+
 					g.endmsg()
 				} else {
 					g.hitMonster(pos, bolt)
 				}
 			} else if ch != 'M' || tp.Disguise == 'M' {
 				if fromHero {
-					g.runto(pos)
+					g.runTo(pos)
 				}
+
 				if g.Options.Terse {
 					g.msg("%s misses", name)
 				} else {
@@ -292,6 +351,7 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 		} else if hitHero && pos == p.Pos {
 			hitHero = false
 			changed = !changed
+
 			if !g.save(VsMagic) {
 				if p.Stats.HP -= g.roll(6, 6); p.Stats.HP <= 0 {
 					if fromHero {
@@ -300,7 +360,9 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 						g.death(g.Level.MonsterAt(start.Y, start.X).Type)
 					}
 				}
+
 				used = true
+
 				if g.Options.Terse {
 					g.msg("the %s hits", name)
 				} else {
@@ -310,6 +372,7 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 				g.msg("the %s whizzes by you", name)
 			}
 		}
+
 		g.mvaddch(pos.Y, pos.X, dirch)
 		g.refresh()
 	}
@@ -321,11 +384,12 @@ func (g *RogueGame) fireBolt(start Coord, dir *Coord, name string) {
 
 // fixStick sets up a new wand or staff (sticks.c fix_stick).
 func (g *RogueGame) fixStick(cur *Object) {
-	if g.Items.WandType[cur.Which] == "staff" {
+	if g.Items.WandType[cur.Which] == staffName {
 		cur.Damage = dice("2x3")
 	} else {
 		cur.Damage = dice("1x1")
 	}
+
 	cur.HurlDmg = dice("1x1")
 
 	switch cur.WandKind() {
@@ -342,8 +406,10 @@ func chargeStr(g *RogueGame, obj *Object) string {
 	if !obj.Flags.Has(Known) {
 		return ""
 	}
+
 	if g.Options.Terse {
 		return fmt.Sprintf(" [%d]", obj.Charges)
 	}
+
 	return fmt.Sprintf(" [%d charges]", obj.Charges)
 }

game/tables.go

@@ -1,15 +1,141 @@
 package game
 
-// This file is the immutable data from extern.c and init.c: tables that are
-// never written after program start. Per-game mutable copies (the ObjInfo
-// tables, whose probabilities are re-summed and whose Know/Guess fields
-// change during play) are cloned into RogueGame.Items by NewGame.
+// tables.go — the static data tables the C game kept as file-scope globals
+// (extern.c, init.c, and assorted per-file statics). The port gathers them
+// into gameData: every RogueGame carries its own copy, so the package holds
+// no package-level state. Per-game mutable copies (the ObjInfo tables,
+// whose probabilities are re-summed and whose Know/Guess fields change
+// during play) are cloned into RogueGame.Items by NewGame.
 
-// initStats is the C INIT_STATS: the player's starting statistics.
-var initStats = Stats{Str: 16, Exp: 0, Lvl: 1, ArmorClass: 10, HP: 12, Dmg: dice("1x4"), MaxHP: 12}
+// helpEntry is rogue.h struct h_list.
+type helpEntry struct {
+	Ch    byte
+	Desc  string
+	Print bool
+}
 
-// aClass is extern.c a_class[]: armor class for each armor type.
-var aClass = [NumArmorTypes]int{
+// gameData is the bundle of static tables, built by newGameData and hung on
+// RogueGame as g.data. Nothing in it mutates during play: the one table the
+// C code writes to (the venus flytrap damage hack) operates on the game's
+// Monsters copy, not on this template.
+type gameData struct {
+	// initStats is the C INIT_STATS: the player's starting statistics.
+	initStats Stats
+
+	// aClass is extern.c a_class[]: armor class for each armor type.
+	aClass [NumArmorTypes]int
+
+	// eLevels is extern.c e_levels[]: experience thresholds per level; the
+	// zero terminates the table as in C.
+	eLevels []int
+
+	// trName is extern.c tr_name[]: names of the traps.
+	trName [NumTrapTypes]string
+
+	// invTName is extern.c inv_t_name[]: the inventory style names.
+	invTName []string
+
+	// monsterTable is extern.c monsters[26]: all monster kinds, indexed by
+	// letter - 'A'. Monster strength (XX in C) is always 10; HP (___ in C)
+	// is rolled from the level at creation time.
+	monsterTable [26]MonsterKind
+
+	// Base ObjInfo tables (extern.c). These are templates: NewGame copies
+	// them into ItemLore before initProbs converts Prob to cumulative form.
+	baseThings   [NumThings]ObjInfo
+	baseArmInfo  [NumArmorTypes]ObjInfo
+	basePotInfo  [NumPotionTypes]ObjInfo
+	baseRingInfo [NumRingTypes]ObjInfo
+	baseScrInfo  [NumScrollTypes]ObjInfo
+	baseWeapInfo [NumWeaponTypes + 1]ObjInfo
+	baseWsInfo   [NumWandTypes]ObjInfo
+
+	// rainbow is init.c rainbow[]: the possible potion colors.
+	rainbow []string
+
+	// sylls is init.c sylls[]: syllables for generated scroll names.
+	sylls []string
+
+	// stoneTable is init.c stones[]: ring stones and their worth.
+	stoneTable []Stone
+
+	// woods is init.c wood[]: what staffs are made of.
+	woods []string
+
+	// metals is init.c metal[]: what wands are made of.
+	metals []string
+
+	// helpStr is extern.c helpstr[]: the '?' command help text.
+	helpStr []helpEntry
+
+	// hNames are the strings for hitting; the first four are used when the
+	// player strikes, the second four for monsters (fight.c h_names).
+	hNames [8]string
+
+	// mNames are the strings for missing (fight.c m_names).
+	mNames [8]string
+
+	// strPlus adjusts hit probabilities due to strength (fight.c str_plus).
+	strPlus [32]int
+
+	// addDam adjusts damage done due to strength (fight.c add_dam).
+	addDam [32]int
+
+	// lvlMons and wandMons list monsters in rough order of vorpalness;
+	// zero entries in wandMons never wander (monsters.c).
+	lvlMons  [26]byte
+	wandMons [26]byte
+
+	// ringUses is the rings.c ring_eat static uses[] table: how much food
+	// each ring type uses up per turn (negative = a 1-in-n chance of 1).
+	ringUses [NumRingTypes]int
+
+	// initWeaps is the weapons.c init_dam[] table.
+	initWeaps [NumWeaponTypes]weaponSetup
+
+	// pActions is potions.c p_actions[]. The P_SEEINVIS message is dynamic
+	// (it names the fruit) and is computed in applyPotionFuse.
+	pActions [NumPotionTypes]pact
+
+	// idType maps identify scrolls to the kind of item they identify
+	// (scrolls.c static id_type).
+	idType [ScrollIdentifyRingOrStick + 1]ObjectKind
+
+	// rdesConn is the hardcoded 3x3 room adjacency matrix from
+	// passages.c do_passages.
+	rdesConn [MaxRooms][MaxRooms]bool
+
+	// thingList is misc.c rnd_thing()'s static table.
+	thingList []byte
+
+	// identList is command.c's static ident_list.
+	identList []helpEntry
+
+	// hungerStateName is io.c state_name[].
+	hungerStateName [4]string
+
+	// ripArt is the rip.c rip[] tombstone art.
+	ripArt []string
+
+	// killnameTable is the rip.c nlist[]: special death causes.
+	killnameTable []helpEntry
+
+	// scoreReasons is the rip.c reason[] scoreboard strings.
+	scoreReasons [4]string
+}
+
+// ripWall is the repeated blank wall line of the tombstone art.
+const ripWall = "                  |                  |"
+
+// newGameData builds the static tables. Each game gets a fresh copy, which
+// keeps the package free of globals.
+//
+//nolint:funlen,maintidx // a single composite literal holding every C data table
+func newGameData() *gameData {
+	return &gameData{
+		initStats: Stats{Str: 16, Exp: 0, Lvl: 1, ArmorClass: 10, HP: 12, Dmg: dice("1x4"), MaxHP: 12},
+
+		aClass: [NumArmorTypes]int{
 			8, // LEATHER
 			7, // RING_MAIL
 			7, // STUDDED_LEATHER
@@ -18,17 +144,14 @@ var aClass = [NumArmorTypes]int{
 			4, // SPLINT_MAIL
 			4, // BANDED_MAIL
 			3, // PLATE_MAIL
-}
+		},
 
-// eLevels is extern.c e_levels[]: experience thresholds per level; the
-// zero terminates the table as in C.
-var eLevels = []int{
+		eLevels: []int{
 			10, 20, 40, 80, 160, 320, 640, 1300, 2600, 5200, 13000, 26000,
 			50000, 100000, 200000, 400000, 800000, 2000000, 4000000, 8000000, 0,
-}
+		},
 
-// trName is extern.c tr_name[]: names of the traps.
-var trName = [NumTrapTypes]string{
+		trName: [NumTrapTypes]string{
 			"a trapdoor",
 			"an arrow trap",
 			"a sleeping gas trap",
@@ -37,15 +160,11 @@ var trName = [NumTrapTypes]string{
 			"a poison dart trap",
 			"a rust trap",
 			"a mysterious trap",
-}
+		},
 
-// invTName is extern.c inv_t_name[]: the inventory style names.
-var invTName = []string{"Overwrite", "Slow", "Clear"}
+		invTName: []string{"Overwrite", "Slow", "Clear"},
 
-// monsterTable is extern.c monsters[26]: all monster kinds, indexed by
-// letter - 'A'. Monster strength (XX in C) is always 10; HP (___ in C) is
-// rolled from the level at creation time.
-var monsterTable = [26]MonsterKind{
+		monsterTable: [26]MonsterKind{
 			/* Name             CARRY  FLAGS                          str exp  lvl arm hp  dmg */
 			{"aquator", 0, Mean, Stats{10, 20, 5, 2, 1, dice("0x0/0x0"), 0}},
 			{"bat", 0, Flying, Stats{10, 1, 1, 3, 1, dice("1x2"), 0}},
@@ -73,12 +192,9 @@ var monsterTable = [26]MonsterKind{
 			{"xeroc", 30, 0, Stats{10, 100, 7, 7, 1, dice("4x4"), 0}},
 			{"yeti", 30, 0, Stats{10, 50, 4, 6, 1, dice("1x6/1x6"), 0}},
 			{"zombie", 0, Mean, Stats{10, 6, 2, 8, 1, dice("1x8"), 0}},
-}
+		},
 
-// Base ObjInfo tables (extern.c). These are templates: NewGame copies them
-// into ItemLore before initProbs converts Prob to cumulative form.
-
-var baseThings = [NumThings]ObjInfo{
+		baseThings: [NumThings]ObjInfo{
 			{Prob: 26}, // potion
 			{Prob: 36}, // scroll
 			{Prob: 16}, // food
@@ -86,9 +202,9 @@ var baseThings = [NumThings]ObjInfo{
 			{Prob: 7},  // armor
 			{Prob: 4},  // ring
 			{Prob: 4},  // stick
-}
+		},
 
-var baseArmInfo = [NumArmorTypes]ObjInfo{
+		baseArmInfo: [NumArmorTypes]ObjInfo{
 			{Name: "leather armor", Prob: 20, Worth: 20},
 			{Name: "ring mail", Prob: 15, Worth: 25},
 			{Name: "studded leather armor", Prob: 15, Worth: 20},
@@ -97,9 +213,9 @@ var baseArmInfo = [NumArmorTypes]ObjInfo{
 			{Name: "splint mail", Prob: 10, Worth: 80},
 			{Name: "banded mail", Prob: 10, Worth: 90},
 			{Name: "plate mail", Prob: 5, Worth: 150},
-}
+		},
 
-var basePotInfo = [NumPotionTypes]ObjInfo{
+		basePotInfo: [NumPotionTypes]ObjInfo{
 			{Name: "confusion", Prob: 7, Worth: 5},
 			{Name: "hallucination", Prob: 8, Worth: 5},
 			{Name: "poison", Prob: 8, Worth: 5},
@@ -114,9 +230,9 @@ var basePotInfo = [NumPotionTypes]ObjInfo{
 			{Name: "restore strength", Prob: 13, Worth: 130},
 			{Name: "blindness", Prob: 5, Worth: 5},
 			{Name: "levitation", Prob: 6, Worth: 75},
-}
+		},
 
-var baseRingInfo = [NumRingTypes]ObjInfo{
+		baseRingInfo: [NumRingTypes]ObjInfo{
 			{Name: "protection", Prob: 9, Worth: 400},
 			{Name: "add strength", Prob: 9, Worth: 400},
 			{Name: "sustain strength", Prob: 5, Worth: 280},
@@ -131,9 +247,9 @@ var baseRingInfo = [NumRingTypes]ObjInfo{
 			{Name: "teleportation", Prob: 5, Worth: 30},
 			{Name: "stealth", Prob: 7, Worth: 470},
 			{Name: "maintain armor", Prob: 5, Worth: 380},
-}
+		},
 
-var baseScrInfo = [NumScrollTypes]ObjInfo{
+		baseScrInfo: [NumScrollTypes]ObjInfo{
 			{Name: "monster confusion", Prob: 7, Worth: 140},
 			{Name: "magic mapping", Prob: 4, Worth: 150},
 			{Name: "hold monster", Prob: 2, Worth: 180},
@@ -152,9 +268,9 @@ var baseScrInfo = [NumScrollTypes]ObjInfo{
 			{Name: "remove curse", Prob: 7, Worth: 105},
 			{Name: "aggravate monsters", Prob: 3, Worth: 20},
 			{Name: "protect armor", Prob: 2, Worth: 250},
-}
+		},
 
-var baseWeapInfo = [NumWeaponTypes + 1]ObjInfo{
+		baseWeapInfo: [NumWeaponTypes + 1]ObjInfo{
 			{Name: "mace", Prob: 11, Worth: 8},
 			{Name: "long sword", Prob: 11, Worth: 15},
 			{Name: "short bow", Prob: 12, Worth: 15},
@@ -165,9 +281,9 @@ var baseWeapInfo = [NumWeaponTypes + 1]ObjInfo{
 			{Name: "shuriken", Prob: 12, Worth: 5},
 			{Name: "spear", Prob: 12, Worth: 5},
 			{}, // DO NOT REMOVE: fake entry for dragon's breath
-}
+		},
 
-var baseWsInfo = [NumWandTypes]ObjInfo{
+		baseWsInfo: [NumWandTypes]ObjInfo{
 			{Name: "light", Prob: 12, Worth: 250},
 			{Name: "invisibility", Prob: 6, Worth: 5},
 			{Name: "lightning", Prob: 3, Worth: 330},
@@ -182,18 +298,17 @@ var baseWsInfo = [NumWandTypes]ObjInfo{
 			{Name: "teleport away", Prob: 6, Worth: 340},
 			{Name: "teleport to", Prob: 6, Worth: 50},
 			{Name: "cancellation", Prob: 5, Worth: 280},
-}
+		},
 
-// rainbow is init.c rainbow[]: the possible potion colors.
-var rainbow = []string{
+		rainbow: []string{
 			"amber", "aquamarine", "black", "blue", "brown", "clear", "crimson",
 			"cyan", "ecru", "gold", "green", "grey", "magenta", "orange", "pink",
 			"plaid", "purple", "red", "silver", "tan", "tangerine", "topaz",
 			"turquoise", "vermilion", "violet", "white", "yellow",
-}
+		},
 
-// sylls is init.c sylls[]: syllables for generated scroll names.
-var sylls = []string{
+		//nolint:misspell // "ther" is a C scroll syllable, kept faithfully
+		sylls: []string{
 			"a", "ab", "ag", "aks", "ala", "an", "app", "arg", "arze", "ash",
 			"bek", "bie", "bit", "bjor", "blu", "bot", "bu", "byt", "comp",
 			"con", "cos", "cre", "dalf", "dan", "den", "do", "e", "eep", "el",
@@ -210,10 +325,9 @@ var sylls = []string{
 			"uni", "ur", "val", "viv", "vly", "vom", "wah", "wed", "werg",
 			"wex", "whon", "wun", "xo", "y", "yot", "yu", "zant", "zeb", "zim",
 			"zok", "zon", "zum",
-}
+		},
 
-// stoneTable is init.c stones[]: ring stones and their worth.
-var stoneTable = []Stone{
+		stoneTable: []Stone{
 			{"agate", 25}, {"alexandrite", 40}, {"amethyst", 50},
 			{"carnelian", 40}, {"diamond", 300}, {"emerald", 300},
 			{"germanium", 225}, {"granite", 5}, {"garnet", 50},
@@ -223,35 +337,25 @@ var stoneTable = []Stone{
 			{"ruby", 350}, {"sapphire", 285}, {"stibotantalite", 200},
 			{"tiger eye", 50}, {"topaz", 60}, {"turquoise", 70},
 			{"taaffeite", 300}, {"zircon", 80},
-}
+		},
 
-// woods is init.c wood[]: what staffs are made of.
-var woods = []string{
+		woods: []string{
 			"avocado wood", "balsa", "bamboo", "banyan", "birch", "cedar",
 			"cherry", "cinnibar", "cypress", "dogwood", "driftwood", "ebony",
 			"elm", "eucalyptus", "fall", "hemlock", "holly", "ironwood",
 			"kukui wood", "mahogany", "manzanita", "maple", "oaken",
 			"persimmon wood", "pecan", "pine", "poplar", "redwood", "rosewood",
 			"spruce", "teak", "walnut", "zebrawood",
-}
+		},
 
-// metals is init.c metal[]: what wands are made of.
-var metals = []string{
+		metals: []string{
 			"aluminum", "beryllium", "bone", "brass", "bronze", "copper",
 			"electrum", "gold", "iron", "lead", "magnesium", "mercury",
 			"nickel", "pewter", "platinum", "steel", "silver", "silicon",
 			"tin", "titanium", "tungsten", "zinc",
-}
+		},
 
-// helpEntry is rogue.h struct h_list.
-type helpEntry struct {
-	Ch    byte
-	Desc  string
-	Print bool
-}
-
-// helpStr is extern.c helpstr[]: the '?' command help text.
-var helpStr = []helpEntry{
+		helpStr: []helpEntry{
 			{'?', "	prints help", true},
 			{'/', "	identify object", true},
 			{'h', "	left", true},
@@ -317,6 +421,173 @@ var helpStr = []helpEntry{
 			{'!', "	shell escape", true},
 			{'F', "<dir>	fight till either of you dies", true},
 			{'v', "	print version number", true},
+		},
+
+		hNames: [8]string{
+			" scored an excellent hit on ",
+			" hit ",
+			" have injured ",
+			" swing and hit ",
+			" scored an excellent hit on ",
+			" hit ",
+			" has injured ",
+			" swings and hits ",
+		},
+
+		mNames: [8]string{
+			" miss",
+			" swing and miss",
+			" barely miss",
+			" don't hit",
+			" misses",
+			" swings and misses",
+			" barely misses",
+			" doesn't hit",
+		},
+
+		strPlus: [32]int{
+			-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+			1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
+		},
+
+		addDam: [32]int{
+			-7, -6, -5, -4, -3, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3,
+			3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6,
+		},
+
+		lvlMons: [26]byte{
+			'K', 'E', 'B', 'S', 'H', 'I', 'R', 'O', 'Z', 'L', 'C', 'Q', 'A',
+			'N', 'Y', 'F', 'T', 'W', 'P', 'X', 'U', 'M', 'V', 'G', 'J', 'D',
+		},
+
+		wandMons: [26]byte{
+			'K', 'E', 'B', 'S', 'H', 0, 'R', 'O', 'Z', 0, 'C', 'Q', 'A',
+			0, 'Y', 0, 'T', 'W', 'P', 0, 'U', 'M', 'V', 'G', 'J', 0,
+		},
+
+		ringUses: [NumRingTypes]int{
+			1,  // R_PROTECT
+			1,  // R_ADDSTR
+			1,  // R_SUSTSTR
+			-3, // R_SEARCH
+			-5, // R_SEEINVIS
+			0,  // R_NOP
+			0,  // R_AGGR
+			-3, // R_ADDHIT
+			-3, // R_ADDDAM
+			2,  // R_REGEN
+			-2, // R_DIGEST
+			0,  // R_TELEPORT
+			1,  // R_STEALTH
+			1,  // R_SUSTARM
+		},
+
+		initWeaps: [NumWeaponTypes]weaponSetup{
+			{dice("2x4"), dice("1x3"), noWeapon, 0},                    // WeaponMace
+			{dice("3x4"), dice("1x2"), noWeapon, 0},                    // Long sword
+			{dice("1x1"), dice("1x1"), noWeapon, 0},                    // WeaponBow
+			{dice("1x1"), dice("2x3"), WeaponBow, Stackable | Missile}, // WeaponArrow
+			{dice("1x6"), dice("1x4"), noWeapon, Missile},              // WeaponDagger
+			{dice("4x4"), dice("1x2"), noWeapon, 0},                    // 2h sword
+			{dice("1x1"), dice("1x3"), noWeapon, Stackable | Missile},  // WeaponDart
+			{dice("1x2"), dice("2x4"), noWeapon, Stackable | Missile},  // Shuriken
+			{dice("2x3"), dice("1x6"), noWeapon, Missile},              // WeaponSpear
+		},
+
+		pActions: [NumPotionTypes]pact{
+			PotionConfusion: {Confused, DUnconfuse, HuhDuration,
+				"what a tripy feeling!",
+				"wait, what's going on here. Huh? What? Who?"},
+			PotionLSD: {Hallucinating, DComeDown, SeeDuration,
+				"Oh, wow!  Everything seems so cosmic!",
+				"Oh, wow!  Everything seems so cosmic!"},
+			PotionSeeInvisible: {CanSeeInvisible, DUnsee, SeeDuration, "", ""},
+			PotionBlindness: {Blind, DSight, SeeDuration,
+				"oh, bummer!  Everything is dark!  Help!",
+				"a cloak of darkness falls around you"},
+			PotionLevitation: {Levitating, DLand, HealTime,
+				"oh, wow!  You're floating in the air!",
+				"you start to float in the air"},
+		},
+
+		idType: [ScrollIdentifyRingOrStick + 1]ObjectKind{
+			ScrollIdentifyPotion:      KindPotion,
+			ScrollIdentifyScroll:      KindScroll,
+			ScrollIdentifyWeapon:      KindWeapon,
+			ScrollIdentifyArmor:       KindArmor,
+			ScrollIdentifyRingOrStick: KindRingOrStick,
+		},
+
+		rdesConn: [MaxRooms][MaxRooms]bool{
+			{false, true, false, true, false, false, false, false, false},
+			{true, false, true, false, true, false, false, false, false},
+			{false, true, false, false, false, true, false, false, false},
+			{true, false, false, false, true, false, true, false, false},
+			{false, true, false, true, false, true, false, true, false},
+			{false, false, true, false, true, false, false, false, true},
+			{false, false, false, true, false, false, false, true, false},
+			{false, false, false, false, true, false, true, false, true},
+			{false, false, false, false, false, true, false, true, false},
+		},
+
+		thingList: []byte{
+			Potion, Scroll, Ring, Stick, Food, Weapon, Armor, Stairs, Gold, Amulet,
+		},
+
+		identList: []helpEntry{
+			{'|', "wall of a room", false},
+			{'-', "wall of a room", false},
+			{Gold, goldName, false},
+			{Stairs, "a staircase", false},
+			{Door, "door", false},
+			{Floor, "room floor", false},
+			{PlayerCh, "you", false},
+			{Passage, "passage", false},
+			{Trap, "trap", false},
+			{Potion, potionName, false},
+			{Scroll, scrollName, false},
+			{Food, "food", false},
+			{Weapon, "weapon", false},
+			{' ', "solid rock", false},
+			{Armor, "armor", false},
+			{Amulet, "the Amulet of Yendor", false},
+			{Ring, ringName, false},
+			{Stick, "wand or staff", false},
+		},
+
+		hungerStateName: [4]string{"", "Hungry", "Weak", "Faint"},
+
+		ripArt: []string{
+			"                       __________",
+			"                      /          \\",
+			"                     /    REST    \\",
+			"                    /      IN      \\",
+			"                   /     PEACE      \\",
+			"                  /                  \\",
+			ripWall,
+			ripWall,
+			"                  |   killed by a    |",
+			ripWall,
+			"                  |       1980       |",
+			"                 *|     *  *  *      | *",
+			"         ________)/\\\\_//(\\/(/\\)/\\//\\/|_)_______",
+		},
+
+		killnameTable: []helpEntry{
+			{'a', "arrow", true},
+			{'b', "bolt", true},
+			{'d', "dart", true},
+			{'h', "hypothermia", false},
+			{'s', "starvation", false},
+		},
+
+		scoreReasons: [4]string{
+			"killed",
+			"quit",
+			"A total winner",
+			"killed with Amulet",
+		},
+	}
 }
 
 // Version strings (vers.c). The encstr/statlist XOR keys are not ported:

game/tables_test.go

@@ -9,16 +9,20 @@ func TestProbabilitiesSumTo100(t *testing.T) {
 		for _, oi := range info {
 			s += oi.Prob
 		}
+
 		return s
 	}
+
+	data := newGameData()
+
 	tables := map[string][]ObjInfo{
-		"things":  baseThings[:],
-		"potions": basePotInfo[:],
-		"scrolls": baseScrInfo[:],
-		"rings":   baseRingInfo[:],
-		"sticks":  baseWsInfo[:],
-		"weapons": baseWeapInfo[:NumWeaponTypes], // excludes the flame entry
-		"armor":   baseArmInfo[:],
+		"things":  data.baseThings[:],
+		"potions": data.basePotInfo[:],
+		"scrolls": data.baseScrInfo[:],
+		"rings":   data.baseRingInfo[:],
+		"sticks":  data.baseWsInfo[:],
+		"weapons": data.baseWeapInfo[:NumWeaponTypes], // excludes the flame entry
+		"armor":   data.baseArmInfo[:],
 	}
 	for name, tab := range tables {
 		if s := sum(tab); s != 100 {
@@ -29,10 +33,12 @@ func TestProbabilitiesSumTo100(t *testing.T) {
 
 func TestInitProbsCumulative(t *testing.T) {
 	g := NewGame(Config{Seed: 1})
+
 	last := g.Items.Potions[NumPotionTypes-1].Prob
 	if last != 100 {
 		t.Errorf("cumulative potion probability ends at %d, want 100", last)
 	}
+
 	for i := PotionKind(1); i < NumPotionTypes; i++ {
 		if g.Items.Potions[i].Prob < g.Items.Potions[i-1].Prob {
 			t.Errorf("potion probs not nondecreasing at %d", i)
@@ -43,27 +49,34 @@ func TestInitProbsCumulative(t *testing.T) {
 func TestNewGameRandomizesAppearances(t *testing.T) {
 	g := NewGame(Config{Seed: 12345})
 	seen := map[string]bool{}
+
 	for i, c := range g.Items.PotColors {
 		if c == "" {
 			t.Fatalf("potion %d has no color", i)
 		}
+
 		if seen[c] {
 			t.Errorf("potion color %q assigned twice", c)
 		}
+
 		seen[c] = true
 	}
+
 	for i, n := range g.Items.ScrNames {
 		if n == "" {
 			t.Fatalf("scroll %d has no name", i)
 		}
+
 		if len(n) > MaxNameLen+1 {
 			t.Errorf("scroll name %q longer than C buffer allows", n)
 		}
 	}
+
 	for i := range g.Items.WandType {
 		if g.Items.WandType[i] != "wand" && g.Items.WandType[i] != "staff" {
 			t.Errorf("stick %d has type %q", i, g.Items.WandType[i])
 		}
+
 		if g.Items.WandMade[i] == "" {
 			t.Errorf("stick %d has no material", i)
 		}
@@ -77,10 +90,12 @@ func TestNewGameRandomizesAppearances(t *testing.T) {
 }
 
 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

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

game/things.go

@@ -9,15 +9,17 @@ import (
 
 // invName returns the name of something as it would appear in an inventory
 // (things.c inv_name).
-func (g *RogueGame) invName(obj *Object, drop bool) string {
+func (g *RogueGame) inventoryName(obj *Object, drop bool) string {
 	var pb strings.Builder
+
 	which := obj.Which
 	it := &g.Items
+
 	switch obj.Kind {
 	case KindPotion:
-		g.nameit(&pb, obj, "potion", it.PotColors[which], &it.Potions[which], nullstr)
+		g.nameit(&pb, obj, potionName, it.PotColors[which], &it.Potions[which], nullstr)
 	case KindRing:
-		g.nameit(&pb, obj, "ring", it.RingStones[which], &it.Rings[which], ringNum)
+		g.nameit(&pb, obj, ringName, it.RingStones[which], &it.Rings[which], ringNum)
 	case KindWand:
 		g.nameit(&pb, obj, it.WandType[which], it.WandMade[which], &it.Sticks[which], chargeStr)
 	case KindScroll:
@@ -26,12 +28,15 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 		} else {
 			fmt.Fprintf(&pb, "%d scrolls ", obj.Count)
 		}
+
 		op := &it.Scrolls[which]
-		if op.Know {
+
+		switch {
+		case op.Know:
 			fmt.Fprintf(&pb, "of %s", op.Name)
-		} else if op.Guess != "" {
+		case op.Guess != "":
 			fmt.Fprintf(&pb, "called %s", op.Guess)
-		} else {
+		default:
 			fmt.Fprintf(&pb, "titled '%s'", it.ScrNames[which])
 		}
 	case KindFood:
@@ -50,33 +55,40 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 		}
 	case KindWeapon:
 		sp := it.Weapons[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)
 		}
 	case KindArmor:
 		sp := it.Armors[which].Name
 		if obj.Flags.Has(Known) {
-			fmt.Fprintf(&pb, "%s %s [", num(aClass[which]-obj.ArmorClass, 0, Armor), sp)
+			fmt.Fprintf(&pb, "%s %s [", num(g.data.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)
 		}
@@ -87,20 +99,25 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 	}
 
 	out := pb.String()
+
 	if g.InvDescribe {
 		p := &g.Player
 		if obj == p.CurArmor {
 			out += " (being worn)"
 		}
+
 		if obj == p.CurWeapon {
 			out += " (weapon in hand)"
 		}
-		if obj == p.CurRing[Left] {
+
+		switch obj {
+		case p.CurRing[Left]:
 			out += " (on left hand)"
-		} else if obj == p.CurRing[Right] {
+		case p.CurRing[Right]:
 			out += " (on right hand)"
 		}
 	}
+
 	if out != "" {
 		if drop && isUpper(out[0]) {
 			out = string(toLower(out[0])) + out[1:]
@@ -108,6 +125,7 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 			out = string(toUpper(out[0])) + out[1:]
 		}
 	}
+
 	return out
 }
 
@@ -115,29 +133,36 @@ func (g *RogueGame) invName(obj *Object, drop bool) string {
 // leavePack/detach vocabulary collision).
 func (g *RogueGame) dropIt() {
 	p := &g.Player
+
 	ch := g.Level.Char(p.Pos.Y, p.Pos.X)
 	if ch != Floor && ch != Passage {
 		g.After = false
 		g.msg("there is something there already")
+
 		return
 	}
-	obj := g.getItem("drop", KindNone)
-	if obj == nil {
+
+	obj, ok := g.promptPackItem("drop", KindNone)
+	if !ok {
 		return
 	}
+
 	if !g.dropCheck(obj) {
 		return
 	}
+
 	obj = g.leavePack(obj, true, !obj.Kind.MergesInPack())
 	// Link it into the level object list
-	attachObj(&g.Level.Objects, obj)
+	g.Level.AddObject(obj)
 	g.Level.SetChar(p.Pos.Y, p.Pos.X, obj.Kind.Glyph())
 	g.Level.FlagsAt(p.Pos.Y, p.Pos.X).Set(FDropped)
+
 	obj.Pos = p.Pos
 	if obj.Kind == KindAmulet {
 		g.HasAmulet = false
 	}
-	g.msg("dropped %s", g.invName(obj, true))
+
+	g.msg("dropped %s", g.inventoryName(obj, true))
 }
 
 // dropCheck does special checks for dropping or unwielding|unwearing|
@@ -146,34 +171,43 @@ func (g *RogueGame) dropCheck(obj *Object) bool {
 	if obj == nil {
 		return true
 	}
+
 	p := &g.Player
 	if obj != p.CurArmor && obj != p.CurWeapon &&
 		obj != p.CurRing[Left] && obj != p.CurRing[Right] {
 		return true
 	}
+
 	if obj.Flags.Has(Cursed) {
 		g.msg("you can't.  It appears to be cursed")
+
 		return false
 	}
-	if obj == p.CurWeapon {
+
+	switch obj {
+	case p.CurWeapon:
 		p.CurWeapon = nil
-	} else if obj == p.CurArmor {
+	case p.CurArmor:
 		g.wasteTime()
+
 		p.CurArmor = nil
-	} else {
+	default:
 		hand := Right
 		if obj == p.CurRing[Left] {
 			hand = Left
 		}
+
 		p.CurRing[hand] = nil
+
 		switch obj.RingKind() {
 		case RingAddStrength:
-			g.chgStr(-obj.Bonus)
+			g.changeStrength(-obj.Bonus)
 		case RingSeeInvisible:
 			g.unsee(0)
 			g.Extinguish(DUnsee)
 		}
 	}
+
 	return true
 }
 
@@ -193,6 +227,7 @@ func (g *RogueGame) newThing() *Object {
 	} else {
 		kind = pickOne(g, g.Items.Things[:])
 	}
+
 	switch kind {
 	case 0:
 		cur.Kind = KindPotion
@@ -202,6 +237,7 @@ func (g *RogueGame) newThing() *Object {
 		cur.Which = pickOne(g, g.Items.Scrolls[:])
 	case 2:
 		cur.Kind = KindFood
+
 		g.Player.NoFood = 0
 		if g.rnd(10) != 0 {
 			cur.Which = 0
@@ -210,6 +246,7 @@ func (g *RogueGame) newThing() *Object {
 		}
 	case 3:
 		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
@@ -219,7 +256,8 @@ func (g *RogueGame) newThing() *Object {
 	case 4:
 		cur.Kind = KindArmor
 		cur.Which = pickOne(g, g.Items.Armors[:])
-		cur.ArmorClass = aClass[cur.Which]
+
+		cur.ArmorClass = g.data.aClass[cur.Which]
 		if r := g.rnd(100); r < 20 {
 			cur.Flags.Set(Cursed)
 			cur.ArmorClass += g.rnd(3) + 1
@@ -228,6 +266,7 @@ func (g *RogueGame) newThing() *Object {
 		}
 	case 5:
 		cur.Kind = KindRing
+
 		cur.Which = pickOne(g, g.Items.Rings[:])
 		switch cur.RingKind() {
 		case RingAddStrength, RingProtection, RingDexterity, RingIncreaseDamage:
@@ -243,6 +282,7 @@ func (g *RogueGame) newThing() *Object {
 		cur.Which = pickOne(g, g.Items.Sticks[:])
 		g.fixStick(cur)
 	}
+
 	return cur
 }
 
@@ -255,6 +295,7 @@ func pickOne(g *RogueGame, info []ObjInfo) int {
 			return idx
 		}
 	}
+
 	return 0 // bad pick_one: C resets to the start of the table
 }
 
@@ -272,20 +313,27 @@ type invPage struct {
 // (things.c discovered).
 func (g *RogueGame) discovered() {
 	var ch byte
+
 	for {
 		discList := false
+
 		if !g.Options.Terse {
-			g.addmsg("for ")
+			g.addmsgf("for ")
 		}
-		g.addmsg("what type")
+
+		g.addmsgf("what type")
+
 		if !g.Options.Terse {
-			g.addmsg(" of object do you want a list")
+			g.addmsgf(" of object do you want a list")
 		}
+
 		g.msg("? (* for all)")
+
 		ch = g.readchar()
 		switch ch {
 		case Escape:
 			g.msg("")
+
 			return
 		case Potion, Scroll, Ring, Stick, '*':
 			discList = true
@@ -297,10 +345,12 @@ func (g *RogueGame) discovered() {
 					Potion, Scroll, Ring, Stick)
 			}
 		}
+
 		if discList {
 			break
 		}
 	}
+
 	if ch == '*' {
 		g.printDisc(Potion)
 		g.addLine("")
@@ -320,6 +370,7 @@ func (g *RogueGame) discovered() {
 // (things.c print_disc).
 func (g *RogueGame) printDisc(typ byte) {
 	var info []ObjInfo
+
 	switch typ {
 	case Scroll:
 		info = g.Items.Scrolls[:]
@@ -330,18 +381,23 @@ func (g *RogueGame) printDisc(typ byte) {
 	case Stick:
 		info = g.Items.Sticks[:]
 	}
+
 	order := make([]int, len(info))
 	g.setOrder(order)
+
 	obj := Object{Count: 1}
 	numFound := 0
+
 	for i := range info {
 		if info[order[i]].Know || info[order[i]].Guess != "" {
 			obj.Kind = objectKindForGlyph(typ)
 			obj.Which = order[i]
-			g.addLine("%s", g.invName(&obj, false))
+			g.addLine("%s", g.inventoryName(&obj, false))
+
 			numFound++
 		}
 	}
+
 	if numFound == 0 {
 		g.addLine("%s", g.nothing(typ))
 	}
@@ -353,6 +409,7 @@ func (g *RogueGame) setOrder(order []int) {
 	for i := range order {
 		order[i] = i
 	}
+
 	for i := len(order); i > 0; i-- {
 		r := g.rnd(i)
 		order[i-1], order[r] = order[r], order[i-1]
@@ -368,6 +425,7 @@ func (g *RogueGame) addLine(format string, a ...any) int {
 	pg := &g.invPage
 	prompt := "--Press space to continue--"
 	isFlush := format == flushSentinel
+
 	var line string
 	if !isFlush {
 		line = fmt.Sprintf(format, a...)
@@ -375,36 +433,43 @@ func (g *RogueGame) addLine(format string, a ...any) int {
 
 	if pg.lineCnt == 0 {
 		g.scr.Hw.Clear()
+
 		if g.Options.InvType == InvSlow {
 			g.Msgs.Mpos = 0
 		}
 	}
+
 	if g.Options.InvType == InvSlow {
 		if !isFlush && line != "" {
 			if g.msg("%s", line) == Escape {
 				return Escape
 			}
 		}
+
 		pg.lineCnt++
 	} else {
 		if !pg.init {
 			pg.maxlen = len(prompt)
 			pg.init = true
 		}
+
 		if pg.lineCnt >= NumLines-1 || isFlush {
 			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)
 				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(' ')
@@ -417,19 +482,24 @@ func (g *RogueGame) addLine(format string, a ...any) int {
 				g.scr.Hw.Clear()
 				g.refresh()
 			}
+
 			pg.newpage = true
 			pg.lineCnt = 0
 			pg.maxlen = len(prompt)
 		}
-		if !isFlush && !(pg.lineCnt == 0 && line == "") {
+
+		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
 		}
 	}
+
 	return ^Escape
 }
 
@@ -447,6 +517,7 @@ func (g *RogueGame) endLine() {
 			g.flushLine()
 		}
 	}
+
 	pg.lineCnt = 0
 	pg.newpage = false
 }
@@ -459,20 +530,24 @@ func (g *RogueGame) nothing(typ byte) string {
 	} else {
 		out = "Haven't discovered anything"
 	}
+
 	if typ != '*' {
 		var tystr string
+
 		switch typ {
 		case Potion:
-			tystr = "potion"
+			tystr = potionName
 		case Scroll:
-			tystr = "scroll"
+			tystr = scrollName
 		case Ring:
-			tystr = "ring"
+			tystr = ringName
 		case Stick:
 			tystr = "stick"
 		}
+
 		out += fmt.Sprintf(" about any %ss", tystr)
 	}
+
 	return out
 }
 
@@ -480,20 +555,22 @@ func (g *RogueGame) nothing(typ byte) string {
 // (things.c nameit).
 func (g *RogueGame) nameit(pb *strings.Builder, obj *Object, typ, which string,
 	op *ObjInfo, prfunc func(*RogueGame, *Object) string) {
-	if op.Know || op.Guess != "" {
+	switch {
+	case op.Know || op.Guess != "":
 		if obj.Count == 1 {
 			fmt.Fprintf(pb, "A %s ", typ)
 		} else {
 			fmt.Fprintf(pb, "%d %ss ", obj.Count, typ)
 		}
+
 		if op.Know {
 			fmt.Fprintf(pb, "of %s%s(%s)", op.Name, prfunc(g, obj), which)
 		} else {
 			fmt.Fprintf(pb, "called %s%s(%s)", op.Guess, prfunc(g, obj), which)
 		}
-	} else if obj.Count == 1 {
+	case obj.Count == 1:
 		fmt.Fprintf(pb, "A%s %s %s", vowelstr(which), which, typ)
-	} else {
+	default:
 		fmt.Fprintf(pb, "%d %s %ss", obj.Count, which, typ)
 	}
 }
@@ -505,13 +582,17 @@ func nullstr(*RogueGame, *Object) string { return "" }
 // pr_list).
 func (g *RogueGame) prList() {
 	if !g.Options.Terse {
-		g.addmsg("for ")
+		g.addmsgf("for ")
 	}
-	g.addmsg("what type")
+
+	g.addmsgf("what type")
+
 	if !g.Options.Terse {
-		g.addmsg(" of object do you want a list")
+		g.addmsgf(" of object do you want a list")
 	}
+
 	g.msg("? ")
+
 	ch := g.readchar()
 	switch ch {
 	case Potion:
@@ -533,14 +614,17 @@ func (g *RogueGame) prList() {
 // (things.c pr_spec).
 func (g *RogueGame) prSpec(info []ObjInfo) {
 	lastprob := 0
+
 	i := byte('0')
 	for idx := range info {
 		if i == '9'+1 {
 			i = 'a'
 		}
+
 		g.addLine("%c: %s (%d%%)", i, info[idx].Name, info[idx].Prob-lastprob)
 		lastprob = info[idx].Prob
 		i++
 	}
+
 	g.endLine()
 }

game/types.go

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

game/weapons.go

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

game/wizard.go

@@ -8,50 +8,60 @@ package game
 // create_obj).
 func (g *RogueGame) createObj() {
 	obj := newObject()
+
 	g.msg("type of item: ")
 	obj.Kind = objectKindForGlyph(g.readchar())
 	g.Msgs.Mpos = 0
 	g.msg("which %c do you want? (0-f)", obj.Kind.Glyph())
+
 	ch := g.readchar()
 	if isDigit(ch) {
 		obj.Which = int(ch - '0')
 	} else {
 		obj.Which = int(ch-'a') + 10
 	}
+
 	obj.Group = 0
 	obj.Count = 1
 	g.Msgs.Mpos = 0
-	switch {
-	case obj.Kind == KindWeapon || obj.Kind == KindArmor:
+
+	switch obj.Kind {
+	case KindWeapon, KindArmor:
 		g.msg("blessing? (+,-,n)")
 		bless := g.readchar()
 		g.Msgs.Mpos = 0
+
 		if bless == '-' {
 			obj.Flags.Set(Cursed)
 		}
+
 		if obj.Kind == KindWeapon {
 			g.initWeapon(obj, WeaponKind(obj.Which))
+
 			if bless == '-' {
 				obj.HPlus -= g.rnd(3) + 1
 			}
+
 			if bless == '+' {
 				obj.HPlus += g.rnd(3) + 1
 			}
 		} else {
-			obj.ArmorClass = aClass[obj.Which]
+			obj.ArmorClass = g.data.aClass[obj.Which]
 			if bless == '-' {
 				obj.ArmorClass += g.rnd(3) + 1
 			}
+
 			if bless == '+' {
 				obj.ArmorClass -= g.rnd(3) + 1
 			}
 		}
-	case obj.Kind == KindRing:
+	case KindRing:
 		switch obj.RingKind() {
 		case RingProtection, RingAddStrength, RingDexterity, RingIncreaseDamage:
 			g.msg("blessing? (+,-,n)")
 			bless := g.readchar()
 			g.Msgs.Mpos = 0
+
 			if bless == '-' {
 				obj.Flags.Set(Cursed)
 				obj.Bonus = -1
@@ -61,15 +71,17 @@ func (g *RogueGame) createObj() {
 		case RingAggravateMonsters, RingTeleportation:
 			obj.Flags.Set(Cursed)
 		}
-	case obj.Kind == KindWand:
+	case KindWand:
 		g.fixStick(obj)
-	case obj.Kind == KindGold:
+	case KindGold:
 		g.msg("how much?")
+
 		buf := ""
 		if g.getStr(&buf, g.scr.Std) == Norm {
 			obj.GoldValue = cAtoi(buf)
 		}
 	}
+
 	g.addPack(obj, false)
 }
 
@@ -77,18 +89,22 @@ func (g *RogueGame) createObj() {
 func (g *RogueGame) showMap() {
 	hw := g.scr.Hw
 	hw.Clear()
+
 	for y := 1; y < NumLines-1; y++ {
-		for x := 0; x < NumCols; x++ {
-			real := g.Level.FlagsAt(y, x).Has(FReal)
-			if !real {
+		for x := range NumCols {
+			isReal := g.Level.FlagsAt(y, x).Has(FReal)
+			if !isReal {
 				hw.Standout(true)
 			}
+
 			hw.MvAddCh(y, x, g.Level.Char(y, x))
-			if !real {
+
+			if !isReal {
 				hw.Standout(false)
 			}
 		}
 	}
+
 	g.showWin("---More (level map)---")
 }
 
@@ -97,27 +113,35 @@ func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
 	p := &g.Player
 	if len(p.Pack) == 0 {
 		g.msg("you don't have anything in your pack to identify")
+
 		return
 	}
 
 	var obj *Object
 	for {
-		obj = g.getItem("identify", kind)
+		obj, _ = g.promptPackItem("identify", kind)
+
 		if !insist {
 			break
 		}
+
 		if g.NObjs == 0 {
 			return
 		}
+
 		if obj == nil {
 			g.msg("you must identify something")
-		} else if kind != KindNone && obj.Kind != kind &&
-			!(kind == KindRingOrStick &&
-				(obj.Kind == KindRing || obj.Kind == KindWand)) {
-			g.msg("you must identify a %s", kind)
-		} else {
-			break
+
+			continue
 		}
+
+		if !matchesFilter(kind, obj) {
+			g.msg("you must identify a %s", kind)
+
+			continue
+		}
+
+		break
 	}
 
 	if obj == nil {
@@ -136,7 +160,8 @@ func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
 	case KindRing:
 		setKnow(obj, g.Items.Rings[:])
 	}
-	g.msg("%s", g.invName(obj, false))
+
+	g.msg("%s", g.inventoryName(obj, false))
 }
 
 // setKnow sets things up when we really know what a thing is (wizard.c
@@ -154,15 +179,18 @@ func setKnow(obj *Object, info []ObjInfo) {
 func (g *RogueGame) teleport() {
 	p := &g.Player
 	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())
-	c, _ := g.findFloor(nil, 0, true)
-	if g.roomin(c) != p.Room {
+
+	c, _ := g.findFloor(true)
+	if g.roomIn(c) != p.Room {
 		g.leaveRoom(p.Pos)
 		p.Pos = c
 		g.enterRoom(p.Pos)
 	} else {
 		p.Pos = c
+
 		g.look(true)
 	}
+
 	g.mvaddch(p.Pos.Y, p.Pos.X, PlayerCh)
 	// turn off ISHELD in case teleportation was done while fighting a
 	// Flytrap
@@ -171,6 +199,7 @@ func (g *RogueGame) teleport() {
 		p.VfHit = 0
 		g.Monsters['F'-'A'].Stats.Dmg = dice("000x0")
 	}
+
 	g.NoMove = 0
 	g.Count = 0
 	g.Running = false

term/tcell.go

@@ -5,6 +5,8 @@
 package term
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -21,6 +23,9 @@ type Tcell struct {
 	last   *game.Window // last rendered window, for resize redraws
 }
 
+// ErrScreenTooSmall reports a terminal below the required 80x24.
+var ErrScreenTooSmall = errors.New("screen too small")
+
 // New initializes the terminal. The screen must be at least 80x24, as the
 // C game required.
 func New() (*Tcell, error) {
@@ -28,16 +33,22 @@ func New() (*Tcell, error) {
 	if err != nil {
 		return nil, err
 	}
-	if err := s.Init(); err != nil {
-		return nil, err
+
+	initErr := s.Init()
+	if initErr != nil {
+		return nil, initErr
 	}
+
 	w, h := s.Size()
 	if h < game.NumLines || w < game.NumCols {
 		s.Fini()
-		return nil, fmt.Errorf("sorry, the screen must be at least %dx%d",
-			game.NumLines, game.NumCols)
+
+		return nil, fmt.Errorf("sorry, %w: %dx%d required",
+			ErrScreenTooSmall, game.NumCols, game.NumLines)
 	}
+
 	s.HideCursor()
+
 	return &Tcell{screen: s}, nil
 }
 
@@ -49,17 +60,21 @@ func (t *Tcell) Fini() {
 // Render blits a game window to the terminal (curses refresh).
 func (t *Tcell) Render(w *game.Window) {
 	t.last = w
+
 	rows, cols := w.Size()
-	for y := 0; y < rows; y++ {
-		for x := 0; x < cols; x++ {
+	for y := range rows {
+		for x := range cols {
 			ch, standout := w.CellAt(y, x)
+
 			style := tcell.StyleDefault
 			if standout {
 				style = style.Reverse(true)
 			}
+
 			t.screen.SetContent(x, y, rune(ch), nil, style)
 		}
 	}
+
 	t.screen.Show()
 }
 
@@ -105,8 +120,9 @@ func (t *Tcell) ReadChar() byte {
 				return 3
 			default:
 				if ev.Key() >= tcell.KeyCtrlA && ev.Key() <= tcell.KeyCtrlZ {
-					return byte(ev.Key())
+					return byte(ev.Key()) //nolint:gosec // G115: 1..26 fits
 				}
+
 				if r := ev.Rune(); r > 0 && r < 0x80 {
 					return byte(r)
 				}
@@ -118,18 +134,29 @@ func (t *Tcell) ReadChar() byte {
 // ShellEscape suspends the screen and runs the user's shell (main.c
 // shell + md_shellescape).
 func (t *Tcell) ShellEscape() {
-	if err := t.screen.Suspend(); err != nil {
+	err := t.screen.Suspend()
+	if err != nil {
 		return
 	}
+
 	shell := os.Getenv("SHELL")
 	if shell == "" {
 		shell = "/bin/sh"
 	}
-	fmt.Println("[Entering shell; exit to return to the game]")
-	cmd := exec.Command(shell)
+
+	_, _ = fmt.Fprintln(os.Stdout,
+		"[Entering shell; exit to return to the game]")
+
+	// The shell session has no deadline by design; Background context.
+	cmd := exec.CommandContext(context.Background(), //nolint:gosec // G204: the user's own $SHELL
+		shell)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.Run()
-	t.screen.Resume()
+	_ = cmd.Run() // best effort: the shell is the user's business
+
+	resumeErr := t.screen.Resume()
+	if resumeErr != nil {
+		panic(resumeErr) // terminal resume failure is unrecoverable
+	}
 }