122 lines
3.3 KiB
Go
122 lines
3.3 KiB
Go
package world
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"io"
|
|
"math"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
const vanillaParityFixture = "testdata/vanilla_overworld_12345.bin"
|
|
|
|
func TestVanillaBlockParity(t *testing.T) {
|
|
f, err := os.Open(vanillaParityFixture)
|
|
if err != nil {
|
|
if os.Getenv("REGIONIO_REQUIRE_PARITY") == "1" {
|
|
t.Fatalf("required parity fixture: %v", err)
|
|
}
|
|
t.Skip("vanilla block fixture not installed; run cmd/vanillacapture with Java 25")
|
|
}
|
|
defer f.Close()
|
|
|
|
var header [24]byte
|
|
if _, err := io.ReadFull(f, header[:]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(header[:8]) != "RIOPAR01" {
|
|
t.Fatalf("bad parity fixture magic %q", header[:8])
|
|
}
|
|
seed := int64(binary.BigEndian.Uint64(header[8:16]))
|
|
count := int(binary.BigEndian.Uint32(header[16:20]))
|
|
if seed != 12345 || count <= 0 {
|
|
t.Fatalf("fixture seed=%d chunks=%d", seed, count)
|
|
}
|
|
gen := NewVanillaGenerator(seed)
|
|
for chunkIndex := 0; chunkIndex < count; chunkIndex++ {
|
|
var coords [8]byte
|
|
if _, err := io.ReadFull(f, coords[:]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cx := int32(binary.BigEndian.Uint32(coords[:4]))
|
|
cz := int32(binary.BigEndian.Uint32(coords[4:]))
|
|
chunk := gen(cx, cz)
|
|
var state [2]byte
|
|
for y := MinY; y < MinY+WorldHeight; y++ {
|
|
for z := 0; z < 16; z++ {
|
|
for x := 0; x < 16; x++ {
|
|
if _, err := io.ReadFull(f, state[:]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := binary.BigEndian.Uint16(state[:])
|
|
if got := chunk.GetBlock(x, y, z); got != want {
|
|
t.Fatalf("chunk (%d,%d) block (%d,%d,%d): got state %d want %d", cx, cz, x, y, z, got, want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for y := MinY; y < MinY+WorldHeight; y += biomeCellSize {
|
|
for z := 0; z < 16; z += biomeCellSize {
|
|
for x := 0; x < 16; x += biomeCellSize {
|
|
if _, err := io.ReadFull(f, state[:]); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := binary.BigEndian.Uint16(state[:])
|
|
if got := chunk.GetBiome(x, y, z); got != want {
|
|
t.Fatalf("chunk (%d,%d) biome (%d,%d,%d): got %d want %d", cx, cz, x, y, z, got, want)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var trailing [1]byte
|
|
if n, err := f.Read(trailing[:]); n != 0 || err != io.EOF {
|
|
t.Fatalf("fixture has trailing data or read error: n=%d err=%v", n, err)
|
|
}
|
|
}
|
|
|
|
// TestVanillaParity compares our generated surface heights against heights
|
|
// captured from the official server (seed 12345, normal terrain). Requires
|
|
// /tmp/vanilla_ground.json from the capture step.
|
|
func TestVanillaParity(t *testing.T) {
|
|
raw, err := os.ReadFile("/tmp/vanilla_ground.json")
|
|
if err != nil {
|
|
t.Skip("no vanilla capture")
|
|
}
|
|
var van map[string][]int
|
|
json.Unmarshal(raw, &van)
|
|
|
|
gen := NewVanillaGenerator(12345)
|
|
var total, exact, within1, within3 int
|
|
var maxDiff int
|
|
for key, vh := range van {
|
|
parts := strings.Split(key, ",")
|
|
cx, _ := strconv.Atoi(parts[0])
|
|
cz, _ := strconv.Atoi(parts[1])
|
|
ch := gen(int32(cx), int32(cz))
|
|
oh := ch.columnHeights()
|
|
for idx := 0; idx < 256; idx++ {
|
|
ourY := int(oh[idx]) - 65
|
|
d := int(math.Abs(float64(ourY - vh[idx])))
|
|
total++
|
|
if d == 0 {
|
|
exact++
|
|
}
|
|
if d <= 1 {
|
|
within1++
|
|
}
|
|
if d <= 3 {
|
|
within3++
|
|
}
|
|
if d > maxDiff {
|
|
maxDiff = d
|
|
}
|
|
}
|
|
}
|
|
pct := func(n int) float64 { return 100 * float64(n) / float64(total) }
|
|
t.Logf("columns=%d exact=%.1f%% within1=%.1f%% within3=%.1f%% maxDiff=%d",
|
|
total, pct(exact), pct(within1), pct(within3), maxDiff)
|
|
}
|