Server: track each entity once for all its clients, as vanilla's ServerEntity

Every guest had its own copy of what it was last told about every entity,
so each tick compared each entity's data and built and encoded its update
packets once per guest. A level now keeps one ServerEntity state per
entity (ChunkMap.entityMap), whose changes are worked out once a tick,
encoded once and sent to every guest tracking it; a guest's Tracker is the
set of entities it is paired with. The update cadence is the entity's own
tickCount, as vanilla's, and late clients are paired with the data the
others hold. The per-tick copy of every entity state, the id lists and the
packet lists are gone too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-18 07:44:30 +02:00
parent 4b43242a61
commit c63fa74239
3 changed files with 528 additions and 242 deletions
+13
View File
@@ -174,6 +174,19 @@ impl PlayerSender {
self.deliver(Out::Packet(body));
}
}
/// Several packets in order, as [`Self::send`] each: under one lock
/// while the tick holds them.
pub fn send_many(&self, bodies: impl IntoIterator<Item = Vec<u8>>) {
if !HOLDING.get() {
bodies.into_iter().for_each(|body| self.send(body));
return;
}
let mut held = self.held();
for body in bodies {
self.pending.fetch_add(body.len(), Ordering::Relaxed);
held.push(body);
}
}
/// Hand the held packets to the writer thread.
pub fn flush(&self) {
let held = std::mem::take(&mut *self.held());
+462 -176
View File
@@ -1,8 +1,10 @@
//! Entity tracking (ChunkMap.TrackedEntity / ServerEntity): the game describes
//! every entity it simulates as an `EntityState` each tick; a `Tracker`
//! remembers what one client has been told and produces the spawn, movement,
//! motion, metadata, equipment and removal packets that bring it up to date,
//! at the entity type's update interval (`tracking`).
//! every entity it simulates as an `EntityState` each tick. A level's
//! `Entities` remember what its clients were last told about each entity,
//! once for all of them as vanilla's ServerEntity does, and produce the
//! movement, motion, metadata and equipment packets that bring them up to
//! date at the entity type's update interval (`tracking`); each client's
//! `Tracker` is the set of entities it has been paired with.
use super::tracking;
use horizon_protocol::{
buf::pack_degrees,
@@ -61,29 +63,6 @@ fn acceleration_power(kind: &str) -> Option<f64> {
}
}
/// What a client was last told about one entity (ServerEntity's fields).
struct Sent {
/// VecDeltaCodec's base: the last position sent.
base: [f64; 3],
/// lastSentYRot / lastSentXRot / lastSentYHeadRot.
rotation: (i8, i8),
head: i8,
/// lastSentMovement.
velocity: [f64; 3],
meta: Vec<(u8, i32, Value)>,
equipment: Vec<(u8, Option<Stack>)>,
was_on_ground: bool,
tick: u32,
teleport_delay: u32,
/// The type's update interval (0: never) and whether velocity is tracked.
interval: u32,
track_deltas: bool,
/// lastPassengers, and wasRiding: a passenger's position isn't synced,
/// and the first update after it dismounts is a full position sync.
passengers: Vec<i32>,
was_riding: bool,
}
/// Who rides what this tick (`Entity.getPassengers`, `isPassenger`).
#[derive(Default)]
pub struct Riding {
@@ -114,9 +93,42 @@ impl Riding {
}
}
#[derive(Default)]
pub struct Tracker {
sent: crate::fast_hash::FxHashMap<i32, Sent>,
/// What a level's clients were last told about one entity (ServerEntity's
/// fields), shared by every client that tracks it.
struct ServerEntity {
/// The registry id of its type (None: a type the clients don't know,
/// never paired).
kind: Option<i32>,
/// The type's tracking range in chunks, update interval (0: never),
/// whether velocity is tracked, whether it is an `AbstractArrow` and its
/// `AbstractHurtingProjectile.accelerationPower`.
range: i32,
interval: u32,
track_deltas: bool,
arrow: bool,
power: Option<f64>,
/// VecDeltaCodec's base: the last position sent.
base: [f64; 3],
/// lastSentYRot / lastSentXRot / lastSentYHeadRot.
rotation: (i8, i8),
head: i8,
/// lastSentMovement.
velocity: [f64; 3],
/// trackedDataValues: the entity data the clients hold.
meta: Vec<(u8, i32, Value)>,
equipment: Vec<(u8, Option<Stack>)>,
was_on_ground: bool,
tick: u32,
teleport_delay: u32,
/// lastPassengers, and wasRiding: a passenger's position isn't synced,
/// and the first update after it dismounts is a full position sync.
passengers: Vec<i32>,
was_riding: bool,
/// The level tick it was last seen in, its place in that tick's list, and
/// whether it was added in it (its first update is the next tick's).
seen: u32,
index: usize,
added: bool,
}
/// VecDeltaCodec.encode.
@@ -124,116 +136,94 @@ fn encode(v: f64) -> i64 {
(v * 4096.0).round() as i64
}
/// The type's tracking range in chunks: a client sees an entity of `kind`
/// within it, capped by the view distance, horizontally
/// (TrackedEntity.updatePlayer).
pub fn tracking_chunks(kind: &str) -> i32 {
i32::from(tracking::settings(kind).0)
}
impl Tracker {
pub fn is_tracking(&self, id: i32) -> bool {
self.sent.contains_key(&id)
}
pub fn ids(&self) -> Vec<i32> {
self.sent.keys().copied().collect()
}
pub fn forget(&mut self, id: i32) {
self.sent.remove(&id);
}
pub fn clear(&mut self) {
self.sent.clear();
}
pub fn len(&self) -> usize {
self.sent.len()
}
pub fn is_empty(&self) -> bool {
self.sent.is_empty()
impl ServerEntity {
/// `new ServerEntity`: the entity as it is when it joins the level.
fn new(e: &EntityState, kind: Option<i32>, riding: &Riding) -> Self {
let (range, interval, track_deltas) = tracking::settings(&e.kind);
Self {
kind,
range: i32::from(range),
interval,
track_deltas,
arrow: is_arrow(&e.kind),
power: acceleration_power(&e.kind),
base: e.position,
rotation: (pack_degrees(e.pitch), pack_degrees(e.yaw)),
head: pack_degrees(e.head_yaw),
velocity: e.velocity,
meta: e.meta.clone(),
equipment: e.equipment.clone(),
was_on_ground: e.on_ground,
tick: 0,
teleport_delay: 0,
passengers: riding.passengers(e.id).to_vec(),
was_riding: false,
seen: 0,
index: 0,
added: true,
}
}
/// The packets that introduce an entity (ServerEntity.sendPairingData).
pub fn spawn(
&mut self,
/// ServerEntity.sendPairingData: the packets that introduce the entity
/// to a client that starts tracking it.
fn pairing(
&self,
e: &EntityState,
entity_type: i32,
kind: i32,
riding: &Riding,
) -> Vec<play::Clientbound> {
let rotation = (pack_degrees(e.pitch), pack_degrees(e.yaw));
let head = pack_degrees(e.head_yaw);
let (_, interval, track_deltas) = tracking::settings(&e.kind);
let mut out = vec![play::Clientbound::AddEntity(AddEntity {
out: &mut Vec<play::Clientbound>,
) {
out.push(play::Clientbound::AddEntity(AddEntity {
id: e.id,
uuid: e.uuid,
kind: entity_type,
kind,
position: e.position,
velocity: e.velocity,
pitch: rotation.0,
yaw: rotation.1,
head_yaw: head,
pitch: pack_degrees(e.pitch),
yaw: pack_degrees(e.yaw),
head_yaw: pack_degrees(e.head_yaw),
data: e.data,
})];
if !e.meta.is_empty() {
}));
if !self.meta.is_empty() {
out.push(play::Clientbound::SetEntityData(SetEntityData {
id: e.id,
values: e.meta.clone(),
values: self.meta.clone(),
}));
}
if !e.equipment.is_empty() {
if !self.equipment.is_empty() {
out.push(play::Clientbound::SetEquipment(SetEquipment {
id: e.id,
slots: e.equipment.clone(),
slots: self.equipment.clone(),
}));
}
let passengers = riding.passengers(e.id).to_vec();
if !passengers.is_empty() {
if !riding.passengers(e.id).is_empty() {
out.push(riding.set_passengers(e.id));
}
if let Some(&vehicle) = riding.vehicle.get(&e.id) {
out.push(riding.set_passengers(vehicle));
}
self.sent.insert(
e.id,
Sent {
base: e.position,
rotation,
head,
velocity: e.velocity,
meta: e.meta.clone(),
equipment: e.equipment.clone(),
was_on_ground: e.on_ground,
tick: 0,
teleport_delay: 0,
interval,
track_deltas,
passengers,
was_riding: false,
},
);
out
}
/// Changes since the last update (ServerEntity.sendChanges): movement and
/// rotation every update interval (positions at least every 60 ticks, a
/// full position sync every 400 or when the entity lands or leaves the
/// ground), velocity for types that track it, changed data at once.
pub fn update(&mut self, e: &EntityState, riding: &Riding) -> Vec<play::Clientbound> {
let Some(s) = self.sent.get_mut(&e.id) else {
return Vec::new();
};
let mut out = Vec::new();
fn send_changes(&mut self, e: &EntityState, riding: &Riding, out: &mut Vec<play::Clientbound>) {
let passengers = riding.passengers(e.id);
if passengers != s.passengers.as_slice() {
if passengers != self.passengers.as_slice() {
out.push(riding.set_passengers(e.id));
s.passengers = passengers.to_vec();
self.passengers.clear();
self.passengers.extend_from_slice(passengers);
}
let dirty = e.meta != s.meta;
let due = s.interval != 0 && s.tick.is_multiple_of(s.interval);
// SynchedEntityData.isDirty: once for every client.
let dirty = e.meta != self.meta;
let due = self.interval != 0 && self.tick.is_multiple_of(self.interval);
if due || dirty {
let rotation = (pack_degrees(e.pitch), pack_degrees(e.yaw));
let turned = |a: i8, b: i8| (i32::from(a) - i32::from(b)).abs() >= 1;
let arrow = is_arrow(&e.kind);
let rotate =
arrow || turned(rotation.1, s.rotation.1) || turned(rotation.0, s.rotation.0);
let rotate = self.arrow
|| turned(rotation.1, self.rotation.1)
|| turned(rotation.0, self.rotation.0);
if riding.vehicle.contains_key(&e.id) {
// A passenger: its rotation alone (its vehicle places it).
if rotate {
@@ -245,19 +235,19 @@ impl Tracker {
on_ground: e.on_ground,
},
)));
s.rotation = rotation;
self.rotation = rotation;
}
s.base = e.position;
s.was_riding = true;
Self::send_dirty(e, s, dirty, &mut out);
Self::send_head(e, s, &mut out);
s.tick += 1;
Self::send_equipment(e, s, &mut out);
return out;
self.base = e.position;
self.was_riding = true;
self.send_dirty(e, dirty, out);
self.send_head(e, out);
self.tick += 1;
self.send_equipment(e, out);
return;
}
s.teleport_delay += 1;
let d: f64 = (0..3).map(|k| (e.position[k] - s.base[k]).powi(2)).sum();
let send_position = arrow || d >= 7.629_394_5e-6 || s.tick.is_multiple_of(60);
self.teleport_delay += 1;
let d: f64 = (0..3).map(|k| (e.position[k] - self.base[k]).powi(2)).sum();
let send_position = self.arrow || d >= 7.629_394_5e-6 || self.tick.is_multiple_of(60);
let sync = EntityPositionSync {
id: e.id,
path: PositionPath::Linear(e.position),
@@ -267,16 +257,16 @@ impl Tracker {
};
// ServerEntity.createMovePacket.
let packet = if e.precise
|| s.teleport_delay > 400
|| s.was_riding
|| s.was_on_ground != e.on_ground
|| self.teleport_delay > 400
|| self.was_riding
|| self.was_on_ground != e.on_ground
{
s.was_on_ground = e.on_ground;
s.teleport_delay = 0;
s.was_riding = false;
self.was_on_ground = e.on_ground;
self.teleport_delay = 0;
self.was_riding = false;
Some(play::Clientbound::EntityPositionSync(sync))
} else if send_position {
let delta = [0, 1, 2].map(|k| encode(e.position[k]) - encode(s.base[k]));
let delta = [0, 1, 2].map(|k| encode(e.position[k]) - encode(self.base[k]));
if delta.iter().any(|v| i16::try_from(*v).is_err()) {
Some(play::Clientbound::EntityPositionSync(sync))
} else {
@@ -304,18 +294,18 @@ impl Tracker {
} else {
None
};
if s.track_deltas {
if self.track_deltas {
let diff: f64 = (0..3)
.map(|k| (e.velocity[k] - s.velocity[k]).powi(2))
.map(|k| (e.velocity[k] - self.velocity[k]).powi(2))
.sum();
let still = e.velocity.iter().all(|v| *v == 0.0);
if diff > 1.0e-7 || diff > 0.0 && still {
s.velocity = e.velocity;
self.velocity = e.velocity;
let motion = play::Clientbound::SetEntityMotion(SetEntityMotion {
id: e.id,
velocity: e.velocity,
});
match acceleration_power(&e.kind) {
match self.power {
// A bundle: the motion and the projectile's power.
Some(power) => out.extend([
play::Clientbound::BundleDelimiter(horizon_protocol::packets::Empty),
@@ -339,29 +329,28 @@ impl Tracker {
};
out.push(packet);
if position {
s.base = e.position;
self.base = e.position;
}
if rotated {
s.rotation = rotation;
self.rotation = rotation;
}
}
Self::send_dirty(e, s, dirty, &mut out);
Self::send_head(e, s, &mut out);
self.send_dirty(e, dirty, out);
self.send_head(e, out);
}
s.tick += 1;
Self::send_equipment(e, s, &mut out);
out
self.tick += 1;
self.send_equipment(e, out);
}
/// ServerEntity.sendDirtyEntityData.
fn send_dirty(e: &EntityState, s: &mut Sent, dirty: bool, out: &mut Vec<play::Clientbound>) {
fn send_dirty(&mut self, e: &EntityState, dirty: bool, out: &mut Vec<play::Clientbound>) {
if !dirty {
return;
}
let changed: Vec<_> = e
.meta
.iter()
.filter(|m| !s.meta.contains(m))
.filter(|m| !self.meta.contains(m))
.cloned()
.collect();
if !changed.is_empty() {
@@ -370,31 +359,31 @@ impl Tracker {
values: changed,
}));
}
s.meta = e.meta.clone();
self.meta.clone_from(&e.meta);
}
fn send_head(e: &EntityState, s: &mut Sent, out: &mut Vec<play::Clientbound>) {
fn send_head(&mut self, e: &EntityState, out: &mut Vec<play::Clientbound>) {
let head = pack_degrees(e.head_yaw);
if (i32::from(head) - i32::from(s.head)).abs() >= 1 {
if (i32::from(head) - i32::from(self.head)).abs() >= 1 {
out.push(play::Clientbound::RotateHead(RotateHead {
id: e.id,
head_yaw: head,
}));
s.head = head;
self.head = head;
}
}
/// LivingEntity.detectEquipmentUpdates: changed slots every tick.
fn send_equipment(e: &EntityState, s: &mut Sent, out: &mut Vec<play::Clientbound>) {
if e.equipment != s.equipment {
fn send_equipment(&mut self, e: &EntityState, out: &mut Vec<play::Clientbound>) {
if e.equipment != self.equipment {
// Cleared slots are sent as empty stacks.
let mut slots: Vec<(u8, Option<Stack>)> = e
.equipment
.iter()
.filter(|m| !s.equipment.contains(m))
.filter(|m| !self.equipment.contains(m))
.cloned()
.collect();
for (slot, _) in &s.equipment {
for (slot, _) in &self.equipment {
if !e.equipment.iter().any(|(k, _)| k == slot) {
slots.push((*slot, None));
}
@@ -405,11 +394,195 @@ impl Tracker {
slots,
}));
}
s.equipment = e.equipment.clone();
self.equipment.clone_from(&e.equipment);
}
}
}
/// The entities one client tracks (`TrackedEntity.seenBy`, from the
/// client's side).
#[derive(Default)]
pub struct Tracker {
seen: crate::fast_hash::FxHashSet<i32>,
}
impl Tracker {
pub fn is_tracking(&self, id: i32) -> bool {
self.seen.contains(&id)
}
pub fn ids(&self) -> Vec<i32> {
self.seen.iter().copied().collect()
}
pub fn clear(&mut self) {
self.seen.clear();
}
pub fn len(&self) -> usize {
self.seen.len()
}
pub fn is_empty(&self) -> bool {
self.seen.is_empty()
}
}
/// Who a level's entities are tracked by this tick: a client's position,
/// view distance and chunks.
pub struct Viewer<'a> {
pub entity_id: i32,
pub position: [f64; 3],
pub view_distance: i32,
pub chunks: &'a crate::fast_hash::FxHashSet<(i32, i32)>,
pub tracker: &'a mut Tracker,
/// What the tick sends it, in order.
pub out: &'a mut Vec<Vec<u8>>,
}
/// TrackedEntity.updatePlayer: within the type's range (capped by the view
/// distance) horizontally, in a chunk the client has.
fn sees(
position: [f64; 3],
view_distance: i32,
chunks: &crate::fast_hash::FxHashSet<(i32, i32)>,
e: &EntityState,
range: i32,
) -> bool {
let range = f64::from(range.min(view_distance) * 16);
let (dx, dz) = (position[0] - e.position[0], position[2] - e.position[2]);
let chunk = (
(e.position[0].floor() as i32) >> 4,
(e.position[2].floor() as i32) >> 4,
);
dx * dx + dz * dz <= range * range && chunks.contains(&chunk)
}
/// One level's tracked entities (ChunkMap.entityMap).
#[derive(Default)]
pub struct Entities {
states: crate::fast_hash::FxHashMap<i32, ServerEntity>,
/// The level tick, stamped on every entity still in the level.
tick: u32,
/// This tick's tracking range of each entity, and what each client
/// makes of each entity ([`SEES`], [`TRACKS`]), kept between ticks.
ranges: Vec<i32>,
flags: Vec<Vec<u8>>,
/// One entity's packets and their bodies, kept between entities.
packets: Vec<play::Clientbound>,
bodies: Vec<Vec<u8>>,
}
/// The client sees the entity this tick, and already tracked it.
const SEES: u8 = 1;
const TRACKS: u8 = 2;
fn encode_all(packets: &[play::Clientbound], bodies: &mut Vec<Vec<u8>>) {
bodies.clear();
bodies.extend(packets.iter().map(play::Clientbound::encode));
}
impl Entities {
pub fn len(&self) -> usize {
self.states.len()
}
pub fn is_empty(&self) -> bool {
self.states.is_empty()
}
/// One tick of ChunkMap.tick for the entities in the level now and the
/// clients in it: each client first loses the entities that left its
/// range or the level (one ClientboundRemoveEntitiesPacket), then each
/// entity's changes are made once and go to every client tracking it,
/// and the clients that start tracking it are paired with it. A client
/// never tracks its own entity. `kind` names a type's registry id.
pub fn tick(
&mut self,
entities: &[&EntityState],
riding: &Riding,
viewers: &mut [Viewer],
mut kind: impl FnMut(&str) -> Option<i32>,
) {
self.tick = self.tick.wrapping_add(1);
let now = self.tick;
self.ranges.clear();
for (index, e) in entities.iter().enumerate() {
let s = self
.states
.entry(e.id)
.or_insert_with(|| ServerEntity::new(e, kind(&e.kind), riding));
s.seen = now;
s.index = index;
self.ranges.push(s.range);
}
self.flags.resize_with(viewers.len(), Vec::new);
for (v, flags) in viewers.iter_mut().zip(&mut self.flags) {
flags.clear();
let mut kept = 0;
flags.extend(entities.iter().zip(&self.ranges).map(|(e, &range)| {
if e.id == v.entity_id || !sees(v.position, v.view_distance, v.chunks, e, range) {
0
} else if v.tracker.seen.contains(&e.id) {
kept += 1;
SEES | TRACKS
} else {
SEES
}
}));
// Usually the client still sees all it tracks.
let mut removed = Vec::new();
if kept != v.tracker.seen.len() {
let states = &self.states;
v.tracker.seen.retain(|id| match states.get(id) {
Some(s) if s.seen == now && flags[s.index] & TRACKS != 0 => true,
_ => {
removed.push(*id);
false
}
});
}
if !removed.is_empty() {
v.out.push(
play::Clientbound::RemoveEntities(play::RemoveEntities { ids: removed })
.encode(),
);
}
}
for (index, e) in entities.iter().enumerate() {
let Some(s) = self.states.get_mut(&e.id) else {
continue;
};
self.packets.clear();
if !s.added {
s.send_changes(e, riding, &mut self.packets);
}
s.added = false;
let mut encoded = false;
let mut pairing: Option<Vec<Vec<u8>>> = None;
for (v, flags) in viewers.iter_mut().zip(&self.flags) {
let f = flags[index];
if f & TRACKS != 0 {
if self.packets.is_empty() {
continue;
}
if !encoded {
encode_all(&self.packets, &mut self.bodies);
encoded = true;
}
v.out.extend(self.bodies.iter().cloned());
} else if f & SEES != 0
&& let Some(kind) = s.kind
{
let bodies = pairing.get_or_insert_with(|| {
let mut packets = Vec::new();
s.pairing(e, kind, riding, &mut packets);
packets.iter().map(play::Clientbound::encode).collect()
});
v.out.extend(bodies.iter().cloned());
v.tracker.seen.insert(e.id);
}
}
}
self.states.retain(|_, s| s.seen == now);
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -432,39 +605,49 @@ mod tests {
}
}
/// The entity as added this tick, then its updates (one a tick).
fn added(e: &EntityState) -> ServerEntity {
ServerEntity::new(e, Some(100), &Riding::default())
}
fn changes(s: &mut ServerEntity, e: &EntityState) -> Vec<play::Clientbound> {
let mut out = Vec::new();
s.send_changes(e, &Riding::default(), &mut out);
out
}
#[test]
fn moves_go_out_every_update_interval() {
let mut t = Tracker::default();
let spawn = t.spawn(&state(0.0), 100, &Riding::default());
assert!(matches!(spawn[0], play::Clientbound::AddEntity(_)));
let mut s = added(&state(0.0));
let mut spawn = Vec::new();
s.pairing(&state(0.0), 100, &Riding::default(), &mut spawn);
assert!(matches!(spawn[..], [play::Clientbound::AddEntity(_)]));
// Tick 0 is due and a multiple of 60: the position goes out unchanged.
assert!(matches!(
t.update(&state(0.0), &Riding::default())[..],
changes(&mut s, &state(0.0))[..],
[play::Clientbound::MoveEntityPos(_)]
));
// A zombie updates every third tick.
assert!(t.update(&state(0.5), &Riding::default()).is_empty());
assert!(t.update(&state(0.5), &Riding::default()).is_empty());
assert!(changes(&mut s, &state(0.5)).is_empty());
assert!(changes(&mut s, &state(0.5)).is_empty());
assert!(matches!(
t.update(&state(0.5), &Riding::default())[..],
changes(&mut s, &state(0.5))[..],
[play::Clientbound::MoveEntityPos(_)]
));
for _ in 0..2 {
t.update(&state(40.0), &Riding::default());
changes(&mut s, &state(40.0));
}
let jump = t.update(&state(40.0), &Riding::default());
let jump = changes(&mut s, &state(40.0));
assert!(matches!(jump[0], play::Clientbound::EntityPositionSync(_)));
}
#[test]
fn fireballs_bundle_their_motion_with_their_power() {
let mut t = Tracker::default();
let mut e = state(0.0);
e.kind = "minecraft:fireball".into();
e.on_ground = false;
t.spawn(&e, 100, &Riding::default());
let mut s = added(&e);
e.velocity = [0.0, 0.0, 0.5];
let out = t.update(&e, &Riding::default());
let out = changes(&mut s, &e);
assert!(matches!(
out[..],
[
@@ -479,53 +662,49 @@ mod tests {
#[test]
fn arrows_send_position_and_rotation_every_update() {
let mut t = Tracker::default();
let mut e = state(0.0);
e.kind = "minecraft:arrow".into();
t.spawn(&e, 100, &Riding::default());
let mut s = added(&e);
assert!(matches!(
t.update(&e, &Riding::default())[..],
changes(&mut s, &e)[..],
[play::Clientbound::MoveEntityPosRot(_)]
));
}
#[test]
fn precise_entities_sync_their_position() {
let mut t = Tracker::default();
let mut e = state(0.0);
e.kind = "minecraft:tnt".into();
e.precise = true;
t.spawn(&e, 100, &Riding::default());
let mut s = added(&e);
assert!(matches!(
t.update(&e, &Riding::default())[..],
changes(&mut s, &e)[..],
[play::Clientbound::EntityPositionSync(_)]
));
}
#[test]
fn landing_sends_a_position_sync() {
let mut t = Tracker::default();
let mut e = state(0.0);
t.spawn(&e, 100, &Riding::default());
t.update(&e, &Riding::default());
let mut s = added(&e);
changes(&mut s, &e);
e.on_ground = false;
t.update(&e, &Riding::default());
t.update(&e, &Riding::default());
changes(&mut s, &e);
changes(&mut s, &e);
assert!(matches!(
t.update(&e, &Riding::default())[..],
changes(&mut s, &e)[..],
[play::Clientbound::EntityPositionSync(_)]
));
}
#[test]
fn metadata_and_equipment_send_only_the_changes() {
let mut t = Tracker::default();
let mut e = state(0.0);
t.spawn(&e, 100, &Riding::default());
t.update(&e, &Riding::default());
let mut s = added(&e);
changes(&mut s, &e);
e.meta.push((0, 0, Value::Byte(1)));
e.equipment.push((0, Some(Stack::new(5, 1))));
let out = t.update(&e, &Riding::default());
let out = changes(&mut s, &e);
assert!(
out.iter()
.any(|p| matches!(p, play::Clientbound::SetEntityData(_)))
@@ -534,12 +713,119 @@ mod tests {
out.iter()
.any(|p| matches!(p, play::Clientbound::SetEquipment(_)))
);
assert!(t.update(&e, &Riding::default()).is_empty());
assert!(changes(&mut s, &e).is_empty());
e.equipment.clear();
let out = t.update(&e, &Riding::default());
let out = changes(&mut s, &e);
let Some(play::Clientbound::SetEquipment(eq)) = out.first() else {
panic!("expected equipment");
};
assert_eq!(eq.slots, vec![(0, None)]);
}
/// Two clients at the origin; the chunks they hold.
struct Clients {
chunks: crate::fast_hash::FxHashSet<(i32, i32)>,
trackers: [Tracker; 2],
out: [Vec<Vec<u8>>; 2],
positions: [[f64; 3]; 2],
}
impl Clients {
fn new() -> Self {
Self {
chunks: (-4..4).flat_map(|x| (-4..4).map(move |z| (x, z))).collect(),
trackers: Default::default(),
out: Default::default(),
positions: [[0.0, 64.0, 0.0]; 2],
}
}
fn tick(&mut self, level: &mut Entities, entities: &[&EntityState]) {
for out in &mut self.out {
out.clear();
}
let [t0, t1] = &mut self.trackers;
let [o0, o1] = &mut self.out;
let mut viewers = [
Viewer {
entity_id: 1,
position: self.positions[0],
view_distance: 10,
chunks: &self.chunks,
tracker: t0,
out: o0,
},
Viewer {
entity_id: 2,
position: self.positions[1],
view_distance: 10,
chunks: &self.chunks,
tracker: t1,
out: o1,
},
];
level.tick(entities, &Riding::default(), &mut viewers, |_| Some(100));
}
}
fn body(p: play::Clientbound) -> Vec<u8> {
p.encode()
}
#[test]
fn every_client_gets_the_same_changes_and_late_ones_are_paired() {
let mut level = Entities::default();
let mut c = Clients::new();
// The second client is out of range at first.
c.positions[1] = [500.0, 64.0, 0.0];
let mut e = state(0.0);
c.tick(&mut level, &[&e]);
assert!(c.trackers[0].is_tracking(7) && !c.trackers[1].is_tracking(7));
assert!(c.out[1].is_empty());
// Tick 0's forced position goes to the client tracking it.
c.tick(&mut level, &[&e]);
assert_eq!(c.out[0].len(), 1);
// The second client comes in range: paired with the entity as it is,
// then sent the same changes as the first.
c.positions[1] = [0.0, 64.0, 0.0];
e.position[0] = 1.0;
c.tick(&mut level, &[&e]);
assert!(c.trackers[1].is_tracking(7));
assert!(c.out[0].is_empty());
assert_eq!(c.out[1].len(), 1);
c.tick(&mut level, &[&e]);
e.position[0] = 2.0;
c.tick(&mut level, &[&e]);
assert!(!c.out[0].is_empty());
assert_eq!(c.out[0], c.out[1]);
}
#[test]
fn clients_lose_what_leaves_range_or_the_level_and_never_track_themselves() {
let mut level = Entities::default();
let mut c = Clients::new();
let mut me = state(0.0);
me.id = 1;
me.kind = "minecraft:player".into();
let mut e = state(0.0);
c.tick(&mut level, &[&me, &e]);
assert!(!c.trackers[0].is_tracking(1) && c.trackers[1].is_tracking(1));
assert!(c.trackers[0].is_tracking(7));
// Out of the zombie's 8 chunks.
e.position[0] = 200.0;
c.tick(&mut level, &[&me, &e]);
assert!(!c.trackers[0].is_tracking(7));
let removed = body(play::Clientbound::RemoveEntities(play::RemoveEntities {
ids: vec![7],
}));
assert_eq!(c.out[0].first(), Some(&removed));
// Gone from the level: the other client loses it too, and so does
// the level.
e.position[0] = 0.0;
c.tick(&mut level, &[&me, &e]);
assert!(c.trackers[0].is_tracking(7));
c.tick(&mut level, &[&me]);
assert!(!c.trackers[0].is_tracking(7) && !c.trackers[1].is_tracking(7));
assert_eq!(c.out[0].first(), Some(&removed));
assert_eq!(level.len(), 1);
}
}
+53 -66
View File
@@ -8,7 +8,7 @@ use super::{
Lan, NetEvent,
chunks::ChunkEncoder,
data::SyncData,
entity::EntityState,
entity::{Entities, EntityState, Viewer},
guest::{Guest, SentEffect, stack_to_network},
};
use crate::{
@@ -148,6 +148,10 @@ pub struct Hub {
clock_ids: Vec<i32>,
item_ids: std::collections::HashMap<Arc<str>, i32>,
entity_types: std::collections::HashMap<String, i32>,
/// Each level's tracked entities, by dimension.
entities: std::collections::HashMap<String, Entities>,
/// What one tick of entity tracking sends each guest, kept between ticks.
entity_out: Vec<Vec<Vec<u8>>>,
}
fn string(s: &str) -> Tag {
@@ -201,6 +205,20 @@ fn yellow_names(key: &str, names: Vec<Tag>) -> Tag {
])
}
/// An entity type's registry id, remembered once looked up.
fn entity_type(
types: &mut std::collections::HashMap<String, i32>,
sync: &SyncData,
kind: &str,
) -> Option<i32> {
if let Some(id) = types.get(kind) {
return Some(*id);
}
let id = sync.builtin.get("minecraft:entity_type")?.id(kind)?;
types.insert(kind.to_owned(), id);
Some(id)
}
/// ChunkTrackingView.contains: the chunks a player at (cx, cz) with view
/// distance `r` is sent (isWithinDistance with the neighbours' buffer).
fn tracked(cx: i32, cz: i32, r: i32, x: i32, z: i32) -> bool {
@@ -259,6 +277,8 @@ impl Hub {
clock_ids,
item_ids: Default::default(),
entity_types: Default::default(),
entities: Default::default(),
entity_out: Vec::new(),
}
}
@@ -292,14 +312,6 @@ impl Hub {
let sync = self.sync.clone();
stack_to_network(|_| id, |name| sync.id("minecraft:enchantment", name), s)
}
fn entity_type(&mut self, kind: &str) -> Option<i32> {
if let Some(id) = self.entity_types.get(kind) {
return Some(*id);
}
let id = self.sync.builtin.get("minecraft:entity_type")?.id(kind)?;
self.entity_types.insert(kind.to_owned(), id);
Some(id)
}
pub fn broadcast(&self, packet: &C) {
let body = packet.encode();
@@ -1493,65 +1505,40 @@ impl Hub {
})
.collect();
all.extend(guest_states);
all.extend(ctx.entities.iter().cloned());
let by_id: std::collections::HashMap<i32, usize> =
all.iter().enumerate().map(|(i, e)| (e.id, i)).collect();
// Each entity type's tracking range, looked up once rather than for
// every player.
let ranges: Vec<i32> = all
.iter()
.map(|e| super::entity::tracking_chunks(&e.kind))
let entities: Vec<&EntityState> = all.iter().chain(ctx.entities).collect();
// ChunkMap.tick: the level's entities, once for all its players.
let mut level = self
.entities
.remove(&self.config.dimension)
.unwrap_or_default();
let mut outs = std::mem::take(&mut self.entity_out);
let dimension = &self.config.dimension;
let here = |g: &Guest| g.placed && g.dimension == *dimension;
outs.resize_with(self.guests.iter().filter(|g| here(g)).count(), Vec::new);
let mut viewers: Vec<Viewer> = self
.guests
.iter_mut()
.filter(|g| here(g))
.zip(outs.iter_mut())
.map(|(g, out)| Viewer {
entity_id: g.entity_id,
position: g.position,
view_distance: g.view_distance,
chunks: &g.sent_chunks,
tracker: &mut g.tracker,
out,
})
.collect();
for gi in 0..self.guests.len() {
if !self.here(&self.guests[gi]) {
continue;
}
let view = self.guests[gi].view_distance;
let me = self.guests[gi].entity_id;
let origin = self.guests[gi].position;
// TrackedEntity.updatePlayer: within the type's range (capped by the
// view distance) horizontally, in a chunk the client has.
let visible = |g: &Guest, ei: usize| {
let e = &all[ei];
let range = f64::from(ranges[ei].min(view) * 16);
let (dx, dz) = (origin[0] - e.position[0], origin[2] - e.position[2]);
let chunk = (
(e.position[0].floor() as i32) >> 4,
(e.position[2].floor() as i32) >> 4,
);
dx * dx + dz * dz <= range * range && g.sent_chunks.contains(&chunk)
};
// Forget what disappeared or left range.
let mut removed = Vec::new();
for id in self.guests[gi].tracker.ids() {
match by_id.get(&id) {
Some(&ei) if visible(&self.guests[gi], ei) => {}
_ => removed.push(id),
}
}
if !removed.is_empty() {
for id in &removed {
self.guests[gi].tracker.forget(*id);
}
self.guests[gi].send(&C::RemoveEntities(play::RemoveEntities { ids: removed }));
}
for (ei, e) in all.iter().enumerate() {
if e.id == me {
continue;
}
if self.guests[gi].tracker.is_tracking(e.id) {
let packets = self.guests[gi].tracker.update(e, &self.riding);
self.guests[gi].send_all(&packets);
} else if visible(&self.guests[gi], ei) {
let Some(kind) = self.entity_type(&e.kind) else {
continue;
};
// Players need their list entry first; guests got it at join.
let packets = self.guests[gi].tracker.spawn(e, kind, &self.riding);
self.guests[gi].send_all(&packets);
}
}
let (types, sync) = (&mut self.entity_types, &self.sync);
level.tick(&entities, &self.riding, &mut viewers, |kind| {
entity_type(types, sync, kind)
});
drop(viewers);
for (g, out) in self.guests.iter().filter(|g| here(g)).zip(outs.iter_mut()) {
g.sender.send_many(out.drain(..));
}
self.entity_out = outs;
self.entities.insert(self.config.dimension.clone(), level);
}
/// ServerPlayer.stopSleepInBed: the wake-up animation goes to the player