Merge branch 'parity/villager-social' into parity-base
This commit is contained in:
@@ -223,56 +223,133 @@ 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 [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,
|
||||
child,
|
||||
} => {
|
||||
events.remove(i);
|
||||
let (Some(a), Some(b)) = (index(mobs, parent), index(mobs, partner)) else {
|
||||
continue;
|
||||
};
|
||||
villager::ext_mut(&mut mobs[b]).eat_and_digest();
|
||||
let Some((bed, variant)) = child else {
|
||||
continue;
|
||||
};
|
||||
mobs[b].extra.age = 6000;
|
||||
let index = mobs.len() + born.len();
|
||||
let kind = types.types.get("minecraft:villager").expect("villager");
|
||||
let p = mobs[a].position;
|
||||
let mut child = Mob::new(100_000 + index as u32, Arc::new(kind.clone()), p, 0.0);
|
||||
child.persistent = true;
|
||||
// The flat world is all plains (type 0).
|
||||
child.extra.variant = variant.unwrap_or(0);
|
||||
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 +556,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 +771,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 +820,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 +930,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 +954,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 +996,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 {
|
||||
|
||||
@@ -87,60 +87,7 @@ impl ProjectileWorld for ProjWorld<'_, '_> {
|
||||
}
|
||||
}
|
||||
pub(super) fn seen(m: &Mob, player: Option<[i32; 4]>) -> Seen {
|
||||
let villager = m.species() == Species::Villager;
|
||||
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(),
|
||||
// A villager is "in love" when it is willing to breed (`canBreed`).
|
||||
in_love: if 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: match (villager, player) {
|
||||
(true, Some(uuid)) => {
|
||||
horizon_client::mobs::villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid))
|
||||
}
|
||||
_ => 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,
|
||||
],
|
||||
}
|
||||
m.seen(player)
|
||||
}
|
||||
impl Game<'_> {
|
||||
pub(super) fn player_view(&self) -> Option<PlayerView> {
|
||||
@@ -967,7 +914,11 @@ impl Game<'_> {
|
||||
}
|
||||
MobEvent::CureZombieVillager { mob } => self.cure_zombie_villager(mob),
|
||||
MobEvent::VillagerMeet { mob, other } => self.villager_meet(mob, other),
|
||||
MobEvent::VillagerBirth { parent, partner } => self.villager_birth(parent, partner),
|
||||
MobEvent::VillagerBirth {
|
||||
parent,
|
||||
partner,
|
||||
child,
|
||||
} => self.villager_birth(parent, partner, child),
|
||||
MobEvent::GolemCheck { mob, needed } => self.villager_golem_check(mob, needed),
|
||||
MobEvent::Firework { at, color, flight } => {
|
||||
self.villager_firework(at, color, flight)
|
||||
|
||||
@@ -8,7 +8,6 @@ use horizon_client::{
|
||||
mobs::{Mob, Species, spawning, villager},
|
||||
};
|
||||
use horizon_core::{geometry::Vec3, random::RandomSource};
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn block_of(p: Vec3) -> [i32; 3] {
|
||||
[p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
|
||||
@@ -59,68 +58,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);
|
||||
}
|
||||
}
|
||||
@@ -219,46 +163,39 @@ impl Game<'_> {
|
||||
/// `VillagerMakeLove.tryToGiveBirth`: both eat, a free bed within 48
|
||||
/// blocks is taken for the child, who is a baby villager of one of
|
||||
/// three villager types.
|
||||
pub(super) fn villager_birth(&mut self, parent: u32, partner: u32) {
|
||||
pub(super) fn villager_birth(
|
||||
&mut self,
|
||||
parent: u32,
|
||||
partner: u32,
|
||||
child: Option<([i32; 3], Option<u8>)>,
|
||||
) {
|
||||
let (Some(ia), Some(ib)) = (self.villager_index(parent), self.villager_index(partner))
|
||||
else {
|
||||
return;
|
||||
};
|
||||
villager::ext_mut(&mut self.mobs[ia]).eat_and_digest();
|
||||
villager::ext_mut(&mut self.mobs[ib]).eat_and_digest();
|
||||
let from = self.mobs[ia].position;
|
||||
let angry = |g: &mut Self| {
|
||||
let Some((bed, variant)) = child else {
|
||||
for i in [ia, ib] {
|
||||
let p = g.mobs[i].position;
|
||||
g.particles_at("angry_villager", [p.x, p.y + 1.8, p.z]);
|
||||
let p = self.mobs[i].position;
|
||||
self.particles_at("angry_villager", [p.x, p.y + 1.8, p.z]);
|
||||
}
|
||||
};
|
||||
let Some(bed) = self.take_vacant_bed(block_of(from)) else {
|
||||
angry(self);
|
||||
return;
|
||||
};
|
||||
// Villager.getBreedOffspring: half the biome's type, a quarter each parent's.
|
||||
let roll = self.mobs[ia].random.next_double();
|
||||
let kind_of = |m: &Mob| m.extra.variant;
|
||||
let facts = self.biome_facts(
|
||||
from.x.floor() as i32,
|
||||
from.y.floor() as i32,
|
||||
from.z.floor() as i32,
|
||||
);
|
||||
let variant = if roll < 0.5 {
|
||||
let variant = variant.unwrap_or_else(|| {
|
||||
let facts = self.biome_facts(
|
||||
from.x.floor() as i32,
|
||||
from.y.floor() as i32,
|
||||
from.z.floor() as i32,
|
||||
);
|
||||
spawning::villager_type(&facts)
|
||||
} else if roll < 0.75 {
|
||||
kind_of(&self.mobs[ia])
|
||||
} else {
|
||||
kind_of(&self.mobs[ib])
|
||||
};
|
||||
});
|
||||
self.mobs[ib].extra.age = 6000;
|
||||
let Some(id) =
|
||||
self.spawn_mob_for("minecraft:villager", [from.x, from.y, from.z], true, true)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
self.mobs[ia].extra.age = 6000;
|
||||
self.mobs[ib].extra.age = 6000;
|
||||
if let Some(child) = self.mobs.iter_mut().find(|m| m.id == id) {
|
||||
child.extra.variant = variant;
|
||||
child.extra.variant2 = villager::NONE;
|
||||
@@ -267,44 +204,6 @@ impl Game<'_> {
|
||||
}
|
||||
self.particles_at("heart", [from.x, from.y + 1.8, from.z]);
|
||||
}
|
||||
/// `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)
|
||||
}
|
||||
fn particles_at(&mut self, kind: &'static str, at: [f64; 3]) {
|
||||
if let Some(ty) = horizon_client::particles::ParticleType::from_name(kind) {
|
||||
let options = horizon_client::particles::ParticleOptions::simple(ty);
|
||||
|
||||
@@ -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()])
|
||||
}
|
||||
|
||||
@@ -798,10 +798,14 @@ pub enum MobEvent {
|
||||
mob: u32,
|
||||
other: u32,
|
||||
},
|
||||
/// Two villagers make a baby.
|
||||
/// Two villagers make a baby (`VillagerMakeLove.tryToGiveBirth`): the
|
||||
/// parent has eaten and, with a bed for the child, rests; the partner
|
||||
/// eats, and rests too if `child` holds the child's bed and type
|
||||
/// (`None`: the biome's).
|
||||
VillagerBirth {
|
||||
parent: u32,
|
||||
partner: u32,
|
||||
child: Option<([i32; 3], Option<u8>)>,
|
||||
},
|
||||
/// A villager asks whether enough neighbours want an iron golem.
|
||||
GolemCheck {
|
||||
@@ -936,11 +940,65 @@ pub struct Seen {
|
||||
/// `render::PROFESSIONS`), a llama's strength. And a villager's experience.
|
||||
pub profession: u8,
|
||||
pub xp: i32,
|
||||
/// What other villagers read of a villager's state and brain.
|
||||
pub villager: Option<Arc<villager::Seen>>,
|
||||
/// `MAX_HEALTH`, `JUMP_STRENGTH` and `MOVEMENT_SPEED` base values (a
|
||||
/// horse's breeding stock).
|
||||
pub stats: [f64; 3],
|
||||
}
|
||||
impl Mob {
|
||||
/// What other mobs see of this one this tick (`player`: the player's
|
||||
/// UUID, which villagers' reputation is keyed by).
|
||||
pub fn seen(&self, player: Option<[i32; 4]>) -> Seen {
|
||||
let m = self;
|
||||
let villager = m.species() == Species::Villager;
|
||||
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(),
|
||||
// A villager is "in love" when it is willing to breed (`canBreed`).
|
||||
in_love: if villager {
|
||||
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: villager.then_some(m.extra.home).flatten(),
|
||||
bed: villager.then_some(m.extra.bed).flatten(),
|
||||
yaw: m.yaw,
|
||||
velocity: m.velocity,
|
||||
leash: m.extra.leash,
|
||||
caravan: 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: raider::has_active_raid(m),
|
||||
player_rep: match (villager, player) {
|
||||
(true, Some(uuid)) => villager::ext(m).map_or(0, |e| e.gossips.reputation(uuid)),
|
||||
_ => 0,
|
||||
},
|
||||
pushable: m.pushable(),
|
||||
category: m.category(),
|
||||
potential_job: villager_brain::potential_job_site(m),
|
||||
meeting: villager.then_some(m.extra.meeting).flatten(),
|
||||
profession: m.extra.variant2,
|
||||
xp: villager::xp(m),
|
||||
villager: villager.then(|| Arc::new(villager::seen(m))),
|
||||
stats: [
|
||||
f64::from(m.attrs.max_health),
|
||||
m.extra.vector[0],
|
||||
m.attrs.speed,
|
||||
],
|
||||
}
|
||||
}
|
||||
/// `EntityType.getCategory`'s name.
|
||||
pub fn category(&self) -> &'static str {
|
||||
match self.kind.category.as_str() {
|
||||
@@ -1000,6 +1058,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);
|
||||
}
|
||||
|
||||
@@ -132,6 +132,38 @@ impl MobWorld<'_> {
|
||||
.map(|shape| shape.boxes().iter().map(|b| b.move_by(offset)).collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
/// `Level.findSupportingBlock`: of the blocks whose collision shape
|
||||
/// meets `area`, the one whose centre is nearest `from` (ties: the
|
||||
/// greatest by `Vec3i.compareTo`, y then z then x).
|
||||
pub fn supporting_block(&self, area: Aabb, from: Vec3) -> Option<[i32; 3]> {
|
||||
use horizon_core::geometry::Axis;
|
||||
let range = |axis| {
|
||||
(area.min(axis) - 1.0e-7).floor() as i32 - 1
|
||||
..=(area.max(axis) + 1.0e-7).floor() as i32 + 1
|
||||
};
|
||||
let mut best: Option<(f64, [i32; 3])> = None;
|
||||
for y in range(Axis::Y) {
|
||||
for z in range(Axis::Z) {
|
||||
for x in range(Axis::X) {
|
||||
if !self
|
||||
.block_collision_boxes(x, y, z)
|
||||
.iter()
|
||||
.any(|b| b.intersects(area))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let d = (f64::from(x) + 0.5 - from.x).powi(2)
|
||||
+ (f64::from(y) + 0.5 - from.y).powi(2)
|
||||
+ (f64::from(z) + 0.5 - from.z).powi(2);
|
||||
let greater = |b: [i32; 3]| (y, z, x) > (b[1], b[2], b[0]);
|
||||
if best.is_none_or(|(bd, b)| d < bd || d == bd && greater(b)) {
|
||||
best = Some((d, [x, y, z]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
best.map(|(_, p)| p)
|
||||
}
|
||||
pub fn no_collision(&self, b: Aabb) -> bool {
|
||||
let mut scene = SceneCollisions {
|
||||
world: self.world,
|
||||
@@ -346,7 +378,8 @@ impl Mob {
|
||||
let full = (moved.length() * f64::from(0.6_f32)) as f32;
|
||||
let horizontal =
|
||||
((moved.x * moved.x + moved.z * moved.z).sqrt() * f64::from(0.6_f32)) as f32;
|
||||
let on = self.on_pos(1.0e-5);
|
||||
let supporting = self.supporting_block(w, moved);
|
||||
let on = self.supported_on_pos(w, supporting, 1.0e-5);
|
||||
let state = w.world.block(on[0], on[1], on[2]);
|
||||
let climbable = w.facts.get(state).name.as_ref() == "minecraft:powder_snow"
|
||||
|| w.has_tag("minecraft:climbable", &w.facts.get(state).name);
|
||||
@@ -354,7 +387,7 @@ impl Mob {
|
||||
steps.move_dist += if climbable { full } else { horizontal };
|
||||
steps.fly_dist += full;
|
||||
if steps.move_dist > steps.next_step && !w.facts.is_air(state) {
|
||||
let legacy = self.on_pos(0.2);
|
||||
let legacy = self.supported_on_pos(w, supporting, 0.2);
|
||||
let legacy_state = w.world.block(legacy[0], legacy[1], legacy[2]);
|
||||
let produced = !w.facts.is_air(legacy_state)
|
||||
&& (self.on_ground || climbable)
|
||||
@@ -397,6 +430,68 @@ impl Mob {
|
||||
fn fluids_swimming(&self) -> bool {
|
||||
false
|
||||
}
|
||||
/// `Entity.checkSupportingBlock` after a move: on the ground, the block
|
||||
/// under the feet (`mainSupportingBlockPos`), looked for again where
|
||||
/// the mob came from if none is under it now.
|
||||
fn supporting_block(&self, w: &MobWorld, moved: Vec3) -> Option<[i32; 3]> {
|
||||
if !self.on_ground {
|
||||
return None;
|
||||
}
|
||||
let b = self.bounds();
|
||||
use horizon_core::geometry::Axis;
|
||||
let area = Aabb::new(
|
||||
Vec3::new(b.min(Axis::X), b.min(Axis::Y) - 1.0e-6, b.min(Axis::Z)),
|
||||
Vec3::new(b.max(Axis::X), b.min(Axis::Y), b.max(Axis::Z)),
|
||||
);
|
||||
w.supporting_block(area, self.position).or_else(|| {
|
||||
let back = Vec3::new(-moved.x, 0.0, -moved.z);
|
||||
let shifted = Aabb::new(
|
||||
Vec3::new(
|
||||
area.min(Axis::X) + back.x,
|
||||
area.min(Axis::Y),
|
||||
area.min(Axis::Z) + back.z,
|
||||
),
|
||||
Vec3::new(
|
||||
area.max(Axis::X) + back.x,
|
||||
area.max(Axis::Y),
|
||||
area.max(Axis::Z) + back.z,
|
||||
),
|
||||
);
|
||||
w.supporting_block(shifted, self.position)
|
||||
})
|
||||
}
|
||||
/// `Entity.getOnPos(offset)` with a supporting block: its column (its
|
||||
/// own position for fences, walls and gates up to half a block down).
|
||||
fn supported_on_pos(
|
||||
&self,
|
||||
w: &MobWorld,
|
||||
supporting: Option<[i32; 3]>,
|
||||
offset: f32,
|
||||
) -> [i32; 3] {
|
||||
let Some(p) = supporting else {
|
||||
return self.on_pos(offset);
|
||||
};
|
||||
if offset <= 1.0e-5 {
|
||||
return p;
|
||||
}
|
||||
let name = &w.facts.get(w.world.block(p[0], p[1], p[2])).name;
|
||||
let tall = [
|
||||
"minecraft:fences",
|
||||
"minecraft:walls",
|
||||
"minecraft:fence_gates",
|
||||
]
|
||||
.iter()
|
||||
.any(|t| w.has_tag(t, name));
|
||||
if offset <= 0.5 && tall {
|
||||
p
|
||||
} else {
|
||||
[
|
||||
p[0],
|
||||
(self.position.y - f64::from(offset)).floor() as i32,
|
||||
p[2],
|
||||
]
|
||||
}
|
||||
}
|
||||
/// Entity.getOnPos(offset) without a supporting block record.
|
||||
pub fn on_pos(&self, offset: f32) -> [i32; 3] {
|
||||
[
|
||||
|
||||
@@ -496,6 +496,144 @@ impl Ext {
|
||||
now < self.last_gossip_time || now >= self.last_gossip_time + 1200
|
||||
}
|
||||
}
|
||||
/// What a villager ticking later reads of another one this tick (vanilla
|
||||
/// reads the other villager itself).
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Seen {
|
||||
pub gossips: crate::gossip::Gossips,
|
||||
pub last_gossip_time: i64,
|
||||
/// `countFoodPointsInInventory`.
|
||||
pub food_points: i32,
|
||||
/// The `INTERACTION_TARGET` memory (play tag's chases).
|
||||
pub interaction_target: Option<super::Who>,
|
||||
/// The `PATH` memory, when not done: its previous and next nodes.
|
||||
pub path_nodes: Option<(Option<[i32; 3]>, [i32; 3])>,
|
||||
/// `LAST_SLEPT` and whether `GOLEM_DETECTED_RECENTLY` is remembered.
|
||||
pub last_slept: Option<i64>,
|
||||
pub golem_detected: bool,
|
||||
}
|
||||
impl Seen {
|
||||
/// `Villager.wantsToSpawnGolem`.
|
||||
pub fn wants_golem(&self, now: i64) -> bool {
|
||||
self.last_slept.is_some_and(|t| now - t < 24000) && !self.golem_detected
|
||||
}
|
||||
/// `Villager.wantsMoreFood`.
|
||||
pub fn wants_more_food(&self) -> bool {
|
||||
self.food_points < 12
|
||||
}
|
||||
}
|
||||
pub fn seen(m: &Mob) -> Seen {
|
||||
let e = ext(m);
|
||||
let (interaction_target, path_nodes, golem_detected, last_slept) =
|
||||
super::villager_brain::seen_memories(m);
|
||||
Seen {
|
||||
gossips: e.map(|e| e.gossips.clone()).unwrap_or_default(),
|
||||
last_gossip_time: e.map_or(0, |e| e.last_gossip_time),
|
||||
food_points: e.map_or(0, Ext::food_in_inventory),
|
||||
interaction_target,
|
||||
path_nodes,
|
||||
last_slept: last_slept.or(e.and_then(|e| e.last_slept)),
|
||||
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 not `claimed`
|
||||
/// (`free_head`: a bed head that is not occupied).
|
||||
pub fn take_vacant_bed(
|
||||
claimed: &[[i32; 3]],
|
||||
from: [i32; 3],
|
||||
mut free_head: impl FnMut(i32, i32, i32) -> bool,
|
||||
) -> Option<[i32; 3]> {
|
||||
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
|
||||
|
||||
@@ -663,7 +663,7 @@ fn sense_bed(m: &mut Mob, w: &MobWorld, lr: &mut LegacyRandom) {
|
||||
let mut cache = std::mem::take(&mut brain_mut(m).bed_cache);
|
||||
let mut tried = 0;
|
||||
let mut targets = Vec::new();
|
||||
for p in homes {
|
||||
for &p in &homes {
|
||||
if cache.iter().any(|(q, _)| *q == p) {
|
||||
continue;
|
||||
}
|
||||
@@ -679,8 +679,12 @@ fn sense_bed(m: &mut Mob, w: &MobWorld, lr: &mut LegacyRandom) {
|
||||
} else {
|
||||
m.create_path_to_any(w, &targets, 1)
|
||||
};
|
||||
// createPath hands back the current path when it still heads for a
|
||||
// target position it was asked: only a bed (a POI) counts.
|
||||
if let Some(path) = path.filter(|p| p.reached) {
|
||||
mem(m).nearest_bed.set(path.target);
|
||||
if homes.contains(&path.target) {
|
||||
mem(m).nearest_bed.set(path.target);
|
||||
}
|
||||
} else if tried < 5 {
|
||||
cache.retain(|(_, until)| *until >= last_update);
|
||||
}
|
||||
@@ -1609,13 +1613,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 +1626,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 +2851,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,11 +2869,29 @@ 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 {
|
||||
// The parent's half happens in its own tick: it eats,
|
||||
// takes a bed for the child, picks its type and rests.
|
||||
super::villager::ext_mut(m).eat_and_digest();
|
||||
let child = take_bed_for_child(m, cx.w).map(|bed| {
|
||||
// Villager.getBreedOffspring: half the biome's type,
|
||||
// a quarter each parent's.
|
||||
let roll = m.random.next_double();
|
||||
let variant = if roll < 0.5 {
|
||||
None
|
||||
} else if roll < 0.75 {
|
||||
Some(m.extra.variant)
|
||||
} else {
|
||||
Some(cx.w.seen(partner).map_or(m.extra.variant, |s| s.variant))
|
||||
};
|
||||
m.extra.age = 6000;
|
||||
(bed, variant)
|
||||
});
|
||||
cx.events.push(MobEvent::VillagerBirth {
|
||||
parent: m.id,
|
||||
partner,
|
||||
child,
|
||||
});
|
||||
} else if m.random.next_int_bound(35).unwrap_or(1) == 0 {
|
||||
let mut p = vec![m.position];
|
||||
@@ -3366,8 +3383,38 @@ 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) {
|
||||
/// `VillagerMakeLove.takeVacantBed`: a bed head no villager has claimed.
|
||||
fn take_bed_for_child(m: &Mob, w: &MobWorld) -> Option<[i32; 3]> {
|
||||
let claimed: Vec<[i32; 3]> = w
|
||||
.others
|
||||
.iter()
|
||||
.filter(|s| s.species == Species::Villager && s.id != m.id)
|
||||
.filter_map(|s| s.bed)
|
||||
.chain(m.extra.bed)
|
||||
.collect();
|
||||
let p = m.position;
|
||||
let from = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
|
||||
super::villager::take_vacant_bed(&claimed, from, |x, y, z| {
|
||||
w.prop(x, y, z, "part") == Some("head") && w.prop(x, y, z, "occupied") != Some("true")
|
||||
})
|
||||
}
|
||||
/// `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 {
|
||||
@@ -4080,3 +4127,34 @@ pub fn potential_job_site(m: &Mob) -> Option<[i32; 3]> {
|
||||
pub fn seen_can_breed(s: &Seen) -> bool {
|
||||
s.species == Species::Villager && s.in_love
|
||||
}
|
||||
/// The memories other villagers read: the interaction target, the path's
|
||||
/// nodes (while it is not done), whether a golem was seen lately and the
|
||||
/// last sleep.
|
||||
#[allow(clippy::type_complexity)]
|
||||
pub fn seen_memories(
|
||||
m: &Mob,
|
||||
) -> (
|
||||
Option<Who>,
|
||||
Option<(Option<[i32; 3]>, [i32; 3])>,
|
||||
bool,
|
||||
Option<i64>,
|
||||
) {
|
||||
let Some(mm) = mem_ref(m) else {
|
||||
return (None, None, false, None);
|
||||
};
|
||||
let path = mm
|
||||
.path
|
||||
.present()
|
||||
.then_some(m.ai.nav.path.as_ref())
|
||||
.flatten();
|
||||
let nodes = path.filter(|p| !p.is_done()).map(|p| {
|
||||
let n = |i: usize| [p.nodes[i].x, p.nodes[i].y, p.nodes[i].z];
|
||||
((p.next > 0).then(|| n(p.next - 1)), n(p.next))
|
||||
});
|
||||
(
|
||||
mm.interaction_target.value(),
|
||||
nodes,
|
||||
mm.golem_detected_recently.present(),
|
||||
mm.last_slept.value(),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -67,6 +67,8 @@ import net.minecraft.world.entity.LivingEntity;
|
||||
import net.minecraft.world.entity.player.Player;
|
||||
import net.minecraft.world.entity.Mob;
|
||||
import net.minecraft.world.entity.AgeableMob;
|
||||
import net.minecraft.world.entity.item.ItemEntity;
|
||||
import net.minecraft.world.entity.npc.villager.Villager;
|
||||
import net.minecraft.world.entity.ai.Brain;
|
||||
import net.minecraft.world.entity.ai.behavior.BehaviorControl;
|
||||
import net.minecraft.world.entity.ai.behavior.BlockPosTracker;
|
||||
@@ -140,6 +142,10 @@ public final class VanillaMobAiOracle {
|
||||
}
|
||||
}
|
||||
static final List<String> TRACE = new ArrayList<>();
|
||||
/** The entities a scenario ticks, in order: its mobs, then what they spawned. */
|
||||
static final List<Entity> ENTS = new ArrayList<>();
|
||||
static final Map<Entity, Integer> LABELS = new java.util.IdentityHashMap<>();
|
||||
static final UUID PLAYER_UUID = new UUID(0x1234L, 0x5678L);
|
||||
|
||||
static final class MobSpec {
|
||||
String type;
|
||||
@@ -166,6 +172,12 @@ public final class VanillaMobAiOracle {
|
||||
String hand;
|
||||
List<MobSpec> mobs = new ArrayList<>();
|
||||
long levelSeed = 0;
|
||||
/** The day time advances with the game time (sleeping, waking). */
|
||||
boolean daycycle;
|
||||
/** Blocks changed before a given tick: (tick, block or fill line). */
|
||||
List<Object[]> timed = new ArrayList<>();
|
||||
/** Boxes whose block changes are printed every tick. */
|
||||
List<int[]> watches = new ArrayList<>();
|
||||
/** Blocks placed when the scenario starts, so their block entities start afresh and tick. */
|
||||
List<String[]> hearts = new ArrayList<>();
|
||||
/** ServerLevel.isSpawningMonsters during the scenario (a heart spawns creakings). */
|
||||
@@ -192,6 +204,7 @@ public final class VanillaMobAiOracle {
|
||||
case "rain" -> s.rain = true;
|
||||
case "thunder" -> s.thunder = true;
|
||||
case "levelseed" -> s.levelSeed = Long.parseLong(kv[1]);
|
||||
case "daycycle" -> s.daycycle = true;
|
||||
case "spawning" -> s.spawning = true;
|
||||
default -> throw new IllegalArgumentException(line);
|
||||
}
|
||||
@@ -199,6 +212,12 @@ public final class VanillaMobAiOracle {
|
||||
}
|
||||
case "origin" -> { s.originX = Integer.parseInt(f[1]); s.originZ = Integer.parseInt(f[2]); }
|
||||
case "fill", "block" -> s.blocks.add(f);
|
||||
case "at" -> s.timed.add(new Object[] {Integer.parseInt(f[1]), java.util.Arrays.copyOfRange(f, 2, f.length)});
|
||||
case "watch" -> {
|
||||
int[] box = new int[6];
|
||||
for (int i = 0; i < 6; i++) box[i] = Integer.parseInt(f[i + 1]);
|
||||
s.watches.add(box);
|
||||
}
|
||||
case "heart" -> s.hearts.add(f);
|
||||
case "hurt" -> s.hurts.add(new int[] {Integer.parseInt(f[1]), Integer.parseInt(f[2])});
|
||||
case "player" -> {
|
||||
@@ -425,8 +444,12 @@ public final class VanillaMobAiOracle {
|
||||
}
|
||||
|
||||
void build(Scenario s, ServerLevel level) throws Exception {
|
||||
for (String[] b : s.blocks) place(b, level);
|
||||
}
|
||||
|
||||
static void place(String[] b, ServerLevel level) throws Exception {
|
||||
var blocks = level.holderLookup(Registries.BLOCK);
|
||||
for (String[] b : s.blocks) {
|
||||
{
|
||||
if (b[0].equals("block")) {
|
||||
BlockState state = BlockStateParser.parseForBlock(blocks, b[4], false).blockState();
|
||||
level.setBlock(new BlockPos(Integer.parseInt(b[1]), Integer.parseInt(b[2]), Integer.parseInt(b[3])), state, 2 | 16);
|
||||
@@ -453,7 +476,7 @@ public final class VanillaMobAiOracle {
|
||||
level.setThunderLevel(s.thunder ? 1.0F : 0.0F);
|
||||
if (s.player != null) {
|
||||
if (player == null) {
|
||||
CommonListenerCookie cookie = CommonListenerCookie.createInitial(new GameProfile(new UUID(0x1234L, 0x5678L), "horizon-ai"), false);
|
||||
CommonListenerCookie cookie = CommonListenerCookie.createInitial(new GameProfile(PLAYER_UUID, "horizon-ai"), false);
|
||||
player = new ServerPlayer(this, level, cookie.gameProfile(), cookie.clientInformation());
|
||||
Connection connection = new Connection(PacketFlow.SERVERBOUND);
|
||||
new EmbeddedChannel(connection);
|
||||
@@ -479,14 +502,15 @@ public final class VanillaMobAiOracle {
|
||||
} else if (player != null) {
|
||||
player.snapTo(s.originX + 5000, -60, s.originZ, 0.0F, 0.0F);
|
||||
}
|
||||
List<Mob> mobs = new ArrayList<>();
|
||||
ENTS.clear();
|
||||
LABELS.clear();
|
||||
List<Brain<?>> brains = new ArrayList<>();
|
||||
List<Long> seeds = new ArrayList<>();
|
||||
int id = 100000;
|
||||
for (MobSpec spec : s.mobs) {
|
||||
EntityType<?> type = BuiltInRegistries.ENTITY_TYPE.getValue(net.minecraft.resources.Identifier.parse(spec.type));
|
||||
Mob mob = (Mob) type.create(level, EntitySpawnReason.COMMAND);
|
||||
if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, mobs.size()));
|
||||
if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, ENTS.size()));
|
||||
mob.setId(id++);
|
||||
mob.snapTo(spec.x, spec.y, spec.z, spec.yaw, 0.0F);
|
||||
mob.setYHeadRot(spec.yaw);
|
||||
@@ -495,36 +519,74 @@ public final class VanillaMobAiOracle {
|
||||
if (mob instanceof AgeableMob a) a.setBaby(true);
|
||||
else mob.setBaby(true);
|
||||
}
|
||||
List<Runnable> afterAdd = new ArrayList<>();
|
||||
for (String flag : spec.flags) {
|
||||
if (flag.equals("persistent")) mob.setPersistenceRequired();
|
||||
else if (flag.equals("noai")) mob.setNoAi(true);
|
||||
else if (flag.equals("inlove")) ((net.minecraft.world.entity.animal.Animal) mob).setInLoveTime(600);
|
||||
else if (flag.equals("tame") && mob instanceof net.minecraft.world.entity.animal.equine.AbstractHorse horse) horse.setTamed(true);
|
||||
else if (flag.startsWith("age=")) ((AgeableMob) mob).setAge(Integer.parseInt(flag.substring(4)));
|
||||
else if (flag.startsWith("strength=")) method(net.minecraft.world.entity.animal.equine.Llama.class, "setStrength", int.class)
|
||||
.invoke(mob, Integer.parseInt(flag.substring(9)));
|
||||
else if (flag.equals("leashed") || flag.startsWith("leashto=")) {
|
||||
// Leashed once every mob exists (below).
|
||||
String[] kv = flag.split("=", 2);
|
||||
String v = kv.length > 1 ? kv[1] : "";
|
||||
switch (kv[0]) {
|
||||
case "persistent" -> mob.setPersistenceRequired();
|
||||
case "noai" -> mob.setNoAi(true);
|
||||
case "profession" -> {
|
||||
Villager villager = (Villager) mob;
|
||||
villager.setVillagerData(villager.getVillagerData().withProfession(level.registryAccess(),
|
||||
ResourceKey.create(Registries.VILLAGER_PROFESSION, net.minecraft.resources.Identifier.withDefaultNamespace(v))));
|
||||
villager.refreshBrain(level);
|
||||
}
|
||||
case "level" -> {
|
||||
Villager villager = (Villager) mob;
|
||||
villager.setVillagerData(villager.getVillagerData().withLevel(Integer.parseInt(v)));
|
||||
}
|
||||
case "xp" -> ((Villager) mob).setVillagerXp(Integer.parseInt(v));
|
||||
case "food" -> field(Villager.class, "foodLevel").setInt(mob, Integer.parseInt(v));
|
||||
case "age" -> ((AgeableMob) mob).setAge(Integer.parseInt(v));
|
||||
case "inv" -> {
|
||||
for (String item : v.split(",")) {
|
||||
String[] ic = item.split("\\*");
|
||||
((Villager) mob).getInventory().addItem(new net.minecraft.world.item.ItemStack(
|
||||
BuiltInRegistries.ITEM.getValue(net.minecraft.resources.Identifier.parse(ic[0])),
|
||||
ic.length > 1 ? Integer.parseInt(ic[1]) : 1));
|
||||
}
|
||||
}
|
||||
case "gossip" -> {
|
||||
// gossip=player:minor_negative:100
|
||||
String[] g = v.split(":");
|
||||
UUID target = g[0].equals("player") ? PLAYER_UUID : UUID.fromString(g[0]);
|
||||
((Villager) mob).getGossips().add(target,
|
||||
net.minecraft.world.entity.ai.gossip.GossipType.valueOf(g[1].toUpperCase(java.util.Locale.ROOT)), Integer.parseInt(g[2]));
|
||||
}
|
||||
case "slept" -> {
|
||||
long at = Long.parseLong(v);
|
||||
afterAdd.add(() -> mob.getBrain().setMemory(MemoryModuleType.LAST_SLEPT, at));
|
||||
}
|
||||
case "inlove" -> ((net.minecraft.world.entity.animal.Animal) mob).setInLoveTime(600);
|
||||
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));
|
||||
case "leashed", "leashto" -> {
|
||||
// Leashed once every mob exists (below).
|
||||
}
|
||||
default -> throw new IllegalArgumentException(flag);
|
||||
}
|
||||
else throw new IllegalArgumentException(flag);
|
||||
}
|
||||
level.addFreshEntity(mob);
|
||||
for (Runnable r : afterAdd) r.run();
|
||||
mob.getRandom().setSeed(spec.seed);
|
||||
Brain<?> brain = mob.getBrain();
|
||||
@SuppressWarnings("unchecked")
|
||||
Map<Object, Sensor<?>> sensors = (Map<Object, Sensor<?>>) get(brain, "sensors");
|
||||
for (Sensor<?> sensor : sensors.values()) sensor.randomlyDelayStart(mob.getRandom());
|
||||
seedGates(brain, spec.seed);
|
||||
mobs.add(mob);
|
||||
LABELS.put(mob, ENTS.size());
|
||||
ENTS.add(mob);
|
||||
brains.add(brain);
|
||||
seeds.add(spec.seed);
|
||||
}
|
||||
// Leads: to the player ("leashed") or to the n-th mob ("leashto=n").
|
||||
for (int i = 0; i < s.mobs.size(); i++) {
|
||||
for (String flag : s.mobs.get(i).flags) {
|
||||
if (flag.equals("leashed")) ((net.minecraft.world.entity.Leashable) mobs.get(i)).setLeashedTo(player, true);
|
||||
else if (flag.startsWith("leashto=")) ((net.minecraft.world.entity.Leashable) mobs.get(i))
|
||||
.setLeashedTo(mobs.get(Integer.parseInt(flag.substring(8))), true);
|
||||
if (flag.equals("leashed")) ((net.minecraft.world.entity.Leashable) ENTS.get(i)).setLeashedTo(player, true);
|
||||
else if (flag.startsWith("leashto=")) ((net.minecraft.world.entity.Leashable) ENTS.get(i))
|
||||
.setLeashedTo(ENTS.get(Integer.parseInt(flag.substring(8))), true);
|
||||
}
|
||||
}
|
||||
// Hearts start with the scenario: their tickers have not run during the warm-up.
|
||||
@@ -541,12 +603,11 @@ public final class VanillaMobAiOracle {
|
||||
List<Mob> created = new ArrayList<>();
|
||||
Field factoryField = field(EntityType.class, "factory");
|
||||
Object creakingFactory = factoryField.get(EntityTypes.CREAKING);
|
||||
final List<Mob> mobsView = mobs;
|
||||
factoryField.set(EntityTypes.CREAKING, (EntityType.EntityFactory<Creaking>) (type, lvl) -> {
|
||||
Creaking c = new Creaking(type, lvl);
|
||||
try {
|
||||
long seed = 1000 + created.size();
|
||||
if (tracing(s)) field(Entity.class, "random").set(c, new TracingRandom(0L, TRACE, mobsView.size() + created.size()));
|
||||
if (tracing(s)) field(Entity.class, "random").set(c, new TracingRandom(0L, TRACE, ENTS.size() + created.size()));
|
||||
c.getRandom().setSeed(seed);
|
||||
@SuppressWarnings("unchecked")
|
||||
Map<Object, Sensor<?>> cs = (Map<Object, Sensor<?>>) get(c.getBrain(), "sensors");
|
||||
@@ -562,14 +623,25 @@ public final class VanillaMobAiOracle {
|
||||
boolean spawnMonsters = this.getGameRules().get(GameRules.SPAWN_MONSTERS);
|
||||
this.getGameRules().set(GameRules.SPAWN_MOBS, s.spawning, this);
|
||||
this.getGameRules().set(GameRules.SPAWN_MONSTERS, s.spawning, this);
|
||||
int adopted = 0;
|
||||
level.getRandom().setSeed(s.levelSeed);
|
||||
// Loot drawn from random sequences starts afresh in every scenario.
|
||||
this.getRandomSequences().clear();
|
||||
SOUNDS.clear();
|
||||
Method tickTime = method(ServerLevel.class, "tickTime");
|
||||
Object manager = get(level, "entityManager");
|
||||
Method managerTick = method(manager.getClass(), "tick");
|
||||
for (int i = 0; i < mobs.size(); i++) print(0, i, mobs.get(i));
|
||||
Map<BlockPos, BlockState> watched = new java.util.LinkedHashMap<>();
|
||||
for (int[] box : s.watches)
|
||||
for (int y = box[1]; y <= box[4]; y++)
|
||||
for (int z = box[2]; z <= box[5]; z++)
|
||||
for (int x = box[0]; x <= box[3]; x++) {
|
||||
BlockPos pos = new BlockPos(x + s.originX, y, z + s.originZ);
|
||||
watched.put(pos, level.getBlockState(pos));
|
||||
}
|
||||
for (int i = 0; i < ENTS.size(); i++) print(0, i, ENTS.get(i));
|
||||
for (int t = 1; t <= s.ticks; t++) {
|
||||
if (s.daycycle) this.clockManager().setTotalTicks(clock, s.time + t);
|
||||
for (Object[] e : s.timed) if ((Integer) e[0] == t) place((String[]) e[1], level);
|
||||
level.environmentAttributes().invalidateTickCache();
|
||||
level.updateSkyBrightness();
|
||||
tickTime.invoke(level);
|
||||
@@ -591,41 +663,78 @@ public final class VanillaMobAiOracle {
|
||||
TracingRandom.tick = t;
|
||||
TracingRandom.on = tracing(s) && t >= traceFrom() && t <= traceTo();
|
||||
SOUNDS.clear();
|
||||
for (int i = 0; i < mobs.size(); i++) {
|
||||
for (int i = 0; i < ENTS.size(); i++) {
|
||||
// Villager.refreshBrain builds a new brain with new gates: seed those too.
|
||||
if (mobs.get(i).getBrain() != brains.get(i)) {
|
||||
brains.set(i, mobs.get(i).getBrain());
|
||||
if (ENTS.get(i) instanceof Mob m && m.getBrain() != brains.get(i)) {
|
||||
brains.set(i, m.getBrain());
|
||||
seedGates(brains.get(i), seeds.get(i));
|
||||
}
|
||||
}
|
||||
for (int[] hurt : s.hurts) {
|
||||
if (hurt[0] == t && hurt[1] < mobs.size() && !mobs.get(hurt[1]).isRemoved())
|
||||
mobs.get(hurt[1]).hurtServer(level, level.damageSources().playerAttack(player), 1.0F);
|
||||
if (hurt[0] == t && hurt[1] < ENTS.size() && ENTS.get(hurt[1]) instanceof LivingEntity hurtMob && !hurtMob.isRemoved())
|
||||
hurtMob.hurtServer(level, level.damageSources().playerAttack(player), 1.0F);
|
||||
}
|
||||
for (Mob mob : mobs) {
|
||||
if (mob.isRemoved()) continue;
|
||||
mob.checkDespawn();
|
||||
if (mob.isRemoved()) continue;
|
||||
level.tickNonPassenger(mob);
|
||||
for (Entity e : List.copyOf(ENTS)) {
|
||||
if (e.isRemoved()) continue;
|
||||
e.checkDespawn();
|
||||
if (e.isRemoved()) continue;
|
||||
level.tickNonPassenger(e);
|
||||
}
|
||||
if (!heartPositions.isEmpty()) level.tickBlockEntities();
|
||||
managerTick.invoke(manager);
|
||||
// Created mobs that made it into the level, in creation order.
|
||||
for (; adopted < created.size(); adopted++) {
|
||||
Mob c = created.get(adopted);
|
||||
if (!c.isRemoved()) {
|
||||
mobs.add(c);
|
||||
brains.add(c.getBrain());
|
||||
seeds.add(1000L + adopted);
|
||||
// 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<Entity> fresh = new ArrayList<>();
|
||||
for (Entity e : level.getAllEntities())
|
||||
if (!LABELS.containsKey(e) && (e instanceof Villager || created.contains(e))) fresh.add(e);
|
||||
fresh.sort(java.util.Comparator.comparingInt(Entity::getId));
|
||||
for (Entity e : fresh) {
|
||||
int index = ENTS.size();
|
||||
int made = created.indexOf(e);
|
||||
if (made >= 0) {
|
||||
// A heart's creaking: seeded when it was created.
|
||||
LABELS.put(e, index);
|
||||
ENTS.add(e);
|
||||
seeds.add(1000L + made);
|
||||
brains.add(((Mob) e).getBrain());
|
||||
continue;
|
||||
}
|
||||
long seed = spawnSeed(index);
|
||||
LABELS.put(e, index);
|
||||
ENTS.add(e);
|
||||
seeds.add(seed);
|
||||
if (e instanceof Mob mob) {
|
||||
// LivingEntity's constructor turns the head at random (Math.random):
|
||||
// face it the way the body does, as the probe's newborns.
|
||||
mob.setYHeadRot(mob.getYRot());
|
||||
mob.yHeadRotO = mob.getYRot();
|
||||
if (tracing(s)) field(Entity.class, "random").set(mob, new TracingRandom(0L, TRACE, index));
|
||||
mob.getRandom().setSeed(seed);
|
||||
@SuppressWarnings("unchecked")
|
||||
Map<Object, Sensor<?>> sensors = (Map<Object, Sensor<?>>) get(mob.getBrain(), "sensors");
|
||||
for (Sensor<?> sensor : sensors.values()) sensor.randomlyDelayStart(mob.getRandom());
|
||||
seedGates(mob.getBrain(), seed);
|
||||
brains.add(mob.getBrain());
|
||||
} else {
|
||||
brains.add(null);
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < mobs.size(); i++) print(t, i, mobs.get(i));
|
||||
for (int i = 0; i < ENTS.size(); i++) print(t, i, ENTS.get(i));
|
||||
for (BlockPos h : heartPositions) printHeart(t, level, h);
|
||||
for (String sound : SOUNDS) out.println(t + " sound " + sound);
|
||||
for (var w : watched.entrySet()) {
|
||||
BlockState now = level.getBlockState(w.getKey());
|
||||
if (now != w.getValue()) {
|
||||
w.setValue(now);
|
||||
BlockPos p = w.getKey();
|
||||
out.println(t + " block " + (p.getX() - s.originX) + "," + p.getY() + "," + (p.getZ() - s.originZ) + " " + stateName(now));
|
||||
}
|
||||
}
|
||||
for (String line : TRACE) out.println(line);
|
||||
TRACE.clear();
|
||||
}
|
||||
for (Mob mob : mobs) mob.discard();
|
||||
for (Entity e : ENTS) e.discard();
|
||||
for (BlockPos h : heartPositions) level.setBlock(h, net.minecraft.world.level.block.Blocks.AIR.defaultBlockState(), 2 | 16);
|
||||
factoryField.set(EntityTypes.CREAKING, creakingFactory);
|
||||
this.getGameRules().set(GameRules.SPAWN_MOBS, spawnMobs, this);
|
||||
@@ -634,6 +743,18 @@ public final class VanillaMobAiOracle {
|
||||
out.flush();
|
||||
}
|
||||
|
||||
/** The random seed of the entity a scenario spawned at this index. */
|
||||
static long spawnSeed(int index) { return 1000L + 7919L * index; }
|
||||
|
||||
static String stateName(BlockState state) {
|
||||
StringBuilder sb = new StringBuilder(BuiltInRegistries.BLOCK.getKey(state.getBlock()).toString());
|
||||
List<String> props = new ArrayList<>();
|
||||
state.getValues().forEach(v -> props.add(v.toString()));
|
||||
props.sort(null);
|
||||
if (!props.isEmpty()) sb.append('[').append(String.join(",", props)).append(']');
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/** A heart's block state and block entity, and the level random. */
|
||||
static void printHeart(int t, ServerLevel level, BlockPos at) throws Exception {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
@@ -663,16 +784,44 @@ 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) {
|
||||
if (e == null) return "none";
|
||||
if (e instanceof ServerPlayer) return "player";
|
||||
return "e" + e.getId();
|
||||
Integer label = LABELS.get(e);
|
||||
return "e" + (label != null ? 100000 + label : e.getId());
|
||||
}
|
||||
|
||||
static String goals(GoalSelector selector) {
|
||||
@@ -705,13 +854,24 @@ public final class VanillaMobAiOracle {
|
||||
return v.getClass().getSimpleName();
|
||||
}
|
||||
|
||||
void print(int t, int i, Mob m) throws Exception {
|
||||
void print(int t, int i, Entity e) throws Exception {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append(t).append(' ').append(i);
|
||||
if (m.isRemoved()) {
|
||||
out.println(sb.append(" removed ").append(m.getRemovalReason()));
|
||||
if (e.isRemoved()) {
|
||||
out.println(sb.append(" removed ").append(e.getRemovalReason()));
|
||||
return;
|
||||
}
|
||||
if (e instanceof ItemEntity item) {
|
||||
sb.append("\tp ").append(d(item.getX())).append(',').append(d(item.getY())).append(',').append(d(item.getZ()));
|
||||
Vec3 v = item.getDeltaMovement();
|
||||
sb.append("\tv ").append(d(v.x)).append(',').append(d(v.y)).append(',').append(d(v.z));
|
||||
sb.append("\tg ").append(item.onGround() ? 1 : 0).append(item.horizontalCollision ? 1 : 0);
|
||||
sb.append("\titem ").append(stack(item.getItem())).append(' ').append(item.getAge()).append(' ')
|
||||
.append(field(ItemEntity.class, "pickupDelay").getInt(item));
|
||||
out.println(sb);
|
||||
return;
|
||||
}
|
||||
Mob m = (Mob) e;
|
||||
sb.append("\tp ").append(d(m.getX())).append(',').append(d(m.getY())).append(',').append(d(m.getZ()));
|
||||
Vec3 v = m.getDeltaMovement();
|
||||
sb.append("\tv ").append(d(v.x)).append(',').append(d(v.y)).append(',').append(d(v.z));
|
||||
@@ -752,9 +912,52 @@ public final class VanillaMobAiOracle {
|
||||
mem.sort(null);
|
||||
sb.append("\tmem ").append(String.join(" ", mem));
|
||||
}
|
||||
if (m instanceof Villager villager) sb.append("\tvx ").append(villager(villager));
|
||||
out.println(sb);
|
||||
}
|
||||
|
||||
static String stack(net.minecraft.world.item.ItemStack stack) {
|
||||
if (stack.isEmpty()) return "-";
|
||||
return BuiltInRegistries.ITEM.getKey(stack.getItem()).getPath() + "*" + stack.getCount();
|
||||
}
|
||||
|
||||
static String uuidLabel(UUID uuid) {
|
||||
if (uuid.equals(PLAYER_UUID)) return "player";
|
||||
for (Entity e : ENTS) if (e.getUUID().equals(uuid)) return who(e);
|
||||
return uuid.toString();
|
||||
}
|
||||
|
||||
/** A villager's data, food, inventory slots, gossip and offers. */
|
||||
static String villager(Villager v) throws Exception {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
var data = v.getVillagerData();
|
||||
sb.append("prof ").append(data.profession().unwrapKey().get().identifier().getPath()).append(" lvl ").append(data.level())
|
||||
.append(" xp ").append(v.getVillagerXp()).append(" food ").append(field(Villager.class, "foodLevel").getInt(v))
|
||||
.append(" age ").append(v.getAge());
|
||||
List<String> slots = new ArrayList<>();
|
||||
var inv = v.getInventory();
|
||||
for (int k = 0; k < inv.getContainerSize(); k++) slots.add(stack(inv.getItem(k)));
|
||||
while (!slots.isEmpty() && slots.getLast().equals("-")) slots.removeLast();
|
||||
sb.append(" inv ").append(slots.isEmpty() ? "-" : String.join(",", slots));
|
||||
List<String> gossips = new ArrayList<>();
|
||||
v.getGossips().getGossipEntries().forEach((uuid, types) -> types.forEach((type, value) ->
|
||||
gossips.add(uuidLabel(uuid) + ":" + type.getSerializedName() + "=" + value)));
|
||||
gossips.sort(null);
|
||||
sb.append(" gossip ").append(gossips.isEmpty() ? "-" : String.join(",", gossips));
|
||||
sb.append(" rep ").append(v.getGossips().getReputation(PLAYER_UUID, x -> true));
|
||||
sb.append(" sleep ").append(v.getSleepingPos().map(Server::pos).orElse("-"));
|
||||
Object offers = get(v, "offers");
|
||||
if (offers != null) {
|
||||
List<String> list = new ArrayList<>();
|
||||
for (var o : (net.minecraft.world.item.trading.MerchantOffers) offers) {
|
||||
list.add(stack(o.getBaseCostA()) + "+" + stack(o.getCostB()) + ">" + stack(o.getResult()) + "/" + o.getUses() + "/"
|
||||
+ o.getMaxUses() + "/" + o.getDemand() + "/" + o.getSpecialPriceDiff());
|
||||
}
|
||||
sb.append(" offers ").append(list.isEmpty() ? "-" : String.join(",", list));
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
static String name(MemoryModuleType<?> type) {
|
||||
return BuiltInRegistries.MEMORY_MODULE_TYPE.getKey(type).getPath();
|
||||
}
|
||||
|
||||
@@ -77,6 +77,36 @@ 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.
|
||||
# PoiManager.take hands out the free beds of a section in hash order:
|
||||
# the parents claim the two near them, the child gets the only one left.
|
||||
beds = []
|
||||
for x in (-6, 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'])
|
||||
@@ -155,6 +185,8 @@ def write_scenarios(path, chosen):
|
||||
lines.append(f'origin {ox} {oz}')
|
||||
for line in body:
|
||||
f = line.split()
|
||||
# `at TICK block ...` changes blocks before that tick; `watch` boxes stay relative.
|
||||
head, f = (f[:2], f[2:]) if f[0] == 'at' else ([], f)
|
||||
if f[0] == 'player':
|
||||
f[1] = repr(float(f[1]) + ox)
|
||||
f[3] = repr(float(f[3]) + oz)
|
||||
@@ -169,7 +201,7 @@ def write_scenarios(path, chosen):
|
||||
f[k] = str(int(f[k]) + ox)
|
||||
for k in (3, 6):
|
||||
f[k] = str(int(f[k]) + oz)
|
||||
lines.append(' '.join(f))
|
||||
lines.append(' '.join(head + f))
|
||||
lines.append('end')
|
||||
path.write_text('\n'.join(lines) + '\n')
|
||||
|
||||
@@ -187,6 +219,9 @@ def parse(path):
|
||||
if parts[1] == 'sound':
|
||||
cur['sounds'].setdefault(t, []).append(parts[2])
|
||||
continue
|
||||
if parts[1] == 'block':
|
||||
cur.setdefault('blocks', {}).setdefault(t, []).append(parts[2])
|
||||
continue
|
||||
if parts[1] == 'trace':
|
||||
cur.setdefault('trace', {}).setdefault(t, []).append(parts[2])
|
||||
continue
|
||||
@@ -286,11 +321,14 @@ 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
|
||||
for t in sorted(set(v['sounds']) | set(r['sounds'])):
|
||||
if v['sounds'].get(t, []) != r['sounds'].get(t, []):
|
||||
report.append(f'{name}: sounds differ at tick {t}: vanilla {v["sounds"].get(t, [])} | horizon {r["sounds"].get(t, [])}')
|
||||
clean = False
|
||||
break
|
||||
# Sounds and watched block changes: first differing tick.
|
||||
for kind in ('sounds', 'blocks'):
|
||||
va, ra = v.get(kind, {}), r.get(kind, {})
|
||||
for t in sorted(set(va) | set(ra)):
|
||||
if va.get(t, []) != ra.get(t, []):
|
||||
report.append(f'{name}: {kind} differ at tick {t}: vanilla {va.get(t, [])} | horizon {ra.get(t, [])}')
|
||||
clean = False
|
||||
break
|
||||
totals['clean'] += clean
|
||||
if clean:
|
||||
report.append(f'{name}: all {len(v["ticks"])} ticks match')
|
||||
|
||||
Reference in New Issue
Block a user