go: port command loop, save/restore, tcell terminal, and the binary

- command.c in full: the command dispatcher with repeat counts, run
  prefixes, ctrl-run door-stop mode, fight-to-death targeting, and all
  wizard debug commands; search, help, identify, d_level/u_level, call,
  current
- main.c completed: Run()/playit() with the C double ROGUEOPTS parse;
  exit()-anywhere becomes a gameEnd panic recovered in Run
- save.c + state.c: gob SaveState snapshot with explicit pointer-to-
  index fixups for equipment, monster rooms, and chase targets (the
  rs_fix_thing role); save file deleted on restore as in C; SIGHUP/
  SIGTERM autosave hook
- wizard.c completed (create_obj, show_map), passages.c add_pass
- term/: tcell/v2 Terminal — the one third-party dependency — replacing
  curses and mdport's 900-line key decoder; shell escape via suspend
- cmd/rogue: flags -s/-d, SEED (wizard), ROGUEOPTS, ROGUE_WIZARD

Tests: full scripted sessions through Run (quit, descend stairs,
3200-move crash sweep, save-command round trip). Notable fixes found
by tests: gob silently drops embedded fields of unexported types, and
--More-- prompts swallow space-free input scripts.

game/run_test.go

@@ -0,0 +1,104 @@
+package game
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestRunScriptedSession drives a complete game through Run(): a few
+// 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 {
+		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++ {
+		if strings.Contains(g.scr.Std.Line(y), "Top Ten") {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("score list not on screen after quit")
+	}
+}
+
+// TestRunManyTurns mashes movement keys for a while as a crash sweep of
+// the whole turn loop (daemons, hunger, monsters, combat), ending with a
+// quit. The input alternates directions so the hero bumps around rooms.
+func TestRunManyTurns(t *testing.T) {
+	// Spaces between commands double as answers to any --More-- prompts;
+	// without them a single prompt would swallow the rest of the script
+	// (wait_for eats everything that isn't a space).
+	var script []byte
+	moves := []byte("h h j j k k l l y u b n s s . . ")
+	for range 200 {
+		script = append(script, moves...)
+	}
+	script = append(script, " Q y Qy"...)
+	tt := &testTerm{input: script}
+	g := NewGame(Config{Seed: 31337, Term: tt})
+	if err := g.Run(); err != nil {
+		t.Fatalf("Run: %v", err)
+	}
+	if g.Playing {
+		t.Error("session did not end")
+	}
+}
+
+// TestRunDownStairs walks the hero onto the stairs by teleporting there in
+// wizard style, then descends and keeps playing.
+func TestRunDownStairs(t *testing.T) {
+	tt := &testTerm{input: []byte(">..Qy")}
+	g := NewGame(Config{Seed: 7, Term: tt})
+	g.NewLevel()
+	g.Player.Pos = g.Level.Stairs // stand on the stairs
+	g.restored = true             // keep Run from regenerating the level
+	g.Daemons = DaemonList{}      // and give it a fresh daemon table
+	g.StartDaemon(DRunners, 0, After)
+	g.StartDaemon(DDoctor, 0, After)
+	g.Fuse(DSwander, 0, wanderTime(g), After)
+	g.StartDaemon(DStomach, 0, After)
+	if err := g.Run(); err != nil {
+		t.Fatalf("Run: %v", err)
+	}
+	if g.Depth != 2 {
+		t.Errorf("depth = %d after descending, want 2", g.Depth)
+	}
+}
+
+// TestSaveCommandRoundTrip saves via the 'S' command (as a player would)
+// and restores the game.
+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)
+	}
+
+	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)
+	}
+}