rgoue/game/effects_test.go

package game

import "testing"

// mkGameInput builds a headless game; tests script it via setInput. The
// fixed seed keeps the scripted item/monster interactions stable.
func mkGameInput(t *testing.T) *RogueGame {
	t.Helper()

	g := NewGame(Config{Seed: 5, Term: &testTerm{}})
	g.NewLevel()
	g.Oldpos = g.Player.Pos
	g.Oldrp = g.roomin(g.Player.Pos)

	return g
}

// give puts an object straight into the pack and returns its pack letter.
func give(g *RogueGame, obj *Object) byte {
	obj.Count = 1
	g.addPack(obj, true)

	return obj.PackCh
}

// setInput replaces the scripted terminal input.
func setInput(t *testing.T, g *RogueGame, input ...byte) {
	t.Helper()

	tt, ok := g.scr.term.(*testTerm)
	if !ok {
		t.Fatal("game terminal is not a testTerm")
	}

	tt.input = input
	tt.pos = 0
}

func TestQuaffHealingPotion(t *testing.T) {
	g := mkGameInput(t)
	pot := newObject()
	pot.Kind = KindPotion
	pot.Which = int(PotionHealing)
	ch := give(g, pot)
	setInput(t, g, ch)

	g.Player.Stats.HP = 1
	g.quaff()

	if g.Player.Stats.HP <= 1 {
		t.Error("healing potion did not heal")
	}

	if !g.Items.Potions[PotionHealing].Know {
		t.Error("healing potion not identified after drinking")
	}

	if len(g.Player.Pack) != 5 {
		t.Errorf("potion not consumed: %d items", len(g.Player.Pack))
	}
}

func TestQuaffConfusionSetsFlagAndFuse(t *testing.T) {
	g := mkGameInput(t)
	pot := newObject()
	pot.Kind = KindPotion
	pot.Which = int(PotionConfusion)
	ch := give(g, pot)
	setInput(t, g, ch)

	g.quaff()

	if !g.Player.On(Confused) {
		t.Error("confusion potion did not confuse")
	}

	if g.findSlot(DUnconfuse) == nil {
		t.Error("no unconfuse fuse pending")
	}
	// Let the fuse burn down
	for range 30 {
		g.DoFuses(After)
	}

	if g.Player.On(Confused) {
		t.Error("confusion never wore off")
	}
}

func TestReadEnchantArmor(t *testing.T) {
	g := mkGameInput(t)
	scr := newObject()
	scr.Kind = KindScroll
	scr.Which = int(ScrollEnchantArmor)
	ch := give(g, scr)
	setInput(t, g, ch)

	before := g.Player.CurArmor.ArmorClass
	g.readScroll()

	if g.Player.CurArmor.ArmorClass != before-1 {
		t.Errorf("enchant armor: AC %d -> %d, want %d",
			before, g.Player.CurArmor.ArmorClass, before-1)
	}
}

func TestReadHoldMonsterFreezesAdjacent(t *testing.T) {
	// Note: this must not use a greedy monster ('O' orc, ISGREED): the C
	// wake_monster gold-guarding check has no ISHELD guard, so the
	// look(TRUE) at the end of read_scroll immediately re-wakes greedy
	// monsters. The port reproduces that quirk faithfully — see
	// TestHoldScrollGreedyMonsterQuirk.
	g := mkGameInput(t)
	tp := spawnAdjacent(g, 'Z')
	tp.Flags.Set(Awake)

	scr := newObject()
	scr.Kind = KindScroll
	scr.Which = int(ScrollHoldMonster)
	ch := give(g, scr)
	setInput(t, g, ch)

	g.readScroll()
	t.Logf("after scroll: flags=%o huh=%q", tp.Flags, g.Msgs.Huh)

	if tp.On(Awake) || !tp.On(Held) {
		t.Error("hold monster scroll did not hold the adjacent monster")
	}
}

// TestHoldScrollGreedyMonsterQuirk documents a C behavior the port keeps:
// wake_monster's ISGREED branch lacks an ISHELD guard, so a greedy monster
// (orc) held by a scroll is re-woken by the look(TRUE) that read_scroll
// performs, ending up both held and running again.
func TestHoldScrollGreedyMonsterQuirk(t *testing.T) {
	g := mkGameInput(t)
	tp := spawnAdjacent(g, 'O')
	tp.Flags.Set(Awake)

	scr := newObject()
	scr.Kind = KindScroll
	scr.Which = int(ScrollHoldMonster)
	ch := give(g, scr)
	setInput(t, g, ch)

	g.readScroll()
	t.Logf("orc after scroll: flags=%o (Awake=%v Held=%v)",
		tp.Flags, tp.On(Awake), tp.On(Held))

	if !tp.On(Held) {
		t.Error("orc lost Held entirely")
	}

	if !tp.On(Awake) {
		t.Error("quirk changed: greedy monster stayed held; if this is a " +
			"deliberate fix, update this test and ARCHITECTURE.md")
	}
}

func TestZapSlowMonster(t *testing.T) {
	g := mkGameInput(t)
	tp := spawnAdjacent(g, 'Z')
	stick := newObject()
	stick.Kind = KindWand
	stick.Which = int(WandSlowMonster)
	g.fixStick(stick)
	ch := give(g, stick)
	setInput(t, g, ch)

	g.Delta = Coord{X: 1, Y: 0} // aim at the monster

	charges := stick.Charges

	g.doZap()

	if !tp.On(Slowed) {
		t.Error("slow monster wand did not slow")
	}

	if stick.Charges != charges-1 {
		t.Error("zap did not use a charge")
	}
}

func TestParseOpts(t *testing.T) {
	g := NewGame(Config{Seed: 1})
	g.ParseOpts("terse,nojump,name=Conan,fruit=mango,inven=slow")

	if !g.Options.Terse {
		t.Error("terse not set")
	}

	if g.Options.Jump {
		t.Error("nojump not honored")
	}

	if g.Whoami != "Conan" {
		t.Errorf("name = %q", g.Whoami)
	}

	if g.Fruit != "mango" {
		t.Errorf("fruit = %q", g.Fruit)
	}

	if g.Options.InvType != InvSlow {
		t.Errorf("inven = %d", g.Options.InvType)
	}
}