be73f4ac6a
bf81ae635 started saving recipes_used, but Horizon's recipe ids lack the
minecraft: namespace, so a furnace could hold both forms of one id and
vanilla refused it with "Duplicate entry for key" (save_roundtrip).
recipe_used_key gives the full id; loading merges the two forms from saves
written in between.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
4412 lines
170 KiB
Rust
4412 lines
170 KiB
Rust
//! World persistence in the vanilla 26.3 layout, readable by both Horizon and
|
|
//! the vanilla game:
|
|
//! - `level.dat` (`Data`: name, game type, time, spawn, difficulty, version)
|
|
//! plus the saved-data files `data/minecraft/{weather,world_clocks,
|
|
//! world_gen_settings,game_rules}.dat`;
|
|
//! - the player in `players/data/<uuid>.dat` (`singleplayer_uuid`);
|
|
//! - per dimension `dimensions/minecraft/<name>/region/r.X.Z.mca` (chunks:
|
|
//! paletted sections with light, heightmaps, block entities, scheduled
|
|
//! block/fluid ticks) and `entities/r.X.Z.mca` (entities, `entity_nbt`).
|
|
//!
|
|
//! Data Horizon does not simulate (structure references, unknown block
|
|
//! entities and entities, player fields such as the ender chest or effects,
|
|
//! game rules) is kept from the loaded files and written back unchanged.
|
|
//! Worlds saved by older Horizon builds (`region/`, `DIM-1/`, `Player` in
|
|
//! `level.dat`) are migrated on open.
|
|
use crate::{
|
|
Result,
|
|
biome::Biomes,
|
|
chunk::{BIOME_STRATEGY, Chunk, Light, MIN_Y, SECTIONS, Section, block_strategy},
|
|
streaming::ChunkGenerator,
|
|
};
|
|
use horizon_core::{
|
|
paletted::PalettedContainer,
|
|
position::{BlockPos, ChunkPos},
|
|
ticks::{SavedTick, TickPriority, TickTypeId},
|
|
};
|
|
use horizon_world::{
|
|
DATA_VERSION,
|
|
chunk::BlockState,
|
|
chunk_status::ChunkStatus,
|
|
compression::Compression,
|
|
heightmap::{Heightmap, HeightmapChunk, HeightmapState, HeightmapType},
|
|
nbt::{self, Compound, JavaString, Limits, NamedTag, Tag},
|
|
region::{ChunkRecord, RegionFile},
|
|
registry::{BlockRegistry, BlockStateId},
|
|
worldgen::terrain::TerrainBlockStates,
|
|
};
|
|
use std::{
|
|
collections::{BTreeMap, HashMap},
|
|
fs,
|
|
path::{Path, PathBuf},
|
|
sync::{
|
|
Arc, Condvar, Mutex, OnceLock,
|
|
atomic::{AtomicU64, Ordering},
|
|
mpsc,
|
|
},
|
|
};
|
|
|
|
pub const VERSION_NAME: &str = horizon_core::VANILLA_VERSION;
|
|
|
|
/// Snapshot live block entities and custom names for a save batch without
|
|
/// mutating the world. Each map is visited once, retaining its iteration order
|
|
/// within each chunk (including repeated chunk coordinates in the input).
|
|
/// An empty batch skips both maps; one chunk uses the direct filter path.
|
|
pub fn chunks_with_block_entities<'a>(
|
|
chunks: impl IntoIterator<Item = &'a Arc<Chunk>>,
|
|
entities: &HashMap<(i32, i32, i32), crate::containers::BlockEntity>,
|
|
names: &HashMap<(i32, i32, i32), String>,
|
|
) -> Vec<Chunk> {
|
|
let chunks: Vec<_> = chunks.into_iter().collect();
|
|
if chunks.is_empty() {
|
|
return Vec::new();
|
|
}
|
|
if chunks.len() == 1 {
|
|
let mut c = (**chunks[0]).clone();
|
|
c.block_entities = entities
|
|
.iter()
|
|
.filter(|(p, _)| p.0 >> 4 == c.x && p.2 >> 4 == c.z)
|
|
.map(|(p, e)| (*p, e.clone()))
|
|
.collect();
|
|
c.block_names = names
|
|
.iter()
|
|
.filter(|(p, _)| p.0 >> 4 == c.x && p.2 >> 4 == c.z)
|
|
.map(|(p, n)| (*p, n.clone()))
|
|
.collect();
|
|
return vec![c];
|
|
}
|
|
// Index only requested chunks, borrowing their entries so unsaved entities
|
|
// are never cloned. Clone one chunk at a time for inventory cache locality.
|
|
let mut grouped = crate::fast_hash::FxHashMap::<_, (Vec<_>, Vec<_>)>::default();
|
|
grouped.reserve(chunks.len());
|
|
for c in &chunks {
|
|
grouped.entry((c.x, c.z)).or_default();
|
|
}
|
|
for (p, e) in entities {
|
|
if let Some((entries, _)) = grouped.get_mut(&(p.0 >> 4, p.2 >> 4)) {
|
|
entries.push((p, e));
|
|
}
|
|
}
|
|
for (p, n) in names {
|
|
if let Some((_, entries)) = grouped.get_mut(&(p.0 >> 4, p.2 >> 4)) {
|
|
entries.push((p, n));
|
|
}
|
|
}
|
|
chunks
|
|
.into_iter()
|
|
.map(|chunk| {
|
|
let mut c = (**chunk).clone();
|
|
let (entities, names) = &grouped[&(c.x, c.z)];
|
|
c.block_entities = entities.iter().map(|(p, e)| (**p, (*e).clone())).collect();
|
|
c.block_names = names.iter().map(|(p, n)| (**p, (*n).clone())).collect();
|
|
c
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn string(s: &str) -> Tag {
|
|
Tag::String(s.into())
|
|
}
|
|
pub fn text(tag: Option<&Tag>) -> Option<String> {
|
|
match tag {
|
|
Some(Tag::String(s)) => Some(s.to_string_lossy()),
|
|
_ => None,
|
|
}
|
|
}
|
|
/// Any numeric tag as i64 (vanilla's `getIntOr` etc. accept every number type).
|
|
pub fn number(tag: Option<&Tag>) -> Option<i64> {
|
|
Some(match tag? {
|
|
Tag::Byte(v) => i64::from(*v),
|
|
Tag::Short(v) => i64::from(*v),
|
|
Tag::Int(v) => i64::from(*v),
|
|
Tag::Long(v) => *v,
|
|
Tag::Float(b) => f32::from_bits(*b) as i64,
|
|
Tag::Double(b) => f64::from_bits(*b) as i64,
|
|
_ => return None,
|
|
})
|
|
}
|
|
pub(crate) fn float(tag: Option<&Tag>) -> Option<f64> {
|
|
Some(match tag? {
|
|
Tag::Float(b) => f64::from(f32::from_bits(*b)),
|
|
Tag::Double(b) => f64::from_bits(*b),
|
|
other => number(Some(other))? as f64,
|
|
})
|
|
}
|
|
/// Insert or replace a key of a compound tag.
|
|
pub(crate) fn put(tag: &mut Tag, key: &str, value: Tag) {
|
|
if let Tag::Compound(map) = tag {
|
|
map.insert(key.into(), value);
|
|
}
|
|
}
|
|
fn compound_or_empty(tag: Option<Tag>) -> Tag {
|
|
match tag {
|
|
Some(t @ Tag::Compound(_)) => t,
|
|
_ => Tag::Compound(Compound::new()),
|
|
}
|
|
}
|
|
|
|
/// `dimensions/<namespace>/<path>` inside a world folder.
|
|
pub fn dimension_dir(world: &Path, dimension: &str) -> PathBuf {
|
|
let (namespace, path) = dimension
|
|
.split_once(':')
|
|
.unwrap_or(("minecraft", dimension));
|
|
world.join("dimensions").join(namespace).join(path)
|
|
}
|
|
/// `DirectoryLock`: `session.lock` holds "\u{2603}" (UTF-16BE) under an exclusive
|
|
/// file lock for as long as the world is open, so two instances cannot share it.
|
|
pub struct SessionLock(fs::File);
|
|
impl Drop for SessionLock {
|
|
/// `DirectoryLock.close`: release the lock, then close the file. Closing
|
|
/// alone keeps the lock while any copy of the descriptor lives on, such as
|
|
/// the one a process spawned on another thread holds until its `exec`.
|
|
fn drop(&mut self) {
|
|
let _ = self.0.unlock();
|
|
}
|
|
}
|
|
impl SessionLock {
|
|
pub fn acquire(world: &Path) -> Result<Self> {
|
|
use std::io::Write;
|
|
fs::create_dir_all(world)?;
|
|
let mut file = fs::OpenOptions::new()
|
|
.write(true)
|
|
.create(true)
|
|
.truncate(false)
|
|
.open(world.join("session.lock"))?;
|
|
file.try_lock()
|
|
.map_err(|_| format!("{} is already open in another instance", world.display()))?;
|
|
file.set_len(0)?;
|
|
file.write_all(&[0x26, 0x03])?;
|
|
file.flush()?;
|
|
Ok(Self(file))
|
|
}
|
|
}
|
|
/// Bring a world last saved by an older game version to the current format, as
|
|
/// 26.3 does when it opens one: the file fixes and level.dat first
|
|
/// (`FileFixerUpper`), then the DataFixers upgrades of every chunk, entity chunk,
|
|
/// POI chunk, player, saved data, advancements and statistics file. Vanilla runs
|
|
/// the latter as it reads each file; Horizon runs them all on opening, which reads
|
|
/// the same data. Worlds older than the ported fixes (1.17) are refused.
|
|
pub fn upgrade_older_world(world: &Path) -> Result<()> {
|
|
let Some(root) = read_dat(&world.join("level.dat")) else {
|
|
return Ok(());
|
|
};
|
|
let version = root.get("Data").map_or(i64::from(DATA_VERSION), |d| {
|
|
number(d.get("DataVersion")).unwrap_or(-1) // saves of 1.8 and before have none
|
|
});
|
|
if version >= i64::from(DATA_VERSION) {
|
|
return Ok(());
|
|
}
|
|
if version < i64::from(horizon_world::datafix::OLDEST_SUPPORTED) {
|
|
return Err(format!(
|
|
"{} was saved with DataVersion {version}; worlds older than DataVersion {} \
|
|
cannot be upgraded yet (tools/upgrade_world.py runs vanilla's own upgrader)",
|
|
world.display(),
|
|
horizon_world::datafix::OLDEST_SUPPORTED
|
|
)
|
|
.into());
|
|
}
|
|
horizon_world::datafix::files::upgrade_world(world)
|
|
.map_err(|e| format!("upgrading {}: {e}", world.display()))?;
|
|
Ok(())
|
|
}
|
|
/// Move a world saved by an older Horizon build (pre-26.3 layout with a
|
|
/// DataVersion that keeps vanilla from upgrading it) into the 26.3 layout.
|
|
pub fn migrate_legacy(world: &Path) -> Result<()> {
|
|
for (old, dimension) in [
|
|
("", "minecraft:overworld"),
|
|
("DIM-1", "minecraft:the_nether"),
|
|
("DIM1", "minecraft:the_end"),
|
|
] {
|
|
let from = if old.is_empty() {
|
|
world.to_owned()
|
|
} else {
|
|
world.join(old)
|
|
};
|
|
let to = dimension_dir(world, dimension);
|
|
for folder in ["region", "entities", "poi"] {
|
|
let (src, dst) = (from.join(folder), to.join(folder));
|
|
if src.is_dir() && !dst.exists() {
|
|
fs::create_dir_all(&to)?;
|
|
fs::rename(&src, &dst)?;
|
|
}
|
|
}
|
|
if !old.is_empty() && from.is_dir() && fs::read_dir(&from)?.next().is_none() {
|
|
let _ = fs::remove_dir(&from);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Registry lookups shared by chunk encoding and decoding.
|
|
pub struct SaveTables {
|
|
/// Block registry IDs (`BlockId`, scheduled tick types) in registry order.
|
|
block_names: Vec<String>,
|
|
block_ids: HashMap<String, u16>,
|
|
/// Default state of each state's block, to write vanilla's short palette form.
|
|
default_state: Vec<bool>,
|
|
block_entity: Vec<bool>,
|
|
heightmaps: crate::assets::Properties,
|
|
air: u32,
|
|
}
|
|
impl SaveTables {
|
|
pub fn new(assets: &crate::assets::Assets) -> Self {
|
|
let registry = assets.registry;
|
|
let mut block_names: Vec<String> = Vec::new();
|
|
let mut default_state = Vec::with_capacity(registry.len());
|
|
for id in 0..registry.len() {
|
|
let state = registry
|
|
.state(BlockStateId(id as u32))
|
|
.expect("registry state");
|
|
if block_names.last() != Some(&state.name) {
|
|
block_names.push(state.name.clone());
|
|
}
|
|
default_state
|
|
.push(registry.default_state(&state.name) == Some(BlockStateId(id as u32)));
|
|
}
|
|
let block_ids = block_names
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(i, n)| (n.clone(), i as u16))
|
|
.collect();
|
|
Self {
|
|
block_names,
|
|
block_ids,
|
|
default_state,
|
|
block_entity: Vec::new(),
|
|
heightmaps: assets.properties.clone(),
|
|
air: registry.default_state("minecraft:air").map_or(0, |s| s.0),
|
|
}
|
|
}
|
|
/// Tables with only the heightmaps' state facts, for tests.
|
|
#[cfg(test)]
|
|
pub(crate) fn for_heightmaps(heightmaps: crate::assets::Properties) -> Self {
|
|
Self {
|
|
block_names: Vec::new(),
|
|
block_ids: HashMap::new(),
|
|
default_state: Vec::new(),
|
|
block_entity: Vec::new(),
|
|
heightmaps,
|
|
air: 0,
|
|
}
|
|
}
|
|
/// Which states carry a block entity (`BlockFacts`), to drop entries for
|
|
/// unknown block entities whose block is gone.
|
|
pub fn with_block_entities(mut self, facts: &crate::blocks::BlockFacts) -> Self {
|
|
self.block_entity = facts.states.iter().map(|s| s.block_entity).collect();
|
|
self
|
|
}
|
|
}
|
|
|
|
/// Save data loaded with a chunk that Horizon keeps but does not simulate.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct ChunkExtras {
|
|
/// Chunk root keys written back as loaded (structures, PostProcessing,
|
|
/// InhabitedTime, blending data, ...).
|
|
pub root: Compound,
|
|
/// Block entities Horizon does not model.
|
|
pub block_entities: Vec<Tag>,
|
|
/// The NBT of the modelled block entities as loaded, to restore the fields and
|
|
/// detail Horizon does not model when it saves them (`block_entity_nbt::overlay`).
|
|
pub block_entity_sources: Vec<((i32, i32, i32), Tag)>,
|
|
/// Every saved block entity's position in the order of the save's list,
|
|
/// the order `SerializableChunkData` puts them in the chunk's maps.
|
|
pub block_entity_order: Vec<(i32, i32, i32)>,
|
|
/// Scheduled ticks (`block_ticks`/`fluid_ticks`): delays relative to the
|
|
/// save time. Registered with the level's tick scheduler on arrival and
|
|
/// replaced with the scheduler's pending ticks when saving.
|
|
pub block_ticks: Vec<SavedTick>,
|
|
pub fluid_ticks: Vec<SavedTick>,
|
|
/// Game time written as `LastUpdate`.
|
|
pub last_update: i64,
|
|
}
|
|
|
|
fn tick_list(ticks: &[SavedTick], name: impl Fn(u32) -> Option<String>) -> Tag {
|
|
Tag::List(
|
|
ticks
|
|
.iter()
|
|
.filter_map(|t| {
|
|
Some(Tag::compound([
|
|
("i", string(&name(t.kind.0)?)),
|
|
("x", Tag::Int(t.pos.x)),
|
|
("y", Tag::Int(t.pos.y)),
|
|
("z", Tag::Int(t.pos.z)),
|
|
("t", Tag::Int(t.delay)),
|
|
("p", Tag::Int(t.priority as i32)),
|
|
]))
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
fn read_ticks(
|
|
tag: Option<&Tag>,
|
|
chunk: (i32, i32),
|
|
id: impl Fn(&str) -> Option<u32>,
|
|
) -> Vec<SavedTick> {
|
|
let Some(Tag::List(list)) = tag else {
|
|
return Vec::new();
|
|
};
|
|
list.iter()
|
|
.filter_map(|t| {
|
|
let kind = id(&text(t.get("i"))?)?;
|
|
let pos = BlockPos::new(
|
|
number(t.get("x"))? as i32,
|
|
number(t.get("y"))? as i32,
|
|
number(t.get("z"))? as i32,
|
|
);
|
|
// SavedTick.filterTickListForChunk
|
|
if (pos.x >> 4, pos.z >> 4) != chunk {
|
|
return None;
|
|
}
|
|
Some(SavedTick {
|
|
kind: TickTypeId(kind),
|
|
pos,
|
|
delay: number(t.get("t")).unwrap_or(0) as i32,
|
|
priority: TickPriority::by_value(number(t.get("p")).unwrap_or(0) as i32),
|
|
})
|
|
})
|
|
.collect()
|
|
}
|
|
fn fluid_name(kind: u32) -> Option<String> {
|
|
use horizon_world::fluid::FluidKind;
|
|
let fluid = *FluidKind::ALL.get(kind as usize)?;
|
|
Some(
|
|
match fluid {
|
|
FluidKind::Empty => return None,
|
|
FluidKind::FlowingWater => "minecraft:flowing_water",
|
|
FluidKind::Water => "minecraft:water",
|
|
FluidKind::FlowingLava => "minecraft:flowing_lava",
|
|
FluidKind::Lava => "minecraft:lava",
|
|
}
|
|
.to_owned(),
|
|
)
|
|
}
|
|
fn fluid_id(name: &str) -> Option<u32> {
|
|
use horizon_world::fluid::FluidKind;
|
|
Some(match name {
|
|
"minecraft:flowing_water" => FluidKind::FlowingWater,
|
|
"minecraft:water" => FluidKind::Water,
|
|
"minecraft:flowing_lava" => FluidKind::FlowingLava,
|
|
"minecraft:lava" => FluidKind::Lava,
|
|
_ => return None,
|
|
} as u32)
|
|
}
|
|
|
|
fn encode_item(stack: &crate::items::ItemStack) -> Vec<(&'static str, Tag)> {
|
|
let mut entries = vec![
|
|
("id", string(&stack.item)),
|
|
("count", Tag::Int(stack.count as i32)),
|
|
];
|
|
if let Some(components) = crate::item_data::encode_components(stack) {
|
|
entries.push(("components", components));
|
|
}
|
|
entries
|
|
}
|
|
/// ItemStack.CODEC (id, count, components).
|
|
pub fn item_to_nbt(stack: &crate::items::ItemStack) -> Tag {
|
|
Tag::compound(encode_item(stack))
|
|
}
|
|
pub fn item_from_nbt(tag: &Tag) -> Option<crate::items::ItemStack> {
|
|
let id = text(tag.get("id"))?;
|
|
if id == "minecraft:air" {
|
|
return None;
|
|
}
|
|
let count = number(tag.get("count"))
|
|
.or_else(|| number(tag.get("Count")))
|
|
.unwrap_or(1)
|
|
.max(1) as u32;
|
|
let (damage, extra) = crate::item_data::decode_components(tag.get("components"));
|
|
Some(crate::items::ItemStack {
|
|
item: Arc::from(id.as_str()),
|
|
count,
|
|
damage,
|
|
extra,
|
|
})
|
|
}
|
|
pub fn encode_items(slots: &[Option<crate::items::ItemStack>]) -> Tag {
|
|
Tag::List(
|
|
slots
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(i, s)| {
|
|
let mut entries = vec![("Slot", Tag::Byte(i as i8))];
|
|
entries.extend(encode_item(s.as_ref()?));
|
|
Some(Tag::compound(entries))
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
pub fn decode_items(tag: Option<&Tag>, size: usize) -> Vec<Option<crate::items::ItemStack>> {
|
|
let mut slots = vec![None; size];
|
|
if let Some(Tag::List(items)) = tag {
|
|
for it in items {
|
|
let slot = number(it.get("Slot")).unwrap_or(0) as u8 as usize;
|
|
if let Some(cell) = slots.get_mut(slot) {
|
|
*cell = item_from_nbt(it);
|
|
}
|
|
}
|
|
}
|
|
slots
|
|
}
|
|
/// The block entity type ID for the block it sits in (a chest-like container
|
|
/// is a chest, trapped chest or barrel).
|
|
fn block_entity_id(e: &crate::containers::BlockEntity, block: &str) -> String {
|
|
match (e, block) {
|
|
(
|
|
crate::containers::BlockEntity::Chest(_),
|
|
"minecraft:trapped_chest" | "minecraft:barrel" | "minecraft:dropper",
|
|
) => block.to_owned(),
|
|
(crate::containers::BlockEntity::Chest(_), b) if b.ends_with("shulker_box") => {
|
|
"minecraft:shulker_box".to_owned()
|
|
}
|
|
_ => e.id().to_owned(),
|
|
}
|
|
}
|
|
pub fn encode_block_entity(
|
|
p: (i32, i32, i32),
|
|
e: &crate::containers::BlockEntity,
|
|
block: &str,
|
|
) -> Tag {
|
|
use crate::containers::BlockEntity;
|
|
let components = match e {
|
|
BlockEntity::Banner(b) => b.components.clone(),
|
|
_ => Compound::new(),
|
|
};
|
|
let mut entries = vec![
|
|
("id", string(&block_entity_id(e, block))),
|
|
("x", Tag::Int(p.0)),
|
|
("y", Tag::Int(p.1)),
|
|
("z", Tag::Int(p.2)),
|
|
("keepPacked", Tag::Byte(0)),
|
|
("components", Tag::Compound(components)),
|
|
];
|
|
match e {
|
|
BlockEntity::Chest(items) => entries.push(("Items", encode_items(items))),
|
|
BlockEntity::Furnace(f) => {
|
|
entries.push(("Items", encode_items(&f.items)));
|
|
entries.push(("lit_time_remaining", Tag::Int(f.lit_remaining)));
|
|
entries.push(("lit_total_time", Tag::Int(f.lit_total)));
|
|
entries.push(("cooking_time_spent", Tag::Int(f.cooking_timer)));
|
|
entries.push(("cooking_total_time", Tag::Int(f.cooking_total)));
|
|
entries.push(("speed_multiplier", Tag::Float(f.speed.to_bits())));
|
|
let used: Compound = f
|
|
.recipes_used
|
|
.iter()
|
|
.map(|(id, count)| (id.as_str().into(), Tag::Int(*count as i32)))
|
|
.collect();
|
|
entries.push(("RecipesUsed", Tag::Compound(used)));
|
|
}
|
|
BlockEntity::Brewing(b) => {
|
|
entries.push(("Items", encode_items(&b.items)));
|
|
entries.push(("BrewTime", Tag::Int(b.brew_time)));
|
|
entries.push(("total_brew_time", Tag::Int(b.total_brew_time)));
|
|
entries.push(("Fuel", Tag::Int(b.fuel)));
|
|
entries.push(("total_fuel", Tag::Int(b.total_fuel)));
|
|
entries.push(("speed_multiplier", Tag::Float(b.speed.to_bits())));
|
|
}
|
|
BlockEntity::Sign(sign) => entries.extend(sign.encode()),
|
|
BlockEntity::Jukebox(j) => {
|
|
if let Some(record) = &j.record {
|
|
entries.push(("RecordItem", item_to_nbt(record)));
|
|
}
|
|
entries.push(("ticks_since_song_started", Tag::Long(j.ticks)));
|
|
}
|
|
BlockEntity::Beacon(b) => {
|
|
if let Some(p) = &b.primary {
|
|
entries.push(("primary_effect", string(p)));
|
|
}
|
|
if let Some(s) = &b.secondary {
|
|
entries.push(("secondary_effect", string(s)));
|
|
}
|
|
entries.push(("Levels", Tag::Int(b.levels)));
|
|
}
|
|
BlockEntity::Lectern(l) => {
|
|
if let Some(book) = &l.book {
|
|
entries.push(("Book", item_to_nbt(book)));
|
|
entries.push(("Page", Tag::Int(l.page)));
|
|
}
|
|
}
|
|
BlockEntity::Sculk(s) => entries.extend(s.to_nbt()),
|
|
BlockEntity::Crafter(c) => {
|
|
entries.push(("Items", encode_items(&c.items)));
|
|
entries.push((
|
|
"disabled_slots",
|
|
Tag::IntArray(
|
|
(0..9)
|
|
.filter(|&i| c.disabled[i])
|
|
.map(|i| i as i32)
|
|
.collect(),
|
|
),
|
|
));
|
|
entries.push(("triggered", Tag::Int(i32::from(c.triggered))));
|
|
entries.push(("crafting_ticks_remaining", Tag::Int(c.crafting_ticks)));
|
|
}
|
|
BlockEntity::Banner(b) => {
|
|
if !b.layers.is_empty() {
|
|
entries.push(("patterns", crate::banner::layers_to_nbt(&b.layers)));
|
|
}
|
|
if let Some(name) = &b.name {
|
|
entries.push(("CustomName", string(name)));
|
|
}
|
|
}
|
|
BlockEntity::CreakingHeart(h) => {
|
|
if let Some((_, uuid)) = h.creaking {
|
|
entries.push(("creaking", uuid_tag(uuid)));
|
|
}
|
|
}
|
|
BlockEntity::Skull(s) => {
|
|
if let Some(profile) = &s.profile {
|
|
entries.push(("profile", profile.clone()));
|
|
}
|
|
if let Some(sound) = &s.note_block_sound {
|
|
entries.push(("note_block_sound", string(sound)));
|
|
}
|
|
if let Some(name) = &s.custom_name {
|
|
entries.push(("custom_name", name.clone()));
|
|
}
|
|
}
|
|
BlockEntity::Spawner(s) => entries.extend(s.save()),
|
|
BlockEntity::TrialSpawner(s) => entries.extend(s.save()),
|
|
BlockEntity::Vault(v) => entries.extend(v.save()),
|
|
BlockEntity::Beehive(h) => entries.extend(h.to_nbt()),
|
|
BlockEntity::CommandBlock(c) => entries.extend(c.save()),
|
|
}
|
|
Tag::compound(entries)
|
|
}
|
|
/// `block_entity_nbt::overlay`, then a container that now holds items loses its
|
|
/// loot table (vanilla clears it when the loot is generated into the container).
|
|
fn merge_block_entity(original: &Tag, loaded: &Tag, current: &Tag) -> Tag {
|
|
let mut merged = crate::block_entity_nbt::overlay(original, loaded, current);
|
|
let has_items = matches!(current.get("Items"), Some(Tag::List(items)) if !items.is_empty());
|
|
if has_items && let Tag::Compound(map) = &mut merged {
|
|
map.remove(&"LootTable".into());
|
|
map.remove(&"LootTableSeed".into());
|
|
}
|
|
merged
|
|
}
|
|
/// `BannerBlockEntity.loadAdditional` (and the `components` a block entity keeps).
|
|
pub fn decode_banner(tag: &Tag) -> crate::containers::Banner {
|
|
crate::containers::Banner {
|
|
layers: crate::banner::layers_from_nbt(tag.get("patterns")),
|
|
name: text(tag.get("CustomName")),
|
|
components: match tag.get("components") {
|
|
Some(Tag::Compound(c)) => c.clone(),
|
|
_ => Compound::new(),
|
|
},
|
|
}
|
|
}
|
|
pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> {
|
|
use crate::containers::BlockEntity;
|
|
let int = |k: &str| number(tag.get(k)).map(|v| v as i32);
|
|
let id = text(tag.get("id"))?;
|
|
let pos = (int("x")?, int("y")?, int("z")?);
|
|
if id == "minecraft:jukebox" {
|
|
let record = tag.get("RecordItem").and_then(item_from_nbt);
|
|
let ticks = number(tag.get("ticks_since_song_started")).unwrap_or(0);
|
|
let playing = record.is_some();
|
|
return Some((
|
|
pos,
|
|
BlockEntity::Jukebox(crate::containers::Jukebox {
|
|
record,
|
|
ticks,
|
|
playing,
|
|
}),
|
|
));
|
|
}
|
|
if id == "minecraft:creaking_heart" {
|
|
let heart = crate::containers::CreakingHeart {
|
|
creaking: uuid_from_tag(tag.get("creaking")).map(|uuid| (None, uuid)),
|
|
..Default::default()
|
|
};
|
|
return Some((pos, BlockEntity::CreakingHeart(Box::new(heart))));
|
|
}
|
|
if id == "minecraft:lectern" {
|
|
let lectern = crate::containers::Lectern {
|
|
book: tag.get("Book").and_then(item_from_nbt),
|
|
page: int("Page").unwrap_or(0),
|
|
};
|
|
return Some((pos, BlockEntity::Lectern(lectern)));
|
|
}
|
|
if id == "minecraft:banner" {
|
|
return Some((pos, BlockEntity::Banner(decode_banner(tag))));
|
|
}
|
|
if id == "minecraft:beacon" {
|
|
let beacon = crate::containers::Beacon {
|
|
levels: int("Levels").unwrap_or(0),
|
|
primary: text(tag.get("primary_effect")),
|
|
secondary: text(tag.get("secondary_effect")),
|
|
last_check_y: i32::MIN / 2,
|
|
..Default::default()
|
|
};
|
|
return Some((pos, BlockEntity::Beacon(Box::new(beacon))));
|
|
}
|
|
// A skull's block entity id is not its block's name (every head block).
|
|
if id == "minecraft:skull" {
|
|
return Some((
|
|
pos,
|
|
BlockEntity::Skull(crate::containers::Skull::new(
|
|
tag.get("profile").cloned(),
|
|
text(tag.get("note_block_sound")),
|
|
tag.get("custom_name")
|
|
.and_then(crate::block_entity_nbt::component),
|
|
)),
|
|
));
|
|
}
|
|
// A spawner's block entity id is not its block's name.
|
|
let block = match id.as_str() {
|
|
"minecraft:mob_spawner" => "minecraft:spawner",
|
|
other => other,
|
|
};
|
|
let mut entity = BlockEntity::for_block(block)?;
|
|
match &mut entity {
|
|
BlockEntity::Chest(items) => *items = decode_items(tag.get("Items"), items.len()),
|
|
BlockEntity::Furnace(f) => {
|
|
let items = decode_items(tag.get("Items"), 3);
|
|
f.items = [items[0].clone(), items[1].clone(), items[2].clone()];
|
|
f.lit_remaining = int("lit_time_remaining").unwrap_or(0);
|
|
f.lit_total = int("lit_total_time").unwrap_or(0);
|
|
f.cooking_timer = int("cooking_time_spent").unwrap_or(0);
|
|
f.cooking_total = int("cooking_total_time").unwrap_or(0);
|
|
if let Some(speed) = float(tag.get("speed_multiplier")) {
|
|
f.speed = speed as f32;
|
|
}
|
|
// A save without it owes nothing: the field is newer than some worlds.
|
|
if let Some(Tag::Compound(used)) = tag.get("RecipesUsed") {
|
|
for (id, count) in used {
|
|
let count = match count {
|
|
Tag::Int(n) => *n,
|
|
_ => continue,
|
|
};
|
|
// Saves from before the key was namespaced hold both forms of an id.
|
|
*f.recipes_used
|
|
.entry(crate::containers::recipe_used_key(&id.to_string_lossy()))
|
|
.or_insert(0) += count.max(0) as u32;
|
|
}
|
|
}
|
|
}
|
|
BlockEntity::Brewing(b) => {
|
|
let items = decode_items(tag.get("Items"), 5);
|
|
b.items = [
|
|
items[0].clone(),
|
|
items[1].clone(),
|
|
items[2].clone(),
|
|
items[3].clone(),
|
|
items[4].clone(),
|
|
];
|
|
b.brew_time = int("BrewTime").unwrap_or(0);
|
|
b.total_brew_time = int("total_brew_time").unwrap_or(400);
|
|
if b.brew_time > 0 {
|
|
b.ingredient = b.items[3].as_ref().map(|s| s.item.clone());
|
|
}
|
|
b.fuel = int("Fuel").unwrap_or(0);
|
|
b.total_fuel = int("total_fuel").unwrap_or(20);
|
|
b.speed = match tag.get("speed_multiplier") {
|
|
Some(Tag::Float(f)) => f32::from_bits(*f),
|
|
_ => 1.0,
|
|
};
|
|
}
|
|
BlockEntity::Sign(sign) => sign.decode(tag),
|
|
BlockEntity::Sculk(s) => s.load(tag),
|
|
BlockEntity::Crafter(c) => {
|
|
for (slot, item) in decode_items(tag.get("Items"), 9).into_iter().enumerate() {
|
|
c.items[slot] = item;
|
|
}
|
|
if let Some(Tag::IntArray(slots)) = tag.get("disabled_slots") {
|
|
for &slot in slots {
|
|
if (0..9).contains(&slot) && c.items[slot as usize].is_none() {
|
|
c.disabled[slot as usize] = true;
|
|
}
|
|
}
|
|
}
|
|
c.triggered = int("triggered").unwrap_or(0) != 0;
|
|
c.state_triggered = None;
|
|
c.crafting_ticks = int("crafting_ticks_remaining").unwrap_or(0);
|
|
}
|
|
BlockEntity::Jukebox(_)
|
|
| BlockEntity::Beacon(_)
|
|
| BlockEntity::Lectern(_)
|
|
| BlockEntity::Banner(_)
|
|
| BlockEntity::CreakingHeart(_)
|
|
| BlockEntity::Skull(_) => {}
|
|
BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag),
|
|
BlockEntity::TrialSpawner(s) => **s = crate::mobs::trial_spawner::TrialSpawner::load(tag),
|
|
BlockEntity::Vault(v) => **v = crate::vault::Vault::load(tag),
|
|
BlockEntity::Beehive(h) => **h = crate::beehive::Beehive::from_nbt(tag),
|
|
BlockEntity::CommandBlock(c) => **c = crate::command_block::CommandBlock::load(tag),
|
|
}
|
|
Some((pos, entity))
|
|
}
|
|
|
|
/// A column's sections as `Heightmap.primeHeightmaps` reads them.
|
|
struct HeightmapView<'a> {
|
|
sections: &'a [Arc<Section>],
|
|
tables: &'a SaveTables,
|
|
}
|
|
impl HeightmapChunk for HeightmapView<'_> {
|
|
type State = crate::assets::StateFacts;
|
|
fn min_y(&self) -> i32 {
|
|
MIN_Y
|
|
}
|
|
fn height(&self) -> i32 {
|
|
SECTIONS as i32 * 16
|
|
}
|
|
fn highest_section_y(&self) -> i32 {
|
|
let top = self
|
|
.sections
|
|
.iter()
|
|
.rposition(|s| !s.is_uniform(self.tables.air))
|
|
.unwrap_or(0);
|
|
MIN_Y + top as i32 * 16
|
|
}
|
|
fn block_state(&self, x: i32, y: i32, z: i32) -> Self::State {
|
|
// Chunk.get: no block outside the sections.
|
|
let state = usize::try_from((y - MIN_Y) >> 4)
|
|
.ok()
|
|
.and_then(|s| self.sections.get(s))
|
|
.map_or(0, |s| s.get(crate::chunk::index(x, y, z)));
|
|
self.tables.heightmaps.heightmap_state(BlockStateId(state))
|
|
}
|
|
}
|
|
/// Heightmaps kept after world generation (`ChunkStatus.FULL.heightmapsAfter`).
|
|
fn heightmaps(chunk: &Chunk, tables: &SaveTables) -> Tag {
|
|
let kinds = [
|
|
HeightmapType::WorldSurface,
|
|
HeightmapType::OceanFloor,
|
|
HeightmapType::MotionBlocking,
|
|
HeightmapType::MotionBlockingNoLeaves,
|
|
];
|
|
let mut maps: Vec<Heightmap> = kinds
|
|
.iter()
|
|
.filter_map(|k| Heightmap::new(*k, MIN_Y, SECTIONS as i32 * 16).ok())
|
|
.collect();
|
|
let view = HeightmapView {
|
|
sections: &chunk.sections,
|
|
tables,
|
|
};
|
|
let mut refs: Vec<&mut Heightmap> = maps.iter_mut().collect();
|
|
if Heightmap::prime(&view, &mut refs).is_err() {
|
|
return Tag::Compound(Compound::new());
|
|
}
|
|
Tag::compound(maps.iter().map(|m| {
|
|
(
|
|
m.kind().name(),
|
|
Tag::LongArray(m.raw_data().iter().map(|&w| w as i64).collect()),
|
|
)
|
|
}))
|
|
}
|
|
/// The client heightmaps of a column's sections, in a level from `min_y`,
|
|
/// `height` blocks high.
|
|
pub fn client_heightmaps_in(
|
|
sections: &[Arc<Section>],
|
|
tables: &SaveTables,
|
|
min_y: i32,
|
|
height: i32,
|
|
) -> Vec<(i32, Vec<i64>)> {
|
|
let kinds = [
|
|
(1, HeightmapType::WorldSurface),
|
|
(4, HeightmapType::MotionBlocking),
|
|
(5, HeightmapType::MotionBlockingNoLeaves),
|
|
];
|
|
let mut maps: Vec<(i32, Heightmap)> = kinds
|
|
.iter()
|
|
.filter_map(|(id, k)| Heightmap::new(*k, min_y, height).ok().map(|m| (*id, m)))
|
|
.collect();
|
|
let view = HeightmapView { sections, tables };
|
|
let mut refs: Vec<&mut Heightmap> = maps.iter_mut().map(|(_, m)| m).collect();
|
|
if Heightmap::prime(&view, &mut refs).is_err() {
|
|
return Vec::new();
|
|
}
|
|
maps.iter()
|
|
.map(|(id, m)| (*id, m.raw_data().iter().map(|&w| w as i64).collect()))
|
|
.collect()
|
|
}
|
|
/// Vanilla light layer (nibbles, index y<<8|z<<4|x, low nibble first).
|
|
fn nibbles(light: &Light, sky: bool) -> Vec<u8> {
|
|
let mut out = vec![0u8; 2048];
|
|
for (i, byte) in out.iter_mut().enumerate() {
|
|
let value = |j: usize| {
|
|
let v = match light {
|
|
Light::Uniform(v) => *v,
|
|
Light::Full(a) => a[j],
|
|
};
|
|
if sky { v >> 4 } else { v & 15 }
|
|
};
|
|
*byte = value(2 * i) | value(2 * i + 1) << 4;
|
|
}
|
|
out
|
|
}
|
|
|
|
pub fn encode(chunk: &Chunk, registry: &BlockRegistry, biomes: &Biomes) -> NamedTag {
|
|
encode_with(chunk, registry, biomes, None, true)
|
|
}
|
|
/// The chunk NBT vanilla's `SerializableChunkData.write` produces for a full
|
|
/// chunk. `sky_light` is false in dimensions without skylight.
|
|
pub fn encode_with(
|
|
chunk: &Chunk,
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
tables: Option<&SaveTables>,
|
|
sky_light: bool,
|
|
) -> NamedTag {
|
|
let mut sections = Vec::new();
|
|
let air = tables.map_or(0, |t| t.air);
|
|
// Sky layers below the highest section with light other than 15 are
|
|
// written (even all-zero ones): vanilla derives missing layers from the
|
|
// layer above them.
|
|
let top_sky = chunk.sections.iter().rposition(|s| match &s.light {
|
|
Light::Uniform(v) => v >> 4 != 15,
|
|
Light::Full(a) => a.iter().any(|v| v >> 4 != 15),
|
|
});
|
|
for (si, section) in chunk.sections.iter().enumerate() {
|
|
let y = (MIN_Y >> 4) + si as i32;
|
|
// PalettedContainer.pack: distinct states in index order, indices at
|
|
// the saved width.
|
|
let packed = section.blocks.pack();
|
|
let mut states = vec![(
|
|
"palette",
|
|
Tag::List(
|
|
packed
|
|
.palette
|
|
.iter()
|
|
.map(|&id| {
|
|
let state = registry.state(BlockStateId(id));
|
|
match state {
|
|
// BlockState.CODEC: the block name for default states.
|
|
Some(s)
|
|
if tables.is_some_and(|t| {
|
|
t.default_state.get(id as usize) == Some(&true)
|
|
}) =>
|
|
{
|
|
string(&s.name)
|
|
}
|
|
Some(s) => s.to_nbt(),
|
|
None => string("minecraft:air"),
|
|
}
|
|
})
|
|
.collect(),
|
|
),
|
|
)];
|
|
if let Some(data) = &packed.data {
|
|
states.push((
|
|
"data",
|
|
Tag::LongArray(data.iter().map(|&w| w as i64).collect()),
|
|
));
|
|
}
|
|
let biome_packed = section.biomes.pack();
|
|
let mut biome_tag = vec![(
|
|
"palette",
|
|
Tag::List(
|
|
biome_packed
|
|
.palette
|
|
.iter()
|
|
.map(|&b| string(&biomes.get(b as u16).name))
|
|
.collect(),
|
|
),
|
|
)];
|
|
if let Some(data) = &biome_packed.data {
|
|
biome_tag.push((
|
|
"data",
|
|
Tag::LongArray(data.iter().map(|&w| w as i64).collect()),
|
|
));
|
|
}
|
|
let mut entries = vec![
|
|
("Y", Tag::Byte(y as i8)),
|
|
("block_states", Tag::compound(states)),
|
|
("biomes", Tag::compound(biome_tag)),
|
|
];
|
|
if chunk.lit {
|
|
let block_lit = match §ion.light {
|
|
Light::Uniform(v) => v & 15 != 0,
|
|
Light::Full(a) => a.iter().any(|v| v & 15 != 0),
|
|
};
|
|
if block_lit {
|
|
entries.push(("BlockLight", Tag::ByteArray(nibbles(§ion.light, false))));
|
|
}
|
|
if sky_light && top_sky.is_some_and(|top| si <= top + 1) {
|
|
entries.push(("SkyLight", Tag::ByteArray(nibbles(§ion.light, true))));
|
|
}
|
|
}
|
|
let _ = air;
|
|
sections.push(Tag::compound(entries));
|
|
}
|
|
let extras = chunk.saved.as_deref();
|
|
let block_name = |p: &(i32, i32, i32)| -> String {
|
|
registry
|
|
.state(chunk.block(p.0 & 15, p.1, p.2 & 15))
|
|
.map_or_else(String::new, |s| s.name.clone())
|
|
};
|
|
let mut block_entities: Vec<Tag> = chunk
|
|
.block_entities
|
|
.iter()
|
|
.map(|(p, e)| {
|
|
let block = block_name(p);
|
|
let mut current = encode_block_entity(*p, e, &block);
|
|
if let Some((_, name)) = chunk.block_names.iter().find(|(q, _)| q == p)
|
|
&& let Tag::Compound(map) = &mut current
|
|
{
|
|
map.insert("CustomName".into(), string(name));
|
|
}
|
|
let source = extras
|
|
.and_then(|x| x.block_entity_sources.iter().find(|(q, _)| q == p))
|
|
.map(|(_, tag)| tag)
|
|
.filter(|tag| {
|
|
crate::block_entity_nbt::id(tag) == crate::block_entity_nbt::id(¤t)
|
|
});
|
|
let merged = match source {
|
|
Some(original) => {
|
|
let loaded = decode_block_entity(original).map_or_else(
|
|
|| current.clone(),
|
|
|(q, e)| encode_block_entity(q, &e, &block),
|
|
);
|
|
merge_block_entity(original, &loaded, ¤t)
|
|
}
|
|
None => current,
|
|
};
|
|
crate::block_entity_nbt::canonical(&merged).unwrap_or(merged)
|
|
})
|
|
.collect();
|
|
if let Some(extras) = extras {
|
|
for raw in &extras.block_entities {
|
|
let pos = (
|
|
number(raw.get("x")).unwrap_or(0) as i32,
|
|
number(raw.get("y")).unwrap_or(0) as i32,
|
|
number(raw.get("z")).unwrap_or(0) as i32,
|
|
);
|
|
let state = chunk.get(pos.0 & 15, pos.1, pos.2 & 15) as usize;
|
|
let still_there =
|
|
tables.is_none_or(|t| t.block_entity.get(state).copied().unwrap_or(true));
|
|
if still_there && !chunk.block_entities.iter().any(|(p, _)| *p == pos) {
|
|
block_entities
|
|
.push(crate::block_entity_nbt::canonical(raw).unwrap_or_else(|| raw.clone()));
|
|
}
|
|
}
|
|
}
|
|
let mut root = extras
|
|
.map(|e| Tag::Compound(e.root.clone()))
|
|
.unwrap_or_else(|| Tag::Compound(Compound::new()));
|
|
for (key, value) in [
|
|
("DataVersion", Tag::Int(DATA_VERSION)),
|
|
("xPos", Tag::Int(chunk.x)),
|
|
("zPos", Tag::Int(chunk.z)),
|
|
("yPos", Tag::Int(MIN_Y >> 4)),
|
|
("Status", string("minecraft:full")),
|
|
("LastUpdate", Tag::Long(extras.map_or(0, |e| e.last_update))),
|
|
("isLightOn", Tag::Byte(i8::from(chunk.lit))),
|
|
("sections", Tag::List(sections)),
|
|
("block_entities", Tag::List(block_entities)),
|
|
] {
|
|
put(&mut root, key, value);
|
|
}
|
|
if let Some(Tag::Compound(map)) = Some(&mut root) {
|
|
map.entry("InhabitedTime".into()).or_insert(Tag::Long(0));
|
|
map.entry("structures".into()).or_insert_with(|| {
|
|
Tag::compound([
|
|
("References", Tag::Compound(Compound::new())),
|
|
("starts", Tag::Compound(Compound::new())),
|
|
])
|
|
});
|
|
if !chunk.structure_refs.is_empty()
|
|
&& let Some(Tag::Compound(s)) = map.get_mut(&"structures".into())
|
|
{
|
|
let mut refs: std::collections::BTreeMap<&str, Vec<i64>> = Default::default();
|
|
for (id, (x, z)) in &chunk.structure_refs {
|
|
refs.entry(id)
|
|
.or_default()
|
|
.push(i64::from(*x as u32) | i64::from(*z) << 32);
|
|
}
|
|
let refs: Compound = refs
|
|
.into_iter()
|
|
.map(|(id, v)| (id.into(), Tag::LongArray(v)))
|
|
.collect();
|
|
s.insert("References".into(), Tag::Compound(refs));
|
|
}
|
|
map.entry("PostProcessing".into())
|
|
.or_insert_with(|| Tag::List(vec![Tag::List(Vec::new()); SECTIONS]));
|
|
}
|
|
if let Some(t) = tables {
|
|
put(&mut root, "Heightmaps", heightmaps(chunk, t));
|
|
let names = |k: u32| t.block_names.get(k as usize).cloned();
|
|
let (blocks, fluids) = extras.map_or((&[][..], &[][..]), |e| {
|
|
(&e.block_ticks[..], &e.fluid_ticks[..])
|
|
});
|
|
put(&mut root, "block_ticks", tick_list(blocks, names));
|
|
put(&mut root, "fluid_ticks", tick_list(fluids, fluid_name));
|
|
}
|
|
NamedTag {
|
|
name: "".into(),
|
|
tag: root,
|
|
}
|
|
}
|
|
/// Root keys `encode_with` regenerates; everything else is kept as loaded.
|
|
const GENERATED_KEYS: [&str; 14] = [
|
|
"DataVersion",
|
|
"xPos",
|
|
"zPos",
|
|
"yPos",
|
|
"Status",
|
|
"LastUpdate",
|
|
"isLightOn",
|
|
"sections",
|
|
"block_entities",
|
|
"Heightmaps",
|
|
"block_ticks",
|
|
"fluid_ticks",
|
|
"entities",
|
|
"CarvingMask",
|
|
];
|
|
pub fn decode(root: &NamedTag, registry: &BlockRegistry, biomes: &Biomes) -> Option<Chunk> {
|
|
decode_with(root, registry, biomes, None)
|
|
}
|
|
/// Only full chunks load here; partially generated ones (vanilla's world
|
|
/// border of proto chunks) resume generation through `decode_proto`.
|
|
pub fn decode_with(
|
|
root: &NamedTag,
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
tables: Option<&SaveTables>,
|
|
) -> Option<Chunk> {
|
|
if text(root.tag.get("Status")).is_some_and(|s| s != "minecraft:full" && s != "full") {
|
|
return None;
|
|
}
|
|
decode_column(root, registry, biomes, tables)
|
|
}
|
|
/// `decode_with` whatever the chunk's status.
|
|
fn decode_column(
|
|
root: &NamedTag,
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
tables: Option<&SaveTables>,
|
|
) -> Option<Chunk> {
|
|
let tag = &root.tag;
|
|
let Tag::Int(x) = tag.get("xPos")? else {
|
|
return None;
|
|
};
|
|
let Tag::Int(z) = tag.get("zPos")? else {
|
|
return None;
|
|
};
|
|
let mut chunk = Chunk::empty(*x, *z);
|
|
// structures.References: structure id -> packed start chunk positions.
|
|
if let Some(Tag::Compound(refs)) = tag.get("structures").and_then(|s| s.get("References")) {
|
|
for (id, v) in refs {
|
|
if let Tag::LongArray(starts) = v {
|
|
let id: Arc<str> = Arc::from(id.to_string_lossy());
|
|
for &p in starts {
|
|
chunk
|
|
.structure_refs
|
|
.push((id.clone(), (p as i32, (p >> 32) as i32)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let air = registry.default_state("minecraft:air")?.0;
|
|
let mut cache: HashMap<String, u32> = HashMap::new();
|
|
let Some(Tag::List(sections)) = tag.get("sections") else {
|
|
return Some(chunk);
|
|
};
|
|
for section in sections {
|
|
let Some(y) = number(section.get("Y")) else {
|
|
continue;
|
|
};
|
|
let si = y as i32 - (MIN_Y >> 4);
|
|
if !(0..SECTIONS as i32).contains(&si) {
|
|
continue;
|
|
}
|
|
if let Some(states) = section.get("block_states")
|
|
&& let Some(Tag::List(palette)) = states.get("palette")
|
|
{
|
|
let palette: Vec<u32> = palette
|
|
.iter()
|
|
.map(|p| {
|
|
let state = BlockState::from_nbt(p).ok();
|
|
let key = state
|
|
.as_ref()
|
|
.map(|s| format!("{}{:?}", s.name, s.properties))
|
|
.unwrap_or_default();
|
|
*cache.entry(key).or_insert_with(|| {
|
|
state
|
|
.and_then(|s| {
|
|
registry.id(&s).or_else(|| {
|
|
// Missing properties take the block's defaults.
|
|
let default = registry.default_state(&s.name)?;
|
|
let mut full = registry.state(default)?.clone();
|
|
for (k, v) in &s.properties {
|
|
if full.properties.contains_key(k) {
|
|
full.properties.insert(k.clone(), v.clone());
|
|
}
|
|
}
|
|
registry.id(&full).or(Some(default))
|
|
})
|
|
})
|
|
.map_or(air, |id| id.0)
|
|
})
|
|
})
|
|
.collect();
|
|
let target = Arc::make_mut(&mut chunk.sections[si as usize]);
|
|
let data = match states.get("data") {
|
|
Some(Tag::LongArray(data)) => {
|
|
Some(data.iter().map(|&w| w as u64).collect::<Vec<_>>())
|
|
}
|
|
_ => None,
|
|
};
|
|
if let Ok(blocks) =
|
|
PalettedContainer::from_packed(block_strategy(), palette, data.as_deref())
|
|
{
|
|
target.blocks = blocks;
|
|
}
|
|
}
|
|
if let Some(b) = section.get("biomes")
|
|
&& let Some(Tag::List(palette)) = b.get("palette")
|
|
{
|
|
let ids: Vec<u16> = palette
|
|
.iter()
|
|
.map(|p| match p {
|
|
Tag::String(s) => biomes.id(&s.to_string_lossy()),
|
|
_ => 0,
|
|
})
|
|
.collect();
|
|
let data = match b.get("data") {
|
|
Some(Tag::LongArray(data)) => {
|
|
Some(data.iter().map(|&w| w as u64).collect::<Vec<_>>())
|
|
}
|
|
_ => None,
|
|
};
|
|
let palette: Vec<u32> = ids.iter().map(|&id| u32::from(id)).collect();
|
|
let target = Arc::make_mut(&mut chunk.sections[si as usize]);
|
|
if let Ok(container) =
|
|
PalettedContainer::from_packed(BIOME_STRATEGY, palette.clone(), data.as_deref())
|
|
{
|
|
target.biomes = container;
|
|
} else if let Some(&first) = palette.first() {
|
|
target.biomes = PalettedContainer::new(BIOME_STRATEGY, first);
|
|
}
|
|
}
|
|
}
|
|
let mut extras = ChunkExtras {
|
|
last_update: number(tag.get("LastUpdate")).unwrap_or(0),
|
|
..ChunkExtras::default()
|
|
};
|
|
if let Some(Tag::List(entities)) = tag.get("block_entities") {
|
|
for e in entities {
|
|
let int = |k: &str| number(e.get(k)).map(|v| v as i32);
|
|
if let (Some(x), Some(y), Some(z)) = (int("x"), int("y"), int("z")) {
|
|
extras.block_entity_order.push((x, y, z));
|
|
}
|
|
match decode_block_entity(e) {
|
|
Some(be) => {
|
|
if let Some(name) = text(e.get("CustomName")) {
|
|
chunk.block_names.push((be.0, name));
|
|
}
|
|
extras.block_entity_sources.push((be.0, e.clone()));
|
|
chunk.block_entities.push(be);
|
|
}
|
|
None => extras.block_entities.push(e.clone()),
|
|
}
|
|
}
|
|
}
|
|
if let Tag::Compound(map) = tag {
|
|
extras.root = map
|
|
.iter()
|
|
.filter(|(k, _)| !GENERATED_KEYS.contains(&k.to_string_lossy().as_str()))
|
|
.map(|(k, v)| (k.clone(), v.clone()))
|
|
.collect();
|
|
}
|
|
if let Some(t) = tables {
|
|
extras.block_ticks = read_ticks(tag.get("block_ticks"), (*x, *z), |n| {
|
|
t.block_ids.get(n).map(|&i| u32::from(i))
|
|
});
|
|
extras.fluid_ticks = read_ticks(tag.get("fluid_ticks"), (*x, *z), fluid_id);
|
|
}
|
|
chunk.saved = Some(Arc::new(extras));
|
|
Some(chunk)
|
|
}
|
|
|
|
/// A proto chunk saved before it became final. Decoration writes into a
|
|
/// chunk's neighbours, and decorated chunks wait for theirs, so the chunks
|
|
/// past the finished ones hold writes that generating them again would lose
|
|
/// (whole structure pieces, trees, ores). Vanilla saves its proto chunks too.
|
|
pub struct SavedProto {
|
|
/// Blocks, scheduled ticks (in `saved`) and post-processing marks.
|
|
pub column: Chunk,
|
|
/// Decorated itself (`features`), not only written to by its neighbours
|
|
/// (`terrain`).
|
|
pub decorated: bool,
|
|
/// Block entity data in placement order, with `x`, `y` and `z`.
|
|
pub block_entities: Vec<Tag>,
|
|
/// Entities placed by structures, with absolute `Pos`.
|
|
pub entities: Vec<Tag>,
|
|
}
|
|
pub fn encode_proto(
|
|
proto: &SavedProto,
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
tables: Option<&SaveTables>,
|
|
sky_light: bool,
|
|
) -> NamedTag {
|
|
let mut root = encode_with(&proto.column, registry, biomes, tables, sky_light);
|
|
let status = if proto.decorated {
|
|
ChunkStatus::Features
|
|
} else {
|
|
ChunkStatus::Terrain
|
|
};
|
|
// ProtoChunk.postProcessing: one list per section, packed section offsets.
|
|
let mut marks = vec![Vec::new(); SECTIONS];
|
|
for &[x, y, z] in &proto.column.postprocess {
|
|
if let Some(list) = marks.get_mut(((y - MIN_Y) >> 4) as usize) {
|
|
list.push(Tag::Short(
|
|
((x & 15) | (y & 15) << 4 | (z & 15) << 8) as i16,
|
|
));
|
|
}
|
|
}
|
|
for (key, value) in [
|
|
("Status", string(status.name())),
|
|
("isLightOn", Tag::Byte(0)),
|
|
("block_entities", Tag::List(proto.block_entities.clone())),
|
|
("entities", Tag::List(proto.entities.clone())),
|
|
(
|
|
"PostProcessing",
|
|
Tag::List(marks.into_iter().map(Tag::List).collect()),
|
|
),
|
|
] {
|
|
put(&mut root.tag, key, value);
|
|
}
|
|
root
|
|
}
|
|
/// A proto chunk generation can resume: `terrain` (written to by a
|
|
/// neighbour's decoration) up to `spawn`. Earlier statuses hold nothing that
|
|
/// generating the chunk again doesn't reproduce.
|
|
pub fn decode_proto(
|
|
root: &NamedTag,
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
tables: Option<&SaveTables>,
|
|
) -> Option<SavedProto> {
|
|
let status = ChunkStatus::parse(&text(root.tag.get("Status"))?).ok()?;
|
|
if !(ChunkStatus::Terrain..ChunkStatus::Full).contains(&status) {
|
|
return None;
|
|
}
|
|
let mut column = decode_column(root, registry, biomes, tables)?;
|
|
column.block_entities.clear();
|
|
let base = number(root.tag.get("yPos")).map_or(MIN_Y, |y| y as i32 * 16);
|
|
if let Some(Tag::List(sections)) = root.tag.get("PostProcessing") {
|
|
for (si, marks) in sections.iter().enumerate() {
|
|
let Tag::List(marks) = marks else {
|
|
continue;
|
|
};
|
|
for mark in marks {
|
|
if let Tag::Short(p) = mark {
|
|
let p = i32::from(*p);
|
|
column.postprocess.push([
|
|
column.x * 16 + (p & 15),
|
|
base + si as i32 * 16 + ((p >> 4) & 15),
|
|
column.z * 16 + ((p >> 8) & 15),
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let list = |key: &str| match root.tag.get(key) {
|
|
Some(Tag::List(list)) => list.clone(),
|
|
_ => Vec::new(),
|
|
};
|
|
Some(SavedProto {
|
|
column,
|
|
decorated: status >= ChunkStatus::Features,
|
|
block_entities: list("block_entities"),
|
|
entities: list("entities"),
|
|
})
|
|
}
|
|
|
|
/// Read the stored `SkyLight`/`BlockLight` layers of a chunk saved with
|
|
/// `isLightOn` (`SerializableChunkData.read` + `ThreadedLevelLightEngine`),
|
|
/// so it needs no relighting. A missing sky layer repeats the bottom layer of
|
|
/// the section above it (15 above the highest stored one); a missing block
|
|
/// layer is dark.
|
|
pub fn load_light(tag: &Tag, chunk: &mut Chunk, sky_light: bool) {
|
|
if tag.get("isLightOn") != Some(&Tag::Byte(1)) {
|
|
return;
|
|
}
|
|
let Some(Tag::List(sections)) = tag.get("sections") else {
|
|
return;
|
|
};
|
|
let mut layers: Vec<(Option<&[u8]>, Option<&[u8]>)> = vec![(None, None); SECTIONS];
|
|
for section in sections {
|
|
let Some(y) = number(section.get("Y")) else {
|
|
continue;
|
|
};
|
|
let si = y as i32 - (MIN_Y >> 4);
|
|
if !(0..SECTIONS as i32).contains(&si) {
|
|
continue;
|
|
}
|
|
let layer = |name: &str| match section.get(name) {
|
|
Some(Tag::ByteArray(a)) if a.len() == 2048 => Some(&a[..]),
|
|
_ => None,
|
|
};
|
|
layers[si as usize] = (layer("SkyLight"), layer("BlockLight"));
|
|
}
|
|
// Uniform saved layers need no expanded allocation. Both nibbles of
|
|
// each byte must match, not merely the bytes across the layer.
|
|
let uniform_layer = |layer: &[u8]| {
|
|
let first = layer[0];
|
|
(first & 15 == first >> 4 && layer.iter().all(|&v| v == first)).then_some(first & 15)
|
|
};
|
|
let mut above = [if sky_light { 15 } else { 0 }; 256];
|
|
for (si, (sky, block)) in layers.into_iter().enumerate().rev() {
|
|
let sky = sky.filter(|_| sky_light);
|
|
let sky_uniform = sky.map_or_else(
|
|
|| above.iter().all(|&v| v == above[0]).then_some(above[0]),
|
|
uniform_layer,
|
|
);
|
|
let block_uniform = block.map_or(Some(0), uniform_layer);
|
|
let section = Arc::make_mut(&mut chunk.sections[si]);
|
|
if let (Some(s), Some(b)) = (sky_uniform, block_uniform) {
|
|
section.light = Light::Uniform(s << 4 | b);
|
|
above.fill(s);
|
|
} else {
|
|
let mut data = Box::new([0u8; 4096]);
|
|
match (sky, block) {
|
|
(Some(sky), Some(block)) => {
|
|
for ((pair, &s), &b) in
|
|
data.as_chunks_mut::<2>().0.iter_mut().zip(sky).zip(block)
|
|
{
|
|
pair[0] = s << 4 | (b & 15);
|
|
pair[1] = (s & 0xf0) | (b >> 4);
|
|
}
|
|
}
|
|
(Some(sky), None) => {
|
|
for (pair, &s) in data.as_chunks_mut::<2>().0.iter_mut().zip(sky) {
|
|
pair[0] = s << 4;
|
|
pair[1] = s & 0xf0;
|
|
}
|
|
}
|
|
(None, Some(block)) => {
|
|
for (i, (pair, &b)) in data
|
|
.as_chunks_mut::<2>()
|
|
.0
|
|
.iter_mut()
|
|
.zip(block)
|
|
.enumerate()
|
|
{
|
|
pair[0] = above[(i * 2) & 255] << 4 | (b & 15);
|
|
pair[1] = above[(i * 2 + 1) & 255] << 4 | (b >> 4);
|
|
}
|
|
}
|
|
(None, None) => {
|
|
for layer in data.as_chunks_mut::<256>().0 {
|
|
for (v, &s) in layer.iter_mut().zip(&above) {
|
|
*v = s << 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(sky) = sky {
|
|
for (pair, &s) in above.as_chunks_mut::<2>().0.iter_mut().zip(sky) {
|
|
pair[0] = s & 15;
|
|
pair[1] = s >> 4;
|
|
}
|
|
}
|
|
section.light = Light::Full(data);
|
|
}
|
|
section.compact();
|
|
}
|
|
chunk.lit = true;
|
|
chunk.light_loaded = true;
|
|
}
|
|
|
|
type RegionCache = Mutex<HashMap<(i32, i32), Option<Arc<Mutex<RegionFile>>>>>;
|
|
/// The region file at `path` through the cache, which readers and the writer
|
|
/// share, so a read never sees a header older than the sectors it points to.
|
|
/// `create` makes a missing file (for a write); otherwise a missing file is
|
|
/// `None`, until a write creates it.
|
|
fn cached_region(
|
|
cache: &RegionCache,
|
|
key: (i32, i32),
|
|
path: &Path,
|
|
create: bool,
|
|
) -> Result<Option<Arc<Mutex<RegionFile>>>> {
|
|
let mut regions = cache.lock().map_err(|_| "region cache poisoned")?;
|
|
if let Some(Some(region)) = regions.get(&key) {
|
|
return Ok(Some(region.clone()));
|
|
}
|
|
if !create && regions.contains_key(&key) {
|
|
return Ok(None);
|
|
}
|
|
if create && let Some(parent) = path.parent() {
|
|
fs::create_dir_all(parent)?;
|
|
}
|
|
// A file this process can't write (a read-only world) is still read.
|
|
let region = match RegionFile::open_writable(path, create) {
|
|
Err(e) if !create && e.kind() == std::io::ErrorKind::PermissionDenied => {
|
|
RegionFile::open(path)
|
|
}
|
|
other => other,
|
|
};
|
|
let region = match region {
|
|
Ok(r) => Some(Arc::new(Mutex::new(r))),
|
|
Err(_) if !create => None,
|
|
Err(e) => return Err(e.into()),
|
|
};
|
|
regions.insert(key, region.clone());
|
|
Ok(region)
|
|
}
|
|
/// Write `records` into the region files of `folder` in place, as vanilla's
|
|
/// `RegionFile.write` does: each chunk takes free sectors and the header
|
|
/// then points to it; the region's other chunks are not touched. `None`
|
|
/// clears a chunk. The chunks are encoded and compressed before their region
|
|
/// is locked for the writes (`compress_records`), and each region is flushed
|
|
/// to the disk once.
|
|
fn write_region_records(
|
|
root: &Path,
|
|
cache: &RegionCache,
|
|
folder: &str,
|
|
records: &[((i32, i32), &Record)],
|
|
) -> Result<()> {
|
|
let timestamp = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map_or(0, |d| d.as_secs() as u32);
|
|
let compressed = compress_records(records, timestamp);
|
|
let mut by_region: BTreeMap<(i32, i32), Vec<(ChunkPos, Option<ChunkRecord>)>> = BTreeMap::new();
|
|
for (&((x, z), _), record) in records.iter().zip(compressed) {
|
|
let record = record?;
|
|
by_region
|
|
.entry((x >> 5, z >> 5))
|
|
.or_default()
|
|
.push((ChunkPos::new(x, z), record));
|
|
}
|
|
for ((rx, rz), list) in by_region {
|
|
let path = region_path(root, folder, rx, rz);
|
|
// Clearing chunks of a region that doesn't exist changes nothing.
|
|
let create = list.iter().any(|(_, r)| r.is_some());
|
|
let Some(region) = cached_region(cache, (rx, rz), &path, create)? else {
|
|
continue;
|
|
};
|
|
let mut region = region.lock().map_err(|_| "region file poisoned")?;
|
|
let mut changed = false;
|
|
for (pos, record) in &list {
|
|
match record {
|
|
Some(record) => {
|
|
region.write(*pos, record)?;
|
|
changed = true;
|
|
}
|
|
None => changed |= region.clear(*pos, timestamp)?,
|
|
}
|
|
}
|
|
if changed {
|
|
region.sync()?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Fewest chunks each helper of `compress_records` takes: below this a thread
|
|
/// costs more to start than it saves.
|
|
const CHUNKS_PER_HELPER: usize = 4;
|
|
/// Each record encoded and compressed (`None` for a deletion), in the order
|
|
/// given. Vanilla's IOWorker does this one chunk after another; here a batch
|
|
/// is shared out to scoped threads, which take the next chunk as they finish
|
|
/// one. Each chunk's bytes depend only on the chunk, and the writes stay in
|
|
/// order, so the files are the same as from one thread. At most half the
|
|
/// hardware threads help, leaving the rest to the game and its workers.
|
|
fn compress_records(
|
|
records: &[((i32, i32), &Record)],
|
|
timestamp: u32,
|
|
) -> Vec<std::io::Result<Option<ChunkRecord>>> {
|
|
let compress = |record: &Record| {
|
|
record
|
|
.tag()
|
|
.map(|tag| ChunkRecord::from_nbt(&tag, Compression::Zlib, timestamp, Limits::default()))
|
|
.transpose()
|
|
};
|
|
let helpers = std::thread::available_parallelism()
|
|
.map_or(1, |n| n.get().div_ceil(2))
|
|
.min(records.len() / CHUNKS_PER_HELPER);
|
|
if helpers <= 1 {
|
|
return records.iter().map(|(_, r)| compress(r)).collect();
|
|
}
|
|
let next = std::sync::atomic::AtomicUsize::new(0);
|
|
let mut done: Vec<(usize, std::io::Result<Option<ChunkRecord>>)> =
|
|
std::thread::scope(|scope| {
|
|
let threads: Vec<_> = (0..helpers)
|
|
.map(|_| {
|
|
scope.spawn(|| {
|
|
let mut out = Vec::new();
|
|
loop {
|
|
let i = next.fetch_add(1, Ordering::Relaxed);
|
|
let Some((_, record)) = records.get(i) else {
|
|
return out;
|
|
};
|
|
out.push((i, compress(record)));
|
|
}
|
|
})
|
|
})
|
|
.collect();
|
|
threads
|
|
.into_iter()
|
|
.flat_map(|t| t.join().unwrap_or_else(|e| std::panic::resume_unwind(e)))
|
|
.collect()
|
|
});
|
|
done.sort_unstable_by_key(|(i, _)| *i);
|
|
done.into_iter().map(|(_, r)| r).collect()
|
|
}
|
|
|
|
fn region_path(root: &Path, folder: &str, rx: i32, rz: i32) -> PathBuf {
|
|
root.join(format!("{folder}/r.{rx}.{rz}.mca"))
|
|
}
|
|
|
|
/// A record waiting for the writer thread.
|
|
#[derive(Clone)]
|
|
enum Record {
|
|
Tag(Arc<NamedTag>),
|
|
/// A chunk to encode on the writer thread.
|
|
Chunk(Arc<Chunk>, Arc<Encoding>),
|
|
Delete,
|
|
}
|
|
/// What encoding a chunk needs, captured when it is queued.
|
|
struct Encoding {
|
|
registry: &'static BlockRegistry,
|
|
biomes: Arc<Biomes>,
|
|
tables: Option<Arc<SaveTables>>,
|
|
sky_light: bool,
|
|
}
|
|
impl Record {
|
|
fn tag(&self) -> Option<Arc<NamedTag>> {
|
|
match self {
|
|
Record::Tag(t) => Some(t.clone()),
|
|
Record::Chunk(c, e) => Some(Arc::new(encode_with(
|
|
c,
|
|
e.registry,
|
|
&e.biomes,
|
|
e.tables.as_deref(),
|
|
e.sky_light,
|
|
))),
|
|
Record::Delete => None,
|
|
}
|
|
}
|
|
}
|
|
/// Chunk and entity records waiting for the writer thread, by (entities?,
|
|
/// x, z): reads see them before the region files do.
|
|
type PendingWrites = Mutex<HashMap<(bool, i32, i32), (u64, Record)>>;
|
|
type WriteBatch = (bool, Vec<((i32, i32), Record, u64)>);
|
|
|
|
/// The background thread that encodes chunks and writes them into the region files, in
|
|
/// submission order.
|
|
struct Writer {
|
|
send: mpsc::Sender<WriteBatch>,
|
|
thread: std::thread::JoinHandle<()>,
|
|
}
|
|
|
|
/// Writes still queued or running, with a condition to wait for none.
|
|
#[derive(Default)]
|
|
struct Outstanding {
|
|
count: Mutex<usize>,
|
|
error: Mutex<Option<String>>,
|
|
done: Condvar,
|
|
}
|
|
/// One dimension folder (`dimensions/minecraft/<name>`). Region files are
|
|
/// read lazily by worker threads.
|
|
pub struct SaveDir {
|
|
pub root: PathBuf,
|
|
regions: Arc<RegionCache>,
|
|
entity_regions: Arc<RegionCache>,
|
|
pending: Arc<PendingWrites>,
|
|
sequence: AtomicU64,
|
|
writer: Mutex<Option<Writer>>,
|
|
outstanding: Arc<Outstanding>,
|
|
/// Set by `Persistent` before the first load.
|
|
pub tables: OnceLock<Arc<SaveTables>>,
|
|
/// False in dimensions without skylight (no SkyLight layers are written).
|
|
pub sky_light: bool,
|
|
}
|
|
impl SaveDir {
|
|
pub fn new(root: PathBuf) -> Self {
|
|
let sky_light = !root.ends_with("the_nether") && !root.ends_with("DIM-1");
|
|
Self {
|
|
root,
|
|
regions: Default::default(),
|
|
entity_regions: Default::default(),
|
|
pending: Default::default(),
|
|
sequence: AtomicU64::new(0),
|
|
writer: Mutex::new(None),
|
|
outstanding: Default::default(),
|
|
tables: OnceLock::new(),
|
|
sky_light,
|
|
}
|
|
}
|
|
fn region_path(&self, folder: &str, rx: i32, rz: i32) -> PathBuf {
|
|
region_path(&self.root, folder, rx, rz)
|
|
}
|
|
fn read_record(&self, folder: &str, x: i32, z: i32) -> Option<NamedTag> {
|
|
let pending = self
|
|
.pending
|
|
.lock()
|
|
.ok()?
|
|
.get(&(folder != "region", x, z))
|
|
.map(|(_, r)| r.clone());
|
|
if let Some(record) = pending {
|
|
return record.tag().map(|t| (*t).clone());
|
|
}
|
|
let key = (x >> 5, z >> 5);
|
|
let cache = if folder == "region" {
|
|
&self.regions
|
|
} else {
|
|
&self.entity_regions
|
|
};
|
|
let path = self.region_path(folder, key.0, key.1);
|
|
let region = cached_region(cache, key, &path, false).ok()??;
|
|
let record = region.lock().ok()?.read(ChunkPos::new(x, z)).ok()??;
|
|
record.nbt(Limits::default()).ok()
|
|
}
|
|
pub fn load(&self, x: i32, z: i32, registry: &BlockRegistry, biomes: &Biomes) -> Option<Chunk> {
|
|
let root = self.read_record("region", x, z)?;
|
|
let tables = self.tables.get().map(|t| &**t);
|
|
let mut chunk = decode_with(&root, registry, biomes, tables)?;
|
|
load_light(&root.tag, &mut chunk, self.sky_light);
|
|
Some(chunk)
|
|
}
|
|
/// A proto chunk saved before it became final (`decode_proto`).
|
|
pub fn load_proto(
|
|
&self,
|
|
x: i32,
|
|
z: i32,
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
) -> Option<SavedProto> {
|
|
let root = self.read_record("region", x, z)?;
|
|
decode_proto(&root, registry, biomes, self.tables.get().map(|t| &**t))
|
|
}
|
|
/// Queue proto chunks for the writer thread; loads see them meanwhile.
|
|
pub fn save_protos(
|
|
&self,
|
|
protos: &[SavedProto],
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
) -> Result<()> {
|
|
let tables = self.tables.get().map(|t| &**t);
|
|
let records = protos
|
|
.iter()
|
|
.map(|p| {
|
|
let tag = encode_proto(p, registry, biomes, tables, self.sky_light);
|
|
((p.column.x, p.column.z), Some(tag))
|
|
})
|
|
.collect();
|
|
self.write_records("region", records, false)
|
|
}
|
|
/// Entities saved for a chunk (`entities/`; older chunks may still keep
|
|
/// them in the chunk's own `entities` list).
|
|
pub fn load_entities(&self, x: i32, z: i32) -> Vec<Tag> {
|
|
let mut out = Vec::new();
|
|
if let Some(root) = self.read_record("entities", x, z)
|
|
&& let Some(Tag::List(list)) = root.tag.get("Entities")
|
|
{
|
|
out.extend(list.iter().cloned());
|
|
}
|
|
out
|
|
}
|
|
/// Queue `records` for the writer thread; with `wait`, return once
|
|
/// they and every earlier write are on disk.
|
|
fn write_records(
|
|
&self,
|
|
folder: &str,
|
|
records: Vec<((i32, i32), Option<NamedTag>)>,
|
|
wait: bool,
|
|
) -> Result<()> {
|
|
let records = records
|
|
.into_iter()
|
|
.map(|(k, t)| (k, t.map_or(Record::Delete, |t| Record::Tag(Arc::new(t)))))
|
|
.collect();
|
|
self.queue(folder != "region", records, wait)
|
|
}
|
|
fn queue(&self, entities: bool, records: Vec<((i32, i32), Record)>, wait: bool) -> Result<()> {
|
|
if !records.is_empty() {
|
|
let mut batch = Vec::with_capacity(records.len());
|
|
{
|
|
let mut pending = self.pending.lock().map_err(|_| "pending writes poisoned")?;
|
|
for (key, record) in records {
|
|
let seq = self.sequence.fetch_add(1, Ordering::Relaxed);
|
|
pending.insert((entities, key.0, key.1), (seq, record.clone()));
|
|
batch.push((key, record, seq));
|
|
}
|
|
}
|
|
*self
|
|
.outstanding
|
|
.count
|
|
.lock()
|
|
.map_err(|_| "writer poisoned")? += 1;
|
|
let mut writer = self.writer.lock().map_err(|_| "writer poisoned")?;
|
|
let writer = writer.get_or_insert_with(|| self.start_writer());
|
|
if writer.send.send((entities, batch)).is_err() {
|
|
*self
|
|
.outstanding
|
|
.error
|
|
.lock()
|
|
.map_err(|_| "writer poisoned")? = Some("the region writer stopped".into());
|
|
*self
|
|
.outstanding
|
|
.count
|
|
.lock()
|
|
.map_err(|_| "writer poisoned")? -= 1;
|
|
self.outstanding.done.notify_all();
|
|
return Err("the region writer stopped".into());
|
|
}
|
|
}
|
|
if wait {
|
|
self.flush()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
fn start_writer(&self) -> Writer {
|
|
let (send, receive) = mpsc::channel::<WriteBatch>();
|
|
let root = self.root.clone();
|
|
let (regions, entity_regions) = (self.regions.clone(), self.entity_regions.clone());
|
|
let pending = self.pending.clone();
|
|
let outstanding = self.outstanding.clone();
|
|
let thread = std::thread::Builder::new()
|
|
.name("horizon-region-writer".into())
|
|
.spawn(move || {
|
|
for (entities, batch) in receive {
|
|
let (folder, cache) = if entities {
|
|
("entities", &entity_regions)
|
|
} else {
|
|
("region", ®ions)
|
|
};
|
|
// IOWorker.pendingWrites: a chunk queued again since is
|
|
// written once, by its newest batch.
|
|
let newest = |k: &(i32, i32), seq: u64| {
|
|
pending.lock().map_or(true, |p| {
|
|
p.get(&(entities, k.0, k.1)).is_none_or(|p| p.0 <= seq)
|
|
})
|
|
};
|
|
let records: Vec<_> = batch
|
|
.iter()
|
|
.filter(|(k, _, seq)| newest(k, *seq))
|
|
.map(|(k, r, _)| (*k, r))
|
|
.collect();
|
|
let result = write_region_records(&root, cache, folder, &records);
|
|
if let Err(e) = &result {
|
|
let message = format!("failed to write {folder} files: {e}");
|
|
log::warn!("Horizon: {message}");
|
|
*outstanding.error.lock().unwrap() = Some(message);
|
|
}
|
|
// Keep failed snapshots readable; never report them as durable.
|
|
if result.is_ok()
|
|
&& let Ok(mut pending) = pending.lock()
|
|
{
|
|
for (k, _, seq) in &batch {
|
|
if pending
|
|
.get(&(entities, k.0, k.1))
|
|
.is_some_and(|p| p.0 == *seq)
|
|
{
|
|
pending.remove(&(entities, k.0, k.1));
|
|
}
|
|
}
|
|
}
|
|
if let Ok(mut count) = outstanding.count.lock() {
|
|
*count -= 1;
|
|
outstanding.done.notify_all();
|
|
}
|
|
}
|
|
})
|
|
.expect("spawn region writer");
|
|
Writer { send, thread }
|
|
}
|
|
/// Wait until every queued write is on disk.
|
|
pub fn flush(&self) -> Result<()> {
|
|
let mut count = self
|
|
.outstanding
|
|
.count
|
|
.lock()
|
|
.map_err(|_| "writer poisoned")?;
|
|
while *count > 0 {
|
|
count = self
|
|
.outstanding
|
|
.done
|
|
.wait(count)
|
|
.map_err(|_| "writer poisoned")?;
|
|
}
|
|
self.write_result()
|
|
}
|
|
/// Poll durability without holding up the event loop. Errors remain visible
|
|
/// to every waiter, including a later synchronous shutdown.
|
|
pub fn writes_finished(&self) -> Result<bool> {
|
|
let count = self
|
|
.outstanding
|
|
.count
|
|
.lock()
|
|
.map_err(|_| "writer poisoned")?;
|
|
self.write_result()?;
|
|
Ok(*count == 0)
|
|
}
|
|
fn write_result(&self) -> Result<()> {
|
|
match &*self
|
|
.outstanding
|
|
.error
|
|
.lock()
|
|
.map_err(|_| "writer poisoned")?
|
|
{
|
|
Some(error) => Err(error.clone().into()),
|
|
None => Ok(()),
|
|
}
|
|
}
|
|
/// Write `chunks` into their region files and wait until they are on disk.
|
|
pub fn save(
|
|
&self,
|
|
chunks: &[Arc<Chunk>],
|
|
registry: &BlockRegistry,
|
|
biomes: &Biomes,
|
|
) -> Result<usize> {
|
|
let tables = self.tables.get().map(|t| &**t);
|
|
let records = chunks
|
|
.iter()
|
|
.map(|c| {
|
|
(
|
|
(c.x, c.z),
|
|
Some(encode_with(c, registry, biomes, tables, self.sky_light)),
|
|
)
|
|
})
|
|
.collect();
|
|
self.write_records("region", records, true)?;
|
|
Ok(chunks.len())
|
|
}
|
|
/// `save` on the writer thread: returns before the files are written;
|
|
/// loads see the chunks meanwhile.
|
|
pub fn save_later(
|
|
&self,
|
|
chunks: &[Arc<Chunk>],
|
|
registry: &'static BlockRegistry,
|
|
biomes: &Arc<Biomes>,
|
|
) -> Result<usize> {
|
|
let encoding = Arc::new(Encoding {
|
|
registry,
|
|
biomes: biomes.clone(),
|
|
tables: self.tables.get().cloned(),
|
|
sky_light: self.sky_light,
|
|
});
|
|
let records = chunks
|
|
.iter()
|
|
.map(|c| ((c.x, c.z), Record::Chunk(c.clone(), encoding.clone())))
|
|
.collect();
|
|
self.queue(false, records, false)?;
|
|
Ok(chunks.len())
|
|
}
|
|
/// Write the entity chunks (`EntityStorage`): an empty list deletes it.
|
|
pub fn save_entities(&self, chunks: Vec<((i32, i32), Vec<Tag>)>) -> Result<()> {
|
|
self.write_entities(chunks, true)
|
|
}
|
|
/// `save_entities` on the writer thread.
|
|
pub fn save_entities_later(&self, chunks: Vec<((i32, i32), Vec<Tag>)>) -> Result<()> {
|
|
self.write_entities(chunks, false)
|
|
}
|
|
fn write_entities(&self, chunks: Vec<((i32, i32), Vec<Tag>)>, wait: bool) -> Result<()> {
|
|
let records = chunks
|
|
.into_iter()
|
|
.map(|((x, z), entities)| {
|
|
let tag = (!entities.is_empty()).then(|| NamedTag {
|
|
name: "".into(),
|
|
tag: Tag::compound([
|
|
("DataVersion", Tag::Int(DATA_VERSION)),
|
|
("Position", Tag::IntArray(vec![x, z])),
|
|
("Entities", Tag::List(entities)),
|
|
]),
|
|
});
|
|
((x, z), tag)
|
|
})
|
|
.collect();
|
|
self.write_records("entities", records, wait)
|
|
}
|
|
}
|
|
|
|
impl Drop for SaveDir {
|
|
/// Finish queued writes before the world is let go.
|
|
fn drop(&mut self) {
|
|
if let Some(writer) = self.writer.get_mut().ok().and_then(Option::take) {
|
|
drop(writer.send);
|
|
let _ = writer.thread.join();
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn read_dat(path: &Path) -> Option<Tag> {
|
|
let bytes = fs::read(path).ok()?;
|
|
let raw = match Compression::Gzip.decode(&bytes, 64 << 20) {
|
|
Ok(raw) => raw,
|
|
Err(_) => bytes,
|
|
};
|
|
Some(nbt::read_named(&raw, Limits::default()).ok()?.0.tag)
|
|
}
|
|
/// Write a gzip NBT file the way vanilla does (`<name>_new`, keep `_old`).
|
|
pub fn write_dat(path: &Path, tag: Tag) -> Result<()> {
|
|
if let Some(dir) = path.parent() {
|
|
fs::create_dir_all(dir)?;
|
|
}
|
|
let bytes = nbt::write_named(
|
|
&NamedTag {
|
|
name: "".into(),
|
|
tag,
|
|
},
|
|
Limits::default(),
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let compressed = Compression::Gzip.encode(&bytes)?;
|
|
let file = path
|
|
.file_name()
|
|
.and_then(|n| n.to_str())
|
|
.unwrap_or("data.dat");
|
|
let temporary = path.with_file_name(format!("{file}_new"));
|
|
fs::write(&temporary, compressed)?;
|
|
if path.exists() {
|
|
let old = match file.strip_suffix(".dat") {
|
|
Some(stem) => path.with_file_name(format!("{stem}.dat_old")),
|
|
None => path.with_file_name(format!("{file}_old")),
|
|
};
|
|
// Util.safeReplaceFile: no backup, no replacement.
|
|
fs::rename(path, old).map_err(|e| format!("{}: {e}", path.display()))?;
|
|
}
|
|
fs::rename(temporary, path)?;
|
|
Ok(())
|
|
}
|
|
/// `SavedDataStorage`: `{data: ..., DataVersion}` under `data/minecraft/`.
|
|
fn saved_data_path(world: &Path, name: &str) -> PathBuf {
|
|
world
|
|
.join("data")
|
|
.join("minecraft")
|
|
.join(format!("{name}.dat"))
|
|
}
|
|
fn read_saved_data(world: &Path, name: &str) -> Option<Tag> {
|
|
read_dat(&saved_data_path(world, name))?
|
|
.get("data")
|
|
.cloned()
|
|
}
|
|
/// The world's generator settings: world_gen_settings.dat (26.3) or
|
|
/// level.dat's Data.WorldGenSettings.
|
|
pub fn world_gen_settings(world: &Path) -> Option<Tag> {
|
|
read_saved_data(world, "world_gen_settings").or_else(|| {
|
|
read_dat(&world.join("level.dat"))?
|
|
.get("Data")?
|
|
.get("WorldGenSettings")
|
|
.cloned()
|
|
})
|
|
}
|
|
fn write_saved_data(world: &Path, name: &str, data: Tag) -> Result<()> {
|
|
write_dat(
|
|
&saved_data_path(world, name),
|
|
Tag::compound([("data", data), ("DataVersion", Tag::Int(DATA_VERSION))]),
|
|
)
|
|
}
|
|
pub fn uuid_text(u: [i32; 4]) -> String {
|
|
let hex: String = u.iter().map(|v| format!("{:08x}", *v as u32)).collect();
|
|
format!(
|
|
"{}-{}-{}-{}-{}",
|
|
&hex[0..8],
|
|
&hex[8..12],
|
|
&hex[12..16],
|
|
&hex[16..20],
|
|
&hex[20..32]
|
|
)
|
|
}
|
|
pub fn uuid_from_text(s: &str) -> Option<[i32; 4]> {
|
|
let hex: String = s.chars().filter(|c| *c != '-').collect();
|
|
if hex.len() != 32 {
|
|
return None;
|
|
}
|
|
let mut out = [0i32; 4];
|
|
for (i, v) in out.iter_mut().enumerate() {
|
|
*v = u32::from_str_radix(&hex[i * 8..i * 8 + 8], 16).ok()? as i32;
|
|
}
|
|
Some(out)
|
|
}
|
|
/// A random (version 4) UUID as vanilla's four-int form.
|
|
pub fn random_uuid() -> [i32; 4] {
|
|
let t = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map_or(0, |d| d.as_nanos() as u64);
|
|
let mut s = t ^ (std::process::id() as u64).rotate_left(32) ^ 0x9E37_79B9_7F4A_7C15;
|
|
let mut next = || {
|
|
s ^= s << 13;
|
|
s ^= s >> 7;
|
|
s ^= s << 17;
|
|
s
|
|
};
|
|
let (a, b) = (next(), next());
|
|
let a = (a & !0xF000) | 0x4000;
|
|
let b = (b & !(0xC000_0000_0000_0000)) | 0x8000_0000_0000_0000;
|
|
[(a >> 32) as i32, a as i32, (b >> 32) as i32, b as i32]
|
|
}
|
|
pub(crate) fn uuid_tag(u: [i32; 4]) -> Tag {
|
|
Tag::IntArray(u.to_vec())
|
|
}
|
|
pub(crate) fn uuid_from_tag(tag: Option<&Tag>) -> Option<[i32; 4]> {
|
|
match tag? {
|
|
Tag::IntArray(v) if v.len() == 4 => Some([v[0], v[1], v[2], v[3]]),
|
|
Tag::String(s) => uuid_from_text(&s.to_string_lossy()),
|
|
_ => None,
|
|
}
|
|
}
|
|
pub(crate) fn doubles(values: &[f64]) -> Tag {
|
|
Tag::List(values.iter().map(|v| Tag::Double(v.to_bits())).collect())
|
|
}
|
|
pub(crate) fn floats(values: &[f32]) -> Tag {
|
|
Tag::List(values.iter().map(|v| Tag::Float(v.to_bits())).collect())
|
|
}
|
|
pub(crate) fn read_doubles<const N: usize>(tag: Option<&Tag>) -> Option<[f64; N]> {
|
|
match tag? {
|
|
Tag::List(l) if l.len() == N => {
|
|
let mut out = [0.0; N];
|
|
for (o, v) in out.iter_mut().zip(l) {
|
|
*o = float(Some(v))?;
|
|
}
|
|
Some(out)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Default game rules of a new 26.3 world (`data/minecraft/game_rules.dat`).
|
|
const GAME_RULES: [(&str, i32); 58] = [
|
|
("spawn_wandering_traders", 1),
|
|
("block_drops", 1),
|
|
("reduced_debug_info", 0),
|
|
("show_death_messages", 1),
|
|
("spawner_blocks_work", 1),
|
|
("spawn_monsters", 1),
|
|
("tnt_explodes", 1),
|
|
("player_movement_check", 1),
|
|
("immediate_respawn", 0),
|
|
("block_explosion_drop_decay", 1),
|
|
("spread_vines", 1),
|
|
("max_entity_cramming", 24),
|
|
("forgive_dead_players", 1),
|
|
("fall_damage", 1),
|
|
("send_command_feedback", 1),
|
|
("global_sound_events", 1),
|
|
("elytra_movement_check", 1),
|
|
("fire_spread_radius_around_player", 128),
|
|
("freeze_damage", 1),
|
|
("mob_explosion_drop_decay", 1),
|
|
("natural_health_regeneration", 1),
|
|
("players_nether_portal_default_delay", 80),
|
|
("mob_drops", 1),
|
|
("log_admin_commands", 1),
|
|
("mob_griefing", 1),
|
|
("spawn_mobs", 1),
|
|
("pvp", 1),
|
|
("spectators_generate_chunks", 1),
|
|
("max_command_sequence_length", 65536),
|
|
("players_nether_portal_creative_delay", 0),
|
|
("players_sleeping_percentage", 100),
|
|
("advance_weather", 1),
|
|
("max_block_modifications", 32768),
|
|
("max_command_forks", 65536),
|
|
("drowning_damage", 1),
|
|
("command_block_output", 1),
|
|
("locator_bar", 1),
|
|
("show_advancement_messages", 1),
|
|
("respawn_radius", 10),
|
|
("raids", 1),
|
|
("spawn_phantoms", 1),
|
|
("max_snow_accumulation_height", 1),
|
|
("limited_crafting", 0),
|
|
("allow_entering_nether_using_portals", 1),
|
|
("lava_source_conversion", 0),
|
|
("tnt_explosion_drop_decay", 0),
|
|
("universal_anger", 0),
|
|
("keep_inventory", 0),
|
|
("spawn_patrols", 1),
|
|
("random_tick_speed", 3),
|
|
("fire_damage", 1),
|
|
("entity_drops", 1),
|
|
("advance_time", 1),
|
|
("command_blocks_work", 1),
|
|
("spawn_wardens", 1),
|
|
("water_source_conversion", 1),
|
|
("projectiles_can_break_blocks", 1),
|
|
("ender_pearls_vanish_on_death", 1),
|
|
];
|
|
/// Integer-valued rules; the others are booleans stored as bytes.
|
|
const INT_RULES: [&str; 11] = [
|
|
"max_snow_accumulation_height",
|
|
"random_tick_speed",
|
|
"max_entity_cramming",
|
|
"fire_spread_radius_around_player",
|
|
"players_nether_portal_default_delay",
|
|
"max_command_sequence_length",
|
|
"players_nether_portal_creative_delay",
|
|
"players_sleeping_percentage",
|
|
"max_block_modifications",
|
|
"max_command_forks",
|
|
"respawn_radius",
|
|
];
|
|
|
|
/// World and player state stored in `level.dat`, the saved-data files and
|
|
/// the player file.
|
|
/// The world options CreateWorldScreen sets (`WorldOptions` and the world
|
|
/// preset) that `world_gen_settings` keeps.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub struct WorldGen {
|
|
/// The `minecraft:flat` preset (Superflat) instead of `normal`.
|
|
pub flat: bool,
|
|
pub structures: bool,
|
|
pub bonus_chest: bool,
|
|
}
|
|
impl WorldGen {
|
|
/// A saved world's choices, from its `world_gen_settings`.
|
|
pub fn read(world: &Path) -> Option<Self> {
|
|
let settings = world_gen_settings(world)?;
|
|
let flag = |key: &str, default: bool| number(settings.get(key)).map_or(default, |v| v != 0);
|
|
let generator = settings
|
|
.get("dimensions")
|
|
.and_then(|d| d.get("minecraft:overworld"))
|
|
.and_then(|o| o.get("generator"));
|
|
Some(Self {
|
|
flat: text(generator.and_then(|g| g.get("type")))
|
|
.is_some_and(|t| t.trim_start_matches("minecraft:") == "flat"),
|
|
structures: flag("generate_structures", true),
|
|
bonus_chest: flag("bonus_chest", false),
|
|
})
|
|
}
|
|
}
|
|
impl Default for WorldGen {
|
|
fn default() -> Self {
|
|
Self {
|
|
flat: false,
|
|
structures: true,
|
|
bonus_chest: false,
|
|
}
|
|
}
|
|
}
|
|
/// Writes a new world's `world_gen_settings` (seed, options and dimensions).
|
|
pub fn write_world_gen_settings(dir: &Path, seed: i64, options: WorldGen) -> Result<()> {
|
|
write_world_gen_settings_with(dir, seed, options, None)
|
|
}
|
|
/// [`write_world_gen_settings`] with a flat overworld's own generator
|
|
/// settings (FlatLevelGeneratorSettings, as `flatgen::settings_from_json`
|
|
/// reads them) instead of the Superflat preset's classic layers.
|
|
pub fn write_world_gen_settings_with(
|
|
dir: &Path,
|
|
seed: i64,
|
|
options: WorldGen,
|
|
flat_settings: Option<Tag>,
|
|
) -> Result<()> {
|
|
fs::create_dir_all(dir)?;
|
|
// worldgen/world_preset/flat.json's overworld: the classic flat layers.
|
|
let layer = |block: &str, height: i32| {
|
|
Tag::compound([("block", string(block)), ("height", Tag::Int(height))])
|
|
};
|
|
let classic = || {
|
|
Tag::compound([
|
|
("biome", string("minecraft:plains")),
|
|
("features", Tag::Byte(0)),
|
|
("lakes", Tag::Byte(0)),
|
|
(
|
|
"layers",
|
|
Tag::List(vec![
|
|
layer("minecraft:bedrock", 1),
|
|
layer("minecraft:dirt", 2),
|
|
layer("minecraft:grass_block", 1),
|
|
]),
|
|
),
|
|
(
|
|
"structure_overrides",
|
|
Tag::List(vec![
|
|
string("minecraft:strongholds"),
|
|
string("minecraft:villages"),
|
|
]),
|
|
),
|
|
])
|
|
};
|
|
let flat = Tag::compound([
|
|
("type", string("minecraft:overworld")),
|
|
(
|
|
"generator",
|
|
Tag::compound([
|
|
("type", string("minecraft:flat")),
|
|
("settings", flat_settings.unwrap_or_else(classic)),
|
|
]),
|
|
),
|
|
]);
|
|
let dimension = |kind: &str, settings: &str, source: Tag| {
|
|
Tag::compound([
|
|
("type", string(kind)),
|
|
(
|
|
"generator",
|
|
Tag::compound([
|
|
("type", string("minecraft:noise")),
|
|
("settings", string(settings)),
|
|
("biome_source", source),
|
|
]),
|
|
),
|
|
])
|
|
};
|
|
let preset = |p: &str| {
|
|
Tag::compound([
|
|
("type", string("minecraft:multi_noise")),
|
|
("preset", string(p)),
|
|
])
|
|
};
|
|
write_saved_data(
|
|
dir,
|
|
"world_gen_settings",
|
|
Tag::compound([
|
|
("seed", Tag::Long(seed)),
|
|
(
|
|
"generate_structures",
|
|
Tag::Byte(i8::from(options.structures)),
|
|
),
|
|
("bonus_chest", Tag::Byte(i8::from(options.bonus_chest))),
|
|
(
|
|
"dimensions",
|
|
Tag::compound([
|
|
(
|
|
"minecraft:overworld",
|
|
if options.flat {
|
|
flat
|
|
} else {
|
|
dimension(
|
|
"minecraft:overworld",
|
|
"minecraft:overworld",
|
|
preset("minecraft:overworld"),
|
|
)
|
|
},
|
|
),
|
|
(
|
|
"minecraft:the_nether",
|
|
dimension(
|
|
"minecraft:the_nether",
|
|
"minecraft:nether",
|
|
preset("minecraft:nether"),
|
|
),
|
|
),
|
|
(
|
|
"minecraft:the_end",
|
|
dimension(
|
|
"minecraft:the_end",
|
|
"minecraft:end",
|
|
Tag::compound([("type", string("minecraft:the_end"))]),
|
|
),
|
|
),
|
|
]),
|
|
),
|
|
]),
|
|
)
|
|
}
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct Level {
|
|
pub name: String,
|
|
pub seed: i64,
|
|
pub creative: bool,
|
|
/// The game mode id (0 survival, 1 creative, 2 adventure, 3 spectator);
|
|
/// `creative` wins when the two disagree.
|
|
pub game_mode: i32,
|
|
pub time: i64,
|
|
pub day_time: i64,
|
|
/// Where the player respawns when it has no bed or anchor: its forced
|
|
/// Overworld point (`spawnpoint`), or the world spawn.
|
|
pub spawn: Option<[f64; 3]>,
|
|
/// A respawn point resolved through its block when the player respawns
|
|
/// (a bed, a respawn anchor, a forced point outside the Overworld):
|
|
/// dimension, block, yaw and `forced`.
|
|
pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>,
|
|
pub position: Option<[f64; 3]>,
|
|
pub rotation: [f32; 2],
|
|
pub health: f32,
|
|
/// LivingEntity `AbsorptionAmount`: the golden hearts left.
|
|
pub absorption: f32,
|
|
pub food: i32,
|
|
pub saturation: f32,
|
|
/// (slot, item, count, damage): 0..36 inventory, 100..103 armor (feet..head), 150 offhand.
|
|
pub inventory: Vec<(u8, String, u32, u32)>,
|
|
/// Extra item components of `inventory` entries, by slot.
|
|
pub inventory_components: HashMap<u8, Box<crate::item_data::StackData>>,
|
|
/// Player.XpSeed: the enchanting table seed.
|
|
pub xp_seed: i32,
|
|
/// ServerPlayer.seenCredits: the end poem has been shown.
|
|
pub seen_credits: bool,
|
|
/// Player.active_effects: (id, duration, amplifier, ambient, show_icon).
|
|
pub active_effects: Vec<(String, i32, i32, bool, bool)>,
|
|
/// Player.EnderItems: the ender chest inventory (27 slots).
|
|
pub ender_items: Vec<Option<crate::items::ItemStack>>,
|
|
/// The `recipeBook` compound: open/filter settings and unlocked recipes.
|
|
pub recipe_book: crate::recipe_book::Settings,
|
|
pub xp_level: i32,
|
|
pub xp_progress: f32,
|
|
pub xp_total: i32,
|
|
pub weather: crate::world::Weather,
|
|
/// Player.Dimension (minecraft:overworld / minecraft:the_nether).
|
|
pub dimension: String,
|
|
/// World spawn (`level.dat` `spawn`), distinct from a bed respawn point.
|
|
pub world_spawn: Option<[i32; 3]>,
|
|
/// The world spawn's yaw and pitch (`setworldspawn`'s rotation).
|
|
pub world_spawn_angle: [f32; 2],
|
|
pub difficulty: String,
|
|
pub hardcore: bool,
|
|
/// `difficulty_settings.locked` (LevelData.isDifficultyLocked).
|
|
pub difficulty_locked: bool,
|
|
/// `allowCommands`: read from `level.dat` or chosen on the Create New
|
|
/// World screen; unset is written as off.
|
|
pub allow_commands: Option<bool>,
|
|
/// Game rule values by name without namespace (`keep_inventory`, ...).
|
|
pub game_rules: BTreeMap<String, i32>,
|
|
pub player_uuid: Option<[i32; 4]>,
|
|
pub selected_slot: i32,
|
|
pub motion: [f64; 3],
|
|
pub fall_distance: f64,
|
|
pub on_ground: bool,
|
|
pub food_exhaustion: f32,
|
|
pub food_tick_timer: i32,
|
|
/// Abilities.flying: whether creative/spectator flight is active.
|
|
pub flying: bool,
|
|
/// The player compound as loaded, for fields Horizon does not model
|
|
/// (ender chest, effects, abilities, recipe book, attributes, ...).
|
|
pub player_extra: Option<Tag>,
|
|
}
|
|
impl Level {
|
|
/// Initialize the offline single-player identity before saving or dropping items.
|
|
pub fn ensure_player_uuid(&mut self) -> [i32; 4] {
|
|
*self.player_uuid.get_or_insert_with(|| {
|
|
let u = horizon_protocol::crypto::offline_uuid("Player");
|
|
[
|
|
(u >> 96) as u32 as i32,
|
|
(u >> 64) as u32 as i32,
|
|
(u >> 32) as u32 as i32,
|
|
u as u32 as i32,
|
|
]
|
|
})
|
|
}
|
|
pub fn game_rule(&self, name: &str) -> i32 {
|
|
self.game_rules
|
|
.get(name)
|
|
.copied()
|
|
.or_else(|| GAME_RULES.iter().find(|(n, _)| *n == name).map(|(_, v)| *v))
|
|
.unwrap_or(0)
|
|
}
|
|
/// The saved game mode id.
|
|
pub fn mode(&self) -> i32 {
|
|
match (self.creative, self.game_mode) {
|
|
(true, _) => 1,
|
|
(false, 1) => 0,
|
|
(false, m) => m.clamp(0, 3),
|
|
}
|
|
}
|
|
pub fn read(dir: &Path) -> Option<Self> {
|
|
let root = read_dat(&dir.join("level.dat"))?;
|
|
let data = root.get("Data")?;
|
|
let n = |t: Option<&Tag>| number(t).unwrap_or(0);
|
|
let mut level = Self {
|
|
name: text(data.get("LevelName")).unwrap_or_else(|| "World".into()),
|
|
creative: n(data.get("GameType")) == 1,
|
|
game_mode: n(data.get("GameType")) as i32,
|
|
time: n(data.get("Time")),
|
|
health: 20.0,
|
|
food: 20,
|
|
saturation: 5.0,
|
|
dimension: "minecraft:overworld".into(),
|
|
difficulty: "normal".into(),
|
|
..Self::default()
|
|
};
|
|
// 26.3: spawn {pos: [I; x, y, z], dimension, yaw, pitch}; older: SpawnX/Y/Z.
|
|
level.world_spawn = match data.get("spawn").and_then(|s| s.get("pos")) {
|
|
Some(Tag::IntArray(p)) if p.len() == 3 => Some([p[0], p[1], p[2]]),
|
|
_ => data.get("SpawnX").map(|_| {
|
|
[
|
|
n(data.get("SpawnX")) as i32,
|
|
n(data.get("SpawnY")) as i32,
|
|
n(data.get("SpawnZ")) as i32,
|
|
]
|
|
}),
|
|
};
|
|
let angle = |k: &str| match data.get("spawn").and_then(|s| s.get(k)) {
|
|
Some(Tag::Float(b)) => f32::from_bits(*b),
|
|
_ => 0.0,
|
|
};
|
|
level.world_spawn_angle = [angle("yaw"), angle("pitch")];
|
|
if let Some(d) = data.get("difficulty_settings") {
|
|
level.difficulty = text(d.get("difficulty")).unwrap_or_else(|| "normal".into());
|
|
level.hardcore = n(d.get("hardcore")) != 0;
|
|
level.difficulty_locked = n(d.get("locked")) != 0;
|
|
}
|
|
level.allow_commands = Some(n(data.get("allowCommands")) != 0);
|
|
let mut rules: BTreeMap<String, i32> = GAME_RULES
|
|
.iter()
|
|
.map(|(k, v)| ((*k).to_owned(), *v))
|
|
.collect();
|
|
let saved_rules = read_saved_data(dir, "game_rules");
|
|
if let Some(Tag::Compound(map)) = &saved_rules {
|
|
for (k, v) in map {
|
|
let name = k.to_string_lossy();
|
|
let name = name.strip_prefix("minecraft:").unwrap_or(&name).to_owned();
|
|
if let Some(v) = number(Some(v)) {
|
|
rules.insert(name, v as i32);
|
|
}
|
|
}
|
|
}
|
|
level.game_rules = rules;
|
|
// Seed: world_gen_settings.dat (26.3) or Data.WorldGenSettings.
|
|
level.seed = read_saved_data(dir, "world_gen_settings")
|
|
.and_then(|w| number(w.get("seed")))
|
|
.or_else(|| number(data.get("WorldGenSettings").and_then(|w| w.get("seed"))))
|
|
.unwrap_or(0);
|
|
// Day time: the overworld clock (26.3) or Data.DayTime.
|
|
level.day_time = read_saved_data(dir, "world_clocks")
|
|
.and_then(|c| {
|
|
number(
|
|
c.get("minecraft:overworld")
|
|
.and_then(|o| o.get("total_ticks")),
|
|
)
|
|
})
|
|
.or_else(|| number(data.get("DayTime")))
|
|
.unwrap_or(level.time);
|
|
let weather = read_saved_data(dir, "weather");
|
|
let w = |new: &str, old: &str| {
|
|
number(weather.as_ref().and_then(|w| w.get(new)))
|
|
.or_else(|| number(data.get(old)))
|
|
.unwrap_or(0)
|
|
};
|
|
let raining = w("raining", "raining") != 0;
|
|
let thundering = w("thundering", "thundering") != 0;
|
|
level.weather = crate::world::Weather {
|
|
clear_time: w("clear_weather_time", "clearWeatherTime") as i32,
|
|
rain_time: w("rain_time", "rainTime") as i32,
|
|
thunder_time: w("thunder_time", "thunderTime") as i32,
|
|
raining,
|
|
thundering,
|
|
rain_level: if raining { (1.0, 1.0) } else { (0.0, 0.0) },
|
|
thunder_level: if thundering { (1.0, 1.0) } else { (0.0, 0.0) },
|
|
};
|
|
// The player: players/data/<singleplayer_uuid>.dat, the newest player
|
|
// file of a server world, or the legacy Data.Player.
|
|
let uuid = uuid_from_tag(data.get("singleplayer_uuid"));
|
|
let player_dir = dir.join("players").join("data");
|
|
let owner = uuid.and_then(|u| read_dat(&player_dir.join(format!("{}.dat", uuid_text(u)))));
|
|
let player = owner
|
|
.or_else(|| {
|
|
fs::read_dir(&player_dir)
|
|
.ok()
|
|
.and_then(|d| {
|
|
d.flatten()
|
|
.filter(|e| e.path().extension().is_some_and(|x| x == "dat"))
|
|
.max_by_key(|e| e.metadata().and_then(|m| m.modified()).ok())
|
|
})
|
|
.and_then(|e| read_dat(&e.path()))
|
|
})
|
|
.or_else(|| data.get("Player").cloned());
|
|
level.player_uuid = uuid_from_tag(player.as_ref().and_then(|p| p.get("UUID"))).or(uuid);
|
|
let spawn = level
|
|
.world_spawn
|
|
.map(|s| [f64::from(s[0]), f64::from(s[1]), f64::from(s[2])]);
|
|
level.spawn = spawn;
|
|
if let Some(p) = &player {
|
|
level.read_player(p);
|
|
}
|
|
level.player_extra = player;
|
|
Some(level)
|
|
}
|
|
pub fn read_player(&mut self, p: &Tag) {
|
|
let n = |k: &str| number(p.get(k));
|
|
let f = |k: &str| float(p.get(k));
|
|
self.position = read_doubles::<3>(p.get("Pos"));
|
|
if let Some(r) = read_doubles::<2>(p.get("Rotation")) {
|
|
self.rotation = [r[0] as f32, r[1] as f32];
|
|
}
|
|
self.motion = read_doubles::<3>(p.get("Motion")).unwrap_or_default();
|
|
self.health = f("Health").map_or(20.0, |v| v as f32);
|
|
self.absorption = f("AbsorptionAmount").map_or(0.0, |v| v as f32);
|
|
self.food = n("foodLevel").map_or(20, |v| v as i32);
|
|
self.saturation = f("foodSaturationLevel").map_or(5.0, |v| v as f32);
|
|
self.food_exhaustion = f("foodExhaustionLevel").unwrap_or(0.0) as f32;
|
|
self.food_tick_timer = n("foodTickTimer").unwrap_or(0) as i32;
|
|
self.xp_level = n("XpLevel").unwrap_or(0) as i32;
|
|
self.xp_progress = f("XpP").unwrap_or(0.0) as f32;
|
|
self.xp_total = n("XpTotal").unwrap_or(0) as i32;
|
|
self.selected_slot = n("SelectedItemSlot").unwrap_or(0) as i32;
|
|
self.fall_distance = f("fall_distance").unwrap_or(0.0);
|
|
self.on_ground = n("OnGround").unwrap_or(0) != 0;
|
|
self.seen_credits = n("seenCredits").unwrap_or(0) != 0;
|
|
if let Some(mode) = n("playerGameType") {
|
|
self.creative = mode == 1;
|
|
self.game_mode = mode as i32;
|
|
}
|
|
self.flying = p
|
|
.get("abilities")
|
|
.and_then(|a| number(a.get("flying")))
|
|
.is_some_and(|v| v != 0);
|
|
if let Some(d) = text(p.get("Dimension")) {
|
|
self.dimension = d;
|
|
}
|
|
if let Some(respawn) = p.get("respawn")
|
|
&& let Some(Tag::IntArray(pos)) = respawn.get("pos")
|
|
&& pos.len() == 3
|
|
{
|
|
let dimension =
|
|
text(respawn.get("dimension")).unwrap_or_else(|| "minecraft:overworld".into());
|
|
let forced = number(respawn.get("forced")).is_some_and(|v| v != 0);
|
|
// A forced point in the Overworld (`spawnpoint`) is where the
|
|
// player respawns; anything else (a bed, an anchor) is resolved
|
|
// through its block then.
|
|
if dimension == "minecraft:overworld" && forced {
|
|
self.spawn = Some([f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])]);
|
|
} else {
|
|
let yaw = match respawn.get("yaw") {
|
|
Some(Tag::Float(b)) => f32::from_bits(*b),
|
|
_ => 0.0,
|
|
};
|
|
self.respawn_elsewhere = Some((dimension, [pos[0], pos[1], pos[2]], yaw, forced));
|
|
}
|
|
}
|
|
let mut inventory = Vec::new();
|
|
let mut inventory_components = HashMap::new();
|
|
if let Some(Tag::List(items)) = p.get("Inventory") {
|
|
for it in items {
|
|
let slot = number(it.get("Slot")).unwrap_or(0) as i8 as u8;
|
|
if let Some(stack) = item_from_nbt(it) {
|
|
let slot = if slot as i8 == -106 { 150 } else { slot };
|
|
if let Some(extra) = &stack.extra {
|
|
inventory_components.insert(slot, extra.clone());
|
|
}
|
|
// Legacy armor slots 100..103 and offhand -106 (150).
|
|
let slot = if slot as i8 == -106 { 150 } else { slot };
|
|
inventory.push((slot, stack.item.to_string(), stack.count, stack.damage));
|
|
}
|
|
}
|
|
}
|
|
if let Some(eq) = p.get("equipment") {
|
|
for (name, slot) in [
|
|
("feet", 100u8),
|
|
("legs", 101),
|
|
("chest", 102),
|
|
("head", 103),
|
|
("offhand", 150),
|
|
] {
|
|
if let Some(stack) = eq.get(name).and_then(item_from_nbt) {
|
|
inventory.retain(|(s, ..)| *s != slot);
|
|
if let Some(extra) = &stack.extra {
|
|
inventory_components.insert(slot, extra.clone());
|
|
}
|
|
inventory.push((slot, stack.item.to_string(), stack.count, stack.damage));
|
|
}
|
|
}
|
|
}
|
|
self.inventory = inventory;
|
|
self.ender_items = decode_items(p.get("EnderItems"), 27);
|
|
self.recipe_book = crate::recipe_book::Settings::read(p.get("recipeBook"));
|
|
self.inventory_components = inventory_components;
|
|
self.xp_seed = n("XpSeed").unwrap_or(0) as i32;
|
|
self.active_effects = match p.get("active_effects") {
|
|
Some(Tag::List(list)) => list
|
|
.iter()
|
|
.filter_map(|e| {
|
|
let id = text(e.get("id"))?;
|
|
let get = |k: &str| number(e.get(k));
|
|
Some((
|
|
id,
|
|
get("duration").unwrap_or(0) as i32,
|
|
get("amplifier").unwrap_or(0) as i32,
|
|
get("ambient").unwrap_or(0) != 0,
|
|
get("show_icon").is_none_or(|v| v != 0),
|
|
))
|
|
})
|
|
.collect(),
|
|
_ => Vec::new(),
|
|
};
|
|
}
|
|
/// The player compound: the loaded one with Horizon's state written over it.
|
|
pub fn player_tag(&self) -> Tag {
|
|
let mut p = compound_or_empty(self.player_extra.clone());
|
|
// Keys rewritten from scratch.
|
|
if let Tag::Compound(map) = &mut p {
|
|
for key in [
|
|
"Inventory",
|
|
"EnderItems",
|
|
"equipment",
|
|
"active_effects",
|
|
"Pos",
|
|
"respawn",
|
|
"recipeBook",
|
|
] {
|
|
map.remove(&JavaString::from(key));
|
|
}
|
|
}
|
|
let mut inventory = Vec::new();
|
|
let mut equipment = Vec::new();
|
|
for (slot, id, count, damage) in &self.inventory {
|
|
let extra = self.inventory_components.get(slot).cloned();
|
|
let stack = crate::items::ItemStack {
|
|
item: Arc::from(id.as_str()),
|
|
count: *count,
|
|
damage: *damage,
|
|
extra,
|
|
};
|
|
match slot {
|
|
0..=35 => {
|
|
let mut entries = vec![("Slot", Tag::Byte(*slot as i8))];
|
|
entries.extend(encode_item(&stack));
|
|
inventory.push(Tag::compound(entries));
|
|
}
|
|
100 => equipment.push(("feet", item_to_nbt(&stack))),
|
|
101 => equipment.push(("legs", item_to_nbt(&stack))),
|
|
102 => equipment.push(("chest", item_to_nbt(&stack))),
|
|
103 => equipment.push(("head", item_to_nbt(&stack))),
|
|
150 => equipment.push(("offhand", item_to_nbt(&stack))),
|
|
_ => {}
|
|
}
|
|
}
|
|
// GameType.updatePlayerAbilities.
|
|
let mode = self.mode();
|
|
let (creative, spectator) = (mode == 1, mode == 3);
|
|
let mut abilities = compound_or_empty(p.get("abilities").cloned());
|
|
for (k, v) in [
|
|
("invulnerable", creative || spectator),
|
|
("mayfly", creative || spectator),
|
|
("instabuild", creative),
|
|
("mayBuild", mode < 2),
|
|
] {
|
|
put(&mut abilities, k, Tag::Byte(i8::from(v)));
|
|
}
|
|
if spectator {
|
|
put(&mut abilities, "flying", Tag::Byte(1));
|
|
} else if creative {
|
|
put(&mut abilities, "flying", Tag::Byte(i8::from(self.flying)));
|
|
} else {
|
|
put(&mut abilities, "flying", Tag::Byte(0));
|
|
}
|
|
if let Tag::Compound(map) = &mut abilities {
|
|
map.entry("mayBuild".into()).or_insert(Tag::Byte(1));
|
|
map.entry("flySpeed".into())
|
|
.or_insert(Tag::Float(0.05f32.to_bits()));
|
|
map.entry("walkSpeed".into())
|
|
.or_insert(Tag::Float(0.1f32.to_bits()));
|
|
map.entry("flying".into()).or_insert(Tag::Byte(0));
|
|
}
|
|
let uuid = self.player_uuid.unwrap_or([0, 0, 0, 0]);
|
|
let mut entries: Vec<(&str, Tag)> = vec![
|
|
("DataVersion", Tag::Int(DATA_VERSION)),
|
|
("UUID", uuid_tag(uuid)),
|
|
("Rotation", floats(&self.rotation)),
|
|
("Motion", doubles(&self.motion)),
|
|
("OnGround", Tag::Byte(i8::from(self.on_ground))),
|
|
("fall_distance", Tag::Double(self.fall_distance.to_bits())),
|
|
("Health", Tag::Float(self.health.to_bits())),
|
|
("AbsorptionAmount", Tag::Float(self.absorption.to_bits())),
|
|
("foodLevel", Tag::Int(self.food)),
|
|
("foodSaturationLevel", Tag::Float(self.saturation.to_bits())),
|
|
(
|
|
"foodExhaustionLevel",
|
|
Tag::Float(self.food_exhaustion.to_bits()),
|
|
),
|
|
("foodTickTimer", Tag::Int(self.food_tick_timer)),
|
|
("XpLevel", Tag::Int(self.xp_level)),
|
|
("XpP", Tag::Float(self.xp_progress.to_bits())),
|
|
("XpTotal", Tag::Int(self.xp_total)),
|
|
("SelectedItemSlot", Tag::Int(self.selected_slot)),
|
|
("XpSeed", Tag::Int(self.xp_seed)),
|
|
(
|
|
"active_effects",
|
|
Tag::List(
|
|
self.active_effects
|
|
.iter()
|
|
.map(|(id, duration, amplifier, ambient, icon)| {
|
|
Tag::compound([
|
|
("id", string(id)),
|
|
("duration", Tag::Int(*duration)),
|
|
("amplifier", Tag::Byte(*amplifier as i8)),
|
|
("ambient", Tag::Byte(i8::from(*ambient))),
|
|
("show_particles", Tag::Byte(1)),
|
|
("show_icon", Tag::Byte(i8::from(*icon))),
|
|
])
|
|
})
|
|
.collect(),
|
|
),
|
|
),
|
|
("playerGameType", Tag::Int(self.mode())),
|
|
("Inventory", Tag::List(inventory)),
|
|
("EnderItems", encode_items(&self.ender_items)),
|
|
("recipeBook", self.recipe_book.write()),
|
|
("abilities", abilities),
|
|
(
|
|
"Dimension",
|
|
string(if self.dimension.is_empty() {
|
|
"minecraft:overworld"
|
|
} else {
|
|
&self.dimension
|
|
}),
|
|
),
|
|
];
|
|
// LivingEntity.addAdditionalSaveData omits empty equipment and an empty
|
|
// effect list. PlayerEquipment.isEmpty also counts the selected hotbar
|
|
// item, which the codec never writes: holding one saves `equipment: {}`.
|
|
let holding = self
|
|
.inventory
|
|
.iter()
|
|
.any(|(slot, _, count, _)| i32::from(*slot) == self.selected_slot && *count > 0);
|
|
if holding || !equipment.is_empty() {
|
|
entries.push(("equipment", Tag::compound(equipment)));
|
|
}
|
|
if self.active_effects.is_empty() {
|
|
entries.retain(|(key, _)| *key != "active_effects");
|
|
}
|
|
if let Some(pos) = self.position {
|
|
entries.push(("Pos", doubles(&pos)));
|
|
}
|
|
entries.push(("seenCredits", Tag::Byte(i8::from(self.seen_credits))));
|
|
// A respawn point other than the world spawn: an anchor elsewhere, or a bed.
|
|
if let Some((dimension, block, yaw, forced)) = &self.respawn_elsewhere {
|
|
let mut respawn = vec![
|
|
("dimension", string(dimension)),
|
|
("pos", Tag::IntArray(block.to_vec())),
|
|
("yaw", Tag::Float(yaw.to_bits())),
|
|
("pitch", Tag::Float(0f32.to_bits())),
|
|
];
|
|
if *forced {
|
|
respawn.push(("forced", Tag::Byte(1)));
|
|
}
|
|
entries.push(("respawn", Tag::compound(respawn)));
|
|
} else if let Some(s) = self.spawn {
|
|
let block = [
|
|
s[0].floor() as i32,
|
|
s[1].floor() as i32,
|
|
s[2].floor() as i32,
|
|
];
|
|
// A point of the player's own in the Overworld other than a bed
|
|
// (`respawn_elsewhere`): `spawnpoint`'s, forced.
|
|
if Some(block) != self.world_spawn {
|
|
entries.push((
|
|
"respawn",
|
|
Tag::compound([
|
|
("dimension", string("minecraft:overworld")),
|
|
("pos", Tag::IntArray(block.to_vec())),
|
|
("yaw", Tag::Float(0f32.to_bits())),
|
|
("pitch", Tag::Float(0f32.to_bits())),
|
|
("forced", Tag::Byte(1)),
|
|
]),
|
|
));
|
|
}
|
|
}
|
|
for (key, value) in entries {
|
|
put(&mut p, key, value);
|
|
}
|
|
if let Tag::Compound(map) = &mut p {
|
|
for (key, value) in [
|
|
("Air", Tag::Short(300)),
|
|
("Fire", Tag::Short(-20)),
|
|
("Invulnerable", Tag::Byte(0)),
|
|
("PortalCooldown", Tag::Int(0)),
|
|
("Score", Tag::Int(0)),
|
|
("SleepTimer", Tag::Short(0)),
|
|
("XpSeed", Tag::Int(0)),
|
|
("seenCredits", Tag::Byte(0)),
|
|
("HurtTime", Tag::Short(0)),
|
|
("DeathTime", Tag::Short(0)),
|
|
("FallFlying", Tag::Byte(0)),
|
|
] {
|
|
map.entry(key.into()).or_insert(value);
|
|
}
|
|
}
|
|
p
|
|
}
|
|
/// Write every file; a world without a player UUID gets a random one.
|
|
pub fn write(&mut self, dir: &Path) -> Result<()> {
|
|
fs::create_dir_all(dir)?;
|
|
let existing = read_dat(&dir.join("level.dat")).and_then(|r| r.get("Data").cloned());
|
|
let legacy = existing
|
|
.as_ref()
|
|
.is_some_and(|d| d.get("Player").is_some() || d.get("WorldGenSettings").is_some());
|
|
let mut data = compound_or_empty(existing);
|
|
if let Tag::Compound(map) = &mut data {
|
|
// Pre-26.3 keys now stored elsewhere (a legacy Horizon level.dat).
|
|
for key in [
|
|
"Player",
|
|
"WorldGenSettings",
|
|
"DayTime",
|
|
"SpawnX",
|
|
"SpawnY",
|
|
"SpawnZ",
|
|
"SpawnAngle",
|
|
"clearWeatherTime",
|
|
"rainTime",
|
|
"thunderTime",
|
|
"raining",
|
|
"thundering",
|
|
"Difficulty",
|
|
"hardcore",
|
|
"GameRules",
|
|
"DimensionData",
|
|
"WanderingTraderSpawnChance",
|
|
"WanderingTraderSpawnDelay",
|
|
"WanderingTraderId",
|
|
"BorderCenterX",
|
|
"BorderCenterZ",
|
|
"BorderSize",
|
|
"BorderSafeZone",
|
|
"BorderWarningBlocks",
|
|
"BorderWarningTime",
|
|
"BorderSizeLerpTime",
|
|
"BorderSizeLerpTarget",
|
|
"BorderDamagePerBlock",
|
|
"DifficultyLocked",
|
|
"ScheduledEvents",
|
|
"CustomBossEvents",
|
|
"DragonFight",
|
|
] {
|
|
map.remove(&JavaString::from(key));
|
|
}
|
|
}
|
|
let uuid = self.ensure_player_uuid();
|
|
// A new world's first spawn point is its world spawn.
|
|
if self.world_spawn.is_none() {
|
|
self.world_spawn = self.spawn.map(|s| {
|
|
[
|
|
s[0].floor() as i32,
|
|
s[1].floor() as i32,
|
|
s[2].floor() as i32,
|
|
]
|
|
});
|
|
}
|
|
let spawn = self.world_spawn.unwrap_or([0, 64, 0]);
|
|
let mut history: Vec<Tag> = match data.get("version_history") {
|
|
Some(Tag::List(l)) => l.clone(),
|
|
_ => Vec::new(),
|
|
};
|
|
if history.last() != Some(&Tag::Int(DATA_VERSION)) {
|
|
history.push(Tag::Int(DATA_VERSION));
|
|
}
|
|
let mut brands: Vec<Tag> = match data.get("ServerBrands") {
|
|
Some(Tag::List(l)) => l.clone(),
|
|
_ => Vec::new(),
|
|
};
|
|
if !brands.contains(&string("horizon")) {
|
|
brands.push(string("horizon"));
|
|
}
|
|
let mut difficulty = compound_or_empty(data.get("difficulty_settings").cloned());
|
|
put(
|
|
&mut difficulty,
|
|
"difficulty",
|
|
string(if self.difficulty.is_empty() {
|
|
"normal"
|
|
} else {
|
|
&self.difficulty
|
|
}),
|
|
);
|
|
put(
|
|
&mut difficulty,
|
|
"hardcore",
|
|
Tag::Byte(i8::from(self.hardcore)),
|
|
);
|
|
put(
|
|
&mut difficulty,
|
|
"locked",
|
|
Tag::Byte(i8::from(self.difficulty_locked)),
|
|
);
|
|
let now = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.map_or(0, |d| d.as_millis() as i64);
|
|
for (key, value) in [
|
|
("DataVersion", Tag::Int(DATA_VERSION)),
|
|
(
|
|
"Version",
|
|
Tag::compound([
|
|
("Name", string(VERSION_NAME)),
|
|
("Id", Tag::Int(DATA_VERSION)),
|
|
("Snapshot", Tag::Byte(0)),
|
|
("Series", string("main")),
|
|
]),
|
|
),
|
|
("version_history", Tag::List(history)),
|
|
("version", Tag::Int(19133)),
|
|
("LevelName", string(&self.name)),
|
|
("GameType", Tag::Int(self.mode())),
|
|
("Time", Tag::Long(self.time)),
|
|
("LastPlayed", Tag::Long(now)),
|
|
(
|
|
"spawn",
|
|
Tag::compound([
|
|
("pos", Tag::IntArray(spawn.to_vec())),
|
|
("dimension", string("minecraft:overworld")),
|
|
("yaw", Tag::Float(self.world_spawn_angle[0].to_bits())),
|
|
("pitch", Tag::Float(self.world_spawn_angle[1].to_bits())),
|
|
]),
|
|
),
|
|
("difficulty_settings", difficulty),
|
|
("initialized", Tag::Byte(1)),
|
|
("singleplayer_uuid", uuid_tag(uuid)),
|
|
("ServerBrands", Tag::List(brands)),
|
|
] {
|
|
put(&mut data, key, value);
|
|
}
|
|
if let Tag::Compound(map) = &mut data {
|
|
map.entry("allowCommands".into()).or_insert(Tag::Byte(0));
|
|
if let Some(allow) = self.allow_commands {
|
|
map.insert("allowCommands".into(), Tag::Byte(i8::from(allow)));
|
|
}
|
|
map.entry("WasModded".into()).or_insert(Tag::Byte(0));
|
|
map.entry("DataPacks".into()).or_insert_with(|| {
|
|
Tag::compound([
|
|
("Enabled", Tag::List(vec![string("vanilla")])),
|
|
(
|
|
"Disabled",
|
|
Tag::List(
|
|
[
|
|
"minecart_improvements",
|
|
"redstone_experiments",
|
|
"trade_rebalance",
|
|
]
|
|
.iter()
|
|
.map(|s| string(s))
|
|
.collect(),
|
|
),
|
|
),
|
|
])
|
|
});
|
|
}
|
|
// Saved data: weather, clocks, and (when missing or legacy) world
|
|
// generation settings and game rules.
|
|
write_saved_data(
|
|
dir,
|
|
"weather",
|
|
Tag::compound([
|
|
("clear_weather_time", Tag::Int(self.weather.clear_time)),
|
|
("rain_time", Tag::Int(self.weather.rain_time)),
|
|
("thunder_time", Tag::Int(self.weather.thunder_time)),
|
|
("raining", Tag::Byte(i8::from(self.weather.raining))),
|
|
("thundering", Tag::Byte(i8::from(self.weather.thundering))),
|
|
]),
|
|
)?;
|
|
let mut clocks = compound_or_empty(read_saved_data(dir, "world_clocks"));
|
|
let mut overworld = compound_or_empty(clocks.get("minecraft:overworld").cloned());
|
|
put(&mut overworld, "total_ticks", Tag::Long(self.day_time));
|
|
put(&mut clocks, "minecraft:overworld", overworld);
|
|
if let Tag::Compound(map) = &mut clocks {
|
|
map.entry("minecraft:the_end".into())
|
|
.or_insert_with(|| Tag::compound([("total_ticks", Tag::Long(self.time))]));
|
|
}
|
|
write_saved_data(dir, "world_clocks", clocks)?;
|
|
if legacy || !saved_data_path(dir, "world_gen_settings").exists() {
|
|
write_world_gen_settings(dir, self.seed, WorldGen::default())?;
|
|
}
|
|
if !saved_data_path(dir, "game_rules").exists() || !self.game_rules.is_empty() {
|
|
// Only rules vanilla knows: an unknown key makes it reject the file.
|
|
let mut rules = Tag::Compound(Compound::new());
|
|
for (name, default) in GAME_RULES {
|
|
let value = self.game_rules.get(name).copied().unwrap_or(default);
|
|
let tag = if INT_RULES.contains(&name) {
|
|
Tag::Int(value)
|
|
} else {
|
|
Tag::Byte(i8::from(value != 0))
|
|
};
|
|
put(&mut rules, &format!("minecraft:{name}"), tag);
|
|
}
|
|
write_saved_data(dir, "game_rules", rules)?;
|
|
}
|
|
write_dat(
|
|
&dir.join("players")
|
|
.join("data")
|
|
.join(format!("{}.dat", uuid_text(uuid))),
|
|
self.player_tag(),
|
|
)?;
|
|
write_dat(&dir.join("level.dat"), Tag::compound([("Data", data)]))?;
|
|
Ok(())
|
|
}
|
|
}
|
|
/// Loads saved chunks before falling back to generation.
|
|
pub struct Persistent<G> {
|
|
pub inner: Arc<G>,
|
|
pub save: Arc<SaveDir>,
|
|
pub registry: Arc<crate::assets::Assets>,
|
|
pub biomes: Arc<Biomes>,
|
|
}
|
|
type LodSurfaces = Arc<[crate::lod::Column; 256]>;
|
|
struct SavedLodSampler<G: ChunkGenerator> {
|
|
generator: Arc<Persistent<G>>,
|
|
inner: Box<dyn crate::streaming::LodSampler>,
|
|
cache: std::collections::VecDeque<((i32, i32), Option<LodSurfaces>)>,
|
|
details: Vec<crate::streaming::LodDetail>,
|
|
}
|
|
impl<G: ChunkGenerator> SavedLodSampler<G> {
|
|
fn saved_columns(&mut self, key: (i32, i32)) -> Option<LodSurfaces> {
|
|
let cached = match self.cache.iter().position(|(at, _)| *at == key) {
|
|
Some(index) => self.cache.remove(index).unwrap(),
|
|
None => (
|
|
key,
|
|
self.generator.save.lod_surfaces(
|
|
key.0,
|
|
key.1,
|
|
&self.generator.registry,
|
|
&self.generator.biomes,
|
|
),
|
|
),
|
|
};
|
|
let columns = cached.1.clone();
|
|
self.cache.push_front(cached);
|
|
self.cache.truncate(128);
|
|
columns
|
|
}
|
|
}
|
|
impl<G: ChunkGenerator> crate::streaming::LodSampler for SavedLodSampler<G> {
|
|
fn fork(&self) -> Option<Box<dyn crate::streaming::LodSampler>> {
|
|
Some(Box::new(Self {
|
|
generator: self.generator.clone(),
|
|
inner: self.inner.fork()?,
|
|
cache: Default::default(),
|
|
details: Vec::new(),
|
|
}))
|
|
}
|
|
fn request_detail(&mut self, chunks: &[(i32, i32)], center: [i32; 2]) {
|
|
let mut missing = Vec::new();
|
|
for &key in chunks {
|
|
if let Some(columns) = self.saved_columns(key) {
|
|
self.details.push((key, columns));
|
|
} else {
|
|
missing.push(key);
|
|
}
|
|
}
|
|
self.inner.request_detail(&missing, center);
|
|
}
|
|
fn drain_details(&mut self) -> Vec<crate::streaming::LodDetail> {
|
|
let mut details = std::mem::take(&mut self.details);
|
|
for (key, generated) in self.inner.drain_details() {
|
|
// A generation batch also returns neighbouring, unrequested chunks.
|
|
// Their saved builds must take precedence too.
|
|
details.push((key, self.saved_columns(key).unwrap_or(generated)));
|
|
}
|
|
details
|
|
}
|
|
fn grid(&mut self, x: i32, z: i32, stride: i32, side: usize) -> Vec<crate::lod::Column> {
|
|
let mut columns = self.inner.grid(x, z, stride, side);
|
|
if stride <= 16 {
|
|
for (index, column) in columns.iter_mut().enumerate() {
|
|
let (wx, wz) = (
|
|
x + (index % side) as i32 * stride,
|
|
z + (index / side) as i32 * stride,
|
|
);
|
|
if let Some(saved) = self.saved_columns((wx >> 4, wz >> 4)) {
|
|
*column = crate::lod::Column::reduced(
|
|
&saved,
|
|
(wx & 15) as usize,
|
|
(wz & 15) as usize,
|
|
stride as usize,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
columns
|
|
}
|
|
fn sample(&mut self, x: i32, z: i32) -> Option<crate::lod::Surface> {
|
|
self.column(x, z).surface
|
|
}
|
|
fn column(&mut self, x: i32, z: i32) -> crate::lod::Column {
|
|
self.reduced_column(x, z, 1)
|
|
}
|
|
fn reduced_column(&mut self, x: i32, z: i32, width: i32) -> crate::lod::Column {
|
|
if width <= 16
|
|
&& let Some(columns) = self.saved_columns((x >> 4, z >> 4))
|
|
{
|
|
return crate::lod::Column::reduced(
|
|
&columns,
|
|
(x & 15) as usize,
|
|
(z & 15) as usize,
|
|
width as usize,
|
|
);
|
|
}
|
|
self.inner.reduced_column(x, z, width)
|
|
}
|
|
}
|
|
|
|
/// Read one palette index without expanding the other entries in the section.
|
|
fn lod_palette_index(
|
|
container: &Tag,
|
|
index: usize,
|
|
entries: usize,
|
|
minimum_bits: u32,
|
|
) -> Option<usize> {
|
|
let Tag::List(palette) = container.get("palette")? else {
|
|
return None;
|
|
};
|
|
if palette.is_empty() || palette.len() > entries || index >= entries {
|
|
return None;
|
|
}
|
|
if palette.len() == 1 {
|
|
return Some(0);
|
|
}
|
|
let bits = (usize::BITS - (palette.len() - 1).leading_zeros()).max(minimum_bits);
|
|
let per_word = 64 / bits as usize;
|
|
let Tag::LongArray(data) = container.get("data")? else {
|
|
return None;
|
|
};
|
|
if data.len() != entries.div_ceil(per_word) {
|
|
return None;
|
|
}
|
|
let value = ((data[index / per_word] as u64 >> ((index % per_word) * bits as usize))
|
|
& ((1 << bits) - 1)) as usize;
|
|
(value < palette.len()).then_some(value)
|
|
}
|
|
fn lod_light_layers(sections: &[(i32, &Tag)], sky_light: bool) -> Box<[u8]> {
|
|
let mut layers = [(None, None); SECTIONS];
|
|
for &(y, section) in sections {
|
|
let layer = |name: &str| match section.get(name) {
|
|
Some(Tag::ByteArray(data)) if data.len() == 2048 => Some(&data[..]),
|
|
_ => None,
|
|
};
|
|
layers[(y - (MIN_Y >> 4)) as usize] = (
|
|
if sky_light { layer("SkyLight") } else { None },
|
|
layer("BlockLight"),
|
|
);
|
|
}
|
|
let mut light = vec![0u8; SECTIONS * 4096].into_boxed_slice();
|
|
let mut above = [if sky_light { 15u8 } else { 0 }; 256];
|
|
let nibble = |data: &[u8], index: usize| (data[index / 2] >> ((index & 1) * 4)) & 15;
|
|
for si in (0..SECTIONS).rev() {
|
|
let (sky, block) = layers[si];
|
|
let section = &mut light[si * 4096..(si + 1) * 4096];
|
|
for (index, value) in section.iter_mut().enumerate() {
|
|
*value = sky.map_or(above[index & 255], |data| nibble(data, index)) << 4
|
|
| block.map_or(0, |data| nibble(data, index));
|
|
}
|
|
// Missing sky layers inherit the bottom layer above, as load_light does.
|
|
for (index, value) in above.iter_mut().enumerate() {
|
|
*value = section[index] >> 4;
|
|
}
|
|
}
|
|
light
|
|
}
|
|
fn lod_face_light(light: &[u8], x: usize, y: usize, z: usize) -> u16 {
|
|
let index = y * 256 + z * 16 + x;
|
|
let mut sky = light[index] >> 4;
|
|
let mut block = light[index] & 15;
|
|
for (valid, index) in [
|
|
(x > 0, index.wrapping_sub(1)),
|
|
(x < 15, index + 1),
|
|
(z > 0, index.wrapping_sub(16)),
|
|
(z < 15, index + 16),
|
|
(y > 0, index.wrapping_sub(256)),
|
|
(y + 1 < SECTIONS * 16, index + 256),
|
|
] {
|
|
if valid {
|
|
sky = sky.max(light[index] >> 4);
|
|
block = block.max(light[index] & 15);
|
|
}
|
|
}
|
|
u16::from(sky) << 4 | u16::from(block) << 12
|
|
}
|
|
fn decode_lod_surfaces(
|
|
root: &NamedTag,
|
|
assets: &crate::assets::Assets,
|
|
biomes: &Biomes,
|
|
sky_light: bool,
|
|
) -> Option<LodSurfaces> {
|
|
let Tag::List(sections) = root.tag.get("sections")? else {
|
|
return None;
|
|
};
|
|
let mut sections: Vec<_> = sections
|
|
.iter()
|
|
.filter_map(|section| {
|
|
let y = number(section.get("Y"))? as i32;
|
|
(MIN_Y >> 4..(MIN_Y >> 4) + SECTIONS as i32)
|
|
.contains(&y)
|
|
.then_some((y, section))
|
|
})
|
|
.collect();
|
|
sections.sort_unstable_by_key(|(y, _)| std::cmp::Reverse(*y));
|
|
let mut columns: Box<[crate::lod::Column; 256]> =
|
|
Box::new(std::array::from_fn(|_| crate::lod::Column {
|
|
surface: None,
|
|
spans: Vec::new(),
|
|
}));
|
|
let mut water = [None; 256];
|
|
let light = lod_light_layers(§ions, sky_light);
|
|
let mut states = BTreeMap::new();
|
|
for (section_y, section) in sections {
|
|
if let Some(blocks) = section.get("block_states") {
|
|
let Tag::List(palette) = blocks.get("palette")? else {
|
|
return None;
|
|
};
|
|
// Resolve each state once per palette, rather than parsing NBT for every block.
|
|
let palette: Vec<_> = palette
|
|
.iter()
|
|
.map(|entry| {
|
|
let descriptor = BlockState::from_nbt(entry).ok()?;
|
|
let state = *states.entry(descriptor.clone()).or_insert_with(|| {
|
|
assets
|
|
.registry
|
|
.id(&descriptor)
|
|
.or_else(|| assets.registry.default_state(&descriptor.name))
|
|
});
|
|
Some(state.map(|state| {
|
|
let properties = assets.properties.heightmap_state(state);
|
|
let fluid = matches!(
|
|
descriptor.name.as_str(),
|
|
"minecraft:water" | "minecraft:lava"
|
|
);
|
|
(state, fluid, properties.blocks_motion_in_heightmap())
|
|
}))
|
|
})
|
|
.collect::<Option<_>>()?;
|
|
let biome_palette: Vec<_> = section
|
|
.get("biomes")
|
|
.and_then(|container| match container.get("palette")? {
|
|
Tag::List(palette) => Some(palette),
|
|
_ => None,
|
|
})
|
|
.into_iter()
|
|
.flatten()
|
|
.map(|entry| match entry {
|
|
Tag::String(name) => biomes.id(&name.to_string_lossy()),
|
|
_ => 0,
|
|
})
|
|
.collect();
|
|
for z in 0..16 {
|
|
for x in 0..16 {
|
|
let cell = z * 16 + x;
|
|
let column = &mut columns[cell];
|
|
for y in (0..16).rev() {
|
|
let index = y * 256 + cell;
|
|
let palette_index = lod_palette_index(blocks, index, 4096, 4)?;
|
|
let Some((state, fluid, solid)) = palette[palette_index] else {
|
|
continue;
|
|
};
|
|
if !solid && !fluid {
|
|
continue;
|
|
}
|
|
let biome = section
|
|
.get("biomes")
|
|
.and_then(|container| {
|
|
lod_palette_index(
|
|
container,
|
|
(y / 4) * 16 + (z / 4) * 4 + x / 4,
|
|
64,
|
|
1,
|
|
)
|
|
})
|
|
.and_then(|index| biome_palette.get(index))
|
|
.copied()
|
|
.unwrap_or(0);
|
|
let height = section_y * 16 + y as i32 + 1;
|
|
if column.surface.is_none() {
|
|
if fluid {
|
|
water[cell].get_or_insert((height, state));
|
|
} else {
|
|
column.surface = Some(crate::lod::Surface {
|
|
height,
|
|
state,
|
|
water: water[cell],
|
|
biome,
|
|
});
|
|
}
|
|
}
|
|
let light = lod_face_light(&light, x, (height - 1 - MIN_Y) as usize, z);
|
|
let min = (height - 1) as i16;
|
|
let max = height as i16;
|
|
if let Some(previous) = column.spans.last_mut()
|
|
&& previous.min == max
|
|
&& (previous.state, previous.biome, previous.light)
|
|
== (state, biome, light)
|
|
{
|
|
previous.min = min;
|
|
} else {
|
|
column.spans.push(crate::lod::Span {
|
|
min,
|
|
max,
|
|
state,
|
|
biome,
|
|
light,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for column in &mut *columns {
|
|
column.spans.reverse();
|
|
}
|
|
Some(Arc::from(columns))
|
|
}
|
|
|
|
impl SaveDir {
|
|
fn lod_surfaces(
|
|
&self,
|
|
x: i32,
|
|
z: i32,
|
|
assets: &crate::assets::Assets,
|
|
biomes: &Biomes,
|
|
) -> Option<LodSurfaces> {
|
|
let pending = self
|
|
.pending
|
|
.lock()
|
|
.ok()?
|
|
.get(&(false, x, z))
|
|
.map(|(_, record)| record.clone());
|
|
let root = if let Some(record) = pending {
|
|
record.tag().map(|tag| (*tag).clone())?
|
|
} else {
|
|
// Far-only reads must not populate the gameplay region cache across the whole view.
|
|
let mut region = RegionFile::open(self.region_path("region", x >> 5, z >> 5)).ok()?;
|
|
region
|
|
.read(ChunkPos::new(x, z))
|
|
.ok()??
|
|
.nbt(Limits::default())
|
|
.ok()?
|
|
};
|
|
// Proto saves may still be missing decoration from their neighbors.
|
|
if text(root.tag.get("Status"))
|
|
.is_some_and(|status| status != "minecraft:full" && status != "full")
|
|
{
|
|
return None;
|
|
}
|
|
decode_lod_surfaces(&root, assets, biomes, self.sky_light)
|
|
}
|
|
}
|
|
|
|
impl<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
|
|
type Worker = G::Worker;
|
|
fn worker(&self) -> G::Worker {
|
|
self.inner.worker()
|
|
}
|
|
fn lod_sampler(self: Arc<Self>) -> Box<dyn crate::streaming::LodSampler> {
|
|
let inner = ChunkGenerator::lod_sampler(self.inner.clone());
|
|
Box::new(SavedLodSampler {
|
|
generator: self,
|
|
inner,
|
|
cache: Default::default(),
|
|
details: Vec::new(),
|
|
})
|
|
}
|
|
fn load(&self, x: i32, z: i32) -> Option<Chunk> {
|
|
self.save
|
|
.tables
|
|
.get_or_init(|| Arc::new(SaveTables::new(&self.registry)));
|
|
let mut chunk = self.save.load(x, z, self.registry.registry, &self.biomes)?;
|
|
for s in &mut chunk.sections {
|
|
Arc::make_mut(s).compact();
|
|
}
|
|
chunk.entities = self.save.load_entities(x, z);
|
|
Some(chunk)
|
|
}
|
|
fn lod_surface(&self, worker: &mut G::Worker, x: i32, z: i32) -> Option<crate::lod::Surface> {
|
|
// Resident/visited summaries override this procedural fallback in the LOD cache.
|
|
self.inner.lod_surface(worker, x, z)
|
|
}
|
|
fn prepare_loaded(&self, worker: &mut G::Worker, chunk: &Chunk) {
|
|
self.inner.prepare_loaded(worker, chunk);
|
|
}
|
|
fn proto(&self, worker: &mut G::Worker, x: i32, z: i32) -> crate::streaming::Proto {
|
|
let mut proto = self.inner.proto(worker, x, z);
|
|
if let Some(saved) = self
|
|
.save
|
|
.load_proto(x, z, self.registry.registry, &self.biomes)
|
|
{
|
|
self.inner.restore_proto(&mut proto, saved);
|
|
}
|
|
proto
|
|
}
|
|
fn is_decorated(&self, proto: &crate::streaming::Proto) -> bool {
|
|
self.inner.is_decorated(proto)
|
|
}
|
|
fn save_protos(&self, protos: &[&crate::streaming::Proto]) {
|
|
self.save
|
|
.tables
|
|
.get_or_init(|| Arc::new(SaveTables::new(&self.registry)));
|
|
let saved: Vec<SavedProto> = protos
|
|
.iter()
|
|
.filter_map(|p| self.inner.saved_proto(p))
|
|
.collect();
|
|
if let Err(e) = self
|
|
.save
|
|
.save_protos(&saved, self.registry.registry, &self.biomes)
|
|
{
|
|
log::warn!("Horizon: failed to save proto chunks: {e}");
|
|
}
|
|
}
|
|
fn save_finished(&self, mut chunk: Chunk) {
|
|
self.save
|
|
.tables
|
|
.get_or_init(|| Arc::new(SaveTables::new(&self.registry)));
|
|
let key = (chunk.x, chunk.z);
|
|
let entities = std::mem::take(&mut chunk.entities);
|
|
let saved = self
|
|
.save
|
|
.save_later(&[Arc::new(chunk)], self.registry.registry, &self.biomes)
|
|
.and_then(|_| self.save.save_entities_later(vec![(key, entities)]));
|
|
if let Err(e) = saved {
|
|
log::warn!("Horizon: failed to save chunk {} {}: {e}", key.0, key.1);
|
|
}
|
|
}
|
|
fn decorates(&self) -> bool {
|
|
self.inner.decorates()
|
|
}
|
|
fn decorate(&self, worker: &mut G::Worker, region: &mut [crate::streaming::Proto; 9]) {
|
|
self.inner.decorate(worker, region);
|
|
}
|
|
fn finish(&self, proto: crate::streaming::Proto) -> Chunk {
|
|
self.inner.finish(proto)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#[test]
|
|
fn saved_far_surface_reads_builds_and_water_without_gameplay_chunks() {
|
|
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES") else {
|
|
return;
|
|
};
|
|
let root = PathBuf::from(root);
|
|
let assets = crate::assets::Assets::load(&root).expect("assets");
|
|
let biomes = Biomes::load(&root).expect("biomes");
|
|
let stone = assets.registry.default_state("minecraft:stone").unwrap();
|
|
let water = assets.registry.default_state("minecraft:water").unwrap();
|
|
let sand = assets.registry.default_state("minecraft:sand").unwrap();
|
|
let dirt = assets.registry.default_state("minecraft:dirt").unwrap();
|
|
let leaves = assets
|
|
.registry
|
|
.default_state("minecraft:oak_leaves")
|
|
.unwrap();
|
|
let mut chunk = Chunk::empty(-2, 3);
|
|
chunk.set(0, 109, 0, stone.0);
|
|
chunk.set(3, 121, 5, stone.0);
|
|
chunk.set(3, 122, 5, stone.0);
|
|
chunk.set(3, 120, 5, dirt.0);
|
|
chunk.set(3, 119, 5, dirt.0);
|
|
chunk.set(3, 115, 5, stone.0);
|
|
chunk.set(11, 125, 11, stone.0);
|
|
chunk.set(14, 127, 14, stone.0);
|
|
chunk.set(14, 112, 14, stone.0);
|
|
for y in 95..98 {
|
|
chunk.set(2, y, 6, stone.0);
|
|
}
|
|
chunk.lit = true;
|
|
let mut cave_light = Box::new([0x03; 4096]);
|
|
cave_light[crate::chunk::index(12, 125, 11)] = 0xa7;
|
|
Arc::make_mut(&mut chunk.sections[((121 - MIN_Y) >> 4) as usize]).light =
|
|
Light::Full(cave_light);
|
|
chunk.set(7, 90, 9, sand.0);
|
|
chunk.set(7, 98, 9, leaves.0);
|
|
let forest = biomes.id("minecraft:forest");
|
|
chunk.set_biome_cell(7 / 4, (98 - MIN_Y) / 4, 9 / 4, forest);
|
|
chunk.set(4, 54, 4, sand.0);
|
|
for y in 55..64 {
|
|
chunk.set(4, y, 4, water.0);
|
|
}
|
|
let mut saved = encode(&chunk, assets.registry, &biomes);
|
|
put(
|
|
&mut saved.tag,
|
|
"block_entities",
|
|
Tag::String("not decoded by far sampling".into()),
|
|
);
|
|
let dir = std::env::temp_dir().join(format!("horizon-lod-save-{}", std::process::id()));
|
|
fs::create_dir_all(&dir).unwrap();
|
|
let save = SaveDir::new(dir.clone());
|
|
save.write_records("region", vec![((-2, 3), Some(saved))], true)
|
|
.unwrap();
|
|
let reopened = SaveDir::new(dir.clone());
|
|
let surfaces = reopened
|
|
.lod_surfaces(-2, 3, &assets, &biomes)
|
|
.expect("saved summary");
|
|
assert_eq!(surfaces[0].surface.unwrap().height, 110);
|
|
assert_eq!(surfaces[0].surface.unwrap().state, stone);
|
|
let narrow_build = surfaces[5 * 16 + 3].surface.unwrap();
|
|
assert_eq!((narrow_build.height, narrow_build.state), (123, stone));
|
|
assert!(
|
|
surfaces[5 * 16 + 2].surface.is_none(),
|
|
"adjacent columns stay distinct"
|
|
);
|
|
let strata = &surfaces[5 * 16 + 3].spans;
|
|
assert_eq!(
|
|
strata
|
|
.iter()
|
|
.map(|span| (span.min, span.max, span.state))
|
|
.collect::<Vec<_>>(),
|
|
vec![(115, 116, stone), (119, 121, dirt), (121, 123, stone)]
|
|
);
|
|
assert!(
|
|
strata.iter().all(|span| span.light == 0x3000),
|
|
"saved cave darkness and block light survive"
|
|
);
|
|
assert_eq!(
|
|
surfaces[11 * 16 + 11].spans[0].light,
|
|
0x70a0,
|
|
"neighbor face light uses separate sky/block channels"
|
|
);
|
|
let boundaries = &surfaces[14 * 16 + 14].spans;
|
|
assert_eq!(boundaries.len(), 2);
|
|
assert!(
|
|
boundaries.iter().all(|span| span.light == 0x30f0),
|
|
"face light crosses section boundaries above and below"
|
|
);
|
|
let across_sections = &surfaces[6 * 16 + 2].spans;
|
|
assert_eq!(across_sections.len(), 1);
|
|
assert_eq!((across_sections[0].min, across_sections[0].max), (95, 98));
|
|
let canopy = surfaces[9 * 16 + 7].surface.unwrap();
|
|
assert_eq!(
|
|
(canopy.height, canopy.state, canopy.biome),
|
|
(99, leaves, forest)
|
|
);
|
|
let underwater = surfaces[4 * 16 + 4].surface.unwrap();
|
|
assert_eq!((underwater.height, underwater.state), (55, sand));
|
|
assert_eq!(underwater.water, Some((64, water)));
|
|
assert!(surfaces[15].surface.is_none(), "saved void stays empty");
|
|
assert!(
|
|
reopened.regions.lock().unwrap().is_empty(),
|
|
"far reads do not grow gameplay region cache"
|
|
);
|
|
let mut proto = encode(&chunk, assets.registry, &biomes);
|
|
put(
|
|
&mut proto.tag,
|
|
"Status",
|
|
string(ChunkStatus::Terrain.name()),
|
|
);
|
|
put(&mut proto.tag, "xPos", Tag::Int(-3));
|
|
save.write_records("region", vec![((-3, 3), Some(proto))], true)
|
|
.unwrap();
|
|
assert!(
|
|
reopened.lod_surfaces(-3, 3, &assets, &biomes).is_none(),
|
|
"unfinished proto saves must not suppress complete decoration"
|
|
);
|
|
let mut nether = SaveDir::new(dir.clone());
|
|
nether.sky_light = false;
|
|
let dark = nether.lod_surfaces(-2, 3, &assets, &biomes).unwrap();
|
|
assert!(
|
|
dark.iter()
|
|
.flat_map(|c| &c.spans)
|
|
.all(|s| s.light & 0xf0 == 0),
|
|
"no invented skylight in Nether saves"
|
|
);
|
|
struct SavedOnly(Vec<crate::streaming::LodDetail>);
|
|
impl crate::streaming::LodSampler for SavedOnly {
|
|
fn sample(&mut self, _: i32, _: i32) -> Option<crate::lod::Surface> {
|
|
panic!("saved data must win")
|
|
}
|
|
fn request_detail(&mut self, chunks: &[(i32, i32)], _: [i32; 2]) {
|
|
assert!(
|
|
chunks.is_empty(),
|
|
"saved builds must not request speculative generation"
|
|
);
|
|
}
|
|
fn drain_details(&mut self) -> Vec<crate::streaming::LodDetail> {
|
|
std::mem::take(&mut self.0)
|
|
}
|
|
}
|
|
let inner = Arc::new(crate::testgen::TestTerrain::new(assets.registry, &biomes).unwrap());
|
|
let generator = Arc::new(Persistent {
|
|
inner,
|
|
save: Arc::new(reopened),
|
|
registry: Arc::new(assets),
|
|
biomes: Arc::new(biomes),
|
|
});
|
|
let mut sampler = SavedLodSampler {
|
|
generator,
|
|
inner: Box::new(SavedOnly(Vec::new())),
|
|
cache: Default::default(),
|
|
details: Vec::new(),
|
|
};
|
|
use crate::streaming::LodSampler;
|
|
sampler.request_detail(&[(-2, 3)], [-32, 48]);
|
|
let details = sampler.drain_details();
|
|
assert_eq!(details.len(), 1);
|
|
assert_eq!(&details[0].1[..], &surfaces[..]);
|
|
sampler.cache.clear();
|
|
let generated: LodSurfaces =
|
|
Arc::new(std::array::from_fn(|_| crate::lod::Column::default()));
|
|
sampler.inner = Box::new(SavedOnly(vec![
|
|
((-2, 3), generated.clone()),
|
|
((-9, 9), generated.clone()),
|
|
]));
|
|
let details = sampler.drain_details();
|
|
assert_eq!(
|
|
&details[0].1[..],
|
|
&surfaces[..],
|
|
"unrequested batch neighbours must preserve saved builds"
|
|
);
|
|
assert!(Arc::ptr_eq(&details[1].1, &generated));
|
|
sampler.inner =
|
|
crate::streaming::ChunkGenerator::lod_sampler(sampler.generator.inner.clone());
|
|
let grid = sampler.grid(-32, 48, 2, 16);
|
|
for z in 0..8 {
|
|
for x in 0..8 {
|
|
assert_eq!(
|
|
grid[z * 16 + x],
|
|
crate::lod::Column::reduced(&surfaces, x * 2, z * 2, 2),
|
|
"saved builds must override a batched direct grid"
|
|
);
|
|
}
|
|
}
|
|
drop((save, sampler, nether));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn saved_far_surface_rejects_invalid_packed_palettes() {
|
|
let mut states = Tag::compound([
|
|
("palette", Tag::List(vec![Tag::Byte(0), Tag::Byte(1)])),
|
|
("data", Tag::LongArray(vec![0; 256])),
|
|
]);
|
|
assert_eq!(lod_palette_index(&states, 4095, 4096, 4), Some(0));
|
|
assert_eq!(lod_palette_index(&states, 4096, 4096, 4), None);
|
|
put(&mut states, "data", Tag::LongArray(vec![15; 256]));
|
|
assert_eq!(lod_palette_index(&states, 0, 4096, 4), None);
|
|
put(&mut states, "data", Tag::LongArray(vec![0; 255]));
|
|
assert_eq!(lod_palette_index(&states, 0, 4096, 4), None);
|
|
}
|
|
|
|
#[test]
|
|
fn save_batch_preserves_order_coordinates_and_ownership() {
|
|
use crate::containers::BlockEntity;
|
|
let mut entities = HashMap::new();
|
|
let mut names = HashMap::new();
|
|
for x in [i32::MIN, -17, -16, -1, 0, 15, 16, i32::MAX] {
|
|
for z in [-17, -16, -1, 0, 15, 16] {
|
|
let p = (x, 64, z);
|
|
entities.insert(p, BlockEntity::Chest(vec![None; 27]));
|
|
names.insert(p, format!("container {x},{z}"));
|
|
}
|
|
}
|
|
// Names without a modelled entity must also survive the snapshot.
|
|
names.insert((-2, 80, -3), "orphan name".into());
|
|
let mut source = Chunk::empty(-1, -1);
|
|
source
|
|
.block_entities
|
|
.push(((99, 0, 99), BlockEntity::Chest(vec![])));
|
|
source.block_names.push(((99, 0, 99), "stale".into()));
|
|
source.saved = Some(Arc::new(ChunkExtras::default()));
|
|
let source = Arc::new(source);
|
|
let batch = vec![
|
|
source.clone(),
|
|
Arc::new(Chunk::empty(1, 1)),
|
|
Arc::new(Chunk::empty(-2, 0)),
|
|
source.clone(), // Preserve input order and repeated coordinates.
|
|
Arc::new(Chunk::empty(i32::MIN >> 4, -2)),
|
|
Arc::new(Chunk::empty(i32::MAX >> 4, 1)),
|
|
Arc::new(Chunk::empty(100, 100)),
|
|
];
|
|
let encode = |entries: &[((i32, i32, i32), BlockEntity)]| {
|
|
entries
|
|
.iter()
|
|
.map(|(p, e)| encode_block_entity(*p, e, "minecraft:chest"))
|
|
.collect::<Vec<_>>()
|
|
};
|
|
for input in [&batch[..0], &batch[..1], &batch[..]] {
|
|
let actual = chunks_with_block_entities(input, &entities, &names);
|
|
assert_eq!(actual.len(), input.len());
|
|
for (c, original) in actual.iter().zip(input) {
|
|
let expected: Vec<_> = entities
|
|
.iter()
|
|
.filter(|(p, _)| (p.0 >> 4, p.2 >> 4) == (c.x, c.z))
|
|
.map(|(p, e)| (*p, e.clone()))
|
|
.collect();
|
|
let expected_names: Vec<_> = names
|
|
.iter()
|
|
.filter(|(p, _)| (p.0 >> 4, p.2 >> 4) == (c.x, c.z))
|
|
.map(|(p, n)| (*p, n.clone()))
|
|
.collect();
|
|
assert_eq!((c.x, c.z), (original.x, original.z));
|
|
assert_eq!(encode(&c.block_entities), encode(&expected));
|
|
assert_eq!(c.block_names, expected_names);
|
|
assert!(Arc::ptr_eq(&c.sections[0], &original.sections[0]));
|
|
if let Some(saved) = &original.saved {
|
|
assert!(Arc::ptr_eq(c.saved.as_ref().unwrap(), saved));
|
|
}
|
|
}
|
|
}
|
|
let snapshot = chunks_with_block_entities(&batch, &entities, &names);
|
|
entities.clear();
|
|
names.clear();
|
|
assert!(!snapshot[0].block_entities.is_empty());
|
|
assert!(!snapshot[0].block_names.is_empty());
|
|
assert_eq!(source.block_names[0].1, "stale");
|
|
assert_eq!(source.block_entities[0].0, (99, 0, 99));
|
|
}
|
|
|
|
#[test]
|
|
fn records_compressed_on_helpers_match_one_thread_in_order() {
|
|
use super::{Record, compress_records};
|
|
let records: Vec<((i32, i32), Record)> = (0..53i32)
|
|
.map(|i| {
|
|
let record = if i % 7 == 3 {
|
|
Record::Delete
|
|
} else {
|
|
let payload: Vec<i64> = (0..i * 97 % 2000).map(|v| i64::from(v * i)).collect();
|
|
Record::Tag(Arc::new(NamedTag {
|
|
name: "".into(),
|
|
tag: Tag::compound([
|
|
("xPos", Tag::Int(i)),
|
|
("Data", Tag::LongArray(payload)),
|
|
]),
|
|
}))
|
|
};
|
|
((i, -i), record)
|
|
})
|
|
.collect();
|
|
let refs: Vec<_> = records.iter().map(|(k, r)| (*k, r)).collect();
|
|
let compressed = compress_records(&refs, 1234);
|
|
assert_eq!(compressed.len(), records.len());
|
|
for ((_, record), got) in records.iter().zip(compressed) {
|
|
let want = record
|
|
.tag()
|
|
.map(|t| ChunkRecord::from_nbt(&t, Compression::Zlib, 1234, Limits::default()))
|
|
.transpose()
|
|
.unwrap();
|
|
let got = got.unwrap();
|
|
assert_eq!(
|
|
got.as_ref().map(|r| (&r.compressed, r.timestamp)),
|
|
want.as_ref().map(|r| (&r.compressed, r.timestamp))
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn older_worlds_are_upgraded_on_opening() {
|
|
let dir = std::env::temp_dir().join(format!("horizon-dv-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
let level =
|
|
|v: i32| Tag::compound([("Data", Tag::compound([("DataVersion", Tag::Int(v))]))]);
|
|
let version = |dir: &std::path::Path| {
|
|
super::read_dat(&dir.join("level.dat"))
|
|
.and_then(|r| super::number(r.get("Data")?.get("DataVersion")))
|
|
};
|
|
// 1.12.2 and 1.16.5: upgraded too, every server fix is ported.
|
|
for old in [1343, 2586] {
|
|
super::write_dat(&dir.join("level.dat"), level(old)).unwrap();
|
|
super::upgrade_older_world(&dir).unwrap();
|
|
assert_eq!(version(&dir), Some(i64::from(super::DATA_VERSION)));
|
|
}
|
|
// 1.21.1: upgraded to the current version.
|
|
super::write_dat(&dir.join("level.dat"), level(3955)).unwrap();
|
|
super::upgrade_older_world(&dir).unwrap();
|
|
assert_eq!(version(&dir), Some(i64::from(super::DATA_VERSION)));
|
|
super::upgrade_older_world(&dir).unwrap();
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
}
|
|
#[test]
|
|
fn write_completion_polls_without_waiting_and_keeps_latest_snapshot() {
|
|
let dir = std::env::temp_dir().join(format!("horizon-save-poll-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
let save = super::SaveDir::new(dir.clone());
|
|
let lock = super::SessionLock::acquire(&dir).unwrap();
|
|
let path = save.region_path("entities", 0, 0);
|
|
let region = super::cached_region(&save.entity_regions, (0, 0), &path, true)
|
|
.unwrap()
|
|
.unwrap();
|
|
// Hold the actual region lock, rather than relying on disk speed or sleeps.
|
|
let blocked = region.lock().unwrap();
|
|
let entity = |version| Tag::compound([("version", Tag::Int(version))]);
|
|
save.save_entities_later(vec![((1, 2), vec![entity(1)])])
|
|
.unwrap();
|
|
save.save_entities_later(vec![((1, 2), vec![entity(2)])])
|
|
.unwrap();
|
|
assert!(!save.writes_finished().unwrap());
|
|
assert_eq!(save.load_entities(1, 2), vec![entity(2)]);
|
|
assert!(super::SessionLock::acquire(&dir).is_err());
|
|
drop(blocked);
|
|
save.flush().unwrap();
|
|
assert!(save.writes_finished().unwrap());
|
|
let reopened = super::SaveDir::new(dir.clone());
|
|
assert_eq!(reopened.load_entities(1, 2), vec![entity(2)]);
|
|
save.save_entities_later(vec![((1, 2), vec![])]).unwrap();
|
|
save.flush().unwrap();
|
|
assert!(
|
|
super::SaveDir::new(dir.clone())
|
|
.load_entities(1, 2)
|
|
.is_empty()
|
|
);
|
|
drop((reopened, save, lock));
|
|
let _ = std::fs::remove_dir_all(dir);
|
|
}
|
|
|
|
#[test]
|
|
fn failed_async_writes_are_readable_and_never_reported_durable() {
|
|
let dir = std::env::temp_dir().join(format!("horizon-save-failure-{}", std::process::id()));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
// A file where a directory is needed causes a real writer I/O error.
|
|
std::fs::write(dir.join("entities"), b"blocked").unwrap();
|
|
let save = super::SaveDir::new(dir.clone());
|
|
let entity = Tag::compound([("version", Tag::Int(3))]);
|
|
save.save_entities_later(vec![((0, 0), vec![entity.clone()])])
|
|
.unwrap();
|
|
assert!(save.flush().is_err());
|
|
assert!(save.writes_finished().is_err());
|
|
assert_eq!(save.load_entities(0, 0), vec![entity]);
|
|
// The failure stays visible on subsequent barriers too.
|
|
assert!(save.flush().is_err());
|
|
drop(save);
|
|
let _ = std::fs::remove_dir_all(dir);
|
|
}
|
|
|
|
#[test]
|
|
fn session_lock_is_exclusive() {
|
|
let dir = std::env::temp_dir().join(format!("horizon-lock-{}", std::process::id()));
|
|
let first = super::SessionLock::acquire(&dir).expect("first lock");
|
|
assert!(super::SessionLock::acquire(&dir).is_err());
|
|
assert_eq!(
|
|
std::fs::read(dir.join("session.lock")).unwrap(),
|
|
[0x26, 0x03]
|
|
);
|
|
drop(first);
|
|
assert!(super::SessionLock::acquire(&dir).is_ok());
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
}
|
|
/// #749: a copy of the lock's descriptor (a child process spawned on
|
|
/// another thread holds one until it execs) must not keep a released
|
|
/// world locked.
|
|
#[test]
|
|
fn session_lock_releases_while_a_descriptor_copy_lives() {
|
|
let dir = std::env::temp_dir().join(format!("horizon-lock-copy-{}", std::process::id()));
|
|
let lock = super::SessionLock::acquire(&dir).expect("first lock");
|
|
let copy = lock.0.try_clone().unwrap();
|
|
drop(lock);
|
|
assert!(super::SessionLock::acquire(&dir).is_ok());
|
|
drop(copy);
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
}
|
|
#[test]
|
|
fn crafter_block_entity_round_trips() {
|
|
let mut crafter = crate::containers::Crafter::default();
|
|
crafter.items[2] = Some(crate::items::ItemStack::new("minecraft:stick", 5));
|
|
crafter.disabled[4] = true;
|
|
crafter.triggered = true;
|
|
crafter.crafting_ticks = 3;
|
|
let tag = encode_block_entity(
|
|
(7, 8, 9),
|
|
&crate::containers::BlockEntity::Crafter(crafter),
|
|
"minecraft:crafter",
|
|
);
|
|
let (pos, back) = decode_block_entity(&tag).expect("crafter");
|
|
assert_eq!(pos, (7, 8, 9));
|
|
let crate::containers::BlockEntity::Crafter(back) = back else {
|
|
panic!("not a crafter");
|
|
};
|
|
assert_eq!(back.items[2].as_ref().map(|s| s.count), Some(5));
|
|
assert!(back.disabled[4] && !back.disabled[3]);
|
|
assert!(back.triggered);
|
|
assert_eq!(back.crafting_ticks, 3);
|
|
assert_eq!(back.redstone_signal(), 2);
|
|
}
|
|
#[test]
|
|
fn spawner_block_entity_round_trips() {
|
|
// A dungeon spawner as vanilla saves it (`id` is mob_spawner, not the block).
|
|
let saved = horizon_world::nbt::parse_snbt(
|
|
r#"{id:"minecraft:mob_spawner",x:67,y:-52,z:-64,Delay:20s,SpawnData:{entity:{id:"minecraft:zombie"}},SpawnPotentials:[]}"#,
|
|
)
|
|
.unwrap()
|
|
.0;
|
|
let (pos, back) = decode_block_entity(&saved).expect("spawner");
|
|
assert_eq!(pos, (67, -52, -64));
|
|
let crate::containers::BlockEntity::Spawner(spawner) = &back else {
|
|
panic!("not a spawner");
|
|
};
|
|
let next = spawner.next_data().and_then(|d| d.id());
|
|
assert_eq!(next.as_deref(), Some("minecraft:zombie"));
|
|
let tag = encode_block_entity(pos, &back, "minecraft:spawner");
|
|
let (_, again) = decode_block_entity(&tag).expect("spawner again");
|
|
let crate::containers::BlockEntity::Spawner(again) = again else {
|
|
panic!("not a spawner");
|
|
};
|
|
assert_eq!(again.update_tag(), spawner.update_tag());
|
|
}
|
|
#[test]
|
|
fn banner_block_entity_round_trips() {
|
|
let banner = crate::containers::Banner {
|
|
layers: vec![crate::banner::BannerLayer::new("minecraft:creeper", "lime")],
|
|
name: Some("Flag".into()),
|
|
components: [("minecraft:rarity".into(), string("uncommon"))].into(),
|
|
};
|
|
let tag = encode_block_entity(
|
|
(1, 2, 3),
|
|
&crate::containers::BlockEntity::Banner(banner.clone()),
|
|
"minecraft:red_banner",
|
|
);
|
|
let (pos, back) = decode_block_entity(&tag).expect("banner");
|
|
assert_eq!(pos, (1, 2, 3));
|
|
let crate::containers::BlockEntity::Banner(back) = back else {
|
|
panic!("not a banner");
|
|
};
|
|
assert_eq!(back.layers, banner.layers);
|
|
assert_eq!(back.name, banner.name);
|
|
assert_eq!(back.components, banner.components);
|
|
}
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn skull_block_entity_keeps_its_profile() {
|
|
// A placed `player_head` as vanilla saves it: the owning player's
|
|
// `profile` survives load, encode and `canonical`.
|
|
let saved = horizon_world::nbt::parse_snbt(
|
|
r#"{id:"minecraft:skull",x:10,y:64,z:20,profile:{name:"Steve",id:[I;1,2,3,4],properties:[{name:"textures",value:"abc"}]},note_block_sound:"minecraft:entity.player.hurt",custom_name:"Trophy"}"#,
|
|
)
|
|
.unwrap()
|
|
.0;
|
|
let (pos, back) = decode_block_entity(&saved).expect("skull");
|
|
assert_eq!(pos, (10, 64, 20));
|
|
let crate::containers::BlockEntity::Skull(skull) = &back else {
|
|
panic!("not a skull");
|
|
};
|
|
assert_eq!(skull.profile, saved.get("profile").cloned());
|
|
assert_eq!(
|
|
skull.note_block_sound.as_deref(),
|
|
Some("minecraft:entity.player.hurt")
|
|
);
|
|
assert_eq!(back.id(), "minecraft:skull");
|
|
let tag = encode_block_entity(pos, &back, "minecraft:player_head");
|
|
assert_eq!(
|
|
crate::block_entity_nbt::id(&tag).as_deref(),
|
|
Some("minecraft:skull")
|
|
);
|
|
assert_eq!(tag.get("profile"), saved.get("profile"));
|
|
let (_, again) = decode_block_entity(&tag).expect("skull again");
|
|
let crate::containers::BlockEntity::Skull(again) = again else {
|
|
panic!("not a skull");
|
|
};
|
|
assert_eq!(again.profile, skull.profile);
|
|
// A profile-less head (skeleton, creeper) round-trips too.
|
|
let plain = encode_block_entity(
|
|
pos,
|
|
&crate::containers::BlockEntity::Skull(crate::containers::Skull::default()),
|
|
"minecraft:creeper_head",
|
|
);
|
|
let (_, decoded) = decode_block_entity(&plain).expect("plain skull");
|
|
assert!(matches!(decoded, crate::containers::BlockEntity::Skull(_)));
|
|
// The heads and skulls have one; the piston's head is no skull.
|
|
use crate::containers::BlockEntity;
|
|
assert!(matches!(
|
|
BlockEntity::for_block("minecraft:player_wall_head"),
|
|
Some(BlockEntity::Skull(_))
|
|
));
|
|
assert!(BlockEntity::for_block("minecraft:piston_head").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn uuid_text_round_trips() {
|
|
let u = [-158327916, 1572358581, -2125825222, -487948715];
|
|
assert_eq!(uuid_from_text(&uuid_text(u)), Some(u));
|
|
assert_eq!(
|
|
uuid_text([0, 1, 2, 3]),
|
|
"00000000-0000-0001-0000-000200000003"
|
|
);
|
|
let r = random_uuid();
|
|
assert_eq!((r[1] >> 12) & 0xF, 4, "version 4");
|
|
}
|
|
#[test]
|
|
fn creaking_heart_keeps_its_protector_uuid() {
|
|
use crate::containers::{BlockEntity, CreakingHeart};
|
|
let heart = CreakingHeart {
|
|
creaking: Some((Some(7), [1, 2, 3, 4])),
|
|
..Default::default()
|
|
};
|
|
let tag = encode_block_entity(
|
|
(3, 70, -5),
|
|
&BlockEntity::CreakingHeart(Box::new(heart)),
|
|
"minecraft:creaking_heart",
|
|
);
|
|
assert_eq!(
|
|
tag.get("creaking"),
|
|
Some(&Tag::IntArray(vec![1, 2, 3, 4])),
|
|
"vanilla stores the protector's UUID under `creaking`"
|
|
);
|
|
let (pos, entity) = decode_block_entity(&tag).expect("heart decodes");
|
|
assert_eq!(pos, (3, 70, -5));
|
|
let BlockEntity::CreakingHeart(h) = entity else {
|
|
panic!("a creaking heart");
|
|
};
|
|
// The entity id is resolved again once the creaking is loaded.
|
|
assert_eq!(h.creaking, Some((None, [1, 2, 3, 4])));
|
|
let lonely = encode_block_entity(
|
|
(0, 0, 0),
|
|
&BlockEntity::CreakingHeart(Box::default()),
|
|
"minecraft:creaking_heart",
|
|
);
|
|
assert!(lonely.get("creaking").is_none());
|
|
}
|
|
#[test]
|
|
fn light_nibbles_use_vanilla_order() {
|
|
let mut a = Box::new([0u8; 4096]);
|
|
a[0] = 0xF3; // sky 15, block 3 at x=0
|
|
a[1] = 0x52; // sky 5, block 2 at x=1
|
|
let light = Light::Full(a);
|
|
assert_eq!(nibbles(&light, false)[0], 0x23);
|
|
assert_eq!(nibbles(&light, true)[0], 0x5F);
|
|
}
|
|
#[test]
|
|
fn stored_light_loads_with_vanilla_defaults() {
|
|
let mut sky = vec![0u8; 2048];
|
|
sky[0] = 0x5A; // x=0 -> 10, x=1 -> 5
|
|
let section = |y: i8, entries: Vec<(&str, Tag)>| {
|
|
let mut all = vec![("Y", Tag::Byte(y))];
|
|
all.extend(entries);
|
|
Tag::compound(all)
|
|
};
|
|
let tag = Tag::compound([
|
|
("isLightOn", Tag::Byte(1)),
|
|
(
|
|
"sections",
|
|
Tag::List(vec![
|
|
section(
|
|
-4,
|
|
vec![
|
|
("SkyLight", Tag::ByteArray(sky)),
|
|
("BlockLight", Tag::ByteArray(vec![0x21; 2048])),
|
|
],
|
|
),
|
|
// No sky layer: repeats the bottom layer of the section above.
|
|
section(-3, vec![]),
|
|
]),
|
|
),
|
|
]);
|
|
let mut chunk = Chunk::empty(0, 0);
|
|
load_light(&tag, &mut chunk, true);
|
|
assert!(chunk.lit && chunk.light_loaded);
|
|
let at = |c: &Chunk, si: usize, i: usize| c.sections[si].light(i);
|
|
assert_eq!(at(&chunk, 0, 0), 0xA1, "stored sky 10, block 1");
|
|
assert_eq!(at(&chunk, 0, 1), 0x52, "stored sky 5, block 2");
|
|
// Section -3 has no layers; above it (-2..) sky defaults to 15.
|
|
assert_eq!(at(&chunk, 1, 0), 0xF0);
|
|
assert_eq!(at(&chunk, SECTIONS - 1, 5), 0xF0);
|
|
let mut dark = Chunk::empty(0, 0);
|
|
load_light(&tag, &mut dark, false);
|
|
assert_eq!(at(&dark, 1, 0), 0x00, "no skylight dimension");
|
|
let mut unlit = Chunk::empty(0, 0);
|
|
load_light(
|
|
&Tag::compound([("isLightOn", Tag::Byte(0))]),
|
|
&mut unlit,
|
|
true,
|
|
);
|
|
assert!(!unlit.lit && !unlit.light_loaded);
|
|
}
|
|
#[test]
|
|
fn saved_light_matches_reference_for_layers_and_metadata() {
|
|
fn reference(tag: &Tag, chunk: &mut Chunk, sky_light: bool) {
|
|
if tag.get("isLightOn") != Some(&Tag::Byte(1)) {
|
|
return;
|
|
}
|
|
let Some(Tag::List(sections)) = tag.get("sections") else {
|
|
return;
|
|
};
|
|
let mut layers: Vec<(Option<&[u8]>, Option<&[u8]>)> = vec![(None, None); SECTIONS];
|
|
for section in sections {
|
|
let Some(y) = number(section.get("Y")) else {
|
|
continue;
|
|
};
|
|
let si = y as i32 - (MIN_Y >> 4);
|
|
if !(0..SECTIONS as i32).contains(&si) {
|
|
continue;
|
|
}
|
|
let layer = |name: &str| match section.get(name) {
|
|
Some(Tag::ByteArray(a)) if a.len() == 2048 => Some(&a[..]),
|
|
_ => None,
|
|
};
|
|
layers[si as usize] = (layer("SkyLight"), layer("BlockLight"));
|
|
}
|
|
let above = [if sky_light { 15 } else { 0 }; 256];
|
|
crate::light::light_from_layers(chunk, &layers, above, sky_light);
|
|
}
|
|
|
|
let section = |y: Tag, sky: Option<Tag>, block: Option<Tag>| {
|
|
let mut entries = vec![("Y", y)];
|
|
if let Some(v) = sky {
|
|
entries.push(("SkyLight", v));
|
|
}
|
|
if let Some(v) = block {
|
|
entries.push(("BlockLight", v));
|
|
}
|
|
Tag::compound(entries)
|
|
};
|
|
let root = |sections| {
|
|
Tag::compound([
|
|
("isLightOn", Tag::Byte(1)),
|
|
("sections", Tag::List(sections)),
|
|
])
|
|
};
|
|
let check = |tag: &Tag| {
|
|
for sky_light in [false, true] {
|
|
let mut expected = Chunk::empty(-3, 5);
|
|
let s = Arc::make_mut(&mut expected.sections[0]);
|
|
s.light = Light::Full(Box::new([0xab; 4096]));
|
|
s.blocks.set(0, 1);
|
|
s.blocks.set(0, 0);
|
|
s.biomes.set(0, 1);
|
|
s.biomes.set(0, 0);
|
|
let mut actual = expected.clone();
|
|
reference(tag, &mut expected, sky_light);
|
|
load_light(tag, &mut actual, sky_light);
|
|
assert_eq!(
|
|
(actual.lit, actual.light_loaded),
|
|
(expected.lit, expected.light_loaded)
|
|
);
|
|
for (a, b) in actual.sections.iter().zip(&expected.sections) {
|
|
assert_eq!(
|
|
std::mem::discriminant(&a.light),
|
|
std::mem::discriminant(&b.light)
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", a.blocks.to_wire()),
|
|
format!("{:?}", b.blocks.to_wire())
|
|
);
|
|
assert_eq!(
|
|
format!("{:?}", a.biomes.to_wire()),
|
|
format!("{:?}", b.biomes.to_wire())
|
|
);
|
|
for i in 0..4096 {
|
|
assert_eq!(a.light(i), b.light(i), "index {i}, sky {sky_light}");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
for tag in [
|
|
Tag::compound(Vec::<(&str, Tag)>::new()),
|
|
Tag::compound([("isLightOn", Tag::Byte(0))]),
|
|
Tag::compound([("isLightOn", Tag::Byte(2))]),
|
|
Tag::compound([("isLightOn", Tag::Int(1)), ("sections", Tag::List(vec![]))]),
|
|
Tag::compound([("isLightOn", Tag::Byte(1)), ("sections", Tag::Int(0))]),
|
|
root(vec![]),
|
|
] {
|
|
check(&tag);
|
|
}
|
|
// Cover every repeated byte, including 0xF0/0x0F: a uniform byte
|
|
// array need not hold uniform nibbles.
|
|
for byte in 0..=255u8 {
|
|
check(&root(vec![section(
|
|
Tag::Byte(19),
|
|
Some(Tag::ByteArray(vec![byte; 2048])),
|
|
Some(Tag::ByteArray(vec![255 - byte; 2048])),
|
|
)]));
|
|
}
|
|
// Every pair of uniform sky/block nibble values, with missing
|
|
// sections below inheriting the stored bottom row.
|
|
for sky in 0..16u8 {
|
|
for block in 0..16u8 {
|
|
check(&root(vec![section(
|
|
Tag::Byte(1),
|
|
Some(Tag::ByteArray(vec![sky * 17; 2048])),
|
|
Some(Tag::ByteArray(vec![block * 17; 2048])),
|
|
)]));
|
|
}
|
|
}
|
|
for length in [0, 1, 2047, 2048, 2049] {
|
|
for invalid in [
|
|
Tag::Int(1),
|
|
Tag::List(vec![]),
|
|
Tag::ByteArray(vec![0xf0; length]),
|
|
] {
|
|
check(&root(vec![section(
|
|
Tag::Byte(-4),
|
|
Some(invalid.clone()),
|
|
Some(invalid),
|
|
)]));
|
|
}
|
|
}
|
|
let varied: Vec<u8> = (0..2048)
|
|
.map(|i| (i as u8).wrapping_mul(73).wrapping_add(31))
|
|
.collect();
|
|
check(&root(vec![
|
|
section(Tag::Byte(-5), Some(Tag::ByteArray(varied.clone())), None),
|
|
section(Tag::Byte(20), Some(Tag::ByteArray(varied.clone())), None),
|
|
section(
|
|
Tag::String("19".into()),
|
|
Some(Tag::ByteArray(varied.clone())),
|
|
None,
|
|
),
|
|
section(Tag::Byte(19), Some(Tag::ByteArray(varied.clone())), None),
|
|
section(Tag::Byte(17), None, Some(Tag::ByteArray(varied.clone()))),
|
|
section(Tag::Byte(-4), Some(Tag::ByteArray(varied.clone())), None),
|
|
// Last duplicate wins, even when its arrays have wrong types.
|
|
section(
|
|
Tag::Byte(-4),
|
|
Some(Tag::Int(15)),
|
|
Some(Tag::ByteArray(vec![7; 2047])),
|
|
),
|
|
section(Tag::Byte(0), None, Some(Tag::ByteArray(varied))),
|
|
]));
|
|
}
|
|
#[test]
|
|
fn level_round_trips_through_the_vanilla_files() {
|
|
let dir = std::env::temp_dir().join(format!("horizon-level-{}", std::process::id()));
|
|
let _ = fs::remove_dir_all(&dir);
|
|
let mut level = Level {
|
|
name: "Test".into(),
|
|
seed: -42,
|
|
time: 1234,
|
|
day_time: 25000,
|
|
creative: true,
|
|
position: Some([1.5, 70.0, -3.25]),
|
|
rotation: [90.0, 10.0],
|
|
health: 17.0,
|
|
absorption: 5.0,
|
|
food: 15,
|
|
saturation: 2.5,
|
|
inventory: vec![
|
|
(0, "minecraft:stone".into(), 12, 0),
|
|
(5, "minecraft:iron_sword".into(), 1, 3),
|
|
(103, "minecraft:iron_helmet".into(), 1, 0),
|
|
],
|
|
xp_level: 3,
|
|
xp_progress: 0.5,
|
|
xp_total: 30,
|
|
dimension: "minecraft:the_nether".into(),
|
|
world_spawn: Some([8, 64, 8]),
|
|
world_spawn_angle: [45.0, -10.0],
|
|
spawn: Some([20.0, 70.0, 20.0]),
|
|
difficulty_locked: true,
|
|
flying: true,
|
|
..Level::default()
|
|
};
|
|
level.weather.raining = true;
|
|
level.weather.rain_time = 500;
|
|
level.game_rules.insert("keep_inventory".into(), 1);
|
|
level.write(&dir).unwrap();
|
|
let back = Level::read(&dir).unwrap();
|
|
assert_eq!(back.name, "Test");
|
|
assert_eq!(back.seed, -42);
|
|
assert_eq!((back.time, back.day_time), (1234, 25000));
|
|
assert!(back.creative);
|
|
assert!(back.flying);
|
|
assert_eq!(back.position, Some([1.5, 70.0, -3.25]));
|
|
assert_eq!(back.rotation, [90.0, 10.0]);
|
|
assert_eq!((back.health, back.food, back.saturation), (17.0, 15, 2.5));
|
|
assert_eq!(back.absorption, 5.0);
|
|
let mut inv = back.inventory.clone();
|
|
inv.sort();
|
|
assert_eq!(
|
|
inv,
|
|
vec![
|
|
(0, "minecraft:stone".into(), 12, 0),
|
|
(5, "minecraft:iron_sword".into(), 1, 3),
|
|
(103, "minecraft:iron_helmet".into(), 1, 0)
|
|
]
|
|
);
|
|
assert_eq!(
|
|
(back.xp_level, back.xp_progress, back.xp_total),
|
|
(3, 0.5, 30)
|
|
);
|
|
assert_eq!(back.dimension, "minecraft:the_nether");
|
|
assert_eq!(back.world_spawn, Some([8, 64, 8]));
|
|
assert_eq!(back.world_spawn_angle, [45.0, -10.0]);
|
|
assert_eq!(back.spawn, Some([20.0, 70.0, 20.0]));
|
|
assert!(back.difficulty_locked);
|
|
assert!(back.weather.raining);
|
|
assert_eq!(back.weather.rain_time, 500);
|
|
assert_eq!(back.game_rule("keep_inventory"), 1);
|
|
assert_eq!(back.game_rule("random_tick_speed"), 3);
|
|
// Unknown player data survives another save.
|
|
let mut extra = back.player_extra.clone().unwrap();
|
|
put(
|
|
&mut extra,
|
|
"ShoulderEntityLeft",
|
|
Tag::compound([("id", string("minecraft:parrot"))]),
|
|
);
|
|
let mut ender = vec![None; 27];
|
|
ender[3] = Some(crate::items::ItemStack::new("minecraft:diamond", 2));
|
|
let mut again = Level {
|
|
player_extra: Some(extra),
|
|
ender_items: ender,
|
|
// The live amount, not the one the loaded compound held (#1307).
|
|
absorption: 2.0,
|
|
..back
|
|
};
|
|
again.write(&dir).unwrap();
|
|
let third = Level::read(&dir).unwrap();
|
|
assert_eq!(third.absorption, 2.0);
|
|
assert!(matches!(
|
|
third
|
|
.player_extra
|
|
.as_ref()
|
|
.and_then(|p| p.get("ShoulderEntityLeft")),
|
|
Some(Tag::Compound(_))
|
|
));
|
|
// EnderItems round-trip by slot.
|
|
assert_eq!(
|
|
third.ender_items[3].as_ref().map(|s| (&*s.item, s.count)),
|
|
Some(("minecraft:diamond", 2))
|
|
);
|
|
// A dead player's empty inventory replaces the previously loaded items.
|
|
let mut dead = third;
|
|
dead.health = 0.0;
|
|
dead.inventory.clear();
|
|
dead.inventory_components.clear();
|
|
dead.write(&dir).unwrap();
|
|
let dead = Level::read(&dir).unwrap();
|
|
assert_eq!(dead.health, 0.0);
|
|
assert!(dead.inventory.is_empty());
|
|
assert!(dead.inventory_components.is_empty());
|
|
assert!(dead.player_extra.unwrap().get("equipment").is_none());
|
|
assert!(dir.join("data/minecraft/world_gen_settings.dat").exists());
|
|
let _ = fs::remove_dir_all(&dir);
|
|
}
|
|
|
|
#[test]
|
|
fn effects_that_ended_are_not_saved_again() {
|
|
// A player loaded with an effect that has since run out: the loaded
|
|
// compound still holds it, but the save writes only what is active.
|
|
let mut level = Level {
|
|
active_effects: vec![("minecraft:speed".into(), 200, 1, false, true)],
|
|
..Level::default()
|
|
};
|
|
let loaded = level.player_tag();
|
|
assert!(loaded.get("active_effects").is_some());
|
|
level.player_extra = Some(loaded);
|
|
level.active_effects.clear();
|
|
assert!(level.player_tag().get("active_effects").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn creative_flight_status_persists_in_save_and_resets_for_survival() {
|
|
let mut level = Level {
|
|
creative: true,
|
|
flying: true,
|
|
..Level::default()
|
|
};
|
|
let tag = level.player_tag();
|
|
let flying_byte = tag
|
|
.get("abilities")
|
|
.and_then(|a| number(a.get("flying")))
|
|
.unwrap_or(0);
|
|
assert_eq!(flying_byte, 1);
|
|
|
|
let mut loaded = Level::default();
|
|
loaded.read_player(&tag);
|
|
assert!(loaded.flying);
|
|
|
|
// Survival mode resets flying ability to 0 in save.
|
|
level.creative = false;
|
|
level.game_mode = 0;
|
|
let tag_survival = level.player_tag();
|
|
let flying_survival = tag_survival
|
|
.get("abilities")
|
|
.and_then(|a| number(a.get("flying")))
|
|
.unwrap_or(0);
|
|
assert_eq!(flying_survival, 0);
|
|
}
|
|
|
|
/// `RecipesUsed` is what a furnace owes in experience, so a save that drops it pays the
|
|
/// player nothing after a reload.
|
|
#[test]
|
|
fn a_furnaces_recipes_used_survive_a_save() {
|
|
use crate::containers::BlockEntity;
|
|
let Some(BlockEntity::Furnace(mut f)) = BlockEntity::for_block("minecraft:furnace") else {
|
|
panic!("a furnace");
|
|
};
|
|
f.recipes_used
|
|
.insert("minecraft:cooked_porkchop".to_owned(), 3);
|
|
let tag = encode_block_entity((1, 64, 2), &BlockEntity::Furnace(f), "minecraft:furnace");
|
|
let Some((_, BlockEntity::Furnace(back))) = decode_block_entity(&tag) else {
|
|
panic!("a furnace back");
|
|
};
|
|
assert_eq!(back.recipes_used.get("minecraft:cooked_porkchop"), Some(&3));
|
|
}
|
|
|
|
/// A save written before the key was namespaced holds an id twice, once bare: vanilla
|
|
/// refuses such a furnace, so a load merges them under the full id.
|
|
#[test]
|
|
fn a_furnaces_recipes_used_merges_bare_and_full_ids() {
|
|
use crate::containers::BlockEntity;
|
|
let Some(BlockEntity::Furnace(mut f)) = BlockEntity::for_block("minecraft:furnace") else {
|
|
panic!("a furnace");
|
|
};
|
|
f.recipes_used
|
|
.insert("iron_ingot_from_smelting_iron_ore".to_owned(), 2);
|
|
f.recipes_used
|
|
.insert("minecraft:iron_ingot_from_smelting_iron_ore".to_owned(), 3);
|
|
let tag = encode_block_entity((1, 64, 2), &BlockEntity::Furnace(f), "minecraft:furnace");
|
|
let Some((_, BlockEntity::Furnace(back))) = decode_block_entity(&tag) else {
|
|
panic!("a furnace back");
|
|
};
|
|
assert_eq!(back.recipes_used.len(), 1);
|
|
assert_eq!(
|
|
back.recipes_used
|
|
.get("minecraft:iron_ingot_from_smelting_iron_ore"),
|
|
Some(&5)
|
|
);
|
|
}
|
|
}
|