Merge pull request #2437 from RoyalPixelsDE/fix/structure-mob-finalize

🤖 Agent: Gate check by Ludovic's AI agent (Claude). Checked against 26.3: `StructureTemplate.placeEntities` and the pieces' markers call `finalizeSpawn(level, difficulty, STRUCTURE, null)` inside the `WorldGenRegion` with its random, and the save keys now follow `addAdditionalSaveData`. Your rebased head is the reviewed change plus the comment cleanup, on current main. Gate: this wave's 50 PRs merged on main in one tree (union 9033a9c3b): fmt and clippy `-D warnings` clean, the horizon-client (1136 lib plus the integration tests), horizon-client-core (37), horizon-world (165) and horizon-protocol (100) tests pass, the fast build links, and the 140 harnesses `parity.py` picks for the tree's changed files pass on playhorizon (remote_fireworks, a known load flake there, passed on a rerun on a quiet Mac mini). `lan_e2e.py` passes 14 checks with the host on its server thread and in-frame (chest, xp, damage, kills, projectiles, mobs, drops, body, stopsound, digging, instant_digging, books, knockback, barter); `hurt` fails on main too when run after `damage` (check-order dependency, not this wave). Thanks @FusselTV!
This commit is contained in:
Ludovic Marie
2026-10-27 03:49:24 +01:00
committed by GitHub
11 changed files with 698 additions and 20 deletions
+148 -6
View File
@@ -180,7 +180,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
("Silent", m.silent),
("NoGravity", m.no_gravity),
("Glowing", m.glowing),
("Invulnerable", m.invulnerable_flag),
] {
if on {
map.insert(key.into(), Tag::Byte(1));
@@ -188,6 +187,26 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
map.remove(&horizon_world::nbt::JavaString::from(key));
}
}
map.insert(
"Invulnerable".into(),
Tag::Byte(i8::from(m.invulnerable_flag)),
);
map.insert(
"LeftHanded".into(),
Tag::Byte(i8::from(m.extra.left_handed)),
);
// Keys of older formats that structure templates still carry.
for key in [
"HandItems",
"ArmorItems",
"HandDropChances",
"ArmorDropChances",
"Dimension",
"HurtByTimestamp",
"Leashed",
] {
map.remove(&horizon_world::nbt::JavaString::from(key));
}
if m.ticks_frozen > 0 {
map.insert("TicksFrozen".into(), Tag::Int(m.ticks_frozen));
} else {
@@ -197,7 +216,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
("AbsorptionAmount", Tag::Float(0)),
("FallFlying", Tag::Byte(0)),
("CanPickUpLoot", Tag::Byte(i8::from(m.can_pick_up_loot()))),
("LeftHanded", Tag::Byte(0)),
("current_impulse_context_reset_grace_time", Tag::Int(0)),
(
"Brain",
Tag::compound([("memories", Tag::Compound(Compound::new()))]),
@@ -209,7 +228,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
// Only breedable animals have an age; a loaded creature that was saved without
// one (a frog) stays without.
let aged = raw.is_none_or(|r| r.get("Age").is_some());
if m.kind.category == "creature" && aged {
if (m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin) && aged {
map.insert("Age".into(), Tag::Int(m.extra.age));
map.insert("AgeLocked".into(), Tag::Byte(i8::from(m.extra.age_locked)));
map.insert("ForcedAge".into(), Tag::Int(m.extra.forced_age));
@@ -260,6 +279,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
.or_insert_with(|| string("minecraft:classic"));
}
"minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => {
// Only Piglin.addAdditionalSaveData writes CannotHunt.
if id == "minecraft:piglin_brute" {
map.remove(&"CannotHunt".into());
}
map.insert(
"IsImmuneToZombification".into(),
Tag::Byte(i8::from(m.extra.flag2)),
@@ -498,8 +521,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
)])
});
}
"minecraft:zombie" => {
map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
"minecraft:zombie" | "minecraft:husk" | "minecraft:drowned" => {
for (key, value) in [
("DrownedConversionTime", Tag::Int(-1)),
("InWaterTime", Tag::Int(-1)),
@@ -532,6 +554,21 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
Tag::Byte(i8::from(m.extra.can_break_doors)),
);
}
if matches!(
id,
"minecraft:zombie"
| "minecraft:husk"
| "minecraft:drowned"
| "minecraft:zombie_villager"
| "minecraft:zombified_piglin"
| "minecraft:piglin"
| "minecraft:zoglin"
) {
map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
}
if let Some(a) = m.extra.attributes.as_deref() {
put_attributes(map, m, a);
}
crate::mobs::raider::write_nbt(m, map);
crate::mobs::riders::write_nbt(m, map);
// LivingEntity equipment: what the mob holds now.
@@ -614,6 +651,89 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
}
tag
}
/// `AttributeMap.pack` for the attributes with a base or permanent modifier
/// finalizeSpawn set, over the saved list.
fn put_attributes(map: &mut Compound, m: &Mob, a: &crate::mobs::finalize::Attributes) {
use crate::mobs::finalize::{self, Attr, Op};
let mut list = match map.get(&"attributes".into()) {
Some(Tag::List(l)) => l.clone(),
_ => Vec::new(),
};
for attr in Attr::ALL {
let modifiers: Vec<Tag> = a
.modifiers
.iter()
.filter(|x| x.attr == attr)
.map(|x| {
let op = match x.op {
Op::AddValue => "add_value",
Op::AddMultipliedBase => "add_multiplied_base",
Op::AddMultipliedTotal => "add_multiplied_total",
};
Tag::compound([
("id", string(x.id)),
("amount", Tag::Double(x.amount.to_bits())),
("operation", string(op)),
])
})
.collect();
if modifiers.is_empty() && !a.bases.iter().any(|(b, _)| *b == attr) {
continue;
}
let id = format!("minecraft:{}", attr.name());
let mut entry = vec![
("id", string(&id)),
("base", Tag::Double(finalize::base_value(m, attr).to_bits())),
];
if !modifiers.is_empty() {
entry.push(("modifiers", Tag::List(modifiers)));
}
let entry = Tag::compound(entry);
match list
.iter_mut()
.find(|t| text(t.get("id")).as_deref() == Some(id.as_str()))
{
Some(t) => *t = entry,
None => list.push(entry),
}
}
map.insert("attributes".into(), Tag::List(list));
}
/// `Brain.Packed`: the memories finalizeSpawn set, over the saved ones.
pub fn put_brain(map: &mut Compound, m: &Mob, dimension: &str) {
if m.extra.memories.is_empty() {
return;
}
let mut memories = match map.get(&"Brain".into()).and_then(|b| b.get("memories")) {
Some(Tag::Compound(c)) => c.clone(),
_ => Compound::new(),
};
for &(name, value, ttl) in &m.extra.memories {
let value = match name {
"hunted_recently" => Tag::Byte(value as i8),
"home" => match m.extra.home {
Some(p) => Tag::compound([
("dimension", string(dimension)),
("pos", Tag::IntArray(p.to_vec())),
]),
None => continue,
},
_ => Tag::Int(value as i32),
};
let mut memory = vec![("value", value)];
if ttl != i64::MAX {
memory.push(("ttl", Tag::Long(ttl)));
}
memories.insert(
format!("minecraft:{name}").as_str().into(),
Tag::compound(memory),
);
}
map.insert(
"Brain".into(),
Tag::compound([("memories", Tag::Compound(memories))]),
);
}
/// `CustomName`: a text component saved as a string or a `{text: ..}` compound.
fn custom_name(tag: &Tag) -> Option<String> {
match tag.get("CustomName")? {
@@ -633,6 +753,22 @@ pub fn name_text(tag: &Tag) -> Text {
t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
}
}
/// Mob.finalizeSpawn's follow range bonus in the saved attributes.
pub(crate) fn spawn_bonus(tag: &Tag) -> Option<f64> {
let Some(Tag::List(attrs)) = tag.get("attributes") else {
return None;
};
let range = attrs
.iter()
.find(|a| text(a.get("id")).as_deref() == Some("minecraft:follow_range"))?;
let Some(Tag::List(modifiers)) = range.get("modifiers") else {
return None;
};
let bonus = modifiers
.iter()
.find(|x| text(x.get("id")).as_deref() == Some("minecraft:random_spawn_bonus"))?;
float(bonus.get("amount"))
}
pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -> Option<Mob> {
let kind = types.get(&self::kind(tag)?)?.clone();
let position = position(tag)?;
@@ -658,6 +794,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
}
}
}
if let Some(bonus) = spawn_bonus(tag) {
use crate::mobs::finalize::{Attr, Op, add_modifier};
let id = "minecraft:random_spawn_bonus";
add_modifier(&mut m, Attr::FollowRange, id, bonus, Op::AddMultipliedBase);
}
m.health = float(tag.get("Health")).map_or(m.attrs.max_health, |h| h as f32);
m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
// What it holds (equipment.mainhand / offhand), when saved.
@@ -699,7 +840,8 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
m.extra.pick_up_loot = flag(tag, "CanPickUpLoot");
m.custom_name = custom_name(tag);
m.custom_name_text = tag.get("CustomName").map(name_text);
if m.kind.category == "creature" {
m.extra.left_handed = flag(tag, "LeftHanded");
if m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin {
m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32;
m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32;
m.extra.age_locked = flag(tag, "AgeLocked");
+3
View File
@@ -4740,6 +4740,7 @@ impl Game<'_> {
/// What the tick runs after the local player's own update: effects, the
/// world's entities and blocks, and the network hub.
fn tick_world(&mut self, running: bool) -> Result<()> {
self.share_spawn_conditions();
self.update_chunk_tickets();
horizon_client::spans::time("tick_effects", || self.tick_effects(running));
// Player.tick's ItemCooldowns.tick for the window's player (a
@@ -8175,6 +8176,7 @@ impl Game<'_> {
);
self.session_lock = Some(session_lock);
self.end.set_locator(locator);
self.share_spawn_conditions();
self.score = Default::default();
self.fns = Default::default();
self.bosses = Default::default();
@@ -8313,6 +8315,7 @@ impl Game<'_> {
seed,
)?;
self.end.set_locator(locator);
self.share_spawn_conditions();
Ok((streaming, save))
}
/// Change dimension through a portal (Entity.changeDimension with
@@ -430,6 +430,12 @@ impl Game<'_> {
),
}
}
/// What the generator finalizes this level's structure mobs with.
pub(super) fn share_spawn_conditions(&self) {
if let Some(terrain) = self.end.locator() {
terrain.set_spawn_conditions(self.difficulty_id() as u8, self.world.day_time);
}
}
/// `ServerLevel.getCurrentDifficultyAt`.
pub(super) fn local_difficulty(&self, at: [f64; 3]) -> spawning::LocalDifficulty {
use horizon_world::food::Difficulty;
+1
View File
@@ -192,6 +192,7 @@ impl Game<'_> {
let mut locator = self.end.locator();
swap(&mut locator, &mut p.locator);
self.end.set_locator(locator);
self.share_spawn_conditions();
swap(&mut self.save, &mut p.save);
swap(&mut self.block_ticks, &mut p.block_ticks);
swap(&mut self.tick_chunks, &mut p.tick_chunks);
+10 -2
View File
@@ -357,7 +357,8 @@ impl Game<'_> {
pub(super) fn load_mob(&mut self, tag: Tag, mount: Option<u32>) -> Option<u32> {
self.next_entity += 1;
let uuid = entity_nbt::uuid(&tag);
// Structure entities placed with finalizeEntities.
// Structure mobs that generation left to finish: saves from before
// they were finalized at placement, or a placement that could not.
let mut tag = tag;
let mut finalize = false;
if let Tag::Compound(c) = &mut tag {
@@ -449,7 +450,8 @@ impl Game<'_> {
}
}
/// An entity of a type Horizon does not simulate, kept as its compound.
fn load_other(&mut self, tag: Tag, kind: &str) -> Option<u32> {
fn load_other(&mut self, mut tag: Tag, kind: &str) -> Option<u32> {
strip_finalize(&mut tag);
let position = entity_nbt::position(&tag)?;
let rotation = match tag.get("Rotation") {
Some(Tag::List(l)) => {
@@ -1014,3 +1016,9 @@ impl Game<'_> {
self.save.save_entities(chunks)
}
}
/// Only a mob is finalized; another entity drops the request.
fn strip_finalize(tag: &mut Tag) {
if let Tag::Compound(c) = tag {
c.remove(&"horizon:finalize".into());
}
}
+1 -1
View File
@@ -235,7 +235,7 @@ impl Game<'_> {
}
out
}
fn difficulty_id(&self) -> i32 {
pub(super) fn difficulty_id(&self) -> i32 {
use horizon_world::food::Difficulty;
match self.world.health_rules.difficulty {
Difficulty::Peaceful => 0,
+15 -1
View File
@@ -24,7 +24,9 @@ use horizon_world::{
};
use std::{path::Path, sync::Arc};
mod lod;
mod structure_mobs;
use lod::VanillaLodSampler;
use structure_mobs::StructureMobFinalizer;
pub struct VanillaTerrain {
generator: OverworldGenerator,
@@ -32,6 +34,7 @@ pub struct VanillaTerrain {
biome_map: Vec<u16>,
/// Loot tables for generated containers.
loot: Option<Arc<horizon_world::loot::LootData>>,
structure_mobs: Arc<StructureMobFinalizer>,
/// A worker for structure queries from the game thread.
query: std::sync::Mutex<Option<GeneratorWorker>>,
/// Block state id -> block index, the game's block tick type: worldgen
@@ -138,6 +141,10 @@ impl VanillaTerrain {
generator,
biome_map,
loot,
structure_mobs: Arc::new(StructureMobFinalizer::new(
dir.parent().unwrap_or(dir).to_owned(),
dimension,
)),
query: std::sync::Mutex::new(None),
tick_blocks,
tick_states,
@@ -147,6 +154,11 @@ impl VanillaTerrain {
created: std::time::Instant::now(),
})
}
/// The difficulty (0 peaceful to 3 hard) and overworld clock structure
/// mobs are finalized with.
pub fn set_spawn_conditions(&self, difficulty: u8, day_time: i64) {
self.structure_mobs.set_conditions(difficulty, day_time);
}
/// A proto chunk's blocks, biomes, scheduled ticks and post-processing
/// marks as a column.
fn column(&self, chunk: &ProtoChunk) -> Chunk {
@@ -362,7 +374,9 @@ pub fn shared_data(
impl ChunkGenerator for VanillaTerrain {
type Worker = GeneratorWorker;
fn worker(&self) -> GeneratorWorker {
self.generator.worker()
let mut worker = self.generator.worker();
worker.set_structure_mobs(self.structure_mobs.clone());
worker
}
fn lod_sampler(self: Arc<Self>) -> Box<dyn LodSampler> {
Box::new(VanillaLodSampler::new(self))
@@ -0,0 +1,446 @@
//! `Mob.finalizeSpawn(level, level.getCurrentDifficultyAt(pos), STRUCTURE, null)`
//! of the mobs structures place (StructureTemplate.placeEntities with
//! finalizeEntities, ocean ruin drowned, mansion illagers, witch huts,
//! monuments), run as decoration places them, with the WorldGenRegion's random.
use crate::{
enchant::Enchantments,
entity_nbt,
items::Items,
mobs::{
Mob, MobType, MobTypes,
finalize::{self, Ctx, FinalizeLevel, Reason, SpawnData, SpawnRegistries},
spawning::{LocalDifficulty, MOON_BRIGHTNESS},
},
};
use chrono::Datelike;
use horizon_core::{
geometry::{Aabb, Vec3},
random::{LegacyRandom, RandomSource, XoroshiroRandom},
};
use horizon_world::{
nbt::{Compound, Tag},
worldgen::{generator::StructureMobs, structure::legacy::PieceRandom},
};
use std::{
collections::{HashMap, HashSet},
path::PathBuf,
sync::{
Arc, OnceLock,
atomic::{AtomicI64, AtomicU8, Ordering},
},
};
struct Data {
types: HashMap<String, Arc<MobType>>,
biome_tags: HashMap<String, HashSet<String>>,
registries: SpawnRegistries,
enchantments: Enchantments,
items: Items,
camel_husk: (f32, f32),
}
fn load(root: &std::path::Path) -> Option<Data> {
let types = MobTypes::load(root).ok()?.types;
let camel = types.get("minecraft:camel_husk")?;
let camel_husk = (camel.width as f32, camel.height as f32);
Some(Data {
types: types.into_iter().map(|(k, t)| (k, Arc::new(t))).collect(),
biome_tags: crate::items::load_tags(root, "worldgen/biome").unwrap_or_default(),
registries: SpawnRegistries::load(root),
enchantments: Enchantments::load(root),
items: Items::tags_only(root).ok()?,
camel_husk,
})
}
pub struct StructureMobFinalizer {
root: PathBuf,
dimension: String,
data: OnceLock<Option<Data>>,
/// The level's difficulty (0 peaceful to 3 hard) and overworld clock.
difficulty: AtomicU8,
day_time: AtomicI64,
}
impl StructureMobFinalizer {
pub fn new(root: PathBuf, dimension: &str) -> Self {
Self {
root,
dimension: dimension.to_owned(),
data: OnceLock::new(),
difficulty: AtomicU8::new(2),
day_time: AtomicI64::new(0),
}
}
pub fn set_conditions(&self, difficulty: u8, day_time: i64) {
self.difficulty.store(difficulty, Ordering::Relaxed);
self.day_time.store(day_time, Ordering::Relaxed);
}
}
struct Level<'a> {
data: &'a Data,
biome: &'a str,
structures: &'a [String],
difficulty: u8,
day_time: i64,
next_id: u32,
}
impl FinalizeLevel for Level<'_> {
fn biome(&self, _: [i32; 3]) -> String {
self.biome.to_owned()
}
fn biome_tag(&self, tag: &str, _: [i32; 3]) -> bool {
self.data
.biome_tags
.get(tag)
.is_some_and(|b| b.contains(self.biome))
}
fn structures_with_piece_at(&self, _: [i32; 3]) -> Vec<String> {
self.structures.to_vec()
}
fn moon_phase(&self, _: [i32; 3]) -> usize {
self.day_time.div_euclid(24000).rem_euclid(8) as usize
}
fn spawning_monsters(&self) -> bool {
self.difficulty != 0
}
// No block collision: only a husk's camel asks, and no structure places husks.
fn no_collision(&self, _: Aabb) -> bool {
true
}
// WorldGenRegion holds no entities.
fn free_chicken(&self, _: Aabb) -> Option<u32> {
None
}
fn ride_chicken(&mut self, _: u32, _: u32) {}
fn game_time(&self) -> i64 {
self.day_time
}
fn halloween(&self) -> bool {
let today = chrono::Local::now();
(today.month(), today.day()) == (10, 31)
}
fn create(&mut self, kind: &str, _: Reason) -> Option<Mob> {
if self.difficulty == 0 && !finalize::allowed_in_peaceful(kind) {
return None;
}
let t = self.data.types.get(kind)?.clone();
self.next_id += 1;
Some(Mob::new(self.next_id, t, Vec3::ZERO, 0.0))
}
}
fn run<R: RandomSource>(
level: &mut Level<'_>,
random: &mut R,
difficulty: LocalDifficulty,
data: &SpawnData<'_>,
m: &mut Mob,
) -> Vec<Mob> {
let mut cx = Ctx {
level,
random,
difficulty,
data,
created: Vec::new(),
};
cx.finalize(m, Reason::Structure, None);
cx.created
}
/// The saved compound of mob `i` with the mobs riding it under `Passengers`.
fn tree(mobs: &[(Mob, Option<Tag>)], i: usize, dimension: &str) -> Compound {
let (m, raw) = &mobs[i];
let Tag::Compound(mut c) = entity_nbt::mob_to_nbt(m, [0; 4], raw.as_ref()) else {
return Compound::new();
};
c.remove(&"UUID".into());
entity_nbt::put_brain(&mut c, m, dimension);
let riders: Vec<Tag> = (0..mobs.len())
.filter(|&j| mobs[j].0.extra.mount == Some(m.id))
.map(|j| Tag::Compound(tree(mobs, j, dimension)))
.collect();
if !riders.is_empty() {
c.insert("Passengers".into(), Tag::List(riders));
}
c
}
impl StructureMobs for StructureMobFinalizer {
fn finalize(
&self,
nbt: &mut Compound,
biome: &str,
structures: &[String],
random: &mut dyn PieceRandom,
) -> bool {
let Some(data) = self.data.get_or_init(|| {
let data = load(&self.root);
if data.is_none() {
log::error!("Horizon: no mob data, structure mobs are finalized when loaded");
}
data
}) else {
return false;
};
let mut raw = Tag::Compound(nbt.clone());
if let Tag::Compound(c) = &mut raw {
c.remove(&"horizon:finalize".into());
}
let Some(mut m) = entity_nbt::mob_from_nbt(&raw, &data.types, 1) else {
// Not a mob: vanilla finalizes only Mob instances.
return true;
};
let base = self.difficulty.load(Ordering::Relaxed);
let day_time = self.day_time.load(Ordering::Relaxed);
let mut level = Level {
data,
biome,
structures,
difficulty: base,
day_time,
next_id: 1,
};
let moon = MOON_BRIGHTNESS[level.moon_phase([0; 3])];
// WorldGenRegion.getCurrentDifficultyAt: no inhabited time.
let difficulty = LocalDifficulty::new(base, day_time, 0, moon);
let spawn = SpawnData {
registries: &data.registries,
enchantments: &data.enchantments,
items: &data.items,
camel_husk_size: data.camel_husk,
};
let any = random.as_any();
let created = if let Some(r) = any.downcast_mut::<LegacyRandom>() {
run(&mut level, r, difficulty, &spawn, &mut m)
} else if let Some(r) = any.downcast_mut::<XoroshiroRandom>() {
run(&mut level, r, difficulty, &spawn, &mut m)
} else {
log::error!("Horizon: unknown region random, structure mobs are finalized when loaded");
return false;
};
let mut mobs = vec![(m, Some(raw))];
mobs.extend(created.into_iter().map(|c| (c, None)));
let root = mobs
.iter()
.position(|(m, _)| m.extra.mount.is_none())
.unwrap_or(0);
*nbt = tree(&mobs, root, &self.dimension);
true
}
}
#[cfg(test)]
mod tests {
use super::*;
/// The bastion's crossbow piglin keeps its crossbow (STRUCTURE skips
/// createSpawnWeapon) and saves what Piglin.addAdditionalSaveData writes.
#[test]
fn bastion_crossbow_piglin_finalizes_as_structure() {
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
return;
};
let file = root.join("worldgen/structure/minecraft/bastion/mobs/crossbow_piglin.nbt");
let mut bytes = Vec::new();
std::io::Read::read_to_end(
&mut flate2::read::GzDecoder::new(std::fs::File::open(file).unwrap()),
&mut bytes,
)
.unwrap();
let limits = horizon_world::nbt::Limits::templates();
let template = horizon_world::nbt::read_named(&bytes, limits)
.unwrap()
.0
.tag;
let Some(Tag::List(entities)) = template.get("entities") else {
panic!("no entities");
};
let Some(Tag::Compound(mut nbt)) = entities[0].get("nbt").cloned() else {
panic!("no nbt");
};
nbt.remove(&"UUID".into());
let hook = StructureMobFinalizer::new(root, "minecraft:the_nether");
let mut random = LegacyRandom::new(12345);
hook.finalize(&mut nbt, "minecraft:nether_wastes", &[], &mut random);
let keys: Vec<String> = {
let mut k: Vec<String> = nbt.keys().map(|k| k.to_string_lossy()).collect();
k.sort();
k
};
assert_eq!(
keys,
[
"AbsorptionAmount",
"Air",
"Brain",
"CanPickUpLoot",
"CannotHunt",
"DeathTime",
"FallFlying",
"Fire",
"Health",
"HurtTime",
"Inventory",
"Invulnerable",
"IsBaby",
"IsImmuneToZombification",
"LeftHanded",
"Motion",
"OnGround",
"PersistenceRequired",
"PortalCooldown",
"Pos",
"Rotation",
"TimeInOverworld",
"attributes",
"current_impulse_context_reset_grace_time",
"equipment",
"fall_distance",
"id",
]
);
let tag = Tag::Compound(nbt);
let held = tag.get("equipment").and_then(|e| e.get("mainhand"));
assert!(
matches!(held.and_then(|h| h.get("id")), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:crossbow")
);
let hunted = tag
.get("Brain")
.and_then(|b| b.get("memories"))
.and_then(|m| m.get("minecraft:hunted_recently"));
assert!(matches!(
hunted.and_then(|h| h.get("ttl")),
Some(Tag::Long(600..=2400))
));
let Some(Tag::List(attributes)) = tag.get("attributes") else {
panic!("no attributes");
};
assert!(attributes.iter().any(|a| {
matches!(a.get("id"), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:follow_range")
&& matches!(a.get("modifiers"), Some(Tag::List(m)) if m.len() == 1)
}));
}
fn id(t: Option<&Tag>) -> String {
match t.and_then(|t| t.get("id")) {
Some(Tag::String(s)) => s.to_string_lossy().trim_start_matches("minecraft:").into(),
_ => "-".into(),
}
}
/// What a vanilla world saves of a structure mob that finalizeSpawn decides.
fn describe(mob: &Tag) -> String {
let eq = mob.get("equipment");
let gear: Vec<String> = ["mainhand", "head", "chest", "legs", "feet"]
.iter()
.map(|slot| id(eq.and_then(|e| e.get(slot))))
.collect();
let ttl = match mob
.get("Brain")
.and_then(|b| b.get("memories"))
.and_then(|m| m.get("minecraft:hunted_recently"))
.and_then(|h| h.get("ttl"))
{
Some(Tag::Long(t)) => t.to_string(),
_ => "-".into(),
};
let bonus = crate::entity_nbt::spawn_bonus(mob).unwrap_or(f64::NAN);
let flag = |k: &str| matches!(mob.get(k), Some(Tag::Byte(1)));
let riders = match mob.get("Passengers") {
Some(Tag::List(p)) => format!(
" [{}]",
p.iter().map(describe).collect::<Vec<_>>().join("; ")
),
_ => String::new(),
};
format!(
"{} {} ttl={ttl} bonus={bonus:.6} left={} baby={}{riders}",
id(Some(mob)),
gear.join(","),
flag("LeftHanded"),
flag("IsBaby") || matches!(mob.get("Age"), Some(Tag::Int(a)) if *a < 0),
)
}
/// The described entities of chunk (x, z) after decorating the 3x3 around it.
fn chunk_mobs(
root: &std::path::Path,
seed: i64,
dimension: &str,
x: i32,
z: i32,
) -> Vec<String> {
use crate::streaming::{ChunkGenerator, Proto};
let assets = crate::assets::Assets::load(root).unwrap();
let biomes = crate::biome::Biomes::load(root).unwrap();
let terrain = super::super::VanillaTerrain::for_dimension(
&root.join("worldgen"),
assets.registry,
&biomes,
seed,
dimension,
)
.unwrap();
let mut worker = terrain.worker();
let mut region: [Proto; 9] = std::array::from_fn(|i| {
terrain.proto(&mut worker, x + i as i32 % 3 - 1, z + i as i32 / 3 - 1)
});
terrain.decorate(&mut worker, &mut region);
let center = std::mem::replace(&mut region[4], Box::new(()));
let mut got: Vec<String> = terrain
.finish(center)
.entities
.iter()
.map(describe)
.collect();
got.sort();
got
}
/// Seed 12345's bastion at chunk (-21, 8): the mobs of chunk (-23, 8) as two
/// vanilla 26.3 runs saved them (weapons and armour, hunting memory, follow
/// range bonus, handedness), from the region random of that chunk. The
/// memories are as placed: vanilla saved them 13 brain ticks later.
#[test]
fn bastion_chunk_mobs_match_vanilla() {
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
return;
};
let got = chunk_mobs(&root, 12345, "minecraft:the_nether", -23, 8);
let mut expected = [
"piglin golden_sword,-,golden_chestplate,-,- ttl=1760 bonus=0.013784",
"piglin crossbow,-,-,-,- ttl=806 bonus=-0.011458",
"piglin golden_sword,-,-,-,- ttl=1315 bonus=-0.084585",
"piglin golden_sword,-,-,-,- ttl=1489 bonus=-0.038292",
"piglin_brute golden_axe,-,-,-,- ttl=- bonus=-0.020574",
"piglin crossbow,-,-,-,- ttl=1620 bonus=-0.079135",
"hoglin -,-,-,-,- ttl=- bonus=-0.012052",
"piglin golden_sword,-,-,-,- ttl=783 bonus=-0.077071",
"piglin crossbow,-,-,golden_leggings,- ttl=1431 bonus=0.007058",
]
.map(|e| format!("{e} left=false baby=false"));
expected.sort();
assert_eq!(got, expected);
}
/// Seed 12345's ocean ruin at (53, 39, 424): Drowned.finalizeSpawn mounts the
/// trident drowned on a zombie nautilus, as vanilla saved chunk (3, 26).
#[test]
fn ocean_ruin_drowned_match_vanilla() {
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
return;
};
let got = chunk_mobs(&root, 12345, "minecraft:overworld", 3, 26);
let d = |gear: &str, bonus: &str| {
format!("drowned {gear},-,-,-,- ttl=- bonus={bonus} left=false baby=false")
};
let mut expected = vec![
d("-", "0.001996"),
format!(
"zombie_nautilus -,-,-,-,- ttl=- bonus=-0.044983 left=false baby=false [{}]",
d("trident", "-0.045604")
),
d("fishing_rod", "-0.059079"),
d("-", "0.021658"),
];
expected.sort();
assert_eq!(got, expected);
}
}
@@ -1648,6 +1648,22 @@ pub(super) struct WorkerState {
heights: HashMap<(i32, i32, u8), i32>,
/// Decorate with structure pieces only (for structure parity checks).
pub(super) structures_only: bool,
pub(super) structure_mobs: Option<Arc<dyn StructureMobs>>,
}
/// `Mob.finalizeSpawn(level, difficulty, STRUCTURE, null)` of the entities a
/// structure places with finalizeEntities, run by the game, which owns mobs.
pub trait StructureMobs: Send + Sync {
/// Finalizes the entity in `nbt` if it is a mob, drawing from the
/// region's random. `biome` is the biome at its block, `structures` the
/// structures with a piece there. False when it could not: the entity
/// keeps its `horizon:finalize` for the game to finish on load.
fn finalize(
&self,
nbt: &mut crate::nbt::Compound,
biome: &str,
structures: &[String],
random: &mut dyn super::structure::legacy::PieceRandom,
) -> bool;
}
trait SeededPipeline: Send + Sync {
@@ -2464,6 +2480,7 @@ impl OverworldGenerator {
carver_biomes: HashMap::new(),
timings: StageTimings::default(),
structures_only: false,
structure_mobs: None,
heights: HashMap::new(),
},
}
@@ -2590,6 +2607,9 @@ impl GeneratorWorker {
pub fn set_structures_only(&mut self, only: bool) {
self.state.structures_only = only;
}
pub fn set_structure_mobs(&mut self, mobs: Arc<dyn StructureMobs>) {
self.state.structure_mobs = Some(mobs);
}
}
#[cfg(test)]
@@ -310,6 +310,7 @@ impl Decoration {
Err(e) => return Err(resource(e.to_string())),
};
let structures_only = worker.structures_only;
let references = region[4].structure_starts.clone();
let mut block_entities = Vec::new();
for chunk in region.iter_mut() {
block_entities.append(&mut chunk.block_entities);
@@ -318,6 +319,9 @@ impl Decoration {
block_entities,
entities: Vec::new(),
level_random,
structure_mobs: worker.structure_mobs.clone(),
starts: references.clone(),
biome_names: data.biome_names(),
blocks: data
.feature_resources
.as_ref()
@@ -334,7 +338,6 @@ impl Decoration {
};
let mut stats = DecorateStats::default();
let blocks = self.blocks;
let references = region[4].structure_starts.clone();
// ChunkGenerator.getWritableArea: the chunk's minimum Y + 1 to its maximum Y.
let chunk_box = BoundingBox::new(
[center.x * 16, min_y + 1, center.z * 16],
@@ -419,15 +422,11 @@ impl Decoration {
}
// WorldGenRegion.addFreshEntity: into the chunk holding the position.
for nbt in std::mem::take(&mut world.entities) {
let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
let Some(at) = block_of(&nbt) else {
continue;
};
let coord = |i: usize| match p.get(i) {
Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
_ => 0,
};
let index = ((coord(2) >> 4).wrapping_sub(center.z) + 1) * 3
+ (coord(0) >> 4).wrapping_sub(center.x)
let index = ((at[2] >> 4).wrapping_sub(center.z) + 1) * 3
+ (at[0] >> 4).wrapping_sub(center.x)
+ 1;
if let Some(chunk) = usize::try_from(index).ok().and_then(|i| region.get_mut(i)) {
chunk.entities.push(nbt);
@@ -454,6 +453,9 @@ struct World<'a> {
block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
entities: Vec<crate::nbt::Compound>,
level_random: &'a mut dyn super::structure::legacy::PieceRandom,
structure_mobs: Option<Arc<dyn super::generator::StructureMobs>>,
starts: Vec<Arc<super::structure::start::StructureStart>>,
biome_names: &'a [Arc<str>],
blocks: Option<&'a BlockBehavior>,
region: TerrainRegion<'static, GenBlockStates>,
biomes: BiomeRegion<BiomeId>,
@@ -847,7 +849,27 @@ impl PlacementContext for World<'_> {
(0..ny).all(|y| (0..nz).all(|z| shape.is_full(x as i32, y as i32, z as i32)))
}))
}
fn add_entity(&mut self, nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
fn add_entity(&mut self, mut nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
if let Some(mobs) = self.structure_mobs.clone()
&& nbt.contains_key(&"horizon:finalize".into())
{
let at = block_of(&nbt).unwrap_or([0; 3]);
let biome = self
.biome_identity(at)
.ok()
.and_then(|b| self.biome_names.get(b.0 as usize))
.map_or("", |n| &**n)
.to_owned();
let structures: Vec<String> = self
.starts
.iter()
.filter(|s| s.pieces.iter().any(|p| p.bounding_box().is_inside(at)))
.map(|s| s.name.clone())
.collect();
if mobs.finalize(&mut nbt, &biome, &structures, self.level_random) {
nbt.remove(&"horizon:finalize".into());
}
}
self.entities.push(nbt);
Ok(())
}
@@ -1167,3 +1189,14 @@ impl PlacementContext for World<'_> {
Ok(Some(false))
}
}
/// The block an entity's `Pos` is in.
fn block_of(nbt: &crate::nbt::Compound) -> Option<[i32; 3]> {
let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
return None;
};
Some(std::array::from_fn(|i| match p.get(i) {
Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
_ => 0,
}))
}
@@ -31,14 +31,19 @@ pub type Markers = Vec<(String, [i32; 3])>;
pub trait PieceRandom: ProcessorRandom {
fn boolean(&mut self) -> bool;
fn double(&mut self) -> f64;
/// The concrete random, for callers that need all of `RandomSource`.
fn as_any(&mut self) -> &mut dyn std::any::Any;
}
impl<R: RandomSource> PieceRandom for R {
impl<R: RandomSource + 'static> PieceRandom for R {
fn boolean(&mut self) -> bool {
self.next_boolean()
}
fn double(&mut self) -> f64 {
self.next_double()
}
fn as_any(&mut self) -> &mut dyn std::any::Any {
self
}
}
/// Object-safe world access for piece post-processing.