Convert readScroll to a per-scroll handler table (refactor step 7)

The read_scroll switch becomes gameData.readHandlers, indexed by
ScrollKind; the five identify scrolls share one handler. The magic
mapping cell logic is extracted into revealSpot. Effect order and RNG
call sequence unchanged.

game/scrolls.go

@@ -28,20 +28,38 @@ func (g *RogueGame) readScroll() {
 	// Get rid of the thing
 	g.leavePack(obj, false, false)
 
-	switch obj.ScrollKind() {
-	case ScrollMonsterConfusion:
+	if h := g.data.readHandlers[obj.ScrollKind()]; h != nil {
+		h(g, obj)
+	}
+
+	g.look(true) // put the result of the scroll on the screen
+	g.status()
+
+	g.callIt(&g.Items.Scrolls[obj.Which])
+}
+
+// The per-scroll effect handlers, dispatched through
+// gameData.readHandlers. Each is one case of the C read_scroll switch.
+
+func (g *RogueGame) readMonsterConfusion(*Object) {
 	// Scroll of monster confusion.  Give him that power.
-		p.Flags.Set(CanConfuse)
+	g.Player.Flags.Set(CanConfuse)
 	g.msg("your hands begin to glow %s", g.pickColor("red"))
-	case ScrollEnchantArmor:
+}
+
+func (g *RogueGame) readEnchantArmor(*Object) {
+	p := &g.Player
 	if p.CurArmor != nil {
 		p.CurArmor.ArmorClass--
 		p.CurArmor.Flags.Clear(Cursed)
 		g.msg("your armor glows %s for a moment", g.pickColor("silver"))
 	}
-	case ScrollHoldMonster:
+}
+
+func (g *RogueGame) readHoldMonster(*Object) {
 	// Hold monster scroll.  Stop all monsters within two spaces from
 	// chasing after the hero.
+	p := &g.Player
 	held := 0
 
 	for x := p.Pos.X - 2; x <= p.Pos.X+2; x++ {
@@ -81,16 +99,21 @@ func (g *RogueGame) readScroll() {
 	} else {
 		g.msg("you feel a strange sense of loss")
 	}
-	case ScrollSleep:
+}
+
+func (g *RogueGame) readSleep(*Object) {
 	// Scroll which makes you fall asleep
 	g.Items.Scrolls[ScrollSleep].Know = true
 	g.NoCommand += g.rnd(g.spread(5)) + 4 // SLEEPTIME
 
-		p.Flags.Clear(Awake)
+	g.Player.Flags.Clear(Awake)
 	g.msg("you fall asleep")
-	case ScrollCreateMonster:
+}
+
+func (g *RogueGame) readCreateMonster(*Object) {
 	// Create a monster: first look in a circle around him, next try
 	// his room, otherwise give up
+	p := &g.Player
 	i := 0
 
 	var mp Coord
@@ -122,18 +145,31 @@ func (g *RogueGame) readScroll() {
 		tp := &Monster{}
 		g.newMonster(tp, g.randMonster(false), mp)
 	}
-	case ScrollIdentifyPotion, ScrollIdentifyScroll, ScrollIdentifyWeapon, ScrollIdentifyArmor, ScrollIdentifyRingOrStick:
+}
+
+func (g *RogueGame) readIdentify(obj *Object) {
 	// Identify, let him figure something out
 	g.Items.Scrolls[obj.Which].Know = true
 	g.msg("this scroll is an %s scroll", g.Items.Scrolls[obj.Which].Name)
 	g.whatis(true, g.data.idType[obj.ScrollKind()])
-	case ScrollMagicMapping:
+}
+
+func (g *RogueGame) readMagicMapping(*Object) {
 	// Scroll of magic mapping.
 	g.Items.Scrolls[ScrollMagicMapping].Know = true
 	g.msg("oh, now this scroll has a map on it")
 	// take all the things we want to keep hidden out of the window
 	for y := 1; y < NumLines-1; y++ {
 		for x := range NumCols {
+			g.revealSpot(y, x)
+		}
+	}
+}
+
+// revealSpot uncovers one map cell for magic mapping: secret doors and
+// passages become real, hidden traps show, and the visible character is
+// drawn (the loop body of the C SCR_MAP case).
+func (g *RogueGame) revealSpot(y, x int) {
 	pp := g.Level.At(y, x)
 	ch := pp.Ch
 	pass := false
@@ -190,7 +226,7 @@ func (g *RogueGame) readScroll() {
 	if ch != ' ' {
 		if tp := pp.Monst; tp != nil {
 			tp.OldCh = ch
-						if !p.On(SenseMonsters) {
+			if !g.Player.On(SenseMonsters) {
 				g.mvaddch(y, x, ch)
 			}
 		} else {
@@ -198,8 +234,8 @@ func (g *RogueGame) readScroll() {
 		}
 	}
 }
-		}
-	case ScrollFoodDetection:
+
+func (g *RogueGame) readFoodDetection(*Object) {
 	// Food detection
 	found := false
 
@@ -219,8 +255,11 @@ func (g *RogueGame) readScroll() {
 	} else {
 		g.msg("your nose tingles")
 	}
-	case ScrollTeleportation:
+}
+
+func (g *RogueGame) readTeleportation(*Object) {
 	// Scroll of teleportation: make him disappear and reappear
+	p := &g.Player
 	curRoom := p.Room
 
 	g.teleport()
@@ -228,7 +267,10 @@ func (g *RogueGame) readScroll() {
 	if curRoom != p.Room {
 		g.Items.Scrolls[ScrollTeleportation].Know = true
 	}
-	case ScrollEnchantWeapon:
+}
+
+func (g *RogueGame) readEnchantWeapon(*Object) {
+	p := &g.Player
 	if p.CurWeapon == nil || p.CurWeapon.Kind != KindWeapon {
 		g.msg("you feel a strange sense of loss")
 	} else {
@@ -243,23 +285,34 @@ func (g *RogueGame) readScroll() {
 		g.msg("your %s glows %s for a moment",
 			g.Items.Weapons[p.CurWeapon.Which].Name, g.pickColor("blue"))
 	}
-	case ScrollScareMonster:
+}
+
+func (g *RogueGame) readScareMonster(*Object) {
 	// Reading it is a mistake and produces laughter at her poor boo
 	// boo.
 	g.msg("you hear maniacal laughter in the distance")
-	case ScrollRemoveCurse:
+}
+
+func (g *RogueGame) readRemoveCurse(*Object) {
+	p := &g.Player
+
 	uncurse(p.CurArmor)
 	uncurse(p.CurWeapon)
 	uncurse(p.CurRing[Left])
 	uncurse(p.CurRing[Right])
 	g.msg("%s", g.chooseStr("you feel in touch with the Universal Onenes",
 		"you feel as if somebody is watching over you"))
-	case ScrollAggravateMonsters:
+}
+
+func (g *RogueGame) readAggravateMonsters(*Object) {
 	// This scroll aggravates all the monsters on the current level
 	// and sets them running towards the hero
 	g.aggravate()
 	g.msg("you hear a high pitched humming noise")
-	case ScrollProtectArmor:
+}
+
+func (g *RogueGame) readProtectArmor(*Object) {
+	p := &g.Player
 	if p.CurArmor != nil {
 		p.CurArmor.Flags.Set(Protected)
 		g.msg("your armor is covered by a shimmering %s shield",
@@ -269,12 +322,6 @@ func (g *RogueGame) readScroll() {
 	}
 }
 
-	g.look(true) // put the result of the scroll on the screen
-	g.status()
-
-	g.callIt(&g.Items.Scrolls[obj.Which])
-}
-
 // uncurse uncurses an item (scrolls.c uncurse).
 func uncurse(obj *Object) {
 	if obj != nil {

game/tables.go

@@ -127,6 +127,11 @@ type gameData struct {
 	// the cases of the potions.c quaff switch. The bool is trip — was
 	// the hero hallucinating when the potion went down.
 	quaffHandlers [NumPotionTypes]func(g *RogueGame, trip bool)
+
+	// readHandlers dispatches each scroll kind to its effect method:
+	// the cases of the scrolls.c read_scroll switch. The handler gets
+	// the scroll being read (the identify family needs its subtype).
+	readHandlers [NumScrollTypes]func(g *RogueGame, obj *Object)
 }
 
 // ripWall is the repeated blank wall line of the tombstone art.
@@ -609,6 +614,27 @@ func newGameData() *gameData {
 			PotionBlindness:       (*RogueGame).quaffBlindness,
 			PotionLevitation:      (*RogueGame).quaffLevitation,
 		},
+
+		readHandlers: [NumScrollTypes]func(*RogueGame, *Object){
+			ScrollMonsterConfusion:    (*RogueGame).readMonsterConfusion,
+			ScrollMagicMapping:        (*RogueGame).readMagicMapping,
+			ScrollHoldMonster:         (*RogueGame).readHoldMonster,
+			ScrollSleep:               (*RogueGame).readSleep,
+			ScrollEnchantArmor:        (*RogueGame).readEnchantArmor,
+			ScrollIdentifyPotion:      (*RogueGame).readIdentify,
+			ScrollIdentifyScroll:      (*RogueGame).readIdentify,
+			ScrollIdentifyWeapon:      (*RogueGame).readIdentify,
+			ScrollIdentifyArmor:       (*RogueGame).readIdentify,
+			ScrollIdentifyRingOrStick: (*RogueGame).readIdentify,
+			ScrollScareMonster:        (*RogueGame).readScareMonster,
+			ScrollFoodDetection:       (*RogueGame).readFoodDetection,
+			ScrollTeleportation:       (*RogueGame).readTeleportation,
+			ScrollEnchantWeapon:       (*RogueGame).readEnchantWeapon,
+			ScrollCreateMonster:       (*RogueGame).readCreateMonster,
+			ScrollRemoveCurse:         (*RogueGame).readRemoveCurse,
+			ScrollAggravateMonsters:   (*RogueGame).readAggravateMonsters,
+			ScrollProtectArmor:        (*RogueGame).readProtectArmor,
+		},
 	}
 }