Merge pull request #2673 from kacpherek/fix/server-thread-no-local-player
🤖 Agent: Merged by Ludovic's AI agent (Claude, contrib-gate-19) after the contribution gate. Checked against vanilla 26.3 and proven in union/cg19-r2 (all round-2 PRs together: clippy, 1722 tests, 135 harnesses, lan_e2e in-frame and on the server thread) and union/cg19-r3 (the same PRs merged with today's main: 96/96 harnesses). Thanks @kacpherek.
This commit is contained in:
@@ -558,7 +558,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
"memories",
|
||||
Tag::compound([(
|
||||
"minecraft:liked_player",
|
||||
Tag::compound([("value", Tag::IntArray(vec![0, 0, 0, 1]))]),
|
||||
Tag::compound([(
|
||||
"value",
|
||||
Tag::IntArray(m.extra.owner.unwrap_or([0, 0, 0, 1]).to_vec()),
|
||||
)]),
|
||||
)]),
|
||||
)]),
|
||||
);
|
||||
@@ -1179,11 +1182,14 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
|
||||
m.extra.ints[1] = number(first.get("count")).unwrap_or(1) as i32;
|
||||
}
|
||||
m.extra.egg_time = number(tag.get("DuplicationCooldown")).unwrap_or(0) as i32;
|
||||
m.extra.tame = tag
|
||||
let liked = tag
|
||||
.get("Brain")
|
||||
.and_then(|b| b.get("memories"))
|
||||
.and_then(|b| b.get("minecraft:liked_player"))
|
||||
.is_some();
|
||||
.and_then(|b| b.get("minecraft:liked_player"));
|
||||
m.extra.tame = liked.is_some();
|
||||
m.extra.owner = liked
|
||||
.and_then(|l| l.get("value"))
|
||||
.and_then(|v| crate::save::uuid_from_tag(Some(v)));
|
||||
}
|
||||
if crate::mobs::camel::is_camel(m.species()) {
|
||||
let sitting = matches!(tag.get("LastPoseTick"), Some(Tag::Long(v)) if *v < 0);
|
||||
|
||||
@@ -8,7 +8,6 @@ use horizon_core::random::RandomSource;
|
||||
impl Game<'_> {
|
||||
pub(super) fn tick_allays(&mut self) {
|
||||
let griefing = self.ui.rules.bool("mob_griefing");
|
||||
let player = self.player.as_ref().map(|p| p.position);
|
||||
// The playing jukeboxes, found at the first allay: no allay starts
|
||||
// or stops one, and the block entities run into the thousands.
|
||||
let mut jukeboxes: Option<Vec<(i32, i32, i32)>> = None;
|
||||
@@ -58,7 +57,7 @@ impl Game<'_> {
|
||||
};
|
||||
let Some((j, _)) = wanted else {
|
||||
self.mobs[i].extra.point = None;
|
||||
self.allay_deliver(i, player);
|
||||
self.allay_deliver(i);
|
||||
continue;
|
||||
};
|
||||
let e = &self.dropped[j];
|
||||
@@ -90,14 +89,46 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `AllayAi.getLikedPlayer`: the player the allay was given an item by,
|
||||
/// found by UUID among the host and the guests of the level (the window
|
||||
/// is a guest on the server thread), when they are not a spectator and
|
||||
/// within 64 blocks.
|
||||
fn allay_liked_player(&self, i: usize) -> Option<horizon_core::geometry::Vec3> {
|
||||
let m = &self.mobs[i];
|
||||
if !m.extra.tame {
|
||||
return None;
|
||||
}
|
||||
// An allay saved before its player was kept belongs to the host.
|
||||
let uuid = m
|
||||
.extra
|
||||
.owner
|
||||
.filter(|u| *u != [0, 0, 0, 1])
|
||||
.or(self.level.player_uuid)
|
||||
.unwrap_or([0, 0, 0, 1]);
|
||||
let host = self
|
||||
.player_view()
|
||||
.filter(|p| !p.spectator && self.level.player_uuid.unwrap_or([0, 0, 0, 1]) == uuid)
|
||||
.map(|p| p.position);
|
||||
let found = host.or_else(|| {
|
||||
self.lan_present()
|
||||
.into_iter()
|
||||
.find(|p| p.uuid == uuid && !p.spectator)
|
||||
.map(|p| {
|
||||
horizon_core::geometry::Vec3::new(p.position[0], p.position[1], p.position[2])
|
||||
})
|
||||
});
|
||||
found.filter(|p| p.distance_squared(m.position) < 64.0 * 64.0)
|
||||
}
|
||||
/// `GoAndGiveItemsToTarget` / `AllayAi.throwItem`: within 3 blocks of
|
||||
/// the deposit, one item a tick, each restarting the three-second pause
|
||||
/// before it picks anything up again.
|
||||
fn allay_deliver(&mut self, i: usize, player: Option<horizon_core::geometry::Vec3>) {
|
||||
fn allay_deliver(&mut self, i: usize) {
|
||||
let m = &self.mobs[i];
|
||||
if m.extra.ints[1] <= 0 {
|
||||
return;
|
||||
}
|
||||
let player = self.allay_liked_player(i);
|
||||
let m = &self.mobs[i];
|
||||
let target = match m.extra.home.filter(|_| m.extra.ints[2] > 0) {
|
||||
Some(h) => horizon_core::geometry::Vec3::new(
|
||||
f64::from(h[0]) + 0.5,
|
||||
@@ -167,11 +198,14 @@ impl Game<'_> {
|
||||
self.consume_held();
|
||||
return true;
|
||||
}
|
||||
let acting = self.acting_uuid();
|
||||
let holds = m.extra.main_hand.is_some();
|
||||
if !holds && !item.is_empty() {
|
||||
let m = &mut self.mobs[index];
|
||||
m.extra.main_hand = Some(item.into());
|
||||
m.extra.tame = true;
|
||||
// `Allay.mobInteract` remembers LIKED_PLAYER by UUID.
|
||||
m.extra.owner = Some(acting);
|
||||
self.audio
|
||||
.play("minecraft:entity.allay.item_given", Some(at), 2.0, 1.0);
|
||||
self.consume_held();
|
||||
@@ -186,6 +220,7 @@ impl Game<'_> {
|
||||
.unwrap_or_else(|| "minecraft:air".into());
|
||||
let carried = std::mem::take(&mut m.extra.ints[1]);
|
||||
m.extra.tame = false;
|
||||
m.extra.owner = None;
|
||||
self.audio
|
||||
.play("minecraft:entity.allay.item_taken", Some(at), 2.0, 1.0);
|
||||
if carried > 0 {
|
||||
|
||||
@@ -456,9 +456,10 @@ impl Game<'_> {
|
||||
teams: std::sync::Arc::new(self.mob_teams()),
|
||||
items: Some(self.res.items()),
|
||||
lid_openers: &self.lid_openers,
|
||||
// The first player in the level: a server has no player of its own.
|
||||
difficulty: self.local_difficulty(
|
||||
self.player
|
||||
.as_ref()
|
||||
self.level_players()
|
||||
.first()
|
||||
.map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z]),
|
||||
),
|
||||
}
|
||||
@@ -4484,13 +4485,10 @@ impl Game<'_> {
|
||||
f64::from((pos[0] >> 4) * 16 + 8),
|
||||
f64::from((pos[2] >> 4) * 16 + 8),
|
||||
];
|
||||
let spectator = self.spectator();
|
||||
let Some(close) = self.player.as_ref().filter(|_| !spectator).map(|p| {
|
||||
let close = self.level_players().iter().any(|p| {
|
||||
let (dx, dz) = (p.position.x - centre[0], p.position.z - centre[1]);
|
||||
dx * dx + dz * dz < 16384.0
|
||||
}) else {
|
||||
return;
|
||||
};
|
||||
!p.spectator && dx * dx + dz * dz < 16384.0
|
||||
});
|
||||
if !close {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -3029,14 +3029,11 @@ impl Game<'_> {
|
||||
let (a, b) = (room.min_position(), room.max_position());
|
||||
lo.x < b.x && hi.x > a.x && lo.y < b.y && hi.y > a.y && lo.z < b.z && hi.z > a.z
|
||||
};
|
||||
let player = self.player.as_ref().is_some_and(|p| {
|
||||
let w = f64::from(p.dimensions.width) / 2.0;
|
||||
let h = f64::from(p.dimensions.height);
|
||||
touches(
|
||||
Vec3::new(p.position.x - w, p.position.y, p.position.z - w),
|
||||
Vec3::new(p.position.x + w, p.position.y + h, p.position.z + w),
|
||||
)
|
||||
});
|
||||
// Level.getEntities: the host's player and every guest in the level.
|
||||
let player = self
|
||||
.fight_players()
|
||||
.iter()
|
||||
.any(|p| !p.spectator && touches(p.bounds.min_position(), p.bounds.max_position()));
|
||||
player
|
||||
|| self.crystals.iter().any(|c| {
|
||||
touches(
|
||||
|
||||
@@ -2469,7 +2469,10 @@ impl Game<'_> {
|
||||
if let Some((at, velocity)) = soul {
|
||||
super::lan_particles::send_soul_particle(host, at, velocity);
|
||||
}
|
||||
self.as_guest(host, conn, |game| game.tick_player_sculk_events());
|
||||
self.as_guest(host, conn, |game| {
|
||||
game.sculk_step_on_player();
|
||||
game.tick_player_sculk_events();
|
||||
});
|
||||
for event in events {
|
||||
match event {
|
||||
MotionEvent::HurtSound(sound) => self.player_hurt_sound(sound, at),
|
||||
|
||||
@@ -279,11 +279,13 @@ impl Game<'_> {
|
||||
/// horse is a trap for fifteen minutes; a player within ten blocks springs
|
||||
/// it.
|
||||
pub(super) fn tick_skeleton_traps(&mut self) {
|
||||
let player = self
|
||||
.player
|
||||
.as_ref()
|
||||
.filter(|p| !p.health.dead_or_dying())
|
||||
.map(|p| p.position);
|
||||
// `Level.hasNearbyAlivePlayer`: alive, not a spectator, in the level.
|
||||
let players: Vec<_> = self
|
||||
.level_players()
|
||||
.into_iter()
|
||||
.filter(|p| p.alive && !p.spectator)
|
||||
.map(|p| p.position)
|
||||
.collect();
|
||||
let mut sprung = Vec::new();
|
||||
for m in &mut self.mobs {
|
||||
if m.species() != Species::SkeletonHorse || !m.extra.trap || !m.alive() {
|
||||
@@ -296,7 +298,10 @@ impl Game<'_> {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if player.is_some_and(|p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE) {
|
||||
if players
|
||||
.iter()
|
||||
.any(|&p| m.distance_sqr(p) < TRAP_RANGE * TRAP_RANGE)
|
||||
{
|
||||
sprung.push(m.id);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -102,11 +102,12 @@ impl RaidLevel for Lvl<'_, '_> {
|
||||
&& g.res.facts().is_air(g.world.block(x, y, z))
|
||||
}
|
||||
fn player(&self) -> Option<RaidPlayer> {
|
||||
let p = self.game.player.as_ref()?;
|
||||
// The first player in the level: a server has no player of its own.
|
||||
let p = self.game.level_players().into_iter().next()?;
|
||||
Some(RaidPlayer {
|
||||
position: [p.position.x, p.position.y, p.position.z],
|
||||
block: block_of(p.position),
|
||||
alive: !p.health.dead_or_dying(),
|
||||
alive: p.alive,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -174,12 +175,13 @@ impl PatrolLevel for PatrolCx<'_, '_, '_> {
|
||||
fn bright_outside(&self) -> bool {
|
||||
self.level.game.dim == Dim::Overworld && self.level.game.sky_darken() < 4
|
||||
}
|
||||
/// `PatrolSpawner.tick` picks from `level.players()`: the local player
|
||||
/// and every guest in the level.
|
||||
fn patrol_players(&self) -> Vec<([i32; 3], bool)> {
|
||||
let g = self.level.game;
|
||||
g.player
|
||||
.as_ref()
|
||||
.map(|p| (block_of(p.position), g.spectator()))
|
||||
.into_iter()
|
||||
self.level
|
||||
.players
|
||||
.iter()
|
||||
.map(|p| (block_of(p.position), p.spectator))
|
||||
.collect()
|
||||
}
|
||||
fn sections_to_village(&self, pos: [i32; 3]) -> i32 {
|
||||
@@ -633,7 +635,7 @@ impl Game<'_> {
|
||||
/// `Raid.playSound`: the horn, 13 blocks away from the player toward the
|
||||
/// wave, for players within 64 blocks or in the raid.
|
||||
fn raid_horn(&mut self, id: i32, pos: [i32; 3]) {
|
||||
let Some(p) = self.player.as_ref().map(|p| p.position) else {
|
||||
let Some(p) = self.level_players().first().map(|p| p.position) else {
|
||||
return;
|
||||
};
|
||||
let in_raid = self.raiding.raids.get(id).is_some_and(|r| r.bar.player);
|
||||
|
||||
@@ -876,17 +876,26 @@ impl Game<'_> {
|
||||
/// `SculkSensorBlock.stepOn` and `SculkShriekerBlock.stepOn`: standing on
|
||||
/// them is heard (or seen) every tick.
|
||||
fn sculk_step_on(&mut self) {
|
||||
self.sculk_step_on_player();
|
||||
let mut standing: Vec<(Who, [f64; 3])> = Vec::new();
|
||||
if let Some(p) = self.player.as_ref()
|
||||
&& p.ground.on_ground
|
||||
{
|
||||
standing.push((Who::Player, [p.position.x, p.position.y, p.position.z]));
|
||||
}
|
||||
for m in &self.mobs {
|
||||
if m.alive() && m.on_ground {
|
||||
standing.push((Who::Mob(m.id), [m.position.x, m.position.y, m.position.z]));
|
||||
}
|
||||
}
|
||||
self.sculk_stand_on(standing);
|
||||
}
|
||||
/// `stepOn` for the player in place: the host, or a guest swapped in
|
||||
/// (`guest_server_tick`), as a server has no player of its own.
|
||||
pub(super) fn sculk_step_on_player(&mut self) {
|
||||
if let Some(p) = self.player.as_ref()
|
||||
&& p.ground.on_ground
|
||||
{
|
||||
let at = [p.position.x, p.position.y, p.position.z];
|
||||
self.sculk_stand_on(vec![(Who::Player, at)]);
|
||||
}
|
||||
}
|
||||
fn sculk_stand_on(&mut self, standing: Vec<(Who, [f64; 3])>) {
|
||||
for (who, at) in standing {
|
||||
// getOnPosLegacy: 0.2 below the feet.
|
||||
let key = (
|
||||
@@ -1108,23 +1117,10 @@ impl Game<'_> {
|
||||
/// in the way (`isUnobstructed`), and no block collision.
|
||||
fn warden_fits(&self, mob: &Mob) -> bool {
|
||||
let bounds = mob.bounds();
|
||||
let player_blocks = !self.spectator()
|
||||
&& self.player.as_ref().is_some_and(|p| {
|
||||
let w = f64::from(p.dimensions.width) / 2.0;
|
||||
let b = horizon_core::geometry::Aabb::new(
|
||||
horizon_core::geometry::Vec3::new(
|
||||
p.position.x - w,
|
||||
p.position.y,
|
||||
p.position.z - w,
|
||||
),
|
||||
horizon_core::geometry::Vec3::new(
|
||||
p.position.x + w,
|
||||
p.position.y + f64::from(p.dimensions.height),
|
||||
p.position.z + w,
|
||||
),
|
||||
);
|
||||
!p.health.dead_or_dying() && b.intersects(bounds)
|
||||
});
|
||||
let player_blocks = self
|
||||
.level_players()
|
||||
.iter()
|
||||
.any(|p| p.alive && !p.spectator && p.bounds.intersects(bounds));
|
||||
if player_blocks
|
||||
|| self
|
||||
.mobs
|
||||
|
||||
@@ -5,9 +5,8 @@ use super::Game;
|
||||
use horizon_client::{
|
||||
items::ItemStack,
|
||||
mobs::{Mob, Species, sniffer},
|
||||
particles::Particle,
|
||||
};
|
||||
use horizon_core::random::RandomSource;
|
||||
use horizon_core::{geometry::Vec3, random::RandomSource};
|
||||
|
||||
impl Game<'_> {
|
||||
/// The egg item at the parent (`Sniffer.spawnChildFromBreeding`; the
|
||||
@@ -46,15 +45,20 @@ impl Game<'_> {
|
||||
/// block's hit sound between the 1.7th and the 6th second of the
|
||||
/// digging animation) and `playSearchingSound`.
|
||||
pub(super) fn tick_sniffer_effects(&mut self) {
|
||||
let Some(camera) = self.player.as_ref().map(|p| p.position) else {
|
||||
// Vanilla runs these on each client: a sniffer within 32 blocks of
|
||||
// any player in the level (the host and the guests) shows them.
|
||||
let players = self.level_players();
|
||||
if players.is_empty() {
|
||||
return;
|
||||
};
|
||||
}
|
||||
for i in 0..self.mobs.len() {
|
||||
let m = &self.mobs[i];
|
||||
if m.species() != Species::Sniffer
|
||||
|| !m.alive()
|
||||
|| m.silent
|
||||
|| m.position.distance_squared(camera) > 32.0 * 32.0
|
||||
|| !players
|
||||
.iter()
|
||||
.any(|p| m.position.distance_squared(p.position) <= 32.0 * 32.0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
@@ -79,20 +83,20 @@ impl Game<'_> {
|
||||
}
|
||||
let head = sniffer::head_block(m);
|
||||
let below = self.world.block(head[0], head[1] - 1, head[2]);
|
||||
let Some((sprite, tint)) = self.particle_sprite(below, [head[0], head[1] - 1, head[2]])
|
||||
else {
|
||||
if self
|
||||
.particle_sprite(below, [head[0], head[1] - 1, head[2]])
|
||||
.is_none()
|
||||
{
|
||||
continue;
|
||||
};
|
||||
}
|
||||
let dust = [
|
||||
f64::from(head[0]) + 0.5,
|
||||
f64::from(head[1]) + 0.5 - f64::from(0.65_f32),
|
||||
f64::from(head[2]) + 0.5,
|
||||
];
|
||||
for _ in 0..30 {
|
||||
let particle =
|
||||
Particle::terrain(&mut self.world.random, dust, [0.0; 3], sprite.clone(), tint);
|
||||
self.particles.push(particle);
|
||||
}
|
||||
// Drawn in this window when it has one, and sent to the players
|
||||
// within 32 blocks (the server thread's window is one of them).
|
||||
self.landing_dust(None, below, Vec3::new(dust[0], dust[1], dust[2]), 30, 0.0);
|
||||
if self.mobs[i].age.is_multiple_of(10) {
|
||||
let hit = self.res.facts().get(below).sounds.hit.clone();
|
||||
self.audio.play(&hit, Some(at), 0.5, 0.5);
|
||||
|
||||
Reference in New Issue
Block a user