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

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

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

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

game/rings.go

@@ -0,0 +1,174 @@
+package game
+
+import "fmt"
+
+// rings.c — routines dealing specifically with rings.
+
+// ringOn puts a ring on a hand (rings.c ring_on).
+func (g *RogueGame) ringOn() {
+	p := &g.Player
+	obj := g.getItem("put on", int(Ring))
+	// Make certain that it is something that we want to wear
+	if obj == nil {
+		return
+	}
+	if obj.Type != Ring {
+		if !g.Options.Terse {
+			g.msg("it would be difficult to wrap that around a finger")
+		} else {
+			g.msg("not a ring")
+		}
+		return
+	}
+
+	// find out which hand to put it on
+	if g.isCurrent(obj) {
+		return
+	}
+
+	var ring int
+	switch {
+	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
+		if ring = g.gethand(); ring < 0 {
+			return
+		}
+	case p.CurRing[Left] == nil:
+		ring = Left
+	case p.CurRing[Right] == nil:
+		ring = Right
+	default:
+		if !g.Options.Terse {
+			g.msg("you already have a ring on each hand")
+		} else {
+			g.msg("wearing two")
+		}
+		return
+	}
+	p.CurRing[ring] = obj
+
+	// Calculate the effect it has on the poor guy.
+	switch obj.Which {
+	case RAddStr:
+		g.chgStr(obj.Arm)
+	case RSeeInvis:
+		g.invisOn()
+	case RAggr:
+		g.aggravate()
+	}
+
+	if !g.Options.Terse {
+		g.addmsg("you are now wearing ")
+	}
+	g.msg("%s (%c)", g.invName(obj, true), obj.PackCh)
+}
+
+// ringOff takes off a ring (rings.c ring_off).
+func (g *RogueGame) ringOff() {
+	p := &g.Player
+	var ring int
+	switch {
+	case p.CurRing[Left] == nil && p.CurRing[Right] == nil:
+		if g.Options.Terse {
+			g.msg("no rings")
+		} else {
+			g.msg("you aren't wearing any rings")
+		}
+		return
+	case p.CurRing[Left] == nil:
+		ring = Right
+	case p.CurRing[Right] == nil:
+		ring = Left
+	default:
+		if ring = g.gethand(); ring < 0 {
+			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)
+	}
+}
+
+// gethand asks which hand the hero is interested in (rings.c gethand).
+func (g *RogueGame) gethand() int {
+	for {
+		if g.Options.Terse {
+			g.msg("left or right ring? ")
+		} 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 {
+			g.msg("please type L or R")
+		}
+	}
+}
+
+// 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 = [MaxRings]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 {
+	ring := g.Player.CurRing[hand]
+	if ring == nil {
+		return 0
+	}
+	eat := ringUses[ring.Which]
+	if eat < 0 {
+		if g.rnd(-eat) == 0 {
+			eat = 1
+		} else {
+			eat = 0
+		}
+	}
+	if ring.Which == RDigest {
+		eat = -eat
+	}
+	return eat
+}
+
+// ringNum prints ring bonuses (rings.c ring_num).
+func ringNum(g *RogueGame, obj *Object) string {
+	if !obj.Flags.Has(IsKnow) {
+		return ""
+	}
+	switch obj.Which {
+	case RProtect, RAddStr, RAddDam, RAddHit:
+		return fmt.Sprintf(" [%s]", num(obj.Arm, 0, Ring))
+	}
+	return ""
+}