Add vanilla world diff tool and End gateway block entities in decoration
vanilla_diff compares Rust-decorated chunks with region files of a vanilla world generated for the same seed; chunkgen_bench takes --dimension. configure_end_gateway stores the exit of end_gateway_return gateways instead of failing the feature. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
//!
|
||||
//! chunkgen_bench <client resource dir> [--seed S] [--size N] [--threads T]
|
||||
//! [--center CX CZ] [--verify <material-stage parity dir>] [--no-decorate]
|
||||
//! [--dimension minecraft:the_nether|minecraft:the_end]
|
||||
use horizon_core::position::ChunkPos;
|
||||
use horizon_world::{
|
||||
DATA_VERSION,
|
||||
@@ -274,6 +275,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 dimension = String::from("minecraft:overworld");
|
||||
let mut starts: Option<(i32, i32, i32, i32, PathBuf)> = None;
|
||||
while let Some(arg) = args.next() {
|
||||
let mut next = || args.next().expect("argument value");
|
||||
@@ -284,6 +286,7 @@ fn main() -> Result<(), Error> {
|
||||
"--center" => center = (next().parse()?, next().parse()?),
|
||||
"--verify" => parity = Some(PathBuf::from(next())),
|
||||
"--no-decorate" => decorate = false,
|
||||
"--dimension" => dimension = next(),
|
||||
"--starts" => {
|
||||
starts = Some((
|
||||
next().parse()?,
|
||||
@@ -304,7 +307,8 @@ fn main() -> Result<(), Error> {
|
||||
verify(&data, &parity)?;
|
||||
}
|
||||
let start = Instant::now();
|
||||
let generator = OverworldGenerator::new(data.clone(), seed)?;
|
||||
let generator =
|
||||
OverworldGenerator::for_dimension(data.clone(), seed, "minecraft:normal", &dimension)?;
|
||||
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)?;
|
||||
|
||||
@@ -0,0 +1,439 @@
|
||||
//! Differential check of decorated chunks against a vanilla world.
|
||||
//!
|
||||
//! vanilla_diff <client resource dir> <vanilla world dir> --seed S
|
||||
//! [--dimension minecraft:overworld] [--from CX CZ] [--size N]
|
||||
//! [--threads T] [--show FROM->TO] [--limit N] [--reverse] [--shuffle SEED]
|
||||
//! [--other <second vanilla world dir>]
|
||||
//!
|
||||
//! Generates an (N+4)² chunk area with the Rust pipeline, decorates the inner
|
||||
//! (N+2)² chunks (vanilla FEATURES writes reach one neighbor) and compares the
|
||||
//! N² chunks starting at (CX, CZ) block by block with the region files of a
|
||||
//! vanilla world generated for the same seed (with ticks frozen, see
|
||||
//! docs/parity/worldgen.md). Prints mismatches grouped by vanilla → Rust block.
|
||||
use horizon_core::position::{BlockPos, ChunkPos};
|
||||
use horizon_world::{
|
||||
DATA_VERSION,
|
||||
chunk::{BlockSection, BlockState, ChunkData},
|
||||
nbt::{Limits, Tag},
|
||||
region::RegionFile,
|
||||
registry::BlockRegistry,
|
||||
worldgen::generator::{GeneratorData, OverworldGenerator, ProtoChunk},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
collections::{BTreeMap, HashMap},
|
||||
fs,
|
||||
path::{Path, PathBuf},
|
||||
sync::{
|
||||
Mutex,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
},
|
||||
};
|
||||
|
||||
type Error = Box<dyn std::error::Error + Send + Sync>;
|
||||
|
||||
fn tag(v: &Value) -> Tag {
|
||||
match v {
|
||||
Value::String(s) => Tag::String(s.as_str().into()),
|
||||
Value::Number(n) => Tag::Int(n.as_i64().unwrap() as i32),
|
||||
Value::Array(a) => Tag::List(a.iter().map(tag).collect()),
|
||||
Value::Object(o) => {
|
||||
Tag::Compound(o.iter().map(|(k, v)| (k.as_str().into(), tag(v))).collect())
|
||||
}
|
||||
_ => panic!("invalid registry metadata"),
|
||||
}
|
||||
}
|
||||
|
||||
fn registry(resources: &Path) -> Result<&'static BlockRegistry, Error> {
|
||||
let facts: Value = serde_json::from_str(&fs::read_to_string(resources.join("facts.json"))?)?;
|
||||
let registry = BlockRegistry::from_nbt(&Tag::compound([
|
||||
("DataVersion", Tag::Int(DATA_VERSION)),
|
||||
(
|
||||
"states",
|
||||
Tag::List(
|
||||
facts["states"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|v| tag(&v[4]))
|
||||
.collect(),
|
||||
),
|
||||
),
|
||||
("defaults", tag(&facts["defaults"])),
|
||||
]))?;
|
||||
Ok(Box::leak(Box::new(registry)))
|
||||
}
|
||||
|
||||
fn describe(state: &BlockState) -> String {
|
||||
if state.properties.is_empty() {
|
||||
return state.name.clone();
|
||||
}
|
||||
let props: Vec<String> = state
|
||||
.properties
|
||||
.iter()
|
||||
.map(|(k, v)| format!("{k}={v}"))
|
||||
.collect();
|
||||
format!("{}[{}]", state.name, props.join(","))
|
||||
}
|
||||
|
||||
fn region_dir(world: &Path, dimension: &str) -> PathBuf {
|
||||
let modern = world
|
||||
.join("dimensions")
|
||||
.join(dimension.replace(':', "/"))
|
||||
.join("region");
|
||||
if modern.is_dir() {
|
||||
return modern;
|
||||
}
|
||||
match dimension {
|
||||
"minecraft:the_nether" => world.join("DIM-1/region"),
|
||||
"minecraft:the_end" => world.join("DIM1/region"),
|
||||
_ => world.join("region"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Terrain-stage chunks of the `full`² area at `origin`, row-major.
|
||||
fn generate_area(
|
||||
generator: &OverworldGenerator,
|
||||
origin: (i32, i32),
|
||||
full: i32,
|
||||
threads: usize,
|
||||
) -> Result<Vec<ProtoChunk>, Error> {
|
||||
let count = (full * full) as usize;
|
||||
let next = AtomicUsize::new(0);
|
||||
let slots: Vec<Mutex<Option<ProtoChunk>>> = (0..count).map(|_| Mutex::new(None)).collect();
|
||||
std::thread::scope(|scope| -> Result<(), Error> {
|
||||
let handles = (0..threads)
|
||||
.map(|_| {
|
||||
scope.spawn(|| -> Result<(), Error> {
|
||||
let mut worker = generator.worker();
|
||||
loop {
|
||||
let i = next.fetch_add(1, Ordering::Relaxed);
|
||||
if i >= count {
|
||||
return Ok(());
|
||||
}
|
||||
let pos = ChunkPos::new(
|
||||
origin.0 + (i as i32 % full),
|
||||
origin.1 + (i as i32 / full),
|
||||
);
|
||||
*slots[i].lock().unwrap() = Some(worker.generate_proto(pos)?);
|
||||
}
|
||||
})
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
handles.into_iter().try_for_each(|h| h.join().unwrap())
|
||||
})?;
|
||||
Ok(slots
|
||||
.into_iter()
|
||||
.map(|s| s.into_inner().unwrap().unwrap())
|
||||
.collect())
|
||||
}
|
||||
|
||||
/// Decorates the chunks at `order` (indices into the `full`² area, each with
|
||||
/// all eight neighbors present) in that order, one FEATURES pass each.
|
||||
fn decorate_area(
|
||||
generator: &OverworldGenerator,
|
||||
protos: Vec<ProtoChunk>,
|
||||
full: i32,
|
||||
order: &[(i32, i32)],
|
||||
) -> Result<Vec<ProtoChunk>, Error> {
|
||||
let mut chunks: Vec<Option<ProtoChunk>> = protos.into_iter().map(Some).collect();
|
||||
let mut worker = generator.worker();
|
||||
let (mut unsupported_roots, mut failed) = (0, 0);
|
||||
let mut skipped = std::collections::BTreeSet::new();
|
||||
for &(x, z) in order {
|
||||
let mut region = Vec::with_capacity(9);
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
region.push(chunks[((z + dz) * full + x + dx) as usize].take().unwrap());
|
||||
}
|
||||
}
|
||||
let mut region: [ProtoChunk; 9] = region.try_into().map_err(|_| "region")?;
|
||||
let stats = worker.decorate(&mut region)?;
|
||||
unsupported_roots += stats.unsupported;
|
||||
failed += stats.failed;
|
||||
skipped.extend(stats.skipped);
|
||||
for (i, chunk) in region.into_iter().enumerate() {
|
||||
let (dx, dz) = (i as i32 % 3 - 1, i as i32 / 3 - 1);
|
||||
chunks[((z + dz) * full + x + dx) as usize] = Some(chunk);
|
||||
}
|
||||
}
|
||||
println!("decoration: unsupported roots {unsupported_roots}, failed {failed}");
|
||||
if !skipped.is_empty() {
|
||||
println!(
|
||||
"skipped: {}",
|
||||
skipped.into_iter().collect::<Vec<_>>().join(" ")
|
||||
);
|
||||
}
|
||||
Ok(chunks.into_iter().map(Option::unwrap).collect())
|
||||
}
|
||||
|
||||
/// Lazily opened region files of one dimension.
|
||||
struct Regions {
|
||||
dir: PathBuf,
|
||||
files: HashMap<(i32, i32), Option<RegionFile>>,
|
||||
}
|
||||
impl Regions {
|
||||
fn new(dir: PathBuf) -> Self {
|
||||
Self {
|
||||
dir,
|
||||
files: HashMap::new(),
|
||||
}
|
||||
}
|
||||
fn chunk(&mut self, pos: ChunkPos) -> Result<Option<ChunkData>, Error> {
|
||||
let key = (pos.x >> 5, pos.z >> 5);
|
||||
let dir = &self.dir;
|
||||
let file = self.files.entry(key).or_insert_with(|| {
|
||||
RegionFile::open(dir.join(format!("r.{}.{}.mca", key.0, key.1))).ok()
|
||||
});
|
||||
let Some(file) = file else { return Ok(None) };
|
||||
let Some(record) = file.read(pos)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
Ok(Some(ChunkData::new(record.nbt(Limits::default())?)?))
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<(), Error> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let resources = PathBuf::from(args.next().expect("client resource directory"));
|
||||
let world = PathBuf::from(args.next().expect("vanilla world directory"));
|
||||
let (mut seed, mut from, mut size, mut threads) = (0i64, (0, 0), 8i32, 4usize);
|
||||
let mut dimension = String::from("minecraft:overworld");
|
||||
let mut show: Option<String> = None;
|
||||
let mut limit = 40usize;
|
||||
let mut other: Option<PathBuf> = None;
|
||||
let (mut reverse, mut shuffle) = (false, 0i64);
|
||||
while let Some(arg) = args.next() {
|
||||
let mut next = || args.next().expect("argument value");
|
||||
match arg.as_str() {
|
||||
"--seed" => seed = next().parse()?,
|
||||
"--from" => from = (next().parse()?, next().parse()?),
|
||||
"--size" => size = next().parse()?,
|
||||
"--threads" => threads = next().parse()?,
|
||||
"--dimension" => dimension = next(),
|
||||
"--show" => show = Some(next()),
|
||||
"--limit" => limit = next().parse()?,
|
||||
"--other" => other = Some(PathBuf::from(next())),
|
||||
"--reverse" => reverse = true,
|
||||
"--shuffle" => shuffle = next().parse()?,
|
||||
_ => return Err(format!("unknown argument {arg}").into()),
|
||||
}
|
||||
}
|
||||
let registry = registry(&resources)?;
|
||||
let data = GeneratorData::load(&resources.join("worldgen"), registry)?;
|
||||
let generator =
|
||||
OverworldGenerator::for_dimension(data, seed, "minecraft:normal", &dimension)?;
|
||||
let unsupported = generator.unsupported_features();
|
||||
println!("unsupported placed features: {}", unsupported.len());
|
||||
|
||||
// Rust: terrain for (size+4)², decoration for the inner (size+2)².
|
||||
let full = size + 4;
|
||||
let (x0, z0) = (from.0 - 2, from.1 - 2);
|
||||
let mut order: Vec<(i32, i32)> = (1..full - 1)
|
||||
.flat_map(|z| (1..full - 1).map(move |x| (x, z)))
|
||||
.collect();
|
||||
if reverse {
|
||||
let mut reversed = order.clone();
|
||||
reversed.reverse();
|
||||
let alternate = decorate_area(
|
||||
&generator,
|
||||
generate_area(&generator, (x0, z0), full, threads)?,
|
||||
full,
|
||||
&reversed,
|
||||
)?;
|
||||
let chunks = decorate_area(
|
||||
&generator,
|
||||
generate_area(&generator, (x0, z0), full, threads)?,
|
||||
full,
|
||||
&order,
|
||||
)?;
|
||||
let mut pairs: BTreeMap<(String, String), usize> = BTreeMap::new();
|
||||
let mut total = 0;
|
||||
let name = |id| {
|
||||
registry
|
||||
.state(id)
|
||||
.map(|s: &BlockState| s.name.trim_start_matches("minecraft:").to_owned())
|
||||
.unwrap_or_default()
|
||||
};
|
||||
for (a, b) in chunks.iter().zip(&alternate) {
|
||||
let p = a.position();
|
||||
if p.x < from.0 || p.z < from.1 || p.x >= from.0 + size || p.z >= from.1 + size {
|
||||
continue;
|
||||
}
|
||||
for section in 0..a.terrain.height() as usize / 16 {
|
||||
let (sa, sb) = (
|
||||
a.terrain.section(section).unwrap(),
|
||||
b.terrain.section(section).unwrap(),
|
||||
);
|
||||
for index in 0..4096 {
|
||||
let (x, y) = (sa.get(index)?, sb.get(index)?);
|
||||
if x != y {
|
||||
total += 1;
|
||||
*pairs.entry((name(x), name(y))).or_default() += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("decoration order sensitivity (raster vs reverse): {total} blocks differ");
|
||||
let mut sorted: Vec<_> = pairs.into_iter().collect();
|
||||
sorted.sort_by(|a, b| b.1.cmp(&a.1));
|
||||
for ((v, r), n) in sorted.iter().take(limit) {
|
||||
println!("{n:>9} {v} <-> {r}");
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
if shuffle != 0 {
|
||||
// Deterministic Fisher-Yates with a 64-bit LCG.
|
||||
let mut state = shuffle as u64;
|
||||
for i in (1..order.len()).rev() {
|
||||
state = state
|
||||
.wrapping_mul(6364136223846793005)
|
||||
.wrapping_add(1442695040888963407);
|
||||
order.swap(i, (state >> 33) as usize % (i + 1));
|
||||
}
|
||||
}
|
||||
let chunks = match other {
|
||||
Some(_) => Vec::new(),
|
||||
None => decorate_area(
|
||||
&generator,
|
||||
generate_area(&generator, (x0, z0), full, threads)?,
|
||||
full,
|
||||
&order,
|
||||
)?,
|
||||
};
|
||||
let (min_y, height) = match dimension.as_str() {
|
||||
"minecraft:overworld" => (-64, 384),
|
||||
_ => (0, 256),
|
||||
};
|
||||
|
||||
// Vanilla region files.
|
||||
let mut vanilla = Regions::new(region_dir(&world, &dimension));
|
||||
let mut second = other.map(|w| Regions::new(region_dir(&w, &dimension)));
|
||||
let air = registry.default_state("minecraft:air").unwrap();
|
||||
let mut pairs: BTreeMap<(String, String), usize> = BTreeMap::new();
|
||||
let mut examples: Vec<[i32; 3]> = Vec::new();
|
||||
let (mut compared, mut differ, mut missing) = (0usize, 0usize, 0usize);
|
||||
let mut per_chunk = Vec::new();
|
||||
for cz in from.1..from.1 + size {
|
||||
for cx in from.0..from.0 + size {
|
||||
let pos = ChunkPos::new(cx, cz);
|
||||
let Some(theirs) = vanilla.chunk(pos)? else {
|
||||
missing += 1;
|
||||
continue;
|
||||
};
|
||||
let ours = match &mut second {
|
||||
Some(second) => match second.chunk(pos)? {
|
||||
Some(chunk) => Some(chunk),
|
||||
None => {
|
||||
missing += 1;
|
||||
continue;
|
||||
}
|
||||
},
|
||||
None => None,
|
||||
};
|
||||
let status = match theirs.root().tag.get("Status") {
|
||||
Some(Tag::String(s)) => s.to_string().unwrap_or_default(),
|
||||
_ => String::new(),
|
||||
};
|
||||
let rust = chunks.get(((cz - z0) * full + cx - x0) as usize);
|
||||
if size == 1 {
|
||||
println!("vanilla structures: {:?}", theirs.root().tag.get("structures"));
|
||||
if let Some(rust) = rust {
|
||||
println!("rust structures: {:?}", rust.structures());
|
||||
}
|
||||
}
|
||||
if status != "minecraft:full" {
|
||||
println!("chunk {cx} {cz}: vanilla status {status}");
|
||||
}
|
||||
let mut chunk_differ = 0;
|
||||
for section in 0..height as usize / 16 {
|
||||
let base_y = min_y + section as i32 * 16;
|
||||
let at = BlockPos::new(cx * 16, base_y, cz * 16);
|
||||
let ours_loaded;
|
||||
let ours: Option<&BlockSection> = match (&ours, rust) {
|
||||
(Some(chunk), _) => {
|
||||
ours_loaded = chunk.load_block_section(at, registry)?;
|
||||
ours_loaded.as_ref()
|
||||
}
|
||||
(None, Some(rust)) => rust.terrain.section(section),
|
||||
(None, None) => None,
|
||||
};
|
||||
let theirs = theirs.load_block_section(at, registry)?;
|
||||
for index in 0..4096 {
|
||||
let a = ours.map_or(Ok(air), |s| s.get(index))?;
|
||||
let b = theirs.as_ref().map_or(Ok(air), |s| s.get(index))?;
|
||||
compared += 1;
|
||||
if a == b {
|
||||
continue;
|
||||
}
|
||||
differ += 1;
|
||||
chunk_differ += 1;
|
||||
let (va, ru) = (
|
||||
registry.state(b).map(describe).unwrap_or_default(),
|
||||
registry.state(a).map(describe).unwrap_or_default(),
|
||||
);
|
||||
let short = |s: &str| {
|
||||
s.split('[')
|
||||
.next()
|
||||
.unwrap()
|
||||
.trim_start_matches("minecraft:")
|
||||
.to_owned()
|
||||
};
|
||||
let pair = (short(&va), short(&ru));
|
||||
let p = [
|
||||
cx * 16 + (index & 15) as i32,
|
||||
base_y + (index >> 8) as i32,
|
||||
cz * 16 + ((index >> 4) & 15) as i32,
|
||||
];
|
||||
if let Some(filter) = &show {
|
||||
let label = format!("{}->{}", pair.0, pair.1);
|
||||
if &label == filter && examples.len() < limit {
|
||||
examples.push(p);
|
||||
println!(" {p:?}: vanilla {va} rust {ru}");
|
||||
}
|
||||
}
|
||||
*pairs.entry(pair).or_default() += 1;
|
||||
}
|
||||
}
|
||||
per_chunk.push(((cx, cz), chunk_differ));
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"compared {compared} blocks in {} chunks ({missing} missing): {differ} differ ({:.4}%)",
|
||||
per_chunk.len(),
|
||||
differ as f64 * 100.0 / compared.max(1) as f64
|
||||
);
|
||||
let mut sorted: Vec<_> = pairs.into_iter().collect();
|
||||
sorted.sort_by(|a, b| b.1.cmp(&a.1));
|
||||
for ((v, r), n) in sorted.iter().take(limit) {
|
||||
println!("{n:>9} vanilla {v} -> rust {r}");
|
||||
}
|
||||
// Decoration order at chunk borders differs between runs (vanilla's own
|
||||
// runs disagree), which mostly swaps blocks symmetrically. One-sided
|
||||
// differences point at real generation differences.
|
||||
let counts: BTreeMap<_, _> = sorted.iter().cloned().collect();
|
||||
let mut net: Vec<(i64, &(String, String))> = counts
|
||||
.iter()
|
||||
.map(|(pair, &n)| {
|
||||
let back = counts
|
||||
.get(&(pair.1.clone(), pair.0.clone()))
|
||||
.copied()
|
||||
.unwrap_or(0);
|
||||
(n as i64 - back as i64, pair)
|
||||
})
|
||||
.filter(|(n, _)| *n > 0)
|
||||
.collect();
|
||||
net.sort_by(|a, b| b.0.cmp(&a.0));
|
||||
println!("one-sided differences:");
|
||||
for (n, (v, r)) in net.iter().take(limit) {
|
||||
println!("{n:>9} vanilla {v} -> rust {r}");
|
||||
}
|
||||
let clean = per_chunk.iter().filter(|(_, n)| *n == 0).count();
|
||||
println!("chunks identical: {clean}/{}", per_chunk.len());
|
||||
let mut worst = per_chunk.clone();
|
||||
worst.sort_by(|a, b| b.1.cmp(&a.1));
|
||||
for ((x, z), n) in worst.iter().take(8).filter(|(_, n)| *n > 0) {
|
||||
println!(" chunk {x} {z}: {n}");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -615,6 +615,30 @@ impl PlacementContext for World<'_> {
|
||||
self.block_entities.push((position, nbt));
|
||||
Ok(())
|
||||
}
|
||||
/// WorldGenRegion.getBlockEntity creates the gateway's block entity when the
|
||||
/// block is an End gateway; TheEndGatewayBlockEntity.setExitPosition.
|
||||
fn configure_end_gateway(
|
||||
&mut self,
|
||||
position: [i32; 3],
|
||||
exit: [i32; 3],
|
||||
exact: bool,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
let chunk = self.region.chunk(position[0] >> 4, position[2] >> 4)?;
|
||||
let state = chunk.block(position[0], position[1], position[2]);
|
||||
let registry = self.decoration.bindings.registry();
|
||||
if registry.state(state).map(|s| s.name.as_str()) != Some("minecraft:end_gateway") {
|
||||
return Ok(());
|
||||
}
|
||||
use crate::nbt::Tag;
|
||||
let mut nbt = crate::nbt::Compound::new();
|
||||
nbt.insert("id".into(), Tag::String("minecraft:end_gateway".into()));
|
||||
nbt.insert("Age".into(), Tag::Long(0));
|
||||
nbt.insert("exit_portal".into(), Tag::IntArray(exit.to_vec()));
|
||||
if exact {
|
||||
nbt.insert("ExactTeleport".into(), Tag::Byte(1));
|
||||
}
|
||||
self.set_block_entity(position, nbt)
|
||||
}
|
||||
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
self.region.world_seed()
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user