Files
horizon-airdef/crates/horizon-client/src/mobs/spawn_selection.rs
T
Ludovic Marie 173a55e608 Delete pub items nothing uses, and the stubs that hid unused code
93 pub items (78 functions and methods, 14 constants, 1 struct) in horizon-client,
horizon-world, horizon-core, horizon-friends and horizon-server-files had
no caller anywhere in the repository: not in the crate, the other crates,
the examples, the tests or the binaries. rustc can't flag them because
horizon-client and the others are libraries, where a pub item counts as
used. The imports and the private helpers only they used go with them
(title.rs date_string, goals.rs flag_index).

Also drops the #[allow(dead_code)]/#[allow(unused)] items that only hid
dead code: chat_debug_fill, merchant_title and Goals::locked_by had no
caller, and four stubs (_keep, _unused, _rule_kind, const _) existed only
to keep an import used. LightTables::from_parts is used by its tests, so
it is #[cfg(test)] instead of allowed.

Protocol id tables and entity data serializer ids stay: they mirror
vanilla's registries in full. The launcher's three unused items are left
for a launcher PR.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 12:08:44 +02:00

1424 lines
49 KiB
Rust

//! `NaturalSpawner`: which mob spawns where and when. The spawn state
//! (`createState`: category counts, the spawn potential's charges, the
//! per-player local caps), the filtered categories and their global and local
//! caps, `spawnForChunk` and `spawnCategoryForPosition` (the three packs of up
//! to four attempts, the distance and respawn checks, `getRandomSpawnMobAt`
//! over `mobsAt`: the nether fortress bounds, structure spawn overrides by
//! piece or bounding box, then the biome's natural mob spawns), the per-type
//! checks of `isValidSpawnPostitionForType` and `isValidPositionForMob`
//! (each class's `checkSpawnRules` walk target value, `checkSpawnObstruction`,
//! `removeWhenFarAway`, cluster and group sizes), and
//! `spawnMobsForChunkGeneration`. Everything reads the level through
//! [`NaturalLevel`] so the game and the differential test world
//! (tools/test_natural_spawn_parity.py) run the same code; random draws follow
//! vanilla's order.
use super::Species;
use super::spawn_rules::{self, Reason, SpawnLevel};
use crate::biome::SpawnEntry;
use crate::fast_hash::FxHashMap;
use horizon_core::{
geometry::{Aabb, Vec3},
random::RandomSource,
};
use serde_json::Value;
use std::{collections::HashMap, fs, path::Path};
/// A `natural_mob_spawns` / `spawn_overrides` entry list.
pub fn parse_entries(list: &Value) -> Vec<SpawnEntry> {
list.as_array()
.into_iter()
.flatten()
.filter_map(|e| {
let count = &e["count"];
let (min, max, constant) = match count {
Value::Number(n) => {
let n = n.as_u64().unwrap_or(1) as u32;
(n, n, true)
}
c if c["type"].as_str() == Some("minecraft:constant") => {
let n = c["value"].as_u64().unwrap_or(1) as u32;
(n, n, true)
}
c => (
c["min_inclusive"].as_u64().unwrap_or(1) as u32,
c["max_inclusive"].as_u64().unwrap_or(1) as u32,
false,
),
};
Some(SpawnEntry {
entity: e["type"].as_str()?.to_owned(),
weight: e["weight"].as_u64().unwrap_or(1) as u32,
min,
max,
constant,
})
})
.collect()
}
/// `MobSpawnSettings.MobSpawnCost`.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SpawnCost {
pub energy_budget: f64,
pub charge: f64,
}
/// The `spawn_costs` of a `natural_mob_spawns` value.
pub fn parse_costs(costs: &Value) -> HashMap<String, SpawnCost> {
costs
.as_object()
.into_iter()
.flatten()
.map(|(k, c)| {
(
k.clone(),
SpawnCost {
energy_budget: c["energy_budget"].as_f64().unwrap_or(0.0),
charge: c["charge"].as_f64().unwrap_or(0.0),
},
)
})
.collect()
}
/// `MobCategory`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Category {
Monster,
Creature,
Ambient,
Axolotls,
UndergroundWaterCreature,
WaterCreature,
WaterAmbient,
Misc,
}
impl Category {
pub const ALL: [Self; 8] = [
Self::Monster,
Self::Creature,
Self::Ambient,
Self::Axolotls,
Self::UndergroundWaterCreature,
Self::WaterCreature,
Self::WaterAmbient,
Self::Misc,
];
/// `NaturalSpawner.SPAWNING_CATEGORIES`: all but MISC, in enum order.
pub const SPAWNING: [Self; 7] = [
Self::Monster,
Self::Creature,
Self::Ambient,
Self::Axolotls,
Self::UndergroundWaterCreature,
Self::WaterCreature,
Self::WaterAmbient,
];
pub fn name(self) -> &'static str {
match self {
Self::Monster => "monster",
Self::Creature => "creature",
Self::Ambient => "ambient",
Self::Axolotls => "axolotls",
Self::UndergroundWaterCreature => "underground_water_creature",
Self::WaterCreature => "water_creature",
Self::WaterAmbient => "water_ambient",
Self::Misc => "misc",
}
}
pub fn from_name(name: &str) -> Self {
Self::ALL
.into_iter()
.find(|c| c.name() == name)
.unwrap_or(Self::Misc)
}
fn index(self) -> usize {
self as usize
}
/// `getMaxInstancesPerChunk`.
pub fn max(self) -> i32 {
match self {
Self::Monster => 70,
Self::Creature => 10,
Self::Ambient => 15,
Self::Axolotls | Self::UndergroundWaterCreature | Self::WaterCreature => 5,
Self::WaterAmbient => 20,
Self::Misc => -1,
}
}
pub fn friendly(self) -> bool {
self != Self::Monster
}
pub fn persistent(self) -> bool {
matches!(self, Self::Creature | Self::Misc)
}
pub fn despawn_distance(self) -> i32 {
if self == Self::WaterAmbient { 64 } else { 128 }
}
}
/// `PathfinderMob.checkSpawnRules`: the class's `getWalkTargetValue` at the
/// spawn position must not be negative (plain `Mob`s accept any position).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum WalkTarget {
NotPathfinder,
Zero,
Animal,
Mooshroom,
Turtle,
Monster,
Giant,
Guardian,
Silverfish,
Strider,
Hoglin,
Bee,
HappyGhast,
}
fn walk_target(s: Species) -> WalkTarget {
use Species as S;
use WalkTarget as W;
match s {
S::Bat | S::Slime | S::MagmaCube | S::SulfurCube | S::Ghast | S::Phantom => {
W::NotPathfinder
}
// Monster subclasses that override it with 0.
S::Enderman | S::Creaking | S::Pillager | S::Warden => W::Zero,
S::Giant => W::Giant,
S::Guardian | S::ElderGuardian => W::Guardian,
S::Silverfish => W::Silverfish,
S::Zombie
| S::Husk
| S::Drowned
| S::ZombieVillager
| S::ZombifiedPiglin
| S::Skeleton
| S::Stray
| S::Bogged
| S::Parched
| S::WitherSkeleton
| S::Creeper
| S::Spider
| S::CaveSpider
| S::Endermite
| S::Witch
| S::Vindicator
| S::Evoker
| S::Illusioner
| S::Ravager
| S::Piglin
| S::PiglinBrute
| S::Zoglin
| S::Blaze
| S::Vex
| S::Breeze
| S::Wither => W::Monster,
S::Mooshroom => W::Mooshroom,
S::Turtle => W::Turtle,
S::Strider => W::Strider,
S::Hoglin => W::Hoglin,
S::Bee => W::Bee,
S::HappyGhast => W::HappyGhast,
// Animal subclasses with their own value.
S::Axolotl | S::Nautilus | S::ZombieNautilus => W::Zero,
S::Pig
| S::Cow
| S::Sheep
| S::Chicken
| S::Rabbit
| S::Horse
| S::Donkey
| S::Mule
| S::Llama
| S::TraderLlama
| S::SkeletonHorse
| S::ZombieHorse
| S::Camel
| S::CamelHusk
| S::Goat
| S::Panda
| S::PolarBear
| S::Fox
| S::Wolf
| S::Cat
| S::Ocelot
| S::Parrot
| S::Armadillo
| S::Frog
| S::Sniffer => W::Animal,
// Other PathfinderMobs: water animals, golems, villagers, allays...
_ => W::Zero,
}
}
/// Each class's `checkSpawnObstruction`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Obstruction {
/// `Mob`: no liquid in the box and no entity blocking it.
NoLiquidUnobstructed,
Unobstructed,
Ocelot,
NoLiquid,
}
fn obstruction(s: Species) -> Obstruction {
use Species as S;
match s {
S::Squid
| S::GlowSquid
| S::Dolphin
| S::Axolotl
| S::Cod
| S::Salmon
| S::TropicalFish
| S::Pufferfish
| S::Tadpole
| S::Nautilus
| S::ZombieNautilus
| S::Guardian
| S::ElderGuardian
| S::Strider
| S::Drowned => Obstruction::Unobstructed,
S::Ocelot => Obstruction::Ocelot,
S::Ravager => Obstruction::NoLiquid,
// ZombifiedPiglin's override is the Mob default's two tests; iron
// golems and wardens never spawn naturally.
_ => Obstruction::NoLiquidUnobstructed,
}
}
/// `Mob.removeWhenFarAway` of a freshly created mob.
fn removed_when_far(s: Species) -> bool {
use Species as S;
match s {
// Animal, golems, villagers, traders, allays and wardens never;
// cats and ocelots only past 2400 ticks; chickens as jockeys.
S::Axolotl
| S::Cod
| S::Salmon
| S::TropicalFish
| S::Pufferfish
| S::Tadpole
| S::CamelHusk
| S::ZombieHorse
| S::Hoglin
| S::Nautilus
| S::ZombieNautilus => true,
S::Villager
| S::WanderingTrader
| S::IronGolem
| S::SnowGolem
| S::Shulker
| S::Allay
| S::Warden => false,
_ => !is_animal(s),
}
}
fn is_animal(s: Species) -> bool {
use Species as S;
matches!(walk_target(s), WalkTarget::Animal)
|| matches!(
s,
S::Axolotl
| S::Nautilus
| S::ZombieNautilus
| S::Mooshroom
| S::Turtle
| S::Strider
| S::Hoglin
| S::Bee
| S::HappyGhast
)
}
/// `Mob.getMaxSpawnClusterSize`.
pub fn max_cluster_size(s: Species) -> u32 {
use Species as S;
match s {
S::Horse
| S::Donkey
| S::Mule
| S::Llama
| S::TraderLlama
| S::SkeletonHorse
| S::ZombieHorse
| S::Camel
| S::CamelHusk => 6,
S::Cod | S::TropicalFish | S::Pufferfish | S::Tadpole | S::Wolf => 8,
S::Salmon => 5,
S::Ghast | S::HappyGhast | S::Pillager => 1,
_ => 4,
}
}
/// `EntityType.canSpawnFarFromPlayer`: creatures, misc, pillagers, shulkers.
fn spawns_far_from_player(s: Species, category: Category) -> bool {
matches!(category, Category::Creature | Category::Misc)
|| matches!(s, Species::Pillager | Species::Shulker)
}
/// What natural spawning reads from a level beyond the spawn rules.
/// An entity type's species, width, height and category.
pub type MobType = (Species, f32, f32, Category);
pub trait NaturalLevel: SpawnLevel {
fn min_y(&self) -> i32;
/// `getMaxY()`: the highest buildable block.
fn max_y(&self) -> i32;
/// `DimensionType.ambientLight`.
fn ambient_light(&self) -> f32;
fn has_ceiling(&self) -> bool;
/// The entity type's species, width, height and category.
fn mob_type(&self, entity: &str) -> Option<MobType>;
/// The `natural_mob_spawns` lists by category at a position.
fn biome_spawns(&self, x: i32, y: i32, z: i32) -> Option<&HashMap<String, Vec<SpawnEntry>>>;
/// The `natural_mob_spawns` spawn cost of a type at a position.
fn spawn_cost(&self, entity: &str, x: i32, y: i32, z: i32) -> Option<SpawnCost>;
/// The `creature_world_gen_spawn_probability` attribute at a position.
fn creature_probability(&self, x: i32, y: i32, z: i32) -> f32;
/// Every structure whose references reach the position's chunk and
/// whose id `wanted` takes, in the chunk's reference order.
fn structures_at(
&self,
x: i32,
y: i32,
z: i32,
wanted: &dyn Fn(&str) -> bool,
) -> Vec<StructureAt>;
fn structure_spawns(&self) -> &StructureSpawns;
/// Where the players `getNearestPlayer(x, y, z, -1, false)` measures to
/// are: every one that is not a spectator.
fn nearest_player_positions(&self) -> &[[f64; 3]];
/// The world spawn point, when it is in this dimension.
fn respawn(&self) -> Option<[i32; 3]>;
/// `ServerLevel.canSpawnEntitiesInChunk`.
fn can_spawn_in_chunk(&self, cx: i32, cz: i32) -> bool;
/// `noCollision(null, box)`: blocks under an empty collision context and
/// entities that can be collided with.
fn no_collision(&self, bounds: Aabb) -> bool;
/// `isUnobstructed(entity)`: no entity blocking building overlaps.
fn unobstructed(&self, bounds: Aabb) -> bool;
/// The `spawn_mobs` game rule.
fn spawn_mobs(&self) -> bool;
/// `getHeight(heightmap, x, z)`.
fn heightmap(&self, kind: Heightmap, x: i32, z: i32) -> i32;
/// `isPathfindable(PathComputationType.LAND)` of the block.
fn pathfindable_land(&self, x: i32, y: i32, z: i32) -> bool;
}
/// The heightmap types `SpawnPlacements` registers.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Heightmap {
WorldSurface,
OceanFloor,
MotionBlocking,
MotionBlockingNoLeaves,
}
impl Heightmap {
pub fn from_name(name: &str) -> Self {
match name {
"WORLD_SURFACE" => Self::WorldSurface,
"OCEAN_FLOOR" => Self::OceanFloor,
"MOTION_BLOCKING" => Self::MotionBlocking,
_ => Self::MotionBlockingNoLeaves,
}
}
}
/// `Heightmap.Types`' predicates: WORLD_SURFACE (not air), OCEAN_FLOOR
/// (`#blocks_motion_in_heightmap`), MOTION_BLOCKING (that or a fluid) and
/// MOTION_BLOCKING_NO_LEAVES (`#blocks_motion_in_heightmap_no_leaves` or a fluid).
pub fn heightmap_blocks<L: SpawnLevel>(l: &L, kind: Heightmap, x: i32, y: i32, z: i32) -> bool {
let state = l.state(x, y, z);
let f = l.facts().get(state);
let fluid = f.fluid != crate::blocks::Fluid::None;
match kind {
Heightmap::WorldSurface => !l.facts().is_air(state),
Heightmap::OceanFloor => l.block_tag("minecraft:blocks_motion_in_heightmap", &f.name),
Heightmap::MotionBlocking => {
fluid || l.block_tag("minecraft:blocks_motion_in_heightmap", &f.name)
}
Heightmap::MotionBlockingNoLeaves => {
fluid || l.block_tag("minecraft:blocks_motion_in_heightmap_no_leaves", &f.name)
}
}
}
/// `LevelReader.getLightLevelDependentMagicValue`.
fn magic_light<L: NaturalLevel>(l: &L, x: i32, y: i32, z: i32) -> f32 {
let raw = l
.block_light(x, y, z)
.max(l.sky_light(x, y, z) - l.sky_darken());
let v = raw as f32 / 15.0;
let curved = v / (4.0 - 3.0 * v);
curved + l.ambient_light() * (1.0 - curved)
}
fn cost_from_light<L: NaturalLevel>(l: &L, x: i32, y: i32, z: i32) -> f32 {
magic_light(l, x, y, z) - 0.5
}
fn name_at<L: NaturalLevel>(l: &L, x: i32, y: i32, z: i32) -> &str {
&l.facts().get(l.state(x, y, z)).name
}
fn fluid_at<L: NaturalLevel>(l: &L, x: i32, y: i32, z: i32) -> crate::blocks::Fluid {
l.facts().get(l.state(x, y, z)).fluid
}
/// `checkSpawnRules(level, NATURAL)` of a freshly created mob at a block.
pub(crate) fn mob_spawn_rules<L: NaturalLevel>(s: Species, l: &L, x: i32, y: i32, z: i32) -> bool {
use crate::blocks::Fluid;
let value = match walk_target(s) {
WalkTarget::NotPathfinder | WalkTarget::Zero => 0.0,
WalkTarget::Animal => {
if name_at(l, x, y - 1, z) == "minecraft:grass_block" {
10.0
} else {
cost_from_light(l, x, y, z)
}
}
WalkTarget::Mooshroom => {
if name_at(l, x, y - 1, z) == "minecraft:mycelium" {
10.0
} else {
cost_from_light(l, x, y, z)
}
}
WalkTarget::Turtle => {
if fluid_at(l, x, y, z) == Fluid::Water
|| l.block_tag("minecraft:sand", name_at(l, x, y - 1, z))
{
10.0
} else {
cost_from_light(l, x, y, z)
}
}
WalkTarget::Monster => -cost_from_light(l, x, y, z),
WalkTarget::Giant => cost_from_light(l, x, y, z),
WalkTarget::Guardian => {
if fluid_at(l, x, y, z) == Fluid::Water {
10.0 + cost_from_light(l, x, y, z)
} else {
-cost_from_light(l, x, y, z)
}
}
WalkTarget::Silverfish => {
if infested_host(name_at(l, x, y - 1, z)) {
10.0
} else {
-cost_from_light(l, x, y, z)
}
}
// A new strider is not in lava yet.
WalkTarget::Strider => {
if fluid_at(l, x, y, z) == Fluid::Lava {
10.0
} else {
0.0
}
}
// A new hoglin remembers no repellent.
WalkTarget::Hoglin => {
if name_at(l, x, y - 1, z) == "minecraft:crimson_nylium" {
10.0
} else {
0.0
}
}
WalkTarget::Bee => {
if l.facts().is_air(l.state(x, y, z)) {
10.0
} else {
0.0
}
}
WalkTarget::HappyGhast => {
let air = |dy| l.facts().is_air(l.state(x, y + dy, z));
if !air(0) {
0.0
} else if air(-1) && !air(-2) {
10.0
} else {
5.0
}
}
};
value >= 0.0
}
/// `InfestedBlock.isCompatibleHostBlock`.
fn infested_host(block: &str) -> bool {
matches!(
block,
"minecraft:stone"
| "minecraft:cobblestone"
| "minecraft:stone_bricks"
| "minecraft:mossy_stone_bricks"
| "minecraft:cracked_stone_bricks"
| "minecraft:chiseled_stone_bricks"
| "minecraft:deepslate"
)
}
/// `LevelReader.containsAnyLiquid`: the blocks from the box's minimum corner
/// to the block holding its maximum corner.
pub fn contains_any_liquid<L: SpawnLevel>(l: &L, b: Aabb) -> bool {
let (lo, hi) = (b.min_position(), b.max_position());
let (x0, y0, z0) = (
lo.x.floor() as i32,
lo.y.floor() as i32,
lo.z.floor() as i32,
);
let (x1, y1, z1) = (
hi.x.floor() as i32,
hi.y.floor() as i32,
hi.z.floor() as i32,
);
(x0..=x1).any(|x| {
(y0..=y1).any(|y| {
(z0..=z1).any(|z| l.facts().get(l.state(x, y, z)).fluid != crate::blocks::Fluid::None)
})
})
}
/// `EntityDimensions.makeBoundingBox`: the half width is a float.
pub fn spawn_box(x: f64, y: f64, z: f64, width: f32, height: f32) -> Aabb {
let half = f64::from(width / 2.0);
Aabb::new(
Vec3::new(x - half, y, z - half),
Vec3::new(x + half, y + f64::from(height), z + half),
)
}
/// `EntityType.spawnDimensionsScale`: cube mobs are checked for room at
/// their largest spawn size.
fn spawn_dimensions_scale(s: Species) -> f32 {
match s {
Species::Slime | Species::MagmaCube => 4.0,
Species::SulfurCube => 2.0,
_ => 1.0,
}
}
/// `EntityType.getSpawnAABB`.
pub fn spawn_aabb(s: Species, x: f64, y: f64, z: f64, width: f32, height: f32) -> Aabb {
let scale = spawn_dimensions_scale(s);
let half = f64::from(scale * width / 2.0);
Aabb::new(
Vec3::new(x - half, y, z - half),
Vec3::new(x + half, y + f64::from(scale * height), z + half),
)
}
/// `checkSpawnObstruction` of a freshly created mob with the given box.
pub(crate) fn spawn_obstruction<L: NaturalLevel>(
s: Species,
l: &L,
bounds: Aabb,
spawned: &[Aabb],
x: i32,
y: i32,
z: i32,
) -> bool {
let unobstructed =
|l: &L| l.unobstructed(bounds) && !spawned.iter().any(|b| b.intersects(bounds));
match obstruction(s) {
Obstruction::NoLiquidUnobstructed => !contains_any_liquid(l, bounds) && unobstructed(l),
Obstruction::Unobstructed => unobstructed(l),
Obstruction::NoLiquid => !contains_any_liquid(l, bounds),
Obstruction::Ocelot => {
if unobstructed(l) && !contains_any_liquid(l, bounds) {
if y < l.sea_level() {
return false;
}
let below = name_at(l, x, y - 1, z);
if below == "minecraft:grass_block" || l.block_tag("minecraft:leaves", below) {
return true;
}
}
false
}
}
}
/// A structure's spawn override for one category.
#[derive(Clone, Debug)]
pub struct Override {
/// `bounding_box: piece` (else the whole structure's box).
pub piece: bool,
pub spawns: Vec<SpawnEntry>,
}
/// Every structure's `spawn_overrides`, by structure id then category.
#[derive(Clone, Debug, Default)]
pub struct StructureSpawns {
/// Fx-hashed: natural spawning asks for every structure reaching every
/// position it tries.
pub overrides: FxHashMap<String, FxHashMap<String, Override>>,
}
impl StructureSpawns {
/// The overrides of the resource root first asked for, loaded once.
pub fn shared(root: &Path) -> &'static Self {
static SHARED: std::sync::OnceLock<StructureSpawns> = std::sync::OnceLock::new();
SHARED.get_or_init(|| Self::load(root))
}
pub fn load(root: &Path) -> Self {
let mut overrides = FxHashMap::default();
let dir = root.join("data/minecraft/worldgen/structure");
for entry in fs::read_dir(dir).into_iter().flatten().flatten() {
let path = entry.path();
let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
continue;
};
let Some(v) = fs::read(&path)
.ok()
.and_then(|b| serde_json::from_slice::<Value>(&b).ok())
else {
continue;
};
let map: FxHashMap<String, Override> = v["spawn_overrides"]
.as_object()
.into_iter()
.flatten()
.map(|(category, o)| {
(
category.clone(),
Override {
piece: o["bounding_box"].as_str() == Some("piece"),
spawns: parse_entries(&o["spawns"]),
},
)
})
.collect();
if !map.is_empty() {
overrides.insert(format!("minecraft:{stem}"), map);
}
}
Self { overrides }
}
pub fn get(&self, structure: &str, category: &str) -> Option<&Override> {
self.overrides.get(structure)?.get(category)
}
}
/// A structure whose references reach a position's chunk.
#[derive(Clone, Debug)]
pub struct StructureAt {
pub id: String,
/// A piece of one of its starts holds the position.
pub in_piece: bool,
/// One of its starts' bounding boxes holds the position.
pub in_bounds: bool,
}
/// `NetherFortressStructure.FORTRESS_ENEMIES`.
pub fn fortress_enemies() -> &'static [SpawnEntry] {
static ENEMIES: std::sync::LazyLock<Vec<SpawnEntry>> = std::sync::LazyLock::new(|| {
let e = |entity: &str, weight, min, max, constant| SpawnEntry {
entity: entity.to_owned(),
weight,
min,
max,
constant,
};
vec![
e("minecraft:blaze", 10, 2, 3, false),
e("minecraft:zombified_piglin", 5, 4, 4, true),
e("minecraft:wither_skeleton", 8, 5, 5, true),
e("minecraft:skeleton", 2, 5, 5, true),
e("minecraft:magma_cube", 3, 4, 4, true),
]
});
&ENEMIES
}
/// `NaturalSpawner.mobsAt`: the fortress bounds on nether bricks, then
/// `ChunkGenerator.getMobsAt` (the first referenced structure whose override
/// for the category holds the position), else the biome's list. Borrowed from
/// the level: a spawn attempt looks it up up to twice.
pub fn mobs_at<L: NaturalLevel>(
l: &L,
category: Category,
x: i32,
y: i32,
z: i32,
) -> &[SpawnEntry] {
// Only a fortress or a structure overriding this category's spawns can
// change the list, so only theirs are looked up (the references reaching
// most chunks are mineshafts, which override nothing).
let overrides = l.structure_spawns();
let monster = category == Category::Monster;
let structures = l.structures_at(x, y, z, &|id| {
(monster && id == "minecraft:fortress") || overrides.get(id, category.name()).is_some()
});
if category == Category::Monster
&& name_at(l, x, y - 1, z) == "minecraft:nether_bricks"
&& structures
.iter()
.any(|s| s.id == "minecraft:fortress" && s.in_bounds)
{
return fortress_enemies();
}
for s in &structures {
if let Some(o) = overrides.get(&s.id, category.name())
&& (if o.piece { s.in_piece } else { s.in_bounds })
{
return &o.spawns;
}
}
l.biome_spawns(x, y, z)
.and_then(|b| b.get(category.name()))
.map_or(&[], Vec::as_slice)
}
/// `WeightedList.getRandom`.
pub fn weighted_pick(list: &[SpawnEntry], random: &mut impl RandomSource) -> Option<SpawnEntry> {
let total: i64 = list.iter().map(|e| i64::from(e.weight)).sum();
if total <= 0 {
return None;
}
let mut selection = i64::from(random.next_int_bound(total as i32).ok()?);
for e in list {
selection -= i64::from(e.weight);
if selection < 0 {
return Some(e.clone());
}
}
None
}
/// `SpawnerData.count().sample(random)`: a constant draws nothing.
pub fn sample_count(entry: &SpawnEntry, random: &mut impl RandomSource) -> u32 {
if entry.constant {
entry.min
} else {
let span = entry.max.saturating_sub(entry.min) as i32 + 1;
entry.min + random.next_int_bound(span).unwrap_or(0) as u32
}
}
/// `SpawnerData.equals`: the type and the count provider (the weight is not
/// part of it; a constant and a one-value uniform differ).
fn same_spawner(a: &SpawnEntry, b: &SpawnEntry) -> bool {
a.entity == b.entity && a.constant == b.constant && a.min == b.min && a.max == b.max
}
/// An entity counted by `NaturalSpawner.createState`.
#[derive(Clone, Debug)]
pub struct Counted<'a> {
pub entity: &'a str,
pub category: Category,
/// `blockPosition()`.
pub block: [i32; 3],
pub is_mob: bool,
/// `isPersistenceRequired() || requiresCustomPersistence()`.
pub persistent: bool,
}
/// A player as the spawn caps see it.
#[derive(Clone, Copy, Debug)]
pub struct SpawnPlayer {
pub position: [f64; 3],
pub spectator: bool,
}
/// `NaturalSpawner.SpawnState` with its `PotentialCalculator` and
/// `LocalMobCapCalculator`.
#[derive(Clone, Debug)]
pub struct SpawnState {
spawnable_chunks: i32,
counts: [i32; 8],
charges: Vec<([i32; 3], f64)>,
players: Vec<SpawnPlayer>,
players_near: FxHashMap<(i32, i32), Vec<usize>>,
player_counts: FxHashMap<usize, [i32; 8]>,
last_checked: Option<([i32; 3], String, f64)>,
}
impl SpawnState {
/// `NaturalSpawner.createState`: every non-persistent entity of a
/// spawning category in a loaded chunk adds its biome's spawn charge, its
/// category count and (for mobs) the local caps of the players near it.
pub fn new<L: NaturalLevel>(
l: &L,
spawnable_chunks: i32,
players: Vec<SpawnPlayer>,
entities: &[Counted],
chunk_loaded: impl Fn(i32, i32) -> bool,
) -> Self {
let mut state = Self {
spawnable_chunks,
counts: [0; 8],
charges: Vec::new(),
players,
players_near: FxHashMap::default(),
player_counts: FxHashMap::default(),
last_checked: None,
};
for e in entities {
if e.is_mob && e.persistent || e.category == Category::Misc {
continue;
}
let [x, y, z] = e.block;
if !chunk_loaded(x >> 4, z >> 4) {
continue;
}
if let Some(cost) = l.spawn_cost(e.entity, x, y, z) {
state.add_charge(e.block, cost.charge);
}
if e.is_mob {
state.add_local(x >> 4, z >> 4, e.category);
}
state.counts[e.category.index()] += 1;
}
state
}
fn add_charge(&mut self, pos: [i32; 3], charge: f64) {
if charge != 0.0 {
self.charges.push((pos, charge));
}
}
/// `ChunkMap.getPlayersCloseForSpawning`: none past the natural spawn
/// chunk tracker's range of 8 chunks from every player, else the
/// non-spectators within 128 blocks of the chunk's centre.
fn players_near<'a>(
near: &'a mut FxHashMap<(i32, i32), Vec<usize>>,
players: &[SpawnPlayer],
cx: i32,
cz: i32,
) -> &'a [usize] {
near.entry((cx, cz)).or_insert_with(|| {
let tracked = players.iter().any(|p| {
let (px, pz) = (
(p.position[0].floor() as i32) >> 4,
(p.position[2].floor() as i32) >> 4,
);
(px - cx).abs().max((pz - cz).abs()) <= 8
});
if !tracked {
return Vec::new();
}
let (x, z) = (f64::from(cx * 16 + 8), f64::from(cz * 16 + 8));
players
.iter()
.enumerate()
.filter(|(_, p)| {
let (dx, dz) = (x - p.position[0], z - p.position[2]);
!p.spectator && dx * dx + dz * dz < 16384.0
})
.map(|(i, _)| i)
.collect()
})
}
fn add_local(&mut self, cx: i32, cz: i32, category: Category) {
for &p in Self::players_near(&mut self.players_near, &self.players, cx, cz) {
self.player_counts.entry(p).or_insert([0; 8])[category.index()] += 1;
}
}
/// `canSpawnForCategoryGlobal`.
pub fn can_spawn_global(&self, category: Category) -> bool {
let max = category.max() * self.spawnable_chunks / 289;
self.counts[category.index()] < max
}
/// `canSpawnForCategoryLocal` (`LocalMobCapCalculator.canSpawn`).
pub fn can_spawn_local(&mut self, category: Category, cx: i32, cz: i32) -> bool {
let near = Self::players_near(&mut self.players_near, &self.players, cx, cz);
near.iter().any(|p| {
self.player_counts
.get(p)
.is_none_or(|c| c[category.index()] < category.max())
})
}
/// `getFilteredSpawningCategories`.
pub fn filtered_categories(
&self,
spawn_enemies: bool,
spawn_persistent: bool,
) -> Vec<Category> {
Category::SPAWNING
.into_iter()
.filter(|&c| {
(spawn_enemies || c.friendly())
&& (spawn_persistent || !c.persistent())
&& self.can_spawn_global(c)
})
.collect()
}
/// `SpawnState.canSpawn`: the spawn potential's energy change must stay
/// within the type's budget where it has a spawn cost.
fn can_spawn<L: NaturalLevel>(&mut self, l: &L, entity: &str, pos: [i32; 3]) -> bool {
match l.spawn_cost(entity, pos[0], pos[1], pos[2]) {
None => {
self.last_checked = Some((pos, entity.to_owned(), 0.0));
true
}
Some(cost) => {
self.last_checked = Some((pos, entity.to_owned(), cost.charge));
self.energy_change(pos, cost.charge) <= cost.energy_budget
}
}
}
/// `PotentialCalculator.getPotentialEnergyChange`.
fn energy_change(&self, pos: [i32; 3], charge: f64) -> f64 {
if charge == 0.0 {
return 0.0;
}
let mut change = 0.0;
for (p, c) in &self.charges {
let d = [
f64::from(p[0] - pos[0]),
f64::from(p[1] - pos[1]),
f64::from(p[2] - pos[2]),
];
let dist = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
change += if dist == 0.0 {
f64::INFINITY
} else {
c / dist.sqrt()
};
}
change * charge
}
/// `SpawnState.afterSpawn`.
fn after_spawn<L: NaturalLevel>(
&mut self,
l: &L,
entity: &str,
category: Category,
pos: [i32; 3],
) {
let charge = match &self.last_checked {
Some((p, t, c)) if *p == pos && t == entity => *c,
_ => l
.spawn_cost(entity, pos[0], pos[1], pos[2])
.map_or(0.0, |c| c.charge),
};
self.add_charge(pos, charge);
self.counts[category.index()] += 1;
self.add_local(pos[0] >> 4, pos[2] >> 4, category);
}
}
/// What a spawn pass did, in vanilla's order (for differential tests).
#[derive(Clone, Debug, PartialEq)]
pub enum Event {
/// `getFilteredSpawningCategories`.
Categories(Vec<Category>),
/// `canSpawnForCategoryLocal` for the chunk.
Local(Category, bool),
/// `getRandomPosWithin`'s start.
Start(Category, [i32; 3]),
/// An attempt at a position (the nearest player lookup).
Try(i32, i32),
/// The type passed `isValidSpawnPostitionForType`; the spawn state's
/// potential test answered.
Test(String, [i32; 3], bool),
/// A mob spawned.
Spawn(String, [f64; 3], f32),
}
/// A mob the spawner is about to add: the level runs `finalizeSpawn` and
/// adds it, returning its finalized box and whether a tropical fish schools.
#[derive(Clone, Debug)]
pub struct SpawnRequest<'a> {
pub entity: &'a str,
pub species: Species,
pub position: [f64; 3],
pub yaw: f32,
/// Mobs of this group spawned before (the `SpawnGroupData`'s size).
pub group_index: u32,
pub reason: Reason,
}
#[derive(Clone, Copy, Debug)]
pub struct Spawned {
pub bounds: Aabb,
/// `TropicalFish.isSchool`.
pub school: bool,
}
/// `NaturalSpawner.spawnForChunk` for the categories already filtered.
#[allow(clippy::too_many_arguments)]
pub fn spawn_for_chunk<L: NaturalLevel, R: RandomSource>(
l: &L,
random: &mut R,
state: &mut SpawnState,
categories: &[Category],
chunk: (i32, i32),
spawn: &mut dyn FnMut(&L, &SpawnRequest) -> Option<Spawned>,
trace: &mut dyn FnMut(Event),
) {
for &category in categories {
let local = state.can_spawn_local(category, chunk.0, chunk.1);
trace(Event::Local(category, local));
if local {
spawn_category_for_chunk(l, random, state, category, chunk, spawn, trace);
}
}
}
/// `NaturalSpawner.spawnCategoryForChunk`: `getRandomPosWithin` (a column of
/// the chunk, a height up to one above the world surface).
pub fn spawn_category_for_chunk<L: NaturalLevel, R: RandomSource>(
l: &L,
random: &mut R,
state: &mut SpawnState,
category: Category,
chunk: (i32, i32),
spawn: &mut dyn FnMut(&L, &SpawnRequest) -> Option<Spawned>,
trace: &mut dyn FnMut(Event),
) {
let x = chunk.0 * 16 + random.next_int_bound(16).unwrap_or(0);
let z = chunk.1 * 16 + random.next_int_bound(16).unwrap_or(0);
let top = l.heightmap(Heightmap::WorldSurface, x, z) + 1;
let min = l.min_y();
let y = min + random.next_int_bound(top - min + 1).unwrap_or(0);
trace(Event::Start(category, [x, y, z]));
if y > min {
spawn_category_for_position(l, random, state, category, chunk, [x, y, z], spawn, trace);
}
}
/// `NaturalSpawner.spawnCategoryForPosition` with the spawn state's
/// `canSpawn` and `afterSpawn`.
#[allow(clippy::too_many_arguments)]
pub fn spawn_category_for_position<L: NaturalLevel, R: RandomSource>(
l: &L,
random: &mut R,
state: &mut SpawnState,
category: Category,
chunk: (i32, i32),
start: [i32; 3],
spawn: &mut dyn FnMut(&L, &SpawnRequest) -> Option<Spawned>,
trace: &mut dyn FnMut(Event),
) {
let [x0, y, z0] = start;
if l.mob_data().state(l.state(x0, y, z0)).flags & super::data::REDSTONE_CONDUCTOR != 0 {
return;
}
let mut spawned: Vec<Aabb> = Vec::new();
let mut cluster = 0u32;
let mut nearest = Nearest::new(start);
for _ in 0..3 {
let (mut x, mut z) = (x0, z0);
// The group's entry, its type and where it was picked.
let mut current: Option<(SpawnEntry, Option<MobType>, [i32; 3])> = None;
let mut group_index = 0u32;
let mut max = (random.next_float() * 4.0).ceil() as i32;
let mut ll = 0;
while ll < max {
ll += 1;
x += random.next_int_bound(6).unwrap_or(0) - random.next_int_bound(6).unwrap_or(0);
z += random.next_int_bound(6).unwrap_or(0) - random.next_int_bound(6).unwrap_or(0);
let (xx, zz) = (f64::from(x) + 0.5, f64::from(z) + 0.5);
trace(Event::Try(x, z));
let Some(distance) = nearest.distance_sqr(l, xx, f64::from(y), zz) else {
continue;
};
if !right_distance(l, chunk, [x, y, z], distance) {
continue;
}
if current.is_none() {
let list = if category == Category::WaterAmbient
&& l.biome_tag("minecraft:reduce_water_ambient_spawns", x, y, z)
&& random.next_float() < 0.98
{
None
} else {
weighted_pick(mobs_at(l, category, x, y, z), random)
};
let Some(entry) = list else {
break;
};
max = sample_count(&entry, random) as i32;
let kind = l.mob_type(&entry.entity);
current = Some((entry, kind, [x, y, z]));
}
let (entry, kind, picked_at) = current.as_ref().unwrap_or_else(|| unreachable!());
// The list the entry was picked from holds it where it was picked.
let listed = *picked_at == [x, y, z];
let valid = valid_position_for_type(
l,
random,
category,
entry,
*kind,
listed,
[x, y, z],
distance,
);
let Some((species, width, height, type_category)) = (*kind).filter(|_| valid) else {
continue;
};
let passed = state.can_spawn(l, &entry.entity, [x, y, z]);
trace(Event::Test(entry.entity.clone(), [x, y, z], passed));
if !passed {
continue;
}
// getMobForSpawn (a type the game cannot create, which would end
// the pass, never passes isValidSpawnPostitionForType).
let yaw = random.next_float() * 360.0;
let bounds = spawn_box(xx, f64::from(y), zz, width, height);
let despawn = f64::from(type_category.despawn_distance().pow(2));
let far = distance > despawn && removed_when_far(species);
if far
|| !mob_spawn_rules(species, l, x, y, z)
|| !spawn_obstruction(species, l, bounds, &spawned, x, y, z)
{
continue;
}
let request = SpawnRequest {
entity: &entry.entity,
species,
position: [xx, f64::from(y), zz],
yaw,
group_index,
reason: Reason::Natural,
};
let Some(result) = spawn(l, &request) else {
continue;
};
group_index += 1;
spawned.push(result.bounds);
cluster += 1;
state.after_spawn(l, &entry.entity, type_category, [x, y, z]);
trace(Event::Spawn(
entry.entity.clone(),
[xx, f64::from(y), zz],
yaw,
));
if cluster >= max_cluster_size(species) {
return;
}
// TropicalFish.isMaxGroupSizeReached.
if species == Species::TropicalFish && !result.school {
break;
}
}
}
}
/// `getNearestPlayer(x, y, z, -1, false)`'s squared distance for the
/// attempts of one start. The spawn checks only compare it with 24² and the
/// despawn distances (128² at most), so it is measured only to the players
/// that can be within 128 blocks of an attempt near the start: when none is,
/// the nearest reads as infinitely far, which every check answers as it
/// answers the real distance. An attempt that wanders farther than
/// `MARGIN` from the start measures every player.
struct Nearest {
/// The players that can be within 128 blocks, once an attempt asked.
nearby: Option<Vec<[f64; 3]>>,
start: (f64, f64),
}
impl Nearest {
const REACH: f64 = 128.0;
const MARGIN: f64 = 64.0;
fn new(start: [i32; 3]) -> Self {
Self {
nearby: None,
start: (f64::from(start[0]) + 0.5, f64::from(start[2]) + 0.5),
}
}
fn distance_sqr<L: NaturalLevel>(&mut self, l: &L, x: f64, y: f64, z: f64) -> Option<f64> {
let all = l.nearest_player_positions();
if all.is_empty() {
return None;
}
let distance = |p: &[f64; 3]| (p[0] - x).powi(2) + (p[1] - y).powi(2) + (p[2] - z).powi(2);
let (sx, sz) = self.start;
if (x - sx).abs() > Self::MARGIN || (z - sz).abs() > Self::MARGIN {
return all.iter().map(distance).reduce(f64::min);
}
// The others are farther than REACH, across, from every point within
// MARGIN of the start.
let nearby = self.nearby.get_or_insert_with(|| {
all.iter()
.filter(|p| {
let dx = ((p[0] - sx).abs() - Self::MARGIN).max(0.0);
let dz = ((p[2] - sz).abs() - Self::MARGIN).max(0.0);
dx * dx + dz * dz <= Self::REACH * Self::REACH
})
.copied()
.collect()
});
Some(nearby.iter().map(distance).fold(f64::INFINITY, f64::min))
}
}
/// `isRightDistanceToPlayerAndSpawnPoint`.
fn right_distance<L: NaturalLevel>(l: &L, chunk: (i32, i32), pos: [i32; 3], distance: f64) -> bool {
if distance <= 576.0 {
return false;
}
if let Some(r) = l.respawn() {
let d = [
f64::from(r[0]) + 0.5 - (f64::from(pos[0]) + 0.5),
f64::from(r[1]) + 0.5 - f64::from(pos[1]),
f64::from(r[2]) + 0.5 - (f64::from(pos[2]) + 0.5),
];
if d[0] * d[0] + d[1] * d[1] + d[2] * d[2] < 24.0 * 24.0 {
return false;
}
}
let (cx, cz) = (pos[0] >> 4, pos[2] >> 4);
(cx, cz) == chunk || l.can_spawn_in_chunk(cx, cz)
}
/// `isValidSpawnPostitionForType`, for the entry's type (`mob_type`).
/// `listed`: the position is where the entry was picked from `mobsAt`.
#[allow(clippy::too_many_arguments)]
fn valid_position_for_type<L: NaturalLevel, R: RandomSource>(
l: &L,
random: &mut R,
category: Category,
entry: &SpawnEntry,
kind: Option<MobType>,
listed: bool,
pos: [i32; 3],
distance: f64,
) -> bool {
let Some((species, width, height, type_category)) = kind else {
return false;
};
if type_category == Category::Misc {
return false;
}
let despawn = f64::from(type_category.despawn_distance().pow(2));
if !spawns_far_from_player(species, type_category) && distance > despawn {
return false;
}
let [x, y, z] = pos;
if !listed
&& !mobs_at(l, category, x, y, z)
.iter()
.any(|e| same_spawner(e, entry))
{
return false;
}
if !spawn_rules::is_spawn_position_ok(species, l, x, y, z) {
return false;
}
if !spawn_rules::check_spawn_rules(species, l, Reason::Natural, random, x, y, z) {
return false;
}
l.no_collision(spawn_aabb(
species,
f64::from(x) + 0.5,
f64::from(y),
f64::from(z) + 0.5,
width,
height,
))
}
/// What chunk generation spawning did (for differential tests).
#[derive(Clone, Debug, PartialEq)]
pub enum GenEvent {
/// An attempt at a column (the heightmap lookup).
Column(i32, i32),
Spawn(String, [f64; 3], f32),
}
/// `NaturalSpawner.spawnMobsForChunkGeneration`: creature packs placed on
/// the chunk's surface. `rules` is the level's own random, which the spawn
/// predicates draw from.
#[allow(clippy::too_many_arguments)]
pub fn spawn_mobs_for_chunk_generation<L: NaturalLevel, R: RandomSource, Q: RandomSource>(
l: &L,
source: [i32; 3],
chunk: (i32, i32),
random: &mut R,
rules: &mut Q,
spawn: &mut dyn FnMut(&L, &SpawnRequest) -> Option<Spawned>,
trace: &mut dyn FnMut(GenEvent),
) {
if !l.spawn_mobs() {
return;
}
let [sx, sy, sz] = source;
let mobs = l
.biome_spawns(sx, sy, sz)
.and_then(|b| b.get("creature"))
.cloned()
.unwrap_or_default();
if mobs.iter().map(|e| e.weight).sum::<u32>() == 0 {
return;
}
let probability = l.creature_probability(sx, sy, sz);
let (xo, zo) = (chunk.0 * 16, chunk.1 * 16);
while random.next_float() < probability {
let Some(entry) = weighted_pick(&mobs, random) else {
continue;
};
let count = sample_count(&entry, random);
let mut group_index = 0u32;
let mut spawned: Vec<Aabb> = Vec::new();
let mut x = xo + random.next_int_bound(16).unwrap_or(0);
let mut z = zo + random.next_int_bound(16).unwrap_or(0);
let (start_x, start_z) = (x, z);
let kind = l.mob_type(&entry.entity);
for _ in 0..count {
let mut success = false;
let mut attempts = 0;
while !success && attempts < 4 {
attempts += 1;
let Some((species, width, height, _)) = kind else {
break;
};
let pos = top_non_colliding(l, &entry.entity, x, z);
trace(GenEvent::Column(x, z));
if spawn_rules::is_spawn_position_ok(species, l, pos[0], pos[1], pos[2]) {
let fx = f64::from(x).clamp(
f64::from(xo) + f64::from(width),
f64::from(xo) + 16.0 - f64::from(width),
);
let fz = f64::from(z).clamp(
f64::from(zo) + f64::from(width),
f64::from(zo) + 16.0 - f64::from(width),
);
let fy = f64::from(pos[1]);
let (bx, bz) = (fx.floor() as i32, fz.floor() as i32);
if !l.no_collision(spawn_aabb(species, fx, fy, fz, width, height))
|| !spawn_rules::check_spawn_rules(
species,
l,
Reason::ChunkGeneration,
rules,
bx,
pos[1],
bz,
)
{
continue;
}
let yaw = random.next_float() * 360.0;
let bounds = spawn_box(fx, fy, fz, width, height);
if mob_spawn_rules(species, l, bx, pos[1], bz)
&& spawn_obstruction(species, l, bounds, &spawned, bx, pos[1], bz)
{
let request = SpawnRequest {
entity: &entry.entity,
species,
position: [fx, fy, fz],
yaw,
group_index,
reason: Reason::ChunkGeneration,
};
if let Some(result) = spawn(l, &request) {
group_index += 1;
spawned.push(result.bounds);
trace(GenEvent::Spawn(entry.entity.clone(), [fx, fy, fz], yaw));
success = true;
}
}
}
x += random.next_int_bound(5).unwrap_or(0) - random.next_int_bound(5).unwrap_or(0);
z += random.next_int_bound(5).unwrap_or(0) - random.next_int_bound(5).unwrap_or(0);
while x < xo || x >= xo + 16 || z < zo || z >= zo + 16 {
x = start_x + random.next_int_bound(5).unwrap_or(0)
- random.next_int_bound(5).unwrap_or(0);
z = start_z + random.next_int_bound(5).unwrap_or(0)
- random.next_int_bound(5).unwrap_or(0);
}
}
}
}
}
/// `getTopNonCollidingPos`: the type's heightmap, under the ceiling in
/// dimensions that have one, then the placement type's adjustment.
fn top_non_colliding<L: NaturalLevel>(l: &L, entity: &str, x: i32, z: i32) -> [i32; 3] {
let heightmap = Heightmap::from_name(l.mob_data().heightmap(entity));
let mut y = l.heightmap(heightmap, x, z);
if l.has_ceiling() {
loop {
y -= 1;
if l.facts().is_air(l.state(x, y, z)) {
break;
}
}
loop {
y -= 1;
if !(l.facts().is_air(l.state(x, y, z)) && y > l.min_y()) {
break;
}
}
}
if l.mob_data().placement(entity) == super::data::Placement::OnGround
&& l.pathfindable_land(x, y - 1, z)
{
y -= 1;
}
[x, y, z]
}