rgoue/game/save_test.go

package game

import (
	"encoding/gob"
	"os"
	"path/filepath"
	"testing"
)

func TestSaveRestoreRoundTrip(t *testing.T) {
	g := mkGame(t, 4242)
	// Dirty up some state so the round trip is meaningful.
	g.Player.Purse = 123
	g.Player.FoodLeft = 777
	g.HasAmulet = true
	g.Items.Potions[PotionHealing].Know = true
	g.Items.Scrolls[ScrollMagicMapping].Guess = "map???"

	g.Monsters['F'-'A'].Stats.Dmg = dice("3x1") // mutated bestiary must survive
	if len(g.Level.Monsters) > 0 {
		g.Level.Monsters[0].Flags.Set(Awake)
		g.Level.Monsters[0].Dest = &g.Player.Pos
	}

	path := filepath.Join(t.TempDir(), "rogue.save")

	saveErr := g.saveFile(path)
	if saveErr != nil {
		t.Fatalf("saveFile: %v", saveErr)
	}

	h, err := Restore(path, Params{Term: &testTerm{}})
	if err != nil {
		t.Fatalf("Restore: %v", err)
	}

	_, statErr := os.Stat(path)
	if !os.IsNotExist(statErr) {
		t.Error("save file not deleted on restore (C anti-restart rule)")
	}

	checkRestoredState(t, g, h)
	checkRestoredMonsters(t, g, h)
	checkEquipmentAliasing(t, g, h)
}

// checkRestoredState verifies the scalar state survived the round trip.
func checkRestoredState(t *testing.T, g, h *RogueGame) {
	t.Helper()

	if h.Player.Purse != 123 || h.Player.FoodLeft != 777 {
		t.Errorf("player state lost: purse=%d food=%d",
			h.Player.Purse, h.Player.FoodLeft)
	}

	if !h.HasAmulet {
		t.Error("amulet flag lost")
	}

	if !h.Items.Potions[PotionHealing].Know {
		t.Error("potion identification lost")
	}

	if h.Items.Scrolls[ScrollMagicMapping].Guess != "map???" {
		t.Error("scroll guess lost")
	}

	if h.Monsters['F'-'A'].Stats.Dmg.String() != "3x1" {
		t.Error("mutated bestiary lost")
	}

	if h.Rng.Seed != g.Rng.Seed {
		t.Error("RNG state lost")
	}

	if renderMap(h) != renderMap(g) {
		t.Error("restored level map differs")
	}
}

// checkRestoredMonsters verifies the monster list and its pointer fixups
// survived the round trip.
func checkRestoredMonsters(t *testing.T, g, h *RogueGame) {
	t.Helper()

	if len(h.Level.Monsters) != len(g.Level.Monsters) {
		t.Fatalf("monster count %d != %d",
			len(h.Level.Monsters), len(g.Level.Monsters))
	}

	if len(g.Level.Monsters) == 0 {
		return
	}

	m := h.Level.Monsters[0]
	if m.Dest != &h.Player.Pos {
		t.Error("monster chase target not re-aliased to the hero")
	}

	if h.Level.MonsterAt(m.Pos.Y, m.Pos.X) != m {
		t.Error("map monster index not rebuilt")
	}

	if m.Room == nil {
		t.Error("monster room pointer not rebuilt")
	}
}

// checkEquipmentAliasing verifies the wielded mace is the same *Object as
// the one in the pack.
func checkEquipmentAliasing(t *testing.T, g, h *RogueGame) {
	t.Helper()

	st := g.snapshot()
	t.Logf("snapshot indices: weapon=%d armor=%d rings=%v packlen=%d",
		st.Player.CurWeapon, st.Player.CurArmor, st.Player.CurRing,
		len(st.Player.Body.Pack))
	t.Logf("restored: CurWeapon=%p pack has %d items", h.Player.CurWeapon,
		len(h.Player.Pack))

	found := false

	for i, o := range h.Player.Pack {
		t.Logf("  pack[%d]=%p type=%v which=%d", i, o, o.Kind, o.Which)

		if o == h.Player.CurWeapon {
			found = true
		}
	}

	if !found {
		t.Error("restored CurWeapon is not aliased into the pack")
	}
}

func TestRestoreRejectsWrongVersion(t *testing.T) {
	g := mkGame(t, 1)
	path := filepath.Join(t.TempDir(), "rogue.save")
	st := g.snapshot()
	st.Version = "0.0.0"

	f, err := os.Create(path) //nolint:gosec // G304: test temp path
	if err != nil {
		t.Fatal(err)
	}

	encErr := gob.NewEncoder(f).Encode(st)
	if encErr != nil {
		t.Fatal(encErr)
	}

	closeErr := f.Close()
	if closeErr != nil {
		t.Fatal(closeErr)
	}

	_, restoreErr := Restore(path, Params{})
	if restoreErr == nil {
		t.Error("restore accepted an out-of-date save")
	}
}