rgoue/game/wizard.go

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

// wizard.c — special wizard commands, some of which are also non-wizard
// commands under strange circumstances. The DES password check is not
// ported: wizard mode is enabled by configuration instead.

// createObj is the wizard command for getting anything he wants (wizard.c
// create_obj).
func (g *RogueGame) createObj() {
	obj := newObject()

	g.msg("type of item: ")
	obj.Kind = objectKindForGlyph(g.readchar())
	g.Msgs.Mpos = 0
	g.msg("which %c do you want? (0-f)", obj.Kind.Glyph())

	ch := g.readchar()
	if isDigit(ch) {
		obj.Which = int(ch - '0')
	} else {
		obj.Which = int(ch-'a') + 10
	}

	obj.Group = 0
	obj.Count = 1
	g.Msgs.Mpos = 0

	// Deliberate divergence from 5.4.4: C stored this nibble unchecked, so
	// 'a'-'f' (and anything below '0' or 'a', which goes negative) indexed
	// straight past the ends of the per-kind static tables. That was
	// undefined behavior C happened to survive by reading adjacent memory;
	// in Go it is a panic that kills the process with the terminal still in
	// raw mode. C had no defined behavior here to be faithful to, so the
	// choice is rejected outright rather than emulating a garbage read. The
	// check precedes every rnd() call below, so the RNG sequence is
	// untouched either way.
	if !obj.wizardCanCreate() {
		g.msg("there is no such %s", obj.Kind)

		return
	}

	//nolint:exhaustive // C-faithful: only the cases C handled (approved 2026-07-07)
	switch obj.Kind {
	case KindWeapon, KindArmor:
		g.createWeaponArmor(obj)
	case KindRing:
		g.createRing(obj)
	case KindWand:
		g.fixStick(obj)
	case KindGold:
		g.msg("how much?")

		buf := ""
		if g.getStr(&buf, g.scr.Std) == Norm {
			obj.GoldValue = cAtoi(buf)
		}
	}

	g.addPack(obj, false)
}

// createWeaponArmor sets up a wizard-created weapon or armor with an
// optional blessing (the weapon/armor arm of wizard.c create_obj).
func (g *RogueGame) createWeaponArmor(obj *Object) {
	g.msg("blessing? (+,-,n)")
	bless := g.readchar()
	g.Msgs.Mpos = 0

	if bless == '-' {
		obj.Flags.Set(Cursed)
	}

	if obj.Kind == KindWeapon {
		g.initWeapon(obj, WeaponKind(obj.Which))

		if bless == '-' {
			obj.HPlus -= g.rnd(3) + 1
		}

		if bless == '+' {
			obj.HPlus += g.rnd(3) + 1
		}

		return
	}

	obj.ArmorClass = g.data.armorClass(obj.Which)
	if bless == '-' {
		obj.ArmorClass += g.rnd(3) + 1
	}

	if bless == '+' {
		obj.ArmorClass -= g.rnd(3) + 1
	}
}

// createRing sets up a wizard-created ring, prompting for a bonus on
// the bonus rings (the ring arm of wizard.c create_obj).
func (g *RogueGame) createRing(obj *Object) {
	//nolint:exhaustive // C-faithful: only the cases C handled (approved 2026-07-07)
	switch obj.RingKind() {
	case RingProtection, RingAddStrength, RingDexterity, RingIncreaseDamage:
		g.msg("blessing? (+,-,n)")
		bless := g.readchar()
		g.Msgs.Mpos = 0

		if bless == '-' {
			obj.Flags.Set(Cursed)
			obj.Bonus = -1
		} else {
			obj.Bonus = g.rnd(2) + 1
		}
	case RingAggravateMonsters, RingTeleportation:
		obj.Flags.Set(Cursed)
	}
}

// showMap prints out the whole map for the wizard (wizard.c show_map).
func (g *RogueGame) showMap() {
	hw := g.scr.Hw
	hw.Clear()

	for y := 1; y < NumLines-1; y++ {
		for x := range NumCols {
			isReal := g.Level.FlagsAt(y, x).Has(FReal)
			if !isReal {
				hw.Standout(true)
			}

			hw.MvAddCh(y, x, g.Level.Char(y, x))

			if !isReal {
				hw.Standout(false)
			}
		}
	}

	g.showWin("---More (level map)---")
}

// whatis identifies what a certain object is (wizard.c whatis).
func (g *RogueGame) whatis(insist bool, kind ObjectKind) {
	p := &g.Player
	if len(p.Pack) == 0 {
		g.msg("you don't have anything in your pack to identify")

		return
	}

	obj, ok := g.whatisPick(insist, kind)
	if !ok {
		return
	}

	//nolint:exhaustive // C-faithful: only the cases C handled (approved 2026-07-07)
	switch obj.Kind {
	case KindScroll:
		setKnow(obj, g.Items.Scrolls[:])
	case KindPotion:
		setKnow(obj, g.Items.Potions[:])
	case KindWand:
		setKnow(obj, g.Items.Sticks[:])
	case KindWeapon, KindArmor:
		obj.Flags.Set(Known)
	case KindRing:
		setKnow(obj, g.Items.Rings[:])
	}

	g.msg("%s", g.inventoryName(obj, false))
}

// whatisPick prompts for the item to identify, re-asking until a
// matching one is chosen when insist is set; ok is false when the
// player gives up (the prompt loop of wizard.c whatis).
func (g *RogueGame) whatisPick(insist bool, kind ObjectKind) (*Object, bool) {
	for {
		obj, _ := g.promptPackItem("identify", kind)

		if !insist {
			return obj, obj != nil
		}

		if g.NObjs == 0 {
			return nil, false
		}

		if obj == nil {
			g.msg("you must identify something")

			continue
		}

		if !matchesFilter(kind, obj) {
			g.msg("you must identify a %s", kind)

			continue
		}

		return obj, true
	}
}

// setKnow sets things up when we really know what a thing is (wizard.c
// set_know).
func setKnow(obj *Object, info []ObjInfo) {
	info[obj.Which].Know = true
	obj.Flags.Set(Known)
	info[obj.Which].Guess = ""
}

// The C type_name()/tlist table is gone: ObjectKind.String() carries the
// same vocabulary.

// teleport bamfs the hero someplace else (wizard.c teleport).
func (g *RogueGame) teleport() {
	p := &g.Player
	g.mvaddch(p.Pos.Y, p.Pos.X, g.floorAt())

	c, _ := g.findFloor(true)
	if g.roomIn(c) != p.Room {
		g.leaveRoom(p.Pos)
		p.Pos = c
		g.enterRoom(p.Pos)
	} else {
		p.Pos = c

		g.look(true)
	}

	g.mvaddch(p.Pos.Y, p.Pos.X, PlayerCh)
	// turn off ISHELD in case teleportation was done while fighting a
	// Flytrap
	if p.On(Held) {
		p.Flags.Clear(Held)
		p.VfHit = 0
		g.Monsters['F'-'A'].Stats.Dmg = dice("000x0")
	}

	g.NoMove = 0
	g.Count = 0
	g.Running = false
	g.flushType()
}