From e4bb8463b971be5585aa607f45be596f08a67755 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 16:07:47 +0200 Subject: [PATCH] Show the player list and the world border wall in the game Holding the player-list key draws tab_list's layout: in single player the local player with the list objective (vanilla shows nothing otherwise), on a server the listed players from PlayerInfoUpdate (game mode, latency, display name, list order, hat), the tab list header and footer, online mode for heads and the server's objectives, scores, display slots and teams, which now also feed the sidebar. The renderer draws the border wall with RenderPipelines.WORLD_BORDER's overlay blend and the forcefield texture, from border_render's buffer and transforms; the client border follows the server's border packets and ticks between them. The vignette reddens near the border. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 4 + crates/horizon-client/src/game/remote.rs | 249 ++++++++++++++++++- crates/horizon-client/src/game/scoreboard.rs | 56 +++++ 3 files changed, 308 insertions(+), 1 deletion(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 047fec3fd..bd506ad5f 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -756,6 +756,8 @@ struct Game<'a> { /// `WorldBorderRenderer` and its render state. border_renderer: horizon_client::border_render::BorderRenderer, border_state: horizon_client::border_render::BorderRenderState, + /// `Hud.tabList`: the player list's header, footer and heart states. + tab_list: horizon_client::tab_list::TabList, subtitles: subtitle_hud::SubtitleState, adv: advancements::AdvState, stats_ui: stats_screen::StatsUi, @@ -3118,6 +3120,7 @@ impl Game<'_> { batch.text(atlas, text, (w - tw) / 2.0, h - 59.0, u32::MAX, true); } self.draw_chat(&mut batch); + self.draw_tab_list(&mut batch); let atlas = &self.res.atlas; if let Some((_, ticks)) = self.sleeping { // Gui sleep overlay fading in over 100 ticks. @@ -8188,6 +8191,7 @@ pub fn run() -> Result<()> { border: Default::default(), border_renderer: Default::default(), border_state: Default::default(), + tab_list: Default::default(), subtitles: Default::default(), adv: Default::default(), stats_ui: Default::default(), diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 472c8d24b..83c132430 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -102,6 +102,16 @@ pub(super) struct Remote { pub chat_input: Option, action_bar: Option<(String, Instant)>, players: HashMap, + /// `ClientPacketListener.playerInfoMap` as player-list entries, and + /// which of them are listed. + tab_players: HashMap, + listed: std::collections::HashSet, + /// `ClientboundLoginPacket.onlineMode`: the player list shows heads. + online_mode: bool, + /// Player entities in the level: entity id to profile UUID. + level_players: HashMap, + /// The local player's profile UUID (always in the level). + profile: u128, destroying: Option<([i32; 3], u8, f32)>, destroy_delay: u32, placing: Option<([i32; 3], u64)>, @@ -126,6 +136,16 @@ fn face_direction(face: [i32; 3]) -> u8 { } } +/// A protocol number format as the scoreboard's. +fn number_format(f: &play::NumberFormat) -> horizon_client::scoreboard::NumberFormat { + use horizon_client::scoreboard::{NumberFormat, tag_to_json}; + match f { + play::NumberFormat::Blank => NumberFormat::Blank, + play::NumberFormat::Styled(t) => NumberFormat::Styled(tag_to_json(t)), + play::NumberFormat::Fixed(t) => NumberFormat::Fixed(tag_to_json(t)), + } +} + impl Game<'_> { /// Leave the title for a server (ConnectScreen): an empty world fed by the connection. pub(super) fn connect_server(&mut self, address: &str, name: &str) -> Result<()> { @@ -213,6 +233,11 @@ impl Game<'_> { chat_input: None, action_bar: None, players: HashMap::new(), + tab_players: HashMap::new(), + listed: Default::default(), + online_mode: false, + level_players: HashMap::new(), + profile: 0, destroying: None, destroy_delay: 0, placing: None, @@ -231,6 +256,8 @@ impl Game<'_> { if let Some(mut r) = self.remote.take() { r.session.disconnect(); } + self.tab_list.reset(); + self.score.board = Default::default(); self.streaming = Streaming::new(Arc::new(NoTerrain), self.res.context.clone(), 1); self.streaming.paused = true; self.world = World::new(self.res.facts.air, 0); @@ -238,6 +265,9 @@ impl Game<'_> { self.mobs.clear(); self.dropped.clear(); self.particles.clear(); + self.score.board = Default::default(); + self.tab_list = Default::default(); + self.border = Default::default(); self.screen = Screen::Playing; self.container = None; if let Some(r) = self.renderer.as_mut() { @@ -323,11 +353,14 @@ impl Game<'_> { } } Event::Joined { - registries, name, .. + registries, + name, + uuid, } => { self.set_registries(registries); if let Some(r) = self.remote.as_mut() { r.joined = true; + r.profile = uuid; r.status = format!("Joined as {name}; loading terrain..."); } } @@ -662,6 +695,7 @@ impl Game<'_> { match packet { C::Login(p) => { if let Some(r) = self.remote.as_mut() { + r.online_mode = p.online_mode; r.entity_id = p.player_id; r.view_distance = p.chunk_radius; } @@ -797,10 +831,20 @@ impl Game<'_> { .unwrap_or_default(); let yaw = horizon_protocol::buf::unpack_degrees(p.yaw); let head = horizon_protocol::buf::unpack_degrees(p.head_yaw); + if let Some(r) = self.remote.as_mut() { + if kind == "minecraft:player" { + r.level_players.insert(p.id, p.uuid); + } else { + r.level_players.remove(&p.id); + } + } self.spawn_entity(p.id, &kind, p.position, yaw, head); } C::RemoveEntities(p) => { for id in p.ids { + if let Some(r) = self.remote.as_mut() { + r.level_players.remove(&id); + } self.remove_entity(id); } } @@ -1068,7 +1112,45 @@ impl Game<'_> { } C::PlayerInfoUpdate(p) => { if let Some(r) = self.remote.as_mut() { + // handlePlayerInfoUpdate: new entries first, then every + // action on every known entry. + if p.actions & 1 != 0 { + for e in &p.entries { + if let Some(name) = &e.name { + r.tab_players.entry(e.uuid).or_insert_with(|| { + horizon_client::tab_list::TabPlayer::new(e.uuid, name.clone()) + }); + } + } + } for e in p.entries { + if let Some(t) = r.tab_players.get_mut(&e.uuid) { + if let Some(mode) = e.game_mode { + t.game_mode = mode; + } + if let Some(latency) = e.latency { + t.latency = latency; + } + if let Some(name) = &e.display_name { + t.display_name = + name.as_ref().map(horizon_client::scoreboard::tag_to_json); + } + if let Some(order) = e.list_order { + t.list_order = order; + } + if let Some(hat) = e.show_hat { + t.show_hat = hat; + } + match e.listed { + Some(true) => { + r.listed.insert(e.uuid); + } + Some(false) => { + r.listed.remove(&e.uuid); + } + None => {} + } + } if let Some(name) = e.name { r.players.insert(e.uuid, name); } @@ -1079,9 +1161,74 @@ impl Game<'_> { if let Some(r) = self.remote.as_mut() { for u in p.uuids { r.players.remove(&u); + r.tab_players.remove(&u); + r.listed.remove(&u); } } } + C::TabList(p) => { + // handleTabListCustomisation: empty text clears it. + let text = |t: &Tag| { + let json = horizon_client::scoreboard::tag_to_json(t); + let text = horizon_client::scoreboard::comp_text(&json); + (!text.plain().is_empty()).then_some(text) + }; + self.tab_list.header = text(&p.header); + self.tab_list.footer = text(&p.footer); + } + C::InitializeBorder(p) => { + let b = &mut self.border; + b.set_center([p.center_x, p.center_z]); + if p.lerp_time > 0 { + b.lerp_between(p.old_size, p.new_size, p.lerp_time); + } else { + b.set_size(p.new_size); + } + b.set_absolute_max_size(p.absolute_max_size); + b.warning_distance = p.warning_blocks; + b.warning_time = p.warning_time; + } + C::SetBorderCenter(p) => self.border.set_center([p.x, p.z]), + C::SetBorderLerpSize(p) => { + self.border + .lerp_between(p.old_size, p.new_size, p.lerp_time) + } + C::SetBorderSize(p) => self.border.set_size(p.size), + C::SetBorderWarningDelay(p) => self.border.warning_time = p.delay, + C::SetBorderWarningDistance(p) => self.border.warning_distance = p.blocks, + C::SetObjective(p) => self.remote_objective(p), + C::SetDisplayObjective(p) => { + // DisplaySlot ids: list, sidebar, below_name, then the team sidebars. + let slot = match p.slot { + 0 => "list".to_owned(), + 2 => "below_name".to_owned(), + n @ 3..=18 => format!( + "sidebar.team.{}", + horizon_client::text::COLORS[(n - 3) as usize].1 + ), + _ => "sidebar".to_owned(), + }; + let board = &mut self.score.board; + let objective = board.objective(&p.objective).map(|o| o.name.clone()); + board.set_display_objective(&slot, objective.as_deref()); + } + C::SetScore(p) => { + let board = &mut self.score.board; + if board.objective(&p.objective).is_some() { + let s = board.score_mut(&p.owner, &p.objective); + s.value = p.score; + s.display = p + .display + .as_ref() + .map(horizon_client::scoreboard::tag_to_json); + s.number_format = p.number_format.as_ref().map(number_format); + } + } + C::ResetScore(p) => match &p.objective { + Some(o) => self.score.board.reset_one(&p.owner, o), + None => self.score.board.reset_all(&p.owner), + }, + C::SetPlayerTeam(p) => self.remote_team(p), C::SetChunkCacheRadius(p) => { self.streaming.radius = self.settings.render_distance.min(p.distance + 1).max(2); if let Some(r) = self.remote.as_mut() { @@ -1103,6 +1250,104 @@ impl Game<'_> { } Ok(()) } + /// `handleAddObjective`: add, remove or change an objective. + fn remote_objective(&mut self, p: play::SetObjective) { + use horizon_client::scoreboard::{RenderType, tag_to_json}; + let board = &mut self.score.board; + match (p.method, p.display) { + (1, _) => board.remove_objective(&p.name), + (method, Some((name, render, format))) => { + let render = if render == 1 { + RenderType::Hearts + } else { + RenderType::Integer + }; + let format = format.as_ref().map(number_format); + if method == 0 { + board.add_objective( + &p.name, + "dummy", + tag_to_json(&name), + render, + false, + format, + ); + } else if let Some(o) = board.objective_mut(&p.name) { + o.display_name = tag_to_json(&name); + o.render_type = render; + o.number_format = format; + } + } + _ => {} + } + } + /// `handleSetPlayerTeamPacket`. + fn remote_team(&mut self, p: play::SetPlayerTeam) { + use horizon_client::scoreboard::{CollisionRule, Visibility, tag_to_json}; + let board = &mut self.score.board; + if p.method == 1 { + board.remove_team(&p.name); + return; + } + if p.method == 0 { + board.add_team(&p.name); + } + if let Some(params) = &p.parameters + && let Some(team) = board.team_mut(&p.name) + { + team.display_name = tag_to_json(¶ms.display_name); + team.prefix = tag_to_json(¶ms.prefix); + team.suffix = tag_to_json(¶ms.suffix); + team.color = params + .color + .and_then(|c| horizon_client::text::COLORS.get(c as usize)) + .map(|c| c.1.to_owned()); + team.allow_friendly_fire = params.options & 1 != 0; + team.see_friendly_invisibles = params.options & 2 != 0; + team.nametag_visibility = Visibility::ALL + .get(params.name_tag_visibility as usize) + .copied() + .unwrap_or(Visibility::Always); + team.collision_rule = CollisionRule::ALL + .get(params.collision_rule as usize) + .copied() + .unwrap_or(CollisionRule::Always); + } + match p.method { + 0 | 3 => { + for player in &p.players { + board.add_to_team(player, &p.name); + } + } + 4 => { + for player in &p.players { + board.remove_from_team(player); + } + } + _ => {} + } + } + /// The player list's view of the connection: the listed players, online + /// mode, and which players are in the level with an upside-down name. + pub(super) fn remote_tab_players( + &self, + ) -> Option<(Vec, bool, Vec)> { + let r = self.remote.as_ref()?; + let players: Vec<_> = r + .listed + .iter() + .filter_map(|u| r.tab_players.get(u).cloned()) + .collect(); + let upside_down = players + .iter() + .filter(|p| { + (p.name == "Dinnerbone" || p.name == "Grumm") + && (p.uuid == r.profile || r.level_players.values().any(|u| *u == p.uuid)) + }) + .map(|p| p.uuid) + .collect(); + Some((players, r.online_mode, upside_down)) + } /// ChatType decoration: `chat.translation_key` with sender/content parameters. fn format_chat(&self, bound: &play::ChatTypeBound, content: &str) -> String { let Some(r) = self.remote.as_ref() else { @@ -1266,6 +1511,8 @@ impl Game<'_> { if self.use_delay > 0 { self.use_delay -= 1; } + // ClientLevel.tick: the border's size change. + self.border.tick(); self.tick_remote_entities(); self.tick_hand(); self.tick_particles(); diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs index d6962d674..5361007df 100644 --- a/crates/horizon-client/src/game/scoreboard.rs +++ b/crates/horizon-client/src/game/scoreboard.rs @@ -559,6 +559,62 @@ impl Game<'_> { } } +impl Game<'_> { + /// `Hud.extractTabList`: the player list while the player-list key is + /// held. A single-player world lists only its player, so it shows only + /// with a `list` objective. + pub(super) fn draw_tab_list(&mut self, batch: &mut HudBatch) { + use horizon_client::tab_list::{self, TabInputs, TabPlayer}; + let chatting = self.remote.is_some() && self.remote_chat_open(); + let key = self.screen == super::Screen::Playing + && !chatting + && self.keys.contains(&winit::keyboard::KeyCode::Tab); + let (players, online_mode, upside_down) = match self.remote_tab_players() { + Some(remote) => remote, + None => { + // The integrated server: the local player, online mode, no ping. + let uuid = self.level.player_uuid.map_or(0, |u| { + u.iter() + .fold(0u128, |a, &w| (a << 32) | u128::from(w as u32)) + }); + let mut me = TabPlayer::new(uuid, PLAYER_NAME); + me.game_mode = self.mode_id(); + me.skin = "entity/player/wide/steve".into(); + (vec![me], true, Vec::new()) + } + }; + let board = &self.score.board; + let objective = board.display_objective(sb::SLOT_LIST); + let shown = tab_list::visible( + key, + self.remote.is_none(), + players.len(), + objective.is_some(), + ); + self.tab_list.set_visible(shown); + if !shown { + return; + } + let up = |id: u128| upside_down.contains(&id); + let inputs = TabInputs { + players: &players, + board, + objective, + screen_width: batch.width as i32, + online_mode, + gui_ticks: self.ticks as i64, + // Horizon has no "chat background only" option: vanilla's default (on). + background: tab_list::row_background( + true, + f64::from(self.settings.text_background_opacity), + ), + upside_down: &up, + }; + let draws = self.tab_list.layout(&inputs, &self.res.atlas.font); + tab_list::paint(batch, &self.res.atlas, &draws); + } +} + /// The commands' view of the game. struct GameEnv<'a, 'b> { g: &'a mut Game<'b>,