diff --git a/crates/horizon-client/examples/mob_ai_probe.rs b/crates/horizon-client/examples/mob_ai_probe.rs index df0d70b62..c3d6a5605 100644 --- a/crates/horizon-client/examples/mob_ai_probe.rs +++ b/crates/horizon-client/examples/mob_ai_probe.rs @@ -223,56 +223,144 @@ fn goals(m: &Mob, names: Vec<&'static str>) -> String { .join("|") } -fn seen(m: &Mob) -> Seen { - Seen { - id: m.id, - species: m.species(), - position: m.position, - bounds: m.bounds(), - eye_y: m.eye_y(), - alive: m.alive(), - baby: m.is_baby(), - in_love: if m.species() == Species::Villager { - horizon_client::mobs::villager::can_breed(m) - } else { - m.extra.in_love > 0 - }, - tame: m.extra.tame, - hostile: m.hostile(), - target: m.ai.target, - health: m.health, - variant: m.extra.variant, - color: m.extra.color, - job: (m.species() == Species::Villager) - .then_some(m.extra.home) - .flatten(), - bed: (m.species() == Species::Villager) - .then_some(m.extra.bed) - .flatten(), - yaw: m.yaw, - velocity: m.velocity, - leash: m.extra.leash, - caravan: horizon_client::mobs::caravan::head_of(m), - delay: m.extra.ints[5], - hurt_by: m.ai.last_hurt_by.map(|w| (w, m.ai.last_hurt_by_time)), - active_raid: horizon_client::mobs::raider::has_active_raid(m), - player_rep: 0, - pushable: m.pushable(), - category: m.category(), - potential_job: horizon_client::mobs::villager_brain::potential_job_site(m), - meeting: (m.species() == Species::Villager) - .then_some(m.extra.meeting) - .flatten(), - profession: m.extra.variant2, - xp: horizon_client::mobs::villager::xp(m), - stats: [ - f64::from(m.attrs.max_health), - m.extra.vector[0], - m.attrs.speed, - ], +/// The oracle's villager flags: profession, level, xp, food, inventory, +/// gossip about the player and the last sleep. +fn villager_flag(m: &mut Mob, flag: &str) { + use horizon_client::mobs::villager; + let (k, v) = flag + .split_once('=') + .unwrap_or_else(|| panic!("unknown mob flag {flag}")); + match k { + "profession" => { + let p = horizon_client::mobs::render::PROFESSIONS + .iter() + .position(|p| *p == v) + .expect("profession"); + villager::set_profession(m, p as u8); + } + "level" => m.extra.variant3 = v.parse().unwrap(), + "xp" => { + m.extra.trade.get_or_insert_with(Default::default).xp = v.parse().unwrap(); + } + "food" => villager::ext_mut(m).food_level = v.parse().unwrap(), + "inv" => { + for item in v.split(',') { + let (name, count) = item.split_once('*').unwrap_or((item, "1")); + villager::ext_mut(m) + .inventory + .push(horizon_client::items::ItemStack::new( + &if name.contains(':') { + name.to_owned() + } else { + format!("minecraft:{name}") + }, + count.parse().unwrap(), + )); + } + } + "gossip" => { + let g: Vec<&str> = v.split(':').collect(); + assert_eq!(g[0], "player", "gossip about the player only"); + let kind = horizon_client::gossip::GossipType::from_id(g[1]).expect("gossip type"); + villager::ext_mut(m) + .gossips + .add(PLAYER_UUID, kind, g[2].parse().unwrap()); + } + "slept" => villager::ext_mut(m).last_slept = Some(v.parse().unwrap()), + _ => panic!("unknown mob flag {flag}"), } } +/// The random seed of the entity a scenario spawns at this index (the +/// oracle's `spawnSeed`). +fn spawn_seed(index: usize) -> i64 { + 1000 + 7919 * index as i64 +} + +/// Villager events that act at once in vanilla (`TradeWithVillager` and +/// `VillagerMakeLove` write the other villager directly). +fn villager_events( + mobs: &mut Vec, + events: &mut Vec, + from: usize, + w: &MobWorld, + types: &MobTypes, + items: &Items, + born: &mut Vec, + day_time: i64, +) { + use horizon_client::mobs::villager; + let index = |mobs: &[Mob], id: u32| { + mobs.iter() + .position(|m| m.id == id && m.species() == Species::Villager) + }; + let mut i = from; + while i < events.len() { + match events[i] { + MobEvent::VillagerMeet { mob, other } => { + if let (Some(a), Some(b)) = (index(mobs, mob), index(mobs, other)) { + let meeting = villager::meet(mobs, a, b, w.game_time, |item| { + items.get(item).map_or(64, |i| i.max_stack) + }); + assert!( + meeting.thrown.is_empty(), + "villagers toss items: not modelled here" + ); + } + events.remove(i); + } + MobEvent::VillagerBirth { parent, partner } => { + events.remove(i); + let (Some(a), Some(b)) = (index(mobs, parent), index(mobs, partner)) else { + continue; + }; + villager::ext_mut(&mut mobs[a]).eat_and_digest(); + villager::ext_mut(&mut mobs[b]).eat_and_digest(); + let p = mobs[a].position; + let from = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]; + let Some(bed) = villager::take_vacant_bed(mobs, from, |x, y, z| { + w.prop(x, y, z, "part") == Some("head") + && w.prop(x, y, z, "occupied") == Some("false") + }) else { + continue; + }; + // Villager.getBreedOffspring: half the biome's type (plains + // here), a quarter each parent's. + let roll = horizon_core::random::RandomSource::next_double(&mut mobs[a].random); + let variant = if roll < 0.5 { + 0 + } else if roll < 0.75 { + mobs[a].extra.variant + } else { + mobs[b].extra.variant + }; + mobs[a].extra.age = 6000; + mobs[b].extra.age = 6000; + let index = mobs.len() + born.len(); + let kind = types.types.get("minecraft:villager").expect("villager"); + let mut child = Mob::new(100_000 + index as u32, Arc::new(kind.clone()), p, 0.0); + child.persistent = true; + child.extra.variant = variant; + child.extra.variant2 = villager::NONE; + child.extra.age = -24000; + child.extra.bed = Some(bed); + let seed = spawn_seed(index); + child.random = LegacyRandom::new(seed); + horizon_client::mobs::villager_brain::init(&mut child, w.game_time, day_time, seed); + born.push(child); + } + _ => i += 1, + } + } +} + +/// The player's UUID (the oracle's `PLAYER_UUID`). +const PLAYER_UUID: [i32; 4] = [0, 0x1234, 0, 0x5678]; + +fn seen(m: &Mob) -> Seen { + m.seen(Some(PLAYER_UUID)) +} + /// The probe's mobs as a creaking heart sees them: creakings it creates take /// the n-th seed from 1000, as the oracle's do. struct Host<'a> { @@ -479,9 +567,95 @@ fn print(out: &mut String, t: i32, i: usize, m: &Mob) { if let Some((acts, mem)) = brain { let _ = write!(out, "\tact {acts}\tmem {mem}"); } + if m.species() == Species::Villager { + let _ = write!(out, "\tvx {}", villager(m)); + } out.push('\n'); } +fn stack(s: &horizon_client::items::ItemStack) -> String { + if s.count == 0 { + return "-".into(); + } + format!("{}*{}", s.item.trim_start_matches("minecraft:"), s.count) +} + +/// The oracle's `villager`: data, food, inventory, gossip, sleep and offers. +fn villager(m: &Mob) -> String { + use horizon_client::mobs::villager; + let e = villager::ext(m); + let mut slots: Vec = (0..8) + .map(|k| { + e.and_then(|e| e.inventory.get(k)) + .map_or_else(|| "-".to_owned(), stack) + }) + .collect(); + while slots.last().is_some_and(|s| s == "-") { + slots.pop(); + } + // Villagers gossip about players only. + let label = |t: [i32; 4]| { + if t == PLAYER_UUID { + "player".to_owned() + } else { + format!("{t:?}") + } + }; + let mut gossips: Vec = e + .map(|e| { + e.gossips + .entries() + .map(|(t, k, v)| format!("{}:{}={v}", label(t), k.id())) + .collect() + }) + .unwrap_or_default(); + gossips.sort(); + let join = |v: &[String]| { + if v.is_empty() { + "-".to_owned() + } else { + v.join(",") + } + }; + let mut s = format!( + "prof {} lvl {} xp {} food {} age {} inv {} gossip {} rep {} sleep {}", + horizon_client::mobs::render::PROFESSIONS[m.extra.variant2 as usize % 15], + m.extra.variant3.max(1), + villager::xp(m), + e.map_or(0, |e| e.food_level), + m.extra.age, + join(&slots), + join(&gossips), + e.map_or(0, |e| e.gossips.reputation(PLAYER_UUID)), + match (villager::sleeping(m), m.extra.bed) { + (true, Some(b)) => format!("{},{},{}", b[0], b[1], b[2]), + _ => "-".into(), + } + ); + if let Some(t) = m.extra.trade.as_ref().filter(|t| !t.offers.is_empty()) { + let offers: Vec = t + .offers + .iter() + .map(|o| { + format!( + "{}+{}>{}/{}/{}/{}/{}", + stack(&o.base_cost_a.stack), + o.cost_b + .as_ref() + .map_or_else(|| "-".to_owned(), |c| stack(&c.stack)), + stack(&o.result), + o.uses, + o.max_uses, + o.demand, + o.special_price_diff + ) + }) + .collect(); + s.push_str(&format!(" offers {}", join(&offers))); + } + s +} + fn main() -> horizon_client::Result<()> { let args: Vec = std::env::args().skip(1).collect(); if args.len() != 3 { @@ -608,7 +782,7 @@ fn main() -> horizon_client::Result<()> { let n: u32 = x[8..].parse().unwrap(); m.extra.leash = Some(horizon_client::mobs::leash::Holder::Mob(100_000 + n)); } - other => panic!("unknown mob flag {other}"), + other => villager_flag(&mut m, other), } } m.random = LegacyRandom::new(spec.seed); @@ -657,7 +831,7 @@ fn main() -> horizon_client::Result<()> { velocity: Vec3::ZERO, yaw: 0.0, hero: false, - uuid: [0, 0x1234, 0, 0x5678], + uuid: PLAYER_UUID, allies: Default::default(), } }); @@ -767,6 +941,7 @@ fn main() -> horizon_client::Result<()> { #[allow(unused_mut)] // filled only with the rng-trace feature let mut traces: Vec = Vec::new(); let mut pushes = Vec::new(); + let mut born = Vec::new(); for i in 0..mobs.len() { if mobs[i].removed { continue; @@ -790,6 +965,16 @@ fn main() -> horizon_client::Result<()> { m.removed = true; } horizon_client::mobs::apply_brain_events(&mut mobs, &mut events, from); + villager_events( + &mut mobs, + &mut events, + from, + &w, + &types, + &items, + &mut born, + s.time, + ); // 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) { @@ -822,6 +1007,7 @@ fn main() -> horizon_client::Result<()> { added.append(&mut host.added); } drop(w); + mobs.append(&mut born); mobs.append(&mut added); for e in &heart_events { match e { diff --git a/crates/horizon-client/src/game/villagers.rs b/crates/horizon-client/src/game/villagers.rs index cbf3d015b..35377a3cc 100644 --- a/crates/horizon-client/src/game/villagers.rs +++ b/crates/horizon-client/src/game/villagers.rs @@ -59,68 +59,13 @@ impl Game<'_> { }; let now = self.world.game_time; let items = &self.res.items; - let max = |item: &str| items.get(item).map_or(64, |i| i.max_stack); - // Villager.gossip: both must be past their cool-down. - let ready = { - let ea = villager::ext(&self.mobs[ia]); - let eb = villager::ext(&self.mobs[ib]); - ea.is_none_or(|e| e.can_gossip(now)) && eb.is_none_or(|e| e.can_gossip(now)) - }; - let mut golem = false; - if ready { - let source = villager::ext(&self.mobs[ib]).cloned().unwrap_or_default(); - let me = &mut self.mobs[ia]; - let mut random = me.random.clone(); - let e = villager::ext_mut(me); - e.gossips.transfer_from(&source.gossips, &mut random, 10); - e.last_gossip_time = now; - me.random = random; - villager::ext_mut(&mut self.mobs[ib]).last_gossip_time = now; - golem = true; + let meeting = villager::meet(&mut self.mobs, ia, ib, now, |item| { + items.get(item).map_or(64, |i| i.max_stack) + }); + for stack in meeting.thrown { + self.villager_throw(meeting.from, meeting.eye, meeting.to, stack); } - // Surplus food goes to a hungry neighbour (farmers hand it to anyone). - let farmer = villager::is_farmer(&self.mobs[ia]); - let (from, eye, to) = ( - self.mobs[ia].position, - self.mobs[ia].eye_y(), - self.mobs[ib].position, - ); - let wants_more = villager::ext(&self.mobs[ib]).is_none_or(|e| e.wants_more_food()); - let excess = villager::ext(&self.mobs[ia]).is_some_and(|e| e.has_excess_food()); - let mut thrown = Vec::new(); - if excess - && (farmer || wants_more) - && let Some(s) = villager::ext_mut(&mut self.mobs[ia]) - .take_half_stack(|s| villager::food_points(&s.item) > 0, max) - { - thrown.push(s); - } - // A farmer's wheat. - if farmer - && villager::ext(&self.mobs[ia]).is_some_and(|e| e.count_item("minecraft:wheat") > 32) - && let Some(s) = villager::ext_mut(&mut self.mobs[ia]) - .take_half_stack(|s| &*s.item == "minecraft:wheat", max) - { - thrown.push(s); - } - // Wares the neighbour's profession asks for and ours does not. - let theirs = villager::requested_items(&self.mobs[ib]); - let mine = villager::requested_items(&self.mobs[ia]); - let wanted: Vec<&str> = theirs - .iter() - .copied() - .filter(|i| !mine.contains(i)) - .collect(); - if !wanted.is_empty() - && let Some(s) = villager::ext_mut(&mut self.mobs[ia]) - .take_half_stack(|s| wanted.contains(&&*s.item), max) - { - thrown.push(s); - } - for stack in thrown { - self.villager_throw(from, eye, to, stack); - } - if golem { + if meeting.gossiped { self.villager_golem_check(a, 5); } } @@ -269,41 +214,18 @@ impl Game<'_> { } /// `PoiManager.take(HOME, ..., 48)`: the nearest unclaimed bed head. fn take_vacant_bed(&self, from: [i32; 3]) -> Option<[i32; 3]> { - let claimed: Vec<[i32; 3]> = self - .mobs - .iter() - .filter(|m| m.species() == Species::Villager) - .filter_map(|m| m.extra.bed) - .collect(); let mut known: HashMap = HashMap::new(); - let mut best: Option<(i32, [i32; 3])> = None; - for y in from[1] - 8..=from[1] + 8 { - for z in from[2] - 48..=from[2] + 48 { - for x in from[0] - 48..=from[0] + 48 { - let state = self.world.block(x, y, z); - if self.res.facts.is_air(state) { - continue; - } - let free_head = *known.entry(state.0).or_insert_with(|| { - self.res.facts.get(state).name.ends_with("_bed") - && self.res.assets.registry.state(state).is_some_and(|s| { - s.properties.get("part").map(String::as_str) == Some("head") - && s.properties.get("occupied").map(String::as_str) - != Some("true") - }) - }); - let d = (x - from[0]).pow(2) + (y - from[1]).pow(2) + (z - from[2]).pow(2); - if free_head - && d <= 48 * 48 - && !claimed.contains(&[x, y, z]) - && best.is_none_or(|(b, _)| d < b) - { - best = Some((d, [x, y, z])); - } - } - } - } - best.map(|(_, p)| p) + villager::take_vacant_bed(&self.mobs, from, |x, y, z| { + let state = self.world.block(x, y, z); + !self.res.facts.is_air(state) + && *known.entry(state.0).or_insert_with(|| { + self.res.facts.get(state).name.ends_with("_bed") + && self.res.assets.registry.state(state).is_some_and(|s| { + s.properties.get("part").map(String::as_str) == Some("head") + && s.properties.get("occupied").map(String::as_str) != Some("true") + }) + }) + }) } fn particles_at(&mut self, kind: &'static str, at: [f64; 3]) { if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) { diff --git a/crates/horizon-client/src/gossip.rs b/crates/horizon-client/src/gossip.rs index 63cc7e265..9a964a3e6 100644 --- a/crates/horizon-client/src/gossip.rs +++ b/crates/horizon-client/src/gossip.rs @@ -110,6 +110,15 @@ impl Gossips { pub fn clear(&mut self) { self.map.clear(); } + /// Every (target, type, value) held. + pub fn entries(&self) -> impl Iterator + '_ { + self.map.iter().flat_map(|(t, e)| { + GossipType::ALL + .into_iter() + .filter(move |k| e[k.index()] != 0) + .map(move |k| (*t, k, e[k.index()])) + }) + } pub fn get(&self, target: Target, kind: GossipType) -> i32 { self.map.get(&target).map_or(0, |e| e[kind.index()]) } diff --git a/crates/horizon-client/src/mobs.rs b/crates/horizon-client/src/mobs.rs index 33626e8fb..d4168c404 100644 --- a/crates/horizon-client/src/mobs.rs +++ b/crates/horizon-client/src/mobs.rs @@ -1054,6 +1054,7 @@ pub fn apply_brain_events(mobs: &mut [Mob], events: &mut Vec, from: us MobEvent::LockGaze { mob, partner } => { if let Some(m) = mobs.iter_mut().find(|m| m.id == mob) { animal_brain::lock_gaze(m, partner); + villager_brain::lock_gaze_half(m, Who::Mob(partner)); } events.remove(i); } diff --git a/crates/horizon-client/src/mobs/villager.rs b/crates/horizon-client/src/mobs/villager.rs index 5f26183b8..4b344a0d3 100644 --- a/crates/horizon-client/src/mobs/villager.rs +++ b/crates/horizon-client/src/mobs/villager.rs @@ -536,6 +536,109 @@ pub fn seen(m: &Mob) -> Seen { golem_detected, } } +/// What `TradeWithVillager.tick` hands over: stacks tossed from the first +/// villager's hand (`from`, its eye height) toward the second (`to`), and +/// whether the gossip happened (`spawnGolemIfNeeded` follows). +pub struct Meeting { + pub thrown: Vec, + pub from: horizon_core::geometry::Vec3, + pub eye: f64, + pub to: horizon_core::geometry::Vec3, + pub gossiped: bool, +} +/// `TradeWithVillager.tick` for villagers `a` and `b` (indices into `mobs`): +/// `Villager.gossip` (at most once in 1200 ticks for both), then surplus +/// food and wanted wares taken out of `a`'s inventory. +pub fn meet( + mobs: &mut [Mob], + a: usize, + b: usize, + now: i64, + max_stack: impl Fn(&str) -> u32, +) -> Meeting { + let ready = ext(&mobs[a]).is_none_or(|e| e.can_gossip(now)) + && ext(&mobs[b]).is_none_or(|e| e.can_gossip(now)); + if ready { + let source = ext(&mobs[b]).map(|e| e.gossips.clone()).unwrap_or_default(); + let me = &mut mobs[a]; + let mut random = me.random.clone(); + let e = ext_mut(me); + e.gossips.transfer_from(&source, &mut random, 10); + e.last_gossip_time = now; + me.random = random; + ext_mut(&mut mobs[b]).last_gossip_time = now; + } + // Surplus food goes to a hungry neighbour (farmers hand it to anyone). + let farmer = is_farmer(&mobs[a]); + let wants_more = ext(&mobs[b]).is_none_or(Ext::wants_more_food); + let excess = ext(&mobs[a]).is_some_and(Ext::has_excess_food); + let mut thrown = Vec::new(); + if excess + && (farmer || wants_more) + && let Some(s) = + ext_mut(&mut mobs[a]).take_half_stack(|s| food_points(&s.item) > 0, &max_stack) + { + thrown.push(s); + } + // A farmer's wheat. + if farmer + && ext(&mobs[a]).is_some_and(|e| e.count_item("minecraft:wheat") > 32) + && let Some(s) = + ext_mut(&mut mobs[a]).take_half_stack(|s| &*s.item == "minecraft:wheat", &max_stack) + { + thrown.push(s); + } + // Wares the neighbour's profession asks for and ours does not. + let theirs = requested_items(&mobs[b]); + let mine = requested_items(&mobs[a]); + let wanted: Vec<&str> = theirs + .iter() + .copied() + .filter(|i| !mine.contains(i)) + .collect(); + if !wanted.is_empty() + && let Some(s) = + ext_mut(&mut mobs[a]).take_half_stack(|s| wanted.contains(&&*s.item), &max_stack) + { + thrown.push(s); + } + Meeting { + thrown, + from: mobs[a].position, + eye: mobs[a].eye_y(), + to: mobs[b].position, + gossiped: ready, + } +} +/// `PoiManager.take(HOME, ..., 48)`: the nearest bed head no villager has +/// claimed (`free_head`: a bed head that is not occupied). +pub fn take_vacant_bed( + mobs: &[Mob], + from: [i32; 3], + mut free_head: impl FnMut(i32, i32, i32) -> bool, +) -> Option<[i32; 3]> { + let claimed: Vec<[i32; 3]> = mobs + .iter() + .filter(|m| m.species() == Species::Villager) + .filter_map(|m| m.extra.bed) + .collect(); + let mut best: Option<(i32, [i32; 3])> = None; + for y in from[1] - 8..=from[1] + 8 { + for z in from[2] - 48..=from[2] + 48 { + for x in from[0] - 48..=from[0] + 48 { + let d = (x - from[0]).pow(2) + (y - from[1]).pow(2) + (z - from[2]).pow(2); + if d <= 48 * 48 + && best.is_none_or(|(b, _)| d < b) + && free_head(x, y, z) + && !claimed.contains(&[x, y, z]) + { + best = Some((d, [x, y, z])); + } + } + } + } + best.map(|(_, p)| p) +} /// `Villager.canBreed`: enough food, awake and an adult. pub fn can_breed(m: &Mob) -> bool { m.species() == Species::Villager diff --git a/crates/horizon-client/src/mobs/villager_brain.rs b/crates/horizon-client/src/mobs/villager_brain.rs index 987dca76f..aefaaf3e4 100644 --- a/crates/horizon-client/src/mobs/villager_brain.rs +++ b/crates/horizon-client/src/mobs/villager_brain.rs @@ -1609,13 +1609,7 @@ impl B { } t.begin(cx); let target = mem(m).interaction_target.value().unwrap(); - let mm = mem(m); - mm.look_target.set(Tracker::Entity(target, true)); - mm.walk_target.set(WalkTarget { - target: Tracker::Entity(target, true), - speed: 0.5, - close: 2, - }); + lock_gaze(m, target, cx); true } B::MakeLove { t, birth } => { @@ -1628,7 +1622,7 @@ impl B { } t.begin(cx); let target = mem(m).breed_target.value().unwrap(); - lock_gaze(m, target); + lock_gaze(m, target, cx); *birth = now + 275 + i64::from(m.random.next_int_bound(50).unwrap_or(0)); true } @@ -2853,6 +2847,7 @@ impl B { && i.position.distance_squared(m.position) <= 5.0 { let Who::Mob(other) = target else { return }; + lock_gaze(m, target, cx); cx.events.push(MobEvent::VillagerMeet { mob: m.id, other }); } } @@ -2870,7 +2865,7 @@ impl B { .target_info(target) .is_some_and(|t| t.position.distance_squared(m.position) <= 5.0) { - lock_gaze(m, target); + lock_gaze(m, target, cx); if now >= *birth { cx.events.push(MobEvent::VillagerBirth { parent: m.id, @@ -3366,8 +3361,23 @@ fn breeding_possible(m: &mut Mob, w: &MobWorld) -> bool { && super::villager::can_breed(m) && w.seen(id).is_some_and(|s| s.in_love) } -/// `BehaviorUtils.lockGazeAndWalkToEachOther`, this villager's half. -fn lock_gaze(m: &mut Mob, target: Who) { +/// `BehaviorUtils.lockGazeAndWalkToEachOther`: this villager's half, and +/// the other villager's through a `LockGaze` event. +fn lock_gaze(m: &mut Mob, target: Who, cx: &mut Bx) { + lock_gaze_half(m, target); + if let Who::Mob(other) = target { + cx.events.push(MobEvent::LockGaze { + mob: other, + partner: m.id, + }); + } +} +/// One villager's half of `lockGazeAndWalkToEachOther`: look at the other +/// and walk to it. +pub fn lock_gaze_half(m: &mut Mob, target: Who) { + if super::villager::ext(m).is_none_or(|e| e.brain.is_none()) { + return; + } let mm = mem(m); mm.look_target.set(Tracker::Entity(target, true)); mm.walk_target.set(WalkTarget { 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 b9c93ae42..d16869cc8 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaMobAiOracle.java @@ -779,10 +779,37 @@ public final class VanillaMobAiOracle { } static void seedGate(Object behavior, long seed) throws Exception { - if (!(behavior instanceof GateBehavior)) return; - ShufflingList list = (ShufflingList) field(GateBehavior.class, "behaviors").get(behavior); - field(ShufflingList.class, "random").set(list, new net.minecraft.world.level.levelgen.LegacyRandomSource(seed)); - for (Object child : list) seedGate(child, seed); + seedLists(behavior, seed, java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<>()), 0); + } + + /** + * Seeds every ShufflingList a behaviour holds: a GateBehavior's, and the ones TriggerGate + * captures in its lambdas (BehaviorBuilder's one-shots), found through their fields. + */ + static void seedLists(Object o, long seed, Set seen, int depth) throws Exception { + if (o == null || depth > 8 || !seen.add(o)) return; + if (o instanceof ShufflingList list) { + field(ShufflingList.class, "random").set(list, new net.minecraft.world.level.levelgen.LegacyRandomSource(seed)); + for (Object child : list) seedLists(child, seed, seen, depth + 1); + return; + } + String name = o.getClass().getName(); + if (!name.startsWith("net.minecraft.world.entity.ai.behavior") || o instanceof Enum) return; + for (Class c = o.getClass(); c != null && c.getName().startsWith("net.minecraft"); c = c.getSuperclass()) { + for (Field f : c.getDeclaredFields()) { + if (java.lang.reflect.Modifier.isStatic(f.getModifiers()) || f.getType().isPrimitive()) continue; + f.setAccessible(true); + Object v = f.get(o); + if (v instanceof Iterable it && !(v instanceof ShufflingList)) { + for (Object x : it) seedLists(x, seed, seen, depth + 1); + } else if (v instanceof com.mojang.datafixers.util.Pair pair) { + seedLists(pair.getFirst(), seed, seen, depth + 1); + seedLists(pair.getSecond(), seed, seen, depth + 1); + } else { + seedLists(v, seed, seen, depth + 1); + } + } + } } static String who(Entity e) { @@ -880,7 +907,7 @@ public final class VanillaMobAiOracle { mem.sort(null); sb.append("\tmem ").append(String.join(" ", mem)); } - if (m instanceof Villager v) sb.append("\tvx ").append(villager(v)); + if (m instanceof Villager villager) sb.append("\tvx ").append(villager(villager)); out.println(sb); } diff --git a/tools/test_mob_ai_parity.py b/tools/test_mob_ai_parity.py index d9c1594a9..691c1ada7 100644 --- a/tools/test_mob_ai_parity.py +++ b/tools/test_mob_ai_parity.py @@ -77,6 +77,34 @@ def scenarios(): 'player 12.5 -60 0.5', 'mob minecraft:villager 0.5 -60 0.5 0 51 persistent', ]) + # Two villagers gossip (TradeWithVillager): what one heard of the player + # passes to the other, weakened, once in 1200 ticks; idle and at the bell. + gossips = ('gossip=player:minor_negative:100 gossip=player:major_positive:15 ' + 'gossip=player:trading:20 gossip=player:minor_positive:3') + for name, opts, extra in [('villager_gossip_idle', 'time=100', []), + ('villager_gossip_bell', 'time=9500', ['block 0 -60 -6 minecraft:bell'])]: + add(name, 400, extra + [ + 'player 14.5 -60 0.5', + f'mob minecraft:villager 0.5 -60 0.5 0 61 persistent {gossips}', + 'mob minecraft:villager 2.5 -60 0.5 180 62 persistent gossip=player:minor_positive:50', + ], opts) + # Two villagers with bread breed (VillagerMakeLove): they eat, a baby is + # born and takes a free bed, the parents rest for 6000 ticks. + beds = [] + for x in (-6, -3, 3, 6): + beds += [f'block {x} -60 6 minecraft:red_bed[facing=north,part=foot]', + f'block {x} -60 5 minecraft:red_bed[facing=north,part=head]'] + for name, seeds in [('villager_breed', (71, 72)), ('villager_breed_2', (73, 74))]: + add(name, 900, beds + [ + 'player 14.5 -60 0.5', + f'mob minecraft:villager 0.5 -60 0.5 0 {seeds[0]} persistent inv=bread*3', + f'mob minecraft:villager 2.5 -60 0.5 180 {seeds[1]} persistent inv=bread*3 food=4', + ], 'time=100') + # Too little food: no breeding. + add('villager_breed_hungry', 400, beds[:2] + [ + 'mob minecraft:villager 0.5 -60 0.5 0 75 persistent inv=bread*2', + 'mob minecraft:villager 2.5 -60 0.5 180 76 persistent inv=bread*3', + ], 'time=100') # Breezes: idle, and fighting a player near, in, and beyond the inner jump circle. add('breeze_alone', 200, ['mob minecraft:breeze 0.5 -60 0.5 90 61 persistent']) add('breeze_player', 200, ['player 8.5 -60 0.5', 'mob minecraft:breeze 0.5 -60 0.5 0 62 persistent'])