Saves: write points of interest

Horizon finds villager POIs from the blocks and kept no poi folder, so a
world it made had none. Vanilla rebuilds a missing section on load, but
until a chunk is loaded nothing knows its beds, job sites, bells, nests,
portals or lodestones.

Saving a chunk now writes its POI records the way PoiManager saves its
sections: each section with POI blocks, valid, one record per block of
PoiTypes with its max tickets, free_tickets left out at 0. A chunk that
lost its last POI and had a record gets an empty one, since vanilla
trusts a valid section.

The records are built on the region writer thread, which reads the
saved record there, so unloading chunks reads no files on the tick
thread. A straw bed is no home (PoiTypes.BEDS is the sixteen colours);
/locate poi uses the same table.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
FusselTV
2026-10-25 23:00:07 +01:00
parent 57c5f81299
commit 2143c26a2e
2 changed files with 388 additions and 64 deletions
+1 -32
View File
@@ -2572,38 +2572,7 @@ impl Game<'_> {
/// `PoiTypes`: the point of interest type of a block state.
fn poi_type(&self, state: horizon_world::registry::BlockStateId) -> Option<&'static str> {
let s = self.pack.assets.registry.state(state)?;
let name = s.name.strip_prefix("minecraft:")?;
Some(match name {
"blast_furnace" => "minecraft:armorer",
"smoker" => "minecraft:butcher",
"cartography_table" => "minecraft:cartographer",
"brewing_stand" => "minecraft:cleric",
"composter" => "minecraft:farmer",
"barrel" => "minecraft:fisherman",
"fletching_table" => "minecraft:fletcher",
"cauldron" | "lava_cauldron" | "water_cauldron" | "powder_snow_cauldron" => {
"minecraft:leatherworker"
}
"lectern" => "minecraft:librarian",
"stonecutter" => "minecraft:mason",
"loom" => "minecraft:shepherd",
"smithing_table" => "minecraft:toolsmith",
"grindstone" => "minecraft:weaponsmith",
"bell" => "minecraft:meeting",
"beehive" => "minecraft:beehive",
"bee_nest" => "minecraft:bee_nest",
"nether_portal" => "minecraft:nether_portal",
"lodestone" => "minecraft:lodestone",
"test_instance_block" => "minecraft:test_instance",
n if n.ends_with("_bed") => {
if s.properties.get("part").map(String::as_str) != Some("head") {
return None;
}
"minecraft:home"
}
n if n.ends_with("lightning_rod") => "minecraft:lightning_rod",
_ => return None,
})
horizon_client::save::poi_type(s).map(|(kind, _)| kind)
}
/// `LocateCommand.locatePoi`: `PoiManager.findClosestWithType` within
/// 256 blocks of the source, over the loaded chunks.
+387 -32
View File
@@ -247,6 +247,44 @@ pub struct SaveTables {
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 {
@@ -275,6 +313,9 @@ impl SaveTables {
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.
@@ -287,6 +328,7 @@ impl SaveTables {
block_entity: Vec::new(),
heightmaps,
air: 0,
poi: Vec::new(),
}
}
/// Which states carry a block entity (`BlockFacts`), to drop entries for
@@ -734,6 +776,103 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
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)),
]),
}
}
/// A column's sections as `Heightmap.primeHeightmaps` reads them.
struct HeightmapView<'a> {
sections: &'a [Arc<Section>],
@@ -1555,6 +1694,9 @@ 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.
@@ -1575,14 +1717,86 @@ impl Record {
e.tables.as_deref(),
e.sky_light,
))),
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<(bool, i32, i32), (u64, Record)>>;
type WriteBatch = (bool, Vec<((i32, i32), Record, u64)>);
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.
@@ -1604,6 +1818,7 @@ 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>>,
@@ -1620,6 +1835,7 @@ impl SaveDir {
root,
regions: Default::default(),
entity_regions: Default::default(),
poi_regions: Default::default(),
pending: Default::default(),
sequence: AtomicU64::new(0),
writer: Mutex::new(None),
@@ -1636,21 +1852,17 @@ impl SaveDir {
.pending
.lock()
.ok()?
.get(&(folder != "region", x, z))
.get(&(Folder::of(folder), x, z))
.map(|(_, r)| r.clone());
if let Some(record) = pending {
return record.tag().map(|t| (*t).clone());
}
let key = (x >> 5, z >> 5);
let cache = if folder == "region" {
&self.regions
} else {
&self.entity_regions
let cache = match Folder::of(folder) {
Folder::Region => &self.regions,
Folder::Entities => &self.entity_regions,
Folder::Poi => &self.poi_regions,
};
let path = self.region_path(folder, key.0, key.1);
let region = cached_region(cache, key, &path, false).ok()??;
let record = region.lock().ok()?.read(ChunkPos::new(x, z)).ok()??;
record.nbt(Limits::default()).ok()
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)?;
@@ -1710,16 +1922,16 @@ impl SaveDir {
.into_iter()
.map(|(k, t)| (k, t.map_or(Record::Delete, |t| Record::Tag(Arc::new(t)))))
.collect();
self.queue(folder != "region", records, wait)
self.queue(Folder::of(folder), records, wait)
}
fn queue(&self, entities: bool, records: Vec<((i32, i32), Record)>, wait: bool) -> Result<()> {
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((entities, key.0, key.1), (seq, record.clone()));
pending.insert((folder, key.0, key.1), (seq, record.clone()));
batch.push((key, record, seq));
}
}
@@ -1730,7 +1942,7 @@ impl SaveDir {
.map_err(|_| "writer poisoned")? += 1;
let mut writer = self.writer.lock().map_err(|_| "writer poisoned")?;
let writer = writer.get_or_insert_with(|| self.start_writer());
if writer.send.send((entities, batch)).is_err() {
if writer.send.send((folder, batch)).is_err() {
*self
.outstanding
.error
@@ -1753,30 +1965,36 @@ impl SaveDir {
fn start_writer(&self) -> Writer {
let (send, receive) = mpsc::channel::<WriteBatch>();
let root = self.root.clone();
let (regions, entity_regions) = (self.regions.clone(), self.entity_regions.clone());
let (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 (entities, batch) in receive {
let (folder, cache) = if entities {
("entities", &entity_regions)
} else {
("region", &regions)
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(&(entities, k.0, k.1)).is_none_or(|p| p.0 <= seq)
p.get(&(kind, k.0, k.1)).is_none_or(|p| p.0 <= seq)
})
};
let records: Vec<_> = batch
let resolved: Vec<_> = batch
.iter()
.filter(|(k, _, seq)| newest(k, *seq))
.map(|(k, r, _)| (*k, r))
.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}");
@@ -1788,11 +2006,8 @@ impl SaveDir {
&& let Ok(mut pending) = pending.lock()
{
for (k, _, seq) in &batch {
if pending
.get(&(entities, k.0, k.1))
.is_some_and(|p| p.0 == *seq)
{
pending.remove(&(entities, k.0, k.1));
if pending.get(&(kind, k.0, k.1)).is_some_and(|p| p.0 == *seq) {
pending.remove(&(kind, k.0, k.1));
}
}
}
@@ -1861,8 +2076,19 @@ impl SaveDir {
})
.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(
@@ -1881,7 +2107,8 @@ impl SaveDir {
.iter()
.map(|c| ((c.x, c.z), Record::Chunk(c.clone(), encoding.clone())))
.collect();
self.queue(false, records, false)?;
self.queue(Folder::Region, records, false)?;
self.save_poi(chunks, false)?;
Ok(chunks.len())
}
/// Write the entity chunks (`EntityStorage`): an empty list deletes it.
@@ -3326,7 +3553,7 @@ impl SaveDir {
.pending
.lock()
.ok()?
.get(&(false, x, z))
.get(&(Folder::Region, x, z))
.map(|(_, record)| record.clone());
let root = if let Some(record) = pending {
record.tag().map(|tag| (*tag).clone())?
@@ -3436,6 +3663,134 @@ impl<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
#[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 saved_far_surface_reads_builds_and_water_without_gameplay_chunks() {
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES") else {