diff --git a/crates/horizon-client/examples/mob_ai_probe.rs b/crates/horizon-client/examples/mob_ai_probe.rs index b5bfc213b..5762abcd6 100644 --- a/crates/horizon-client/examples/mob_ai_probe.rs +++ b/crates/horizon-client/examples/mob_ai_probe.rs @@ -5,6 +5,7 @@ //! usage: mob_ai_probe RESOURCES SCENARIOS OUTPUT use horizon_client::{ assets::Assets, + beehive::HiveHost, biome::Biomes, blocks::BlockFacts, chunk::{Chunk, HEIGHT, MIN_Y}, @@ -27,7 +28,13 @@ use horizon_core::{ random::LegacyRandom, }; use horizon_world::{chunk::BlockState, registry::BlockRegistry, registry::BlockStateId}; -use std::{collections::BTreeMap, fmt::Write as _, fs, path::Path, sync::Arc}; +use std::{ + collections::{BTreeMap, HashMap}, + fmt::Write as _, + fs, + path::Path, + sync::Arc, +}; struct MobSpec { kind: String, @@ -54,6 +61,8 @@ struct Scenario { hearts: Vec>, /// `ServerLevel.isSpawningMonsters`. spawning: bool, + /// The day time moves on with every tick. + daycycle: bool, /// The player hits a mob for 1 at the start of a tick: (tick, mob index). hurts: Vec<(i32, usize)>, /// The player feeds an animal at the start of a tick (Animal.mobInteract): @@ -85,6 +94,7 @@ fn parse(text: &str) -> Vec { "thunder" => s.thunder = true, "levelseed" => {} "spawning" => s.spawning = true, + "daycycle" => s.daycycle = true, _ => panic!("unknown scenario option {kv}"), } } @@ -407,6 +417,65 @@ impl HeartHost for Host<'_> { self.spawning } } +/// A scenario's beehives as `BeehiveBlockEntity.serverTick` sees the level: +/// the bees let out are newcomers seeded as the oracle seeds them. +struct ProbeHive<'a, 'w> { + w: &'a MobWorld<'w>, + random: &'a mut LegacyRandom, + types: &'a HashMap>, + /// The index of the first newcomer of this tick. + first: usize, + added: &'a mut Vec, + honey: &'a mut Vec<([i32; 3], i32)>, + events: &'a mut Vec, +} +impl HiveHost for ProbeHive<'_, '_> { + fn random(&mut self) -> &mut LegacyRandom { + self.random + } + fn bees_stay_in_hive(&self, _at: [i32; 3]) -> bool { + horizon_client::mobs::bee::bees_stay_in_hive(self.w) + } + fn blocked(&self, at: [i32; 3]) -> bool { + !self.w.block_collision_boxes(at[0], at[1], at[2]).is_empty() + } + fn set_honey_level(&mut self, at: [i32; 3], level: i32) { + self.honey.push((at, level)); + } + fn load(&mut self, tag: &horizon_world::nbt::Tag) -> Option { + let index = self.first + self.added.len(); + let mut m = + horizon_client::entity_nbt::mob_from_nbt(tag, self.types, 100_000 + index as u32)?; + if m.species() != Species::Bee { + return None; + } + m.random = LegacyRandom::new(spawn_seed(index)); + horizon_client::mobs::bee::draw_cooldowns(&mut m); + Some(m) + } + fn add(&mut self, m: Mob) -> bool { + self.added.push(m); + true + } + fn sound(&mut self, name: &'static str, at: [f64; 3]) { + self.events.push(MobEvent::Sound(name, at, 1.0, 1.0)); + } +} +/// The hive's honey level and front from its block state. +fn hive_state(registry: &BlockRegistry, world: &World, at: [i32; 3]) -> (Option, [i32; 2]) { + let props = registry + .state(world.block(at[0], at[1], at[2])) + .map(|s| s.properties.clone()) + .unwrap_or_default(); + let honey = props.get("honey_level").and_then(|v| v.parse().ok()); + let facing = horizon_client::beehive::facing_step(props.get("facing").map(String::as_str)); + (honey, facing) +} +fn is_hive(b: &[String]) -> bool { + b[0] == "block" + && (b[4].starts_with("minecraft:beehive") || b[4].starts_with("minecraft:bee_nest")) +} + /// The heart's state, block entity and the level random, as the oracle /// prints them. fn print_heart( @@ -702,6 +771,12 @@ fn main() -> horizon_client::Result<()> { let motion = horizon_client::motion::MotionResources::load(root, &assets)?; let data = MobData::load(root, &facts); let types = MobTypes::load(root)?; + // The types a bee leaving its hive is loaded with (EntityType.loadEntityRecursive). + let arc_types: HashMap> = types + .types + .iter() + .map(|(k, v)| (k.clone(), Arc::new(v.clone()))) + .collect(); let biomes = Biomes::load(root)?; let items = Items::load(root, registry, &facts)?; let tables = LightTables::load(root, registry, &facts)?; @@ -744,6 +819,11 @@ fn main() -> horizon_client::Result<()> { let n = |i: usize| b[i].parse::().unwrap(); if b[0] == "block" || b[0] == "chest" { world.set(n(1), n(2), n(3), state(registry, &b[4]))?; + if is_hive(b) { + world + .block_entities + .insert((n(1), n(2), n(3)), BlockEntity::Beehive(Box::default())); + } if b[0] == "chest" { // chest X Y Z STATE SLOTS: item*count or - per slot. let mut slots = vec![None; 27]; @@ -830,6 +910,7 @@ fn main() -> horizon_client::Result<()> { &mut Vec::new(), ), "inlove" => m.extra.in_love = 600, + "nectar" => horizon_client::mobs::bee::set_has_nectar(&mut m, true), "tame" => m.extra.tame = true, x if x.starts_with("age=") => m.extra.age = x[4..].parse().unwrap(), x if x.starts_with("strength=") => m.extra.variant2 = x[9..].parse().unwrap(), @@ -936,7 +1017,7 @@ fn main() -> horizon_client::Result<()> { data: &data, player: player.clone(), others: $snapshot, - daylight: (s.time.rem_euclid(24000)) < 12000, + daylight: (world.day_time.rem_euclid(24000)) < 12000, game_time: world.game_time, day_time: world.day_time, raining: s.rain, @@ -956,6 +1037,9 @@ fn main() -> horizon_client::Result<()> { } for t in 1..=s.ticks { world.game_time += 1; + if s.daycycle { + world.day_time = s.time + i64::from(t); + } let mut heart_events_later: Vec = Vec::new(); // Creaking.tick reads the heart's block entity. for (at, h) in &hearts { @@ -1121,6 +1205,41 @@ fn main() -> horizon_client::Result<()> { _ => {} } } + // BeeEnterHiveGoal.start: BeehiveBlockEntity.addOccupant. + let entering: Vec<[i32; 3]> = events[from.min(events.len())..] + .iter() + .filter_map(|e| match e { + MobEvent::EnterHive { hive, .. } => Some(*hive), + _ => None, + }) + .collect(); + for at in entering { + let key = (at[0], at[1], at[2]); + let Some(BlockEntity::Beehive(mut hive)) = world.block_entities.remove(&key) + else { + continue; + }; + let tag = horizon_client::entity_nbt::mob_to_nbt(&mobs[i], [0; 4], None); + let flower = horizon_client::mobs::bee::get(&mobs[i]).and_then(|b| b.flower); + let mut honey = Vec::new(); + let stored = { + let w = mob_world!(&snapshot); + let mut host = ProbeHive { + w: &w, + random: &mut scratch, + types: &arc_types, + first: 0, + added: &mut Vec::new(), + honey: &mut honey, + events: &mut events, + }; + hive.add_occupant(at, tag, flower, &mut host) + }; + world.block_entities.insert(key, BlockEntity::Beehive(hive)); + if stored { + mobs[i].removed = true; + } + } // ServerLevel ticks entities one after another: the ones // after this mob see it as it is now. if let Some(e) = snapshot.iter_mut().find(|e| e.id == mobs[i].id) { @@ -1153,6 +1272,43 @@ fn main() -> horizon_client::Result<()> { added.append(&mut host.added); } drop(w); + // Then the hives (BeehiveBlockEntity.serverTick). + let mut hive_keys: Vec<(i32, i32, i32)> = world + .block_entities + .iter() + .filter(|(_, e)| matches!(e, BlockEntity::Beehive(_))) + .map(|(k, _)| *k) + .collect(); + hive_keys.sort_unstable(); + let mut honey = Vec::new(); + for key in hive_keys { + let at = [key.0, key.1, key.2]; + let (level, facing) = hive_state(registry, &world, at); + let Some(BlockEntity::Beehive(mut hive)) = world.block_entities.remove(&key) else { + continue; + }; + { + let w = mob_world!(&snapshot); + let mut host = ProbeHive { + w: &w, + random: &mut scratch, + types: &arc_types, + first: mobs.len() + born.len(), + added: &mut added, + honey: &mut honey, + events: &mut events, + }; + hive.server_tick(at, facing, level, &mut host); + } + world.block_entities.insert(key, BlockEntity::Beehive(hive)); + } + for (at, level) in honey { + if let Some(mut st) = registry.state(world.block(at[0], at[1], at[2])).cloned() { + st.properties + .insert("honey_level".to_owned(), level.to_string()); + world.set(at[0], at[1], at[2], registry.resolve(&st)?)?; + } + } mobs.append(&mut born); mobs.append(&mut added); for e in &heart_events { @@ -1235,6 +1391,35 @@ fn main() -> horizon_client::Result<()> { } ); } + for b in s.blocks.iter().filter(|b| is_hive(b)) { + let n = |i: usize| b[i].parse::().unwrap(); + let Some(BlockEntity::Beehive(hive)) = + world.block_entities.get(&(n(1), n(2), n(3))) + else { + continue; + }; + let (level, _) = hive_state(registry, &world, [n(1), n(2), n(3)]); + let bees: Vec = hive + .bees + .iter() + .map(|b| format!("{}/{}", b.ticks_in_hive, b.min_ticks_in_hive)) + .collect(); + let _ = writeln!( + out, + "{t} hive {},{},{} honey {} bees {} flower {}", + b[1], + b[2], + b[3], + level.unwrap_or(-1), + if bees.is_empty() { + "-".into() + } else { + bees.join(",") + }, + hive.flower + .map_or("-".into(), |f| format!("{},{},{}", f[0], f[1], f[2])) + ); + } for line in traces { let _ = writeln!(out, "{line}"); } diff --git a/crates/horizon-client/src/beehive.rs b/crates/horizon-client/src/beehive.rs new file mode 100644 index 000000000..26aa87cfc --- /dev/null +++ b/crates/horizon-client/src/beehive.rs @@ -0,0 +1,438 @@ +//! Beehives and bee nests (`BeehiveBlockEntity`): up to three bees stored as +//! entity tags, let out when their time inside is up (never at night or in +//! the rain, nor through a blocked front, unless the hive is emptied in an +//! emergency), honey for every bee coming home with nectar. The host (the game +//! or the mob AI probe) loads and adds the bees through [`HiveHost`]. +use crate::mobs::{Mob, Species, bee}; +use horizon_core::random::{LegacyRandom, RandomSource}; +use horizon_world::nbt::{Compound, Tag}; + +pub const MAX_OCCUPANTS: usize = 3; +/// `BeehiveBlockEntity.IGNORED_BEE_TAGS`: dropped from a bee going in, and +/// again from the tag it comes out with. +const IGNORED_BEE_TAGS: [&str; 25] = [ + "Air", + "drop_chances", + "equipment", + "Brain", + "CanPickUpLoot", + "DeathTime", + "fall_distance", + "FallFlying", + "Fire", + "HurtTime", + "LeftHanded", + "Motion", + "NoGravity", + "OnGround", + "PortalCooldown", + "Pos", + "Rotation", + "sleeping_pos", + "CannotEnterHiveTicks", + "TicksSincePollination", + "CropsGrownSincePollination", + "hive_pos", + "Passengers", + "leash", + "UUID", +]; + +/// `BeehiveBlockEntity`: the bees inside and the flower one of them knew. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Beehive { + pub bees: Vec, + pub flower: Option<[i32; 3]>, +} +/// `BeehiveBlockEntity.Occupant`: a bee's tag (with its `id`), its time in +/// the hive and the time it stays at least. +#[derive(Clone, Debug, PartialEq)] +pub struct Occupant { + pub entity_data: Tag, + pub ticks_in_hive: i32, + pub min_ticks_in_hive: i32, +} +/// `BeehiveBlockEntity.BeeReleaseStatus`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Release { + HoneyDelivered, + BeeReleased, + Emergency, +} + +/// What a hive needs from the level it is in. +pub trait HiveHost { + /// `level.getRandom()`. + fn random(&mut self) -> &mut LegacyRandom; + /// `EnvironmentAttributes.BEES_STAY_IN_HIVE` at a position. + fn bees_stay_in_hive(&self, at: [i32; 3]) -> bool; + /// A non-empty collision shape at a block. + fn blocked(&self, at: [i32; 3]) -> bool; + /// `BlockState.setValue(HONEY_LEVEL, level)` on the hive. + fn set_honey_level(&mut self, at: [i32; 3], level: i32); + /// `EntityType.loadEntityRecursive` (the tag has its `id` and a `Pos`): + /// a new entity, or `None` for anything but a `#beehive_inhabitors`. + fn load(&mut self, tag: &Tag) -> Option; + /// `Level.addFreshEntity`. + fn add(&mut self, m: Mob) -> bool; + fn sound(&mut self, name: &'static str, at: [f64; 3]); +} + +fn strip_ignored(c: &mut Compound) { + for key in IGNORED_BEE_TAGS { + c.remove(&key.into()); + } +} +fn int(tag: Option<&Tag>) -> Option { + match tag { + Some(Tag::Int(v)) => Some(*v), + _ => None, + } +} +fn pos(tag: Option<&Tag>) -> Option<[i32; 3]> { + match tag { + Some(Tag::IntArray(p)) if p.len() == 3 => Some([p[0], p[1], p[2]]), + _ => None, + } +} + +impl Occupant { + /// `Occupant.of`: the bee's saved tag without the ignored tags, staying + /// 2400 ticks with nectar, else 600. + pub fn of(mut tag: Tag) -> Self { + if let Tag::Compound(c) = &mut tag { + strip_ignored(c); + } + let nectar = matches!(tag.get("HasNectar"), Some(Tag::Byte(v)) if *v != 0); + Self { + entity_data: tag, + ticks_in_hive: 0, + min_ticks_in_hive: if nectar { 2400 } else { 600 }, + } + } + /// `Occupant.create`: a worldgen nest's bee, a bare bee tag. + pub fn create(ticks_in_hive: i32) -> Self { + Self { + entity_data: Tag::compound([("id", Tag::String("minecraft:bee".into()))]), + ticks_in_hive, + min_ticks_in_hive: 600, + } + } + fn has_nectar(&self) -> bool { + matches!(self.entity_data.get("HasNectar"), Some(Tag::Byte(v)) if *v != 0) + } + fn from_nbt(tag: &Tag) -> Option { + let data = tag.get("entity_data")?; + if !matches!(data, Tag::Compound(c) if c.contains_key(&"id".into())) { + return None; + } + Some(Self { + entity_data: data.clone(), + ticks_in_hive: int(tag.get("ticks_in_hive"))?, + min_ticks_in_hive: int(tag.get("min_ticks_in_hive"))?, + }) + } + fn to_nbt(&self) -> Tag { + Tag::compound([ + ("entity_data", self.entity_data.clone()), + ("ticks_in_hive", Tag::Int(self.ticks_in_hive)), + ("min_ticks_in_hive", Tag::Int(self.min_ticks_in_hive)), + ]) + } +} + +impl Beehive { + pub fn full(&self) -> bool { + self.bees.len() == MAX_OCCUPANTS + } + /// `loadAdditional`: `bees` (all or none, as the list codec reads them) + /// and `flower_pos`. + pub fn from_nbt(tag: &Tag) -> Self { + let bees = match tag.get("bees") { + Some(Tag::List(list)) => list + .iter() + .map(Occupant::from_nbt) + .collect::>>() + .unwrap_or_default(), + _ => Vec::new(), + }; + Self { + bees, + flower: pos(tag.get("flower_pos")), + } + } + /// `saveAdditional`. + pub fn to_nbt(&self) -> Vec<(&'static str, Tag)> { + let mut out = vec![( + "bees", + Tag::List(self.bees.iter().map(Occupant::to_nbt).collect()), + )]; + if let Some(f) = self.flower { + out.push(("flower_pos", Tag::IntArray(f.to_vec()))); + } + out + } + /// `addOccupant` (the bee's own tag, saved by the host): the hive keeps + /// the bee's flower, or now and then swaps its own for it. The host then + /// discards the bee. + pub fn add_occupant( + &mut self, + at: [i32; 3], + tag: Tag, + bee_flower: Option<[i32; 3]>, + host: &mut impl HiveHost, + ) -> bool { + if self.bees.len() >= MAX_OCCUPANTS { + return false; + } + self.bees.push(Occupant::of(tag)); + if let Some(f) = bee_flower + && (self.flower.is_none() || host.random().next_boolean()) + { + self.flower = Some(f); + } + let corner = at.map(f64::from); + host.sound("block.beehive.enter", corner); + true + } + /// `serverTick`: the bees whose time is up come out, then the hive + /// hums now and then while it holds any. `honey` is the hive state's + /// honey level as the tick starts (`None` without the property); + /// `facing` its front. + pub fn server_tick( + &mut self, + at: [i32; 3], + facing: [i32; 2], + honey: Option, + host: &mut impl HiveHost, + ) { + let flower = self.flower; + let mut i = 0; + while i < self.bees.len() { + // BeeData.tick: ticksInHive++ > minTicksInHive. + let b = &mut self.bees[i]; + let up = b.ticks_in_hive > b.min_ticks_in_hive; + b.ticks_in_hive += 1; + if up { + let status = if b.has_nectar() { + Release::HoneyDelivered + } else { + Release::BeeReleased + }; + let occupant = b.clone(); + if release(host, at, facing, honey, &occupant, status, flower).is_some() { + self.bees.remove(i); + continue; + } + } + i += 1; + } + if !self.bees.is_empty() && host.random().next_double() < 0.005 { + let hum = [ + f64::from(at[0]) + 0.5, + f64::from(at[1]), + f64::from(at[2]) + 0.5, + ]; + host.sound("block.beehive.work", hum); + } + } + /// `releaseAllOccupants`: the ids of the bees let out. + pub fn release_all( + &mut self, + at: [i32; 3], + facing: [i32; 2], + honey: Option, + status: Release, + host: &mut impl HiveHost, + ) -> Vec { + let flower = self.flower; + let mut out = Vec::new(); + self.bees.retain( + |b| match release(host, at, facing, honey, b, status, flower) { + Some(id) => { + out.extend(id); + false + } + None => true, + }, + ); + out + } +} + +/// `releaseOccupant`: `None` while the bee stays in, else the id of the bee +/// let out (`Some(None)` when the level refused it). +fn release( + host: &mut impl HiveHost, + at: [i32; 3], + facing: [i32; 2], + honey: Option, + occupant: &Occupant, + status: Release, + flower: Option<[i32; 3]>, +) -> Option> { + let emergency = status == Release::Emergency; + if host.bees_stay_in_hive(at) && !emergency { + return None; + } + let blocked = host.blocked([at[0] + facing[0], at[1], at[2] + facing[1]]); + if blocked && !emergency { + return None; + } + // Occupant.createEntity: the tag without the ignored tags. + let mut tag = occupant.entity_data.clone(); + if let Tag::Compound(c) = &mut tag { + strip_ignored(c); + let center = [at[0], at[1], at[2]].map(|v| Tag::Double((f64::from(v) + 0.5).to_bits())); + c.insert("Pos".into(), Tag::List(center.to_vec())); + } + let mut m = host.load(&tag)?; + m.no_gravity = true; + if m.species() == Species::Bee { + bee::set_hive(&mut m, Some(at)); + // setBeeReleaseData: the time inside counts towards growing up and + // away from love. + let ticks = occupant.ticks_in_hive; + if !m.extra.age_locked { + let age = m.extra.age; + m.extra.age = if age < 0 { + (age + ticks).min(0) + } else if age > 0 { + (age - ticks).max(0) + } else { + age + }; + } + m.extra.in_love = (m.extra.in_love - ticks).max(0); + if let Some(f) = flower + && bee::get(&m).is_none_or(|b| b.flower.is_none()) + && host.random().next_float() < 0.9 + { + bee::set_flower(&mut m, Some(f)); + } + if status == Release::HoneyDelivered { + bee::drop_off_nectar(&mut m); + if let Some(level) = honey.filter(|&l| l < 5) { + let mut increase = if host.random().next_int_bound(100).unwrap_or(1) == 0 { + 2 + } else { + 1 + }; + if level + increase > 5 { + increase -= 1; + } + host.set_honey_level(at, level + increase); + } + } + let delta = if blocked { + 0.0 + } else { + 0.55 + f64::from(m.width() / 2.0) + }; + let p = horizon_core::geometry::Vec3::new( + f64::from(at[0]) + 0.5 + delta * f64::from(facing[0]), + f64::from(at[1]) + 0.5 - f64::from(m.height() / 2.0), + f64::from(at[2]) + 0.5 + delta * f64::from(facing[1]), + ); + m.position = p; + m.previous = p; + } + host.sound( + "block.beehive.exit", + [ + f64::from(at[0]) + 0.5, + f64::from(at[1]) + 0.5, + f64::from(at[2]) + 0.5, + ], + ); + let id = m.id; + Some(host.add(m).then_some(id)) +} + +/// `CampfireBlock.isSmokeyPos`: a lit campfire up to five blocks below, +/// unless a block whose collision crosses the smoke's centre post comes +/// first (a lit campfire right under that block still counts). +pub fn smokey(w: &crate::mobs::MobWorld, at: [i32; 3]) -> bool { + let lit = |y: i32| { + w.has_tag("minecraft:campfires", w.block_name(at[0], y, at[2])) + && w.prop(at[0], y, at[2], "lit") == Some("true") + }; + for i in 1..=5 { + let y = at[1] - i; + if lit(y) { + return true; + } + // SHAPE_VIRTUAL_POST: Block.column(4, 0, 16), the middle quarter. + let (x0, z0) = (f64::from(at[0]), f64::from(at[2])); + let blocked = w.block_collision_boxes(at[0], y, at[2]).iter().any(|b| { + let (min, max) = (b.min_position(), b.max_position()); + min.x < x0 + 0.625 && max.x > x0 + 0.375 && min.z < z0 + 0.625 && max.z > z0 + 0.375 + }); + if blocked { + return lit(y - 1); + } + } + false +} + +/// `HorizontalDirectionalBlock.FACING` as an x/z step. +pub fn facing_step(facing: Option<&str>) -> [i32; 2] { + match facing { + Some("south") => [0, 1], + Some("west") => [-1, 0], + Some("east") => [1, 0], + _ => [0, -1], + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn nbt_round_trips_in_vanilla_order() { + let tag = Tag::compound([ + ( + "bees", + Tag::List(vec![ + Occupant::create(37).to_nbt(), + Occupant::create(0).to_nbt(), + ]), + ), + ("flower_pos", Tag::IntArray(vec![1, -60, 3])), + ]); + let hive = Beehive::from_nbt(&tag); + assert_eq!(hive.bees.len(), 2); + assert_eq!(hive.bees[0].ticks_in_hive, 37); + assert_eq!(hive.flower, Some([1, -60, 3])); + assert_eq!(Tag::compound(hive.to_nbt()), tag); + } + + #[test] + fn a_bad_bee_drops_the_whole_list() { + let tag = Tag::compound([( + "bees", + Tag::List(vec![ + Occupant::create(1).to_nbt(), + Tag::compound([("ticks_in_hive", Tag::Int(3))]), + ]), + )]); + assert!(Beehive::from_nbt(&tag).bees.is_empty()); + } + + #[test] + fn going_in_strips_the_ignored_tags() { + let tag = Tag::compound([ + ("id", Tag::String("minecraft:bee".into())), + ("UUID", Tag::IntArray(vec![1, 2, 3, 4])), + ("Health", Tag::Float(10.0_f32.to_bits())), + ("HasNectar", Tag::Byte(1)), + ("hive_pos", Tag::IntArray(vec![0, 0, 0])), + ]); + let o = Occupant::of(tag); + assert_eq!(o.min_ticks_in_hive, 2400); + assert!(o.entity_data.get("UUID").is_none()); + assert!(o.entity_data.get("hive_pos").is_none()); + assert!(o.entity_data.get("Health").is_some()); + } +} diff --git a/crates/horizon-client/src/containers.rs b/crates/horizon-client/src/containers.rs index 70c71d7fc..4870216cd 100644 --- a/crates/horizon-client/src/containers.rs +++ b/crates/horizon-client/src/containers.rs @@ -68,6 +68,8 @@ pub enum BlockEntity { Crafter(Crafter), /// `SpawnerBlockEntity` (`crate::mobs::spawner`). Spawner(Box), + /// `BeehiveBlockEntity` of beehives and bee nests (`crate::beehive`). + Beehive(Box), } /// `CrafterBlockEntity`: nine slots that can be disabled, the powered flag /// and the ticks left in the crafting animation. @@ -185,6 +187,9 @@ impl BlockEntity { if name == "minecraft:spawner" { return Some(Self::Spawner(Box::default())); } + if name == "minecraft:beehive" || name == "minecraft:bee_nest" { + return Some(Self::Beehive(Box::default())); + } if name == "minecraft:lectern" { return Some(Self::Lectern(Lectern::default())); } @@ -261,6 +266,7 @@ impl BlockEntity { Self::Crafter(_) => "minecraft:crafter", Self::CreakingHeart(_) => "minecraft:creaking_heart", Self::Spawner(_) => "minecraft:mob_spawner", + Self::Beehive(_) => "minecraft:beehive", } } pub fn contents(&self) -> Vec { @@ -270,7 +276,9 @@ impl BlockEntity { Self::Brewing(b) => b.items.iter().flatten().cloned().collect(), Self::Sign(_) => Vec::new(), Self::Jukebox(j) => j.record.iter().cloned().collect(), - Self::Beacon(_) | Self::CreakingHeart(_) | Self::Spawner(_) => Vec::new(), + Self::Beacon(_) | Self::CreakingHeart(_) | Self::Spawner(_) | Self::Beehive(_) => { + Vec::new() + } Self::Lectern(l) => l.book.iter().cloned().collect(), Self::Sculk(_) => Vec::new(), Self::Banner(_) => Vec::new(), @@ -289,7 +297,7 @@ impl BlockEntity { | Self::Sculk(_) | Self::Banner(_) => &[], Self::Crafter(c) => &c.items, - Self::CreakingHeart(_) | Self::Spawner(_) => &[], + Self::CreakingHeart(_) | Self::Spawner(_) | Self::Beehive(_) => &[], } } pub fn slots_mut(&mut self) -> &mut [Option] { @@ -304,7 +312,7 @@ impl BlockEntity { | Self::Sculk(_) | Self::Banner(_) => &mut [], Self::Crafter(c) => &mut c.items, - Self::CreakingHeart(_) | Self::Spawner(_) => &mut [], + Self::CreakingHeart(_) | Self::Spawner(_) | Self::Beehive(_) => &mut [], } } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 45068c9d6..f37072932 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -8,6 +8,7 @@ mod armor_stands; mod backdrop; mod banners; mod beacon; +mod beehives; mod block_entity_anims; mod blockctl; mod boats; @@ -2150,6 +2151,10 @@ impl Game<'_> { self.pending.record_saved(pos, &tag); } self.creaking_heart_broken(pos); + let hive = match self.world.block_entities.get(&key) { + Some(BlockEntity::Beehive(h)) => self.hive_state(pos).map(|s| ((**h).clone(), s)), + _ => None, + }; // playerWillDestroy and Level.removeBlock through the vanilla behaviour // library: the block entity's side effects (containers spill), neighbour // and shape updates, and the destroy event (particles, sound). @@ -2199,6 +2204,12 @@ impl Game<'_> { self.pop_resource(pos, d); } } + // BeehiveBlock.playerDestroy: silk touch keeps the bees in. + if let Some((hive, (honey, facing))) = hive + && !silk + { + self.hive_broken_by_player(pos, hive, honey, facing); + } // SpawnerBlock.spawnAfterBreak pops its experience whatever the tool. let xp = if silk && &*facts.name != "minecraft:spawner" { 0 @@ -3793,7 +3804,8 @@ impl Game<'_> { | BlockEntity::Sculk(_) | BlockEntity::Banner(_) | BlockEntity::CreakingHeart(_) - | BlockEntity::Spawner(_), + | BlockEntity::Spawner(_) + | BlockEntity::Beehive(_), ) => {} None => { v.extend((0..self.craft_size * self.craft_size).map(|i| 100 + i)); @@ -4042,7 +4054,8 @@ impl Game<'_> { | BlockEntity::Sculk(_) | BlockEntity::Banner(_) | BlockEntity::CreakingHeart(_) - | BlockEntity::Spawner(_), + | BlockEntity::Spawner(_) + | BlockEntity::Beehive(_), ) => {} None if self.mount_active() => self.draw_mount_background(batch, ox, oy), None => { @@ -5549,6 +5562,7 @@ impl Game<'_> { self.tick_beacons(); self.tick_creaking_hearts()?; self.tick_spawners()?; + self.tick_beehives(); let mut lit_changes = Vec::new(); for (pos, entity) in self.world.block_entities.iter_mut() { if let BlockEntity::Furnace(f) = entity diff --git a/crates/horizon-client/src/game/beehives.rs b/crates/horizon-client/src/game/beehives.rs new file mode 100644 index 000000000..eb74becc7 --- /dev/null +++ b/crates/horizon-client/src/game/beehives.rs @@ -0,0 +1,238 @@ +//! Beehives and bee nests in the game (`crate::beehive` holds their logic): +//! their server tick, bees going in, and the bees let out, angry, when a +//! player breaks the hive or fire reaches it. +use super::Game; +use horizon_client::{ + beehive::{self, Beehive, HiveHost, Release}, + containers::BlockEntity, + mobs::{Mob, Who, bee}, +}; +use horizon_core::{ + geometry::{Aabb, Vec3}, + random::{LegacyRandom, RandomSource}, +}; +use horizon_world::{nbt::Tag, registry::BlockStateId}; + +struct GameHive<'g, 'a> { + game: &'g mut Game<'a>, +} +impl HiveHost for GameHive<'_, '_> { + fn random(&mut self) -> &mut LegacyRandom { + &mut self.game.world.random + } + fn bees_stay_in_hive(&self, _at: [i32; 3]) -> bool { + bee::bees_stay_in_hive(&self.game.mob_world_base(&[])) + } + fn blocked(&self, at: [i32; 3]) -> bool { + !self + .game + .mob_world_base(&[]) + .block_collision_boxes(at[0], at[1], at[2]) + .is_empty() + } + fn set_honey_level(&mut self, at: [i32; 3], level: i32) { + let state = self.game.world.block(at[0], at[1], at[2]); + if let Some(state) = self.game.hive_with_honey(state, level) { + let _ = self.game.level_set(at, state); + } + } + fn load(&mut self, tag: &Tag) -> Option { + let kind = horizon_client::entity_nbt::kind(tag)?; + if !self + .game + .res + .mob_data + .entity_has("minecraft:beehive_inhabitors", &kind) + { + return None; + } + let id = self.game.load_mob(tag.clone(), None)?; + let i = self.game.mobs.iter().position(|m| m.id == id)?; + Some(self.game.mobs.remove(i)) + } + fn add(&mut self, m: Mob) -> bool { + self.game.mobs.push(m); + true + } + fn sound(&mut self, name: &'static str, at: [f64; 3]) { + self.game + .audio + .play(&format!("minecraft:{name}"), Some(at), 1.0, 1.0); + } +} + +impl Game<'_> { + fn hive_with_honey(&self, state: BlockStateId, level: i32) -> Option { + let registry = self.res.assets.registry; + let mut s = registry.state(state)?.clone(); + s.properties + .insert("honey_level".to_owned(), level.to_string()); + registry.resolve(&s).ok() + } + /// The hive's honey level and front, from its block state. + pub(super) fn hive_state(&self, at: [i32; 3]) -> Option<(Option, [i32; 2])> { + let state = self.world.block(at[0], at[1], at[2]); + let name = &self.res.facts.get(state).name; + if !self + .res + .items + .block_tags + .get("minecraft:beehives") + .is_some_and(|t| t.contains(&**name)) + { + return None; + } + let props = &self.res.assets.registry.state(state)?.properties; + let honey = props.get("honey_level").and_then(|v| v.parse().ok()); + let facing = beehive::facing_step(props.get("facing").map(String::as_str)); + Some((honey, facing)) + } + /// `BeehiveBlockEntity.serverTick` for every hive, after an emergency + /// exit for those with fire beside them (`BeehiveBlock.updateShape`). + pub(super) fn tick_beehives(&mut self) { + let mut keys: Vec<(i32, i32, i32)> = self + .world + .block_entities + .iter() + .filter(|(_, e)| matches!(e, BlockEntity::Beehive(_))) + .map(|(k, _)| *k) + .collect(); + keys.sort_unstable(); + for key in keys { + let at = [key.0, key.1, key.2]; + let Some((honey, facing)) = self.hive_state(at) else { + continue; + }; + let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.remove(&key) + else { + continue; + }; + let fire = [ + [1, 0, 0], + [-1, 0, 0], + [0, 1, 0], + [0, -1, 0], + [0, 0, 1], + [0, 0, -1], + ] + .iter() + .any(|d| { + let state = self.world.block(at[0] + d[0], at[1] + d[1], at[2] + d[2]); + &*self.res.facts.get(state).name == "minecraft:fire" + }); + let mut host = GameHive { game: self }; + if fire && !hive.bees.is_empty() { + hive.release_all(at, facing, honey, Release::Emergency, &mut host); + } + hive.server_tick(at, facing, honey, &mut host); + self.world + .block_entities + .insert(key, BlockEntity::Beehive(hive)); + } + } + /// `BeehiveBlockEntity.addOccupant` for a bee its `BeeEnterHiveGoal` + /// sent in: off its lead, its tag stored, the bee gone. + pub(super) fn bee_enter_hive(&mut self, mob: u32, at: [i32; 3]) { + let key = (at[0], at[1], at[2]); + let Some(i) = self + .mobs + .iter() + .position(|m| m.id == mob && m.alive() && !m.removed) + else { + return; + }; + if !matches!(self.world.block_entities.get(&key), Some(BlockEntity::Beehive(h)) if !h.full()) + { + return; + } + if self.mobs[i].extra.leash.is_some() { + self.break_leash(mob, true, false); + self.mobs[i].extra.leash = None; + } + self.mobs[i].extra.mount = None; + let tag = self.mob_tree_nbt(i); + let flower = bee::get(&self.mobs[i]).and_then(|b| b.flower); + let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.remove(&key) else { + return; + }; + let stored = hive.add_occupant(at, tag, flower, &mut GameHive { game: self }); + self.world + .block_entities + .insert(key, BlockEntity::Beehive(hive)); + if stored && let Some(m) = self.mobs.iter_mut().find(|m| m.id == mob) { + m.removed = true; + } + } + /// `BeehiveBlockEntity.emptyAllLivingFromHive` with no player about. + pub(super) fn empty_hive(&mut self, at: [i32; 3], facing: [i32; 2], status: Release) { + let key = (at[0], at[1], at[2]); + let Some(BlockEntity::Beehive(mut hive)) = self.world.block_entities.remove(&key) else { + return; + }; + hive.release_all(at, facing, None, status, &mut GameHive { game: self }); + self.world + .block_entities + .insert(key, BlockEntity::Beehive(hive)); + } + /// `BeehiveBlock.playerDestroy` without silk touch: the bees come out + /// angry at the player unless smoke calms them, then + /// `angerNearbyBees`. + pub(super) fn hive_broken_by_player( + &mut self, + at: [i32; 3], + mut hive: Beehive, + honey: Option, + facing: [i32; 2], + ) { + let released = hive.release_all( + at, + facing, + honey, + Release::Emergency, + &mut GameHive { game: self }, + ); + let sedated = beehive::smokey(&self.mob_world_base(&[]), at); + if let Some(p) = self.player_view().map(|p| p.position) { + for m in self.mobs.iter_mut().filter(|m| released.contains(&m.id)) { + if m.distance_sqr(p) <= 16.0 { + if sedated { + bee::set_stay_out_of_hive_countdown(m); + } else { + m.ai.target = Some(Who::Player); + } + } + } + } + self.anger_nearby_bees(at); + } + /// `BeehiveBlock.angerNearbyBees`: bees within 8 blocks (6 up and down) + /// without a target go for a player in the same box. + fn anger_nearby_bees(&mut self, at: [i32; 3]) { + let min = Vec3::new( + f64::from(at[0]) - 8.0, + f64::from(at[1]) - 6.0, + f64::from(at[2]) - 8.0, + ); + let area = Aabb::new(min, Vec3::new(min.x + 17.0, min.y + 13.0, min.z + 17.0)); + if !self + .player_view() + .is_some_and(|p| p.bounds.intersects(area)) + { + return; + } + let mut bees: Vec = (0..self.mobs.len()) + .filter(|&i| { + let m = &self.mobs[i]; + m.species() == horizon_client::mobs::Species::Bee + && !m.removed + && m.bounds().intersects(area) + }) + .collect(); + bees.retain(|&i| self.mobs[i].ai.target.is_none()); + for i in bees { + // Util.getRandom over the one player. + let _ = self.world.random.next_int_bound(1); + self.mobs[i].ai.target = Some(Who::Player); + } + } +} diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index e181f2507..f9f102e93 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -884,6 +884,7 @@ impl Game<'_> { self.golem_chest_slot(chest, slot, stack) } MobEvent::BecomeStatue { mob } => self.golem_become_statue(mob), + MobEvent::EnterHive { mob, hive } => self.bee_enter_hive(mob, hive), MobEvent::Gift { target, item } => { if let Some(m) = self.mobs.iter_mut().find(|m| m.id == target) && m.saddle_item().is_none() diff --git a/crates/horizon-client/src/game/dispenser.rs b/crates/horizon-client/src/game/dispenser.rs index 6c50b80ae..e8ceb5be3 100644 --- a/crates/horizon-client/src/game/dispenser.rs +++ b/crates/horizon-client/src/game/dispenser.rs @@ -1552,10 +1552,11 @@ impl Game<'_> { && let Some(level) = honey && level >= 5 { - // releaseBeesAndResetHoneyLevel (the bees themselves are not modelled). + // releaseBeesAndResetHoneyLevel. if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) { self.level_set([target.0, target.1, target.2], reset)?; } + self.dispenser_empty_hive(target, state); let bottle = ItemStack::new("minecraft:honey_bottle", 1); self.post_block_game_event("minecraft:fluid_pickup", [pos.0, pos.1, pos.2], None, None); return Ok(( @@ -1624,6 +1625,16 @@ impl Game<'_> { } Ok((Some(stack), FAIL)) } + /// The bees of a hive a dispenser harvested come out (`BEE_RELEASED`: + /// not at night nor in the rain), through the front of its old state. + fn dispenser_empty_hive(&mut self, target: Pos, old: BlockStateId) { + let facing = self.prop(old, "facing"); + self.empty_hive( + [target.0, target.1, target.2], + horizon_client::beehive::facing_step(facing.as_deref()), + horizon_client::beehive::Release::BeeReleased, + ); + } fn shear_beehive(&mut self, target: Pos) -> Result { let state = self.block_at(target); let name = self.dispenser_block_name(target); @@ -1652,6 +1663,7 @@ impl Game<'_> { if let Some(reset) = self.with_props(state, &[("honey_level", "0")]) { self.level_set(p, reset)?; } + self.dispenser_empty_hive(target, state); self.post_block_game_event("minecraft:shear", p, None, None); Ok(true) } diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index f8dd9d503..40bc0d2ea 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -13,6 +13,7 @@ pub mod audio; pub mod auth; pub mod auto_jump; pub mod banner; +pub mod beehive; pub mod benchmark; pub mod biome; pub mod block_entity_anim; diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 6c2bf25f4..4f751aaa1 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -847,6 +847,12 @@ pub enum MobEvent { chest: [i32; 3], open: bool, }, + /// `BeeEnterHiveGoal.start`: the bee goes into its hive (the host stores + /// its tag with `BeehiveBlockEntity.addOccupant` and discards it). + EnterHive { + mob: u32, + hive: [i32; 3], + }, /// `CopperGolem.turnToStatue`. BecomeStatue { mob: u32, diff --git a/crates/horizon-client/src/mobs/bee.rs b/crates/horizon-client/src/mobs/bee.rs index 30bf515c4..cdb0318bc 100644 --- a/crates/horizon-client/src/mobs/bee.rs +++ b/crates/horizon-client/src/mobs/bee.rs @@ -1,9 +1,11 @@ //! Bees (`Bee`): flying about (`FlyingMoveControl`, `BeeWanderGoal`), finding //! flowers and hovering over them until they carry nectar //! (`BeePollinateGoal`), `NeutralMob` anger at whoever hurts them, stinging -//! once and dying of it, and the hive and flower bookkeeping. Beehive block -//! entities are not simulated yet: no hive is ever valid, so bees never find, -//! enter or leave one, nor grow crops on the way home. +//! once and dying of it, and the hive and flower bookkeeping: finding a hive +//! with room nearby (`BeeLocateHiveGoal`), flying home at night, in the rain +//! or with nectar (`BeeGoToHiveGoal`) and going in (`BeeEnterHiveGoal`, done +//! by the host: [`MobEvent::EnterHive`]); the hive lets them out +//! (`crate::beehive`). use super::{ Damage, DamageKind, Mob, MobEvent, MobWorld, Species, Who, control::{LookKind, MoveKind}, @@ -47,6 +49,8 @@ pub struct Bee { /// The cooldowns `ValidateHiveGoal` and `ValidateFlowerGoal` draw when built. pub validate_hive_cooldown: i32, pub validate_flower_cooldown: i32, + /// `BeeGoToHiveGoal.blacklistedTargets`: the last three hives it gave up on. + pub hive_blacklist: Vec<[i32; 3]>, } impl Default for Bee { fn default() -> Self { @@ -68,6 +72,7 @@ impl Default for Bee { pollinating: false, validate_hive_cooldown: 0, validate_flower_cooldown: 0, + hive_blacklist: Vec::new(), } } } @@ -361,12 +366,33 @@ fn closer_than(m: &Mob, p: [i32; 3], dist: i32) -> bool { fn too_far(m: &Mob, p: [i32; 3]) -> bool { !closer_than(m, p, 48) } -/// `Bee.getBeehiveBlockEntity() != null`: hives are not simulated yet. -fn hive_valid(_m: &Mob, _w: &MobWorld) -> bool { - false +/// `Bee.getBeehiveBlockEntity`: the hive's block entity, unless too far. +fn hive_entity<'a>(m: &Mob, w: &'a MobWorld) -> Option<&'a crate::beehive::Beehive> { + let h = get(m)?.hive?; + if too_far(m, h) { + return None; + } + match w.world.block_entities.get(&(h[0], h[1], h[2])) { + Some(crate::containers::BlockEntity::Beehive(hive)) => Some(hive), + _ => None, + } +} +fn hive_valid(m: &Mob, w: &MobWorld) -> bool { + hive_entity(m, w).is_some() +} +/// `BeehiveBlockEntity.isFireNearby`: fire (not soul fire) next to the hive. +fn hive_near_fire(m: &Mob, w: &MobWorld) -> bool { + let Some(h) = get(m).and_then(|b| b.hive).filter(|_| hive_valid(m, w)) else { + return false; + }; + (-1..=1).any(|dx| { + (-1..=1).any(|dy| { + (-1..=1).any(|dz| w.block_name(h[0] + dx, h[1] + dy, h[2] + dz) == "minecraft:fire") + }) + }) } /// `EnvironmentAttributes.BEES_STAY_IN_HIVE`: the overworld's night, or rain. -fn bees_stay_in_hive(w: &MobWorld) -> bool { +pub fn bees_stay_in_hive(w: &MobWorld) -> bool { let night = !w.nether && !w.end && (12542..23460).contains(&w.day_time.rem_euclid(24000)); night || w.raining } @@ -379,8 +405,26 @@ fn wants_to_enter_hive(m: &Mob, w: &MobWorld) -> bool { if b.stay_out_of_hive > 0 || b.pollinating || has_stung(m) || m.ai.target.is_some() { return false; } - // ... && !isHiveNearFire(): no hive, no fire. - has_nectar(m) || tired_of_looking_for_nectar(m) || bees_stay_in_hive(w) + (has_nectar(m) || tired_of_looking_for_nectar(m) || bees_stay_in_hive(w)) + && !hive_near_fire(m, w) +} +/// `Bee.setHivePos`. +pub fn set_hive(m: &mut Mob, hive: Option<[i32; 3]>) { + st(m).hive = hive; +} +/// `Bee.setSavedFlowerPos`. +pub fn set_flower(m: &mut Mob, flower: Option<[i32; 3]>) { + st(m).flower = flower; +} +/// `Bee.dropOffNectar`. +pub fn drop_off_nectar(m: &mut Mob) { + set_has_nectar(m, false); + st(m).crops_grown = 0; +} +/// `Bee.setStayOutOfHiveCountdown`, which in 26.3 only resets the time +/// without nectar. +pub fn set_stay_out_of_hive_countdown(m: &mut Mob) { + st(m).ticks_without_nectar = 0; } fn drop_hive(m: &mut Mob) { let b = st(m); @@ -527,7 +571,7 @@ impl Goal for BecomeAngryTarget { } } -/// `BeeEnterHiveGoal`: into the hive beside it (none is ever valid yet). +/// `BeeEnterHiveGoal`: into the hive beside it, or forget it when full. #[derive(Clone, Debug)] struct EnterHive; impl Goal for EnterHive { @@ -544,12 +588,24 @@ impl Goal for EnterHive { let (x, y, z) = (d(0, m.position.x), d(1, m.position.y), d(2, m.position.z)); x * x + y * y + z * z < 4.0 }); - let enter = close && wants_to_enter_hive(m, cx.w) && hive_valid(m, cx.w); + let mut enter = false; + if close && wants_to_enter_hive(m, cx.w) { + match hive_entity(m, cx.w).map(|h| h.full()) { + Some(false) => enter = true, + Some(true) => st(m).hive = None, + None => {} + } + } enter && calm(m, cx.w) } fn can_continue(&mut self, _m: &mut Mob, _cx: &mut Cx) -> bool { false } + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { + if let Some(hive) = get(m).and_then(|b| b.hive).filter(|_| hive_valid(m, cx.w)) { + cx.events.push(MobEvent::EnterHive { mob: m.id, hive }); + } + } } /// `ValidateHiveGoal`: now and then, forget a hive that is gone. @@ -771,7 +827,8 @@ impl Goal for Pollinate { } } -/// `BeeLocateHiveGoal`: the nearest bee home with room (none yet). +/// `BeeLocateHiveGoal`: the nearest bee home with room within 20 blocks, +/// skipping the ones `BeeGoToHiveGoal` gave up on (unless that is all). #[derive(Clone, Debug)] struct LocateHive; impl Goal for LocateHive { @@ -791,17 +848,49 @@ impl Goal for LocateHive { fn can_continue(&mut self, _m: &mut Mob, _cx: &mut Cx) -> bool { false } - fn start(&mut self, m: &mut Mob, _cx: &mut Cx) { - // findNearbyHivesWithSpace finds no beehive block entity. + fn start(&mut self, m: &mut Mob, cx: &mut Cx) { st(m).hive_cooldown = 200; + let hives = hives_with_space(m, cx.w); + let b = st(m); + let pick = hives + .iter() + .find(|h| !b.hive_blacklist.contains(h)) + .copied(); + if pick.is_none() && !hives.is_empty() { + b.hive_blacklist.clear(); + } + b.hive = pick.or_else(|| hives.first().copied()).or(b.hive); } } +/// `findNearbyHivesWithSpace`: the bee homes (`PoiTypeTags.BEE_HOME`) +/// within 20 blocks whose hive has room, nearest first. +fn hives_with_space(m: &Mob, w: &MobWorld) -> Vec<[i32; 3]> { + let here = block_pos(m); + let dist = |p: &[i32; 3]| { + let d = |i: usize| i64::from(p[i] - here[i]); + d(0) * d(0) + d(1) * d(1) + d(2) * d(2) + }; + let mut hives: Vec<[i32; 3]> = w + .world + .block_entities + .iter() + .filter_map(|(&(x, y, z), e)| match e { + crate::containers::BlockEntity::Beehive(h) if !h.full() => Some([x, y, z]), + _ => None, + }) + .filter(|p| { + dist(p) <= 20 * 20 && w.has_tag("minecraft:beehives", w.block_name(p[0], p[1], p[2])) + }) + .collect(); + hives.sort_by_key(|p| (dist(p), *p)); + hives +} + /// `BeeGoToHiveGoal`: home when it wants to go in. #[derive(Clone, Debug, Default)] struct GoToHive { travelling: i32, - blacklist: Vec<[i32; 3]>, last_path: Option, stuck: i32, } @@ -815,10 +904,11 @@ impl GoToHive { .is_some_and(|path| path.target == p && path.reached && path.is_done()) } fn drop_and_blacklist(&mut self, m: &mut Mob) { - if let Some(h) = get(m).and_then(|b| b.hive) { - self.blacklist.push(h); - while self.blacklist.len() > 3 { - self.blacklist.remove(0); + let b = st(m); + if let Some(h) = b.hive { + b.hive_blacklist.push(h); + while b.hive_blacklist.len() > 3 { + b.hive_blacklist.remove(0); } } drop_hive(m); @@ -1037,8 +1127,27 @@ impl Goal for Wander { m.ai.nav.is_in_progress() } fn start(&mut self, m: &mut Mob, cx: &mut Cx) { - // isHiveValid() is false: wander the way it looks. - let dir = m.view_vector(); + // Back towards a valid hive farther than 24 blocks, else ahead. + let far_hive = get(m) + .and_then(|b| b.hive) + .filter(|&h| hive_valid(m, cx.w) && !closer_than(m, h, 24)); + let dir = match far_hive { + Some(h) => { + let v = [ + f64::from(h[0]) + 0.5 - m.position.x, + f64::from(h[1]) + 0.5 - m.position.y, + f64::from(h[2]) + 0.5 - m.position.z, + ]; + // Vec3.normalize. + let len = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt(); + if len < 1.0E-5 { + [0.0; 3] + } else { + v.map(|c| c / len) + } + } + None => m.view_vector(), + }; let max_rad = f64::from(std::f32::consts::FRAC_PI_2); let at = m .hover_random_pos(cx.w, 8, 7, dir[0], dir[2], max_rad, 3, 1) diff --git a/crates/horizon-client/src/save.rs b/crates/horizon-client/src/save.rs index 294b788b6..f0a645942 100644 --- a/crates/horizon-client/src/save.rs +++ b/crates/horizon-client/src/save.rs @@ -527,6 +527,7 @@ pub fn encode_block_entity( } } BlockEntity::Spawner(s) => entries.extend(s.save()), + BlockEntity::Beehive(h) => entries.extend(h.to_nbt()), } Tag::compound(entries) } @@ -655,6 +656,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain | BlockEntity::Banner(_) | BlockEntity::CreakingHeart(_) => {} BlockEntity::Spawner(s) => **s = crate::mobs::spawner::Spawner::load(tag), + BlockEntity::Beehive(h) => **h = crate::beehive::Beehive::from_nbt(tag), } Some((pos, entity)) } diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java index 80559155a..cc54e472b 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java @@ -585,6 +585,7 @@ public final class VanillaMobAiOracle { } } case "inlove" -> ((net.minecraft.world.entity.animal.Animal) mob).setInLoveTime(600); + case "nectar" -> method(net.minecraft.world.entity.animal.bee.Bee.class, "setHasNectar", boolean.class).invoke(mob, true); case "tame" -> { if (mob instanceof net.minecraft.world.entity.animal.equine.AbstractHorse horse) horse.setTamed(true); } case "strength" -> method(net.minecraft.world.entity.animal.equine.Llama.class, "setStrength", int.class) .invoke(mob, Integer.parseInt(v)); @@ -615,20 +616,7 @@ public final class VanillaMobAiOracle { if (cooldown > 0) brain.setMemory(MemoryModuleType.TRANSPORT_ITEMS_COOLDOWN_TICKS, cooldown); else brain.eraseMemory(MemoryModuleType.TRANSPORT_ITEMS_COOLDOWN_TICKS); } - if (mob instanceof net.minecraft.world.entity.animal.bee.Bee bee) { - // The constructor's draws, made again with the seeded random: the validate - // goals' cooldowns (registerGoals), then the flower cooldown's initialiser. - var rnd = bee.getRandom(); - int hive = net.minecraft.util.Mth.nextInt(rnd, 20, 40); - int flower = net.minecraft.util.Mth.nextInt(rnd, 20, 40); - for (WrappedGoal g : ((GoalSelector) get(bee, "goalSelector")).getAvailableGoals()) { - String n = g.getGoal().getClass().getSimpleName(); - if (n.equals("ValidateHiveGoal")) field(g.getGoal().getClass(), "VALIDATE_HIVE_COOLDOWN").setInt(g.getGoal(), hive); - if (n.equals("ValidateFlowerGoal")) field(g.getGoal().getClass(), "validateFlowerCooldown").setInt(g.getGoal(), flower); - } - field(net.minecraft.world.entity.animal.bee.Bee.class, "remainingCooldownBeforeLocatingNewFlower") - .setInt(bee, net.minecraft.util.Mth.nextInt(rnd, 20, 60)); - } + if (mob instanceof net.minecraft.world.entity.animal.bee.Bee bee) seedBee(bee); @SuppressWarnings("unchecked") Map> sensors = (Map>) get(brain, "sensors"); for (Sensor sensor : sensors.values()) sensor.randomlyDelayStart(mob.getRandom()); @@ -748,14 +736,19 @@ public final class VanillaMobAiOracle { if (e.isRemoved()) continue; level.tickNonPassenger(e); } - if (!heartPositions.isEmpty()) level.tickBlockEntities(); + if (s.blocks.stream().anyMatch(Server::isHive)) { + // A bee leaving its hive takes the id the probe gives it, 100000 + its index + // (goals run in full on ticks where tickCount + id is even). + ((java.util.concurrent.atomic.AtomicInteger) field(ServerLevel.class, "ENTITY_COUNTER").get(null)).set(100000 + ENTS.size() - 1); + level.tickBlockEntities(); + } else if (!heartPositions.isEmpty()) level.tickBlockEntities(); managerTick.invoke(manager); // Villagers the tick spawned (babies) and a heart's creakings tick from the next // one, in the order they were added, with a seeded random of their own. Other // newcomers (animal babies, dropped items) are left out, as the probe leaves them. List fresh = new ArrayList<>(); for (Entity e : level.getAllEntities()) - if (!LABELS.containsKey(e) && (e instanceof Villager || created.contains(e))) fresh.add(e); + if (!LABELS.containsKey(e) && (e instanceof Villager || e instanceof net.minecraft.world.entity.animal.bee.Bee || created.contains(e))) fresh.add(e); fresh.sort(java.util.Comparator.comparingInt(Entity::getId)); for (Entity e : fresh) { int index = ENTS.size(); @@ -779,6 +772,8 @@ public final class VanillaMobAiOracle { mob.yHeadRotO = mob.getYRot(); if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, index)); mob.getRandom().setSeed(seed); + // A bee out of a hive: its constructor drew from an unseeded random. + if (mob instanceof net.minecraft.world.entity.animal.bee.Bee bee) seedBee(bee); @SuppressWarnings("unchecked") Map> sensors = (Map>) get(mob.getBrain(), "sensors"); for (Sensor sensor : sensors.values()) sensor.randomlyDelayStart(mob.getRandom()); @@ -791,6 +786,7 @@ public final class VanillaMobAiOracle { for (int i = 0; i < ENTS.size(); i++) print(t, i, ENTS.get(i)); for (BlockPos h : heartPositions) printHeart(t, level, h); for (String[] b : s.blocks) if (b[0].equals("chest")) printChest(t, s, level, b); + for (String[] b : s.blocks) if (isHive(b)) printHive(t, level, b); for (String sound : SOUNDS) out.println(t + " sound " + sound); for (var w : watched.entrySet()) { BlockState now = level.getBlockState(w.getKey()); @@ -812,6 +808,44 @@ public final class VanillaMobAiOracle { out.flush(); } + /** + * A bee's constructor draws, made again with its seeded random: the validate goals' + * cooldowns (registerGoals), then the flower cooldown's initialiser. + */ + static void seedBee(net.minecraft.world.entity.animal.bee.Bee bee) throws Exception { + var rnd = bee.getRandom(); + int hive = net.minecraft.util.Mth.nextInt(rnd, 20, 40); + int flower = net.minecraft.util.Mth.nextInt(rnd, 20, 40); + for (WrappedGoal g : ((GoalSelector) get(bee, "goalSelector")).getAvailableGoals()) { + String n = g.getGoal().getClass().getSimpleName(); + if (n.equals("ValidateHiveGoal")) field(g.getGoal().getClass(), "VALIDATE_HIVE_COOLDOWN").setInt(g.getGoal(), hive); + if (n.equals("ValidateFlowerGoal")) field(g.getGoal().getClass(), "validateFlowerCooldown").setInt(g.getGoal(), flower); + } + field(net.minecraft.world.entity.animal.bee.Bee.class, "remainingCooldownBeforeLocatingNewFlower") + .setInt(bee, net.minecraft.util.Mth.nextInt(rnd, 20, 60)); + } + + /** A hive's honey level and bees (ticks inside / ticks to stay). */ + static void printHive(int t, ServerLevel level, String[] b) { + BlockPos at = new BlockPos(Integer.parseInt(b[1]), Integer.parseInt(b[2]), Integer.parseInt(b[3])); + if (!(level.getBlockEntity(at) instanceof net.minecraft.world.level.block.entity.BeehiveBlockEntity hive)) return; + net.minecraft.nbt.CompoundTag tag = hive.saveWithoutMetadata(level.registryAccess()); + StringBuilder bees = new StringBuilder(); + for (var bee : tag.getListOrEmpty("bees")) { + net.minecraft.nbt.CompoundTag c = (net.minecraft.nbt.CompoundTag) bee; + if (!bees.isEmpty()) bees.append(','); + bees.append(c.getIntOr("ticks_in_hive", 0)).append('/').append(c.getIntOr("min_ticks_in_hive", 0)); + } + BlockState state = level.getBlockState(at); + out.println(t + " hive " + b[1] + "," + b[2] + "," + b[3] + " honey " + + (state.hasProperty(net.minecraft.world.level.block.BeehiveBlock.HONEY_LEVEL) ? state.getValue(net.minecraft.world.level.block.BeehiveBlock.HONEY_LEVEL) : -1) + + " bees " + (bees.isEmpty() ? "-" : bees) + " flower " + tag.getIntArray("flower_pos").map(p -> p[0] + "," + p[1] + "," + p[2]).orElse("-")); + } + + static boolean isHive(String[] b) { + return b[0].equals("block") && (b[4].startsWith("minecraft:beehive") || b[4].startsWith("minecraft:bee_nest")); + } + /** The random seed of the entity a scenario spawned at this index. */ static long spawnSeed(int index) { return 1000L + 7919L * index; } diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py index 2b66d9b27..b87e0535a 100644 --- a/tools/test_mob_ai_parity.py +++ b/tools/test_mob_ai_parity.py @@ -250,6 +250,13 @@ def scenarios(): add('bee_rain', 300, [FLOWERS, 'mob minecraft:bee 0.5 -58 0.5 0 157 persistent'], 'rain') add('bee_pool', 200, ['fill -3 -63 -3 3 -61 3 minecraft:water', 'mob minecraft:bee 0.5 -62 0.5 0 158 persistent']) add('bee_sting', 400, ['player 4.5 -60 0.5', 'mob minecraft:bee 0.5 -58 0.5 0 159 persistent', 'hurt 20 0']) + # Bees and their hive: home at night and in the rain (BeeLocateHiveGoal, BeeGoToHiveGoal, + # BeeEnterHiveGoal), out again once the morning comes, and nectar turned into honey. + HIVE = 'block 4 -60 0 minecraft:beehive[facing=west,honey_level=0]' + add('bee_hive_night', 300, [HIVE, 'mob minecraft:bee 0.5 -58 0.5 0 161 persistent'], 'time=13000') + add('bee_hive_rain', 300, [HIVE, 'mob minecraft:bee 0.5 -58 0.5 0 162 persistent'], 'rain') + add('bee_hive_morning', 1000, [HIVE, 'mob minecraft:bee 0.5 -58 0.5 0 163 persistent'], 'time=22900 daycycle') + add('bee_hive_honey', 2600, [HIVE, 'mob minecraft:bee 0.5 -58 0.5 0 164 persistent nectar']) return s @@ -304,6 +311,9 @@ def parse(path): if parts[1] == 'heart': cur.setdefault('hearts', {}).setdefault(t, []).append(line.split(' ', 2)[2]) continue + if parts[1] == 'hive': + cur.setdefault('hives', {}).setdefault(t, []).append(parts[2]) + continue if parts[1] == 'chest': cur.setdefault('chests', {}).setdefault(t, []).append(parts[2]) continue @@ -400,8 +410,8 @@ def compare(vanilla, rust, fields=None): report.append(f'{name}: hearts differ at tick {t}: vanilla {v.get("hearts", {}).get(t)} | horizon {r.get("hearts", {}).get(t)}') clean = False break - # Sounds, watched block changes and chest contents: first differing tick. - for kind in ('sounds', 'blocks', 'chests'): + # Sounds, watched block changes, chest contents and hives: first differing tick. + for kind in ('sounds', 'blocks', 'chests', 'hives'): va, ra = v.get(kind, {}), r.get(kind, {}) for t in sorted(set(va) | set(ra)): if va.get(t, []) != ra.get(t, []):