Server players finish vanilla's FULL square, not a 1.5x circle

DistanceManager.PlayerTicketTracker gives every chunk within the server's
view distance (Chebyshev) of a player a PLAYER_LOADING ticket at level 31,
so FULL (33) reaches two chunks past it and FEATURES and TERRAIN one and
two more. A server player's streaming area was a circle of radius
(view distance + 2) * 3 / 2 + 1, finished one further: 2.1x the chunks at
view distance 12. It is now that square, and lan status reports the
server world's chunk counts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-17 21:12:18 +02:00
parent d223b383ee
commit c6531e4bde
2 changed files with 92 additions and 27 deletions
+15 -3
View File
@@ -363,6 +363,12 @@ impl Game<'_> {
"open": true,
"host": h.host_name,
"port": h.settings.port,
// The server's own world: its finished chunks and how many it
// has generated or loaded so far.
"world": {
"chunks": self.world.chunks.len(),
"generated": self.streaming.generated_total,
},
"guests": h.hub.guests.iter().map(|g| json!({
"name": g.name,
"position": g.position,
@@ -1063,14 +1069,20 @@ impl Game<'_> {
/// Keep the chunks around every guest loaded.
fn lan_update_streaming(&mut self, host: &LanHost) {
// DistanceManager.PlayerTicketTracker: every chunk within the server's
// view distance (Chebyshev) of a player holds a PLAYER_LOADING ticket
// at the entity-ticking level (31), whatever the player asked for;
// levels rise by one a chunk, so FULL (33) reaches two chunks past
// it. An extra area finishes its chunks out to its radius + 1. That
// covers what the player tracks (`ChunkTrackingView`, within its view
// distance + 1) and those chunks' lit neighbours.
let radius = host.hub.config.view_distance + 1;
self.streaming.extra = host
.hub
.guests
.iter()
.filter(|g| host.hub.here(g))
// The tracked square's corners and their lit neighbours lie
// within (view distance + 2) * √2 of the player's chunk.
.map(|g| (g.chunk(), (g.view_distance + 2) * 3 / 2 + 1))
.map(|g| (g.chunk(), radius))
.collect();
}
+77 -24
View File
@@ -200,8 +200,10 @@ pub struct Streaming {
/// Chunks come from a server (`insert_remote`/`forget`): nothing is
/// generated and columns are only unloaded when the server says so.
pub remote: bool,
/// More areas to keep loaded (centre chunk, radius), e.g. around guests
/// of a world open to the network. They are generated and kept but not meshed.
/// More areas to keep loaded (centre chunk, radius), e.g. around the
/// players of a server. Each is a square, like vanilla's ticket levels:
/// chunks finish out to `radius + 1` (Chebyshev) and generation reaches
/// past that as around the player. They are generated and kept but not meshed.
pub extra: Vec<((i32, i32), i32)>,
/// Mesh the sections for drawing (false on a server thread).
pub mesh: bool,
@@ -788,20 +790,17 @@ impl Streaming {
world.dirty_sections.retain(|k| !far.contains(&(k.0, k.2)));
}
// Drop far proto chunks that are not checked out.
let areas: Vec<((i32, i32), i64)> =
std::iter::once((self.center, i64::from(self.radius + 4)))
.chain(self.extra.iter().map(|&(c, r)| (c, i64::from(r + 4))))
.collect();
let forced = &self.forced;
let (center, r4) = (self.center, i64::from(self.radius + 4));
let ranges = self.ranges();
let far: Vec<(i32, i32)> = self
.protos
.iter()
.filter(|&(&(x, z), p)| {
p.is_some()
&& !areas.iter().any(|&((cx, cz), r4)| {
i64::from(x - cx).pow(2) + i64::from(z - cz).pow(2) <= r4 * r4
})
&& !forced
&& i64::from(x - center.0).pow(2) + i64::from(z - center.1).pow(2) > r4 * r4
&& !ranges.in_extra(x, z, 4)
&& !ranges
.forced
.iter()
.any(|f| (x - f.0).abs() <= 3 && (z - f.1).abs() <= 3)
})
@@ -1277,21 +1276,21 @@ impl Ranges<'_> {
/// circles, so a fixed margin alone misses the corners of those squares
/// (render distance 2 never finished the chunks next to the player).
fn near_finished(&self, x: i32, z: i32, reach: i32) -> bool {
let near = |c: (i32, i32), radius: i32| {
let gap = |d: i32| i64::from((d.abs() - reach).max(0));
let (dx, dz) = (gap(x - c.0), gap(z - c.1));
let r = i64::from(radius + 1);
dx * dx + dz * dz <= r * r
};
near(self.center, self.radius) || self.extra.iter().any(|&(c, r)| near(c, r))
let gap = |d: i32| i64::from((d.abs() - reach).max(0));
let (dx, dz) = (gap(x - self.center.0), gap(z - self.center.1));
let r = i64::from(self.radius + 1);
// The extra areas are squares: their finished square grown by `reach`.
dx * dx + dz * dz <= r * r || self.in_extra(x, z, 1 + reach)
}
fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
self.in_main_range(x, z, margin)
|| self.extra.iter().any(|&(c, radius)| {
let r = i64::from(radius + margin);
let (dx, dz) = (i64::from(x - c.0), i64::from(z - c.1));
dx * dx + dz * dz <= r * r
})
self.in_main_range(x, z, margin) || self.in_extra(x, z, margin)
}
/// Within `margin` of an extra area's square (Chebyshev distance, as
/// vanilla's ticket levels spread).
fn in_extra(&self, x: i32, z: i32, margin: i32) -> bool {
self.extra
.iter()
.any(|&(c, radius)| (x - c.0).abs().max((z - c.1).abs()) <= radius + margin)
}
/// The columns meshed for drawing: those vanilla draws around the
/// player (`in_view_distance`), and forced ones.
@@ -1778,4 +1777,58 @@ mod tests {
}
}
}
/// A server player's area (`lan_update_streaming`: the server view
/// distance + 1) finishes vanilla's FULL square: PLAYER_LOADING tickets at
/// level 31 out to the view distance, FULL (33) two chunks past it. Every
/// chunk the player tracks has its 3x3 neighbourhood finished, so it can
/// be lit and sent, and generation reaches vanilla's FEATURES (34) and
/// TERRAIN (35) rings.
#[test]
fn server_player_areas_finish_vanillas_full_square() {
let forced = HashSet::new();
for view in 2..=32 {
let extra = [((40, -9), view + 1)];
let r = Ranges {
// The window's own area, far away.
center: (-400, 300),
radius: 2,
extra: &extra,
forced: &forced,
};
let level = |x: i32, z: i32| 31 + ((x - 40).abs().max((z + 9).abs()) - view).max(0);
for x in 40 - view - 8..=40 + view + 8 {
for z in -9 - view - 8..=-9 + view + 8 {
assert_eq!(
r.in_range(x, z, 1),
level(x, z) <= 33,
"view {view}: ({x}, {z})"
);
assert_eq!(
r.requested(x, z, true),
level(x, z) <= 35,
"view {view}: ({x}, {z})"
);
assert_eq!(
r.unloaded(x, z, true),
level(x, z) > 35,
"view {view}: ({x}, {z})"
);
// ChunkTrackingView.contains, at any view distance the player may ask for.
let tracked = |v: i64| {
let gap = |d: i32| i64::from(((d).abs() - 2).max(0));
gap(x - 40).pow(2) + gap(z + 9).pow(2) < v * v
};
if tracked(i64::from(view)) {
for (dx, dz) in (-1..=1).flat_map(|dx| (-1..=1).map(move |dz| (dx, dz))) {
assert!(
r.in_range(x + dx, z + dz, 1),
"view {view}: ({x}, {z}) tracked, not lit"
);
}
}
}
}
}
}
}