Read 26.3 template block states and verify jigsaw starts against vanilla

Templates store palette states as id/properties; reading only Name made
every template block air. Add a vanilla oracle (structure placement, start
selection and Structure.generate over a chunk rectangle), a bench mode
dumping Rust starts in the same format, and a comparison script. For seed
0 over 97x97 chunks all 15 jigsaw starts (villages, trial chambers, trail
ruins, abandoned camps) match vanilla piece for piece.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-08 03:19:08 +02:00
parent f192d01eaa
commit c5fc4d7eb5
7 changed files with 311 additions and 7 deletions
@@ -146,6 +146,69 @@ fn verify(data: &std::sync::Arc<GeneratorData>, parity: &Path) -> Result<(), Err
}
}
/// Structure starts in the oracle's line format (VanillaStructureStartOracle).
fn dump_starts(
generator: &OverworldGenerator,
seed: i64,
[x0, z0, x1, z1]: [i32; 4],
out: &Path,
) -> Result<(), Error> {
use horizon_world::worldgen::structure::{Rotation, start::Piece};
let _ = seed;
let mut worker = generator.worker();
let mut lines = Vec::new();
let start = Instant::now();
for cx in x0..=x1 {
for cz in z0..=z1 {
for s in worker.structure_starts(ChunkPos::new(cx, cz)) {
let b = s.bounding_box;
lines.push(format!(
"start {cx} {cz} {} {} {} {} {} {} {} {}",
s.name,
b.min[0],
b.min[1],
b.min[2],
b.max[0],
b.max[1],
b.max[2],
s.pieces.len()
));
for piece in &s.pieces {
let Piece::Pool(p) = piece;
let b = p.bounding_box;
let rotation = match p.rotation {
Rotation::None => "NONE",
Rotation::Clockwise90 => "CLOCKWISE_90",
Rotation::Clockwise180 => "CLOCKWISE_180",
Rotation::Counterclockwise90 => "COUNTERCLOCKWISE_90",
};
lines.push(format!(
"piece minecraft:jigsaw {} {} {} {} {} {} {} {} {} {rotation} {} {}",
b.min[0],
b.min[1],
b.min[2],
b.max[0],
b.max[1],
b.max[2],
p.position[0],
p.position[1],
p.position[2],
p.ground_level_delta,
p.junctions.len()
));
}
}
}
}
println!(
"structure starts for {} chunks in {:.2?}",
(x1 - x0 + 1) * (z1 - z0 + 1),
start.elapsed()
);
fs::write(out, lines.join("\n") + "\n")?;
Ok(())
}
/// Process CPU seconds (Linux), robust against other load on shared machines.
fn cpu_seconds() -> f64 {
fs::read_to_string("/proc/self/stat")
@@ -198,6 +261,7 @@ fn main() -> Result<(), Error> {
let (mut seed, mut size, mut threads, mut center) = (0i64, 16i32, 2usize, (0, 0));
let mut parity = None;
let mut decorate = true;
let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None;
while let Some(arg) = args.next() {
let mut next = || args.next().expect("argument value");
match arg.as_str() {
@@ -207,6 +271,15 @@ fn main() -> Result<(), Error> {
"--center" => center = (next().parse()?, next().parse()?),
"--verify" => parity = Some(PathBuf::from(next())),
"--no-decorate" => decorate = false,
"--starts" => {
starts = Some((
next().parse()?,
next().parse()?,
next().parse()?,
next().parse()?,
PathBuf::from(next()),
))
}
_ => return Err(format!("unknown argument {arg}").into()),
}
}
@@ -220,6 +293,10 @@ fn main() -> Result<(), Error> {
let start = Instant::now();
let generator = OverworldGenerator::new(data.clone(), seed)?;
println!("seeded generator in {:.2?}", start.elapsed());
if let Some((x0, z0, x1, z1, out)) = starts {
dump_starts(&generator, seed, [x0, z0, x1, z1], &out)?;
return Ok(());
}
let (x0, z0) = (center.0 - size / 2, center.1 - size / 2);
let count = (size * size) as usize;
let next = AtomicUsize::new(0);
@@ -1264,6 +1264,11 @@ trait SeededPipeline: Send + Sync {
) -> Result<DecorateStats, GeneratorError>;
fn data(&self) -> &Arc<GeneratorData>;
fn sea_level(&self) -> i32;
fn structure_starts(
&self,
worker: &mut WorkerState,
pos: ChunkPos,
) -> Vec<Arc<super::structure::start::StructureStart>>;
fn unsupported_features(&self) -> Vec<(String, String)>;
}
impl<R: RandomSource + 'static> SeededPipeline for Pipeline<R>
@@ -1314,6 +1319,25 @@ where
fn sea_level(&self) -> i32 {
self.settings.sea_level
}
fn structure_starts(
&self,
worker: &mut WorkerState,
pos: ChunkPos,
) -> Vec<Arc<super::structure::start::StructureStart>> {
match &self.structures {
Some(structures) => structures
.starts_at(
&mut StructureQueries {
pipeline: self,
worker,
valid: BTreeSet::new(),
},
pos,
)
.to_vec(),
None => Vec::new(),
}
}
fn unsupported_features(&self) -> Vec<(String, String)> {
self.decoration
.as_ref()
@@ -1452,6 +1476,13 @@ impl GeneratorWorker {
self.state.timings.chunks += 1;
result
}
/// STRUCTURE_STARTS: the structure starts owned by a chunk (cached).
pub fn structure_starts(
&mut self,
pos: ChunkPos,
) -> Vec<Arc<super::structure::start::StructureStart>> {
self.pipeline.structure_starts(&mut self.state, pos)
}
pub fn stage_timings(&self) -> StageTimings {
self.state.timings
}
@@ -345,9 +345,16 @@ impl Pools {
let value: Value = serde_json::from_str(json).ok()?;
let mut templates = Vec::new();
for entry in value["elements"].as_array()? {
let element = Arc::new(
PoolElement::decode(&entry["element"], resources, bindings, None).ok()?,
);
let element =
match PoolElement::decode(&entry["element"], resources, bindings, None) {
Ok(element) => Arc::new(element),
Err(error) => {
if std::env::var_os("HORIZON_JIGSAW_DEBUG").is_some() {
eprintln!("pool {name}: {error}");
}
return None;
}
};
for _ in 0..entry["weight"].as_i64().unwrap_or(1) {
templates.push(element.clone());
}
@@ -687,12 +694,13 @@ impl Placer<'_, '_> {
let source_rigid = source_element.projection() == Projection::Rigid;
let mut source_free: Option<Rc<RefCell<Free>>> = None;
let source_y = source_box.min[1];
'jigsaws: for jigsaw in source_element.shuffled_jigsaws(
let jigsaws = source_element.shuffled_jigsaws(
self.resources,
source_position,
source_rotation,
random,
) {
);
'jigsaws: for jigsaw in jigsaws {
let direction = jigsaw.front;
let s = step(direction);
let target_pos: [i32; 3] = std::array::from_fn(|i| jigsaw.pos[i] + s[i]);
@@ -66,14 +66,17 @@ pub(super) fn read_state(registry: &BlockRegistry, tag: &Tag) -> BlockStateId {
let Tag::Compound(compound) = tag else {
return air;
};
let Some(name) = string(get(compound, "Name")) else {
// 26.3 writes `id`/`properties`; older templates use `Name`/`Properties`.
let Some(name) = string(get(compound, "id")).or_else(|| string(get(compound, "Name"))) else {
return air;
};
let Some(default) = registry.default_state(&name) else {
return air;
};
let mut state = registry.state(default).unwrap().clone();
if let Some(Tag::Compound(properties)) = get(compound, "Properties") {
if let Some(Tag::Compound(properties)) =
get(compound, "properties").or_else(|| get(compound, "Properties"))
{
for (key, value) in properties {
let (Tag::String(value), key) = (value, key.to_string_lossy()) else {
continue;
@@ -0,0 +1,95 @@
package dev.horizonlab.parity;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import net.minecraft.SharedConstants;
import net.minecraft.core.*;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.resources.RegistryDataLoader;
import net.minecraft.server.Bootstrap;
import net.minecraft.server.RegistryLayer;
import net.minecraft.server.packs.PackType;
import net.minecraft.server.packs.repository.ServerPacksSource;
import net.minecraft.server.packs.resources.MultiPackResourceManager;
import net.minecraft.tags.TagLoader;
import net.minecraft.util.datafix.DataFixers;
import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelHeightAccessor;
import net.minecraft.world.level.biome.MultiNoiseBiomeSource;
import net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterLists;
import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
import net.minecraft.world.level.levelgen.*;
import net.minecraft.world.level.levelgen.structure.*;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
import net.minecraft.world.level.storage.LevelStorageSource;
/**
* Original oracle: runs vanilla structure placement checks, start selection
* and Structure.generate (as ChunkGenerator.createStructures does for a fresh
* chunk) for a rectangle of overworld chunks and prints every valid start.
*/
public final class VanillaStructureStartOracle {
public static void main(String[] args) throws Exception {
SharedConstants.tryDetectVersion();Bootstrap.bootStrap();
Path out=Path.of(args[0]);long seed=Long.parseLong(args[1]);
int x0=Integer.parseInt(args[2]),z0=Integer.parseInt(args[3]),x1=Integer.parseInt(args[4]),z1=Integer.parseInt(args[5]);
var repo=ServerPacksSource.createVanillaTrustedRepository();repo.reload();repo.setSelected(List.of("vanilla"));
var resources=new MultiPackResourceManager(PackType.SERVER_DATA,repo.openAllSelected());
var layers=RegistryLayer.createRegistryAccess();
var staticTags=TagLoader.loadTagsForExistingRegistries(resources,layers.getLayer(RegistryLayer.STATIC));
var context=TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD),staticTags);
RegistryAccess.Frozen world=RegistryDataLoader.load(resources,context,RegistryDataLoader.WORLD_REGISTRIES,Runnable::run).join();
staticTags.forEach(Registry.PendingTags::apply);
RegistryAccess access=layers.replaceFrom(RegistryLayer.WORLD,world).compositeAccess();
var settings=world.lookupOrThrow(Registries.NOISE_SETTINGS).getOrThrow(NoiseGeneratorSettings.OVERWORLD);
var randomState=RandomState.create(world.lookupOrThrow(Registries.NOISE),seed,settings.value());
var biomeSource=MultiNoiseBiomeSource.createFromPreset(world.lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST).getOrThrow(MultiNoiseBiomeSourceParameterLists.OVERWORLD));
var generator=new NoiseBasedChunkGenerator(biomeSource,settings);
var state=ChunkGeneratorStructureState.createForNormal(randomState,seed,new ChunkPos(0,0),biomeSource,world.lookupOrThrow(Registries.STRUCTURE_SET));
Path tmp=Files.createTempDirectory("horizon-structures");
var storage=LevelStorageSource.createDefault(tmp).createAccess("oracle");
var templates=new StructureTemplateManager(resources,storage,DataFixers.getDataFixer(),BuiltInRegistries.BLOCK);
LevelHeightAccessor height=LevelHeightAccessor.create(-64,384);
var climate=randomState.createClimateSampler(net.minecraft.world.level.levelgen.densityfunction.SamplerContext.builder().enableCaches().build());
var structures=world.lookupOrThrow(Registries.STRUCTURE);
try(var w=new PrintWriter(Files.newBufferedWriter(out,StandardCharsets.UTF_8))) {
structures.listElements().forEach(h->w.println("registry "+h.key().identifier()+" "+h.value().step().ordinal()));
for(int cx=x0;cx<=x1;cx++)for(int cz=z0;cz<=z1;cz++) {
ChunkPos pos=new ChunkPos(cx,cz);
for(var set:state.possibleStructureSets()) {
var placement=set.value().placement();var entries=set.value().structures();
if(!placement.isStructureChunk(state,cx,cz))continue;
var options=new ArrayList<>(entries);
WorldgenRandom random=new WorldgenRandom(new LegacyRandomSource(0L));random.setLargeFeatureSeed(seed,cx,cz);
int total=0;for(var o:options)total+=o.weight();
while(!options.isEmpty()) {
StructureSet.StructureSelectionEntry selected;int index=0;
if(entries.size()==1){selected=options.get(0);}
else{int choice=random.nextInt(total);for(var o:options){choice-=o.weight();if(choice<0)break;index++;}selected=options.get(index);}
var structure=selected.structure();
StructureStart start=structure.value().generate(structure,Level.OVERWORLD,access,generator,biomeSource,climate,randomState,templates,seed,pos,0,height,structure.value().biomes()::contains);
if(start.isValid()) {
var b=start.getBoundingBox();
w.println("start "+cx+" "+cz+" "+structure.unwrapKey().get().identifier()+" "+b.minX()+" "+b.minY()+" "+b.minZ()+" "+b.maxX()+" "+b.maxY()+" "+b.maxZ()+" "+start.getPieces().size());
for(var piece:start.getPieces()) {
var pb=piece.getBoundingBox();
String extra="";
if(piece instanceof PoolElementStructurePiece pool)extra=" "+pool.getPosition().getX()+" "+pool.getPosition().getY()+" "+pool.getPosition().getZ()+" "+pool.getRotation()+" "+pool.getGroundLevelDelta()+" "+pool.getJunctions().size()+" "+pool.getElement();
w.println("piece "+BuiltInRegistries.STRUCTURE_PIECE.getKey(piece.getType())+" "+pb.minX()+" "+pb.minY()+" "+pb.minZ()+" "+pb.maxX()+" "+pb.maxY()+" "+pb.maxZ()+extra);
}
break;
}
if(entries.size()==1)break;
options.remove(index);total-=selected.weight();
}
}
}
}
storage.close();
System.exit(0);
}
}
+55
View File
@@ -0,0 +1,55 @@
#!/usr/bin/env python3
"""Compare Rust structure starts (chunkgen_bench --starts) with the vanilla oracle.
usage: compare_structure_starts.py VANILLA RUST [--all]
Pieces are compared by type, bounding box and (for jigsaw pieces) position,
rotation, ground level delta and junction count. Without --all, vanilla
starts of structure types Rust does not generate yet are only counted.
"""
import collections
import sys
def load(path):
starts = {}
current = None
for line in open(path):
t = line.split()
if not t:
continue
if t[0] == 'start':
current = (int(t[1]), int(t[2]), t[3])
starts[current] = [' '.join(t[4:])]
elif t[0] == 'piece' and current:
starts[current].append(' '.join(t[1:14]))
return starts
def main():
vanilla, rust = load(sys.argv[1]), load(sys.argv[2])
generated = {k[2] for k in rust}
matched = 0
missing = collections.Counter()
for key in sorted(vanilla):
if key not in rust:
missing[key[2]] += 1
if key[2] in generated or '--all' in sys.argv:
print('missing', key)
continue
if vanilla[key] == rust[key]:
matched += 1
continue
v, r = vanilla[key], rust[key]
print('DIFF', key, 'pieces', len(v) - 1, len(r) - 1)
for i, (a, b) in enumerate(zip(v, r)):
if a != b:
print(' first difference at line', i, '\n vanilla', a, '\n rust ', b)
break
for key in sorted(set(rust) - set(vanilla)):
print('extra', key)
print(f'{matched} of {len(vanilla)} vanilla starts match exactly; not generated by Rust:', dict(missing))
return 0 if matched == len(rust) == sum(1 for k in vanilla if k[2] in generated) else 1
if __name__ == '__main__':
sys.exit(main())
+35
View File
@@ -0,0 +1,35 @@
#!/usr/bin/env python3
"""Run the vanilla structure-start oracle for a seed and chunk rectangle.
usage: structure_start_oracle.py OUT SEED X0 Z0 X1 Z1
"""
import os
import subprocess
import sys
try:
from . import lab, test_rust_parity as base
except ImportError:
import lab
import test_rust_parity as base
def main():
out, seed, x0, z0, x1, z1 = sys.argv[1:7]
lock, jars, libraries = base.verify_artifacts()
source = lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity/VanillaStructureStartOracle.java'
build = lab.LOCAL/'structure-start-oracle'
classes = build/'classes'
classes.mkdir(parents=True, exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
subprocess.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-cp', dependencies,
'-d', str(classes), str(source)], check=True)
result = subprocess.run(['java', '-Xmx2G', '-cp', str(classes)+os.pathsep+dependencies,
'dev.horizonlab.parity.VanillaStructureStartOracle', out, seed, x0, z0, x1, z1],
capture_output=True, text=True)
if result.returncode:
lines = [line for line in (result.stdout + result.stderr).splitlines() if 'Exception' in line or 'Caused' in line]
raise SystemExit('oracle failed: ' + ' | '.join(lines[:5]))
if __name__ == '__main__':
main()