Decompose score and wakeMonster (refactor step 7)

score splits into scoreInsert/scoreLines/showScores; wakeMonster gains
meanWakes/medusaCatches/medusaGaze predicates and effect. Behavior and
RNG call order unchanged.

game/monsters.go

@@ -124,22 +124,65 @@ func (g *RogueGame) wakeMonster(y, x int) *Monster {
 		panic("can't find monster in wake_monster")
 	}
 
-	ch := tp.Type
 	// Every time he sees a mean monster, it might start chasing him
-	if !tp.On(Awake) && g.rnd(3) != 0 && tp.On(Mean) && !tp.On(Held) &&
+	if g.meanWakes(tp) {
-		!p.IsWearing(RingStealth) && !p.On(Levitating) {
 		tp.Dest = &p.Pos
 		tp.Flags.Set(Awake)
 	}
 
-	if ch == 'M' && !p.On(Blind) && !p.On(Hallucinating) &&
+	if g.medusaCatches(tp) {
-		!tp.On(Found) && !tp.On(Cancelled) && tp.On(Awake) {
+		g.medusaGaze(tp, y, x)
+	}
+	// 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
+}
+
+// meanWakes decides whether a sleeping mean monster starts the chase
+// (monsters.c wake_monster). The waking roll happens for any sleeping
+// monster, as in C.
+func (g *RogueGame) meanWakes(tp *Monster) bool {
+	p := &g.Player
+
+	return !tp.On(Awake) && g.rnd(3) != 0 && tp.On(Mean) && !tp.On(Held) &&
+		!p.IsWearing(RingStealth) && !p.On(Levitating)
+}
+
+// medusaCatches reports an uncovered, awake medusa the hero can see
+// (monsters.c wake_monster).
+func (g *RogueGame) medusaCatches(tp *Monster) bool {
+	p := &g.Player
+
+	return tp.Type == 'M' && !p.On(Blind) && !p.On(Hallucinating) &&
+		!tp.On(Found) && !tp.On(Cancelled) && tp.On(Awake)
+}
+
+// medusaGaze confuses the hero when the medusa's gaze lands (the M
+// block of monsters.c wake_monster).
+func (g *RogueGame) medusaGaze(tp *Monster, y, x int) {
+	p := &g.Player
+
 	rp := p.Room
-		if (rp != nil && !rp.Flags.Has(Dark)) ||
+	if (rp == nil || rp.Flags.Has(Dark)) &&
-			distance(y, x, p.Pos.Y, p.Pos.X) < LampDist {
+		distance(y, x, p.Pos.Y, p.Pos.X) >= LampDist {
+		return
+	}
+
 	tp.Flags.Set(Found)
 
-			if !g.save(VsMagic) {
+	if g.save(VsMagic) {
+		return
+	}
+
 	if p.On(Confused) {
 		g.Lengthen(DUnconfuse, g.spread(HuhDuration))
 	} else {
@@ -156,21 +199,6 @@ func (g *RogueGame) wakeMonster(y, x int) *Monster {
 	}
 
 	g.msg("s gaze has confused you")
-			}
-		}
-	}
-	// 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
 }
 
 // givePack gives a pack to a monster if it deserves one (monsters.c

game/score.go

@@ -107,8 +107,23 @@ 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 {
+		ins = g.scoreInsert(topTen, amount, flags, monst)
+	}
+
+	lines, highlight := g.scoreLines(topTen, ins)
+	g.showScores(lines, highlight)
+
+	// Update the list file
+	if ins >= 0 {
+		g.wrScore(topTen)
+	}
+}
+
+// scoreInsert slots the new score into the top ten, honoring the
+// one-score-per-losing-uid rule; -1 means it did not place (the
+// insertion half of rip.c score).
+func (g *RogueGame) scoreInsert(topTen []ScoreEnt, amount, flags int, monst byte) int {
 	uid := os.Getuid()
 
 	scp := len(topTen)
@@ -126,7 +141,10 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 		}
 	}
 
-		if scp < len(topTen) {
+	if scp >= len(topTen) {
+		return -1
+	}
+
 	sc2 := len(topTen) - 1
 	if flags != 2 && !g.AllScore {
 		for i := scp; i < len(topTen); i++ {
@@ -157,11 +175,13 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 		Level:   lvl,
 		Time:    time.Now().Unix(),
 	}
-			ins = scp
-		}
-	}
 
-	// Build the list display
+	return scp
+}
+
+// scoreLines formats the scoreboard, noting which display line holds
+// the freshly inserted score (the display half of rip.c score).
+func (g *RogueGame) scoreLines(topTen []ScoreEnt, ins int) ([]string, int) {
 	label := "Rogueists"
 	if g.AllScore {
 		label = "Scores"
@@ -194,7 +214,20 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 		lines = append(lines, line)
 	}
 
-	if g.scr != nil && g.scr.term != nil {
+	return lines, highlight
+}
+
+// showScores prints the scoreboard on the screen when there is one,
+// else to standard output (rip.c score).
+func (g *RogueGame) showScores(lines []string, highlight int) {
+	if g.scr == nil || g.scr.term == nil {
+		for _, line := range lines {
+			_, _ = fmt.Fprintln(os.Stdout, line) // CLI output
+		}
+
+		return
+	}
+
 	g.clear()
 
 	for i, line := range lines {
@@ -210,16 +243,6 @@ func (g *RogueGame) score(amount, flags int, monst byte) {
 	}
 
 	g.refresh()
-	} else {
-		for _, line := range lines {
-			_, _ = fmt.Fprintln(os.Stdout, line) // CLI output
-		}
-	}
-
-	// Update the list file
-	if ins >= 0 {
-		g.wrScore(topTen)
-	}
 }
 
 // ShowScores implements the -s command line option: print the scoreboard