Initial commit: RegionIO Minecraft server core (26.1.2/protocol 775)

Vanilla-faithful overworld generator (final_density + multi-noise biomes),
full connection lifecycle (status/login/configuration/play), chunk streaming,
creative block editing, and the protocol/nbt/registry infrastructure.

internal/world/biome_lookup.go

@@ -0,0 +1,119 @@
+package world
+
+import (
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"sync"
+
+	"regionio/internal/registry"
+	"regionio/internal/worldgen"
+)
+
+//go:embed biome_parameters.json
+var biomeParametersJSON []byte
+
+// rawParameter mirrors one entry of biome_parameters.json: a biome name plus its
+// climate ranges. Each axis value is a [min, max] array; depth is normally a
+// scalar (0.0 surface / 1.0 underground) but a few cave entries carry a [min,
+// max] array, so it is decoded loosely (see depthScalar).
+type rawParameter struct {
+	Biome string `json:"biome"`
+	Param struct {
+		Temperature     [2]float64 `json:"temperature"`
+		Humidity        [2]float64 `json:"humidity"`
+		Continentalness [2]float64 `json:"continentalness"`
+		Erosion         [2]float64 `json:"erosion"`
+		Weirdness       [2]float64 `json:"weirdness"`
+		Depth           any        `json:"depth"`
+		Offset          float64    `json:"offset"`
+	} `json:"parameters"`
+}
+
+// depthScalar extracts a scalar depth from a raw entry, accepting either a JSON
+// number or a single-element [v] array. Arrays with a range are cave entries
+// (non-surface) and return ok=false so the caller skips them.
+func depthScalar(v any) (float64, bool) {
+	switch d := v.(type) {
+	case float64:
+		return d, true
+	case []any:
+		if len(d) == 1 {
+			if f, ok := d[0].(float64); ok {
+				return f, true
+			}
+		}
+	}
+	return 0, false
+}
+
+// surfaceTable is the biome parameter table filtered to depth=0 (surface layer),
+// built once at init. Cave/underground entries (depth=1, or non-zero offset for
+// lush/dripstone/deep_dark) are excluded until the per-cell milestone.
+var (
+	surfaceTable     *worldgen.ParameterTable
+	surfaceTableOnce sync.Once
+)
+
+// loadSurfaceTable parses the embedded biome parameters once and returns the
+// surface-only ParameterTable. Panics on a parse error (a corrupt embedded
+// table is a build-time bug, not a runtime condition).
+func loadSurfaceTable() *worldgen.ParameterTable {
+	surfaceTableOnce.Do(func() {
+		var raw struct {
+			Biomes []rawParameter `json:"biomes"`
+		}
+		if err := json.Unmarshal(biomeParametersJSON, &raw); err != nil {
+			panic(fmt.Sprintf("world: parsing embedded biome_parameters.json: %v", err))
+		}
+		params := make([]worldgen.BiomeParameter, 0, len(raw.Biomes)/2)
+		for _, e := range raw.Biomes {
+			// Surface layer only: depth resolves to the scalar 0.0, and no cave
+			// offset. Range/array depths and non-zero offsets belong to cave
+			// biomes (lush/dripstone/deep_dark), deferred to the per-cell stage.
+			dp, ok := depthScalar(e.Param.Depth)
+			if !ok || dp != 0.0 || e.Param.Offset != 0.0 {
+				continue
+			}
+			params = append(params, makeBiomeParameter(e, dp))
+		}
+		surfaceTable = worldgen.NewParameterTable(params)
+	})
+	return surfaceTable
+}
+
+// makeBiomeParameter converts a raw JSON entry into a BiomeParameter, mapping
+// the [min,max] ranges to quantized ClimateRanges. depth is a scalar in the
+// source but a [depth, depth] band in the table (a single value).
+func makeBiomeParameter(e rawParameter, depth float64) worldgen.BiomeParameter {
+	qr := func(a [2]float64) worldgen.ClimateRange {
+		return worldgen.ClimateRange{Min: worldgen.Quantize(a[0]), Max: worldgen.Quantize(a[1])}
+	}
+	dpQ := worldgen.Quantize(depth)
+	return worldgen.BiomeParameter{
+		Name: e.Biome,
+		Ranges: [worldgen.AxisCount]worldgen.ClimateRange{
+			qr(e.Param.Temperature),
+			qr(e.Param.Humidity),
+			qr(e.Param.Continentalness),
+			qr(e.Param.Erosion),
+			qr(e.Param.Weirdness),
+			{Min: dpQ, Max: dpQ + 1}, // half-open band covering exactly depth
+		},
+		Offset: worldgen.Quantize(e.Param.Offset),
+	}
+}
+
+// BiomeAt returns the network biome ID for the surface biome at block (wx, wz)
+// given the loaded overworld density. It samples the climate axes at sea level,
+// finds the matching biome in the parameter table, and resolves its name to a
+// numeric ID via the synchronized biome registry. Unknown biomes fall back to
+// plains so chunk encoding always gets a valid ID.
+func BiomeAt(od *worldgen.OverworldDensity, wx, wz int) uint16 {
+	point := worldgen.SampleColumn(od, SeaLevel, wx, wz)
+	name := loadSurfaceTable().FindBiome(point)
+	if id := registry.Index("minecraft:worldgen/biome", name); id >= 0 {
+		return uint16(id)
+	}
+	return BiomePlains
+}