From 03d32fc788027cbc77ac096e317b9dc2a3b00db5 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Wed, 7 Oct 2026 20:04:57 +0200 Subject: [PATCH] Add tree, fallen-tree and ore differential parity harness Decodes every vanilla 26.3 tree, fallen_tree, ore and scattered_ore configured feature from the authenticated JAR, places each with both random kinds over layered synthetic worlds backed by native proto-chunk sections, and compares ordered writes, beehive occupants, post-processing marks, results, random tails and the final block diff with Rust. First run: 2783 of 3018 fixtures identical; every ore fixture matches. The remaining differences are StructureTemplate.updateShapeAtEdge neighbor shape updates (faceless vines and unsupported plants beside the tree), which the Rust world hook does not yet implement. Co-Authored-By: Claude Opus 5.5 (1M context) --- .../examples/tree_feature_fixture.rs | 337 ++++++++++++++++++ .../parity/VanillaTreeFeatureOracle.java | 148 ++++++++ tools/test_tree_feature_parity.py | 123 +++++++ 3 files changed, 608 insertions(+) create mode 100644 crates/horizon-world/examples/tree_feature_fixture.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTreeFeatureOracle.java create mode 100644 tools/test_tree_feature_parity.py diff --git a/crates/horizon-world/examples/tree_feature_fixture.rs b/crates/horizon-world/examples/tree_feature_fixture.rs new file mode 100644 index 000000000..0a16dc554 --- /dev/null +++ b/crates/horizon-world/examples/tree_feature_fixture.rs @@ -0,0 +1,337 @@ +//! Vanilla tree, fallen-tree and ore features over a layered synthetic world. +use horizon_core::{ + geometry::{Direction, VoxelShape}, + random::{LegacyRandom, RandomSource, XoroshiroRandom}, +}; +use horizon_world::{ + block_placement::BlockPlacementBindings, + block_properties::BlockPropertiesRegistry, + block_support::{BlockSupportRegistry, SupportType}, + collision::CachedCollisionRegistry, + dynamic_support::DynamicSupportWorld, + fluid::{FluidKind, FluidState, FluidStateTable}, + heightmap::HeightmapType, + nbt::{self, Limits, Tag}, + registry::{BlockRegistry, BlockStateId}, + worldgen::{ + anchor::WorldGenerationContext, + block_feature::FeatureBlockBindings, + feature::{FeatureBlocks, FeatureWorld}, + feature_catalog::FeatureCatalog, + placement::{PlacementContext, PlacementQueryError}, + state_provider::{StateProviderBindings, StateProviderCatalog}, + tags::TagDefinitions, + }, +}; +use serde_json::Value; +use std::{ + collections::{BTreeMap, BTreeSet, HashMap}, + fs, + io::{self, BufRead, Write}, + path::Path, + sync::Arc, +}; + +const MIN_Y: i32 = -64; +const HEIGHT: i32 = 384; + +struct Terrain { + layers: Vec<[i32; 2]>, + hole: [i32; 2], + obstacle: [i32; 3], + overrides: HashMap<[i32; 3], u32>, + air: u32, +} +impl Terrain { + fn new(f: &Value, air: u32) -> Self { + let n = |key: &str| f[key].as_i64().unwrap() as i32; + Self { + layers: f["layers"] + .as_array() + .unwrap() + .iter() + .map(|l| [l[0].as_i64().unwrap() as i32, l[1].as_i64().unwrap() as i32]) + .collect(), + hole: [n("hole_mod"), n("hole_state")], + obstacle: [n("obstacle_mod"), n("obstacle_state"), n("obstacle_min")], + overrides: f["states"] + .as_array() + .unwrap() + .iter() + .map(|v| { + ( + std::array::from_fn(|i| v[i].as_i64().unwrap() as i32), + v[3].as_u64().unwrap() as u32, + ) + }) + .collect(), + air, + } + } + fn hash(x: i32, y: i32, z: i32) -> i32 { + let mut h = x.wrapping_mul(73856093) ^ y.wrapping_mul(19349663) ^ z.wrapping_mul(83492791); + h ^= ((h as u32) >> 13) as i32; + h = h.wrapping_mul(0x5bd1e995); + h ^= ((h as u32) >> 15) as i32; + h & 0x7fff_ffff + } + fn at(&self, [x, y, z]: [i32; 3]) -> BlockStateId { + if let Some(state) = self.overrides.get(&[x, y, z]) { + return BlockStateId(*state); + } + let h = Self::hash(x, y, z); + if let Some(layer) = self.layers.iter().find(|l| y <= l[0]) { + if self.hole[0] > 0 && h % self.hole[0] == 0 { + return BlockStateId(self.hole[1] as u32); + } + return BlockStateId(layer[1] as u32); + } + if self.obstacle[0] > 0 && y >= self.obstacle[2] && h % self.obstacle[0] == 0 { + return BlockStateId(self.obstacle[1] as u32); + } + BlockStateId(self.air) + } +} + +struct World<'a, 'r, W> { + out: &'a mut W, + terrain: Terrain, + overlay: BTreeMap<[i32; 3], BlockStateId>, + void_air: BlockStateId, + height: i32, + fluids: &'a FluidStateTable, + tags: &'a BTreeMap>, + support: &'a BlockSupportRegistry<'r>, +} +impl World<'_, '_, W> { + fn get(&self, p: [i32; 3]) -> BlockStateId { + if p[1] < MIN_Y || p[1] >= MIN_Y + HEIGHT { + return self.void_air; + } + self.overlay + .get(&p) + .copied() + .unwrap_or_else(|| self.terrain.at(p)) + } +} +fn query(error: impl std::fmt::Display) -> PlacementQueryError { + PlacementQueryError::Failed(error.to_string()) +} +impl FeatureWorld for World<'_, '_, W> { + type Error = io::Error; + fn block(&mut self, p: [i32; 3]) -> io::Result { + Ok(self.get(p)) + } + fn set_block(&mut self, p: [i32; 3], state: BlockStateId, flags: i32) -> io::Result { + writeln!(self.out, "set {} {} {} {} {flags}", p[0], p[1], p[2], state.0)?; + if p[1] < MIN_Y || p[1] >= MIN_Y + HEIGHT { + return Ok(false); + } + self.overlay.insert(p, state); + Ok(true) + } +} +impl DynamicSupportWorld for World<'_, '_, W> { + type Error = io::Error; + fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result> { + Ok(None) + } + fn moving_piston_shape(&mut self, _: [i32; 3]) -> io::Result> { + Ok(None) + } +} +impl PlacementContext for World<'_, '_, W> { + fn generation(&self) -> WorldGenerationContext { + WorldGenerationContext::new(MIN_Y, HEIGHT, 63) + } + fn min_y(&mut self) -> Result { + Ok(MIN_Y) + } + fn max_y(&mut self) -> Result { + Ok(MIN_Y + HEIGHT - 1) + } + fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result { + Ok(self.height) + } + fn block_state(&mut self, p: [i32; 3]) -> Result { + Ok(self.get(p)) + } + fn fluid_state(&mut self, p: [i32; 3]) -> Result { + self.fluids + .get(self.get(p)) + .ok_or_else(|| query("unknown fluid")) + } + fn block_matches_tag(&mut self, p: [i32; 3], tag: &str) -> Result { + let state = self.get(p); + Ok(self.tags.get(tag).is_some_and(|s| s.contains(&state))) + } + fn state_face_sturdy( + &mut self, + state: BlockStateId, + p: [i32; 3], + direction: Direction, + ) -> Result { + let support = self.support; + support + .is_face_sturdy(self, state, p, direction, SupportType::Full) + .map_err(query) + } + fn face_sturdy(&mut self, p: [i32; 3], direction: Direction) -> Result { + let state = self.get(p); + self.state_face_sturdy(state, p, direction) + } + fn mark_postprocessing(&mut self, p: [i32; 3]) -> Result<(), PlacementQueryError> { + writeln!(self.out, "post {} {} {}", p[0], p[1], p[2]).map_err(query) + } + fn set_section_block(&mut self, p: [i32; 3], state: BlockStateId) -> Result<(), PlacementQueryError> { + self.overlay.insert(p, state); + Ok(()) + } + fn store_beehive_occupants(&mut self, p: [i32; 3], ticks: &[i32]) -> Result<(), PlacementQueryError> { + for t in ticks { + writeln!(self.out, "bee {} {} {} {t}", p[0], p[1], p[2]).map_err(query)?; + } + Ok(()) + } +} + +#[allow(clippy::too_many_arguments)] +fn fixture( + f: &Value, + mut random: R, + catalog: &FeatureCatalog, + features: &BTreeMap, + bindings: &FeatureBlockBindings<'_>, + blocks: FeatureBlocks, + world: &mut World<'_, '_, impl Write>, +) -> io::Result<()> { + let name = f["feature"].as_str().unwrap(); + writeln!(world.out, "fixture {name}")?; + let feature = match catalog.feature_with_blocks(&features[name], bindings) { + Ok(feature) => feature, + Err(error) => { + eprintln!("decode {name}: {error}"); + return writeln!(world.out, "decode error"); + } + }; + let origin = std::array::from_fn(|i| f["origin"][i].as_i64().unwrap() as i32); + match feature.place(world, &mut random, origin, blocks) { + Ok(result) => writeln!(world.out, "place {result}")?, + Err(error) => writeln!(world.out, "place error {error}")?, + } + writeln!(world.out, "next {}", random.next_long())?; + let changes: Vec<_> = world + .overlay + .iter() + .filter(|(p, state)| world.terrain.at(**p) != **state) + .map(|(p, s)| (*p, *s)) + .collect(); + for (p, state) in changes { + writeln!(world.out, "final {} {} {} {}", p[0], p[1], p[2], state.0)?; + } + writeln!(world.out, "end") +} + +fn main() -> Result<(), Box> { + let arg = std::env::args().nth(1).expect("private fixture directory"); + let dir = Path::new(&arg); + let read = |name: &str| -> Result> { + Ok(nbt::read_named(&fs::read(dir.join(name))?, Limits::default())?.0.tag) + }; + let registry = BlockRegistry::from_nbt(&read("block-registry.nbt")?)?; + let collisions = CachedCollisionRegistry::from_nbt(&read("cached-collision.nbt")?, ®istry)?; + let properties = BlockPropertiesRegistry::from_nbt(&read("block-properties.nbt")?, &collisions)?; + let support = BlockSupportRegistry::from_nbt(&read("cached-support.nbt")?, ®istry)?; + let resources: BTreeMap = + serde_json::from_str(&fs::read_to_string(dir.join("tags.json"))?)?; + let mut tags = TagDefinitions::default(); + for (name, text) in resources { + tags.apply_json(&name, "vanilla", &text)?; + } + let tags = tags.build(|name, _| registry.default_state(name).map(|_| name.to_owned()))?; + let fluid_resources: BTreeMap = + serde_json::from_str(&fs::read_to_string(dir.join("fluid-tags.json"))?)?; + let mut fluid_tags = TagDefinitions::default(); + for (name, text) in fluid_resources { + fluid_tags.apply_json(&name, "vanilla", &text)?; + } + let fluid_tags = + fluid_tags.build(|name, _| FluidKind::from_name(name).map(|_| name.to_owned()))?; + let facts: Value = serde_json::from_str(&fs::read_to_string(dir.join("facts.json"))?)?; + let integers: BTreeSet<(String, String)> = facts["integers"] + .as_array() + .unwrap() + .iter() + .map(|v| (v[0].as_str().unwrap().to_owned(), v[1].as_str().unwrap().to_owned())) + .collect(); + let bundle: Value = + serde_json::from_str(&fs::read_to_string(dir.join("vanilla-features.json"))?)?; + let providers: BTreeMap = serde_json::from_value(bundle["providers"].clone())?; + let features: BTreeMap = serde_json::from_value(bundle["features"].clone())?; + let definitions: Value = + serde_json::from_str(&fs::read_to_string(dir.join("placement-definitions.json"))?)?; + let bindings = FeatureBlockBindings::with_tags(®istry, integers.clone(), &tags.tags)? + .with_block_properties(&properties)? + .with_fluid_tags(&fluid_tags.tags)? + .with_state_providers( + StateProviderBindings::new(®istry, integers, &tags.tags)? + .with_block_properties(&properties)? + .with_fluid_tags(&fluid_tags.tags)?, + StateProviderCatalog::from_resources(&providers)?, + BlockPlacementBindings::new( + ®istry, + &properties, + &serde_json::from_value(definitions["double_plants"].clone())?, + &serde_json::from_value(definitions["mossy_carpets"].clone())?, + )?, + )?; + let catalog = FeatureCatalog::from_resources(&features, &BTreeMap::new(), &TagDefinitions::default())?; + let blocks = FeatureBlocks::from_registry(®istry)?; + let fluids = FluidStateTable::new(®istry)?; + let mut by_name = BTreeMap::>::new(); + for id in 0..registry.len() { + let id = BlockStateId(id as u32); + by_name + .entry(registry.state(id).unwrap().name.clone()) + .or_default() + .push(id); + } + let tag_states: BTreeMap> = tags + .tags + .iter() + .map(|(name, entries)| { + ( + name.clone(), + entries + .iter() + .flat_map(|e| by_name.get(e).into_iter().flatten().copied()) + .collect(), + ) + }) + .collect(); + let support = Arc::new(support); + let air = registry.default_state("minecraft:air").unwrap().0; + let void_air = registry.default_state("minecraft:void_air").unwrap(); + let mut out = io::BufWriter::new(fs::File::create(dir.join("rust.txt"))?); + for line in io::BufReader::new(fs::File::open(dir.join("inputs.txt"))?).lines() { + let f: Value = serde_json::from_str(&line?)?; + let mut world = World { + out: &mut out, + terrain: Terrain::new(&f, air), + overlay: BTreeMap::new(), + void_air, + height: f["height"].as_i64().unwrap() as i32, + fluids: &fluids, + tags: &tag_states, + support: &support, + }; + let seed = f["seed"].as_i64().unwrap(); + if f["legacy"].as_bool().unwrap() { + fixture(&f, LegacyRandom::new(seed), &catalog, &features, &bindings, blocks, &mut world)?; + } else { + fixture(&f, XoroshiroRandom::new(seed), &catalog, &features, &bindings, blocks, &mut world)?; + } + } + out.flush()?; + Ok(()) +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTreeFeatureOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTreeFeatureOracle.java new file mode 100644 index 000000000..34b5da571 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaTreeFeatureOracle.java @@ -0,0 +1,148 @@ +package dev.horizonlab.parity; +import com.google.gson.*; +import com.mojang.serialization.JsonOps; +import java.io.*; +import java.lang.reflect.*; +import java.nio.file.*; +import java.util.*; +import net.minecraft.core.*; +import net.minecraft.core.registries.*; +import net.minecraft.resources.*; +import net.minecraft.util.RandomSource; +import net.minecraft.world.level.*; +import net.minecraft.world.level.biome.*; +import net.minecraft.world.level.block.*; +import net.minecraft.world.level.block.entity.*; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.*; +import net.minecraft.world.level.levelgen.*; +import net.minecraft.world.level.levelgen.feature.Feature; +import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProvider; + +/** + * Actual native tree, fallen-tree and ore features over a layered synthetic + * world backed by proto-chunk sections. Logs ordered level writes, beehive + * occupants, post-processing marks, results, random tails and the final diff. + */ +public final class VanillaTreeFeatureOracle { + private static final int MIN_Y=-64,HEIGHT=384; + private static BlockPos pos(JsonArray a){return new BlockPos(a.get(0).getAsInt(),a.get(1).getAsInt(),a.get(2).getAsInt());} + private static String xyz(BlockPos p){return p.getX()+" "+p.getY()+" "+p.getZ();} + private static final class Chunks { + static final PalettedContainerFactory FACTORY; + static { + Holder biome=Holder.Reference.createStandAlone(new HolderOwner(){},Biomes.PLAINS); + var ids=new IdMapper>();ids.add(biome); + FACTORY=new PalettedContainerFactory(Strategy.createForBlockStates(Block.BLOCK_STATE_REGISTRY),Blocks.AIR.defaultBlockState(),null,Strategy.createForBiomes(ids),biome,null); + } + } + /** Shared with the Rust fixture: layered column, pseudo-random holes and obstacles, overrides. */ + static final class Terrain { + final int[][] layers;final int holeMod,holeState,obstacleMod,obstacleState,obstacleMin;final Map overrides=new HashMap<>(); + Terrain(JsonObject f){ + var raw=f.getAsJsonArray("layers");layers=new int[raw.size()][];for(int i=0;i>>13;h*=0x5bd1e995;h^=h>>>15;return h&0x7fffffff;} + int at(int x,int y,int z){ + var o=overrides.get(new BlockPos(x,y,z));if(o!=null)return o; + int base=-1;for(var l:layers)if(y<=l[0]){base=l[1];break;} + int h=hash(x,y,z); + if(base>=0){if(holeMod>0&&h%holeMod==0)return holeState;return base;} + if(obstacleMod>0&&y>=obstacleMin&&h%obstacleMod==0)return obstacleState; + return Block.getId(Blocks.AIR.defaultBlockState()); + } + } + private static final class World implements InvocationHandler { + final JsonObject f;final PrintWriter out;final Terrain terrain;final Map chunks=new HashMap<>();final Map hives=new HashMap<>(); + final RandomSource shapeRandom=RandomSource.create(0); + World(JsonObject f,PrintWriter out){this.f=f;this.out=out;this.terrain=new Terrain(f);} + ProtoChunk chunk(int cx,int cz){ + return chunks.computeIfAbsent(new ChunkPos(cx,cz),cp->{ + var chunk=new ProtoChunk(cp,UpgradeData.EMPTY,LevelHeightAccessor.create(MIN_Y,HEIGHT),Chunks.FACTORY,null){ + @Override public void markPosForPostProcessing(BlockPos position){out.println("post "+xyz(position));super.markPosForPostProcessing(position);} + }; + for(int s=0;s=MIN_Y+HEIGHT)return Blocks.VOID_AIR.defaultBlockState(); + return chunk(p.getX()>>4,p.getZ()>>4).getBlockState(p); + } + public Object invoke(Object proxy,Method method,Object[] args)throws Throwable { + String name=method.getName(); + switch(name){ + case "getBlockState":return get((BlockPos)args[0]); + case "getFluidState":return get((BlockPos)args[0]).getFluidState(); + case "isStateAtPosition":return ((java.util.function.Predicate)args[1]).test(get((BlockPos)args[0])); + case "isFluidAtPosition":return ((java.util.function.Predicate)args[1]).test(get((BlockPos)args[0]).getFluidState()); + case "getMinY":return MIN_Y; + case "getSeaLevel":return 63; + case "ensureCanWrite":return true; + case "getRandom":return shapeRandom; + case "scheduleTick":return null; + case "setCurrentlyGenerating":return null; + case "getBlockEntity":{ + if(args.length!=1)break;var p=((BlockPos)args[0]).immutable();var state=get(p); + if(!state.is(Blocks.BEE_NEST))return null; + return hives.computeIfAbsent(p,key->new BeehiveBlockEntity(key,state){@Override public void storeBee(BeehiveBlockEntity.Occupant occupant){out.println("bee "+xyz(key)+" "+occupant.ticksInHive());}}); + } + case "setBlock":{ + var p=((BlockPos)args[0]).immutable();var state=(BlockState)args[1];out.println("set "+xyz(p)+" "+Block.getId(state)+" "+args[2]); + if(p.getY()=MIN_Y+HEIGHT)return false; + chunk(p.getX()>>4,p.getZ()>>4).getSection((p.getY()-MIN_Y)>>4).setBlockState(p.getX()&15,p.getY()&15,p.getZ()&15,state,false);return true; + } + case "getHeight":if(args==null||args.length==0)return HEIGHT;return f.get("height").getAsInt(); + case "getChunk": + if(args.length==1&&args[0] instanceof BlockPos p)return chunk(p.getX()>>4,p.getZ()>>4); + if(args.length>=2&&args[0] instanceof Integer x&&args[1] instanceof Integer z)return chunk(x,z); + break; + default:break; + } + if(method.isDefault())return InvocationHandler.invokeDefault(proxy,method,args); + throw new AssertionError(method); + } + } + @SuppressWarnings("unchecked") + public static void main(String[] args)throws Exception { + net.minecraft.SharedConstants.tryDetectVersion();net.minecraft.server.Bootstrap.bootStrap();Path dir=Path.of(args[1]); + VanillaHeightmapOracle.bindTags(JsonParser.parseString(Files.readString(dir.resolve("tags.json"))).getAsJsonObject()); + var bind=VanillaBlockSurvivalOracle.class.getDeclaredMethod("bindFluidTags",JsonObject.class);bind.setAccessible(true);bind.invoke(null,JsonParser.parseString(Files.readString(dir.resolve("fluid-tags.json"))).getAsJsonObject()); + var providers=new MappedRegistry(Registries.BLOCK_STATE_PROVIDER,com.mojang.serialization.Lifecycle.stable()); + var ops=RegistryOps.create(JsonOps.INSTANCE,new RegistryOps.RegistryInfoLookup(){public Optional> lookup(ResourceKey> key){ + if(key.equals(Registries.BLOCK_STATE_PROVIDER))return (Optional>)(Optional)Optional.of(providers); + if(key.equals(Registries.FLUID))return (Optional>)(Optional)Optional.of(BuiltInRegistries.FLUID); + return key.equals(Registries.BLOCK)?(Optional>)(Optional)Optional.of(BuiltInRegistries.BLOCK):Optional.empty(); + }}); + var bundle=JsonParser.parseString(Files.readString(dir.resolve("vanilla-features.json"))).getAsJsonObject(); + for(var entry:bundle.getAsJsonObject("providers").entrySet()) + providers.register(ResourceKey.create(Registries.BLOCK_STATE_PROVIDER,Identifier.parse(entry.getKey())),BlockStateProvider.DIRECT_CODEC.parse(ops,JsonParser.parseString(entry.getValue().getAsString())).getOrThrow(),RegistrationInfo.BUILT_IN); + providers.freeze(); + var features=bundle.getAsJsonObject("features"); + try(var out=new PrintWriter(Files.newBufferedWriter(dir.resolve(args[0]+".txt")));var inputs=Files.lines(dir.resolve("inputs.txt"))) { + for(var line:(Iterable)inputs::iterator){ + var f=JsonParser.parseString(line).getAsJsonObject();long seed=f.get("seed").getAsLong(); + RandomSource random=f.get("legacy").getAsBoolean()?new LegacyRandomSource(seed):new XoroshiroRandomSource(seed); + out.println("fixture "+f.get("feature").getAsString()); + Optional decoded; + try{decoded=Feature.DIRECT_CODEC.parse(ops,JsonParser.parseString(features.get(f.get("feature").getAsString()).getAsString())).result();}catch(RuntimeException error){decoded=Optional.empty();} + if(decoded.isEmpty()){out.println("decode error");continue;} + var handler=new World(f,out);var world=(WorldGenLevel)Proxy.newProxyInstance(WorldGenLevel.class.getClassLoader(),new Class[]{WorldGenLevel.class},handler); + try{out.println("place "+decoded.get().place(world,null,random,pos(f.getAsJsonArray("origin"))));}catch(RuntimeException error){out.println("place error "+error);} + out.println("next "+random.nextLong()); + var keys=new ArrayList<>(handler.chunks.keySet());keys.sort(Comparator.comparingInt(ChunkPos::x).thenComparingInt(ChunkPos::z)); + var changes=new TreeMap(Comparator.comparingInt(BlockPos::getX).thenComparingInt(BlockPos::getY).thenComparingInt(BlockPos::getZ)); + for(var key:keys){var chunk=handler.chunks.get(key); + for(int y=MIN_Y;y>4).getBlockState(lx,y&15,lz)); + if(id!=handler.terrain.at(x,y,z))changes.put(new BlockPos(x,y,z),id); + }} + for(var e:changes.entrySet())out.println("final "+xyz(e.getKey())+" "+e.getValue()); + out.println("end"); + } + } + } +} diff --git a/tools/test_tree_feature_parity.py b/tools/test_tree_feature_parity.py new file mode 100644 index 000000000..6886044e1 --- /dev/null +++ b/tools/test_tree_feature_parity.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +"""Compare vanilla tree, fallen-tree and ore features block-for-block with vanilla.""" +import argparse +import json +import os +from pathlib import Path +import platform +import subprocess +import zipfile +try: + from . import lab, test_rust_parity as base, test_worldgen_parity as worldgen, test_block_survival_parity as survival +except ImportError: + import lab + import test_rust_parity as base + import test_worldgen_parity as worldgen + import test_block_survival_parity as survival + + +def feature_resources(jar): + """Vanilla configured features and named state providers from the authenticated JAR.""" + result={'features':{},'providers':{}} + with zipfile.ZipFile(jar) as archive: + for kind,key in [('feature','features'),('block_state_provider','providers')]: + prefix=f'data/minecraft/worldgen/{kind}/' + for name in sorted(archive.namelist()): + if name.startswith(prefix) and name.endswith('.json'): + result[key]['minecraft:'+name[len(prefix):-5]]=archive.read(name).decode('utf-8') + return result + + +def fixture_hashes(paths): + # Build outputs may live behind a linked private directory outside ROOT. + return {path.name:lab.digest(path,'sha256') for path in paths} + + +def corpus(facts,resources): + get=lambda name:facts['defaults']['minecraft:'+name] + def fixture(feature,**extra): + f={'feature':feature,'seed':0,'legacy':False,'origin':[8,65,8],'height':65,'layers':[[59,get('stone')],[63,get('dirt')],[64,get('grass_block')]], + 'hole_mod':0,'hole_state':get('air'),'obstacle_mod':0,'obstacle_state':get('air'),'obstacle_min':0,'states':[]} + f.update(extra);return f + seeds=[0,1,-1,0x5DEECE66D,0x123456789abcdef,-8070450532247928832] + origins=[[8,65,8],[15,65,0],[0,65,15],[-1,65,-17],[31,65,-16],[100003,65,-4097]] + trees,ores=[],[] + for name,text in resources['features'].items(): + value=json.loads(text);kind=value['type'].removeprefix('minecraft:') + if kind in ('tree','fallen_tree'): + if 'pale_moss' in text:continue # needs the level's feature registry and server level + trees.append(name) + elif kind in ('ore','scattered_ore'):ores.append(name) + worlds=[ + {}, + {'obstacle_mod':37,'obstacle_state':get('oak_leaves'),'obstacle_min':66}, + {'obstacle_mod':23,'obstacle_state':get('stone'),'obstacle_min':65}, + {'obstacle_mod':19,'obstacle_state':get('vine'),'obstacle_min':65}, + {'layers':[[59,get('stone')],[64,get('mud')],[67,get('water')]],'height':68}, + {'layers':[[300,get('stone')],[310,get('dirt')],[311,get('grass_block')]],'origin_y':312,'height':312}, + {'layers':[[59,get('stone')],[63,get('dirt')],[64,get('podzol')]],'hole_mod':11,'hole_state':get('short_grass')}, + ] + for name in trees: + for w,world in enumerate(worlds): + for s,seed in enumerate(seeds): + extra=dict(world);origin=list(origins[(s+w)%len(origins)]);origin[1]=extra.pop('origin_y',extra.get('height',65)) + yield fixture(name,seed=seed,legacy=s%3==2,origin=origin,**extra) + ore_worlds=[ + {'layers':[[-1,get('deepslate')],[250,get('stone')]],'height':251}, + {'layers':[[-1,get('deepslate')],[250,get('stone')]],'height':251,'hole_mod':5,'hole_state':get('air')}, + {'layers':[[-1,get('deepslate')],[250,get('stone')]],'height':-100}, + {'layers':[[250,get('netherrack')]],'height':251,'hole_mod':9,'hole_state':get('cave_air')}, + {'layers':[[30,get('tuff')],[250,get('granite')]],'height':251,'hole_mod':13,'hole_state':get('water')}, + ] + for name in ores: + for w,world in enumerate(ore_worlds): + for s,seed in enumerate(seeds): + origin=list(origins[(s+w)%len(origins)]);origin[1]=[-60,-3,0,40,316,-64][(s*5+w)%6] + yield fixture(name,seed=seed,legacy=s%3==2,origin=origin,**world) + + +def main(): + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--prepare',action='store_true');args=parser.parse_args() + build=lab.LOCAL/'rust-tree-feature-parity';build.mkdir(parents=True,exist_ok=True);report_path=build/'report.json';report_path.unlink(missing_ok=True) + if args.prepare:lab.prepare() + lock,jars,libraries=base.verify_artifacts();parity=lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity' + oracle=parity/'VanillaTreeFeatureOracle.java';exporter=parity/'VanillaSimpleBlockOracle.java' + helpers=[parity/(name+'.java') for name in ['VanillaPlacementOracle','VanillaBlockSurvivalOracle','VanillaBlockPropertiesOracle','VanillaBlockSupportOracle','VanillaBlockStateCodecOracle','VanillaCollisionOracle','VanillaHeightmapOracle']] + sources=[oracle,exporter,*helpers,Path(__file__),*[lab.ROOT/'tools'/name for name in ['test_block_survival_parity.py','test_worldgen_parity.py','test_rust_parity.py','lab.py']],lab.ROOT/'Cargo.toml',lab.ROOT/'Cargo.lock', + *sorted((lab.ROOT/'crates/horizon-core/src').rglob('*.rs')),*sorted((lab.ROOT/'crates/horizon-world/src').rglob('*.rs')),lab.ROOT/'crates/horizon-world/examples/tree_feature_fixture.rs'] + tested_sources=base.source_hashes(sources);classes=build/'classes';classes.mkdir(exist_ok=True) + def run(command,name): + with (build/(name+'.log')).open('w',encoding='utf-8') as log:subprocess.run(list(map(str,command)),cwd=lab.ROOT,check=True,timeout=7200,stdout=log,stderr=subprocess.STDOUT) + dependency_path=os.pathsep.join(map(str,libraries)) + def java(main_class,side,mode,path):run(['java','-Xmx2G','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.'+main_class,mode,path],side+'-'+mode) + tags=worldgen.tag_resources(jars['server']);fluid_tags=survival.fluid_tag_resources(jars['server']);resources=feature_resources(jars['server']) + if tags!=worldgen.tag_resources(jars['client']) or fluid_tags!=survival.fluid_tag_resources(jars['client']) or resources!=feature_resources(jars['client']):raise ValueError('reference resources differ') + for name,value in [('tags.json',tags),('fluid-tags.json',fluid_tags),('vanilla-features.json',resources)]:(build/name).write_text(json.dumps(value,separators=(',',':'))) + run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-cp',str(jars['server'])+os.pathsep+dependency_path,'-d',classes,oracle,exporter,*helpers],'compile-java') + for side in jars: + export=build/(side+'-definitions');export.mkdir(exist_ok=True);java('VanillaSimpleBlockOracle',side,'export',export) + for path in (build/'server-definitions').iterdir(): + if path.read_bytes()!=(build/'client-definitions'/path.name).read_bytes():raise ValueError('reference definitions differ: '+path.name) + (build/path.name).write_bytes(path.read_bytes()) + facts=json.loads((build/'facts.json').read_text()) + inputs=build/'inputs.txt';count=0 + with inputs.open('w',encoding='utf-8') as output: + for fixture in corpus(facts,resources):output.write(json.dumps(fixture,separators=(',',':'))+'\n');count+=1 + fixtures=[inputs,*sorted(build.glob('*.nbt')),*[p for p in sorted(build.glob('*.json')) if p.name!='report.json']];tested_fixtures=fixture_hashes(fixtures) + print(f'Prepared {count:,} feature fixtures',flush=True) + run(['cargo','build','--release','-p','horizon-world','--example','tree_feature_fixture'],'compile-rust') + metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True)) + binary=Path(metadata['target_directory'])/'release/examples'/('tree_feature_fixture.exe' if os.name=='nt' else 'tree_feature_fixture') + run([binary,build],'rust');references=[] + for side,jar in jars.items(): + java('VanillaTreeFeatureOracle',side,side,build);matched=base.compare(build/(side+'.txt'),build/'rust.txt');print(f'{side}: {matched:,} tree/ore output lines match Rust',flush=True) + references.append({'side':side,'jar_sha256':lab.digest(jar,'sha256'),'output_sha256':lab.digest(build/(side+'.txt'),'sha256'),'matched_output_lines':matched}) + base.ensure_sources_unchanged(sources,tested_sources); + if fixture_hashes(fixtures)!=tested_fixtures:raise ValueError('fixtures changed during the run') + report={'schema':1,'minecraft':lock['minecraft']['version'],'manifest_sha1':lock['minecraft']['manifest_sha1'],'platform':platform.platform(),'java':subprocess.check_output(['java','--version'],text=True).splitlines()[0], + 'rustc':subprocess.check_output(['rustc','--version'],text=True).strip(),'fixtures':count,'sources_sha256':tested_sources,'fixtures_sha256':tested_fixtures,'rust_output_sha256':lab.digest(build/'rust.txt','sha256'),'references':references, + 'scope':'Every vanilla 26.3 minecraft:tree (except pale-moss decorated), minecraft:fallen_tree, minecraft:ore and minecraft:scattered_ore configured feature, decoded from the authenticated JAR data, placed with both random kinds over layered synthetic worlds (open ground, leaf/stone/vine obstacles, flooded mud, near the build limit, podzol with grass) backed by native proto-chunk sections. Ordered level writes and flags, beehive occupants, post-processing marks, results, random tails and the final block diff of every touched chunk are compared, including native leaf distances and edge shape updates. Pale-moss ground patches, real WorldGenRegion write policy, heightmaps and decoration scheduling remain covered elsewhere or pending.'} + lab.write_json(report_path,report);print(f'Scoped tree/ore feature parity passed: {report_path}',flush=True) + + +if __name__=='__main__':main()