Merge remote-tracking branch 'origin/main' into fix/st-fishing

# Conflicts:
#	tools/lan_e2e.py
This commit is contained in:
Ludovic Marie
2026-10-24 05:06:43 +02:00
10 changed files with 235 additions and 411 deletions
+6 -1
View File
@@ -3840,7 +3840,12 @@ impl Game<'_> {
}
self.crack_particle(crack.0, crack.1, state);
let m = self.mining.as_mut().ok_or("mining")?;
if m.progress >= 1.0 {
// ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
// insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
// (`guest_stop_digging`), never breaking it on its own count. Breaking it here would
// take the block from under the player's crack before the player's client predicts the
// break, so it gets neither particles nor sound.
if m.progress >= 1.0 && (self.lan_acting.is_none() || m.ticks == 1) {
let pos = m.pos;
self.mining = None;
self.break_block(pos)?;
+2 -49
View File
@@ -2277,7 +2277,7 @@ mod sensor_scan_tests {
use horizon_core::geometry::Vec3;
use serde_json::json;
fn kind() -> Arc<MobType> {
pub(super) fn kind() -> Arc<MobType> {
Arc::new(MobType {
id: "minecraft:cow".into(),
species: Species::Cow,
@@ -2481,56 +2481,9 @@ mod sensor_scan_tests {
}
#[cfg(test)]
mod push_tests {
use super::sensor_scan_tests::kind;
use super::*;
use horizon_core::geometry::Vec3;
use serde_json::json;
fn kind() -> Arc<MobType> {
Arc::new(MobType {
id: "minecraft:cow".into(),
species: Species::Cow,
width: 0.9,
height: 1.4,
eye_height: 1.3,
category: "creature".into(),
max_health: 10.0,
speed: 0.2,
flying_speed: 0.4,
attack_damage: 0.0,
attack_knockback: 0.0,
follow_range: 16.0,
step_height: 0.6,
armor: 0.0,
armor_toughness: 0.0,
knockback_resistance: 0.0,
jump_strength: 0.42,
attributes: Arc::default(),
gravity: 0.08,
safe_fall_distance: 3.0,
fall_damage_multiplier: 1.0,
water_efficiency: 0.0,
water_slowdown: 0.8,
air_speed: 0.02,
baby_scale: 0.5,
head_rot_speed: 10.0,
max_head_x_rot: 40.0,
max_head_y_rot: 75.0,
ambient_interval: 120,
flags: Flags {
animal: true,
..Default::default()
},
model: Arc::new(Part::parse("root", &json!({}))),
layers: HashMap::new(),
texture: String::new(),
brain: Brain::Passive,
anim: Anim::Rabbit,
sounds: [""; 3],
step_sound: None,
food: Arc::default(),
tempt: Arc::default(),
})
}
/// The pending pushes as one list, scanned for each mob, as before.
fn take_old(events: &mut Vec<MobEvent>, from: usize, pending: &mut Vec<(u32, Vec3)>) {
+24 -65
View File
@@ -9,7 +9,12 @@
//! own random drives positions, sounds and jumps. `RunOne` shuffles with a
//! random of its own, seeded with the brain's `shuffle_seed` when it is
//! built.
use super::{Mob, MobEvent, MobWorld, Species, Who, path::Path, sniffer};
use super::{
Mob, MobEvent, MobWorld, Species, Who,
brain::{Timed, living_near},
path::Path,
sniffer,
};
use horizon_core::{
geometry::Vec3,
random::{LegacyRandom, RandomSource},
@@ -603,22 +608,7 @@ fn tick_sensors(m: &mut Mob, w: &MobWorld) {
/// `NearestLivingEntitySensor`: everything alive within the follow range,
/// nearest first.
fn sense_living(m: &mut Mob, w: &MobWorld) {
let r = m.attrs.follow_range;
let area = m.bounds().inflate(Vec3::new(r, r, r));
let mut found: Vec<(Who, f64)> = Vec::new();
for o in w.others_near(area) {
if o.id != m.id && o.alive && o.bounds.intersects(area) {
found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
}
}
if let Some(p) = &w.player
&& p.alive
&& p.bounds.intersects(area)
{
found.push((Who::Player, m.distance_sqr(p.position)));
}
found.sort_by(|a, b| a.1.total_cmp(&b.1));
let list: Vec<Who> = found.into_iter().map(|(w, _)| w).collect();
let list = living_near(m, w);
let mm = mem(m);
mm.mobs.set_list(list.clone());
mm.visible_mobs.set(Visible {
@@ -794,37 +784,6 @@ fn followable_friendly(s: Species) -> bool {
// ---- Behaviours ------------------------------------------------------------
/// `Behavior`'s running state and end time.
#[derive(Clone, Copy, Debug)]
struct Timed {
running: bool,
end: i64,
min: i32,
max: i32,
}
impl Timed {
fn new(min: i32, max: i32) -> Self {
Self {
running: false,
end: 0,
min,
max,
}
}
/// `Behavior.tryStart`'s duration draw.
fn begin(&mut self, cx: &mut Bx) {
self.running = true;
let bound = self.max.wrapping_add(1).wrapping_sub(self.min);
let d = self
.min
.wrapping_add(cx.lr.next_int_bound(bound).unwrap_or(0));
self.end = cx.now + i64::from(d);
}
fn timed_out(&self, now: i64) -> bool {
now > self.end
}
}
/// `RunOne`: shuffles its children by weight and starts the first that can.
#[derive(Clone, Debug)]
struct Gate {
@@ -1076,7 +1035,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
mem(m).walk_target.clear();
mem(m).look_target.clear();
m.add_effect("minecraft:regeneration", 200, 0);
@@ -1086,7 +1045,7 @@ impl B {
if !swim_condition(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::AnimalPanic { t, .. } => {
@@ -1094,7 +1053,7 @@ impl B {
if !(mm.hurt_by.get() == Some(&true) || mm.is_panicking.present()) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
if brain_mut(m).kind == Kind::Sniffer {
reset_sniffing(m, cx);
}
@@ -1123,7 +1082,7 @@ impl B {
let reached = reached(m, cx.w, &walk);
if !reached && compute_path(m, cx, &walk, path, speed) {
*last_target = walk.target.block(cx.w);
t.begin(cx);
t.begin(cx.lr, cx.now);
mem(m).path.set_opt(path.clone());
m.nav_move_to_path(path.clone(), f64::from(*speed));
return true;
@@ -1139,21 +1098,21 @@ impl B {
if !mem(m).temptation_cooldown_ticks.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::CountDownGaze(t) => {
if !mem(m).gaze_cooldown_ticks.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::CountDownTransport(t) => {
if !mem(m).transport_items_cooldown_ticks.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::Transport(x) => x.try_start(m, cx),
@@ -1171,7 +1130,7 @@ impl B {
let Some(partner) = breed_partner(m, cx.w) else {
return false;
};
t.begin(cx);
t.begin(cx.lr, cx.now);
if brain_mut(m).kind == Kind::Sniffer {
reset_sniffing(m, cx);
}
@@ -1200,7 +1159,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
if brain_mut(m).kind == Kind::Sniffer {
reset_sniffing(m, cx);
}
@@ -1210,14 +1169,14 @@ impl B {
if !mem(m).look_target.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::FeelingHappy(t) => {
if !mem(m).sniffer_happy.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
transition(m, cx, sniffer::FEELING_HAPPY);
true
}
@@ -1233,7 +1192,7 @@ impl B {
if !can_sniff(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
transition(m, cx, sniffer::DIGGING);
true
}
@@ -1246,7 +1205,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
transition(m, cx, sniffer::RISING);
true
}
@@ -1261,7 +1220,7 @@ impl B {
if !can_sniff(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
transition(m, cx, sniffer::SEARCHING);
true
}
@@ -1278,7 +1237,7 @@ impl B {
if is_tempted(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
transition(m, cx, sniffer::SCENTING);
true
}
@@ -1293,12 +1252,12 @@ impl B {
if m.is_baby() || !can_sniff(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
transition(m, cx, sniffer::SNIFFING);
true
}
B::DoNothing(t) => {
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::AxolotlAction { .. }
+56 -2
View File
@@ -1,8 +1,11 @@
//! Pieces of vanilla's `Brain` that species implemented as brains share:
//! memories that expire, behaviour durations, walk targets and
//! `MoveToTargetSink`.
use super::{Mob, goals::Cx};
use horizon_core::random::RandomSource;
use super::{Mob, MobWorld, Who, goals::Cx};
use horizon_core::{
geometry::Vec3,
random::{LegacyRandom, RandomSource},
};
/// A memory with an expiry (`Brain.setMemoryWithExpiry`): present for the
/// tick it was set and `ttl` more ticks. `Ttl::default()` is absent.
@@ -25,6 +28,57 @@ impl Ttl {
}
}
}
/// `Behavior`'s bookkeeping in the brains ported behaviour for behaviour
/// (villager, animal, monster, warden): running, and until when.
#[derive(Clone, Copy, Debug)]
pub struct Timed {
pub running: bool,
pub end: i64,
pub min: i32,
pub max: i32,
}
impl Timed {
pub fn new(min: i32, max: i32) -> Self {
Self {
running: false,
end: 0,
min,
max,
}
}
/// `Behavior.tryStart`'s duration draw from the level random, in Java's
/// int arithmetic (made even when it cannot vary).
pub fn begin(&mut self, lr: &mut LegacyRandom, now: i64) {
self.running = true;
let bound = self.max.wrapping_add(1).wrapping_sub(self.min);
let d = self.min.wrapping_add(lr.next_int_bound(bound).unwrap_or(0));
self.end = now + i64::from(d);
}
/// `Behavior.timedOut`.
pub fn timed_out(&self, now: i64) -> bool {
now > self.end
}
}
/// `NearestLivingEntitySensor`'s scan: the living entities (the player
/// among them) whose boxes meet the follow range around `m`, nearest first.
pub fn living_near(m: &Mob, w: &MobWorld) -> Vec<Who> {
let r = m.attrs.follow_range;
let area = m.bounds().inflate(Vec3::new(r, r, r));
let mut found: Vec<(Who, f64)> = Vec::new();
for o in w.others_near(area) {
if o.id != m.id && o.alive && o.bounds.intersects(area) {
found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
}
}
if let Some(p) = &w.player
&& p.alive
&& p.bounds.intersects(area)
{
found.push((Who::Player, m.distance_sqr(p.position)));
}
found.sort_by(|a, b| a.1.total_cmp(&b.1));
found.into_iter().map(|(w, _)| w).collect()
}
/// A random duration in `min..=max` (`Behavior`'s end time).
pub fn duration(m: &mut Mob, min: i32, max: i32) -> i32 {
if max <= min {
+17 -99
View File
@@ -11,9 +11,10 @@
//! seeded when the brain is built.
use super::{
Mob, MobEvent, MobWorld, Species, Who,
brain::{Timed, living_near},
goals::Cx,
path::Path,
villager_brain::{NEVER, Slot, Tracker, Visible, WalkTarget},
villager_brain::{NEVER, Slot, Tracker, Visible, WalkTarget, compute_path, reached},
};
use crate::projectiles::{Projectile, ProjectileKind};
use horizon_core::{
@@ -129,6 +130,10 @@ fn brain_mut(m: &mut Mob) -> &mut Brain {
fn mem(m: &mut Mob) -> &mut Memories {
&mut brain_mut(m).mem
}
/// `CANT_REACH_WALK_TARGET_SINCE`, for `compute_path`.
fn cant_reach(m: &mut Mob) -> &mut Slot<i64> {
&mut mem(m).cant_reach_walk_target_since
}
fn mem_ref(m: &Mob) -> &Memories {
&brain(m).expect("brain").mem
}
@@ -292,22 +297,7 @@ fn tick_sensors(m: &mut Mob, w: &MobWorld) {
/// `NearestLivingEntitySensor`: everything alive within the follow range,
/// nearest first.
fn sense_living(m: &mut Mob, w: &MobWorld) {
let r = m.attrs.follow_range;
let area = m.bounds().inflate(Vec3::new(r, r, r));
let mut found: Vec<(Who, f64)> = Vec::new();
for o in w.others_near(area) {
if o.id != m.id && o.alive && o.bounds.intersects(area) {
found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
}
}
if let Some(p) = &w.player
&& p.alive
&& p.bounds.intersects(area)
{
found.push((Who::Player, m.distance_sqr(p.position)));
}
found.sort_by(|a, b| a.1.total_cmp(&b.1));
let list: Vec<Who> = found.into_iter().map(|(w, _)| w).collect();
let list = living_near(m, w);
let mm = mem(m);
mm.mobs.set_list(list.clone());
mm.visible_mobs.set(Visible {
@@ -456,31 +446,6 @@ fn sense_breeze_attack(m: &mut Mob, w: &MobWorld) {
// ---- Behaviours ---------------------------------------------------------
/// `Behavior`'s bookkeeping: running, and until when.
#[derive(Clone, Debug)]
struct Timed {
running: bool,
end: i64,
min: i32,
max: i32,
}
impl Timed {
fn new(min: i32, max: i32) -> Self {
Self {
running: false,
end: 0,
min,
max,
}
}
/// `Behavior.tryStart`'s duration draw from the level random.
fn begin(&mut self, cx: &mut Bx) {
self.running = true;
let d = self.min + cx.lr.next_int_bound(self.max + 1 - self.min).unwrap_or(0);
self.end = cx.now + i64::from(d);
}
}
/// `StartAttacking`'s target finders.
#[derive(Clone, Copy, Debug)]
enum Finder {
@@ -607,14 +572,14 @@ impl B {
if *creaking && !super::creaking::can_move(m) || !swim_condition(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::LookAtTargetSink(t) => {
if !mem(m).look_target.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::MoveToTargetSink {
@@ -636,9 +601,9 @@ impl B {
}
let walk = mm.walk_target.value().unwrap();
let reached = reached(m, cx.w, &walk);
if !reached && compute_path(m, cx, &walk, path, speed) {
if !reached && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
*last_target = walk.target.block(cx.w);
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
mem(m).path.set_opt(path.clone());
m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -719,7 +684,7 @@ impl B {
true
}
B::DoNothing(t) => {
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::RandomStroll(running, speed) => {
@@ -848,7 +813,7 @@ impl B {
mem(m).breeze_shoot.clear();
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
super::breeze::set_pose(m, super::breeze::SHOOTING);
mem(m).breeze_shoot_charging.set_ttl((), 15);
@@ -867,7 +832,7 @@ impl B {
if !long_jump_can_run(m, cx) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
if !mem(m).breeze_jump_inhaling.present() {
mem(m).breeze_jump_inhaling.set_ttl((), 10);
@@ -905,7 +870,7 @@ impl B {
if !stuck {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
mem(m).breeze_shoot.set_ttl((), 60);
true
}
@@ -924,7 +889,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
slide_start(m, cx);
true
}
@@ -989,7 +954,7 @@ impl B {
&& let Some(now_target) = walk.target.block(cx.w)
{
let d = manhattan_sq(now_target, last);
if d > 4 && compute_path(m, cx, &walk, path, speed) {
if d > 4 && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
*last_target = Some(now_target);
mem(m).path.set_opt(path.clone());
m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -1122,53 +1087,6 @@ fn tracker_visible(m: &mut Mob, w: &MobWorld, t: Tracker) -> bool {
_ => true,
}
}
/// `MoveToTargetSink.reachedTarget`.
fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
walk.target.block(w).is_some_and(|p| {
let h = block_of(m.position);
(p[0] - h[0]).abs() + (p[1] - h[1]).abs() + (p[2] - h[2]).abs() <= walk.close
})
}
/// `MoveToTargetSink.tryComputePath`.
fn compute_path(
m: &mut Mob,
cx: &mut Bx,
walk: &WalkTarget,
path: &mut Option<Path>,
speed: &mut f32,
) -> bool {
let Some(target) = walk.target.block(cx.w) else {
return false;
};
*path = m.create_path_to(cx.w, target, 0);
*speed = walk.speed;
if reached(m, cx.w, walk) {
mem(m).cant_reach_walk_target_since.clear();
} else {
let can_reach = path.as_ref().is_some_and(|p| p.reached);
let mm = mem(m);
if can_reach {
mm.cant_reach_walk_target_since.clear();
} else if !mm.cant_reach_walk_target_since.present() {
mm.cant_reach_walk_target_since.set(cx.now);
}
if path.is_some() {
return true;
}
let to = [
f64::from(target[0]) + 0.5,
f64::from(target[1]),
f64::from(target[2]) + 0.5,
];
if let Some(step) =
m.default_random_pos_towards(cx.w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
{
*path = m.create_path_to(cx.w, block_of(Vec3::new(step[0], step[1], step[2])), 0);
return path.is_some();
}
}
false
}
/// `BehaviorUtils.isWithinAttackRange(body, target, 1)` for a mob without a
/// ranged weapon: `Mob.isWithinMeleeAttackRange`.
fn within_attack_range(m: &Mob, w: &MobWorld, target: Who) -> bool {
@@ -11,6 +11,7 @@
//! `Brain::shuffle_seed` when the brain is built.
use super::{
Mob, MobEvent, MobWorld, Species, Who,
brain::{Timed, living_near},
path::{Path, PathNode},
};
use horizon_core::{
@@ -341,6 +342,10 @@ fn brain_mut(m: &mut Mob) -> &mut Brain {
fn mem(m: &mut Mob) -> &mut Memories {
&mut brain_mut(m).mem
}
/// `CANT_REACH_WALK_TARGET_SINCE`, for `compute_path`.
fn cant_reach(m: &mut Mob) -> &mut Slot<i64> {
&mut mem(m).cant_reach_walk_target_since
}
fn mem_ref(m: &Mob) -> Option<&Memories> {
brain(m).map(|b| &b.mem)
}
@@ -565,22 +570,7 @@ const FOLLOW_RANGE: f64 = 16.0;
/// `NearestLivingEntitySensor`: everything alive within the follow range,
/// nearest first.
fn sense_living(m: &mut Mob, w: &MobWorld) {
let r = m.attrs.follow_range;
let area = m.bounds().inflate(Vec3::new(r, r, r));
let mut found: Vec<(Who, f64)> = Vec::new();
for o in w.others_near(area) {
if o.id != m.id && o.alive && o.bounds.intersects(area) {
found.push((Who::Mob(o.id), m.distance_sqr(o.position)));
}
}
if let Some(p) = &w.player
&& p.alive
&& p.bounds.intersects(area)
{
found.push((Who::Player, m.distance_sqr(p.position)));
}
found.sort_by(|a, b| a.1.total_cmp(&b.1));
let list: Vec<Who> = found.into_iter().map(|(w, _)| w).collect();
let list = living_near(m, w);
let mm = mem(m);
mm.mobs.set_list(list.clone());
mm.visible_mobs.set(Visible {
@@ -791,34 +781,6 @@ fn sense_golem(m: &mut Mob, w: &MobWorld) {
// ---- Behaviours ---------------------------------------------------------
/// `Behavior`'s bookkeeping: running, and until when.
#[derive(Clone, Debug)]
struct Timed {
running: bool,
end: i64,
min: i32,
max: i32,
}
impl Timed {
fn new(min: i32, max: i32) -> Self {
Self {
running: false,
end: 0,
min,
max,
}
}
/// `Behavior.tryStart`'s duration draw.
fn begin(&mut self, cx: &mut Bx) {
self.running = true;
let bound = self.max.wrapping_add(1).wrapping_sub(self.min);
let d = self
.min
.wrapping_add(cx.lr.next_int_bound(bound).unwrap_or(0));
self.end = cx.now + i64::from(d);
}
}
/// The POI types villagers use.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Poi {
@@ -1498,18 +1460,18 @@ impl B {
if !swim_condition(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::LookAtTargetSink(t) => {
if !mem(m).look_target.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::PanicTrigger(t) => {
t.begin(cx);
t.begin(cx.lr, cx.now);
// VillagerPanicTrigger.start
if panic_condition(m) {
if !brain_mut(m).is_active(Act::Panic) {
@@ -1542,9 +1504,9 @@ impl B {
}
let walk = mm.walk_target.value().unwrap();
let reached = reached(m, cx.w, &walk);
if !reached && compute_path(m, cx, &walk, path, speed) {
if !reached && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
*last_target = walk.target.block(cx.w);
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
mem(m).path.set_opt(path.clone());
m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -1561,7 +1523,7 @@ impl B {
if !follow_trading_condition(m, cx.w) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
follow_trading_player(m);
true
}
@@ -1573,7 +1535,7 @@ impl B {
if !matches!(a, Act::Idle | Act::Work | Act::Play) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::JumpOnBed {
@@ -1590,7 +1552,7 @@ impl B {
if mm.walk_target.present() || !m.is_baby() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
*bed = Some(nearest);
*time_left = 100;
*jumps = 3 + cx.lr.next_int_bound(4).unwrap_or(0);
@@ -1599,7 +1561,7 @@ impl B {
true
}
B::DoNothing(t) => {
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::GiveGiftToHero {
@@ -1618,7 +1580,7 @@ impl B {
*until_next -= 1;
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
*given = false;
*started = now;
let mm = mem(m);
@@ -1630,7 +1592,7 @@ impl B {
if !mem(m).interaction_target.present() || !show_trades_condition(m, cx.w) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
if let Some(target) = mem(m).interaction_target.value() {
mem(m).look_target.set(Tracker::Entity(target, true));
@@ -1646,7 +1608,7 @@ impl B {
if !villager_target_valid(m, cx.w, Mem::InteractionTarget) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
let target = mem(m).interaction_target.value().unwrap();
lock_gaze(m, target, cx);
true
@@ -1659,7 +1621,7 @@ impl B {
if !breeding_possible(m, cx.w) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
let target = mem(m).breed_target.value().unwrap();
lock_gaze(m, target, cx);
*birth = now + 275 + i64::from(m.random.next_int_bound(50).unwrap_or(0));
@@ -1680,7 +1642,7 @@ impl B {
if !closer_to_center(site, m.position, 1.73) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
let mm = mem(m);
mm.last_worked_at_poi.set(now);
@@ -1709,7 +1671,7 @@ impl B {
*valid = farmland_around(m, cx.w);
*target = pick_farmland(valid, cx);
let Some(p) = *target else { return false };
t.begin(cx);
t.begin(cx.lr, cx.now);
if now > *next_ok {
let mm = mem(m);
mm.look_target.set(Tracker::Block(p));
@@ -2288,7 +2250,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
if now > *next_ok {
if super::villager::start_sleeping(m, home, w) {
mem(m).last_slept.set(now);
@@ -2609,7 +2571,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::LocateHidingPlace {
@@ -2769,7 +2731,7 @@ impl B {
&& let Some(now_target) = walk.target.block(cx.w)
{
let d = manhattan_sq(now_target, last);
if d > 4 && compute_path(m, cx, &walk, path, speed) {
if d > 4 && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
*last_target = Some(now_target);
mem(m).path.set_opt(path.clone());
m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -3141,33 +3103,37 @@ fn tracker_visible(m: &mut Mob, w: &MobWorld, t: Tracker) -> bool {
}
}
/// `MoveToTargetSink.reachedTarget`.
fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
pub(super) fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
walk.target
.block(w)
.is_some_and(|p| manhattan(p, block_of(m.position)) <= walk.close)
}
/// `MoveToTargetSink.tryComputePath`.
fn compute_path(
/// `MoveToTargetSink.tryComputePath`, for the brains on these memories
/// (villager, monster, warden): `cant_reach` is the brain's
/// `CANT_REACH_WALK_TARGET_SINCE`.
pub(super) fn compute_path(
m: &mut Mob,
cx: &mut Bx,
w: &MobWorld,
now: i64,
walk: &WalkTarget,
path: &mut Option<Path>,
speed: &mut f32,
cant_reach: fn(&mut Mob) -> &mut Slot<i64>,
) -> bool {
let Some(target) = walk.target.block(cx.w) else {
let Some(target) = walk.target.block(w) else {
return false;
};
*path = m.create_path_to(cx.w, target, 0);
*path = m.create_path_to(w, target, 0);
*speed = walk.speed;
if reached(m, cx.w, walk) {
mem(m).cant_reach_walk_target_since.clear();
if reached(m, w, walk) {
cant_reach(m).clear();
} else {
let can_reach = path.as_ref().is_some_and(|p| p.reached);
let mm = mem(m);
let since = cant_reach(m);
if can_reach {
mm.cant_reach_walk_target_since.clear();
} else if !mm.cant_reach_walk_target_since.present() {
mm.cant_reach_walk_target_since.set(cx.now);
since.clear();
} else if !since.present() {
since.set(now);
}
if path.is_some() {
return true;
@@ -3178,14 +3144,14 @@ fn compute_path(
f64::from(target[2]) + 0.5,
];
if let Some(step) =
m.default_random_pos_towards(cx.w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
m.default_random_pos_towards(w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
{
let p = [
step[0].floor() as i32,
step[1].floor() as i32,
step[2].floor() as i32,
];
*path = m.create_path_to(cx.w, p, 0);
*path = m.create_path_to(w, p, 0);
return path.is_some();
}
}
+17 -91
View File
@@ -14,9 +14,10 @@
//! shuffle seed.
use super::{
Mob, MobEvent, MobWorld, Who,
brain::Timed,
goals::Cx,
path::Path,
villager_brain::{Slot, Tracker, Visible, WalkTarget},
villager_brain::{Slot, Tracker, Visible, WalkTarget, compute_path, reached},
warden::{self, Pose},
};
use horizon_core::{
@@ -145,31 +146,6 @@ impl Memories {
}
}
/// `Behavior`'s bookkeeping: running, and until when.
#[derive(Clone, Debug)]
struct Timed {
running: bool,
end: i64,
min: i32,
max: i32,
}
impl Timed {
fn new(min: i32, max: i32) -> Self {
Self {
running: false,
end: 0,
min,
max,
}
}
/// `Behavior.tryStart`'s duration draw (made even when it cannot vary).
fn begin(&mut self, cx: &mut Bx) {
self.running = true;
let d = self.min + cx.lr.next_int_bound(self.max + 1 - self.min).unwrap_or(0);
self.end = cx.now + i64::from(d);
}
}
/// `RunOne`'s `ShufflingList` over a stroll (weight 2) and `DoNothing` (1).
#[derive(Clone, Debug)]
struct Gate {
@@ -383,6 +359,10 @@ fn brain(m: &Mob) -> Option<&Brain> {
pub(super) fn mem(m: &mut Mob) -> &mut Memories {
&mut m.extra.warden.as_mut().expect("a warden").brain.mem
}
/// `CANT_REACH_WALK_TARGET_SINCE`, for `compute_path`.
fn cant_reach(m: &mut Mob) -> &mut Slot<i64> {
&mut mem(m).cant_reach_walk_target_since
}
pub(super) fn mem_ref(m: &Mob) -> Option<&Memories> {
brain(m).map(|b| &b.mem)
}
@@ -558,9 +538,6 @@ fn find_closest(m: &mut Mob, w: &MobWorld, filter: impl Fn(&Mob, Who) -> bool) -
fn block_of(p: Vec3) -> [i32; 3] {
[p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
}
fn manhattan(a: [i32; 3], b: [i32; 3]) -> i32 {
(a[0] - b[0]).abs() + (a[1] - b[1]).abs() + (a[2] - b[2]).abs()
}
fn dist_sqr(a: [i32; 3], b: [i32; 3]) -> i64 {
(0..3).map(|i| i64::from(a[i] - b[i]).pow(2)).sum()
}
@@ -607,57 +584,6 @@ fn tracker_visible(m: &mut Mob, w: &MobWorld, t: Tracker) -> bool {
_ => true,
}
}
/// `MoveToTargetSink.reachedTarget`.
fn reached(m: &Mob, w: &MobWorld, walk: &WalkTarget) -> bool {
walk.target
.block(w)
.is_some_and(|p| manhattan(p, block_of(m.position)) <= walk.close)
}
/// `MoveToTargetSink.tryComputePath`.
fn compute_path(
m: &mut Mob,
cx: &mut Bx,
walk: &WalkTarget,
path: &mut Option<Path>,
speed: &mut f32,
) -> bool {
let Some(target) = walk.target.block(cx.w) else {
return false;
};
*path = m.create_path_to(cx.w, target, 0);
*speed = walk.speed;
if reached(m, cx.w, walk) {
mem(m).cant_reach_walk_target_since.clear();
} else {
let can_reach = path.as_ref().is_some_and(|p| p.reached);
let mm = mem(m);
if can_reach {
mm.cant_reach_walk_target_since.clear();
} else if !mm.cant_reach_walk_target_since.present() {
mm.cant_reach_walk_target_since.set(cx.now);
}
if path.is_some() {
return true;
}
let to = [
f64::from(target[0]) + 0.5,
f64::from(target[1]),
f64::from(target[2]) + 0.5,
];
if let Some(step) =
m.default_random_pos_towards(cx.w, 10, 7, to, f64::from(std::f32::consts::FRAC_PI_2))
{
let p = [
step[0].floor() as i32,
step[1].floor() as i32,
step[2].floor() as i32,
];
*path = m.create_path_to(cx.w, p, 0);
return path.is_some();
}
}
false
}
fn same_path(a: Option<&Path>, b: Option<&Path>) -> bool {
match (a, b) {
(None, None) => true,
@@ -710,7 +636,7 @@ impl B {
if !swim_condition(m) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::SetWardenLookTarget(r) => one(r, || {
@@ -732,7 +658,7 @@ impl B {
if !mem(m).look_target.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::MoveToTargetSink {
@@ -755,9 +681,9 @@ impl B {
return false;
};
let reached = reached(m, cx.w, &walk);
if !reached && compute_path(m, cx, &walk, path, speed) {
if !reached && compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach) {
*last_target = walk.target.block(cx.w);
t.begin(cx);
t.begin(cx.lr, cx.now);
// start
mem(m).path.set_opt(path.clone());
m.nav_move_to_path(path.clone(), f64::from(*speed));
@@ -775,7 +701,7 @@ impl B {
if !mm.is_emerging.present() || mm.walk_target.present() {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
warden::set_pose(m, Pose::Emerging);
sound(m, "entity.warden.emerge", 5.0, 1.0, cx.events);
true
@@ -791,7 +717,7 @@ impl B {
if !(m.on_ground || liquid) {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
if m.on_ground {
warden::set_pose(m, Pose::Digging);
sound(m, "entity.warden.dig", 5.0, 1.0, cx.events);
@@ -872,7 +798,7 @@ impl B {
true
}),
B::DoNothing(t) => {
t.begin(cx);
t.begin(cx.lr, cx.now);
true
}
B::GoToDisturbance(r) => one(r, || {
@@ -907,7 +833,7 @@ impl B {
{
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
sound(m, "entity.warden.sniff", 5.0, 1.0, cx.events);
true
}
@@ -919,7 +845,7 @@ impl B {
let Some(target) = mm.roar_target.value() else {
return false;
};
t.begin(cx);
t.begin(cx.lr, cx.now);
let mm = mem(m);
mm.roar_sound_delay.set_ttl((), ROAR_SOUND_DELAY);
mm.walk_target.clear();
@@ -1004,7 +930,7 @@ impl B {
if !close {
return false;
}
t.begin(cx);
t.begin(cx.lr, cx.now);
let mm = mem(m);
mm.attack_cooling_down
.set_ttl(true, i64::from(SONIC_DURATION));
@@ -1092,7 +1018,7 @@ impl B {
&& let Some(walk) = mem(m).walk_target.value()
&& let Some(now_target) = walk.target.block(cx.w)
&& dist_sqr(now_target, last) > 4
&& compute_path(m, cx, &walk, path, speed)
&& compute_path(m, cx.w, cx.now, &walk, path, speed, cant_reach)
{
*last_target = Some(now_target);
mem(m).path.set_opt(path.clone());
@@ -266,8 +266,8 @@ fn is_virtual(block: usize) -> bool {
VIRTUAL.contains(&block)
}
/// `getSideMask`.
fn side_mask(west: bool, east: bool, north: bool, south: bool) -> i32 {
/// `getSideMask` (LeavesFix has the same copy).
pub(super) fn side_mask(west: bool, east: bool, north: bool, south: bool) -> i32 {
let mut s = 0;
if north {
if east {
@@ -6,6 +6,7 @@
//! emulated here (`IntOpenHashSet` and the key order of an `Int2ObjectOpenHashMap`).
use std::collections::{HashMap, HashSet};
use super::chunk_flatten::side_mask;
use super::dynamic::{as_int, as_long_stream, as_str, ceillog2, set};
use crate::nbt::Tag;
@@ -355,32 +356,6 @@ fn get_index(x: i32, y: i32, z: i32) -> i32 {
y << 8 | z << 4 | x
}
fn side_mask(west: bool, east: bool, north: bool, south: bool) -> i32 {
let mut s = 0;
if north {
if east {
s |= 2;
} else if west {
s |= 128;
} else {
s |= 1;
}
} else if south {
if west {
s |= 32;
} else if east {
s |= 8;
} else {
s |= 16;
}
} else if east {
s |= 4;
} else if west {
s |= 64;
}
s
}
/// `LeavesFix` over a chunk (`{Level: ...}`).
pub(super) fn leaves_fix(chunk: &mut Tag) {
let Some(level) = chunk.get_mut("Level") else {
+68
View File
@@ -4959,5 +4959,73 @@ CHECKS += ['fishing']
CHECK_FNS.update(fishing=check_fishing)
def check_digging(host, guest, out):
"""The server breaks a block a player digs only once that player's client is done
(ServerPlayerGameMode: STOP_DESTROY_BLOCK, or the delayed destroy), never on its own count, so
the player's client always breaks it first, with its particles and sound. The guest holds
attack across a wall of six oak logs with a copper axe and hears each one break; then it digs
stone with a wooden pickaxe and its game stalls for a second halfway: the stone is still there
on both sides when it resumes, and the guest's own crack finishes it."""
gx, gy, gz = (int(v // 1) for v in pos_of(guest))
x, y, z = gx + 3, gy, gz + 4
heard = lambda sound: guest('status')['heard'].get(sound, 0)
at = lambda b: (f'{b[0] + 0.02:.2f}', f'{b[1] + 0.5:.2f}', f'{b[2] + 0.5:.2f}')
guest('command', command='gamemode survival')
guest('command', command='item replace entity @s weapon.mainhand with minecraft:copper_axe')
host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 4} {y + 3} {z + 2} minecraft:air')
host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 4} {y - 1} {z + 2} minecraft:stone')
host('command', command=f'fill {x + 2} {y} {z - 1} {x + 2} {y + 1} {z + 1} minecraft:oak_log')
guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}')
guest.wait(30)
logs = [(x + 2, y + dy, z + dz) for dz in (-1, 0, 1) for dy in (0, 1)]
before = heard('minecraft:block.wood.break')
guest.raw('look-at', *at(logs[0]))
guest.raw('mouse', 'left', 'down')
left = list(logs)
deadline = time.time() + 20
while left and time.time() < deadline:
if guest.raw('block', *left[0]).get('block') != 'minecraft:oak_log':
left.pop(0)
if left:
guest.raw('look-at', *at(left[0]))
guest.raw('mouse', 'left', 'up')
guest.wait(10)
seen = {'logs_left': left, 'log_breaks_heard': heard('minecraft:block.wood.break') - before}
# Stone with a wooden pickaxe: 23 ticks. The guest stalls for a second after about 8.
stone = (x + 2, y, z)
guest('command', command='item replace entity @s weapon.mainhand with minecraft:wooden_pickaxe')
host('command', command=f'setblock {stone[0]} {stone[1]} {stone[2]} minecraft:stone')
guest.wait(10)
before = heard('minecraft:block.stone.break')
guest.raw('look-at', *at(stone))
guest.raw('mouse', 'left', 'down')
time.sleep(0.4)
os.kill(guest.pid, signal.SIGSTOP)
try:
time.sleep(1.0)
finally:
os.kill(guest.pid, signal.SIGCONT)
resumed = {'guest': guest.raw('block', *stone).get('block'), 'server': host.raw('block', *stone).get('block'),
'mining': guest('state').get('mining')}
# Let go once it breaks: past it the crosshair reaches the floor.
deadline = time.time() + 5
while guest.raw('block', *stone).get('block') == 'minecraft:stone' and time.time() < deadline:
pass
guest.raw('mouse', 'left', 'up')
guest.wait(10)
seen.update(resumed=resumed, stone_after=host.raw('block', *stone).get('block'),
stone_breaks_heard=heard('minecraft:block.stone.break') - before)
guest.shot(out, 'digging')
assert not left and seen['log_breaks_heard'] == 6, f'the server broke logs before the guest did: {seen}'
assert resumed['guest'] == resumed['server'] == 'minecraft:stone', f'the server broke the stone while the guest stalled: {seen}'
assert seen['stone_after'] == 'minecraft:air' and seen['stone_breaks_heard'] == 1, f'the guest did not break the stone: {seen}'
return seen
CHECKS += ['digging']
CHECK_FNS.update(digging=check_digging)
if __name__ == '__main__':
main()