Compare villager gossip and breeding with vanilla
Gossip and gifts between villagers (TradeWithVillager) move into the library so the mob_ai probe runs them as the game does; both villagers now lock their gaze on each other, as lockGazeAndWalkToEachOther does. The probe reads the oracle's villager flags, prints villager data (food, inventory, gossip, reputation) and adds babies as they are born. The oracle seeds TriggerGate's shuffles too, which were left to the clock. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -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<Mob>,
|
||||
events: &mut Vec<MobEvent>,
|
||||
from: usize,
|
||||
w: &MobWorld,
|
||||
types: &MobTypes,
|
||||
items: &Items,
|
||||
born: &mut Vec<Mob>,
|
||||
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<String> = (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<String> = 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<String> = 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<String> = 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<String> = 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 {
|
||||
|
||||
@@ -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<u32, bool> = 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) {
|
||||
|
||||
@@ -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<Item = (Target, GossipType, i32)> + '_ {
|
||||
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()])
|
||||
}
|
||||
|
||||
@@ -1054,6 +1054,7 @@ pub fn apply_brain_events(mobs: &mut [Mob], events: &mut Vec<MobEvent>, 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);
|
||||
}
|
||||
|
||||
@@ -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<ItemStack>,
|
||||
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
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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<Object> 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);
|
||||
}
|
||||
|
||||
|
||||
@@ -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'])
|
||||
|
||||
Reference in New Issue
Block a user