Merge pull request #908 from ludovic111/feat/spawner-mobs-processor

🤖 Agent: reviewed; verify passes. Parity: 298/298 harnesses on the integration commit 234bd101 (main + #907/#908/#910); vanilla structure-start oracle 35/35 with all five modpacks-7 changes. Merged in the required order #907 → #908 → #909 → #910 → #911.
This commit is contained in:
Ludovic Marie
2026-10-18 20:07:15 +02:00
committed by GitHub
@@ -139,10 +139,119 @@ pub enum Processor {
BlockAge(f32),
LavaSubmerged,
BlackstoneReplace,
SpawnerMobs(Box<SpawnerMobs>),
}
#[derive(Clone, Debug, Default)]
pub struct ProcessorList(pub Vec<Processor>);
/// The spawner fields `horizon:spawner_mobs` writes: its JSON key, the NBT
/// key and the default (BaseSpawner's).
const SPAWNER_FIELDS: [(&str, &str, i16); 7] = [
("delay", "Delay", 20),
("min_spawn_delay", "MinSpawnDelay", 200),
("max_spawn_delay", "MaxSpawnDelay", 800),
("spawn_count", "SpawnCount", 4),
("max_nearby_entities", "MaxNearbyEntities", 6),
("required_player_range", "RequiredPlayerRange", 16),
("spawn_range", "SpawnRange", 4),
];
/// `horizon:spawner_mobs`, which `horizon-port-pack` writes for the spawner
/// randomizing processors of Moog's Structure Lib and Repurposed Structures
/// (Java code in the mods): a spawner gets one mob of a weighted list,
/// picked with `settings.getRandom(pos).nextFloat()` as theirs do, and the
/// spawner NBT they write. With no mob to pick it becomes `replacement`.
#[derive(Clone, Debug)]
pub struct SpawnerMobs {
/// Each mob's entity compound (its `id` and any NBT) and weight.
mobs: Vec<(Compound, f64)>,
/// [`SPAWNER_FIELDS`]' values.
fields: [i16; 7],
/// `custom_spawn_rules`, in `SpawnData` and the potential alike.
rules: Option<Compound>,
replacement: BlockStateId,
}
impl SpawnerMobs {
fn decode(
value: &Value,
replacement: impl FnOnce(Option<&Value>) -> Result<BlockStateId, DecodeError>,
) -> Result<Self, DecodeError> {
let mobs = value["mobs"]
.as_array()
.ok_or(DecodeError::Field("spawner_mobs mobs"))?
.iter()
.map(
|m| match (json_to_nbt(&m["entity"]), m["weight"].as_f64()) {
(Tag::Compound(entity), Some(weight))
if entity.contains_key(&JavaString::from("id")) =>
{
Ok((entity, weight))
}
_ => Err(DecodeError::Field("spawner_mobs mob")),
},
)
.collect::<Result<_, _>>()?;
let mut fields = [0; 7];
for (field, (key, _, default)) in fields.iter_mut().zip(SPAWNER_FIELDS) {
// The mods' codecs read ints; the spawner saves them as shorts.
*field = value
.get(key)
.map_or(Some(default), |v| v.as_i64().map(|v| v as i16))
.ok_or(DecodeError::Field("spawner_mobs field"))?;
}
let rules = match value.get("custom_spawn_rules").map(json_to_nbt) {
None => None,
Some(Tag::Compound(c)) => Some(c),
Some(_) => return Err(DecodeError::Field("spawner_mobs custom_spawn_rules")),
};
Ok(Self {
mobs,
fields,
rules,
replacement: replacement(value.get("replacement"))?,
})
}
/// The mob for a spawner, drawing from `random` only when there is one
/// to pick (pickWeightedRandom; Repurposed Structures' getSpawnerMob,
/// whose float product can round differently only on a boundary).
fn pick(&self, random: impl FnOnce() -> f32) -> Option<&Compound> {
let total: f64 = self.mobs.iter().map(|m| m.1).sum();
if self.mobs.is_empty() || total <= 0. {
return None;
}
let mut pick = f64::from(random()) * total;
for (entity, weight) in &self.mobs {
pick -= weight;
if pick <= 0. {
return Some(entity);
}
}
self.mobs.last().map(|m| &m.0)
}
/// The spawner's NBT with `entity` as its only potential and next spawn.
fn nbt(&self, entity: &Compound) -> Compound {
let mut data = Compound::new();
data.insert("entity".into(), Tag::Compound(entity.clone()));
if let Some(rules) = &self.rules {
data.insert("custom_spawn_rules".into(), Tag::Compound(rules.clone()));
}
let mut potential = Compound::new();
potential.insert("data".into(), Tag::Compound(data.clone()));
potential.insert("weight".into(), Tag::Int(1));
let mut nbt: Compound = SPAWNER_FIELDS
.iter()
.zip(self.fields)
.map(|((_, key, _), v)| (JavaString::from(*key), Tag::Short(v)))
.collect();
nbt.insert(
"SpawnPotentials".into(),
Tag::List(vec![Tag::Compound(potential)]),
);
nbt.insert("SpawnData".into(), Tag::Compound(data));
nbt
}
}
fn holder_set(
value: &Value,
bindings: &FeatureBlockBindings<'_>,
@@ -272,6 +381,12 @@ impl Processor {
})
.collect::<Result<_, DecodeError>>()?,
),
"horizon:spawner_mobs" => {
Self::SpawnerMobs(Box::new(SpawnerMobs::decode(value, |v| match v {
Some(v) => state(v),
None => Ok(resources.registry.default_state("minecraft:air").unwrap()),
})?))
}
_ => return Err(DecodeError::Field("structure processor type")),
})
}
@@ -537,6 +652,24 @@ fn process_block<W: PlacementContext>(
Some(info)
}
Processor::Capped { .. } => Some(info),
Processor::SpawnerMobs(spawner) => {
if name(info.state) != "minecraft:spawner" {
return Ok(Some(info));
}
let pos = info.pos;
let entity = spawner.pick(|| settings.with_random(pos, |r| r.float()));
Some(match entity {
Some(entity) => BlockInfo {
nbt: Some(spawner.nbt(entity)),
..info
},
None => BlockInfo {
pos,
state: spawner.replacement,
nbt: None,
},
})
}
})
}
fn block_age(
@@ -1032,6 +1165,91 @@ mod tests {
use super::*;
use serde_json::json;
fn spawner(value: Value) -> SpawnerMobs {
SpawnerMobs::decode(&value, |v| {
assert_eq!(v, Some(&json!({"id": "minecraft:cobblestone"})));
Ok(BlockStateId(7))
})
.unwrap()
}
fn id(entity: Option<&Compound>) -> Option<String> {
match entity?.get(&JavaString::from("id")) {
Some(Tag::String(s)) => Some(s.to_string_lossy()),
_ => None,
}
}
#[test]
fn spawner_mobs_pick_by_weight() {
let s = spawner(json!({
"mobs": [
{"entity": {"id": "minecraft:zombie"}, "weight": 1},
{"entity": {"id": "minecraft:husk"}, "weight": 3}],
"replacement": {"id": "minecraft:cobblestone"}}));
// pick = nextFloat * 4, less each weight in turn, until <= 0.
for (r, mob) in [
(0., "zombie"),
(0.25, "zombie"),
(0.2501, "husk"),
(0.999, "husk"),
] {
assert_eq!(id(s.pick(|| r)), Some(format!("minecraft:{mob}")), "{r}");
}
let empty = spawner(json!({"mobs": [], "replacement": {"id": "minecraft:cobblestone"}}));
assert_eq!(empty.pick(|| unreachable!()), None);
assert_eq!(empty.replacement, BlockStateId(7));
}
#[test]
fn spawner_mobs_write_the_mods_nbt() {
let s = spawner(json!({
"mobs": [{"entity": {"id": "minecraft:skeleton", "Health": 30}, "weight": 2}],
"delay": 10, "spawn_count": 2,
"custom_spawn_rules": {"block_light_limit": {"min_inclusive": 0, "max_inclusive": 7}},
"replacement": {"id": "minecraft:cobblestone"}}));
let nbt = s.nbt(s.pick(|| 0.5).unwrap());
let short = |k: &str| nbt.get(&JavaString::from(k)).cloned();
for (k, v) in [
("Delay", 10),
("MinSpawnDelay", 200),
("MaxSpawnDelay", 800),
("SpawnCount", 2),
("MaxNearbyEntities", 6),
("RequiredPlayerRange", 16),
("SpawnRange", 4),
] {
assert_eq!(short(k), Some(Tag::Short(v)), "{k}");
}
let Some(Tag::Compound(data)) = short("SpawnData") else {
panic!("SpawnData")
};
assert!(data.contains_key(&JavaString::from("custom_spawn_rules")));
let Some(Tag::Compound(entity)) = data.get(&JavaString::from("entity")) else {
panic!("entity")
};
assert_eq!(entity.get(&JavaString::from("Health")), Some(&Tag::Int(30)));
let Some(Tag::List(potentials)) = short("SpawnPotentials") else {
panic!("SpawnPotentials")
};
let Tag::Compound(potential) = &potentials[0] else {
panic!("potential")
};
assert_eq!(
potential.get(&JavaString::from("weight")),
Some(&Tag::Int(1))
);
assert_eq!(
potential.get(&JavaString::from("data")),
Some(&Tag::Compound(data.clone()))
);
}
#[test]
fn spawner_mobs_refuse_a_mob_without_an_id() {
let bad = json!({"mobs": [{"entity": {}, "weight": 1}]});
assert!(SpawnerMobs::decode(&bad, |_| Ok(BlockStateId(0))).is_err());
}
#[test]
fn rule_parts_read_ids_without_a_namespace() {
// CTOV writes "always_true"; vanilla reads it as minecraft:always_true.