Files
horizon-airdef/crates/horizon-client/src/save.rs
T
Ludovic Marie d50a5e1f64 refactor: ChunkExtras and RolledLoot live in chunk.rs
The chunk stores them, but they were defined in save.rs, which made chunk.rs
depend on save, one of the edges that keep the client lib in a single cycle.
They move to chunk.rs and save re-exports them. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 11:11:39 +01:00

5163 lines
199 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, HashSet},
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,
/// The POI type and its max tickets of each state (`PoiTypes`).
poi: Vec<Option<(&'static str, i32)>>,
}
/// `PoiTypes.register`: the POI type of a block state and its max tickets.
pub fn poi_type(state: &horizon_world::chunk::BlockState) -> Option<(&'static str, i32)> {
let name = state.name.strip_prefix("minecraft:")?;
Some(match name {
"blast_furnace" => ("minecraft:armorer", 1),
"smoker" => ("minecraft:butcher", 1),
"cartography_table" => ("minecraft:cartographer", 1),
"brewing_stand" => ("minecraft:cleric", 1),
"composter" => ("minecraft:farmer", 1),
"barrel" => ("minecraft:fisherman", 1),
"fletching_table" => ("minecraft:fletcher", 1),
"cauldron" | "lava_cauldron" | "water_cauldron" | "powder_snow_cauldron" => {
("minecraft:leatherworker", 1)
}
"lectern" => ("minecraft:librarian", 1),
"stonecutter" => ("minecraft:mason", 1),
"loom" => ("minecraft:shepherd", 1),
"smithing_table" => ("minecraft:toolsmith", 1),
"grindstone" => ("minecraft:weaponsmith", 1),
"bell" => ("minecraft:meeting", 32),
"beehive" => ("minecraft:beehive", 0),
"bee_nest" => ("minecraft:bee_nest", 0),
"nether_portal" => ("minecraft:nether_portal", 0),
"lodestone" => ("minecraft:lodestone", 0),
"test_instance_block" => ("minecraft:test_instance", 0),
// PoiTypes.BEDS is the sixteen colours: no straw bed.
bed if bed.ends_with("_bed") && bed != "straw_bed" => {
if state.properties.get("part").map(String::as_str) != Some("head") {
return None;
}
("minecraft:home", 1)
}
rod if rod.ends_with("lightning_rod") => ("minecraft:lightning_rod", 0),
_ => return None,
})
}
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),
poi: (0..registry.len())
.map(|id| registry.state(BlockStateId(id as u32)).and_then(poi_type))
.collect(),
}
}
/// 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,
poi: Vec::new(),
}
}
/// 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
}
}
pub use crate::chunk::{ChunkExtras, RolledLoot};
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()),
// CampfireBlockEntity.saveAdditional.
BlockEntity::Campfire(c) => {
entries.push(("Items", encode_items(&c.items)));
entries.push(("CookingTimes", Tag::IntArray(c.progress.to_vec())));
entries.push(("CookingTotalTimes", Tag::IntArray(c.total.to_vec())));
}
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()),
BlockEntity::DaylightDetector => {}
}
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(),
},
}
}
/// A loaded container with a loot table and no items yet, rolled as
/// generation rolls it (Horizon does not unpack on first open).
fn roll_loaded_loot(
chunk: &Chunk,
biomes: &Biomes,
tag: &Tag,
be: &mut ((i32, i32, i32), crate::containers::BlockEntity),
) -> Option<RolledLoot> {
let crate::containers::BlockEntity::Chest(slots) = &mut be.1 else {
return None;
};
let table = text(tag.get("LootTable"))?;
if slots.iter().any(Option::is_some) {
return None;
}
let loot = crate::structure_blocks::loaded_loot_data()?;
let (x, y, z) = be.0;
let biome = &biomes.get(chunk.biome(x & 15, y, z & 15)).name;
let seed = crate::structure_blocks::loot_seed(tag);
Some(crate::structure_blocks::roll_container(
slots,
Some(&loot),
table,
seed,
be.0,
biome,
))
}
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),
// CampfireBlockEntity.loadAdditional: missing time arrays stay zeros.
BlockEntity::Campfire(c) => {
for (slot, item) in decode_items(tag.get("Items"), 4).into_iter().enumerate() {
c.items[slot] = item;
}
let ints = |key: &str| match tag.get(key) {
Some(Tag::IntArray(v)) => std::array::from_fn(|i| v.get(i).copied().unwrap_or(0)),
_ => [0; 4],
};
c.progress = ints("CookingTimes");
c.total = ints("CookingTotalTimes");
}
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::DaylightDetector => {}
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))
}
/// The chunk's points of interest as `PoiManager` saves them: each section
/// with POI blocks, valid, with a record per block at its max tickets (a
/// freshly made world). None when the chunk has none.
pub fn encode_poi(chunk: &Chunk, tables: &SaveTables) -> Option<NamedTag> {
let kind = |v: u32| tables.poi.get(v as usize).copied().flatten();
let mut sections = Compound::new();
let mut states = [0u32; 4096];
for (si, section) in chunk.sections.iter().enumerate() {
if !section.blocks.maybe_has(|v| kind(v).is_some()) {
continue;
}
section.unpack(&mut states);
let y = (MIN_Y >> 4) + si as i32;
let records: Vec<Tag> = states
.iter()
.enumerate()
.filter_map(|(i, &v)| {
let (id, tickets) = kind(v)?;
let i = i as i32;
let pos = [
chunk.x * 16 + (i & 15),
y * 16 + (i >> 8),
chunk.z * 16 + ((i >> 4) & 15),
];
let mut record = vec![("pos", Tag::IntArray(pos.to_vec())), ("type", string(id))];
// PoiRecord.CODEC: free_tickets defaults to 0 and is then left out.
if tickets != 0 {
record.push(("free_tickets", Tag::Int(tickets)));
}
Some(Tag::compound(record))
})
.collect();
if !records.is_empty() {
sections.insert(
y.to_string().as_str().into(),
Tag::compound([("Valid", Tag::Byte(1)), ("Records", Tag::List(records))]),
);
}
}
(!sections.is_empty()).then(|| poi_root(sections))
}
/// A record's `free_tickets` from the POI file the chunk had, while the same
/// POI is still there: a bed or job site a villager claimed stays claimed.
fn keep_claims(saved: &mut NamedTag, old: &NamedTag) {
let key = |r: &Tag| match (r.get("pos"), text(r.get("type"))) {
(Some(Tag::IntArray(pos)), Some(kind)) => Some((pos.clone(), kind)),
_ => None,
};
let mut claims = HashMap::new();
if let Some(Tag::Compound(sections)) = old.tag.get("Sections") {
for section in sections.values() {
if let Some(Tag::List(records)) = section.get("Records") {
for r in records {
if let Some(k) = key(r) {
claims.insert(k, number(r.get("free_tickets")).unwrap_or(0) as i32);
}
}
}
}
}
let Tag::Compound(root) = &mut saved.tag else {
return;
};
let Some(Tag::Compound(sections)) = root.get_mut(&"Sections".into()) else {
return;
};
for section in sections.values_mut() {
let Tag::Compound(section) = section else {
continue;
};
let Some(Tag::List(records)) = section.get_mut(&"Records".into()) else {
continue;
};
for r in records {
let Some(&tickets) = key(r).and_then(|k| claims.get(&k)) else {
continue;
};
if let Tag::Compound(r) = r {
if tickets == 0 {
r.remove(&"free_tickets".into());
} else {
r.insert("free_tickets".into(), Tag::Int(tickets));
}
}
}
}
}
fn poi_root(sections: Compound) -> NamedTag {
NamedTag {
name: "".into(),
tag: Tag::compound([
("DataVersion", Tag::Int(DATA_VERSION)),
("Sections", Tag::Compound(sections)),
]),
}
}
/// What a dimension's saved chunks depend on: skylight and the build height
/// (`DimensionType.minY` and `height`). `Chunk` always holds the Overworld's
/// sections; a level saves only the ones inside its own height.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct LevelShape {
pub sky_light: bool,
pub min_y: i32,
pub height: i32,
}
impl LevelShape {
pub const OVERWORLD: Self = Self {
sky_light: true,
min_y: MIN_Y,
height: SECTIONS as i32 * 16,
};
pub const NETHER: Self = Self {
sky_light: false,
min_y: 0,
height: 256,
};
pub const END: Self = Self {
sky_light: true,
min_y: 0,
height: 256,
};
/// The shape of a dimension folder (`dimensions/minecraft/<name>`, or the
/// old `DIM-1` and `DIM1`).
pub fn for_dir(root: &Path) -> Self {
if root.ends_with("the_nether") || root.ends_with("DIM-1") {
Self::NETHER
} else if root.ends_with("the_end") || root.ends_with("DIM1") {
Self::END
} else {
Self::OVERWORLD
}
}
fn min_section(self) -> i32 {
self.min_y >> 4
}
fn section_count(self) -> usize {
(self.height >> 4) as usize
}
fn has_section(self, y: i32) -> bool {
(self.min_section()..self.min_section() + self.section_count() as i32).contains(&y)
}
}
/// A column's sections as `Heightmap.primeHeightmaps` reads them.
struct HeightmapView<'a> {
sections: &'a [Arc<Section>],
tables: &'a SaveTables,
min_y: i32,
height: i32,
}
impl HeightmapChunk for HeightmapView<'_> {
type State = crate::assets::StateFacts;
fn min_y(&self) -> i32 {
self.min_y
}
fn height(&self) -> i32 {
self.height
}
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, shape: LevelShape) -> Tag {
let kinds = [
HeightmapType::WorldSurface,
HeightmapType::OceanFloor,
HeightmapType::MotionBlocking,
HeightmapType::MotionBlockingNoLeaves,
];
let mut maps: Vec<Heightmap> = kinds
.iter()
.filter_map(|k| Heightmap::new(*k, shape.min_y, shape.height).ok())
.collect();
let view = HeightmapView {
sections: &chunk.sections,
tables,
min_y: shape.min_y,
height: shape.height,
};
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,
min_y,
height,
};
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, LevelShape::OVERWORLD)
}
/// The chunk NBT vanilla's `SerializableChunkData.write` produces for a full
/// chunk in a level of `shape`.
pub fn encode_with(
chunk: &Chunk,
registry: &BlockRegistry,
biomes: &Biomes,
tables: Option<&SaveTables>,
shape: LevelShape,
) -> NamedTag {
let sky_light = shape.sky_light;
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;
if !shape.has_section(y) {
continue;
}
// 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 &section.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(&section.light, false))));
}
if sky_light && top_sky.is_some_and(|top| si <= top + 1) {
entries.push(("SkyLight", Tag::ByteArray(nibbles(&section.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(&current)
});
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, &current)
}
None => current,
};
let mut saved = crate::block_entity_nbt::canonical(&merged).unwrap_or(merged);
if let Some(r) = extras.and_then(|x| x.rolled_loot.iter().find(|r| r.pos == *p))
&& let Tag::Compound(map) = &mut saved
&& !r.restore(map)
{
// A loaded source still carries the table; kept, it rolls again on load.
map.remove(&"LootTable".into());
map.remove(&"LootTableSeed".into());
}
saved
})
.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(shape.min_section())),
("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));
}
let starts: Compound = chunk
.structure_starts
.iter()
.filter_map(|start| match start.save() {
Some(tag) => Some((start.name.as_str().into(), tag)),
None => {
log::warn!(
"Horizon: structure start {} not saved: one of its pieces cannot be",
start.name
);
None
}
})
.collect();
if !starts.is_empty()
&& let Some(Tag::Compound(s)) = map.get_mut(&"structures".into())
{
s.insert("starts".into(), Tag::Compound(starts));
}
map.entry("PostProcessing".into())
.or_insert_with(|| Tag::List(vec![Tag::List(Vec::new()); shape.section_count()]));
}
if let Some(t) = tables {
put(&mut root, "Heightmaps", heightmaps(chunk, t, shape));
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(mut be) => {
if let Some(name) = text(e.get("CustomName")) {
chunk.block_names.push((be.0, name));
}
if let Some(rolled) = roll_loaded_loot(&chunk, biomes, e, &mut be) {
extras.rolled_loot.push(rolled);
}
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>,
shape: LevelShape,
) -> NamedTag {
let mut root = encode_with(&proto.column, registry, biomes, tables, shape);
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(); shape.section_count()];
for &[x, y, z] in &proto.column.postprocess {
let section = usize::try_from((y - shape.min_y) >> 4).ok();
if let Some(list) = section.and_then(|s| marks.get_mut(s)) {
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>),
/// A chunk's points of interest, made on the writer thread against the
/// saved ones (`resolve_poi`).
Poi(Arc<Chunk>, Arc<SaveTables>),
Delete,
}
/// What encoding a chunk needs, captured when it is queued.
struct Encoding {
registry: &'static BlockRegistry,
biomes: Arc<Biomes>,
tables: Option<Arc<SaveTables>>,
shape: LevelShape,
}
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.shape,
))),
Record::Poi(c, t) => encode_poi(c, t).map(Arc::new),
Record::Delete => None,
}
}
}
/// A queued POI record as it is written: claims kept from the saved one, and
/// a chunk that lost its last POI gets an empty one, as vanilla trusts a
/// saved section. None when the chunk never had any.
fn resolve_poi(
root: &Path,
cache: &RegionCache,
(x, z): (i32, i32),
record: &Record,
) -> Option<Record> {
let Record::Poi(chunk, tables) = record else {
return Some(record.clone());
};
let old = read_region_record(root, cache, "poi", x, z).unwrap_or_else(|e| {
log::warn!("Horizon: could not read the poi record of chunk {x} {z}: {e}");
None
});
let tag = match (encode_poi(chunk, tables), old) {
(Some(mut tag), Some(old)) => {
keep_claims(&mut tag, &old);
tag
}
(Some(tag), None) => tag,
(None, Some(_)) => poi_root(Compound::new()),
(None, None) => return None,
};
Some(Record::Tag(Arc::new(tag)))
}
fn read_region_record(
root: &Path,
cache: &RegionCache,
folder: &str,
x: i32,
z: i32,
) -> Result<Option<NamedTag>> {
let key = (x >> 5, z >> 5);
let path = region_path(root, folder, key.0, key.1);
let Some(region) = cached_region(cache, key, &path, false)? else {
return Ok(None);
};
let record = region
.lock()
.map_err(|_| "region file poisoned")?
.read(ChunkPos::new(x, z))?;
Ok(match record {
Some(r) => Some(r.nbt(Limits::default())?),
None => 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<(Folder, i32, i32), (u64, Record)>>;
type WriteBatch = (Folder, Vec<((i32, i32), Record, u64)>);
/// The region folders of a dimension.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Folder {
Region,
Entities,
Poi,
}
impl Folder {
fn of(name: &str) -> Self {
match name {
"entities" => Self::Entities,
"poi" => Self::Poi,
_ => Self::Region,
}
}
fn name(self) -> &'static str {
match self {
Self::Region => "region",
Self::Entities => "entities",
Self::Poi => "poi",
}
}
}
/// 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>,
poi_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>>,
/// The dimension's skylight and height, from its folder name.
pub shape: LevelShape,
}
fn is_forced_ticket(ticket: &Tag) -> bool {
matches!(ticket.get("type"), Some(Tag::String(t)) if *t == JavaString::from("minecraft:forced"))
}
impl SaveDir {
pub fn new(root: PathBuf) -> Self {
let shape = LevelShape::for_dir(&root);
Self {
root,
regions: Default::default(),
entity_regions: Default::default(),
poi_regions: Default::default(),
pending: Default::default(),
sequence: AtomicU64::new(0),
writer: Mutex::new(None),
outstanding: Default::default(),
tables: OnceLock::new(),
shape,
}
}
/// 26.3's TicketStorage: persistent tickets live in each dimension's
/// data/minecraft/chunk_tickets.dat, with ChunkPos.CODEC's [x, z] int array.
pub fn load_forced_chunks(&self) -> HashSet<(i32, i32)> {
let Some(data) = read_saved_data(&self.root, "chunk_tickets") else {
return HashSet::new();
};
let Some(Tag::List(tickets)) = data.get("tickets") else {
return HashSet::new();
};
tickets
.iter()
.filter(|t| is_forced_ticket(t))
.filter_map(|t| match t.get("chunk_pos")? {
Tag::IntArray(pos) if pos.len() == 2 => Some((pos[0], pos[1])),
_ => None,
})
.collect()
}
pub fn save_forced_chunks(&self, forced: &HashSet<(i32, i32)>) -> Result<()> {
if forced.is_empty() && !saved_data_path(&self.root, "chunk_tickets").exists() {
return Ok(());
}
let mut data = compound_or_empty(read_saved_data(&self.root, "chunk_tickets"));
// Preserve persistent tickets Horizon does not simulate.
let mut tickets = match data.get("tickets") {
Some(Tag::List(tickets)) => tickets
.iter()
.filter(|t| !is_forced_ticket(t))
.cloned()
.collect::<Vec<_>>(),
_ => Vec::new(),
};
let mut chunks: Vec<_> = forced.iter().copied().collect();
chunks.sort_unstable();
tickets.extend(chunks.into_iter().map(|(x, z)| {
Tag::compound([
("type", Tag::String("minecraft:forced".into())),
("level", Tag::Int(31)), // ChunkMap.FORCED_TICKET_LEVEL: ENTITY_TICKING.
("chunk_pos", Tag::IntArray(vec![x, z])),
])
}));
put(&mut data, "tickets", Tag::List(tickets));
write_saved_data(&self.root, "chunk_tickets", data)
}
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::of(folder), x, z))
.map(|(_, r)| r.clone());
if let Some(record) = pending {
return record.tag().map(|t| (*t).clone());
}
let cache = match Folder::of(folder) {
Folder::Region => &self.regions,
Folder::Entities => &self.entity_regions,
Folder::Poi => &self.poi_regions,
};
read_region_record(&self.root, cache, folder, x, z).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.shape.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.shape);
((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::of(folder), records, wait)
}
fn queue(&self, folder: Folder, 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((folder, 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((folder, 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, poi_regions) = (
self.regions.clone(),
self.entity_regions.clone(),
self.poi_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 (kind, batch) in receive {
let cache = match kind {
Folder::Region => &regions,
Folder::Entities => &entity_regions,
Folder::Poi => &poi_regions,
};
let folder = kind.name();
// 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(&(kind, k.0, k.1)).is_none_or(|p| p.0 <= seq)
})
};
let resolved: Vec<_> = batch
.iter()
.filter(|(k, _, seq)| newest(k, *seq))
.filter_map(|(k, r, _)| Some((*k, resolve_poi(&root, cache, *k, r)?)))
.collect();
let records: Vec<_> = resolved.iter().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(&(kind, k.0, k.1)).is_some_and(|p| p.0 == *seq) {
pending.remove(&(kind, 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.shape)),
)
})
.collect();
self.write_records("region", records, true)?;
self.save_poi(chunks, true)?;
Ok(chunks.len())
}
fn save_poi(&self, chunks: &[Arc<Chunk>], wait: bool) -> Result<()> {
let Some(tables) = self.tables.get() else {
return Ok(());
};
let records = chunks
.iter()
.map(|c| ((c.x, c.z), Record::Poi(c.clone(), tables.clone())))
.collect();
self.queue(Folder::Poi, records, wait)
}
/// `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(),
shape: self.shape,
});
let records = chunks
.iter()
.map(|c| ((c.x, c.z), Record::Chunk(c.clone(), encoding.clone())))
.collect();
self.queue(Folder::Region, records, false)?;
self.save_poi(chunks, 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 use horizon_client_core::uuid::{uuid_from_text, uuid_text};
/// 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(&sections, 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(&(Folder::Region, 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.shape.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 light_view(&self, proto: &crate::streaming::Proto) -> Option<Chunk> {
self.inner.light_view(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 points_of_interest_save_as_poi_sections() {
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES") else {
return;
};
let assets = crate::assets::Assets::load(&PathBuf::from(root)).expect("assets");
let tables = SaveTables::new(&assets);
let state = |name: &str, props: &[(&str, &str)]| {
let mut s = assets
.registry
.state(assets.registry.default_state(name).unwrap())
.unwrap()
.clone();
for (k, v) in props {
s.properties.insert((*k).into(), (*v).into());
}
assets.registry.id(&s).unwrap().0
};
let mut chunk = Chunk::empty(2, -1);
chunk.set(1, 70, 1, state("minecraft:red_bed", &[("part", "head")]));
chunk.set(1, 70, 2, state("minecraft:red_bed", &[("part", "foot")]));
chunk.set(5, 71, 5, state("minecraft:bell", &[]));
chunk.set(6, 71, 5, state("minecraft:stone", &[]));
chunk.set(9, 70, 9, state("minecraft:straw_bed", &[("part", "head")]));
assert!(encode_poi(&Chunk::empty(0, 0), &tables).is_none());
let saved = encode_poi(&chunk, &tables).expect("records");
let Some(Tag::Compound(sections)) = saved.tag.get("Sections") else {
panic!("no sections");
};
assert_eq!(sections.len(), 1);
let section = &sections[&"4".into()];
assert_eq!(section.get("Valid"), Some(&Tag::Byte(1)));
let Some(Tag::List(records)) = section.get("Records") else {
panic!("no records");
};
let records: Vec<_> = records
.iter()
.map(|r| {
(
text(r.get("type")).unwrap(),
r.get("pos").cloned(),
number(r.get("free_tickets")),
)
})
.collect();
assert_eq!(
records,
[
(
"minecraft:home".into(),
Some(Tag::IntArray(vec![33, 70, -15])),
Some(1)
),
(
"minecraft:meeting".into(),
Some(Tag::IntArray(vec![37, 71, -11])),
Some(32)
),
]
);
}
#[test]
fn a_chunk_that_loses_its_last_poi_saves_empty_sections() {
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 = Arc::new(Biomes::load(&root).expect("biomes"));
let bell = assets.registry.default_state("minecraft:bell").unwrap().0;
let dir = std::env::temp_dir().join(format!("horizon-poi-save-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
let save = SaveDir::new(dir.clone());
let _ = save.tables.set(Arc::new(SaveTables::new(&assets)));
let mut chunk = Chunk::empty(0, 0);
chunk.set(5, 71, 5, bell);
let sections = |save: &SaveDir| match save.read_record("poi", 0, 0)?.tag.get("Sections") {
Some(Tag::Compound(s)) => Some(s.len()),
_ => None,
};
save.save_later(&[Arc::new(chunk.clone())], assets.registry, &biomes)
.unwrap();
save.flush().unwrap();
assert_eq!(sections(&save), Some(1));
chunk.set(5, 71, 5, 0);
save.save_later(&[Arc::new(chunk)], assets.registry, &biomes)
.unwrap();
save.flush().unwrap();
assert_eq!(sections(&SaveDir::new(dir.clone())), Some(0));
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn saved_poi_records_keep_their_claims() {
let record = |pos: [i32; 3], kind: &str, tickets: Option<i32>| {
let mut r = vec![("pos", Tag::IntArray(pos.to_vec())), ("type", string(kind))];
if let Some(t) = tickets {
r.push(("free_tickets", Tag::Int(t)));
}
Tag::compound(r)
};
let poi = |records: Vec<Tag>| {
let mut sections = Compound::new();
sections.insert(
"4".into(),
Tag::compound([("Valid", Tag::Byte(1)), ("Records", Tag::List(records))]),
);
poi_root(sections)
};
let old = poi(vec![
record([1, 70, 1], "minecraft:home", None),
record([5, 71, 5], "minecraft:meeting", Some(30)),
]);
let mut saved = poi(vec![
record([1, 70, 1], "minecraft:home", Some(1)),
record([5, 71, 5], "minecraft:meeting", Some(32)),
record([9, 71, 9], "minecraft:home", Some(1)),
]);
keep_claims(&mut saved, &old);
let expected = poi(vec![
record([1, 70, 1], "minecraft:home", None),
record([5, 71, 5], "minecraft:meeting", Some(30)),
record([9, 71, 9], "minecraft:home", Some(1)),
]);
assert_eq!(saved.tag, expected.tag);
}
#[test]
fn unopened_rolled_containers_save_their_loot_table() {
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 tables = SaveTables::new(&assets);
let chest = assets.registry.default_state("minecraft:chest").unwrap();
let mut slots = vec![None; 27];
slots[3] = Some(crate::items::ItemStack::new("minecraft:bone", 2));
let mut chunk = Chunk::empty(0, 0);
chunk.set(1, 64, 2, chest.0);
chunk.block_entities.push((
(1, 64, 2),
crate::containers::BlockEntity::Chest(slots.clone()),
));
let rolled = RolledLoot {
pos: (1, 64, 2),
table: "minecraft:chests/simple_dungeon".into(),
seed: Some(42),
items: encode_items(&slots),
};
chunk.saved = Some(Arc::new(ChunkExtras {
rolled_loot: vec![rolled],
..ChunkExtras::default()
}));
let saved_chest = |chunk: &Chunk| -> Tag {
let saved = encode_with(
chunk,
assets.registry,
&biomes,
Some(&tables),
LevelShape::OVERWORLD,
);
let Some(Tag::List(list)) = saved.tag.get("block_entities") else {
panic!("no block entities");
};
list[0].clone()
};
let unopened = saved_chest(&chunk);
assert_eq!(
text(unopened.get("LootTable")).as_deref(),
Some("minecraft:chests/simple_dungeon")
);
assert_eq!(number(unopened.get("LootTableSeed")), Some(42));
assert!(unopened.get("Items").is_none());
// Taking an item makes the items the container's own.
if let crate::containers::BlockEntity::Chest(s) = &mut chunk.block_entities[0].1 {
s[3] = None;
s[4] = Some(crate::items::ItemStack::new("minecraft:bone", 1));
}
let opened = saved_chest(&chunk);
assert!(opened.get("LootTable").is_none());
assert!(opened.get("Items").is_some());
// Loaded with its table, rolled, then emptied: no table, or it refills on load.
let mut extras = ChunkExtras::clone(chunk.saved.as_ref().unwrap());
extras.block_entity_sources = vec![(
(1, 64, 2),
Tag::compound([
("id", string("minecraft:chest")),
("x", Tag::Int(1)),
("y", Tag::Int(64)),
("z", Tag::Int(2)),
("LootTable", string("minecraft:chests/simple_dungeon")),
("LootTableSeed", Tag::Long(42)),
]),
)];
chunk.saved = Some(Arc::new(extras));
if let crate::containers::BlockEntity::Chest(s) = &mut chunk.block_entities[0].1 {
s.fill(None);
}
let emptied = saved_chest(&chunk);
assert!(emptied.get("LootTable").is_none());
assert!(emptied.get("LootTableSeed").is_none());
}
#[test]
fn nether_and_end_chunks_save_with_their_own_height() {
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 tables = SaveTables::new(&assets);
let rack = assets
.registry
.default_state("minecraft:netherrack")
.unwrap();
let mut chunk = Chunk::empty(0, 0);
for y in 0..128 {
chunk.set(0, y, 0, rack.0);
}
let saved = encode_with(
&chunk,
assets.registry,
&biomes,
Some(&tables),
LevelShape::NETHER,
);
assert_eq!(number(saved.tag.get("yPos")), Some(0));
let Some(Tag::List(sections)) = saved.tag.get("sections") else {
panic!("no sections");
};
let ys: Vec<i32> = sections
.iter()
.filter_map(|s| number(s.get("Y")).map(|y| y as i32))
.collect();
assert_eq!(ys, (0..16).collect::<Vec<_>>());
let Some(Tag::List(post)) = saved.tag.get("PostProcessing") else {
panic!("no PostProcessing");
};
assert_eq!(post.len(), 16);
// Heightmap values count from the level's minimum: the column's top
// block at y=127 reads 128 (vanilla), not 192 (from the Overworld's -64).
let Some(Tag::LongArray(surface)) = saved
.tag
.get("Heightmaps")
.and_then(|h| h.get("WORLD_SURFACE"))
else {
panic!("no WORLD_SURFACE");
};
assert_eq!(surface[0] & 0x1ff, 128);
let overworld = encode_with(
&chunk,
assets.registry,
&biomes,
Some(&tables),
LevelShape::OVERWORLD,
);
assert_eq!(number(overworld.tag.get("yPos")), Some(-4));
assert_eq!(
LevelShape::for_dir(Path::new("w/dimensions/minecraft/the_end")),
LevelShape::END
);
assert_eq!(
LevelShape::for_dir(Path::new("w/DIM-1")),
LevelShape::NETHER
);
}
#[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.shape = LevelShape::NETHER;
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 campfire_block_entity_round_trips() {
let mut c = crate::containers::Campfire::default();
c.items[1] = Some(crate::items::ItemStack::new("minecraft:beef", 1));
c.progress[1] = 120;
c.total[1] = 600;
let tag = encode_block_entity(
(3, 64, -2),
&crate::containers::BlockEntity::Campfire(Box::new(c.clone())),
"minecraft:soul_campfire",
);
// One block entity type for both campfires.
assert_eq!(text(tag.get("id")).as_deref(), Some("minecraft:campfire"));
let (pos, back) = decode_block_entity(&tag).expect("campfire");
assert_eq!(pos, (3, 64, -2));
let crate::containers::BlockEntity::Campfire(back) = back else {
panic!("not a campfire");
};
assert_eq!(*back, c);
// The update tag a server's clients get: the items alone.
let update =
crate::lan::chunks::entity_tag(&crate::containers::BlockEntity::Campfire(Box::new(c)))
.expect("update tag");
assert!(update.get("Items").is_some() && update.get("CookingTimes").is_none());
}
#[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));
}
/// The world's save (Level.write) writes the rules as they are now, and a
/// world opened again reads them back (#74).
#[test]
fn level_save_keeps_changed_rules() {
use crate::gamerules::{GameRules, Value};
let dir =
std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let mut level = super::Level::default();
level.write(&dir).unwrap();
// Rules changed while playing, then saved and loaded again.
let mut rules = GameRules::load(&dir);
assert_eq!(rules, GameRules::default());
assert!(rules.set("advance_time", Value::Bool(false)));
assert!(rules.set("advance_weather", Value::Bool(false)));
assert!(rules.set("random_tick_speed", Value::Int(0)));
level.game_rules = rules.by_name();
level.write(&dir).unwrap();
assert_eq!(GameRules::load(&dir), rules);
let read = super::Level::read(&dir).unwrap();
assert_eq!(read.game_rules, rules.by_name());
assert_eq!(read.game_rule("advance_time"), 0);
let _ = std::fs::remove_dir_all(dir);
}
/// 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)
);
}
#[test]
fn forced_chunks_survive_dimension_restarts_and_removals() {
let root = std::env::temp_dir().join(format!("horizon-forced-{}", std::process::id()));
let _ = fs::remove_dir_all(&root);
let dimensions = [
"minecraft:overworld",
"minecraft:the_nether",
"minecraft:the_end",
];
for (i, dim) in dimensions.iter().enumerate() {
let save = SaveDir::new(dimension_dir(&root, dim));
assert!(save.load_forced_chunks().is_empty());
let forced = HashSet::from([(i as i32, -17), (-23, i as i32), (-1, -1)]);
save.save_forced_chunks(&forced).unwrap();
}
for (i, dim) in dimensions.iter().enumerate() {
let path = dimension_dir(&root, dim);
let save = SaveDir::new(path.clone());
let mut forced = save.load_forced_chunks();
assert_eq!(
forced,
HashSet::from([(i as i32, -17), (-23, i as i32), (-1, -1)])
);
let mut data = read_saved_data(&path, "chunk_tickets").unwrap();
let other = Tag::compound([
("type", Tag::String("minecraft:portal".into())),
("level", Tag::Int(30)),
("chunk_pos", Tag::IntArray(vec![7, -8])),
("ticks_left", Tag::Long(42)),
]);
if let Some(Tag::List(tickets)) = data.get_mut("tickets") {
assert!(
tickets
.iter()
.all(|t| t.get("level") == Some(&Tag::Int(31)))
);
tickets.push(other.clone());
}
write_saved_data(&path, "chunk_tickets", data).unwrap();
forced.remove(&(-1, -1));
save.save_forced_chunks(&forced).unwrap();
drop(save);
let reopened = SaveDir::new(path.clone());
assert_eq!(reopened.load_forced_chunks(), forced);
reopened.save_forced_chunks(&HashSet::new()).unwrap();
assert!(SaveDir::new(path.clone()).load_forced_chunks().is_empty());
assert_eq!(
read_saved_data(&path, "chunk_tickets")
.unwrap()
.get("tickets"),
Some(&Tag::List(vec![other]))
);
}
fs::remove_dir_all(root).unwrap();
}
}