Merge pull request #1150 from ludovic111/fix/locator-bar-per-level

🤖 Agent: merged. Verify passes. B5's local integration of all its PRs on main: parity --changed 102/102, plus lan_e2e (flakes listed in FEATURES.md LATER 4l).
This commit is contained in:
Ludovic Marie
2026-10-22 04:05:15 +02:00
committed by GitHub
5 changed files with 165 additions and 48 deletions
+4 -3
View File
@@ -61,9 +61,10 @@ pub(super) struct LanHost {
pub mob_players: HashMap<u32, u32>,
/// An integrated server's owner (game/integrated.rs).
pub owner: Option<Owner>,
/// The players' locator bars (game/lan_waypoints.rs), and the guests who
/// are dead, whose respawn replaces their waypoint.
pub waypoints: lan::waypoints::Waypoints,
/// The players' locator bars, one waypoint manager per level by
/// dimension id (game/lan_waypoints.rs), and the guests who are dead,
/// whose respawn replaces their waypoint.
pub waypoints: std::collections::HashMap<String, lan::waypoints::Waypoints>,
pub waypoint_dead: std::collections::HashSet<u128>,
/// Guests' commands waiting for the hub to be back in `self.lan`, where
/// a command can reach every player (game/lan_actions.rs).
+72 -36
View File
@@ -1,5 +1,5 @@
//! The locator bar of the players on a served world (lan/waypoints.rs): what
//! each player looks like to the waypoint manager this tick.
//! each player looks like to their level's waypoint manager this tick.
use super::{Game, lan::LanHost};
use horizon_client::{
items::ItemStack,
@@ -27,8 +27,12 @@ impl Game<'_> {
Some((team.name.clone(), color))
}
/// Each level's `ServerWaypointManager` ticked with the players in that
/// level: a player who changes level leaves the old one's manager
/// (`ServerLevel.removePlayerImmediately`: untracked for everyone there)
/// and joins the new one's (`addDuringTeleport`).
pub(super) fn lan_update_waypoints(&mut self, host: &mut LanHost, state: Option<&HostState>) {
let mut players = Vec::new();
let mut players: Vec<(&str, waypoints::Player)> = Vec::new();
if let Some(h) = state {
let icon = self
.cmds
@@ -39,22 +43,25 @@ impl Game<'_> {
color: i.color,
})
.unwrap_or_default();
players.push(waypoints::Player {
uuid: h.uuid,
conn: None,
position: h.position,
spectator: self.spectator(),
transmit_range: transmit_range(
h.sneaking,
self.potions.effects.get("invisibility").is_some(),
h.equipment[5].as_ref(),
),
receive_range: PLAYER_RANGE,
first_tick: false,
view_distance: host.hub.config.view_distance,
team: self.waypoint_team(&h.name),
icon,
});
players.push((
self.dim.id(),
waypoints::Player {
uuid: h.uuid,
conn: None,
position: h.position,
spectator: self.spectator(),
transmit_range: transmit_range(
h.sneaking,
self.potions.effects.get("invisibility").is_some(),
h.equipment[5].as_ref(),
),
receive_range: PLAYER_RANGE,
first_tick: false,
view_distance: host.hub.config.view_distance,
team: self.waypoint_team(&h.name),
icon,
},
));
}
let mut respawned = Vec::new();
for g in host.hub.guests.iter().filter(|g| g.placed) {
@@ -66,27 +73,56 @@ impl Game<'_> {
}
// Player.updatePlayerPose: the shift key crouches unless flying.
let crouching = g.sneaking && !g.flying && !g.fall_flying && !g.sleeping;
players.push(waypoints::Player {
uuid: g.uuid,
conn: Some(g.conn),
position: g.position,
spectator: g.spectator(),
transmit_range: transmit_range(
crouching,
g.effects.get("invisibility").is_some(),
g.armor[0].as_ref(),
),
receive_range: PLAYER_RANGE,
first_tick: g.ticks == 0,
view_distance: g.view_distance,
team: self.waypoint_team(&g.name),
icon: Icon::default(),
});
players.push((
&g.dimension,
waypoints::Player {
uuid: g.uuid,
conn: Some(g.conn),
position: g.position,
spectator: g.spectator(),
transmit_range: transmit_range(
crouching,
g.effects.get("invisibility").is_some(),
g.armor[0].as_ref(),
),
receive_range: PLAYER_RANGE,
first_tick: g.ticks == 0,
view_distance: g.view_distance,
team: self.waypoint_team(&g.name),
icon: Icon::default(),
},
));
}
host.waypoint_dead
.retain(|uuid| players.iter().any(|p| p.uuid == *uuid));
.retain(|uuid| players.iter().any(|(_, p)| p.uuid == *uuid));
let locator_bar = self.ui.rules.bool("locator_bar");
for (conn, packet) in host.waypoints.tick(&players, &respawned, locator_bar) {
let mut levels: Vec<String> = host.waypoints.keys().cloned().collect();
for (level, _) in &players {
if !levels.iter().any(|l| l == level) {
levels.push((*level).to_owned());
}
}
levels.sort();
let mut out = Vec::new();
for level in levels {
let here: Vec<waypoints::Player> = players
.iter()
.filter(|(l, _)| *l == level)
.map(|(_, p)| p.clone())
.collect();
let away: Vec<(u128, u32)> = players
.iter()
.filter(|(l, _)| *l != level)
.filter_map(|(_, p)| Some((p.uuid, p.conn?)))
.collect();
let manager = host.waypoints.entry(level.clone()).or_default();
out.extend(manager.tick_level(&here, &away, &respawned, locator_bar));
// Nobody left in the level: nothing to remember there.
if here.is_empty() {
host.waypoints.remove(&level);
}
}
for (conn, packet) in out {
if let Some(g) = host.hub.guest(conn) {
g.send(&packet);
}
+50 -1
View File
@@ -153,6 +153,9 @@ pub struct Waypoints {
/// One tick's players, and the packets for their connections.
struct Tick<'a> {
players: HashMap<u128, &'a Player>,
/// The connections of the players in other levels: one who just left this level is
/// still told of the waypoints it loses (`removePlayer` disconnects them).
away: &'a [(u128, u32)],
view: HashMap<u128, ([i32; 2], i32)>,
/// Players a respawn replaced this tick: a new ServerPlayer, on its first tick.
fresh: &'a [u128],
@@ -169,7 +172,17 @@ impl<'a> Tick<'a> {
icon: &Icon,
target: WaypointTarget,
) {
let Some(conn) = self.players.get(&receiver).and_then(|p| p.conn) else {
let Some(conn) = self
.players
.get(&receiver)
.and_then(|p| p.conn)
.or_else(|| {
self.away
.iter()
.find(|(uuid, _)| *uuid == receiver)
.map(|&(_, conn)| conn)
})
else {
return;
};
self.out
@@ -449,9 +462,22 @@ impl Waypoints {
players: &[Player],
respawned: &[u128],
locator_bar: bool,
) -> Vec<(u32, C)> {
self.tick_level(players, &[], respawned, locator_bar)
}
/// [`Self::tick`] for one level of several: `away` are the connections of the players
/// in the other levels, for the untracks owed to one who has just left this one.
pub fn tick_level(
&mut self,
players: &[Player],
away: &[(u128, u32)],
respawned: &[u128],
locator_bar: bool,
) -> Vec<(u32, C)> {
let mut t = Tick {
players: players.iter().map(|p| (p.uuid, p)).collect(),
away,
view: HashMap::default(),
fresh: respawned,
enabled: locator_bar,
@@ -632,6 +658,29 @@ mod tests {
assert_eq!(to(&out, 20), [(1, WaypointTarget::Empty)]);
}
#[test]
fn a_player_leaving_the_level_loses_its_waypoints() {
let (a, b) = (
player(1, 10, [0.5, 64.0, 0.5]),
player(2, 20, [4.5, 64.0, 0.5]),
);
let mut w = Waypoints::default();
w.tick(&[a.clone(), b.clone()], &[], true);
let mut moved = b.clone();
moved.position = [5.5, 64.0, 0.5];
w.tick(&[a.clone(), moved], &[], true);
// B goes to another level: A loses B, and B (reached through `away`) loses A.
let out = w.tick_level(std::slice::from_ref(&a), &[(2, 20)], &[], true);
assert_eq!(
to(&out, 10),
vec![(waypoint_operation::UNTRACK, WaypointTarget::Empty)]
);
assert_eq!(
to(&out, 20),
vec![(waypoint_operation::UNTRACK, WaypointTarget::Empty)]
);
}
#[test]
fn team_colours() {
assert_eq!(team_rgb("red"), Some(0xFF5555));
+23 -3
View File
@@ -93,9 +93,29 @@ def run_side(label, server_command, client_command, build, world):
return out.read_text(encoding='utf-8').splitlines()
SHOWN = ('add', 'remove', 'respawn', 'track', 'untrack', 'update')
def settled(lines):
"""One player's lines of one step, in order, with the waypoint packets reduced to the last for each waypoint:
what the locator bar shows once the step is over. Arriving in a level, vanilla sends the same waypoint more
than once on the way there; the packet by packet order is test_locator_bar_parity's."""
def waypoint(line):
parts = line.split(' ')
return parts[3] if len(parts) > 3 and parts[2] in ('track', 'untrack', 'update') else None
last = {waypoint(l): i for i, l in enumerate(lines) if waypoint(l)}
return [l for i, l in enumerate(lines) if not waypoint(l) or last[waypoint(l)] == i]
def shown(lines):
"""Each player's adds, removes and respawns, without the waypoints (the locator bar harness has those)."""
return [l for l in lines if l.split(' ', 2)[2:3] and l.split(' ', 2)[2].split(' ')[0] in ('add', 'remove', 'respawn')]
"""Each player's adds, removes, respawns and waypoints (as the step leaves them), step by step; sorted within a
step (the packets of one step may leave in another order within the tick)."""
steps = {}
for line in lines:
parts = line.split(' ', 2)
if len(parts) == 3 and parts[2].split(' ')[0] in SHOWN:
steps.setdefault((parts[0], parts[1]), []).append(line)
return [l for key in steps for l in sorted(settled(steps[key]))]
def main():
@@ -139,7 +159,7 @@ def main():
java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0],
lines=len(vanilla), output_sha256=lab.digest(build / 'horizon.txt', 'sha256'),
scope='Two players on a dedicated server changing dimensions (Nether, End, back): the other players each '
'is sent and loses, and the dimensions it respawns into.'))
'is sent and loses, the dimensions it respawns into and its locator bar waypoints.'))
print(f'server dimension players: {len(vanilla)} lines identical')
+16 -5
View File
@@ -11,8 +11,9 @@ vanilla generated first, with Alice and Bob as operators in creative. LocatorBar
of vanilla's protocol code) and records, step by step, the system chat each receives and what the server changes
about it: game mode events, teleports, inventory slots, effects, its death (with the death message), the other
players it is sent or loses and the levels it respawns into. Each player's lines in each step are compared exactly,
in sorted order (the packets of one step may leave in another order within the tick). The locator bar's waypoints
and what a death does besides its messages are left to their own harnesses.
in sorted order (the packets of one step may leave in another order within the tick), with the locator bar's
waypoints as each step leaves them (one manager per level: a player in another level is untracked). What a death does besides its messages
is left to its own harness.
"""
import hashlib
import os
@@ -78,11 +79,21 @@ SCRIPT = [
]
# What the players' locator bars show has its own harness (test_locator_bar_parity), and what a death does
# besides its messages (drops, the body leaving) the player combat ones: here only the messages of `kill`.
WAYPOINTS = ('track ', 'untrack ', 'update ')
DEATH_STEP = 'step=console-kill'
STEP_SECONDS = 2.5
def settled(lines):
"""One player's lines of one step, in order, with the waypoint packets reduced to the last for each waypoint:
what the locator bar shows once the step is over. Arriving in a level, vanilla sends the same waypoint more
than once on the way there; the packet by packet order is test_locator_bar_parity's."""
def waypoint(line):
parts = line.split(' ')
return parts[3] if len(parts) > 3 and parts[2] in ('track', 'untrack', 'update') else None
last = {waypoint(l): i for i, l in enumerate(lines) if waypoint(l)}
return [l for i, l in enumerate(lines) if not waypoint(l) or last[waypoint(l)] == i]
def run_side(label, server_command, client_command, build, world):
directory = build / label
port = server_dir(directory, world)
@@ -134,13 +145,13 @@ def run_side(label, server_command, client_command, build, world):
# At the death, Alice picks up Bob's drops (and gets their advancements) in vanilla.
death_side = step == DEATH_STEP and (not rest.startswith(('chat ', 'killed '))
or 'chat.type.advancement' in rest)
if rest.startswith(WAYPOINTS) or death_side:
if death_side:
continue
if step != 'step=start':
steps.setdefault((who, step), []).append(line)
order = {f'step={s}': i for i, (s, _, _) in enumerate(SCRIPT)}
keys = sorted(steps, key=lambda k: (k[0], order.get(k[1], -1)))
return [l for k in keys for l in sorted(steps[k])], errors
return [l for k in keys for l in sorted(settled(steps[k]))], errors
def main():