rgoue/game/potions.go

//nolint:mnd // C-faithful literals; names hurt C-greppability (approved 2026-07-07)
package game

import "fmt"

// potions.c — functions for dealing with potions.

// pact describes a standard fuse-based potion (potions.c PACT).
type pact struct {
	flags    CreatureFlags
	daemon   DaemonID
	time     int
	high     string // message when hallucinating
	straight string
}

// quaff drinks a potion from the pack (potions.c quaff).
func (g *RogueGame) quaff() {
	p := &g.Player
	obj, ok := g.promptPackItem("quaff", KindPotion)
	// Make certain that it is something that we want to drink
	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)

	if h := g.data.quaffHandler(obj); h != nil {
		h(g, trip)
	}

	g.status()
	// Throw the item away. A malformed potion has no lore entry to name,
	// so it is drunk for no effect and never prompts to be called anything.
	if obj.hasValidWhich() {
		g.callIt(&g.Items.Potions[obj.Which])
	}
}

// The per-potion effect handlers, dispatched through
// gameData.quaffHandlers. Each is one case of the C quaff switch.

func (g *RogueGame) quaffConfusion(trip bool) {
	g.applyPotionFuse(PotionConfusion, !trip)
}

func (g *RogueGame) quaffPoison(bool) {
	g.Items.Potions[PotionPoison].Know = true
	if g.Player.IsWearing(RingSustainStrength) {
		g.msg("you feel momentarily sick")
	} else {
		g.changeStrength(-(g.rnd(3) + 1))
		g.msg("you feel very sick now")
		g.comeDown(0)
	}
}

func (g *RogueGame) quaffHealing(bool) {
	p := &g.Player

	g.Items.Potions[PotionHealing].Know = true
	if p.Stats.HP += g.roll(p.Stats.Lvl, 4); p.Stats.HP > p.Stats.MaxHP {
		p.Stats.MaxHP++
		p.Stats.HP = p.Stats.MaxHP
	}

	g.sight(0)
	g.msg("you begin to feel better")
}

func (g *RogueGame) quaffGainStrength(bool) {
	g.Items.Potions[PotionGainStrength].Know = true
	g.changeStrength(1)
	g.msg("you feel stronger, now.  What bulging muscles!")
}

func (g *RogueGame) quaffDetectMonsters(bool) {
	g.Player.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"))
	}
}

func (g *RogueGame) quaffDetectMagic(bool) {
	// 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 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 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--")
	} else {
		g.msg("you have a %s feeling for a moment, then it passes",
			g.chooseStr("normal", "strange"))
	}
}

func (g *RogueGame) quaffLSD(trip bool) {
	p := &g.Player
	if !trip {
		if p.On(SenseMonsters) {
			g.turnSee(false)
		}

		g.StartDaemon(DVisuals, 0, Before)
		g.SeenStairs = g.seenStairs()
	}

	g.applyPotionFuse(PotionLSD, true)
}

func (g *RogueGame) quaffSeeInvisible(bool) {
	show := g.Player.On(CanSeeInvisible)

	g.applyPotionFuse(PotionSeeInvisible, false)

	if !show {
		g.invisOn()
	}

	g.sight(0)
}

func (g *RogueGame) quaffRaiseLevel(bool) {
	g.Items.Potions[PotionRaiseLevel].Know = true
	g.msg("you suddenly feel much more skillful")
	g.raiseLevel()
}

func (g *RogueGame) quaffExtraHealing(bool) {
	p := &g.Player

	g.Items.Potions[PotionExtraHealing].Know = true
	if p.Stats.HP += g.roll(p.Stats.Lvl, 8); p.Stats.HP > p.Stats.MaxHP {
		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")
}

func (g *RogueGame) quaffHaste(bool) {
	g.Items.Potions[PotionHaste].Know = true

	g.After = false
	if g.addHaste(true) {
		g.msg("you feel yourself moving much faster")
	}
}

func (g *RogueGame) quaffRestoreStrength(bool) {
	p := &g.Player
	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")
}

func (g *RogueGame) quaffBlindness(bool) {
	g.applyPotionFuse(PotionBlindness, true)
}

func (g *RogueGame) quaffLevitation(bool) {
	g.applyPotionFuse(PotionLevitation, true)
}

// raiseLevel: the guy just magically went up a level (potions.c
// raise_level).
func (g *RogueGame) raiseLevel() {
	g.Player.Stats.Exp = g.data.eLevels[g.Player.Stats.Lvl-1] + 1
	g.checkLevel()
}

// 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)
		g.Fuse(pp.daemon, 0, t, After)
		g.look(false)
	} 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 (g *RogueGame) isMagic(o *Object) bool {
	//nolint:exhaustive // C-faithful: only the cases C handled (approved 2026-07-07)
	switch o.Kind {
	case KindArmor:
		return o.Flags.Has(Protected) || o.ArmorClass != g.data.armorClass(o.Which)
	case KindWeapon:
		return o.HPlus != 0 || o.DPlus != 0
	case KindPotion, KindScroll, KindWand, KindRing, KindAmulet:
		return true
	}

	return false
}

// invisOn turns on the ability to see invisible monsters (potions.c
// 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)
		}
	}
}

// turnSee puts on or off seeing monsters on this level (potions.c
// 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 {
				g.addch(mp.OldCh)
			}
		} else if g.showSensed(mp, canSee) {
			addNew = true
		}
	}

	if turnOff {
		g.Player.Flags.Clear(SenseMonsters)
	} else {
		g.Player.Flags.Set(SenseMonsters)
	}

	return addNew
}

// showSensed draws one monster for monster sense, standout when it is
// otherwise invisible; it reports whether the monster was newly revealed
// (the turn-on arm of the C turn_see loop).
func (g *RogueGame) showSensed(mp *Monster, canSee bool) bool {
	if !canSee {
		g.standout()
	}

	if !g.Player.On(Hallucinating) {
		g.addch(mp.Type)
	} else {
		g.addch(g.randomMonsterLetter())
	}

	if !canSee {
		g.standend()

		return true
	}

	return false
}

// seenStairs reports whether the player has seen the stairs (potions.c
// seen_stairs).
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
	}
	// if a monster is on the stairs, this gets hairy
	if tp := g.Level.MonsterAt(st.Y, st.X); tp != nil {
		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
}