Files
horizon-airdef/crates/horizon-client/src/mobs/finalize.rs
T
Ludovic Marie 5205b909f7 Villagers, llamas, bees, allays and copper golems search the full path budget
PathNavigation.setRequiredPathLength calls updatePathfinderMaxVisitedNodes, so a
villager's PathFinder visits up to max(follow range, 48) * 16 = 768 nodes, not the
256 of its follow range alone. Horizon always used follow range * 16, so a villager
gave up on any job site, bed or bell whose path needed more than 256 nodes: in the
seed 12345 village it never found the way round to the mason's stonecutter door.

Navigation now keeps PathFinder.maxVisitedNodes: the base follow range times 16 when
the mob is made, then max(follow range, required path length) * 16 after
setRequiredPathLength and after any follow range change (Mob.onAttributeUpdated).
A happy ghast that grows up or becomes a baby gets a new navigation, as in vanilla.

mob_ai: villager_job_in_box, a composter inside a stone box whose doorway faces away
from the villager.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-24 05:33:52 +02:00

2066 lines
74 KiB
Rust

//! `Mob.finalizeSpawn` and its overrides, for every spawn path (natural
//! spawning, chunk generation, spawners, trial spawners, spawn eggs,
//! commands, structures, patrols, raids, jockeys, conversions...).
//!
//! Every draw vanilla takes from `level.getRandom()` comes from the random
//! the caller passes (the level's random for a running level, the region's
//! for chunk generation); the few that come from the entity's own random
//! (`Zombie.handleAttributes`, `Piglin.createSpawnWeapon`, salmon sizes) come
//! from `Mob::random`. The order of the draws follows vanilla's class chain:
//! each species runs its own part before or after its superclass as vanilla
//! does. Jockeys a mob brings (`EntityType.create` inside finalizeSpawn) are
//! made through [`FinalizeLevel::create`], finalized with the same random and
//! returned in [`Ctx::created`].
//!
//! Variant state kept in [`super::Extra`]: `variant` is the registry or enum
//! index of the species' variant (cat, wolf, frog, farm animals by climate,
//! zombie nautilus, horse, llama, fox, rabbit, parrot, axolotl, salmon,
//! tropical fish pattern, panda main gene, villager type), `variant2` the
//! second part (horse markings, llama strength, panda hidden gene, tropical
//! fish base colour), `variant3` the tropical fish pattern colour, and
//! `sound_variant` the index in the species' sound variant registry.
use super::{Mob, Species, farm::Climate, gear, spawning::LocalDifficulty};
use crate::{enchant::Enchantments, items::Items};
use horizon_core::{
geometry::Aabb,
random::{LegacyRandom, RandomSource},
};
use serde_json::Value;
use std::{fs, path::Path, sync::Arc};
/// `EntitySpawnReason`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Reason {
Natural,
ChunkGeneration,
Spawner,
Structure,
Breeding,
MobSummoned,
Jockey,
Event,
Conversion,
Reinforcement,
Triggered,
Bucket,
SpawnItemUse,
Command,
Dispenser,
Patrol,
TrialSpawner,
Load,
DimensionTravel,
}
impl Reason {
pub const ALL: [Self; 19] = [
Self::Natural,
Self::ChunkGeneration,
Self::Spawner,
Self::Structure,
Self::Breeding,
Self::MobSummoned,
Self::Jockey,
Self::Event,
Self::Conversion,
Self::Reinforcement,
Self::Triggered,
Self::Bucket,
Self::SpawnItemUse,
Self::Command,
Self::Dispenser,
Self::Patrol,
Self::TrialSpawner,
Self::Load,
Self::DimensionTravel,
];
pub fn name(self) -> &'static str {
match self {
Self::Natural => "NATURAL",
Self::ChunkGeneration => "CHUNK_GENERATION",
Self::Spawner => "SPAWNER",
Self::Structure => "STRUCTURE",
Self::Breeding => "BREEDING",
Self::MobSummoned => "MOB_SUMMONED",
Self::Jockey => "JOCKEY",
Self::Event => "EVENT",
Self::Conversion => "CONVERSION",
Self::Reinforcement => "REINFORCEMENT",
Self::Triggered => "TRIGGERED",
Self::Bucket => "BUCKET",
Self::SpawnItemUse => "SPAWN_ITEM_USE",
Self::Command => "COMMAND",
Self::Dispenser => "DISPENSER",
Self::Patrol => "PATROL",
Self::TrialSpawner => "TRIAL_SPAWNER",
Self::Load => "LOAD",
Self::DimensionTravel => "DIMENSION_TRAVEL",
}
}
pub fn parse(name: &str) -> Option<Self> {
Self::ALL.into_iter().find(|r| r.name() == name)
}
}
/// The level as finalizeSpawn reads it.
pub trait FinalizeLevel {
/// The biome id at a block.
fn biome(&self, pos: [i32; 3]) -> String;
/// The biome at a block is in a biome tag (`minecraft:...`).
fn biome_tag(&self, tag: &str, pos: [i32; 3]) -> bool;
/// The structures with a piece at a block.
fn structures_with_piece_at(&self, pos: [i32; 3]) -> Vec<String>;
/// `EnvironmentAttributes.MOON_PHASE` at a block (0 full moon to 7).
fn moon_phase(&self, pos: [i32; 3]) -> usize;
/// `ServerLevel.isSpawningMonsters`.
fn spawning_monsters(&self) -> bool;
/// `Level.noCollision(AABB)`.
fn no_collision(&self, bounds: Aabb) -> bool;
/// The first chicken (in entity order) whose box meets `bounds` and
/// that is not being ridden (`Zombie.finalizeSpawn`'s chicken jockeys).
fn free_chicken(&self, bounds: Aabb) -> Option<u32>;
/// A chicken found by `free_chicken` carries the zombie `rider`
/// (`setChickenJockey(true)` and `startRiding`).
fn ride_chicken(&mut self, chicken: u32, rider: u32);
/// `getGameTime`.
fn game_time(&self) -> i64;
/// `SpecialDates.isHalloween`.
fn halloween(&self) -> bool;
/// `EntityType.create(level, reason)`: a new mob of a type (an id and an
/// own random from the caller), or None where it cannot exist (monsters
/// in peaceful).
fn create(&mut self, kind: &str, reason: Reason) -> Option<Mob>;
}
/// `AgeableMob.AgeableMobGroupData`.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Ageable {
pub size: i32,
pub should_spawn_baby: bool,
pub baby_chance: f32,
}
impl Ageable {
pub fn new(should_spawn_baby: bool, baby_chance: f32) -> Self {
Self {
size: 0,
should_spawn_baby,
baby_chance,
}
}
/// `AgeableMobGroupData(boolean)`.
pub fn babies(should_spawn_baby: bool) -> Self {
Self::new(should_spawn_baby, 0.05)
}
/// `AgeableMobGroupData(float)`.
pub fn chance(baby_chance: f32) -> Self {
Self::new(true, baby_chance)
}
}
/// `SpawnGroupData`: what the mobs of a pack share.
#[derive(Clone, Debug, PartialEq)]
pub enum Group {
Ageable(Ageable),
/// `Zombie.ZombieGroupData`, and `Husk.HuskGroupData` with `tried_camel`.
Zombie {
baby: bool,
jockey: bool,
husk: Option<bool>,
},
/// `Spider.SpiderEffectsGroupData`.
Spider(Option<&'static str>),
Horse(Ageable, u8),
Llama(Ageable, u8),
Fox(Ageable, u8),
Rabbit(Ageable, u8),
Axolotl(Ageable, [u8; 2]),
Wolf(Ageable, u8),
/// `AbstractSchoolingFish.SchoolSpawnGroupData` (the leader's id), and
/// `TropicalFishGroupData` with its variant.
School(u32, Option<(u8, u8, u8)>),
}
impl Group {
fn ageable(&mut self) -> Option<&mut Ageable> {
match self {
Self::Ageable(a)
| Self::Horse(a, _)
| Self::Llama(a, _)
| Self::Fox(a, _)
| Self::Rabbit(a, _)
| Self::Axolotl(a, _)
| Self::Wolf(a, _) => Some(a),
_ => None,
}
}
}
/// A variant registry entry's spawn conditions (`SpawnPrioritySelectors`).
#[derive(Clone, Debug)]
enum Condition {
Biome(Vec<String>),
Structure(Vec<String>),
Moon(Option<f64>, Option<f64>),
}
#[derive(Clone, Debug)]
pub struct VariantRegistry {
/// Entry names in registry order (sorted by id).
pub names: Vec<String>,
selectors: Vec<(usize, Option<Condition>, i32)>,
}
impl VariantRegistry {
fn load(dir: &Path, structure_tags: &dyn Fn(&str) -> Vec<String>) -> Self {
let mut names: Vec<String> = fs::read_dir(dir)
.into_iter()
.flatten()
.flatten()
.filter_map(|e| {
e.file_name()
.to_str()
.and_then(|n| n.strip_suffix(".json"))
.map(str::to_owned)
})
.collect();
names.sort();
let mut selectors = Vec::new();
for (i, name) in names.iter().enumerate() {
let Ok(bytes) = fs::read(dir.join(format!("{name}.json"))) else {
continue;
};
let Ok(v) = serde_json::from_slice::<Value>(&bytes) else {
continue;
};
for s in v["spawn_conditions"].as_array().into_iter().flatten() {
let priority = s["priority"].as_i64().unwrap_or(0) as i32;
let c = &s["condition"];
let list = |v: &Value| -> Vec<String> {
match v {
Value::String(s) => vec![s.clone()],
Value::Array(a) => a
.iter()
.filter_map(|x| x.as_str().map(str::to_owned))
.collect(),
_ => Vec::new(),
}
};
let condition = match c["type"].as_str() {
Some("minecraft:biome") => Some(Condition::Biome(list(&c["biomes"]))),
Some("minecraft:structure") => Some(Condition::Structure(
list(&c["structures"])
.into_iter()
.flat_map(|s| match s.strip_prefix('#') {
Some(tag) => structure_tags(tag),
None => vec![s],
})
.collect(),
)),
Some("minecraft:moon_brightness") => {
let r = &c["range"];
Some(match r.as_f64() {
Some(x) => Condition::Moon(Some(x), Some(x)),
None => Condition::Moon(r["min"].as_f64(), r["max"].as_f64()),
})
}
_ => None,
};
selectors.push((i, condition, priority));
}
}
Self { names, selectors }
}
pub fn index(&self, name: &str) -> Option<usize> {
let name = name.strip_prefix("minecraft:").unwrap_or(name);
self.names.iter().position(|n| n == name)
}
/// `VariantUtils.selectVariantToSpawn`: the entries of the highest
/// priority whose condition holds, one of them at random.
pub fn select<L: FinalizeLevel + ?Sized>(
&self,
level: &L,
pos: [i32; 3],
random: &mut impl RandomSource,
) -> Option<usize> {
let mut unpacked: Vec<&(usize, Option<Condition>, i32)> = self.selectors.iter().collect();
unpacked.sort_by_key(|s| std::cmp::Reverse(s.2));
let mut highest = i32::MIN;
let mut selected = Vec::new();
for (entry, condition, priority) in unpacked {
if *priority < highest {
continue;
}
let ok = match condition {
None => true,
Some(Condition::Biome(list)) => list.iter().any(|b| match b.strip_prefix('#') {
Some(tag) => level.biome_tag(tag, pos),
None => level.biome(pos) == *b,
}),
Some(Condition::Structure(list)) => {
let here = level.structures_with_piece_at(pos);
here.iter().any(|s| list.contains(s))
}
Some(Condition::Moon(min, max)) => {
let b = f64::from(super::spawning::MOON_BRIGHTNESS[level.moon_phase(pos) & 7]);
min.is_none_or(|m| b >= m) && max.is_none_or(|m| b <= m)
}
};
if ok {
highest = *priority;
selected.push(*entry);
}
}
if selected.is_empty() {
return None;
}
Some(selected[random.next_int_bound(selected.len() as i32).unwrap_or(0) as usize])
}
/// `Registry.getRandom`: any entry.
pub fn random(&self, random: &mut impl RandomSource) -> usize {
if self.names.is_empty() {
return 0;
}
random.next_int_bound(self.names.len() as i32).unwrap_or(0) as usize
}
}
/// The registries finalizeSpawn reads.
pub struct SpawnRegistries {
pub pig: VariantRegistry,
pub cow: VariantRegistry,
pub chicken: VariantRegistry,
pub cat: VariantRegistry,
pub wolf: VariantRegistry,
pub frog: VariantRegistry,
pub zombie_nautilus: VariantRegistry,
pub pig_sound: VariantRegistry,
pub cow_sound: VariantRegistry,
pub chicken_sound: VariantRegistry,
pub cat_sound: VariantRegistry,
pub wolf_sound: VariantRegistry,
}
impl SpawnRegistries {
/// Loads the variant registries from a resources directory
/// (`data/minecraft/<registry>/`).
pub fn load(root: &Path) -> Self {
let data = root.join("data/minecraft");
let structure_tag = |tag: &str| -> Vec<String> {
let path = tag.strip_prefix("minecraft:").unwrap_or(tag);
let file = data.join(format!("tags/worldgen/structure/{path}.json"));
let Ok(bytes) = fs::read(file) else {
return Vec::new();
};
serde_json::from_slice::<Value>(&bytes)
.ok()
.and_then(|v| v["values"].as_array().cloned())
.into_iter()
.flatten()
.filter_map(|x| x.as_str().map(str::to_owned))
.collect()
};
let r = |name: &str| VariantRegistry::load(&data.join(name), &structure_tag);
Self {
pig: r("pig_variant"),
cow: r("cow_variant"),
chicken: r("chicken_variant"),
cat: r("cat_variant"),
wolf: r("wolf_variant"),
frog: r("frog_variant"),
zombie_nautilus: r("zombie_nautilus_variant"),
pig_sound: r("pig_sound_variant"),
cow_sound: r("cow_sound_variant"),
chicken_sound: r("chicken_sound_variant"),
cat_sound: r("cat_sound_variant"),
wolf_sound: r("wolf_sound_variant"),
}
}
}
/// What finalizeSpawn needs besides the level: registries, enchantments.
pub struct SpawnData<'a> {
pub registries: &'a SpawnRegistries,
pub enchantments: &'a Enchantments,
pub items: &'a Items,
/// `EntityTypes.CAMEL_HUSK` dimensions (width, height).
pub camel_husk_size: (f32, f32),
}
/// A finalizeSpawn call and the entities it made.
pub struct Ctx<'a, L: FinalizeLevel + ?Sized, R: RandomSource> {
pub level: &'a mut L,
pub random: &'a mut R,
pub difficulty: LocalDifficulty,
pub data: &'a SpawnData<'a>,
/// Jockeys and mounts made along the way, finalized, with their riding
/// links set (`Extra::mount` / `Extra::rider`).
pub created: Vec<Mob>,
}
// ---- attributes -----------------------------------------------------------
/// The attributes finalizeSpawn changes.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Attr {
MaxHealth,
MovementSpeed,
FollowRange,
AttackDamage,
KnockbackResistance,
SpawnReinforcements,
JumpStrength,
Armor,
BurningTime,
}
impl Attr {
pub const ALL: [Self; 9] = [
Self::MaxHealth,
Self::MovementSpeed,
Self::FollowRange,
Self::AttackDamage,
Self::KnockbackResistance,
Self::SpawnReinforcements,
Self::JumpStrength,
Self::Armor,
Self::BurningTime,
];
pub fn name(self) -> &'static str {
match self {
Self::MaxHealth => "max_health",
Self::MovementSpeed => "movement_speed",
Self::FollowRange => "follow_range",
Self::AttackDamage => "attack_damage",
Self::KnockbackResistance => "knockback_resistance",
Self::SpawnReinforcements => "spawn_reinforcements",
Self::JumpStrength => "jump_strength",
Self::Armor => "armor",
Self::BurningTime => "burning_time",
}
}
/// `RangedAttribute` bounds.
fn range(self) -> (f64, f64) {
match self {
Self::MaxHealth => (1.0, 1024.0),
Self::MovementSpeed => (0.0, 1024.0),
Self::FollowRange => (0.0, 2048.0),
Self::AttackDamage => (0.0, 2048.0),
Self::KnockbackResistance | Self::SpawnReinforcements => (0.0, 1.0),
Self::JumpStrength => (0.0, 32.0),
Self::Armor => (0.0, 30.0),
Self::BurningTime => (0.0, 1024.0),
}
}
}
/// `AttributeModifier.Operation`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Op {
AddValue,
AddMultipliedBase,
AddMultipliedTotal,
}
/// A permanent attribute modifier (`AttributeModifier`).
#[derive(Clone, Debug, PartialEq)]
pub struct Modifier {
pub attr: Attr,
pub id: &'static str,
pub amount: f64,
pub op: Op,
}
/// Attribute base values that differ from the type's and the permanent
/// modifiers finalizeSpawn added, in the order vanilla adds them.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Attributes {
pub bases: Vec<(Attr, f64)>,
pub modifiers: Vec<Modifier>,
}
/// The type's default value of an attribute, if the mob has it.
pub fn default_value(m: &Mob, a: Attr) -> Option<f64> {
m.kind
.attributes
.get(&format!("minecraft:{}", a.name()))
.copied()
}
pub fn base_value(m: &Mob, a: Attr) -> f64 {
m.extra
.attributes
.as_ref()
.and_then(|s| s.bases.iter().find(|(x, _)| *x == a).map(|(_, v)| *v))
.or_else(|| default_value(m, a))
.unwrap_or(if a == Attr::BurningTime { 1.0 } else { 0.0 })
}
/// The transient modifiers of the mob's state (`SPEED_MODIFIER_BABY`).
pub fn transient(m: &Mob, a: Attr) -> Option<(f64, Op)> {
if a != Attr::MovementSpeed || !m.is_baby() {
return None;
}
match m.species() {
Species::Zombie
| Species::Husk
| Species::Drowned
| Species::ZombieVillager
| Species::ZombifiedPiglin => Some((0.5, Op::AddMultipliedBase)),
Species::Piglin => Some((f64::from(0.2f32), Op::AddMultipliedBase)),
_ => None,
}
}
/// The attribute modifiers of the mob's effects (`MobEffect.addAttributeModifier`,
/// scaled by the amplifier plus one): strength and speed.
fn effect_modifiers(m: &Mob, a: Attr) -> impl Iterator<Item = (f64, Op)> + '_ {
m.extra
.effects
.iter()
.filter_map(move |&(effect, _, amplifier)| {
let level = f64::from(amplifier + 1);
match (effect.trim_start_matches("minecraft:"), a) {
("strength", Attr::AttackDamage) => Some((3.0 * level, Op::AddValue)),
("speed", Attr::MovementSpeed) => {
Some((f64::from(0.2f32) * level, Op::AddMultipliedTotal))
}
_ => None,
}
})
}
/// `AttributeInstance.getValue`: the base, then the modifiers by operation.
pub fn value(m: &Mob, a: Attr) -> f64 {
compute(m, a, true)
}
fn compute(m: &Mob, a: Attr, with_transient: bool) -> f64 {
let mut base = base_value(m, a);
let empty = Vec::new();
let mods = m.extra.attributes.as_ref().map_or(&empty, |s| &s.modifiers);
let mut ops: Vec<(f64, Op)> = mods
.iter()
.filter(|x| x.attr == a)
.map(|x| (x.amount, x.op))
.collect();
if with_transient {
ops.extend(transient(m, a));
ops.extend(effect_modifiers(m, a));
}
for (amount, op) in &ops {
if *op == Op::AddValue {
base += amount;
}
}
let mut result = base;
for (amount, op) in &ops {
if *op == Op::AddMultipliedBase {
result += base * amount;
}
}
for (amount, op) in &ops {
if *op == Op::AddMultipliedTotal {
result *= 1.0 + amount;
}
}
let (lo, hi) = a.range();
if result.is_nan() {
lo
} else {
result.clamp(lo, hi)
}
}
/// Copies the attribute values into the fields the game reads.
fn refresh(m: &mut Mob, a: Attr) {
match a {
Attr::MaxHealth => m.attrs.max_health = value(m, a) as f32,
Attr::MovementSpeed => m.attrs.speed = base_with_modifiers(m, a),
Attr::FollowRange => {
m.attrs.follow_range = value(m, a);
m.update_max_visited_nodes();
}
Attr::AttackDamage => m.attrs.attack_damage = value(m, a) as f32,
Attr::KnockbackResistance => m.attrs.knockback_resistance = value(m, a),
Attr::SpawnReinforcements => m.attrs.spawn_reinforcements = value(m, a),
Attr::JumpStrength => m.attrs.jump_strength = value(m, a),
Attr::Armor | Attr::BurningTime => {}
}
}
/// The value without the transient baby modifier (`speed_bonus` applies
/// that one to movement speed).
fn base_with_modifiers(m: &Mob, a: Attr) -> f64 {
compute(m, a, false)
}
/// `AttributeInstance.setBaseValue`.
pub fn set_base(m: &mut Mob, a: Attr, v: f64) {
let s = m.extra.attributes.get_or_insert_with(Box::default);
match s.bases.iter_mut().find(|(x, _)| *x == a) {
Some(b) => b.1 = v,
None => s.bases.push((a, v)),
}
refresh(m, a);
}
pub fn has_modifier(m: &Mob, a: Attr, id: &str) -> bool {
m.extra
.attributes
.as_ref()
.is_some_and(|s| s.modifiers.iter().any(|x| x.attr == a && x.id == id))
}
/// `addOrReplacePermanentModifier`.
pub fn add_modifier(m: &mut Mob, a: Attr, id: &'static str, amount: f64, op: Op) {
let s = m.extra.attributes.get_or_insert_with(Box::default);
let new = Modifier {
attr: a,
id,
amount,
op,
};
match s.modifiers.iter_mut().find(|x| x.attr == a && x.id == id) {
Some(x) => *x = new,
None => s.modifiers.push(new),
}
refresh(m, a);
}
pub fn max_health(m: &Mob) -> f32 {
value(m, Attr::MaxHealth) as f32
}
// ---- species facts --------------------------------------------------------
/// `AgeableMob` subclasses.
pub fn ageable(s: Species) -> bool {
use Species as S;
matches!(
s,
S::Pig
| S::Cow
| S::Mooshroom
| S::Sheep
| S::Chicken
| S::Rabbit
| S::Horse
| S::Donkey
| S::Mule
| S::Llama
| S::TraderLlama
| S::Goat
| S::Panda
| S::PolarBear
| S::Fox
| S::Wolf
| S::Cat
| S::Ocelot
| S::Parrot
| S::Bee
| S::Turtle
| S::Armadillo
| S::Frog
| S::Axolotl
| S::Squid
| S::GlowSquid
| S::Dolphin
| S::Villager
| S::WanderingTrader
| S::Slime
| S::MagmaCube
| S::SulfurCube
| S::Hoglin
| S::Strider
| S::Camel
| S::CamelHusk
| S::Sniffer
| S::HappyGhast
| S::Nautilus
| S::ZombieNautilus
| S::ZombieHorse
| S::SkeletonHorse
)
}
fn zombie(s: Species) -> bool {
matches!(
s,
Species::Zombie
| Species::Husk
| Species::Drowned
| Species::ZombieVillager
| Species::ZombifiedPiglin
)
}
fn skeleton(s: Species) -> bool {
matches!(
s,
Species::Skeleton
| Species::Stray
| Species::Bogged
| Species::Parched
| Species::WitherSkeleton
)
}
fn raider(s: Species) -> bool {
super::raider::is_raider(s)
}
/// `EntityType.isAllowedInPeaceful`: the types built with `notInPeaceful`.
pub fn allowed_in_peaceful(kind: &str) -> bool {
!matches!(
kind.strip_prefix("minecraft:").unwrap_or(kind),
"blaze"
| "bogged"
| "breeze"
| "cave_spider"
| "creaking"
| "creeper"
| "drowned"
| "elder_guardian"
| "enderman"
| "endermite"
| "evoker"
| "ghast"
| "giant"
| "guardian"
| "hoglin"
| "husk"
| "illusioner"
| "magma_cube"
| "parched"
| "phantom"
| "piglin_brute"
| "pillager"
| "ravager"
| "silverfish"
| "skeleton"
| "slime"
| "spider"
| "stray"
| "vex"
| "vindicator"
| "warden"
| "witch"
| "wither"
| "wither_skeleton"
| "zoglin"
| "zombie"
| "zombie_villager"
| "zombified_piglin"
)
}
/// `getBabyStartAge`.
fn baby_start_age(s: Species) -> i32 {
if s == Species::Sniffer {
super::sniffer::BABY_START_AGE
} else {
-24000
}
}
/// The age a non-ageable baby (zombies, piglins, zoglins) keeps.
pub const NON_AGEABLE_BABY: i32 = i32::MIN / 2;
/// `AgeableMob.setAge`, with each class's `ageBoundaryReached`.
pub fn set_age(m: &mut Mob, age: i32) {
let old = m.extra.age;
m.extra.age = age;
if (old < 0) != (age < 0) {
age_boundary_reached(m);
}
}
fn age_boundary_reached(m: &mut Mob) {
let baby = m.is_baby();
match m.species() {
Species::Goat => set_base(m, Attr::AttackDamage, if baby { 1.0 } else { 2.0 }),
Species::Hoglin => set_base(m, Attr::AttackDamage, if baby { 0.5 } else { 6.0 }),
Species::SulfurCube if !baby => sulfur_size(m, 2),
_ => {}
}
}
/// `setBaby`: AgeableMob through its age, zombies, piglins and zoglins.
pub fn set_baby(m: &mut Mob, baby: bool) {
let s = m.species();
if ageable(s) {
set_age(m, if baby { baby_start_age(s) } else { 0 });
return;
}
match s {
_ if zombie(s) || s == Species::Piglin => {
m.extra.age = if baby { NON_AGEABLE_BABY } else { 0 };
}
Species::Zoglin => {
m.extra.age = if baby { NON_AGEABLE_BABY } else { 0 };
if baby {
set_base(m, Attr::AttackDamage, 0.5);
}
}
_ => {}
}
}
// ---- equipment ------------------------------------------------------------
/// `EquipmentSlot` names (the `drops::SLOTS` order).
pub const SLOT_NAMES: [&str; 8] = super::drops::SLOTS;
const MAINHAND: usize = 0;
const OFFHAND: usize = 1;
const FEET: usize = 2;
const LEGS: usize = 3;
const CHEST: usize = 4;
const HEAD: usize = 5;
const SADDLE: usize = 7;
/// The `gear` slot of an `EquipmentSlot`.
fn gear_slot(slot: usize) -> usize {
match slot {
MAINHAND => gear::MAIN,
OFFHAND => gear::OFF,
FEET => gear::FEET,
LEGS => gear::LEGS,
CHEST => gear::CHEST,
_ => gear::HEAD,
}
}
pub fn item(m: &Mob, slot: usize) -> Option<Arc<str>> {
match slot {
MAINHAND => m.extra.main_hand.clone(),
OFFHAND => m.extra.off_hand.clone(),
FEET => m.extra.feet.clone(),
LEGS => m.extra.legs.clone(),
CHEST => m.extra.chest.clone(),
HEAD => m.extra.head.clone(),
SADDLE => m.extra.saddled.then(|| Arc::from("minecraft:saddle")),
_ => None,
}
}
/// `setItemSlot` with a fresh stack (enchantments cleared).
pub fn set_item(m: &mut Mob, slot: usize, id: &str) {
let v = Some(Arc::from(id));
match slot {
MAINHAND => m.extra.main_hand = v,
OFFHAND => m.extra.off_hand = v,
FEET => m.extra.feet = v,
LEGS => m.extra.legs = v,
CHEST => m.extra.chest = v,
HEAD => m.extra.head = v,
SADDLE => {
m.extra.saddled = true;
m.extra.saddle_stack = None;
return;
}
_ => return,
}
gear::set(m, gear_slot(slot), Vec::new());
}
/// `Mob.setDropChance`.
pub fn set_drop_chance(m: &mut Mob, slot: usize, chance: f32) {
let c = m
.extra
.drop_chances
.get_or_insert_with(|| Box::new([super::drops::DEFAULT_DROP_CHANCE; 8]));
c[slot] = chance;
}
/// The drop chance stored for a slot (`DropChances.byEquipment`).
pub fn stored_drop_chance(m: &Mob, slot: usize) -> f32 {
m.extra
.drop_chances
.as_ref()
.map_or(super::drops::DEFAULT_DROP_CHANCE, |c| c[slot])
}
impl<L: FinalizeLevel + ?Sized, R: RandomSource> Ctx<'_, L, R> {
fn float(&mut self) -> f32 {
self.random.next_float()
}
fn int(&mut self, bound: i32) -> i32 {
self.random.next_int_bound(bound).unwrap_or(0)
}
fn special(&self) -> f32 {
self.difficulty.special()
}
/// `UniformInt.sample`.
fn uniform(&mut self, min: i32, max: i32) -> i32 {
self.random
.next_int_between_inclusive(min, max)
.unwrap_or(min)
}
// ---- Mob ----------------------------------------------------------
/// `Mob.finalizeSpawn`: the follow range spawn bonus and left-handedness.
fn mob(&mut self, m: &mut Mob, g: Option<Group>) -> Option<Group> {
if !has_modifier(m, Attr::FollowRange, "minecraft:random_spawn_bonus") {
let bonus = self.random.triangle(0.0, 0.114_850_000_000_000_01);
add_modifier(
m,
Attr::FollowRange,
"minecraft:random_spawn_bonus",
bonus,
Op::AddMultipliedBase,
);
}
m.extra.left_handed = self.float() < 0.05;
g
}
/// `AgeableMob.finalizeSpawn`.
fn ageable(&mut self, m: &mut Mob, g: Option<Group>) -> Option<Group> {
let mut g = g.unwrap_or(Group::Ageable(Ageable::babies(true)));
if let Some(a) = g.ageable() {
let (should, size, chance) = (a.should_spawn_baby, a.size, a.baby_chance);
if should && size > 0 && self.float() <= chance {
let start = baby_start_age(m.species());
set_age(m, start);
}
if let Some(a) = g.ageable() {
a.size += 1;
}
}
self.mob(m, Some(g))
}
/// `Mob.populateDefaultEquipmentSlots`: a set of armour from the head
/// down, of one material.
fn armor(&mut self, m: &mut Mob) {
if self.float() >= 0.15 * self.special() {
return;
}
let mut kind = self.int(3);
for _ in 1..=3 {
if self.float() < 0.1087 {
kind += 1;
}
}
let partial = if self.difficulty.hard { 0.1 } else { 0.25 };
const MATERIAL: [&str; 6] = [
"leather",
"copper",
"golden",
"chainmail",
"iron",
"diamond",
];
let mut first = true;
// EQUIPMENT_POPULATION_ORDER: head, chest, legs, feet.
for (slot, piece) in [
(HEAD, "helmet"),
(CHEST, "chestplate"),
(LEGS, "leggings"),
(FEET, "boots"),
] {
if !first && self.float() < partial {
break;
}
first = false;
if item(m, slot).is_none()
&& let Some(material) = MATERIAL.get(kind as usize)
{
set_item(m, slot, &format!("minecraft:{material}_{piece}"));
}
}
}
/// `populateDefaultEquipmentSlots` of each class.
fn populate(&mut self, m: &mut Mob) {
use Species as S;
match m.species() {
S::Zombie | S::Husk | S::ZombieVillager => {
self.armor(m);
let chance = if self.difficulty.hard { 0.05 } else { 0.01 };
if self.float() < chance {
let weapon = match self.int(6) {
0 => "minecraft:iron_sword",
1 => "minecraft:iron_spear",
_ => "minecraft:iron_shovel",
};
set_item(m, MAINHAND, weapon);
}
}
S::Drowned => {
if f64::from(self.float()) > 0.9 {
let weapon = if self.int(16) < 10 {
"minecraft:trident"
} else {
"minecraft:fishing_rod"
};
set_item(m, MAINHAND, weapon);
}
}
S::ZombifiedPiglin => {
let weapon = if self.int(20) == 0 {
"minecraft:golden_spear"
} else {
"minecraft:golden_sword"
};
set_item(m, MAINHAND, weapon);
}
S::WitherSkeleton => set_item(m, MAINHAND, "minecraft:stone_sword"),
s if skeleton(s) => {
self.armor(m);
set_item(m, MAINHAND, "minecraft:bow");
}
S::Pillager => set_item(m, MAINHAND, "minecraft:crossbow"),
S::Vindicator => {
if super::raider::state(m).is_none_or(|s| s.raid_id.is_none()) {
set_item(m, MAINHAND, "minecraft:iron_axe");
}
}
S::Piglin => {
if !m.is_baby() {
for (slot, piece) in [
(HEAD, "helmet"),
(CHEST, "chestplate"),
(LEGS, "leggings"),
(FEET, "boots"),
] {
if self.float() < 0.1 {
set_item(m, slot, &format!("minecraft:golden_{piece}"));
}
}
}
}
S::PiglinBrute => set_item(m, MAINHAND, "minecraft:golden_axe"),
S::Vex => {
set_item(m, MAINHAND, "minecraft:iron_sword");
set_drop_chance(m, MAINHAND, 0.0);
}
S::Fox => {
if self.float() < 0.2 {
let odds = self.float();
let held = if odds < 0.05 {
"minecraft:emerald"
} else if odds < 0.2 {
"minecraft:egg"
} else if odds < 0.4 {
if self.random.next_boolean() {
"minecraft:rabbit_foot"
} else {
"minecraft:rabbit_hide"
}
} else if odds < 0.6 {
"minecraft:wheat"
} else if odds < 0.8 {
"minecraft:leather"
} else {
"minecraft:feather"
};
set_item(m, MAINHAND, held);
}
}
_ => self.armor(m),
}
}
/// `Mob.populateDefaultEquipmentEnchantments`: the weapon one time in
/// four and each piece of armour one time in two, scaled by the local
/// difficulty, through the `mob_spawn_equipment` provider.
fn enchant(&mut self, m: &mut Mob) {
if m.species() == Species::WitherSkeleton {
return;
}
self.enchant_slot(m, MAINHAND, 0.25);
// Pillager.enchantSpawnedWeapon: one crossbow in 300 pierces
// (`pillager_spawn_crossbow`).
if m.species() == Species::Pillager
&& self.int(300) == 0
&& item(m, MAINHAND).as_deref() == Some("minecraft:crossbow")
{
gear::upgrade(m, gear::MAIN, "minecraft:piercing", 1);
}
// EquipmentSlot.VALUES order: feet, legs, chest, head.
for slot in [FEET, LEGS, CHEST, HEAD] {
self.enchant_slot(m, slot, 0.5);
}
}
fn enchant_slot(&mut self, m: &mut Mob, slot: usize, chance: f32) {
let Some(id) = item(m, slot) else { return };
if self.float() >= chance * self.special() {
return;
}
self.enchant_by_cost(m, slot, &id);
}
/// `EnchantmentsByCostWithDifficulty.enchant` (`mob_spawn_equipment`:
/// cost 5 to 5 + 17 x the special multiplier, `#on_mob_spawn_equipment`).
fn enchant_by_cost(&mut self, m: &mut Mob, slot: usize, id: &str) {
let top = 5 + (self.special() * 17.0) as i32;
let cost = self.random.next_int_between_inclusive(5, top).unwrap_or(5);
let e = self.data.enchantments;
let pool = e.tag("minecraft:on_mob_spawn_equipment");
let picked = e.select(self.data.items, self.random, id, cost, pool);
for (enchantment, level) in picked {
gear::upgrade(m, gear_slot(slot), &enchantment, level);
}
}
fn halloween(&mut self, m: &mut Mob) {
if m.extra.head.is_none() && self.level.halloween() && self.float() < 0.25 {
let head = if self.float() < 0.1 {
"minecraft:jack_o_lantern"
} else {
"minecraft:carved_pumpkin"
};
set_item(m, HEAD, head);
set_drop_chance(m, HEAD, 0.0);
}
}
// ---- jockeys ------------------------------------------------------
fn create(&mut self, kind: &str, reason: Reason, at: &Mob) -> Option<Mob> {
let mut j = self.level.create(kind, reason)?;
// snapTo(x, y, z, yRot, 0).
j.position = at.position;
j.previous = at.position;
j.yaw = at.yaw;
j.previous_yaw = at.yaw;
j.body_yaw = at.yaw;
j.head_yaw = at.yaw;
j.head_pitch = 0.0;
Some(j)
}
/// `startRiding`: the rider leaves the vehicle it was on.
fn ride(&mut self, rider: &mut Mob, vehicle: &mut Mob) {
if let Some(old) = rider.extra.mount
&& let Some(v) = self.created.iter_mut().find(|c| c.id == old)
&& v.extra.rider == Some(rider.id)
{
v.extra.rider = None;
}
rider.extra.mount = Some(vehicle.id);
rider.extra.passenger = true;
if vehicle.extra.rider.is_none() {
vehicle.extra.rider = Some(rider.id);
}
}
// ---- the classes --------------------------------------------------
fn zombie(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
let mut g = self.mob(m, g);
let special = self.special();
if reason != Reason::Conversion {
m.extra.pick_up_loot = self.float() < 0.55 * special;
}
if g.is_none() {
g = Some(Group::Zombie {
baby: self.float() < 0.05,
jockey: true,
husk: None,
});
}
if let Some(Group::Zombie { baby, jockey, .. }) = g {
if baby {
set_baby(m, true);
if jockey {
if f64::from(self.float()) < 0.05 {
let search = m
.bounds()
.inflate(horizon_core::geometry::Vec3::new(5.0, 3.0, 5.0));
if let Some(chicken) = self.level.free_chicken(search) {
self.level.ride_chicken(chicken, m.id);
m.extra.mount = Some(chicken);
m.extra.passenger = true;
}
} else if f64::from(self.float()) < 0.05
&& let Some(mut chicken) =
self.create("minecraft:chicken", Reason::Jockey, m)
{
self.finalize(&mut chicken, Reason::Jockey, None);
chicken.extra.jockey = true;
self.ride(m, &mut chicken);
self.created.push(chicken);
}
}
}
m.extra.can_break_doors = self.float() < special * 0.1;
if reason != Reason::Conversion {
self.populate(m);
self.enchant(m);
}
}
self.halloween(m);
self.zombie_attributes(m, special, reason);
g
}
/// `Zombie.handleAttributes`, from the zombie's own random.
fn zombie_attributes(&mut self, m: &mut Mob, special: f32, reason: Reason) {
let r = &mut m.random;
let reinforcements = if m.kind.species == Species::ZombifiedPiglin {
0.0
} else {
r.next_double() * f64::from(0.1f32)
};
let knockback = r.next_double() * f64::from(0.05f32);
let follow = r.next_double() * 1.5 * f64::from(special);
let leader = r.next_float() < special * 0.05;
let leader_rolls =
leader.then(|| (r.next_double() * 0.25 + 0.5, r.next_double() * 3.0 + 1.0));
set_base(m, Attr::SpawnReinforcements, reinforcements);
add_modifier(
m,
Attr::KnockbackResistance,
"minecraft:random_spawn_bonus",
knockback,
Op::AddValue,
);
if follow > 1.0 {
add_modifier(
m,
Attr::FollowRange,
"minecraft:zombie_random_spawn_bonus",
follow,
Op::AddMultipliedTotal,
);
}
if let Some((reinforce, health)) = leader_rolls {
add_modifier(
m,
Attr::SpawnReinforcements,
"minecraft:leader_zombie_bonus",
reinforce,
Op::AddValue,
);
add_modifier(
m,
Attr::MaxHealth,
"minecraft:leader_zombie_bonus",
health,
Op::AddMultipliedTotal,
);
if !matches!(
reason,
Reason::Conversion | Reason::Load | Reason::DimensionTravel
) {
m.health = max_health(m);
}
m.extra.can_break_doors = true;
}
}
fn husk(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
let mut g = self.zombie(m, g, reason);
if reason != Reason::Conversion {
m.extra.pick_up_loot = self.float() < 0.55 * self.special();
}
if let Some(Group::Zombie { baby, jockey, .. }) = g {
g = Some(Group::Zombie {
baby,
jockey,
husk: Some(reason != Reason::Natural),
});
}
if let Some(Group::Zombie {
husk: Some(tried @ false),
..
}) = &mut g
{
let (bx, by, bz) = (
m.position.x.floor(),
m.position.y.floor(),
m.position.z.floor(),
);
let (w, h) = self.data.camel_husk_size;
let half = w / 2.0;
let bounds = Aabb::new(
horizon_core::geometry::Vec3::new(
bx + 0.5 - f64::from(half),
by,
bz + 0.5 - f64::from(half),
),
horizon_core::geometry::Vec3::new(
bx + 0.5 + f64::from(half),
by + f64::from(h),
bz + 0.5 + f64::from(half),
),
);
if self.level.no_collision(bounds) {
*tried = true;
if self.float() < 0.1 {
set_item(m, MAINHAND, "minecraft:iron_spear");
if let Some(mut camel) =
self.level.create("minecraft:camel_husk", Reason::Natural)
{
// setPos: the husk's position, the camel's own rotation.
camel.position = m.position;
camel.previous = m.position;
self.finalize(&mut camel, reason, None);
self.ride(m, &mut camel);
if let Some(mut parched) =
self.create("minecraft:parched", Reason::Natural, m)
{
self.finalize(&mut parched, reason, None);
self.ride(&mut parched, &mut camel);
self.created.push(camel);
self.created.push(parched);
} else {
self.created.push(camel);
}
}
}
}
}
g
}
fn drowned(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
let g = self.zombie(m, g, reason);
if m.extra.off_hand.is_none() && self.float() < 0.03 {
set_item(m, OFFHAND, "minecraft:nautilus_shell");
set_drop_chance(m, OFFHAND, 2.0);
}
let at = [
m.position.x.floor() as i32,
m.position.y.floor() as i32,
m.position.z.floor() as i32,
];
if matches!(reason, Reason::Natural | Reason::Structure)
&& m.extra.main_hand.as_deref() == Some("minecraft:trident")
&& self.float() < 0.5
&& !m.is_baby()
&& !self
.level
.biome_tag("minecraft:more_frequent_drowned_spawns", at)
&& let Some(mut nautilus) = self.create("minecraft:zombie_nautilus", Reason::Jockey, m)
{
if reason == Reason::Structure {
nautilus.persistent = true;
}
self.finalize(&mut nautilus, reason, None);
self.ride(m, &mut nautilus);
self.created.push(nautilus);
}
g
}
fn skeleton(&mut self, m: &mut Mob, g: Option<Group>) -> Option<Group> {
let g = self.mob(m, g);
self.populate(m);
self.enchant(m);
m.extra.pick_up_loot = self.float() < 0.55 * self.special();
self.halloween(m);
if m.species() == Species::WitherSkeleton {
set_base(m, Attr::AttackDamage, 4.0);
}
g
}
fn spider(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
let mut g = self.mob(m, g);
if self.int(100) == 0
&& let Some(mut skeleton) = self.create("minecraft:skeleton", Reason::Jockey, m)
{
self.finalize(&mut skeleton, reason, None);
self.ride(&mut skeleton, m);
self.created.push(skeleton);
}
if g.is_none() {
let mut effect = None;
if self.difficulty.hard && self.float() < 0.1 * self.special() {
effect = Some(match self.int(5) {
0 | 1 => "minecraft:speed",
2 => "minecraft:strength",
3 => "minecraft:regeneration",
_ => "minecraft:invisibility",
});
}
g = Some(Group::Spider(effect));
}
if let Some(Group::Spider(Some(effect))) = g {
m.add_effect(effect, -1, 0);
}
g
}
/// `Raider` then `PatrollingMonster.finalizeSpawn`.
fn raider(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
let witch = m.species() == Species::Witch;
super::raider::state_mut(m).can_join_raid = !witch || reason != Reason::Natural;
if !matches!(reason, Reason::Patrol | Reason::Event | Reason::Structure)
&& self.float() < 0.06
&& super::raider::can_be_leader(m.species())
{
super::raider::state_mut(m).patrol_leader = true;
}
if super::raider::state(m).is_some_and(|s| s.patrol_leader) {
set_item(m, HEAD, super::raider::BANNER);
set_drop_chance(m, HEAD, 2.0);
}
if reason == Reason::Patrol {
super::raider::state_mut(m).patrolling = true;
}
self.mob(m, g)
}
fn piglin(&mut self, m: &mut Mob, g: Option<Group>, reason: Reason) -> Option<Group> {
if reason != Reason::Structure {
if self.float() < 0.2 {
set_baby(m, true);
} else if !m.is_baby() {
// createSpawnWeapon, from the piglin's own random.
let r = &mut m.random;
let weapon = if f64::from(r.next_float()) < 0.5 {
"minecraft:crossbow"
} else if r.next_int_bound(10).unwrap_or(1) == 0 {
"minecraft:golden_spear"
} else {
"minecraft:golden_sword"
};
set_item(m, MAINHAND, weapon);
}
}
// PiglinAi.initMemories: HUNTED_RECENTLY for 30 to 120 seconds.
let hunt = self.uniform(600, 2400);
set_memory(m, "hunted_recently", 1, i64::from(hunt));
self.populate(m);
self.enchant(m);
self.mob(m, g)
}
fn strider(&mut self, m: &mut Mob, g: Option<Group>) -> Option<Group> {
if m.is_baby() {
return self.ageable(m, g);
}
let mut g = g;
if self.int(30) == 0 && self.level.spawning_monsters() {
if let Some(mut jockey) = self.create("minecraft:zombified_piglin", Reason::Jockey, m) {
let baby = self.float() < 0.05;
g = Some(self.strider_jockey(
m,
&mut jockey,
Some(Group::Zombie {
baby,
jockey: false,
husk: None,
}),
));
set_item(&mut jockey, MAINHAND, "minecraft:warped_fungus_on_a_stick");
set_item(m, SADDLE, "minecraft:saddle");
set_drop_chance(m, SADDLE, 2.0);
self.created.push(jockey);
}
} else if self.int(10) == 0 {
if let Some(mut jockey) = self.create("minecraft:strider", Reason::Jockey, m) {
set_age(&mut jockey, -24000);
g = Some(self.strider_jockey(m, &mut jockey, None));
self.created.push(jockey);
}
} else {
g = Some(Group::Ageable(Ageable::chance(0.5)));
}
self.ageable(m, g)
}
/// `Strider.spawnJockey`.
fn strider_jockey(&mut self, m: &mut Mob, jockey: &mut Mob, g: Option<Group>) -> Group {
jockey.position = m.position;
jockey.yaw = m.yaw;
self.finalize(jockey, Reason::Jockey, g);
self.ride(jockey, m);
Group::Ageable(Ageable::chance(0.0))
}
/// `AbstractHorse.finalizeSpawn` with each `randomizeAttributes`.
fn horse(&mut self, m: &mut Mob, g: Option<Group>) -> Option<Group> {
let g = g.or(Some(Group::Ageable(Ageable::chance(0.2))));
use Species as S;
match m.species() {
S::Horse => {
let health = self.horse_health();
set_base(m, Attr::MaxHealth, f64::from(health));
let speed = self.horse_speed();
set_base(m, Attr::MovementSpeed, speed);
let jump = self.horse_jump();
set_base(m, Attr::JumpStrength, jump);
}
S::Donkey | S::Mule | S::Llama | S::TraderLlama => {
let health = self.horse_health();
set_base(m, Attr::MaxHealth, f64::from(health));
}
S::SkeletonHorse => {
let jump = self.horse_jump();
set_base(m, Attr::JumpStrength, jump);
}
S::ZombieHorse => {
let d = 0.066_666_666_666_666_67;
let jump = 0.5
+ self.random.next_double() * d
+ self.random.next_double() * d
+ self.random.next_double() * d;
set_base(m, Attr::JumpStrength, jump);
let speed = (9.0
+ self.random.next_double()
+ self.random.next_double()
+ self.random.next_double())
/ f64::from(42.16f32);
set_base(m, Attr::MovementSpeed, speed);
}
_ => {}
}
self.ageable(m, g)
}
fn horse_health(&mut self) -> f32 {
15.0 + self.int(8) as f32 + self.int(9) as f32
}
fn horse_speed(&mut self) -> f64 {
(f64::from(0.45f32)
+ self.random.next_double() * 0.3
+ self.random.next_double() * 0.3
+ self.random.next_double() * 0.3)
* 0.25
}
fn horse_jump(&mut self) -> f64 {
f64::from(0.4f32)
+ self.random.next_double() * 0.2
+ self.random.next_double() * 0.2
+ self.random.next_double() * 0.2
}
fn villager_type(&mut self, m: &mut Mob) {
let at = block(m);
m.extra.variant = villager_type(&self.level.biome(at));
}
/// `VariantUtils.selectVariantToSpawn` into `variant`, by registry name.
fn variant(&mut self, m: &mut Mob, registry: fn(&SpawnRegistries) -> &VariantRegistry) {
let r = registry(self.data.registries);
let at = block(m);
if let Some(i) = r.select(&*self.level, at, self.random) {
let name = r.names[i].clone();
m.extra.variant = variant_index(m.species(), &name);
}
}
fn sound(&mut self, m: &mut Mob, registry: fn(&SpawnRegistries) -> &VariantRegistry) {
let r = registry(self.data.registries);
m.extra.sound_variant = r.random(self.random) as u8;
}
/// `finalizeSpawn` of the mob's class.
pub fn finalize(&mut self, m: &mut Mob, reason: Reason, g: Option<Group>) -> Option<Group> {
use Species as S;
let s = m.species();
match s {
S::Pig | S::Cow | S::Chicken => {
let (v, sound): (
fn(&SpawnRegistries) -> &VariantRegistry,
fn(&SpawnRegistries) -> &VariantRegistry,
) = match s {
S::Pig => (|r| &r.pig, |r| &r.pig_sound),
S::Cow => (|r| &r.cow, |r| &r.cow_sound),
_ => (|r| &r.chicken, |r| &r.chicken_sound),
};
self.variant(m, v);
self.sound(m, sound);
self.ageable(m, g)
}
S::Cat => {
let g = self.ageable(m, g);
self.variant(m, |r| &r.cat);
self.sound(m, |r| &r.cat_sound);
g
}
S::Wolf => {
let g = match g {
Some(Group::Wolf(a, v)) => {
m.extra.variant = v;
Some(Group::Wolf(a, v))
}
other => {
let r = &self.data.registries.wolf;
let at = block(m);
match r.select(&*self.level, at, self.random) {
Some(i) => {
let v = variant_index(s, &r.names[i]);
m.extra.variant = v;
Some(Group::Wolf(Ageable::babies(false), v))
}
None => other,
}
}
};
self.sound(m, |r| &r.wolf_sound);
self.ageable(m, g)
}
S::Frog => {
self.variant(m, |r| &r.frog);
let jump = self.uniform(100, 140);
set_memory(m, "long_jump_cooldown", i64::from(jump), i64::MAX);
self.ageable(m, g)
}
S::ZombieNautilus => {
self.variant(m, |r| &r.zombie_nautilus);
let cooldown = self.uniform(2400, 3600);
set_memory(m, "attack_target_cooldown", i64::from(cooldown), i64::MAX);
m.extra.counter = cooldown;
self.ageable(m, g)
}
S::Nautilus => {
let cooldown = self.uniform(2400, 3600);
set_memory(m, "attack_target_cooldown", i64::from(cooldown), i64::MAX);
m.extra.counter = cooldown;
self.ageable(m, g)
}
S::Sheep => {
let climate = if self
.level
.biome_tag("minecraft:spawns_warm_variant_farm_animals", block(m))
{
Climate::Warm
} else if self
.level
.biome_tag("minecraft:spawns_cold_variant_farm_animals", block(m))
{
Climate::Cold
} else {
Climate::Temperate
};
m.extra.color = super::farm::sheep_color(climate, self.random);
self.ageable(m, g)
}
S::Rabbit => {
let at = block(m);
let roll = self.int(100);
let mut variant = if self.level.biome_tag("minecraft:spawns_white_rabbits", at) {
if roll < 80 { 1 } else { 3 }
} else if self.level.biome_tag("minecraft:spawns_gold_rabbits", at) {
4
} else if roll < 50 {
0
} else if roll < 90 {
5
} else {
2
};
let g = match g {
Some(Group::Rabbit(a, v)) => {
variant = v;
Group::Rabbit(a, v)
}
_ => Group::Rabbit(Ageable::chance(1.0), variant),
};
m.extra.variant = variant;
self.ageable(m, Some(g))
}
S::Horse => {
let (g, variant) = match g {
Some(Group::Horse(a, v)) => (Group::Horse(a, v), v),
_ => {
let v = self.int(7) as u8;
(Group::Horse(Ageable::babies(true), v), v)
}
};
let markings = self.int(5) as u8;
m.extra.variant = variant;
m.extra.variant2 = markings;
self.horse(m, Some(g))
}
S::Llama | S::TraderLlama => {
let mut g = g;
if s == S::TraderLlama {
if reason == Reason::Event {
set_age(m, 0);
}
if g.is_none() {
g = Some(Group::Ageable(Ageable::babies(false)));
}
}
let max = if self.float() < 0.04 { 5 } else { 3 };
m.extra.variant2 = (1 + self.int(max)) as u8;
let g = match g {
Some(Group::Llama(a, v)) => {
m.extra.variant = v;
Group::Llama(a, v)
}
_ => {
let v = self.int(4) as u8;
m.extra.variant = v;
Group::Llama(Ageable::babies(true), v)
}
};
self.horse(m, Some(g))
}
S::Donkey | S::Mule | S::SkeletonHorse => self.horse(m, g),
S::ZombieHorse => {
if reason == Reason::Natural
&& let Some(mut zombie) = self.create("minecraft:zombie", Reason::Jockey, m)
{
self.finalize(&mut zombie, reason, None);
set_item(&mut zombie, MAINHAND, "minecraft:iron_spear");
self.ride(&mut zombie, m);
self.created.push(zombie);
}
self.horse(m, g)
}
S::Camel | S::CamelHusk => {
let now = self.level.game_time();
m.extra.pose_change_tick = (now - 52 - 1).max(0);
super::camel::stand_up_instantly(m);
self.horse(m, g)
}
S::Goat => {
let jump = self.uniform(600, 1200);
set_memory(m, "long_jump_cooldown", i64::from(jump), i64::MAX);
let ram = self.uniform(600, 6000);
set_memory(m, "ram_cooldown", i64::from(ram), i64::MAX);
m.extra.screaming = self.random.next_double() < 0.02;
age_boundary_reached(m);
if !m.is_baby() && self.float() < 0.1 {
let left = self.random.next_boolean();
m.extra.lost_horns[usize::from(!left)] = true;
}
self.ageable(m, g)
}
S::Panda => {
let main = panda_gene(self.int(16));
let hidden = panda_gene(self.int(16));
m.extra.variant = main;
m.extra.variant2 = hidden;
let shown = panda_variant(main, hidden);
if shown == 5 {
set_base(m, Attr::MaxHealth, 10.0);
}
if shown == 1 {
set_base(m, Attr::MovementSpeed, f64::from(0.07f32));
}
self.ageable(m, g.or(Some(Group::Ageable(Ageable::chance(0.2)))))
}
S::PolarBear | S::Ocelot => {
self.ageable(m, g.or(Some(Group::Ageable(Ageable::chance(1.0)))))
}
S::Fox => {
let at = block(m);
let mut variant = u8::from(self.level.biome_tag("minecraft:spawns_snow_foxes", at));
let mut baby = false;
let g = match g {
Some(Group::Fox(a, v)) => {
variant = v;
baby = a.size >= 2;
Group::Fox(a, v)
}
_ => Group::Fox(Ageable::babies(false), variant),
};
m.extra.variant = variant;
if baby {
set_age(m, -24000);
}
self.populate(m);
self.ageable(m, Some(g))
}
S::Parrot => {
m.extra.variant = self.int(5) as u8;
self.ageable(m, g.or(Some(Group::Ageable(Ageable::babies(false)))))
}
S::Axolotl => {
if reason == Reason::Bucket {
return g;
}
let mut baby = false;
let g = match g {
Some(Group::Axolotl(a, types)) => {
baby = a.size >= 2;
Group::Axolotl(a, types)
}
_ => {
let a = self.int(4) as u8;
let b = self.int(4) as u8;
Group::Axolotl(Ageable::babies(false), [a, b])
}
};
if let Group::Axolotl(_, types) = g {
m.extra.variant = types[self.int(2) as usize];
}
if baby {
set_age(m, -24000);
}
self.ageable(m, Some(g))
}
S::Squid | S::GlowSquid => {
self.ageable(m, g.or(Some(Group::Ageable(Ageable::chance(0.05)))))
}
S::Dolphin => {
m.air = 4800;
m.head_pitch = 0.0;
self.ageable(m, g.or(Some(Group::Ageable(Ageable::chance(0.1)))))
}
S::Turtle => {
m.extra.home = Some(block(m));
self.ageable(m, g)
}
S::Villager | S::WanderingTrader => {
if s == S::Villager {
if reason == Reason::Breeding {
m.extra.variant2 = 0;
}
self.villager_type(m);
}
self.ageable(m, g.or(Some(Group::Ageable(Ageable::babies(false)))))
}
S::Hoglin => {
if self.float() < 0.2 {
set_baby(m, true);
}
self.ageable(m, g)
}
S::Zoglin => {
if self.float() < 0.2 {
set_baby(m, true);
}
self.mob(m, g)
}
S::Strider => self.strider(m, g),
S::Slime | S::MagmaCube | S::SulfurCube => {
let g = if s == S::SulfurCube {
g
} else {
g.or(Some(Group::Ageable(Ageable::babies(false))))
};
let g = self.ageable(m, g);
if s == S::SulfurCube {
let size = if m.is_baby() { 1 } else { 2 };
sulfur_size(m, size);
} else {
let mut scale = self.int(3);
if scale < 2 && self.float() < 0.5 * self.special() {
scale += 1;
}
cube_size(m, 1 << scale);
}
g
}
S::Cod | S::Salmon | S::TropicalFish => {
if s == S::Salmon {
// A weighted list (small 30, medium 50, large 15) on the
// salmon's own random.
let r = m.random.next_int_bound(95).unwrap_or(0);
m.extra.variant = if r < 30 {
0
} else if r < 80 {
1
} else {
2
};
}
let given = g;
self.mob(m, None);
let g = match given {
None => Group::School(m.id, None),
Some(Group::School(leader, v)) => {
m.extra.leader = Some(leader);
Group::School(leader, v)
}
Some(other) => other,
};
if s != S::TropicalFish {
return Some(g);
}
let (g, (p, b, c)) = match g {
Group::School(leader, Some(v)) => (Group::School(leader, Some(v)), v),
other => {
if f64::from(self.float()) < 0.9 {
let v = super::aquatic::COMMON_TROPICAL[self.int(22) as usize];
(Group::School(m.id, Some(v)), v)
} else {
m.extra.lone = true;
let p = self.int(12) as u8;
let b = self.int(16) as u8;
let c = self.int(16) as u8;
(other, (p, b, c))
}
}
};
m.extra.variant = p;
m.extra.variant2 = b;
m.extra.variant3 = c;
Some(g)
}
S::Zombie | S::ZombifiedPiglin => self.zombie(m, g, reason),
S::ZombieVillager => {
self.villager_type(m);
// ZombieVillager's constructor picks the profession from the
// fresh entity's random, before anything seeds it: an
// independent draw that leaves the mob's own random alone.
let mut fresh = LegacyRandom::new(
(m.random.state() as i64).wrapping_mul(0x5851_F42D_4C95_7F2D) ^ i64::from(m.id),
);
m.extra.variant2 = fresh.next_int_bound(15).unwrap_or(0) as u8;
self.zombie(m, g, reason)
}
S::Husk => self.husk(m, g, reason),
S::Drowned => self.drowned(m, g, reason),
s if skeleton(s) => self.skeleton(m, g),
S::Spider => self.spider(m, g, reason),
// CaveSpider.finalizeSpawn returns at once.
S::CaveSpider => g,
S::Pillager => {
self.populate(m);
self.enchant(m);
self.raider(m, g, reason)
}
S::Vindicator => {
let g = self.raider(m, g, reason);
self.populate(m);
self.enchant(m);
g
}
S::Illusioner => {
set_item(m, MAINHAND, "minecraft:bow");
self.raider(m, g, reason)
}
s if raider(s) => self.raider(m, g, reason),
S::Piglin => self.piglin(m, g, reason),
S::PiglinBrute => {
let home = block(m);
m.extra.home = Some(home);
set_memory(m, "home", 0, i64::MAX);
self.populate(m);
self.mob(m, g)
}
S::Vex => {
self.populate(m);
self.enchant(m);
self.mob(m, g)
}
S::Warden => {
super::warden::finalize(m, reason == Reason::Triggered, &mut Vec::new());
set_memory(m, "dig_cooldown", 0, 1200);
if reason == Reason::Triggered {
set_memory(m, "is_emerging", 0, super::warden::EMERGE_DURATION);
}
self.mob(m, g)
}
S::Phantom => {
let at = block(m);
m.extra.home = Some([at[0], at[1] + 5, at[2]]);
m.extra.size = 0;
self.mob(m, g)
}
S::Shulker => {
m.yaw = 0.0;
m.head_yaw = 0.0;
m.previous_yaw = 0.0;
m.previous_head_yaw = 0.0;
self.mob(m, g)
}
_ if ageable(s) => self.ageable(m, g),
_ => self.mob(m, g),
}
}
}
/// `Mob.finalizeSpawn` of a fresh mob. Returns the group data for the next
/// mob of the pack.
pub fn finalize<L: FinalizeLevel + ?Sized, R: RandomSource>(
cx: &mut Ctx<'_, L, R>,
m: &mut Mob,
reason: Reason,
g: Option<Group>,
) -> Option<Group> {
cx.finalize(m, reason, g)
}
fn block(m: &Mob) -> [i32; 3] {
[
m.position.x.floor() as i32,
m.position.y.floor() as i32,
m.position.z.floor() as i32,
]
}
/// A brain memory finalizeSpawn sets: value and ticks until it expires.
fn set_memory(m: &mut Mob, name: &'static str, value: i64, ttl: i64) {
match m.extra.memories.iter_mut().find(|x| x.0 == name) {
Some(x) => *x = (name, value, ttl),
None => m.extra.memories.push((name, value, ttl)),
}
}
/// `Panda.Gene.getRandom` (enum order: normal, lazy, worried, playful,
/// brown, weak, aggressive).
fn panda_gene(roll: i32) -> u8 {
match roll {
0 => 1,
1 => 2,
2 => 3,
4 => 6,
r if r < 9 => 5,
r if r < 11 => 4,
_ => 0,
}
}
/// `Panda.Gene.getVariantFromGenes`: a recessive gene shows when both match.
pub fn panda_variant(main: u8, hidden: u8) -> u8 {
let recessive = matches!(main, 4 | 5);
if recessive && main != hidden { 0 } else { main }
}
/// `AbstractCubeMob.setSize(size, true)` for slimes and magma cubes.
/// `SulfurCube.setSize(size, true)`, with the attribute bases it sets.
fn sulfur_size(m: &mut Mob, size: i32) {
super::sulfur_cube::set_size(m, size, true);
let size = m.extra.size;
set_base(m, Attr::MaxHealth, f64::from(4 * size));
set_base(
m,
Attr::MovementSpeed,
f64::from(0.2f32 + 0.1f32 * size as f32),
);
m.health = max_health(m);
}
fn cube_size(m: &mut Mob, size: i32) {
super::cube::set_size(m, size);
}
/// The index the game keeps for a variant registry entry.
pub fn variant_index(s: Species, name: &str) -> u8 {
let name = name.strip_prefix("minecraft:").unwrap_or(name);
let i = match s {
Species::Cat => super::tame::CAT_VARIANTS.iter().position(|v| *v == name),
Species::Wolf => super::tame::WOLF_VARIANTS.iter().position(|v| v.0 == name),
Species::ZombieNautilus => super::nautilus::VARIANTS.iter().position(|v| *v == name),
_ => ["temperate", "warm", "cold"]
.iter()
.position(|v| *v == name),
};
i.unwrap_or(0) as u8
}
/// The variant data component a mob reports (`Entity.get`, e.g.
/// `Wolf.get(DataComponents.WOLF_VARIANT)`): component id and registry entry.
pub fn variant_component(m: &Mob) -> Option<(&'static str, String)> {
species_variant_component(m.species(), m.extra.variant)
}
/// [`variant_component`] of a species with the game's variant index.
pub fn species_variant_component(s: Species, variant: u8) -> Option<(&'static str, String)> {
let component = match s {
Species::Wolf => "minecraft:wolf/variant",
Species::Cat => "minecraft:cat/variant",
Species::Frog => "minecraft:frog/variant",
Species::Pig => "minecraft:pig/variant",
Species::Cow => "minecraft:cow/variant",
Species::Chicken => "minecraft:chicken/variant",
Species::ZombieNautilus => "minecraft:zombie_nautilus/variant",
_ => return None,
};
Some((component, format!("minecraft:{}", variant_name(s, variant))))
}
/// The registry name of the game's variant index.
pub fn variant_name(s: Species, index: u8) -> &'static str {
let i = index as usize;
match s {
Species::Cat => super::tame::CAT_VARIANTS.get(i).copied().unwrap_or("tabby"),
Species::Wolf => super::tame::WOLF_VARIANTS.get(i).map_or("pale", |v| v.0),
Species::ZombieNautilus => super::nautilus::VARIANTS
.get(i)
.copied()
.unwrap_or("temperate"),
_ => ["temperate", "warm", "cold"]
.get(i)
.copied()
.unwrap_or("temperate"),
}
}
/// `VillagerType.byBiome` (index into `render::VILLAGER_TYPES`: plains,
/// desert, jungle, savanna, snow, swamp, taiga).
pub fn villager_type(biome: &str) -> u8 {
match biome.strip_prefix("minecraft:").unwrap_or(biome) {
"badlands" | "desert" | "eroded_badlands" | "wooded_badlands" => 1,
"bamboo_jungle" | "jungle" | "sparse_jungle" => 2,
"savanna_plateau" | "savanna" | "windswept_savanna" => 3,
"deep_frozen_ocean" | "frozen_ocean" | "frozen_river" | "ice_spikes" | "snowy_beach"
| "snowy_taiga" | "snowy_plains" | "grove" | "snowy_slopes" | "frozen_peaks"
| "jagged_peaks" => 4,
"swamp" | "mangrove_swamp" => 5,
"old_growth_spruce_taiga"
| "old_growth_pine_taiga"
| "windswept_gravelly_hills"
| "windswept_hills"
| "taiga"
| "windswept_forest" => 6,
_ => 0,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn panda_genes_follow_the_vanilla_table() {
assert_eq!(panda_gene(0), 1);
assert_eq!(panda_gene(3), 5);
assert_eq!(panda_gene(4), 6);
assert_eq!(panda_gene(9), 4);
assert_eq!(panda_gene(15), 0);
assert_eq!(panda_variant(4, 0), 0);
assert_eq!(panda_variant(4, 4), 4);
assert_eq!(panda_variant(6, 0), 6);
}
#[test]
fn reasons_round_trip() {
for r in Reason::ALL {
assert_eq!(Reason::parse(r.name()), Some(r));
}
}
#[test]
fn villager_types_by_biome() {
assert_eq!(villager_type("minecraft:badlands"), 1);
assert_eq!(villager_type("minecraft:grove"), 4);
assert_eq!(villager_type("minecraft:plains"), 0);
}
}