rgoue/game/newlevel_test.go

package game

import (
	"strings"
	"testing"
)

func genLevel(t *testing.T, seed int32) *RogueGame {
	t.Helper()

	g := New(Params{Seed: seed})
	g.NewLevel()

	return g
}

// renderMap draws the raw level map (not the screen) as text.
func renderMap(g *RogueGame) string {
	var sb strings.Builder

	for y := range NumLines {
		for x := range NumCols {
			ch := g.Level.Char(y, x)
			if m := g.Level.MonsterAt(y, x); m != nil {
				ch = m.Type
			}

			sb.WriteByte(ch)
		}

		sb.WriteByte('\n')
	}

	return sb.String()
}

func TestNewLevelInvariants(t *testing.T) {
	for _, seed := range []int32{1, 12345, 2026, 99999} {
		g := genLevel(t, seed)

		checkHeroPlacement(t, g, seed)
		checkRoomsDrawn(t, g, seed)
		checkMonstersPlaced(t, g, seed)
		checkObjectsPlaced(t, g, seed)
		checkStartingKit(t, g, seed)
	}
}

// checkHeroPlacement verifies the staircase and hero landed on valid,
// unoccupied cells.
func checkHeroPlacement(t *testing.T, g *RogueGame, seed int32) {
	t.Helper()

	// The staircase is somewhere real.
	st := g.Level.Stairs
	if g.Level.Char(st.Y, st.X) != Stairs {
		t.Errorf("seed %d: no staircase at recorded stairs position", seed)
	}

	// The hero stands on a walkable, monster-free cell.
	hp := g.Player.Pos
	if !stepOk(g.Level.Char(hp.Y, hp.X)) {
		t.Errorf("seed %d: hero on unwalkable cell %q", seed,
			g.Level.Char(hp.Y, hp.X))
	}

	if g.Level.MonsterAt(hp.Y, hp.X) != nil {
		t.Errorf("seed %d: hero standing on a monster", seed)
	}

	if g.Player.Room == nil {
		t.Errorf("seed %d: hero not in any room", seed)
	}
}

// checkRoomsDrawn verifies rooms and floor/passages appear on the map.
func checkRoomsDrawn(t *testing.T, g *RogueGame, seed int32) {
	t.Helper()

	m := renderMap(g)
	if !strings.Contains(m, "|") || !strings.Contains(m, "-") {
		t.Errorf("seed %d: no room walls drawn", seed)
	}

	if !strings.Contains(m, ".") && !strings.Contains(m, "#") {
		t.Errorf("seed %d: no floor or passages drawn", seed)
	}
}

// checkMonstersPlaced verifies every monster is indexed on the map and
// placed in a room.
func checkMonstersPlaced(t *testing.T, g *RogueGame, seed int32) {
	t.Helper()

	for _, mon := range g.Level.Monsters {
		if g.Level.MonsterAt(mon.Pos.Y, mon.Pos.X) != mon {
			t.Errorf("seed %d: monster %c not indexed at its position",
				seed, mon.Type)
		}

		if mon.Room == nil {
			t.Errorf("seed %d: monster %c has no room", seed, mon.Type)
		}
	}
}

// checkObjectsPlaced verifies every level object sits on a cell
// displaying its type (items can share cells only with monsters standing
// on them).
func checkObjectsPlaced(t *testing.T, g *RogueGame, seed int32) {
	t.Helper()

	for _, obj := range g.Level.Objects {
		ch := g.Level.Char(obj.Pos.Y, obj.Pos.X)
		if ch != obj.Kind.Glyph() &&
			g.Level.MonsterAt(obj.Pos.Y, obj.Pos.X) == nil {
			t.Errorf("seed %d: object %v at (%d,%d) but map shows %q",
				seed, obj.Kind, obj.Pos.Y, obj.Pos.X, ch)
		}
	}
}

// checkStartingKit verifies the player has her starting kit: food, armor,
// mace, bow, arrows.
func checkStartingKit(t *testing.T, g *RogueGame, seed int32) {
	t.Helper()

	if len(g.Player.Pack) != 5 {
		t.Errorf("seed %d: starting pack has %d items, want 5",
			seed, len(g.Player.Pack))
	}

	if g.Player.CurWeapon == nil ||
		g.Player.CurWeapon.WeaponKind() != WeaponMace {
		t.Errorf("seed %d: not wielding the starting mace", seed)
	}

	if g.Player.CurArmor == nil ||
		g.Player.CurArmor.ArmorKind() != ArmorRingMail {
		t.Errorf("seed %d: not wearing the starting ring mail", seed)
	}
}

func TestNewLevelDeterministic(t *testing.T) {
	a := renderMap(genLevel(t, 12345))

	b := renderMap(genLevel(t, 12345))
	if a != b {
		t.Error("same seed produced different levels")
	}

	c := renderMap(genLevel(t, 54321))
	if a == c {
		t.Error("different seeds produced identical levels")
	}
}

// TestDeeperLevels exercises generation across many depths and seeds —
// mazes, dark rooms, traps, treasure rooms — as a crash/invariant sweep.
func TestDeeperLevels(t *testing.T) {
	for _, seed := range []int32{7, 42, 1000, 31337} {
		g := New(Params{Seed: seed})
		for depth := 1; depth <= 30; depth++ {
			g.Depth = depth
			g.NewLevel()

			st := g.Level.Stairs
			if g.Level.Char(st.Y, st.X) != Stairs {
				t.Fatalf("seed %d depth %d: missing staircase", seed, depth)
			}
		}
	}
}