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:
@@ -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.
|
||||
|
||||
@@ -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", ®ions)
|
||||
for (kind, batch) in receive {
|
||||
let cache = match kind {
|
||||
Folder::Region => ®ions,
|
||||
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 = §ions[&"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 {
|
||||
|
||||
Reference in New Issue
Block a user