Merge remote-tracking branch 'origin/wip/parity-persist' into t3/minecraft-parity
# Conflicts: # crates/horizon-client/src/chunk.rs # crates/horizon-client/src/game.rs
This commit is contained in:
@@ -0,0 +1,326 @@
|
||||
//! Differential light test: relight chunks of a world saved by the vanilla
|
||||
//! server with Horizon's light engine and compare every SkyLight/BlockLight
|
||||
//! value with the arrays vanilla stored.
|
||||
//!
|
||||
//! cargo run --profile fast -p horizon-client --example light_parity -- \
|
||||
//! RESOURCES DIMENSION_DIR [--nether] [--chunks X0 Z0 X1 Z1]
|
||||
use horizon_client::{
|
||||
assets::Assets,
|
||||
biome::Biomes,
|
||||
blocks::BlockFacts,
|
||||
chunk::{Chunk, MIN_Y, SECTIONS, index},
|
||||
light::{LightTables, light_chunk},
|
||||
save,
|
||||
};
|
||||
use horizon_core::position::ChunkPos;
|
||||
use horizon_world::{
|
||||
nbt::{Limits, Tag},
|
||||
region::RegionFile,
|
||||
};
|
||||
use std::{collections::HashMap, path::PathBuf};
|
||||
|
||||
type Arrays = HashMap<i32, (Option<Vec<u8>>, Option<Vec<u8>>)>;
|
||||
|
||||
fn main() -> horizon_client::Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let root = PathBuf::from(
|
||||
args.first()
|
||||
.ok_or("usage: light_parity RESOURCES DIMENSION_DIR")?,
|
||||
);
|
||||
let dim = PathBuf::from(args.get(1).ok_or("missing dimension directory")?);
|
||||
let sky_light = !args.iter().any(|a| a == "--nether");
|
||||
let assets = Assets::load(&root)?;
|
||||
let facts = BlockFacts::load(&root, assets.registry)?;
|
||||
let biomes = Biomes::load(&root)?;
|
||||
let tables = if args.iter().any(|a| a == "--no-shapes") {
|
||||
LightTables::new(&facts)
|
||||
} else {
|
||||
LightTables::load(&root, assets.registry, &facts)?
|
||||
};
|
||||
let mut chunks: HashMap<(i32, i32), Chunk> = HashMap::new();
|
||||
let mut arrays: HashMap<(i32, i32), Arrays> = HashMap::new();
|
||||
for entry in std::fs::read_dir(dim.join("region"))? {
|
||||
let path = entry?.path();
|
||||
let mut region = RegionFile::open(&path)?;
|
||||
let positions: Vec<ChunkPos> = region.chunks().map(|(p, _)| p).collect();
|
||||
for p in positions {
|
||||
let Some(record) = region.read(p)? else {
|
||||
continue;
|
||||
};
|
||||
let root_tag = record.nbt(Limits::default())?;
|
||||
let tag = &root_tag.tag;
|
||||
if !matches!(tag.get("Status"), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:full")
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if tag.get("isLightOn") != Some(&Tag::Byte(1)) {
|
||||
continue;
|
||||
}
|
||||
let Some(chunk) = save::decode(&root_tag, assets.registry, &biomes) else {
|
||||
continue;
|
||||
};
|
||||
let mut light = Arrays::new();
|
||||
if let Some(Tag::List(sections)) = tag.get("sections") {
|
||||
for s in sections {
|
||||
let Some(Tag::Byte(y)) = s.get("Y") else {
|
||||
continue;
|
||||
};
|
||||
let get = |k: &str| match s.get(k) {
|
||||
Some(Tag::ByteArray(a)) => Some(a.clone()),
|
||||
_ => None,
|
||||
};
|
||||
light.insert(i32::from(*y), (get("SkyLight"), get("BlockLight")));
|
||||
}
|
||||
}
|
||||
arrays.insert((chunk.x, chunk.z), light);
|
||||
chunks.insert((chunk.x, chunk.z), chunk);
|
||||
}
|
||||
}
|
||||
let bounds: Option<[i32; 4]> = args.iter().position(|a| a == "--chunks").map(|i| {
|
||||
std::array::from_fn(|k| {
|
||||
args.get(i + 1 + k)
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(0)
|
||||
})
|
||||
});
|
||||
if let Some(i) = args.iter().position(|a| a == "--column") {
|
||||
let wx: i32 = args[i + 1].parse()?;
|
||||
let wz: i32 = args[i + 2].parse()?;
|
||||
let (y0, y1): (i32, i32) = (args[i + 3].parse()?, args[i + 4].parse()?);
|
||||
let (x, z) = (wx >> 4, wz >> 4);
|
||||
let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
|
||||
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
|
||||
});
|
||||
let lit = light_chunk(®ion, &tables, sky_light);
|
||||
for wy in (y0..=y1).rev() {
|
||||
let si = ((wy - MIN_Y) >> 4) as usize;
|
||||
let i = index(wx, wy, wz);
|
||||
let (sky, block) = arrays[&(x, z)]
|
||||
.get(&((wy) >> 4))
|
||||
.cloned()
|
||||
.unwrap_or((None, None));
|
||||
let nib = |a: &Option<Vec<u8>>| a.as_ref().map(|a| (a[i >> 1] >> ((i & 1) * 4)) & 15);
|
||||
let id = chunks[&(x, z)].get(wx & 15, wy, wz & 15);
|
||||
let packed = lit[si].light(i);
|
||||
println!(
|
||||
"{wy}: {} horizon sky {} block {} vanilla sky {:?} block {:?}",
|
||||
facts.states[id as usize].name,
|
||||
packed >> 4,
|
||||
packed & 15,
|
||||
nib(&sky),
|
||||
nib(&block)
|
||||
);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(i) = args.iter().position(|a| a == "--incremental") {
|
||||
let edits: usize = args.get(i + 1).and_then(|v| v.parse().ok()).unwrap_or(200);
|
||||
incremental(&chunks, &tables, &facts, assets.registry, sky_light, edits);
|
||||
return Ok(());
|
||||
}
|
||||
let mut keys: Vec<(i32, i32)> = chunks
|
||||
.keys()
|
||||
.copied()
|
||||
.filter(|&(x, z)| {
|
||||
(-1..=1).all(|dz| (-1..=1).all(|dx| chunks.contains_key(&(x + dx, z + dz))))
|
||||
})
|
||||
.filter(|&(x, z)| bounds.is_none_or(|b| x >= b[0] && z >= b[1] && x <= b[2] && z <= b[3]))
|
||||
.collect();
|
||||
keys.sort_unstable();
|
||||
let (mut total, mut sky_wrong, mut block_wrong) = (0u64, 0u64, 0u64);
|
||||
let mut shown = 0;
|
||||
for (x, z) in keys {
|
||||
let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
|
||||
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
|
||||
});
|
||||
let lit = light_chunk(®ion, &tables, sky_light);
|
||||
let vanilla = &arrays[&(x, z)];
|
||||
let center = &chunks[&(x, z)];
|
||||
let (mut s_bad, mut b_bad) = (0, 0);
|
||||
for (si, section) in lit.iter().enumerate().take(SECTIONS) {
|
||||
let sy = (MIN_Y >> 4) + si as i32;
|
||||
let (sky, block) = vanilla.get(&sy).cloned().unwrap_or((None, None));
|
||||
for i in 0..4096 {
|
||||
let nibble = |a: &Option<Vec<u8>>, default: u8| {
|
||||
a.as_ref()
|
||||
.map_or(default, |a| (a[i >> 1] >> ((i & 1) * 4)) & 15)
|
||||
};
|
||||
// Vanilla omits never-written (all-zero) layers. Air sections
|
||||
// without a layer read the bottom row of the next stored layer
|
||||
// above (SkyLightSectionStorage.getLightValue), or full
|
||||
// skylight above every stored layer.
|
||||
let vs = match &sky {
|
||||
Some(_) => nibble(&sky, 0),
|
||||
None if !sky_light || !center.sections[si].is_uniform(0) => 0,
|
||||
None => ((sy + 1)..=(MIN_Y >> 4) + SECTIONS as i32)
|
||||
.find_map(|y| vanilla.get(&y).and_then(|(s, _)| s.as_ref()))
|
||||
.map_or(15, |a| (a[(i & 255) >> 1] >> ((i & 1) * 4)) & 15),
|
||||
};
|
||||
let vb = nibble(&block, 0);
|
||||
let packed = section.light(i);
|
||||
let (hs, hb) = (packed >> 4, packed & 15);
|
||||
total += 1;
|
||||
if hs != vs {
|
||||
s_bad += 1;
|
||||
}
|
||||
if hb != vb {
|
||||
b_bad += 1;
|
||||
}
|
||||
if (hs != vs || hb != vb) && shown < 30 {
|
||||
shown += 1;
|
||||
let (lx, lz, ly) = (i & 15, (i >> 4) & 15, i >> 8);
|
||||
let wy = sy * 16 + ly as i32;
|
||||
let wx = x * 16 + lx as i32;
|
||||
let wz = z * 16 + lz as i32;
|
||||
let id = center.get(lx as i32, wy, lz as i32);
|
||||
eprintln!(
|
||||
" {wx} {wy} {wz} {}: sky {hs} vs {vs}, block {hb} vs {vb}",
|
||||
facts.states[id as usize].name
|
||||
);
|
||||
}
|
||||
let _ = index;
|
||||
}
|
||||
}
|
||||
if s_bad + b_bad > 0 {
|
||||
println!("chunk {x} {z}: {s_bad} sky and {b_bad} block values differ");
|
||||
}
|
||||
sky_wrong += s_bad;
|
||||
block_wrong += b_bad;
|
||||
}
|
||||
println!(
|
||||
"{total} values compared: {sky_wrong} sky and {block_wrong} block light values differ"
|
||||
);
|
||||
if sky_wrong + block_wrong > 0 {
|
||||
std::process::exit(1);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Edit lit chunks block by block with `light::relight` and check the result
|
||||
/// against a full relight of the edited neighbourhood after every edit.
|
||||
fn incremental(
|
||||
chunks: &HashMap<(i32, i32), Chunk>,
|
||||
tables: &LightTables,
|
||||
facts: &BlockFacts,
|
||||
registry: &horizon_world::registry::BlockRegistry,
|
||||
sky_light: bool,
|
||||
edits: usize,
|
||||
) {
|
||||
use horizon_client::light::relight;
|
||||
use std::sync::Arc;
|
||||
let mut world: HashMap<(i32, i32), Arc<Chunk>> = HashMap::new();
|
||||
let inner: Vec<(i32, i32)> = {
|
||||
let mut k: Vec<_> = chunks
|
||||
.keys()
|
||||
.copied()
|
||||
.filter(|&(x, z)| {
|
||||
(-3..=3).all(|dz| (-3..=3).all(|dx| chunks.contains_key(&(x + dx, z + dz))))
|
||||
})
|
||||
.collect();
|
||||
k.sort_unstable();
|
||||
k
|
||||
};
|
||||
for &(x, z) in chunks.keys() {
|
||||
if !(-1..=1).all(|dz| (-1..=1).all(|dx| chunks.contains_key(&(x + dx, z + dz)))) {
|
||||
continue;
|
||||
}
|
||||
let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
|
||||
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
|
||||
});
|
||||
let mut c = chunks[&(x, z)].clone();
|
||||
c.sections = light_chunk(®ion, tables, sky_light);
|
||||
c.lit = true;
|
||||
world.insert((x, z), Arc::new(c));
|
||||
}
|
||||
let palette: Vec<u16> = [
|
||||
"minecraft:air",
|
||||
"minecraft:stone",
|
||||
"minecraft:torch",
|
||||
"minecraft:glowstone",
|
||||
"minecraft:oak_leaves",
|
||||
"minecraft:water",
|
||||
"minecraft:glass",
|
||||
]
|
||||
.iter()
|
||||
.filter_map(|n| registry.default_state(n).map(|s| s.0 as u16))
|
||||
.chain(
|
||||
facts
|
||||
.states
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, f)| {
|
||||
[
|
||||
"minecraft:stone_slab",
|
||||
"minecraft:oak_stairs",
|
||||
"minecraft:snow",
|
||||
"minecraft:dirt_path",
|
||||
]
|
||||
.contains(&&*f.name)
|
||||
})
|
||||
.map(|(i, _)| i as u16)
|
||||
.step_by(3),
|
||||
)
|
||||
.collect();
|
||||
let mut seed = 0x2545_F491_4F6C_DD1Du64;
|
||||
let mut next = |n: u64| {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 7;
|
||||
seed ^= seed << 17;
|
||||
seed % n
|
||||
};
|
||||
let mut bad = 0;
|
||||
for e in 0..edits {
|
||||
let (cx, cz) = inner[next(inner.len() as u64) as usize];
|
||||
let (x, z) = (cx * 16 + next(16) as i32, cz * 16 + next(16) as i32);
|
||||
// Near the surface, where light varies most.
|
||||
let top = (0..384)
|
||||
.rev()
|
||||
.find(|y| world[&(cx, cz)].get(x & 15, MIN_Y + y, z & 15) != 0)
|
||||
.unwrap_or(100) as i32
|
||||
+ MIN_Y;
|
||||
let y = top - 3 + next(6) as i32;
|
||||
let state = palette[next(palette.len() as u64) as usize];
|
||||
let chunk = world.get_mut(&(cx, cz)).unwrap();
|
||||
let old = Arc::make_mut(chunk).set(x & 15, y, z & 15, state);
|
||||
if old == state || !tables.differs(old, state) {
|
||||
continue;
|
||||
}
|
||||
relight(&mut world, tables, sky_light, &[(x, y, z)], false);
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
let (kx, kz) = (cx + dx, cz + dz);
|
||||
let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|rz| {
|
||||
std::array::from_fn(|rx| {
|
||||
world
|
||||
.get(&(kx + rx as i32 - 1, kz + rz as i32 - 1))
|
||||
.map(|c| &**c)
|
||||
})
|
||||
});
|
||||
let full = light_chunk(®ion, tables, sky_light);
|
||||
for (si, s) in full.iter().enumerate() {
|
||||
for i in 0..4096 {
|
||||
let (a, b) = (s.light(i), world[&(kx, kz)].sections[si].light(i));
|
||||
if a != b {
|
||||
bad += 1;
|
||||
if bad < 20 {
|
||||
let (lx, lz, ly) = (i & 15, (i >> 4) & 15, i >> 8);
|
||||
eprintln!(
|
||||
"edit {e} at {x} {y} {z} ({} -> {}): {} {} {} full {a:02x} incremental {b:02x}",
|
||||
facts.states[old as usize].name,
|
||||
facts.states[state as usize].name,
|
||||
kx * 16 + lx as i32,
|
||||
MIN_Y + si as i32 * 16 + ly as i32,
|
||||
kz * 16 + lz as i32
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
println!("{edits} edits: {bad} light values differ from a full relight");
|
||||
if bad > 0 {
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,265 @@
|
||||
//! Differential save test: load every full chunk of a world written by the
|
||||
//! vanilla 26.3 server, light it, encode it again with Horizon's chunk writer
|
||||
//! and compare the result with the original NBT: block states, biomes,
|
||||
//! heightmaps, light layers (by value), block entities and scheduled ticks.
|
||||
//!
|
||||
//! cargo run --profile fast -p horizon-client --example save_parity -- \
|
||||
//! RESOURCES DIMENSION_DIR [--nether]
|
||||
use horizon_client::{
|
||||
assets::Assets,
|
||||
biome::Biomes,
|
||||
blocks::BlockFacts,
|
||||
chunk::{Chunk, MIN_Y, SECTIONS},
|
||||
light::{LightTables, light_chunk},
|
||||
save::{self, SaveTables},
|
||||
};
|
||||
use horizon_core::position::ChunkPos;
|
||||
use horizon_world::{
|
||||
chunk::BlockState,
|
||||
nbt::{Limits, NamedTag, Tag},
|
||||
region::RegionFile,
|
||||
};
|
||||
use std::{
|
||||
collections::{BTreeMap, HashMap},
|
||||
path::PathBuf,
|
||||
};
|
||||
|
||||
/// Block state names per section index, decoded independently of Horizon.
|
||||
fn block_names(tag: &Tag) -> BTreeMap<i64, Vec<String>> {
|
||||
let mut out = BTreeMap::new();
|
||||
let Some(Tag::List(sections)) = tag.get("sections") else {
|
||||
return out;
|
||||
};
|
||||
for s in sections {
|
||||
let Some(Tag::Byte(y)) = s.get("Y") else {
|
||||
continue;
|
||||
};
|
||||
let Some(states) = s.get("block_states") else {
|
||||
continue;
|
||||
};
|
||||
let Some(Tag::List(palette)) = states.get("palette") else {
|
||||
continue;
|
||||
};
|
||||
let names: Vec<String> = palette
|
||||
.iter()
|
||||
.map(|p| {
|
||||
let st = BlockState::from_nbt(p).expect("palette entry");
|
||||
format!("{}{:?}", st.name, st.properties)
|
||||
})
|
||||
.collect();
|
||||
let bits = (usize::BITS - (names.len().max(1) - 1).leading_zeros()).max(4);
|
||||
let per = 64 / bits as usize;
|
||||
let data = match states.get("data") {
|
||||
Some(Tag::LongArray(d)) => d.clone(),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let blocks = (0..4096)
|
||||
.map(|i| {
|
||||
if names.len() == 1 {
|
||||
return names[0].clone();
|
||||
}
|
||||
let v = (data[i / per] as u64 >> ((i % per) as u32 * bits)) & ((1 << bits) - 1);
|
||||
names[v as usize].clone()
|
||||
})
|
||||
.collect();
|
||||
out.insert(i64::from(*y), blocks);
|
||||
}
|
||||
out
|
||||
}
|
||||
fn light(tag: &Tag, key: &str) -> HashMap<i64, Vec<u8>> {
|
||||
let mut out = HashMap::new();
|
||||
if let Some(Tag::List(sections)) = tag.get("sections") {
|
||||
for s in sections {
|
||||
if let (Some(Tag::Byte(y)), Some(Tag::ByteArray(a))) = (s.get("Y"), s.get(key)) {
|
||||
out.insert(i64::from(*y), a.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
/// Light value with vanilla's reading of missing layers.
|
||||
fn value(
|
||||
layers: &HashMap<i64, Vec<u8>>,
|
||||
sy: i64,
|
||||
i: usize,
|
||||
sky: bool,
|
||||
empty: bool,
|
||||
top: i64,
|
||||
) -> u8 {
|
||||
let nibble = |a: &Vec<u8>, i: usize| (a[i >> 1] >> ((i & 1) * 4)) & 15;
|
||||
if let Some(a) = layers.get(&sy) {
|
||||
return nibble(a, i);
|
||||
}
|
||||
if !sky || !empty {
|
||||
return 0;
|
||||
}
|
||||
((sy + 1)..=top)
|
||||
.find_map(|y| layers.get(&y))
|
||||
.map_or(15, |a| nibble(a, i & 255))
|
||||
}
|
||||
fn count(tag: &Tag, key: &str) -> usize {
|
||||
match tag.get(key) {
|
||||
Some(Tag::List(l)) => l.len(),
|
||||
_ => 0,
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> horizon_client::Result<()> {
|
||||
let args: Vec<String> = std::env::args().skip(1).collect();
|
||||
let root = PathBuf::from(
|
||||
args.first()
|
||||
.ok_or("usage: save_parity RESOURCES DIMENSION_DIR")?,
|
||||
);
|
||||
let dim = PathBuf::from(args.get(1).ok_or("missing dimension directory")?);
|
||||
let sky_light = !args.iter().any(|a| a == "--nether");
|
||||
let assets = Assets::load(&root)?;
|
||||
let facts = BlockFacts::load(&root, assets.registry)?;
|
||||
let biomes = Biomes::load(&root)?;
|
||||
let lights = LightTables::load(&root, assets.registry, &facts)?;
|
||||
let tables = SaveTables::new(&assets).with_block_entities(&facts);
|
||||
let mut originals: HashMap<(i32, i32), NamedTag> = HashMap::new();
|
||||
let mut chunks: HashMap<(i32, i32), Chunk> = HashMap::new();
|
||||
for entry in std::fs::read_dir(dim.join("region"))? {
|
||||
let mut region = RegionFile::open(entry?.path())?;
|
||||
let positions: Vec<ChunkPos> = region.chunks().map(|(p, _)| p).collect();
|
||||
for p in positions {
|
||||
let Some(record) = region.read(p)? else {
|
||||
continue;
|
||||
};
|
||||
let tag = record.nbt(Limits::default())?;
|
||||
if tag.tag.get("isLightOn") != Some(&Tag::Byte(1)) {
|
||||
continue;
|
||||
}
|
||||
if let Some(c) = save::decode_with(&tag, assets.registry, &biomes, Some(&tables)) {
|
||||
chunks.insert((c.x, c.z), c);
|
||||
originals.insert((p.x, p.z), tag);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut keys: Vec<_> = chunks
|
||||
.keys()
|
||||
.copied()
|
||||
.filter(|&(x, z)| {
|
||||
(-1..=1).all(|dz| (-1..=1).all(|dx| chunks.contains_key(&(x + dx, z + dz))))
|
||||
})
|
||||
.collect();
|
||||
keys.sort_unstable();
|
||||
let (
|
||||
mut blocks_bad,
|
||||
mut biomes_bad,
|
||||
mut heightmaps_bad,
|
||||
mut light_bad,
|
||||
mut light_total,
|
||||
mut other_bad,
|
||||
) = (0, 0, 0, 0u64, 0u64, 0);
|
||||
for &(x, z) in &keys {
|
||||
let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
|
||||
std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1)))
|
||||
});
|
||||
let mut chunk = chunks[&(x, z)].clone();
|
||||
chunk.sections = light_chunk(®ion, &lights, sky_light);
|
||||
chunk.lit = true;
|
||||
let ours = save::encode_with(&chunk, assets.registry, &biomes, Some(&tables), sky_light);
|
||||
let theirs = &originals[&(x, z)];
|
||||
let (a, b) = (&ours.tag, &theirs.tag);
|
||||
// Block states: compare every non-empty vanilla section.
|
||||
let (na, nb) = (block_names(a), block_names(b));
|
||||
for (y, vb) in &nb {
|
||||
match na.get(y) {
|
||||
Some(va) if va == vb => {}
|
||||
Some(va) => {
|
||||
let n = va.iter().zip(vb).filter(|(p, q)| p != q).count();
|
||||
if blocks_bad < 5 {
|
||||
let i = va.iter().zip(vb).position(|(p, q)| p != q).unwrap_or(0);
|
||||
eprintln!(
|
||||
"chunk {x} {z} section {y}: {n} blocks differ, e.g. {} vs {}",
|
||||
va[i], vb[i]
|
||||
);
|
||||
}
|
||||
blocks_bad += 1;
|
||||
}
|
||||
None if vb.iter().all(|s| s.starts_with("minecraft:air")) => {}
|
||||
None => blocks_bad += 1,
|
||||
}
|
||||
}
|
||||
let biome_of = |t: &Tag| -> Vec<Tag> {
|
||||
match t.get("sections") {
|
||||
Some(Tag::List(l)) => l.iter().filter_map(|s| s.get("biomes").cloned()).collect(),
|
||||
_ => Vec::new(),
|
||||
}
|
||||
};
|
||||
if biome_of(a) != biome_of(b) {
|
||||
biomes_bad += 1;
|
||||
}
|
||||
for kind in [
|
||||
"WORLD_SURFACE",
|
||||
"OCEAN_FLOOR",
|
||||
"MOTION_BLOCKING",
|
||||
"MOTION_BLOCKING_NO_LEAVES",
|
||||
] {
|
||||
let get = |t: &Tag| t.get("Heightmaps").and_then(|h| h.get(kind)).cloned();
|
||||
if get(a) != get(b) {
|
||||
if heightmaps_bad < 5 {
|
||||
eprintln!("chunk {x} {z}: heightmap {kind} differs");
|
||||
}
|
||||
heightmaps_bad += 1;
|
||||
}
|
||||
}
|
||||
for (key, sky) in [("SkyLight", true), ("BlockLight", false)] {
|
||||
if sky && !sky_light {
|
||||
continue;
|
||||
}
|
||||
let (la, lb) = (light(a, key), light(b, key));
|
||||
let top = i64::from((MIN_Y >> 4) + SECTIONS as i32);
|
||||
for si in 0..SECTIONS {
|
||||
let sy = i64::from((MIN_Y >> 4) + si as i32);
|
||||
let empty = chunk.sections[si].is_uniform(tables_air(&assets));
|
||||
for i in 0..4096 {
|
||||
light_total += 1;
|
||||
if value(&la, sy, i, sky, empty, top) != value(&lb, sy, i, sky, empty, top) {
|
||||
light_bad += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for key in ["block_entities", "block_ticks", "fluid_ticks"] {
|
||||
if count(a, key) != count(b, key) {
|
||||
if other_bad < 5 {
|
||||
eprintln!(
|
||||
"chunk {x} {z}: {key} {} vs {}",
|
||||
count(a, key),
|
||||
count(b, key)
|
||||
);
|
||||
}
|
||||
other_bad += 1;
|
||||
}
|
||||
}
|
||||
for key in [
|
||||
"structures",
|
||||
"PostProcessing",
|
||||
"InhabitedTime",
|
||||
"Status",
|
||||
"DataVersion",
|
||||
"yPos",
|
||||
] {
|
||||
if a.get(key) != b.get(key) {
|
||||
if other_bad < 5 {
|
||||
eprintln!("chunk {x} {z}: {key} differs");
|
||||
}
|
||||
other_bad += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
println!(
|
||||
"{} chunks: {blocks_bad} sections with different blocks, {biomes_bad} chunks with different biomes, \
|
||||
{heightmaps_bad} different heightmaps, {light_bad} of {light_total} light values differ, {other_bad} other differences",
|
||||
keys.len()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn tables_air(assets: &Assets) -> u16 {
|
||||
assets
|
||||
.registry
|
||||
.default_state("minecraft:air")
|
||||
.map_or(0, |s| s.0 as u16)
|
||||
}
|
||||
@@ -101,6 +101,10 @@ pub struct Chunk {
|
||||
/// Generation postprocessing marks (ProtoChunk.postProcessing) as world
|
||||
/// positions, applied once by LevelChunk.postProcessGeneration.
|
||||
pub postprocess: Vec<[i32; 3]>,
|
||||
/// Saved data Horizon keeps but does not simulate (save.rs).
|
||||
pub saved: Option<Arc<crate::save::ChunkExtras>>,
|
||||
/// Entities read from a save (vanilla entity NBT), spawned on arrival.
|
||||
pub entities: Vec<horizon_world::nbt::Tag>,
|
||||
}
|
||||
impl Chunk {
|
||||
pub fn empty(x: i32, z: i32) -> Self {
|
||||
@@ -114,6 +118,8 @@ impl Chunk {
|
||||
fresh: false,
|
||||
block_entities: Vec::new(),
|
||||
postprocess: Vec::new(),
|
||||
saved: None,
|
||||
entities: Vec::new(),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
|
||||
@@ -0,0 +1,358 @@
|
||||
//! Vanilla 26.3 entity NBT (`Entity.saveWithoutId` and the subclasses'
|
||||
//! `addAdditionalSaveData`) for the entities Horizon simulates: mobs, item
|
||||
//! entities, experience orbs, arrows and falling blocks. Encoding starts from
|
||||
//! the compound the entity was loaded with, when there is one, so fields
|
||||
//! Horizon does not model (variants, attributes, equipment, custom names)
|
||||
//! survive a Horizon save.
|
||||
use crate::{
|
||||
entities::{Arrow, ExperienceOrb, ItemEntity},
|
||||
mobs::{Mob, MobType},
|
||||
save::{doubles, float, floats, item_from_nbt, item_to_nbt, number, put, read_doubles, text, uuid_from_tag},
|
||||
};
|
||||
use horizon_core::geometry::Vec3;
|
||||
use horizon_world::nbt::{Compound, Tag};
|
||||
use std::{collections::HashMap, sync::Arc};
|
||||
|
||||
fn string(s: &str) -> Tag {
|
||||
Tag::String(s.into())
|
||||
}
|
||||
/// Entity type ID (`id`).
|
||||
pub fn kind(tag: &Tag) -> Option<String> {
|
||||
text(tag.get("id"))
|
||||
}
|
||||
pub fn position(tag: &Tag) -> Option<Vec3> {
|
||||
read_doubles::<3>(tag.get("Pos")).map(|p| Vec3::new(p[0], p[1], p[2]))
|
||||
}
|
||||
pub fn uuid(tag: &Tag) -> Option<[i32; 4]> {
|
||||
uuid_from_tag(tag.get("UUID"))
|
||||
}
|
||||
fn motion(tag: &Tag) -> Vec3 {
|
||||
read_doubles::<3>(tag.get("Motion")).map_or(Vec3::ZERO, |m| Vec3::new(m[0], m[1], m[2]))
|
||||
}
|
||||
fn rotation(tag: &Tag) -> [f32; 2] {
|
||||
read_doubles::<2>(tag.get("Rotation")).map_or([0.0; 2], |r| [r[0] as f32, r[1] as f32])
|
||||
}
|
||||
fn flag(tag: &Tag, key: &str) -> bool {
|
||||
number(tag.get(key)).unwrap_or(0) != 0
|
||||
}
|
||||
/// `Entity.saveWithoutId` fields every entity has, over the loaded compound.
|
||||
struct Base<'a> {
|
||||
id: &'a str,
|
||||
uuid: [i32; 4],
|
||||
position: Vec3,
|
||||
motion: Vec3,
|
||||
rotation: [f32; 2],
|
||||
on_ground: bool,
|
||||
fall_distance: f64,
|
||||
}
|
||||
impl Base<'_> {
|
||||
fn tag(&self, raw: Option<&Tag>) -> Tag {
|
||||
let mut tag = match raw {
|
||||
Some(t @ Tag::Compound(_)) => t.clone(),
|
||||
_ => Tag::Compound(Compound::new()),
|
||||
};
|
||||
for (key, value) in [
|
||||
("id", string(self.id)),
|
||||
("UUID", Tag::IntArray(self.uuid.to_vec())),
|
||||
("Pos", doubles(&[self.position.x, self.position.y, self.position.z])),
|
||||
("Motion", doubles(&[self.motion.x, self.motion.y, self.motion.z])),
|
||||
("Rotation", floats(&self.rotation)),
|
||||
("OnGround", Tag::Byte(i8::from(self.on_ground))),
|
||||
("fall_distance", Tag::Double(self.fall_distance.to_bits())),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
if let Tag::Compound(map) = &mut tag {
|
||||
for (key, value) in [("Fire", Tag::Short(-1)), ("Air", Tag::Short(300)), ("Invulnerable", Tag::Byte(0)), ("PortalCooldown", Tag::Int(0))] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
}
|
||||
tag
|
||||
}
|
||||
}
|
||||
|
||||
/// `LivingEntity` + `Mob` (+ `AgeableMob`, creeper and skeleton specifics).
|
||||
pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
let base = Base {
|
||||
id: &m.kind.id,
|
||||
uuid,
|
||||
position: m.position,
|
||||
motion: m.velocity,
|
||||
rotation: [m.yaw, m.head_pitch],
|
||||
on_ground: m.on_ground,
|
||||
fall_distance: m.fall_distance,
|
||||
};
|
||||
let mut tag = base.tag(raw);
|
||||
for (key, value) in [
|
||||
("Health", Tag::Float(m.health.max(0.0).to_bits())),
|
||||
("HurtTime", Tag::Short(m.hurt_time.clamp(0, i32::from(i16::MAX)) as i16)),
|
||||
("DeathTime", Tag::Short(m.death_time.clamp(0, i32::from(i16::MAX)) as i16)),
|
||||
("PersistenceRequired", Tag::Byte(i8::from(m.persistent))),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
let Tag::Compound(map) = &mut tag else { return tag };
|
||||
for (key, value) in [
|
||||
("AbsorptionAmount", Tag::Float(0)),
|
||||
("FallFlying", Tag::Byte(0)),
|
||||
("CanPickUpLoot", Tag::Byte(0)),
|
||||
("LeftHanded", Tag::Byte(0)),
|
||||
("Brain", Tag::compound([("memories", Tag::Compound(Compound::new()))])),
|
||||
] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
let id = m.kind.id.as_str();
|
||||
if m.kind.category == "creature" {
|
||||
for (key, value) in [("Age", Tag::Int(0)), ("ForcedAge", Tag::Int(0)), ("InLove", Tag::Int(0)), ("AgeLocked", Tag::Byte(0))] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
}
|
||||
match id {
|
||||
"minecraft:creeper" => {
|
||||
for (key, value) in [("Fuse", Tag::Short(30)), ("ExplosionRadius", Tag::Byte(3)), ("powered", Tag::Byte(0)), ("ignited", Tag::Byte(0))] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
}
|
||||
// Skeletons are spawned holding a bow (finalizeSpawn); a mob loaded
|
||||
// from NBT keeps only its saved equipment.
|
||||
"minecraft:skeleton" | "minecraft:stray" | "minecraft:bogged" => {
|
||||
map.entry("equipment".into()).or_insert_with(|| Tag::compound([("mainhand", Tag::compound([("id", string("minecraft:bow")), ("count", Tag::Int(1))]))]));
|
||||
}
|
||||
"minecraft:zombie" => {
|
||||
for (key, value) in [("IsBaby", Tag::Byte(0)), ("CanBreakDoors", Tag::Byte(0)), ("DrownedConversionTime", Tag::Int(-1)), ("InWaterTime", Tag::Int(-1))] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
}
|
||||
"minecraft:sheep" => {
|
||||
for (key, value) in [("Color", Tag::Byte(0)), ("Sheared", Tag::Byte(0))] {
|
||||
map.entry(key.into()).or_insert(value);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
tag
|
||||
}
|
||||
pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -> Option<Mob> {
|
||||
let kind = types.get(&self::kind(tag)?)?.clone();
|
||||
let position = position(tag)?;
|
||||
let [yaw, pitch] = rotation(tag);
|
||||
let mut m = Mob::new(id, kind, position, yaw);
|
||||
m.velocity = motion(tag);
|
||||
m.head_pitch = pitch;
|
||||
m.on_ground = flag(tag, "OnGround");
|
||||
m.fall_distance = float(tag.get("fall_distance")).unwrap_or(0.0);
|
||||
if let Some(h) = float(tag.get("Health")) {
|
||||
m.health = h as f32;
|
||||
}
|
||||
m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
|
||||
m.death_time = number(tag.get("DeathTime")).unwrap_or(0) as i32;
|
||||
m.persistent = flag(tag, "PersistenceRequired");
|
||||
// A mob saved mid-death finishes dying; one saved dead is dropped.
|
||||
if m.health <= 0.0 && m.death_time == 0 {
|
||||
return None;
|
||||
}
|
||||
Some(m)
|
||||
}
|
||||
|
||||
/// `ItemEntity`: Health, Age, PickupDelay, Item.
|
||||
pub fn item_entity_to_nbt(e: &ItemEntity, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
let base = Base {
|
||||
id: "minecraft:item",
|
||||
uuid,
|
||||
position: e.position,
|
||||
motion: e.velocity,
|
||||
rotation: [0.0, 0.0],
|
||||
on_ground: e.on_ground,
|
||||
fall_distance: 0.0,
|
||||
};
|
||||
let mut tag = base.tag(raw);
|
||||
for (key, value) in [
|
||||
("Item", item_to_nbt(&e.stack)),
|
||||
("Age", Tag::Short(e.age.min(i16::MAX as u32) as i16)),
|
||||
("PickupDelay", Tag::Short(e.pickup_delay.min(i16::MAX as u32) as i16)),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
if let Tag::Compound(map) = &mut tag {
|
||||
map.entry("Health".into()).or_insert(Tag::Short(5));
|
||||
}
|
||||
tag
|
||||
}
|
||||
pub fn item_entity_from_nbt(tag: &Tag, id: u32, bob_offset: f32) -> Option<ItemEntity> {
|
||||
let stack = item_from_nbt(tag.get("Item")?)?;
|
||||
let position = position(tag)?;
|
||||
Some(ItemEntity {
|
||||
id,
|
||||
stack,
|
||||
position,
|
||||
previous: position,
|
||||
velocity: motion(tag),
|
||||
on_ground: flag(tag, "OnGround"),
|
||||
// Age -32768 marks items that never despawn; Horizon counts upwards.
|
||||
age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
|
||||
pickup_delay: number(tag.get("PickupDelay")).unwrap_or(0).clamp(0, 32767) as u32,
|
||||
bob_offset,
|
||||
})
|
||||
}
|
||||
|
||||
/// `ExperienceOrb`: Health, Age, Value, Count.
|
||||
pub fn orb_to_nbt(o: &ExperienceOrb, uuid: [i32; 4]) -> Tag {
|
||||
let base = Base {
|
||||
id: "minecraft:experience_orb",
|
||||
uuid,
|
||||
position: o.position,
|
||||
motion: o.velocity,
|
||||
rotation: [0.0, 0.0],
|
||||
on_ground: o.on_ground,
|
||||
fall_distance: 0.0,
|
||||
};
|
||||
let mut tag = base.tag(None);
|
||||
for (key, value) in [
|
||||
("Health", Tag::Short(5)),
|
||||
("Age", Tag::Short(o.age.min(i16::MAX as u32) as i16)),
|
||||
("Value", Tag::Short(o.value.min(i16::MAX as u32) as i16)),
|
||||
("Count", Tag::Int(1)),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
tag
|
||||
}
|
||||
/// One Horizon orb per counted orb (vanilla merges orbs of equal value).
|
||||
pub fn orbs_from_nbt(tag: &Tag) -> Vec<ExperienceOrb> {
|
||||
let Some(position) = position(tag) else { return Vec::new() };
|
||||
let count = number(tag.get("Count")).unwrap_or(1).clamp(1, 64) as usize;
|
||||
let orb = ExperienceOrb {
|
||||
position,
|
||||
previous: position,
|
||||
velocity: motion(tag),
|
||||
value: number(tag.get("Value")).unwrap_or(1).max(1) as u32,
|
||||
age: number(tag.get("Age")).unwrap_or(0).max(0) as u32,
|
||||
on_ground: flag(tag, "OnGround"),
|
||||
};
|
||||
vec![orb; count]
|
||||
}
|
||||
|
||||
/// `AbstractArrow`: damage, crit, inGround, life, pickup, item.
|
||||
pub fn arrow_to_nbt(a: &Arrow, uuid: [i32; 4], owner: Option<[i32; 4]>) -> Tag {
|
||||
let v = a.velocity;
|
||||
let horizontal = (v.x * v.x + v.z * v.z).sqrt();
|
||||
let rotation = [(v.x.atan2(v.z).to_degrees()) as f32, (v.y.atan2(horizontal).to_degrees()) as f32];
|
||||
let base = Base {
|
||||
id: "minecraft:arrow",
|
||||
uuid,
|
||||
position: a.position,
|
||||
motion: a.velocity,
|
||||
rotation,
|
||||
on_ground: false,
|
||||
fall_distance: 0.0,
|
||||
};
|
||||
let mut tag = base.tag(None);
|
||||
for (key, value) in [
|
||||
("damage", Tag::Double(a.base_damage.to_bits())),
|
||||
("crit", Tag::Byte(i8::from(a.critical))),
|
||||
("inGround", Tag::Byte(i8::from(a.stuck))),
|
||||
("life", Tag::Short(if a.stuck { a.age.min(1200) as i16 } else { 0 })),
|
||||
// Pickup: allowed for the player's arrows, disallowed for mobs'.
|
||||
("pickup", Tag::Byte(i8::from(a.from_player))),
|
||||
("shake", Tag::Byte(0)),
|
||||
("PierceLevel", Tag::Byte(0)),
|
||||
("HasBeenShot", Tag::Byte(1)),
|
||||
("SoundEvent", string("minecraft:entity.arrow.hit")),
|
||||
("item", Tag::compound([("id", string("minecraft:arrow")), ("count", Tag::Int(1))])),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
if let Some(owner) = owner {
|
||||
put(&mut tag, "Owner", Tag::IntArray(owner.to_vec()));
|
||||
}
|
||||
tag
|
||||
}
|
||||
pub fn arrow_from_nbt(tag: &Tag, player: Option<[i32; 4]>) -> Option<Arrow> {
|
||||
let position = position(tag)?;
|
||||
let stuck = flag(tag, "inGround");
|
||||
Some(Arrow {
|
||||
from_player: player.is_some() && uuid_from_tag(tag.get("Owner")) == player || number(tag.get("pickup")) == Some(1),
|
||||
critical: flag(tag, "crit"),
|
||||
position,
|
||||
previous: position,
|
||||
velocity: motion(tag),
|
||||
stuck,
|
||||
age: if stuck { number(tag.get("life")).unwrap_or(0).max(0) as u32 } else { 0 },
|
||||
base_damage: float(tag.get("damage")).unwrap_or(2.0),
|
||||
})
|
||||
}
|
||||
|
||||
/// `FallingBlockEntity`: BlockState, Time, DropItem, HurtEntities.
|
||||
pub fn falling_block_to_nbt(state: Tag, position: Vec3, motion: Vec3, time: u32, uuid: [i32; 4]) -> Tag {
|
||||
let base = Base {
|
||||
id: "minecraft:falling_block",
|
||||
uuid,
|
||||
position,
|
||||
motion,
|
||||
rotation: [0.0, 0.0],
|
||||
on_ground: false,
|
||||
fall_distance: 0.0,
|
||||
};
|
||||
let mut tag = base.tag(None);
|
||||
for (key, value) in [
|
||||
("BlockState", state),
|
||||
("Time", Tag::Int(time as i32)),
|
||||
("DropItem", Tag::Byte(1)),
|
||||
("HurtEntities", Tag::Byte(0)),
|
||||
("CancelDrop", Tag::Byte(0)),
|
||||
("FallHurtAmount", Tag::Float(0)),
|
||||
("FallHurtMax", Tag::Int(40)),
|
||||
] {
|
||||
put(&mut tag, key, value);
|
||||
}
|
||||
tag
|
||||
}
|
||||
/// (block state tag, position, motion, time)
|
||||
pub fn falling_block_from_nbt(tag: &Tag) -> Option<(Tag, Vec3, Vec3, u32)> {
|
||||
Some((tag.get("BlockState")?.clone(), position(tag)?, motion(tag), number(tag.get("Time")).unwrap_or(0).max(0) as u32))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::items::ItemStack;
|
||||
|
||||
#[test]
|
||||
fn item_entities_round_trip() {
|
||||
let e = ItemEntity {
|
||||
id: 7,
|
||||
stack: ItemStack { item: Arc::from("minecraft:diamond_pickaxe"), count: 1, damage: 5 },
|
||||
position: Vec3::new(100.5, 64.0, -31.5),
|
||||
previous: Vec3::ZERO,
|
||||
velocity: Vec3::new(0.0, -0.04, 0.0),
|
||||
on_ground: true,
|
||||
age: 120,
|
||||
pickup_delay: 10,
|
||||
bob_offset: 0.0,
|
||||
};
|
||||
let tag = item_entity_to_nbt(&e, [1, 2, 3, 4], None);
|
||||
assert_eq!(kind(&tag).as_deref(), Some("minecraft:item"));
|
||||
assert_eq!(uuid(&tag), Some([1, 2, 3, 4]));
|
||||
let back = item_entity_from_nbt(&tag, 9, 0.0).unwrap();
|
||||
assert_eq!(back.stack.damage, 5);
|
||||
assert_eq!((back.age, back.pickup_delay, back.on_ground), (120, 10, true));
|
||||
assert_eq!(back.position.x, 100.5);
|
||||
}
|
||||
#[test]
|
||||
fn unknown_fields_survive() {
|
||||
let raw = Tag::compound([("id", string("minecraft:item")), ("CustomName", string("x")), ("Pos", doubles(&[0.5, 64.0, 0.5])), ("Item", Tag::compound([("id", string("minecraft:stone")), ("count", Tag::Int(3))]))]);
|
||||
let e = item_entity_from_nbt(&raw, 1, 0.0).unwrap();
|
||||
let tag = item_entity_to_nbt(&e, [0; 4], Some(&raw));
|
||||
assert_eq!(text(tag.get("CustomName")).as_deref(), Some("x"));
|
||||
assert_eq!(number(tag.get("Health")), Some(5));
|
||||
}
|
||||
#[test]
|
||||
fn orbs_expand_their_count() {
|
||||
let o = ExperienceOrb { position: Vec3::new(1.0, 2.0, 3.0), previous: Vec3::ZERO, velocity: Vec3::ZERO, value: 7, age: 3, on_ground: false };
|
||||
let mut tag = orb_to_nbt(&o, [0; 4]);
|
||||
put(&mut tag, "Count", Tag::Int(3));
|
||||
let back = orbs_from_nbt(&tag);
|
||||
assert_eq!(back.len(), 3);
|
||||
assert_eq!(back[0].value, 7);
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,7 @@
|
||||
mod control;
|
||||
mod end;
|
||||
mod postprocess;
|
||||
mod persist;
|
||||
use horizon_client::{
|
||||
Result,
|
||||
assets::Assets,
|
||||
@@ -395,6 +396,7 @@ struct Game<'a> {
|
||||
/// Control replies waiting for a rendered frame or a benchmark deadline.
|
||||
pending_screenshot: Option<std::sync::mpsc::Sender<String>>,
|
||||
pending_bench: Option<(Instant, std::sync::mpsc::Sender<String>)>,
|
||||
persist: persist::EntityMemory,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
enum Dim {
|
||||
@@ -719,7 +721,7 @@ impl Game<'_> {
|
||||
fn sync_tick_chunks(&mut self) {
|
||||
let loaded: HashSet<(i32, i32)> = self.world.chunks.keys().copied().collect();
|
||||
for k in loaded.difference(&self.tick_chunks.clone()) {
|
||||
let _ = self.block_ticks.add_empty_chunk(horizon_core::position::ChunkPos::new(k.0, k.1));
|
||||
self.register_chunk_ticks(*k);
|
||||
}
|
||||
for k in self.tick_chunks.difference(&loaded) {
|
||||
self.block_ticks.remove_chunk(horizon_core::position::ChunkPos::new(k.0, k.1));
|
||||
@@ -1400,6 +1402,7 @@ impl Game<'_> {
|
||||
self.tick_using();
|
||||
self.tick_mining()?;
|
||||
self.tick_items();
|
||||
self.spawn_loaded_entities();
|
||||
self.tick_mobs()?;
|
||||
self.tick_experience();
|
||||
self.tick_hand();
|
||||
@@ -2618,6 +2621,7 @@ impl Game<'_> {
|
||||
.filter(|(p, _)| p.0 >> 4 == c.x && p.2 >> 4 == c.z)
|
||||
.map(|(p, e)| (*p, e.clone()))
|
||||
.collect();
|
||||
self.attach_save_data(&mut c);
|
||||
Arc::new(c)
|
||||
}
|
||||
fn tick_mobs(&mut self) -> Result<()> {
|
||||
@@ -2884,6 +2888,8 @@ impl Game<'_> {
|
||||
/// Load (or create) a world folder under saves/ and start streaming it.
|
||||
fn open_world(&mut self, folder: &str, name: Option<&str>, seed: Option<i64>, creative: bool) -> Result<()> {
|
||||
let save_root = std::env::current_dir()?.join("saves").join(folder);
|
||||
horizon_client::save::migrate_legacy(&save_root)?;
|
||||
self.persist = Default::default();
|
||||
let level = Level::read(&save_root).unwrap_or_else(|| Level {
|
||||
name: name.unwrap_or(folder).to_owned(),
|
||||
// WorldOptions.randomSeed when no seed was given.
|
||||
@@ -2942,6 +2948,7 @@ impl Game<'_> {
|
||||
let (yaw, pitch) = self.options.look.unwrap_or((level.rotation[0], level.rotation[1]));
|
||||
self.yaw = yaw;
|
||||
self.pitch = pitch;
|
||||
self.selected = level.selected_slot.clamp(0, 8) as usize;
|
||||
self.streaming = streaming;
|
||||
self.world = world;
|
||||
self.inventory = inventory;
|
||||
@@ -2982,11 +2989,7 @@ impl Game<'_> {
|
||||
}
|
||||
/// Streaming and region storage for one dimension of a world.
|
||||
fn make_streaming(&self, world_root: &std::path::Path, dim: Dim, seed: i64) -> Result<(Streaming, Arc<SaveDir>)> {
|
||||
let region_root = match dim.folder() {
|
||||
Some(f) => world_root.join(f),
|
||||
None => world_root.to_owned(),
|
||||
};
|
||||
let save = Arc::new(SaveDir::new(region_root));
|
||||
let save = Arc::new(SaveDir::new(horizon_client::save::dimension_dir(world_root, dim.id())));
|
||||
let res = &*self.res;
|
||||
let mut streaming = if self.options.test_terrain && dim == Dim::Overworld {
|
||||
let inner = Arc::new(TestTerrain::new(res.assets.registry, &res.biomes)?);
|
||||
@@ -3011,6 +3014,7 @@ impl Game<'_> {
|
||||
let keys: Vec<_> = self.world.modified.drain().collect();
|
||||
let chunks: Vec<_> = keys.iter().filter_map(|k| self.world.chunks.get(k)).map(|c| self.with_entities(c)).collect();
|
||||
self.save.save(&chunks, &self.res.assets.registry, &self.res.biomes)?;
|
||||
self.save_dimension_entities()?;
|
||||
// Coordinates scale by 8 between the Overworld and the Nether.
|
||||
let scale = match (self.dim, target) {
|
||||
(Dim::Overworld, Dim::Nether) => 1.0 / 8.0,
|
||||
@@ -4118,6 +4122,8 @@ impl Game<'_> {
|
||||
.map(|c| self.with_entities(c))
|
||||
.collect();
|
||||
self.save.save(&chunks, &self.res.assets.registry, &self.res.biomes)?;
|
||||
self.save_entities()?;
|
||||
self.level.selected_slot = self.selected as i32;
|
||||
let level = &mut self.level;
|
||||
level.creative = self.creative;
|
||||
level.time = self.world.game_time;
|
||||
@@ -4363,6 +4369,7 @@ impl Game<'_> {
|
||||
.cloned()
|
||||
.collect();
|
||||
let modified: Vec<_> = dirty.iter().map(|c| self.with_entities(c)).collect();
|
||||
self.unload_entities(&unloaded);
|
||||
for c in &unloaded {
|
||||
self.world.block_entities.retain(|p, _| !(p.0 >> 4 == c.x && p.2 >> 4 == c.z));
|
||||
}
|
||||
@@ -4686,7 +4693,7 @@ pub fn run() -> Result<()> {
|
||||
let visibility = models::load_visibility(&root, &assets.registry)?;
|
||||
eprintln!("load visibility: {:.2}s", started.elapsed().as_secs_f32());
|
||||
let tables = Arc::new(MeshTables::new(&assets, &facts, visibility)?);
|
||||
let light = Arc::new(LightTables::new(&facts));
|
||||
let light = Arc::new(LightTables::load(&root, &assets.registry, &facts)?);
|
||||
eprintln!("load tables: {:.2}s", started.elapsed().as_secs_f32());
|
||||
let atlas = HudAtlas::build(&root)?;
|
||||
eprintln!("load atlas: {:.2}s", started.elapsed().as_secs_f32());
|
||||
@@ -4853,6 +4860,7 @@ pub fn run() -> Result<()> {
|
||||
frame_stats: Default::default(),
|
||||
pending_screenshot: None,
|
||||
pending_bench: None,
|
||||
persist: Default::default(),
|
||||
};
|
||||
if let Some(path) = &game.options.control {
|
||||
let server = horizon_client::control::Server::start(path)
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
//! Saving and loading the game state that lives outside chunk blocks:
|
||||
//! entities (`entities/*.mca`, per chunk like vanilla's `EntityStorage`) and
|
||||
//! scheduled block/fluid ticks (chunk `block_ticks`/`fluid_ticks`).
|
||||
use super::{FallingBlock, Game};
|
||||
use horizon_client::{
|
||||
Result,
|
||||
chunk::Chunk,
|
||||
entity_nbt,
|
||||
save::{ChunkExtras, random_uuid},
|
||||
};
|
||||
use horizon_core::{
|
||||
geometry::Vec3,
|
||||
position::ChunkPos,
|
||||
random::RandomSource,
|
||||
ticks::ChunkTicks,
|
||||
};
|
||||
use horizon_world::{chunk::BlockState, nbt::Tag, registry::BlockStateId};
|
||||
use std::{
|
||||
collections::{HashMap, HashSet},
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
/// What Horizon remembers about loaded entities to save them faithfully.
|
||||
#[derive(Default)]
|
||||
pub struct EntityMemory {
|
||||
/// UUIDs of mobs and item entities by Horizon entity ID.
|
||||
uuids: HashMap<u32, [i32; 4]>,
|
||||
/// The compound each mob or item entity was loaded with.
|
||||
raw: HashMap<u32, Tag>,
|
||||
/// Entities of types Horizon does not simulate, kept per chunk and
|
||||
/// written back unchanged.
|
||||
unknown: HashMap<(i32, i32), Vec<Tag>>,
|
||||
}
|
||||
|
||||
fn chunk_of(p: Vec3) -> (i32, i32) {
|
||||
((p.x.floor() as i32) >> 4, (p.z.floor() as i32) >> 4)
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
/// Saved ticks and the save time for a chunk about to be written.
|
||||
pub(super) fn attach_save_data(&self, chunk: &mut Chunk) {
|
||||
let pos = ChunkPos::new(chunk.x, chunk.z);
|
||||
let time = self.world.game_time;
|
||||
let mut extras: ChunkExtras = chunk.saved.as_deref().cloned().unwrap_or_default();
|
||||
if let Some(t) = self.block_ticks.blocks.chunk(pos) {
|
||||
extras.block_ticks = t.pack(time);
|
||||
} else {
|
||||
extras.block_ticks.clear();
|
||||
}
|
||||
if let Some(t) = self.block_ticks.fluids.chunk(pos) {
|
||||
extras.fluid_ticks = t.pack(time);
|
||||
} else {
|
||||
extras.fluid_ticks.clear();
|
||||
}
|
||||
extras.last_update = time;
|
||||
chunk.saved = Some(Arc::new(extras));
|
||||
}
|
||||
/// Register a newly resident chunk with the tick scheduler, with the
|
||||
/// block and fluid ticks it was saved with.
|
||||
pub(super) fn register_chunk_ticks(&mut self, key: (i32, i32)) {
|
||||
let pos = ChunkPos::new(key.0, key.1);
|
||||
let saved = self.world.chunks.get(&key).and_then(|c| c.saved.clone());
|
||||
let (blocks, fluids) = saved.as_deref().map_or((Vec::new(), Vec::new()), |s| (s.block_ticks.clone(), s.fluid_ticks.clone()));
|
||||
let loaded = !blocks.is_empty() || !fluids.is_empty();
|
||||
if self.block_ticks.add_chunk(pos, ChunkTicks::from_saved(blocks), ChunkTicks::from_saved(fluids)).is_ok() && loaded {
|
||||
let time = self.world.game_time;
|
||||
self.block_ticks.blocks.unpack_chunk(pos, time);
|
||||
self.block_ticks.fluids.unpack_chunk(pos, time);
|
||||
}
|
||||
// The saved list is consumed: later saves take the scheduler's ticks.
|
||||
if loaded && let Some(c) = self.world.chunks.get_mut(&key) {
|
||||
let c = Arc::make_mut(c);
|
||||
if let Some(s) = c.saved.as_mut() {
|
||||
let s = Arc::make_mut(s);
|
||||
s.block_ticks.clear();
|
||||
s.fluid_ticks.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Spawn the entities of chunks that finished loading.
|
||||
pub(super) fn spawn_loaded_entities(&mut self) {
|
||||
let loaded = std::mem::take(&mut self.world.loaded_entities);
|
||||
let player_uuid = self.level.player_uuid;
|
||||
for (key, tags) in loaded {
|
||||
for tag in tags {
|
||||
let kind = entity_nbt::kind(&tag).unwrap_or_default();
|
||||
let uuid = entity_nbt::uuid(&tag);
|
||||
match kind.as_str() {
|
||||
"minecraft:item" => {
|
||||
self.next_entity += 1;
|
||||
let bob = self.world.random.next_float() * std::f32::consts::PI * 2.0;
|
||||
if let Some(e) = entity_nbt::item_entity_from_nbt(&tag, self.next_entity, bob) {
|
||||
self.remember(e.id, uuid, tag);
|
||||
self.dropped.push(e);
|
||||
}
|
||||
}
|
||||
"minecraft:experience_orb" => self.orbs.extend(entity_nbt::orbs_from_nbt(&tag)),
|
||||
"minecraft:arrow" => {
|
||||
if let Some(a) = entity_nbt::arrow_from_nbt(&tag, player_uuid) {
|
||||
self.arrows.push(a);
|
||||
}
|
||||
}
|
||||
"minecraft:falling_block" => {
|
||||
if let Some((state, position, velocity, age)) = entity_nbt::falling_block_from_nbt(&tag)
|
||||
&& let Some(state) = self.state_from_nbt(&state)
|
||||
{
|
||||
self.falling.push(FallingBlock { state, position, previous: position, velocity, age });
|
||||
}
|
||||
}
|
||||
_ if self.res.mob_types.contains_key(&kind) => {
|
||||
self.next_entity += 1;
|
||||
if let Some(m) = entity_nbt::mob_from_nbt(&tag, &self.res.mob_types, self.next_entity) {
|
||||
self.remember(m.id, uuid, tag);
|
||||
self.mobs.push(m);
|
||||
}
|
||||
}
|
||||
_ => self.persist.unknown.entry(key).or_default().push(tag),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn remember(&mut self, id: u32, uuid: Option<[i32; 4]>, tag: Tag) {
|
||||
if let Some(u) = uuid {
|
||||
self.persist.uuids.insert(id, u);
|
||||
}
|
||||
self.persist.raw.insert(id, tag);
|
||||
}
|
||||
fn uuid_for(&mut self, id: u32) -> [i32; 4] {
|
||||
*self.persist.uuids.entry(id).or_insert_with(random_uuid)
|
||||
}
|
||||
/// `BlockState.CODEC`: a block name or `{id, properties}` (or legacy `{Name, Properties}`).
|
||||
fn state_from_nbt(&self, tag: &Tag) -> Option<BlockStateId> {
|
||||
let registry = self.res.assets.registry;
|
||||
let state = match tag.get("Name") {
|
||||
Some(Tag::String(name)) => BlockState {
|
||||
name: name.to_string_lossy(),
|
||||
properties: match tag.get("Properties") {
|
||||
Some(Tag::Compound(p)) => p
|
||||
.iter()
|
||||
.filter_map(|(k, v)| match v {
|
||||
Tag::String(v) => Some((k.to_string_lossy(), v.to_string_lossy())),
|
||||
_ => None,
|
||||
})
|
||||
.collect(),
|
||||
_ => Default::default(),
|
||||
},
|
||||
},
|
||||
_ => BlockState::from_nbt(tag).ok()?,
|
||||
};
|
||||
registry.id(&state).or_else(|| registry.default_state(&state.name))
|
||||
}
|
||||
fn state_to_nbt(&self, state: BlockStateId) -> Tag {
|
||||
let registry = self.res.assets.registry;
|
||||
match registry.state(state) {
|
||||
Some(s) if registry.default_state(&s.name) == Some(state) => Tag::String(s.name.as_str().into()),
|
||||
Some(s) => s.to_nbt(),
|
||||
None => Tag::String("minecraft:air".into()),
|
||||
}
|
||||
}
|
||||
/// The entity NBT of every simulated entity in `keys`, plus the unknown
|
||||
/// entities kept for them. With `remove`, the entities leave the world
|
||||
/// (their chunks unload).
|
||||
fn entity_chunks(&mut self, keys: &HashSet<(i32, i32)>, remove: bool) -> Vec<((i32, i32), Vec<Tag>)> {
|
||||
let mut out: HashMap<(i32, i32), Vec<Tag>> = keys.iter().map(|k| (*k, Vec::new())).collect();
|
||||
let player_uuid = self.level.player_uuid;
|
||||
let mobs: Vec<usize> = (0..self.mobs.len()).filter(|&i| keys.contains(&chunk_of(self.mobs[i].position)) && self.mobs[i].alive()).collect();
|
||||
for i in mobs {
|
||||
let id = self.mobs[i].id;
|
||||
let uuid = self.uuid_for(id);
|
||||
let tag = entity_nbt::mob_to_nbt(&self.mobs[i], uuid, self.persist.raw.get(&id));
|
||||
out.entry(chunk_of(self.mobs[i].position)).or_default().push(tag);
|
||||
}
|
||||
let items: Vec<usize> = (0..self.dropped.len()).filter(|&i| keys.contains(&chunk_of(self.dropped[i].position))).collect();
|
||||
for i in items {
|
||||
let id = self.dropped[i].id;
|
||||
let uuid = self.uuid_for(id);
|
||||
let tag = entity_nbt::item_entity_to_nbt(&self.dropped[i], uuid, self.persist.raw.get(&id));
|
||||
out.entry(chunk_of(self.dropped[i].position)).or_default().push(tag);
|
||||
}
|
||||
for o in &self.orbs {
|
||||
if keys.contains(&chunk_of(o.position)) {
|
||||
out.entry(chunk_of(o.position)).or_default().push(entity_nbt::orb_to_nbt(o, random_uuid()));
|
||||
}
|
||||
}
|
||||
for a in &self.arrows {
|
||||
if keys.contains(&chunk_of(a.position)) {
|
||||
let owner = if a.from_player { player_uuid } else { None };
|
||||
out.entry(chunk_of(a.position)).or_default().push(entity_nbt::arrow_to_nbt(a, random_uuid(), owner));
|
||||
}
|
||||
}
|
||||
for f in &self.falling {
|
||||
if keys.contains(&chunk_of(f.position)) {
|
||||
let tag = entity_nbt::falling_block_to_nbt(self.state_to_nbt(f.state), f.position, f.velocity, f.age, random_uuid());
|
||||
out.entry(chunk_of(f.position)).or_default().push(tag);
|
||||
}
|
||||
}
|
||||
for key in keys {
|
||||
let unknown = if remove { self.persist.unknown.remove(key) } else { self.persist.unknown.get(key).cloned() };
|
||||
if let Some(list) = unknown {
|
||||
out.entry(*key).or_default().extend(list);
|
||||
}
|
||||
}
|
||||
if remove {
|
||||
let gone = |p: Vec3| keys.contains(&chunk_of(p));
|
||||
let mut removed: Vec<u32> = Vec::new();
|
||||
self.mobs.retain(|m| {
|
||||
let keep = !gone(m.position);
|
||||
if !keep {
|
||||
removed.push(m.id);
|
||||
}
|
||||
keep
|
||||
});
|
||||
self.dropped.retain(|e| {
|
||||
let keep = !gone(e.position);
|
||||
if !keep {
|
||||
removed.push(e.id);
|
||||
}
|
||||
keep
|
||||
});
|
||||
self.orbs.retain(|o| !gone(o.position));
|
||||
self.arrows.retain(|a| !gone(a.position));
|
||||
self.falling.retain(|f| !gone(f.position));
|
||||
for id in removed {
|
||||
self.persist.uuids.remove(&id);
|
||||
self.persist.raw.remove(&id);
|
||||
}
|
||||
}
|
||||
out.into_iter().collect()
|
||||
}
|
||||
/// Write the entities of every resident chunk (an autosave or quit).
|
||||
pub(super) fn save_entities(&mut self) -> Result<()> {
|
||||
self.spawn_loaded_entities();
|
||||
let keys: HashSet<(i32, i32)> = self.world.chunks.keys().copied().collect();
|
||||
let chunks = self.entity_chunks(&keys, false);
|
||||
// Forget entities that no longer exist.
|
||||
let alive: HashSet<u32> = self.mobs.iter().map(|m| m.id).chain(self.dropped.iter().map(|e| e.id)).collect();
|
||||
self.persist.uuids.retain(|id, _| alive.contains(id));
|
||||
self.persist.raw.retain(|id, _| alive.contains(id));
|
||||
self.save.save_entities(chunks)
|
||||
}
|
||||
/// Save and remove the entities of chunks that unloaded.
|
||||
pub(super) fn unload_entities(&mut self, unloaded: &[Arc<Chunk>]) {
|
||||
if unloaded.is_empty() {
|
||||
return;
|
||||
}
|
||||
self.spawn_loaded_entities();
|
||||
let keys: HashSet<(i32, i32)> = unloaded.iter().map(|c| (c.x, c.z)).collect();
|
||||
let chunks = self.entity_chunks(&keys, true);
|
||||
if let Err(e) = self.save.save_entities(chunks) {
|
||||
eprintln!("Horizon: failed to save entities: {e}");
|
||||
}
|
||||
}
|
||||
/// Leaving a dimension: its entities are saved with it.
|
||||
pub(super) fn save_dimension_entities(&mut self) -> Result<()> {
|
||||
self.spawn_loaded_entities();
|
||||
let keys: HashSet<(i32, i32)> = self.world.chunks.keys().copied().collect();
|
||||
let chunks = self.entity_chunks(&keys, true);
|
||||
self.persist = EntityMemory::default();
|
||||
self.save.save_entities(chunks)
|
||||
}
|
||||
}
|
||||
@@ -14,6 +14,7 @@ pub mod crafting;
|
||||
pub mod creative;
|
||||
pub mod collisions;
|
||||
pub mod entities;
|
||||
pub mod entity_nbt;
|
||||
pub mod environment;
|
||||
pub mod gfx;
|
||||
pub mod health;
|
||||
|
||||
@@ -1,26 +1,52 @@
|
||||
//! Sky and block light for one chunk, flood-filled over its 3x3 neighbourhood
|
||||
//! with vanilla's rules: sky sources run down each column until an edge is
|
||||
//! occluded (`ChunkSkyLightSources`), and light then spreads losing
|
||||
//! `max(1, dampening)` per step (`LightEngine.getOpacity`). Light can travel at
|
||||
//! most 15 blocks, so the 48-wide region determines the centre exactly, apart
|
||||
//! from face-shape occlusion of partial blocks (slabs, stairs), which is not
|
||||
//! modelled yet.
|
||||
//! with vanilla's `LightEngine` rules:
|
||||
//! - light entering a block loses `max(1, getLightDampening)` (`getOpacity`);
|
||||
//! - it cannot cross a face where the two blocks' occlusion faces together
|
||||
//! cover the whole square (`shapeOccludes`, using `getFaceOcclusionShape`
|
||||
//! only for states with `canOcclude && useShapeForLightOcclusion`), which is
|
||||
//! what makes slabs, stairs, snow layers etc. block light directionally;
|
||||
//! - sky sources run down each column to the first occluded edge
|
||||
//! (`ChunkSkyLightSources.isEdgeOccluded`: dampening != 0 or the faces
|
||||
//! between the two blocks occlude).
|
||||
//!
|
||||
//! The final values of vanilla's queue-based engine are the maximum over all
|
||||
//! paths, so a flood fill to the fixed point reproduces them. Light travels at
|
||||
//! most 15 blocks, so the 48-wide region determines the centre exactly.
|
||||
//! `relight_block` applies vanilla's incremental decrease/increase passes
|
||||
//! directly to resident chunks after a block change.
|
||||
use crate::{
|
||||
blocks::BlockFacts,
|
||||
chunk::{Chunk, HEIGHT, Light, SECTIONS, Section, index},
|
||||
chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, Section, index},
|
||||
};
|
||||
use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
|
||||
use horizon_world::registry::{BlockRegistry, BlockStateId};
|
||||
use std::{
|
||||
collections::{HashMap, VecDeque},
|
||||
path::Path,
|
||||
sync::Arc,
|
||||
};
|
||||
use std::{collections::VecDeque, sync::Arc};
|
||||
|
||||
const W: usize = 48;
|
||||
/// Face ID 0: empty occlusion face; 1: the full square.
|
||||
const EMPTY: u16 = 0;
|
||||
const FULL: u16 = 1;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct Cell {
|
||||
dampening: u8,
|
||||
emission: u8,
|
||||
/// Any face is non-empty (`!isEmptyShape`), so edges need the face table.
|
||||
shaped: bool,
|
||||
faces: [u16; 6],
|
||||
}
|
||||
pub struct LightTables {
|
||||
cells: Vec<Cell>,
|
||||
/// `faceShapeOccludes(a, b)` for every pair of distinct face shapes.
|
||||
occludes: Vec<bool>,
|
||||
faces: usize,
|
||||
}
|
||||
impl LightTables {
|
||||
/// Dampening and emission only: every occlusion face is empty.
|
||||
pub fn new(facts: &BlockFacts) -> Self {
|
||||
Self {
|
||||
cells: facts
|
||||
@@ -29,11 +55,120 @@ impl LightTables {
|
||||
.map(|s| Cell {
|
||||
dampening: s.dampening.min(15),
|
||||
emission: s.emission.min(15),
|
||||
shaped: false,
|
||||
faces: [EMPTY; 6],
|
||||
})
|
||||
.collect(),
|
||||
occludes: vec![false, true, true, true],
|
||||
faces: 2,
|
||||
}
|
||||
}
|
||||
/// Full tables with the vanilla occlusion shapes from `occlusion.nbt`.
|
||||
pub fn load(root: &Path, registry: &BlockRegistry, facts: &BlockFacts) -> crate::Result<Self> {
|
||||
use horizon_world::{
|
||||
collision::CachedCollisionRegistry,
|
||||
nbt::{self, Limits},
|
||||
};
|
||||
let data = nbt::read_named(&std::fs::read(root.join("occlusion.nbt"))?, Limits::default())?.0.tag;
|
||||
let occlusion = CachedCollisionRegistry::from_nbt(&data, registry)?;
|
||||
let mut tables = Self::new(facts);
|
||||
let block = VoxelShape::block();
|
||||
let mut shapes: Vec<VoxelShape> = vec![VoxelShape::empty(), block.clone()];
|
||||
let mut by_geometry: HashMap<Vec<u64>, u16> = HashMap::new();
|
||||
let mut by_shape: HashMap<*const VoxelShape, [u16; 6]> = HashMap::new();
|
||||
for (id, cell) in tables.cells.iter_mut().enumerate() {
|
||||
let state = &facts.states[id];
|
||||
// LightEngine.isEmptyShape: !canOcclude || !useShapeForLightOcclusion.
|
||||
if !state.can_occlude || !state.shape_occlusion {
|
||||
continue;
|
||||
}
|
||||
let Some(shape) = occlusion.cached_shape(BlockStateId(id as u32))? else { continue };
|
||||
if shape.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let faces = if let Some(faces) = by_shape.get(&std::ptr::from_ref(shape)) {
|
||||
*faces
|
||||
} else {
|
||||
let mut faces = [FULL; 6];
|
||||
// BlockState.initCache: solidRender shapes use the full faces.
|
||||
if shape.join_is_not_empty(&block, ShapeOp::XOR)? {
|
||||
for direction in Direction::ALL {
|
||||
let face = shape.face_shape(direction)?;
|
||||
faces[direction as usize] = if face.is_empty() {
|
||||
EMPTY
|
||||
} else if face.same_identity(&block) {
|
||||
FULL
|
||||
} else {
|
||||
let key: Vec<u64> = face
|
||||
.boxes()
|
||||
.iter()
|
||||
.flat_map(|b| b.min_position().components().into_iter().chain(b.max_position().components()))
|
||||
.map(f64::to_bits)
|
||||
.collect();
|
||||
*by_geometry.entry(key).or_insert_with(|| {
|
||||
shapes.push(face.clone());
|
||||
(shapes.len() - 1) as u16
|
||||
})
|
||||
};
|
||||
}
|
||||
}
|
||||
by_shape.insert(std::ptr::from_ref(shape), faces);
|
||||
faces
|
||||
};
|
||||
cell.faces = faces;
|
||||
cell.shaped = faces.iter().any(|f| *f != EMPTY);
|
||||
}
|
||||
let n = shapes.len();
|
||||
let mut occludes = vec![false; n * n];
|
||||
for a in 0..n {
|
||||
for b in 0..n {
|
||||
occludes[a * n + b] = if a == FULL as usize || b == FULL as usize {
|
||||
true
|
||||
} else if a == EMPTY as usize && b == EMPTY as usize {
|
||||
false
|
||||
} else {
|
||||
// Shapes.faceShapeOccludes: the union covers the whole face.
|
||||
let union = shapes[a].join_unoptimized(&shapes[b], ShapeOp::OR)?;
|
||||
!block.join_is_not_empty(&union, ShapeOp::ONLY_FIRST)?
|
||||
};
|
||||
}
|
||||
}
|
||||
tables.occludes = occludes;
|
||||
tables.faces = n;
|
||||
Ok(tables)
|
||||
}
|
||||
/// `LightEngine.shapeOccludes(from, to, direction)`.
|
||||
#[inline]
|
||||
fn blocked(&self, from: usize, to: usize, direction: usize) -> bool {
|
||||
let (a, b) = (&self.cells[from], &self.cells[to]);
|
||||
if !a.shaped && !b.shaped {
|
||||
return false;
|
||||
}
|
||||
let fa = a.faces[direction] as usize;
|
||||
let fb = b.faces[direction ^ 1] as usize;
|
||||
self.occludes[fa * self.faces + fb]
|
||||
}
|
||||
/// `ChunkSkyLightSources.isEdgeOccluded(top, bottom)`.
|
||||
#[inline]
|
||||
fn edge_occluded(&self, top: usize, bottom: usize) -> bool {
|
||||
self.cells[bottom].dampening != 0 || self.blocked(top, bottom, Direction::Down as usize)
|
||||
}
|
||||
pub fn emission(&self, state: u16) -> u8 {
|
||||
self.cells[state as usize].emission
|
||||
}
|
||||
pub fn dampening(&self, state: u16) -> u8 {
|
||||
self.cells[state as usize].dampening
|
||||
}
|
||||
/// Whether a state change can change light (`hasDifferentLightProperties`).
|
||||
pub fn differs(&self, old: u16, new: u16) -> bool {
|
||||
let (a, b) = (&self.cells[old as usize], &self.cells[new as usize]);
|
||||
old != new && (a.dampening != b.dampening || a.emission != b.emission || a.shaped || b.shaped)
|
||||
}
|
||||
}
|
||||
// Direction index order matches `Direction` (down, up, north, south, west, east);
|
||||
// `d ^ 1` is the opposite direction.
|
||||
const OFFSETS: [(i32, i32, i32); 6] = [(0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1), (-1, 0, 0), (1, 0, 0)];
|
||||
|
||||
/// `region[dz][dx]` holds the chunks around the centre (index 1,1).
|
||||
/// `sky` is false in dimensions without skylight (the Nether).
|
||||
pub fn light_chunk(region: &[[Option<&Chunk>; 3]; 3], tables: &LightTables, sky_light: bool) -> Vec<Arc<Section>> {
|
||||
@@ -48,9 +183,11 @@ pub fn light_chunk(region: &[[Option<&Chunk>; 3]; 3], tables: &LightTables, sky_
|
||||
}
|
||||
}
|
||||
}
|
||||
let h = (top_section * 16 + 1).min(HEIGHT as usize);
|
||||
// One extra section above the highest occupied one: block light rises
|
||||
// up to 14 blocks into it (sky light there is always 15).
|
||||
let h = ((top_section + 1) * 16).min(HEIGHT as usize);
|
||||
let at = |x: usize, y: usize, z: usize| (y * W + z) * W + x;
|
||||
let mut damp = vec![0u8; W * W * h];
|
||||
let mut states = vec![0u16; W * W * h];
|
||||
let mut sky = vec![0u8; W * W * h];
|
||||
let mut block = vec![0u8; W * W * h];
|
||||
let mut queue = VecDeque::new();
|
||||
@@ -63,20 +200,20 @@ pub fn light_chunk(region: &[[Option<&Chunk>; 3]; 3], tables: &LightTables, sky_
|
||||
continue;
|
||||
}
|
||||
for i in 0..4096 {
|
||||
let id = section.get(i) as usize;
|
||||
let cell = tables.cells[id];
|
||||
let id = section.get(i);
|
||||
let (lx, lz, ly) = (i & 15, (i >> 4) & 15, i >> 8);
|
||||
let p = at(dx * 16 + lx, si * 16 + ly, dz * 16 + lz);
|
||||
damp[p] = cell.dampening;
|
||||
if cell.emission > 0 {
|
||||
block[p] = cell.emission;
|
||||
states[p] = id;
|
||||
let emission = tables.cells[id as usize].emission;
|
||||
if emission > 0 {
|
||||
block[p] = emission;
|
||||
queue.push_back(p as u32);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Columns of missing neighbour chunks contribute no light.
|
||||
// Columns of missing neighbour chunks neither hold nor pass light.
|
||||
let present = |x: usize, z: usize| region[z / 16][x / 16].is_some();
|
||||
let mut lowest = vec![h as i32; W * W];
|
||||
for z in 0..W {
|
||||
@@ -84,13 +221,14 @@ pub fn light_chunk(region: &[[Option<&Chunk>; 3]; 3], tables: &LightTables, sky_
|
||||
if !present(x, z) || !sky_light {
|
||||
continue;
|
||||
}
|
||||
let mut y = h as i32 - 1;
|
||||
// The top layer (above the occupied range) is always open sky.
|
||||
while y >= 0 && damp[at(x, y as usize, z)] == 0 {
|
||||
sky[at(x, y as usize, z)] = 15;
|
||||
let mut y = h as i32 - 1;
|
||||
sky[at(x, y as usize, z)] = 15;
|
||||
while y > 0 && !tables.edge_occluded(states[at(x, y as usize, z)] as usize, states[at(x, y as usize - 1, z)] as usize) {
|
||||
y -= 1;
|
||||
sky[at(x, y as usize, z)] = 15;
|
||||
}
|
||||
lowest[z * W + x] = y + 1;
|
||||
lowest[z * W + x] = y;
|
||||
}
|
||||
}
|
||||
for z in 0..W {
|
||||
@@ -125,30 +263,23 @@ pub fn light_chunk(region: &[[Option<&Chunk>; 3]; 3], tables: &LightTables, sky_
|
||||
let x = p % W;
|
||||
let z = (p / W) % W;
|
||||
let y = p / (W * W);
|
||||
let mut visit = |q: usize| {
|
||||
let next = level.saturating_sub(damp[q].max(1));
|
||||
if next > light[q] {
|
||||
let from = states[p] as usize;
|
||||
for (d, (ox, oy, oz)) in OFFSETS.iter().enumerate() {
|
||||
let (nx, ny, nz) = (x as i32 + ox, y as i32 + oy, z as i32 + oz);
|
||||
if nx < 0 || nz < 0 || ny < 0 || nx >= W as i32 || nz >= W as i32 || ny >= h as i32 {
|
||||
continue;
|
||||
}
|
||||
let (nx, ny, nz) = (nx as usize, ny as usize, nz as usize);
|
||||
if !present(nx, nz) {
|
||||
continue;
|
||||
}
|
||||
let q = at(nx, ny, nz);
|
||||
let to = states[q] as usize;
|
||||
let next = level.saturating_sub(tables.cells[to].dampening.max(1));
|
||||
if next > light[q] && !tables.blocked(from, to, d) {
|
||||
light[q] = next;
|
||||
queue.push_back(q as u32);
|
||||
}
|
||||
};
|
||||
if x > 0 {
|
||||
visit(p - 1);
|
||||
}
|
||||
if x + 1 < W {
|
||||
visit(p + 1);
|
||||
}
|
||||
if z > 0 {
|
||||
visit(p - W);
|
||||
}
|
||||
if z + 1 < W {
|
||||
visit(p + W);
|
||||
}
|
||||
if y > 0 {
|
||||
visit(p - W * W);
|
||||
}
|
||||
if y + 1 < h {
|
||||
visit(p + W * W);
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -184,3 +315,282 @@ pub fn light_chunk(region: &[[Option<&Chunk>; 3]; 3], tables: &LightTables, sky_
|
||||
}
|
||||
sections
|
||||
}
|
||||
|
||||
|
||||
/// Resident chunks the incremental relighter reads and writes.
|
||||
pub trait LightWorld {
|
||||
fn state(&self, x: i32, y: i32, z: i32) -> Option<u16>;
|
||||
/// Packed light (sky << 4 | block), None outside loaded chunks.
|
||||
fn light(&self, x: i32, y: i32, z: i32) -> Option<u8>;
|
||||
fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8);
|
||||
}
|
||||
impl LightWorld for HashMap<(i32, i32), Arc<Chunk>> {
|
||||
fn state(&self, x: i32, y: i32, z: i32) -> Option<u16> {
|
||||
if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
|
||||
return None;
|
||||
}
|
||||
self.get(&(x >> 4, z >> 4)).filter(|c| c.lit).map(|c| c.get(x & 15, y, z & 15))
|
||||
}
|
||||
fn light(&self, x: i32, y: i32, z: i32) -> Option<u8> {
|
||||
if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
|
||||
return None;
|
||||
}
|
||||
self.get(&(x >> 4, z >> 4)).filter(|c| c.lit).map(|c| c.light(x & 15, y, z & 15))
|
||||
}
|
||||
fn set_light(&mut self, x: i32, y: i32, z: i32, packed: u8) {
|
||||
let Some(chunk) = self.get_mut(&(x >> 4, z >> 4)) else { return };
|
||||
let s = ((y - MIN_Y) >> 4) as usize;
|
||||
let i = index(x, y, z);
|
||||
if chunk.sections[s].light(i) == packed {
|
||||
return;
|
||||
}
|
||||
let section = Arc::make_mut(&mut Arc::make_mut(chunk).sections[s]);
|
||||
if let Light::Uniform(v) = section.light {
|
||||
section.light = Light::Full(Box::new([v; 4096]));
|
||||
}
|
||||
if let Light::Full(a) = &mut section.light {
|
||||
a[i] = packed;
|
||||
}
|
||||
}
|
||||
}
|
||||
type Pos = (i32, i32, i32);
|
||||
fn level(world: &impl LightWorld, sky: bool, p: Pos) -> Option<u8> {
|
||||
world.light(p.0, p.1, p.2).map(|v| if sky { v >> 4 } else { v & 15 })
|
||||
}
|
||||
fn set_level(world: &mut impl LightWorld, sky: bool, p: Pos, value: u8) {
|
||||
let Some(old) = world.light(p.0, p.1, p.2) else { return };
|
||||
let packed = if sky { (old & 0x0F) | value << 4 } else { (old & 0xF0) | value };
|
||||
world.set_light(p.0, p.1, p.2, packed);
|
||||
}
|
||||
/// `ChunkSkyLightSources`: the Y of the upper block of the highest occluded
|
||||
/// edge in the column (every block at or above it is a sky source).
|
||||
pub fn lowest_sky_source(world: &impl LightWorld, tables: &LightTables, x: i32, z: i32) -> i32 {
|
||||
let mut y = MIN_Y + HEIGHT - 1;
|
||||
let Some(mut top) = world.state(x, y, z) else { return MIN_Y };
|
||||
while y > MIN_Y {
|
||||
let Some(bottom) = world.state(x, y - 1, z) else { break };
|
||||
if tables.edge_occluded(top as usize, bottom as usize) {
|
||||
return y;
|
||||
}
|
||||
top = bottom;
|
||||
y -= 1;
|
||||
}
|
||||
MIN_Y
|
||||
}
|
||||
/// Vanilla's `checkBlock` + `runLightUpdates` for changed positions on
|
||||
/// resident, lit chunks: clear the light that may have come through or from
|
||||
/// the old states (decrease pass), then re-seed sources and propagate back in
|
||||
/// from the brighter boundary (increase pass). Returns every position whose
|
||||
/// stored light changed, for remeshing. `force` clears around each position
|
||||
/// as if it had been fully lit, for light computed from outdated blocks.
|
||||
pub fn relight(world: &mut impl LightWorld, tables: &LightTables, sky_light: bool, positions: &[Pos], force: bool) -> Vec<Pos> {
|
||||
let mut changed = Vec::new();
|
||||
relight_layer(world, tables, false, positions.to_vec(), force, &mut changed);
|
||||
if sky_light {
|
||||
let mut seeds = positions.to_vec();
|
||||
let mut columns: HashMap<(i32, i32), i32> = HashMap::new();
|
||||
for &(x, _, z) in positions {
|
||||
if columns.contains_key(&(x, z)) {
|
||||
continue;
|
||||
}
|
||||
let source = lowest_sky_source(world, tables, x, z);
|
||||
columns.insert((x, z), source);
|
||||
// Cells whose source status changed: non-15 at or above the new
|
||||
// lowest source, and old 15s (sources) below it.
|
||||
for y in source..MIN_Y + HEIGHT {
|
||||
if level(world, true, (x, y, z)).is_some_and(|l| l != 15) {
|
||||
seeds.push((x, y, z));
|
||||
}
|
||||
}
|
||||
let mut y = source - 1;
|
||||
while y >= MIN_Y && level(world, true, (x, y, z)) == Some(15) {
|
||||
seeds.push((x, y, z));
|
||||
y -= 1;
|
||||
}
|
||||
}
|
||||
relight_layer(world, tables, true, seeds, force, &mut changed);
|
||||
}
|
||||
changed.sort_unstable();
|
||||
changed.dedup();
|
||||
changed
|
||||
}
|
||||
fn relight_layer(world: &mut impl LightWorld, tables: &LightTables, sky: bool, seeds: Vec<Pos>, force: bool, changed: &mut Vec<Pos>) {
|
||||
let mut decrease: VecDeque<(Pos, u8)> = VecDeque::new();
|
||||
let mut cleared: Vec<Pos> = Vec::new();
|
||||
let mut increase: VecDeque<Pos> = VecDeque::new();
|
||||
for p in seeds {
|
||||
let Some(old) = level(world, sky, p) else { continue };
|
||||
if old > 0 {
|
||||
set_level(world, sky, p, 0);
|
||||
changed.push(p);
|
||||
}
|
||||
cleared.push(p);
|
||||
decrease.push_back((p, if force { 15 } else { old }));
|
||||
}
|
||||
while let Some((p, from)) = decrease.pop_front() {
|
||||
for (ox, oy, oz) in OFFSETS {
|
||||
let q = (p.0 + ox, p.1 + oy, p.2 + oz);
|
||||
let Some(l) = level(world, sky, q) else { continue };
|
||||
if l == 0 {
|
||||
continue;
|
||||
}
|
||||
// Sky light runs straight down without loss, so a 15 below a
|
||||
// cleared 15 may have come from it too.
|
||||
if l < from || (sky && oy == -1 && l == 15 && from == 15) {
|
||||
set_level(world, sky, q, 0);
|
||||
changed.push(q);
|
||||
cleared.push(q);
|
||||
decrease.push_back((q, l));
|
||||
} else {
|
||||
increase.push_back(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Sources inside the cleared area light up again.
|
||||
let mut sources: HashMap<(i32, i32), i32> = HashMap::new();
|
||||
for p in cleared {
|
||||
let seed = if sky {
|
||||
let lowest = *sources.entry((p.0, p.2)).or_insert_with(|| lowest_sky_source(world, tables, p.0, p.2));
|
||||
if p.1 >= lowest { 15 } else { 0 }
|
||||
} else {
|
||||
world.state(p.0, p.1, p.2).map_or(0, |s| tables.cells[s as usize].emission)
|
||||
};
|
||||
if seed > level(world, sky, p).unwrap_or(15) {
|
||||
set_level(world, sky, p, seed);
|
||||
changed.push(p);
|
||||
increase.push_back(p);
|
||||
}
|
||||
}
|
||||
while let Some(p) = increase.pop_front() {
|
||||
let Some(l) = level(world, sky, p) else { continue };
|
||||
if l <= 1 {
|
||||
continue;
|
||||
}
|
||||
let Some(from) = world.state(p.0, p.1, p.2) else { continue };
|
||||
for (d, (ox, oy, oz)) in OFFSETS.iter().enumerate() {
|
||||
let q = (p.0 + ox, p.1 + oy, p.2 + oz);
|
||||
let Some(to) = world.state(q.0, q.1, q.2) else { continue };
|
||||
let Some(ql) = level(world, sky, q) else { continue };
|
||||
let next = l.saturating_sub(tables.cells[to as usize].dampening.max(1));
|
||||
if next > ql && !tables.blocked(from as usize, to as usize, d) {
|
||||
set_level(world, sky, q, next);
|
||||
changed.push(q);
|
||||
increase.push_back(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
const AIR: u16 = 0;
|
||||
const STONE: u16 = 1;
|
||||
const TORCH: u16 = 2;
|
||||
const SLAB: u16 = 3;
|
||||
/// Air, stone, torch and a bottom slab (full bottom face, half sides,
|
||||
/// empty top), with a third face shape for the half sides.
|
||||
fn tables() -> LightTables {
|
||||
let cell = |dampening, emission, faces: [u16; 6]| Cell {
|
||||
dampening,
|
||||
emission,
|
||||
shaped: faces.iter().any(|f| *f != EMPTY),
|
||||
faces,
|
||||
};
|
||||
LightTables {
|
||||
cells: vec![
|
||||
cell(0, 0, [EMPTY; 6]),
|
||||
cell(15, 0, [FULL; 6]),
|
||||
cell(0, 14, [EMPTY; 6]),
|
||||
cell(0, 0, [FULL, EMPTY, 2, 2, 2, 2]),
|
||||
],
|
||||
// empty, full, half: only pairs with a full face cover the square.
|
||||
occludes: vec![false, true, false, true, true, true, false, true, false],
|
||||
faces: 3,
|
||||
}
|
||||
}
|
||||
fn world(edit: impl Fn(&mut Chunk)) -> HashMap<(i32, i32), Arc<Chunk>> {
|
||||
let mut chunks = HashMap::new();
|
||||
for z in -1..=1 {
|
||||
for x in -1..=1 {
|
||||
let mut c = Chunk::empty(x, z);
|
||||
for y in MIN_Y..0 {
|
||||
for i in 0..256 {
|
||||
c.set(i & 15, y, i >> 4, STONE);
|
||||
}
|
||||
}
|
||||
if (x, z) == (0, 0) {
|
||||
edit(&mut c);
|
||||
}
|
||||
chunks.insert((x, z), c);
|
||||
}
|
||||
}
|
||||
let lit: Vec<_> = chunks
|
||||
.keys()
|
||||
.map(|&(x, z)| {
|
||||
let region: [[Option<&Chunk>; 3]; 3] =
|
||||
std::array::from_fn(|dz| std::array::from_fn(|dx| chunks.get(&(x + dx as i32 - 1, z + dz as i32 - 1))));
|
||||
let mut c = chunks[&(x, z)].clone();
|
||||
c.sections = light_chunk(®ion, &tables(), true);
|
||||
c.lit = true;
|
||||
((x, z), Arc::new(c))
|
||||
})
|
||||
.collect();
|
||||
lit.into_iter().collect()
|
||||
}
|
||||
fn sky(world: &HashMap<(i32, i32), Arc<Chunk>>, x: i32, y: i32, z: i32) -> u8 {
|
||||
world.light(x, y, z).unwrap() >> 4
|
||||
}
|
||||
fn block(world: &HashMap<(i32, i32), Arc<Chunk>>, x: i32, y: i32, z: i32) -> u8 {
|
||||
world.light(x, y, z).unwrap() & 15
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn torch_light_falls_off_by_one_per_block() {
|
||||
let w = world(|c| {
|
||||
c.set(8, 0, 8, TORCH);
|
||||
});
|
||||
assert_eq!(block(&w, 8, 0, 8), 14);
|
||||
assert_eq!(block(&w, 9, 0, 8), 13);
|
||||
assert_eq!(block(&w, 8, 3, 8), 11);
|
||||
assert_eq!(block(&w, 8, -1, 8), 0);
|
||||
}
|
||||
#[test]
|
||||
fn bottom_slab_takes_sky_from_above_but_not_through_its_bottom() {
|
||||
// A slab roof over a closed stone room at y 0..2.
|
||||
let w = world(|c| {
|
||||
for x in 4..13 {
|
||||
for z in 4..13 {
|
||||
c.set(x, 3, z, SLAB);
|
||||
for y in 0..3 {
|
||||
let wall = x == 4 || x == 12 || z == 4 || z == 12;
|
||||
c.set(x, y, z, if wall { STONE } else { AIR });
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
assert_eq!(sky(&w, 8, 3, 8), 15, "slab cell is lit through its open top");
|
||||
// Without the shape test the room would be lit (slabs have no dampening).
|
||||
assert_eq!(sky(&w, 8, 2, 8), 0, "the full bottom face stops sky light");
|
||||
}
|
||||
#[test]
|
||||
fn incremental_relight_matches_full_relight() {
|
||||
let mut w = world(|c| {
|
||||
c.set(8, 0, 8, TORCH);
|
||||
});
|
||||
let edits = [((8, 0, 8), AIR), ((9, 1, 8), STONE), ((3, 2, 3), TORCH), ((8, 5, 8), SLAB), ((8, -1, 8), AIR)];
|
||||
for ((x, y, z), state) in edits {
|
||||
Arc::make_mut(w.get_mut(&(0, 0)).unwrap()).set(x, y, z, state);
|
||||
relight(&mut w, &tables(), true, &[(x, y, z)], false);
|
||||
}
|
||||
let region: [[Option<&Chunk>; 3]; 3] =
|
||||
std::array::from_fn(|dz| std::array::from_fn(|dx| w.get(&(dx as i32 - 1, dz as i32 - 1)).map(|c| &**c)));
|
||||
let full = light_chunk(®ion, &tables(), true);
|
||||
for (si, s) in full.iter().enumerate() {
|
||||
for i in 0..4096 {
|
||||
assert_eq!(s.light(i), w[&(0, 0)].sections[si].light(i), "section {si} index {i}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+1120
-225
File diff suppressed because it is too large
Load Diff
@@ -109,6 +109,13 @@ pub struct Streaming {
|
||||
/// Dimension flags: sky light, Nether face shading.
|
||||
pub sky_light: bool,
|
||||
pub nether_shading: bool,
|
||||
/// Incremental relighting of block edits on lit chunks (see `light::relight`).
|
||||
light_tables: Arc<LightTables>,
|
||||
/// Applied edits by sequence, replayed onto light jobs snapshotted before them.
|
||||
light_log: Vec<(u64, (i32, i32, i32))>,
|
||||
light_edit_sequence: u64,
|
||||
/// Edit sequence at each in-flight light job's snapshot.
|
||||
light_snapshots: HashMap<(i32, i32), u64>,
|
||||
pub generated_total: u64,
|
||||
pub meshed_total: u64,
|
||||
}
|
||||
@@ -126,6 +133,7 @@ impl Streaming {
|
||||
stop: AtomicBool::new(false),
|
||||
});
|
||||
let (send, results) = mpsc::channel();
|
||||
let light_tables = context.light.clone();
|
||||
let threads = (0..threads.max(1))
|
||||
.map(|i| {
|
||||
let shared = shared.clone();
|
||||
@@ -203,6 +211,10 @@ impl Streaming {
|
||||
paused: false,
|
||||
sky_light: true,
|
||||
nether_shading: false,
|
||||
light_tables,
|
||||
light_log: Vec::new(),
|
||||
light_edit_sequence: 0,
|
||||
light_snapshots: HashMap::new(),
|
||||
generated_total: 0,
|
||||
meshed_total: 0,
|
||||
}
|
||||
@@ -242,6 +254,7 @@ impl Streaming {
|
||||
if self.paused {
|
||||
return (uploads, Vec::new());
|
||||
}
|
||||
self.relight_edits(world);
|
||||
while let Ok(done) = self.results.try_recv() {
|
||||
match done {
|
||||
Done::Proto(x, z, proto) => {
|
||||
@@ -264,6 +277,10 @@ impl Streaming {
|
||||
Done::Generated(mut chunk) => {
|
||||
let key = (chunk.x, chunk.z);
|
||||
world.block_entities.extend(std::mem::take(&mut chunk.block_entities));
|
||||
let entities = std::mem::take(&mut chunk.entities);
|
||||
if !entities.is_empty() {
|
||||
world.loaded_entities.push(((chunk.x, chunk.z), entities));
|
||||
}
|
||||
self.generating.remove(&key);
|
||||
self.finishing.remove(&key);
|
||||
self.decorated.insert(key);
|
||||
@@ -282,6 +299,7 @@ impl Streaming {
|
||||
continue;
|
||||
}
|
||||
self.lighting.remove(&(x, z));
|
||||
let snapshot = self.light_snapshots.remove(&(x, z)).unwrap_or(u64::MAX);
|
||||
if let Some(chunk) = world.chunks.get_mut(&(x, z)) {
|
||||
let chunk = Arc::make_mut(chunk);
|
||||
// Keep blocks edited since the snapshot; take only light.
|
||||
@@ -292,6 +310,7 @@ impl Streaming {
|
||||
}
|
||||
chunk.lit = true;
|
||||
self.lit.insert((x, z));
|
||||
self.replay_light_edits(world, x, z, snapshot);
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
for sy in 0..SECTIONS as i32 {
|
||||
@@ -426,6 +445,7 @@ impl Streaming {
|
||||
world.dirty_light.remove(&(x, z));
|
||||
self.sequence += 1;
|
||||
self.lighting.insert((x, z), self.sequence);
|
||||
self.light_snapshots.insert((x, z), self.light_edit_sequence);
|
||||
self.submit(self.distance(x, z) * 4 + 1, Job::Light(x, z, region, self.sequence, self.sky_light));
|
||||
}
|
||||
// Meshing once the column and its neighbours are lit.
|
||||
@@ -455,6 +475,68 @@ impl Streaming {
|
||||
}
|
||||
(uploads, removed)
|
||||
}
|
||||
/// Relight block edits on lit chunks in place (vanilla's incremental light
|
||||
/// engine) instead of recomputing the 3x3 chunks around each edit.
|
||||
fn relight_edits(&mut self, world: &mut World) {
|
||||
if world.light_edits.is_empty() {
|
||||
return;
|
||||
}
|
||||
let edits = std::mem::take(&mut world.light_edits);
|
||||
let positions: Vec<(i32, i32, i32)> = edits
|
||||
.iter()
|
||||
.filter(|(_, old, new)| self.light_tables.differs(*old, *new))
|
||||
.map(|(p, _, _)| *p)
|
||||
.collect();
|
||||
if positions.is_empty() {
|
||||
return;
|
||||
}
|
||||
let changed = crate::light::relight(&mut world.chunks, &self.light_tables, self.sky_light, &positions, false);
|
||||
Self::mark_light_changes(world, &changed);
|
||||
if !self.light_snapshots.is_empty() {
|
||||
for p in positions {
|
||||
self.light_edit_sequence += 1;
|
||||
self.light_log.push((self.light_edit_sequence, p));
|
||||
}
|
||||
}
|
||||
}
|
||||
/// A light job computed from blocks older than some edits: redo those
|
||||
/// edits on top of its result.
|
||||
fn replay_light_edits(&mut self, world: &mut World, x: i32, z: i32, snapshot: u64) {
|
||||
let positions: Vec<(i32, i32, i32)> = self
|
||||
.light_log
|
||||
.iter()
|
||||
.filter(|(seq, p)| *seq > snapshot && ((p.0 >> 4) - x).abs() <= 1 && ((p.2 >> 4) - z).abs() <= 1)
|
||||
.map(|(_, p)| *p)
|
||||
.collect();
|
||||
if !positions.is_empty() {
|
||||
let changed = crate::light::relight(&mut world.chunks, &self.light_tables, self.sky_light, &positions, true);
|
||||
Self::mark_light_changes(world, &changed);
|
||||
}
|
||||
let oldest = self.light_snapshots.values().copied().min();
|
||||
match oldest {
|
||||
Some(oldest) => self.light_log.retain(|(seq, _)| *seq > oldest),
|
||||
None => self.light_log.clear(),
|
||||
}
|
||||
}
|
||||
/// Sections whose meshes sample a changed light value (faces and corners
|
||||
/// read light from neighbouring blocks).
|
||||
fn mark_light_changes(world: &mut World, changed: &[(i32, i32, i32)]) {
|
||||
let mut last = None;
|
||||
for &(x, y, z) in changed {
|
||||
for dz in -1..=1 {
|
||||
for dy in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
let s = ((y + dy - crate::chunk::MIN_Y) >> 4, (x + dx) >> 4, (z + dz) >> 4);
|
||||
if last == Some(s) || !(0..SECTIONS as i32).contains(&s.0) {
|
||||
continue;
|
||||
}
|
||||
last = Some(s);
|
||||
world.dirty_sections.insert((s.1, s.0, s.2));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
|
||||
let r = i64::from(self.radius + margin);
|
||||
self.distance(x, z) <= r * r
|
||||
|
||||
@@ -18,6 +18,11 @@ pub struct World {
|
||||
pub dirty_sections: HashSet<(i32, i32, i32)>,
|
||||
/// Chunks whose light must be recomputed.
|
||||
pub dirty_light: HashSet<(i32, i32)>,
|
||||
/// Edits on lit chunks (position, old state, new state), relit
|
||||
/// incrementally by streaming.
|
||||
pub light_edits: Vec<((i32, i32, i32), u16, u16)>,
|
||||
/// Saved entities of chunks that just loaded, spawned by the game.
|
||||
pub loaded_entities: Vec<((i32, i32), Vec<horizon_world::nbt::Tag>)>,
|
||||
/// Chunks changed since the last save.
|
||||
pub modified: HashSet<(i32, i32)>,
|
||||
pub block_entities: HashMap<(i32, i32, i32), crate::containers::BlockEntity>,
|
||||
@@ -90,6 +95,8 @@ impl World {
|
||||
air,
|
||||
dirty_sections: HashSet::new(),
|
||||
dirty_light: HashSet::new(),
|
||||
light_edits: Vec::new(),
|
||||
loaded_entities: Vec::new(),
|
||||
modified: HashSet::new(),
|
||||
block_entities: HashMap::new(),
|
||||
game_time: 0,
|
||||
@@ -125,9 +132,13 @@ impl World {
|
||||
}
|
||||
}
|
||||
let _ = sy;
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
self.dirty_light.insert(((x >> 4) + dx, (z >> 4) + dz));
|
||||
if self.chunks.get(&(x >> 4, z >> 4)).is_some_and(|c| c.lit) {
|
||||
self.light_edits.push(((x, y, z), previous, state.0 as u16));
|
||||
} else {
|
||||
for dz in -1..=1 {
|
||||
for dx in -1..=1 {
|
||||
self.dirty_light.insert(((x >> 4) + dx, (z >> 4) + dz));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,146 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Dump Minecraft NBT files (level.dat, data/*.dat, players/*.dat) and Anvil
|
||||
region chunks (region/, entities/, poi/) as readable SNBT-like text.
|
||||
|
||||
anvil_dump.py FILE.dat [PATH...]
|
||||
anvil_dump.py r.0.0.mca [CX CZ] [PATH...]
|
||||
|
||||
PATH selects nested keys (for example `sections 3 block_states`). Long
|
||||
arrays are summarised unless --full is given; --typed suffixes numbers
|
||||
with their NBT type (b, s, l, f, d; plain ints are TAG_Int). Used to compare Horizon saves
|
||||
with worlds written by the vanilla server.
|
||||
"""
|
||||
import gzip
|
||||
import io
|
||||
import json
|
||||
import struct
|
||||
import sys
|
||||
import zlib
|
||||
|
||||
|
||||
def read_tag(f, tag_id):
|
||||
if tag_id == 1:
|
||||
return ('b', struct.unpack('>b', f.read(1))[0])
|
||||
if tag_id == 2:
|
||||
return ('s', struct.unpack('>h', f.read(2))[0])
|
||||
if tag_id == 3:
|
||||
return struct.unpack('>i', f.read(4))[0]
|
||||
if tag_id == 4:
|
||||
return ('l', struct.unpack('>q', f.read(8))[0])
|
||||
if tag_id == 5:
|
||||
return ('f', struct.unpack('>f', f.read(4))[0])
|
||||
if tag_id == 6:
|
||||
return ('d', struct.unpack('>d', f.read(8))[0])
|
||||
if tag_id == 7:
|
||||
n = struct.unpack('>i', f.read(4))[0]
|
||||
return ('B', list(struct.unpack(f'>{n}b', f.read(n))))
|
||||
if tag_id == 8:
|
||||
n = struct.unpack('>H', f.read(2))[0]
|
||||
return f.read(n).decode('utf-8', 'replace')
|
||||
if tag_id == 9:
|
||||
inner, n = struct.unpack('>bi', f.read(5))
|
||||
return [read_tag(f, inner) for _ in range(max(n, 0))]
|
||||
if tag_id == 10:
|
||||
out = {}
|
||||
while True:
|
||||
t = f.read(1)[0]
|
||||
if t == 0:
|
||||
return out
|
||||
n = struct.unpack('>H', f.read(2))[0]
|
||||
name = f.read(n).decode('utf-8', 'replace')
|
||||
out[name] = read_tag(f, t)
|
||||
if tag_id == 11:
|
||||
n = struct.unpack('>i', f.read(4))[0]
|
||||
return ('I', list(struct.unpack(f'>{n}i', f.read(4 * n))))
|
||||
if tag_id == 12:
|
||||
n = struct.unpack('>i', f.read(4))[0]
|
||||
return ('L', list(struct.unpack(f'>{n}q', f.read(8 * n))))
|
||||
raise ValueError(f'bad tag id {tag_id}')
|
||||
|
||||
|
||||
def read_named(data):
|
||||
f = io.BytesIO(data)
|
||||
t = f.read(1)[0]
|
||||
n = struct.unpack('>H', f.read(2))[0]
|
||||
f.read(n)
|
||||
return read_tag(f, t)
|
||||
|
||||
|
||||
def read_dat(path):
|
||||
raw = open(path, 'rb').read()
|
||||
if raw[:2] == b'\x1f\x8b':
|
||||
raw = gzip.decompress(raw)
|
||||
return read_named(raw)
|
||||
|
||||
|
||||
def region_chunks(path):
|
||||
data = open(path, 'rb').read()
|
||||
out = {}
|
||||
for i in range(1024):
|
||||
off = int.from_bytes(data[i * 4:i * 4 + 3], 'big')
|
||||
if off == 0:
|
||||
continue
|
||||
start = off * 4096
|
||||
length = struct.unpack('>i', data[start:start + 4])[0]
|
||||
codec = data[start + 4] & 0x7F
|
||||
payload = data[start + 5:start + 4 + length]
|
||||
if codec == 1:
|
||||
payload = gzip.decompress(payload)
|
||||
elif codec == 2:
|
||||
payload = zlib.decompress(payload)
|
||||
out[(i & 31, i >> 5)] = read_named(payload)
|
||||
return out
|
||||
|
||||
|
||||
def plain(v, full, typed=False):
|
||||
if isinstance(v, tuple):
|
||||
kind, val = v
|
||||
if kind in 'bsldf':
|
||||
return f'{val}{kind}' if typed else val
|
||||
if not full and len(val) > 8:
|
||||
return f'{kind}[{len(val)}: {val[:4]}...]'
|
||||
return val
|
||||
if isinstance(v, dict):
|
||||
return {k: plain(x, full, typed) for k, x in v.items()}
|
||||
if isinstance(v, list):
|
||||
return [plain(x, full, typed) for x in v]
|
||||
return v
|
||||
|
||||
|
||||
def select(v, path):
|
||||
for p in path:
|
||||
if isinstance(v, list):
|
||||
v = v[int(p)]
|
||||
elif isinstance(v, tuple):
|
||||
v = v[1][int(p)]
|
||||
else:
|
||||
v = v[p]
|
||||
return v
|
||||
|
||||
|
||||
def main(argv):
|
||||
full = '--full' in argv
|
||||
typed = '--typed' in argv
|
||||
argv = [a for a in argv if a not in ('--full', '--typed')]
|
||||
if not argv:
|
||||
print(__doc__)
|
||||
return 1
|
||||
path = argv[0]
|
||||
rest = argv[1:]
|
||||
if path.endswith('.mca'):
|
||||
chunks = region_chunks(path)
|
||||
if len(rest) >= 2 and rest[0].lstrip('-').isdigit():
|
||||
cx, cz = int(rest[0]) & 31, int(rest[1]) & 31
|
||||
value = chunks[(cx, cz)]
|
||||
rest = rest[2:]
|
||||
else:
|
||||
print(json.dumps(sorted(chunks)))
|
||||
return 0
|
||||
else:
|
||||
value = read_dat(path)
|
||||
print(json.dumps(plain(select(value, rest), full, typed), indent=1))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
@@ -0,0 +1,160 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Join an offline-mode vanilla 26.3 server as a bare protocol client, stay
|
||||
connected for a while (answering keep-alives) and leave.
|
||||
|
||||
vanilla_login.py [--host H] [--port P] [--seconds S] NAME
|
||||
vanilla_login.py --uuid NAME print the offline UUID the server uses
|
||||
|
||||
The server loads and saves the player's file (players/data/<uuid>.dat), so
|
||||
this checks that player data written by Horizon is accepted by vanilla:
|
||||
its log reports the position it read, and console commands such as
|
||||
`data get entity NAME` can inspect the loaded player meanwhile.
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import socket
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
import zlib
|
||||
|
||||
PROTOCOL = 777 # 26.3
|
||||
|
||||
|
||||
def offline_uuid(name):
|
||||
digest = bytearray(hashlib.md5(('OfflinePlayer:' + name).encode()).digest())
|
||||
digest[6] = (digest[6] & 0x0F) | 0x30
|
||||
digest[8] = (digest[8] & 0x3F) | 0x80
|
||||
return uuid.UUID(bytes=bytes(digest))
|
||||
|
||||
|
||||
def varint(v):
|
||||
out = b''
|
||||
v &= 0xFFFFFFFF
|
||||
while True:
|
||||
b = v & 0x7F
|
||||
v >>= 7
|
||||
out += bytes([b | (0x80 if v else 0)])
|
||||
if not v:
|
||||
return out
|
||||
|
||||
|
||||
def string(s):
|
||||
data = s.encode()
|
||||
return varint(len(data)) + data
|
||||
|
||||
|
||||
class Connection:
|
||||
def __init__(self, host, port):
|
||||
self.sock = socket.create_connection((host, port), timeout=30)
|
||||
self.threshold = -1
|
||||
self.buffer = b''
|
||||
|
||||
def read_exact(self, n):
|
||||
while len(self.buffer) < n:
|
||||
chunk = self.sock.recv(65536)
|
||||
if not chunk:
|
||||
raise EOFError('server closed the connection')
|
||||
self.buffer += chunk
|
||||
out, self.buffer = self.buffer[:n], self.buffer[n:]
|
||||
return out
|
||||
|
||||
def read_varint(self):
|
||||
value = shift = 0
|
||||
while True:
|
||||
b = self.read_exact(1)[0]
|
||||
value |= (b & 0x7F) << shift
|
||||
shift += 7
|
||||
if not b & 0x80:
|
||||
return value
|
||||
|
||||
def send(self, packet_id, payload=b''):
|
||||
body = varint(packet_id) + payload
|
||||
if self.threshold >= 0:
|
||||
if len(body) >= self.threshold:
|
||||
body = varint(len(body)) + zlib.compress(body)
|
||||
else:
|
||||
body = varint(0) + body
|
||||
self.sock.sendall(varint(len(body)) + body)
|
||||
|
||||
def receive(self):
|
||||
length = self.read_varint()
|
||||
body = self.read_exact(length)
|
||||
if self.threshold >= 0:
|
||||
pos, size = parse_varint(body, 0)
|
||||
body = zlib.decompress(body[pos:]) if size else body[pos:]
|
||||
pos, packet_id = parse_varint(body, 0)
|
||||
return packet_id, body[pos:]
|
||||
|
||||
|
||||
def parse_varint(data, pos):
|
||||
value = shift = 0
|
||||
while True:
|
||||
b = data[pos]
|
||||
pos += 1
|
||||
value |= (b & 0x7F) << shift
|
||||
shift += 7
|
||||
if not b & 0x80:
|
||||
return pos, value
|
||||
|
||||
|
||||
def join(host, port, name, seconds):
|
||||
c = Connection(host, port)
|
||||
c.send(0, varint(PROTOCOL) + string(host) + struct.pack('>H', port) + varint(2))
|
||||
c.send(0, string(name) + offline_uuid(name).bytes)
|
||||
# Login: compression, then login finished.
|
||||
while True:
|
||||
pid, data = c.receive()
|
||||
if pid == 3:
|
||||
c.threshold = parse_varint(data, 0)[1]
|
||||
elif pid == 2:
|
||||
break
|
||||
elif pid == 0:
|
||||
raise RuntimeError(f'login refused: {data!r}')
|
||||
c.send(3) # login acknowledged -> configuration
|
||||
while True:
|
||||
pid, data = c.receive()
|
||||
if pid == 15: # select known packs: claim none, receive full registries
|
||||
c.send(7, varint(0))
|
||||
elif pid == 4: # keep alive
|
||||
c.send(4, data)
|
||||
elif pid == 5: # ping
|
||||
c.send(5, data)
|
||||
elif pid == 3: # finish configuration
|
||||
c.send(3)
|
||||
break
|
||||
elif pid == 2:
|
||||
raise RuntimeError(f'disconnected during configuration: {data!r}')
|
||||
deadline = time.time() + seconds
|
||||
c.sock.settimeout(1.0)
|
||||
while time.time() < deadline:
|
||||
try:
|
||||
c.receive()
|
||||
except socket.timeout:
|
||||
continue
|
||||
except EOFError:
|
||||
break # the server stopped
|
||||
# Play packets are not decoded: the server's first keep-alive comes
|
||||
# after 15 seconds and it waits 15 more for the answer, so a session
|
||||
# under 30 seconds needs none.
|
||||
c.sock.close()
|
||||
|
||||
|
||||
def main():
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument('name')
|
||||
p.add_argument('--host', default='127.0.0.1')
|
||||
p.add_argument('--port', type=int, default=25565)
|
||||
p.add_argument('--seconds', type=float, default=5, help='at most 25')
|
||||
p.add_argument('--uuid', action='store_true')
|
||||
args = p.parse_args()
|
||||
if args.uuid:
|
||||
print(offline_uuid(args.name))
|
||||
return 0
|
||||
join(args.host, args.port, args.name, args.seconds)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,113 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run the vanilla 26.3 dedicated server headless on a world folder, optionally
|
||||
send console commands (`sleep SECONDS` pauses between them; `login NAME
|
||||
SECONDS` joins with tools/vanilla_login.py in the background), then stop it
|
||||
cleanly and report problems from its log.
|
||||
|
||||
vanilla_world_check.py --jar server.jar --dir RUN_DIR [--world NAME]
|
||||
[--seed N] [--port P] [--command CMD ...]
|
||||
[--wait-after SECONDS]
|
||||
|
||||
RUN_DIR receives eula.txt, server.properties and logs/. An existing
|
||||
RUN_DIR/NAME world is opened as is (this is how Horizon saves are checked); a
|
||||
missing one is generated by vanilla (this is how reference worlds are made).
|
||||
Exit status 1 when the log contains errors, upgrade/datafix work or chunk
|
||||
load failures.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
SUSPICIOUS = re.compile(
|
||||
r'(ERROR|login failed|Exception|Couldn\'t load|Failed to|Skipping|Invalid|Unknown|corrupt|'
|
||||
r'Recreating|upgrad|DataFix|out of bounds|missing|Mismatch)', re.IGNORECASE)
|
||||
# Benign lines the server prints on every start.
|
||||
BENIGN = re.compile(r'(Unpacking |OFFLINE/INSECURE|online-mode|authenticate usernames|hackers|'
|
||||
r'Failed to load properties|Failed to load eula)')
|
||||
|
||||
|
||||
def main():
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument('--jar', required=True)
|
||||
p.add_argument('--dir', required=True)
|
||||
p.add_argument('--world', default='world')
|
||||
p.add_argument('--seed', default='12345')
|
||||
p.add_argument('--port', default='25671')
|
||||
p.add_argument('--command', action='append', default=[])
|
||||
p.add_argument('--wait-after', type=float, default=1.0)
|
||||
p.add_argument('--timeout', type=float, default=240)
|
||||
args = p.parse_args()
|
||||
os.makedirs(args.dir, exist_ok=True)
|
||||
with open(os.path.join(args.dir, 'eula.txt'), 'w') as f:
|
||||
f.write('eula=true\n')
|
||||
props = {
|
||||
'server-port': args.port, 'online-mode': 'false', 'level-seed': args.seed,
|
||||
'level-name': args.world, 'spawn-protection': '0', 'view-distance': '4',
|
||||
'simulation-distance': '4', 'sync-chunk-writes': 'true', 'enable-query': 'false',
|
||||
'enable-rcon': 'false', 'management-server-enabled': 'false',
|
||||
'pause-when-empty-seconds': '-1', 'white-list': 'false', 'enforce-whitelist': 'false',
|
||||
}
|
||||
with open(os.path.join(args.dir, 'server.properties'), 'w') as f:
|
||||
f.writelines(f'{k}={v}\n' for k, v in props.items())
|
||||
proc = subprocess.Popen(
|
||||
['java', '-Xmx2G', '-jar', os.path.abspath(args.jar), '--nogui'], cwd=args.dir,
|
||||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
|
||||
lines = []
|
||||
done = threading.Event()
|
||||
|
||||
def pump():
|
||||
for line in proc.stdout:
|
||||
lines.append(line.rstrip('\n'))
|
||||
if 'Done (' in line:
|
||||
done.set()
|
||||
done.set()
|
||||
|
||||
threading.Thread(target=pump, daemon=True).start()
|
||||
if not done.wait(args.timeout) or proc.poll() is not None:
|
||||
proc.kill()
|
||||
print('\n'.join(lines))
|
||||
print('server did not start', file=sys.stderr)
|
||||
return 1
|
||||
for command in args.command:
|
||||
if command.startswith('sleep '):
|
||||
time.sleep(float(command.split()[1]))
|
||||
continue
|
||||
if command.startswith('login '):
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import vanilla_login
|
||||
_, name, seconds = command.split()
|
||||
|
||||
def run(name=name, seconds=float(seconds)):
|
||||
try:
|
||||
vanilla_login.join('127.0.0.1', int(args.port), name, seconds)
|
||||
except Exception as e: # reported in the log check below
|
||||
lines.append(f'login failed: {e}')
|
||||
|
||||
threading.Thread(target=run, daemon=True).start()
|
||||
continue
|
||||
proc.stdin.write(command + '\n')
|
||||
proc.stdin.flush()
|
||||
time.sleep(0.5)
|
||||
time.sleep(args.wait_after)
|
||||
proc.stdin.write('stop\n')
|
||||
proc.stdin.flush()
|
||||
try:
|
||||
proc.wait(args.timeout)
|
||||
except subprocess.TimeoutExpired:
|
||||
proc.kill()
|
||||
time.sleep(0.2)
|
||||
problems = [l for l in lines if SUSPICIOUS.search(l) and not BENIGN.search(l)]
|
||||
with open(os.path.join(args.dir, 'check.log'), 'w') as f:
|
||||
f.write('\n'.join(lines) + '\n')
|
||||
for l in problems:
|
||||
print(l)
|
||||
print(f'{len(lines)} log lines, {len(problems)} suspicious')
|
||||
return 1 if problems else 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user