From 37f6481e14323e4696f3134b5aae5d8dc228227a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 15 Oct 2026 22:36:48 +0200 Subject: [PATCH] Server list rows: favicons, styled MOTDs, player count colours, icon arrows OnlineServerEntry draws the server's 64x64 favicon (from servers.dat, then from each ping, saved back like updateServerList), the description as a styled component with legacy codes, formatPlayerCount's dark grey with grey numbers, and on hover the join and move arrows over the icon. The icon's right half joins, its left quarters move the server up or down. Fixes #365, #378, #370 Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/front.rs | 10 +- crates/horizon-client/src/multiplayer.rs | 384 +++++++++++++++++++---- crates/horizon-client/src/title.rs | 1 + 3 files changed, 333 insertions(+), 62 deletions(-) diff --git a/crates/horizon-client/src/front.rs b/crates/horizon-client/src/front.rs index e6224683f..b63853935 100644 --- a/crates/horizon-client/src/front.rs +++ b/crates/horizon-client/src/front.rs @@ -840,8 +840,14 @@ fn multiplayer_page(ui: &mut Ui, x: f32, w: f32, screen: &Screen, caret: bool) { Some(Ping::Ok { motd, players, ms, .. }) => ( - motd.lines().next().unwrap_or("").trim().to_owned(), - format!("{players} · {ms} ms"), + motd.resolve_legacy() + .plain() + .lines() + .next() + .unwrap_or("") + .trim() + .to_owned(), + format!("{} · {ms} ms", Ping::player_count(*players).plain()), color::ACCENT, ), Some(Ping::Failed(_)) => ( diff --git a/crates/horizon-client/src/multiplayer.rs b/crates/horizon-client/src/multiplayer.rs index dc6541e91..f48a4dd50 100644 --- a/crates/horizon-client/src/multiplayer.rs +++ b/crates/horizon-client/src/multiplayer.rs @@ -4,7 +4,7 @@ //! ServerStatusPinger to show the MOTD, player count and latency. use crate::hud::{HudAtlas, HudBatch, rgba}; use crate::lan::discovery::Scanner; -use crate::text::{Text, format_translation}; +use crate::text::{DARK_GRAY, GRAY, Text, format_translation}; use horizon_protocol::servers::{self, ServerEntry}; use std::{ collections::HashMap, @@ -18,14 +18,36 @@ use std::{ pub enum Ping { Pinging, Ok { - motd: String, - players: String, + /// The description component, styled (`sanitizeDescription`). + motd: Text, + /// Online and max players; None when the status has no `players`. + players: Option<(i64, i64)>, ms: u128, version: String, }, Failed(String), } +impl Ping { + /// ServerStatusPinger.formatPlayerCount: dark grey with grey numbers, + /// or `multiplayer.status.unknown` without a player count. + pub fn player_count(players: Option<(i64, i64)>) -> Text { + match players { + Some((online, max)) => Text::translate( + "multiplayer.status.player_count", + &[ + Text::colored(online.to_string(), GRAY), + Text::colored(max.to_string(), GRAY), + ], + ), + None => Text::translate("multiplayer.status.unknown", &[]), + } + .with_color(DARK_GRAY) + } +} type Pings = Arc>>; +/// Server icons by address as 64x64 RGBA (FaviconTexture), from servers.dat +/// and then from each ping's favicon. +type Icons = Arc>>>>; #[derive(Clone, Debug)] pub enum Screen { @@ -33,6 +55,7 @@ pub enum Screen { servers: Vec, selected: Option, pings: Pings, + icons: Icons, /// Worlds announced on the local network, listed after the servers. lan: Scanner, scroll: crate::ui::Scroll, @@ -75,24 +98,63 @@ pub fn servers_file(saves: &Path) -> PathBuf { .parent() .map_or_else(|| PathBuf::from("servers.dat"), |p| p.join("servers.dat")) } -fn ping_all(servers: &[ServerEntry], pings: &Pings) { +/// `FaviconTexture.upload`: a PNG of exactly 64x64 pixels, else no icon. +fn icon_pixels(png: &[u8]) -> Option>> { + crate::hud::decode_bytes(png) + .ok() + .filter(|(w, h, _)| *w == 64 && *h == 64) + .map(|(_, _, p)| Arc::new(p)) +} +/// `ServerStatus.Favicon.CODEC`: a base64 PNG behind the data URL prefix. +fn favicon_bytes(json: &serde_json::Value) -> Option> { + let url = json["favicon"].as_str()?; + let base64 = url + .strip_prefix("data:image/png;base64,")? + .replace('\n', ""); + crate::skins::base64_decode(&base64) +} +fn ping_all(servers: &[ServerEntry], pings: &Pings, icons: &Icons, file: &Path) { for s in servers { let address = s.ip.clone(); pings.lock().unwrap().insert(address.clone(), Ping::Pinging); - let pings = pings.clone(); + let saved = s.icon.clone(); + if let Some(pixels) = saved + .as_deref() + .and_then(crate::skins::base64_decode) + .and_then(|png| icon_pixels(&png)) + { + icons.lock().unwrap().insert(address.clone(), pixels); + } + let (pings, icons, file) = (pings.clone(), icons.clone(), file.to_owned()); let _ = std::thread::Builder::new() .name("horizon-ping".into()) .spawn(move || { let result = match crate::net::ping(&address, Duration::from_secs(5)) { Ok((json, ms)) => { - let lang = Default::default(); - let motd = crate::net::json_text(&json["description"], &lang); - let players = format!( - "{}/{}", - json["players"]["online"].as_i64().unwrap_or(0), - json["players"]["max"].as_i64().unwrap_or(0) - ); + let motd = crate::component::to_text(&json["description"], &mut |s| { + Text::literal(s) + }); + let players = json["players"].as_object().map(|p| { + ( + p.get("online").and_then(|n| n.as_i64()).unwrap_or(0), + p.get("max").and_then(|n| n.as_i64()).unwrap_or(0), + ) + }); let version = json["version"]["name"].as_str().unwrap_or("?").to_owned(); + // A new favicon replaces the saved one (an invalid one + // clears it) and servers.dat is saved again. + if let Some(png) = favicon_bytes(&json) { + let encoded = crate::lan::base64(&png); + let pixels = icon_pixels(&png); + match &pixels { + Some(p) => icons.lock().unwrap().insert(address.clone(), p.clone()), + None => icons.lock().unwrap().remove(&address), + }; + let icon = pixels.map(|_| encoded); + if icon != saved { + save_icon(&file, &address, icon); + } + } Ping::Ok { motd, players, @@ -106,6 +168,33 @@ fn ping_all(servers: &[ServerEntry], pings: &Pings) { }); } } +/// Save the list after a move or delete, keeping the icons pings stored in +/// servers.dat since it was loaded. +fn save_servers(file: &Path, servers: &mut [ServerEntry]) { + let _guard = SAVING.lock(); + let saved = servers::load(file); + for entry in servers.iter_mut() { + if let Some(s) = saved.iter().find(|s| s.ip == entry.ip) { + entry.icon = s.icon.clone(); + } + } + let _ = servers::save(file, servers); +} +/// Held while servers.dat is read and written back. +static SAVING: Mutex<()> = Mutex::new(()); +/// Store `icon` on the entries for `address` (OnlineServerEntry.updateServerList). +fn save_icon(file: &Path, address: &str, icon: Option) { + let _guard = SAVING.lock(); + let mut list = servers::load(file); + let mut changed = false; + for entry in list.iter_mut().filter(|e| e.ip == address) { + changed |= entry.icon != icon; + entry.icon = icon.clone(); + } + if changed { + let _ = servers::save(file, &list); + } +} /// The address of list row `index`: the saved servers, then the LAN games. fn entry_address(servers: &[ServerEntry], lan: &Scanner, index: usize) -> Option { @@ -168,6 +257,41 @@ fn row_at( } rows(servers, lan).nth(index as usize) } +/// SelectableEntry's hover areas over the 32-pixel icon, relative to it. +fn over_right_half(x: f32, y: f32) -> bool { + (16.0..32.0).contains(&x) && (0.0..32.0).contains(&y) +} +fn over_top_left(x: f32, y: f32) -> bool { + (0.0..16.0).contains(&x) && (0.0..16.0).contains(&y) +} +fn over_bottom_left(x: f32, y: f32) -> bool { + (0.0..16.0).contains(&x) && (16.0..32.0).contains(&y) +} +/// The server's favicon in icon slot `slot`, else `misc/unknown_server`. +fn draw_server_icon( + atlas: &HudAtlas, + batch: &mut HudBatch, + pixels: Option<&[u8]>, + slot: usize, + x: f32, + y: f32, +) { + let sprite = format!("horizon/world-icon{}", slot % crate::hud::WORLD_ICON_SLOTS); + if let Some(pixels) = pixels + && let Some(rect) = atlas.sprites.get(&sprite) + { + batch.patches.push(crate::font::Patch { + x: (rect.u0 * atlas.width as f32).round() as u32, + y: (rect.v0 * atlas.height as f32).round() as u32, + width: 64, + height: 64, + rgba: pixels.to_vec(), + }); + batch.sprite_scaled(atlas, &sprite, x, y, 32.0, 32.0, u32::MAX); + } else { + batch.sprite_scaled(atlas, "misc/unknown_server", x, y, 32.0, 32.0, u32::MAX); + } +} /// `LoadingDotsText.get`. fn loading_dots(millis: u128) -> &'static str { ["O o o", "o O o", "o o O", "o O o"][(millis / 300 % 4) as usize] @@ -243,11 +367,13 @@ impl Screen { pub fn list(saves: &Path) -> Self { let servers = servers::load(&servers_file(saves)); let pings: Pings = Arc::default(); - ping_all(&servers, &pings); + let icons: Icons = Arc::default(); + ping_all(&servers, &pings, &icons, &servers_file(saves)); Self::List { servers, selected: None, pings, + icons, lan: Scanner::start(), scroll: crate::ui::Scroll::default(), } @@ -459,7 +585,7 @@ impl Screen { true, ); } - pub fn draw(&self, atlas: &HudAtlas, batch: &mut HudBatch, blink: bool) { + pub fn draw(&self, atlas: &HudAtlas, batch: &mut HudBatch, blink: bool, cursor: (f32, f32)) { let (w, h) = (batch.width, batch.height); crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false); let centered = |batch: &mut HudBatch, text: &str, y: f32, color: u32| { @@ -471,6 +597,7 @@ impl Screen { servers, selected, pings, + icons, lan, scroll, } => { @@ -497,6 +624,9 @@ impl Screen { crate::ui::list_background(batch, atlas, top, bottom, false); let first = batch.vertices.len(); let pings = pings.lock().unwrap(); + let icons = icons.lock().unwrap(); + // The row under the pointer (`isHovered`). + let hovered = row_at(servers.len(), games.len(), cursor, (w, h), scroll.amount); let millis = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .map_or(0, |d| d.as_millis()); @@ -543,25 +673,18 @@ impl Screen { match row { Row::Server(k) => { let server = &servers[k]; - batch.sprite_scaled( - atlas, - "misc/unknown_server", - cx, - cy, - 32.0, - 32.0, - u32::MAX, - ); - batch.text(atlas, &server.name, cx + 35.0, cy + 1.0, u32::MAX, false); + let icon = icons.get(&server.ip); + draw_server_icon(atlas, batch, icon.map(|p| p.as_slice()), i, cx, cy); + batch.text(atlas, &server.name, cx + 35.0, cy + 1.0, u32::MAX, true); // OnlineServerEntry: up to two lines of MOTD, the - // player count left of the status icon. - let (motd, status, motd_color, icon) = match pings.get(&server.ip) { + // player count left of the status icon, all with + // GuiGraphics.text's shadow. + let (motd, status, sprite) = match pings.get(&server.ip) { Some(Ping::Ok { motd, players, ms, .. }) => ( - motd.clone(), - players.clone(), - gray, + motd.resolve_legacy(), + Ping::player_count(*players), format!( "server_list/ping_{}", match ms { @@ -574,12 +697,9 @@ impl Screen { ), ), Some(Ping::Failed(_)) => ( - crate::lang::get_or( - "multiplayer.status.cannot_connect", - "Can't connect to server", - ), - String::new(), - rgba(255, 0, 0, 255), + Text::translate("multiplayer.status.cannot_connect", &[]) + .with_color(0xFF0000), + Text::empty(), "server_list/unreachable".to_owned(), ), _ => { @@ -587,50 +707,71 @@ impl Screen { let frame = (millis / 100 + i as u128 * 2) & 7; let frame = if frame > 4 { 8 - frame } else { frame }; ( - crate::lang::get_or( - "multiplayer.status.pinging", - "Pinging...", - ), - String::new(), - gray, + Text::translate("multiplayer.status.pinging", &[]), + Text::empty(), format!("server_list/pinging_{}", frame + 1), ) } }; - for (n, line) in wrap(&motd, ROW_WIDTH - 4.0 - 34.0, atlas) + for (n, line) in atlas + .font + .split(&motd, ROW_WIDTH - 4.0 - 32.0 - 2.0) .iter() .take(2) .enumerate() { - batch.text( + batch.text_styled( atlas, line, cx + 35.0, cy + 12.0 + 9.0 * n as f32, - motd_color, - false, + gray, + true, ); } let icon_x = cx + ROW_WIDTH - 4.0 - 15.0; batch.sprite_scaled( atlas, - &format!("gui/sprites/{icon}"), + &format!("gui/sprites/{sprite}"), icon_x, cy, 10.0, 8.0, u32::MAX, ); - if !status.is_empty() { - let sw = HudBatch::text_width(atlas, &status).ceil(); - batch.text( - atlas, - &status, - icon_x - sw - 5.0, - cy + 1.0, - gray, - false, - ); + let sw = atlas.font.width_text(&status).ceil(); + batch.text_styled( + atlas, + &status, + icon_x - sw - 5.0, + cy + 1.0, + gray, + true, + ); + // Hovering the row: the join arrow over the icon + // and the move arrows, each highlighted under + // the pointer. + if hovered == Some(row) { + let (rx, ry) = (cursor.0 - cx, cursor.1 - cy); + batch.fill(atlas, cx, cy, 32.0, 32.0, 0xA0909090); + for (sprite, shown, over) in [ + ("join", true, over_right_half(rx, ry)), + ("move_up", k > 0, over_top_left(rx, ry)), + ("move_down", k + 1 < servers.len(), over_bottom_left(rx, ry)), + ] { + if shown { + let lit = if over { "_highlighted" } else { "" }; + batch.sprite_scaled( + atlas, + &format!("gui/sprites/server_list/{sprite}{lit}"), + cx, + cy, + 32.0, + 32.0, + u32::MAX, + ); + } + } } } Row::LanHeader => { @@ -809,7 +950,7 @@ impl Screen { && i < servers.len() { servers.remove(i); - let _ = servers::save(&servers_file(saves), servers); + save_servers(&servers_file(saves), servers); } } (Self::List { .. }, Some(45)) => *self = Self::list(saves), @@ -831,9 +972,34 @@ impl Screen { if scroll.press((x, y), left + ROW_WIDTH + 8.0, top, bottom, content) { return Outcome::None; } + let row = row_at(servers.len(), games, (x, y), (w, h), scroll.amount); + // OnlineServerEntry.mouseClicked: the icon's right half joins, + // its left quarters move the server up or down (and keep it + // selected). + if let Some(Row::Server(k)) = row { + let row_top = top + 2.0 - scroll.amount.trunc() + k as f32 * ROW_HEIGHT; + let (rx, ry) = ((x - left - 2.0).floor(), (y - row_top - 2.0).floor()); + if over_right_half(rx, ry) { + *selected = Some(k); + return Outcome::Connect(servers[k].ip.clone()); + } + let to = if k > 0 && over_top_left(rx, ry) { + Some(k - 1) + } else if k + 1 < servers.len() && over_bottom_left(rx, ry) { + Some(k + 1) + } else { + None + }; + if let Some(to) = to { + servers.swap(k, to); + save_servers(&servers_file(saves), servers); + *selected = Some(to); + return Outcome::None; + } + } // Clicking a selected row again joins it; the LAN header // takes the click without anything to join. - let index = match row_at(servers.len(), games, (x, y), (w, h), scroll.amount) { + let index = match row { Some(Row::Server(k)) => Some(k), Some(Row::Lan(k)) => Some(servers.len() + k), Some(Row::LanHeader) => { @@ -1071,8 +1237,8 @@ mod tests { pings.insert( "server0".into(), Ping::Ok { - motd: String::new(), - players: String::new(), + motd: Text::empty(), + players: None, ms: 42, version: String::new(), }, @@ -1149,4 +1315,102 @@ mod tests { ["O o o", "O o o", "o O o", "o o O", "o O o", "O o o"] ); } + + #[test] + fn player_count_is_dark_gray_with_gray_numbers() { + assert_eq!( + Ping::player_count(Some((3, 20))).component(), + serde_json::json!({ + "translate": "multiplayer.status.player_count", + "with": [{"text": "3", "color": "gray"}, {"text": "20", "color": "gray"}], + "color": "dark_gray", + }) + ); + assert_eq!( + Ping::player_count(None).component(), + serde_json::json!({"translate": "multiplayer.status.unknown", "color": "dark_gray"}) + ); + } + + fn png(size: u32) -> Vec { + let mut out = Vec::new(); + let mut encoder = png::Encoder::new(&mut out, size, size); + encoder.set_color(png::ColorType::Rgba); + let mut writer = encoder.write_header().unwrap(); + writer + .write_image_data(&vec![200; (size * size * 4) as usize]) + .unwrap(); + writer.finish().unwrap(); + out + } + + #[test] + fn favicons_are_64_pixel_pngs_behind_the_data_url() { + let icon = png(64); + let encoded = crate::lan::base64(&icon); + let (a, b) = encoded.split_at(10); + let json = serde_json::json!({ "favicon": format!("data:image/png;base64,{a}\n{b}") }); + let bytes = favicon_bytes(&json).unwrap(); + assert_eq!(bytes, icon); + assert_eq!(icon_pixels(&bytes).unwrap().len(), 64 * 64 * 4); + // FaviconTexture refuses other sizes; other formats are not icons. + assert!(icon_pixels(&png(32)).is_none()); + assert!(favicon_bytes(&serde_json::json!({ "favicon": encoded })).is_none()); + } + + #[test] + fn icon_arrows_join_and_move_servers() { + let dir = std::env::temp_dir().join(format!("horizon-mp-arrows-{}", std::process::id())); + let saves = dir.join("saves"); + std::fs::create_dir_all(&saves).unwrap(); + let file = servers_file(&saves); + let names = ["a", "b", "c"]; + let list: Vec = names + .iter() + .map(|n| ServerEntry::new(n, &format!("127.0.0.1:{}", 1 + n.len()))) + .collect(); + servers::save(&file, &list).unwrap(); + let mut screen = Screen::list(&saves); + let size = (427.0, 240.0); + let order = |screen: &Screen| match screen { + Screen::List { + servers, selected, .. + } => ( + servers.iter().map(|s| s.name.clone()).collect::>(), + *selected, + ), + _ => unreachable!(), + }; + // 427x240: rows start at x 61, the first icon at (63, 37). + let (ix, iy) = (63.0, 37.0); + // The first server has no up arrow: its top-left quarter selects it. + assert!(matches!( + screen.click(None, ix + 4.0, iy + 4.0, size, &saves), + Outcome::None + )); + assert_eq!( + order(&screen), + (vec!["a".into(), "b".into(), "c".into()], Some(0)) + ); + // Bottom-left quarter: down, saved, and still selected. + screen.click(None, ix + 4.0, iy + 20.0, size, &saves); + assert_eq!( + order(&screen), + (vec!["b".into(), "a".into(), "c".into()], Some(1)) + ); + let saved: Vec = servers::load(&file).into_iter().map(|s| s.name).collect(); + assert_eq!(saved, ["b", "a", "c"]); + // Top-left quarter of the second row: back up. + screen.click(None, ix + 4.0, iy + ROW_HEIGHT + 4.0, size, &saves); + assert_eq!( + order(&screen), + (vec!["a".into(), "b".into(), "c".into()], Some(0)) + ); + // The right half joins at once. + match screen.click(None, ix + 20.0, iy + 2.0 * ROW_HEIGHT + 10.0, size, &saves) { + Outcome::Connect(address) => assert_eq!(address, list[2].ip), + _ => panic!("the join arrow connects"), + } + let _ = std::fs::remove_dir_all(&dir); + } } diff --git a/crates/horizon-client/src/title.rs b/crates/horizon-client/src/title.rs index aa78981f5..37a5600ae 100644 --- a/crates/horizon-client/src/title.rs +++ b/crates/horizon-client/src/title.rs @@ -1020,6 +1020,7 @@ impl Title { atlas, batch, (self.started.elapsed().as_millis() / 300).is_multiple_of(2), + cursor, ), } for b in self.buttons(w, h) {