Skip to content

Minecraft: Java Edition 26.3 rewritten from scratch in Rust, checked against vanilla with 281 differential harnesses. Get it with the Horizon launcher.

99.1 KB
Raw Blame
//! Multiplayer screens on the title: the server list (JoinMultiplayerScreen,
//! stored in servers.dat), Add/Edit Server, Direct Connection, and the
//! Disconnected screen. Entries are pinged in the background like
//! ServerStatusPinger to show the MOTD, player count and latency.
use crate::hud::{HudAtlas, HudBatch, rgba};
use crate::lan::discovery::Scanner;
use crate::text::{DARK_GRAY, GRAY, Text, format_translation};
use crate::title::confirm_top;
use horizon_protocol::servers::{self, ServerEntry};
use std::{
    collections::HashMap,
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
    time::{Duration, Instant},
};

const SERVER_NAME: crate::clipboard::FieldId = ("server.name", 0);
const SERVER_ADDRESS: crate::clipboard::FieldId = ("server.address", 0);
const SERVER_DIRECT: crate::clipboard::FieldId = ("server.direct", 0);
const FRIEND_CODE: crate::clipboard::FieldId = ("friend.code", 0);
const FRIEND_RELAY: crate::clipboard::FieldId = ("friend.relay", 0);

/// The result of pinging one address.
#[derive(Clone, Debug)]
pub enum Ping {
    Pinging,
    Ok {
        /// The description component, styled (`sanitizeDescription`).
        motd: Text,
        /// Online and max players; None when the status has no `players`.
        players: Option<(i64, i64)>,
        /// `ServerData.playerList`: shown over the player count.
        player_list: Vec<Text>,
        ms: u128,
        version: String,
    },
    /// `ServerData.State.INCOMPATIBLE`: the server answered, but not with this
    /// game's protocol (or only to the legacy ping).
    Incompatible {
        motd: Text,
        players: Option<(i64, i64)>,
        player_list: Vec<Text>,
        /// `ServerData.version`, shown in red in place of the player count.
        version: Text,
    },
    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)
    }
}
/// ServerStatusPinger: each sample name as a literal line (its `§` codes
/// styled as the font does), then `multiplayer.status.and_more` for the
/// players the sample leaves out.
fn player_list(players: &serde_json::Value, online: i64) -> Vec<Text> {
    let Some(sample) = players["sample"].as_array().filter(|s| !s.is_empty()) else {
        return Vec::new();
    };
    let mut lines: Vec<Text> = sample
        .iter()
        .map(|p| Text::literal(p["name"].as_str().unwrap_or_default()).resolve_legacy())
        .collect();
    let shown = sample.len() as i64;
    if shown < online {
        lines.push(Text::translate(
            "multiplayer.status.and_more",
            &[Text::literal((online - shown).to_string())],
        ));
    }
    lines
}
type Pings = Arc<Mutex<HashMap<String, Ping>>>;
/// Server icons by address as 64x64 RGBA (FaviconTexture), from servers.dat
/// and then from each ping's favicon.
type Icons = Arc<Mutex<HashMap<String, Arc<Vec<u8>>>>>;

#[derive(Clone, Debug)]
pub enum Screen {
    List {
        servers: Vec<ServerEntry>,
        selected: Option<usize>,
        pings: Pings,
        icons: Icons,
        /// Worlds announced on the local network, listed after the servers.
        lan: Scanner,
        scroll: crate::ui::Scroll,
    },
    /// Add (index None) or edit a server entry.
    Edit {
        index: Option<usize>,
        name: String,
        address: String,
        focus: u8,
        /// Server Resource Packs (`acceptTextures`): Enabled, Disabled, or
        /// none for Prompt.
        packs: Option<bool>,
    },
    Direct {
        address: String,
    },
    /// ConfirmScreen for Delete: the list it returns to, the server's name
    /// and how many lines the warning took when last drawn.
    ConfirmDelete {
        list: Box<Screen>,
        name: String,
        lines: std::cell::Cell<usize>,
    },
    /// Join a friend's world with its invite code (Horizon's own, behind the
    /// title screen's Friends button).
    Friend {
        code: String,
        /// The relay for short codes (optional; saved on Join).
        relay: String,
        focus: u8,
    },
    Disconnected {
        reason: String,
        /// Auto-reconnect's next attempt, until it is cancelled.
        retry: Option<crate::reconnect::Retry>,
    },
}
/// What a click asks the title screen to do.
pub enum Outcome {
    None,
    Back,
    Connect { address: String, lan: bool },
}
/// A button: x, y, width, label, enabled, id.
pub type ButtonSpec = (f32, f32, f32, String, bool, u8);

/// `this.width / 2` (or `height / 2`): `Screen`'s size is an int, so the
/// division drops the half and widgets stay on whole GUI pixels. A half
/// pixel lands between device pixels and draws thinner borders and uneven
/// glyphs at most window heights.
fn half(size: f32) -> f32 {
    (size.ceil() / 2.0).floor()
}
/// `this.height / 4`, as an int division.
fn quarter(size: f32) -> f32 {
    (size.ceil() / 4.0).floor()
}
/// `centeredText` around `width / 2`: `x - font.width(text) / 2`.
fn centered_x(width: f32, text_width: f32) -> f32 {
    half(width) - half(text_width)
}

/// The server list, beside `saves/`; with `--player-dir`, the player's own.
pub fn servers_file(saves: &Path) -> PathBuf {
    servers_file_of(crate::logging::player_dir_override(), saves)
}

/// [`servers_file`] for a given `--player-dir`.
fn servers_file_of(player: Option<&Path>, saves: &Path) -> PathBuf {
    if let Some(player) = player {
        return player.join("servers.dat");
    }
    saves
        .parent()
        .map_or_else(|| PathBuf::from("servers.dat"), |p| p.join("servers.dat"))
}
/// `FaviconTexture.upload`: a PNG of exactly 64x64 pixels, else no icon.
fn icon_pixels(png: &[u8]) -> Option<Arc<Vec<u8>>> {
    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<Vec<u8>> {
    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 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 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 player_list = players
                            .map(|(online, _)| player_list(&json["players"], online))
                            .unwrap_or_default();
                        let version = json["version"]["name"].as_str().unwrap_or("?").to_owned();
                        // ServerStatus.version absent: `multiplayer.status.old`
                        // and protocol 0.
                        let protocol = json["version"]["protocol"].as_i64().unwrap_or(0);
                        let version_text = if json["version"].is_object() {
                            Text::literal(version.clone())
                        } else {
                            Text::translate("multiplayer.status.old", &[])
                        };
                        // 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);
                            }
                        }
                        // OnlineServerEntry: SUCCESSFUL only for this game's protocol.
                        if protocol == i64::from(horizon_protocol::PROTOCOL_VERSION) {
                            Ping::Ok {
                                motd,
                                players,
                                player_list,
                                ms,
                                version,
                            }
                        } else {
                            Ping::Incompatible {
                                motd,
                                players,
                                player_list,
                                version: version_text,
                            }
                        }
                    }
                    // ClientStatusPacketListener.onDisconnect without a
                    // status: pingLegacyServer.
                    Err(e) => match crate::net::ping_legacy(&address, Duration::from_secs(5)) {
                        Ok(legacy) => Ping::Incompatible {
                            motd: Text::literal(legacy.motd),
                            players: Some((
                                i64::from(legacy.players),
                                i64::from(legacy.max_players),
                            )),
                            player_list: Vec::new(),
                            version: Text::literal(legacy.version),
                        },
                        Err(_) => Ping::Failed(e),
                    },
                };
                pings.lock().unwrap().insert(address, result);
            });
    }
}
/// Save the list after a move or delete, keeping the icons pings stored in
/// servers.dat since it was loaded, and the Code of Conduct accepted on a server.
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();
            entry.accepted_code_of_conduct = s.accepted_code_of_conduct;
        }
    }
    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<String>) {
    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);
    }
}

/// `ClientPacketListener.handleServerData`: a valid icon the joined server
/// sends replaces the one its list entries keep.
pub fn save_server_icon(saves: &Path, address: &str, png: &[u8]) {
    if icon_pixels(png).is_some() {
        save_icon(&servers_file(saves), address, Some(crate::lan::base64(png)));
    }
}

/// Horizon's official survival server: a name and an address like any entry. The address is
/// `horizon_telemetry::server_status::OFFICIAL_ADDRESS`, the one place it is kept.
pub const OFFICIAL_SERVER: (&str, &str) = (
    "Horizon Official",
    horizon_telemetry::server_status::OFFICIAL_ADDRESS,
);
/// Beside servers.dat once the official server was offered, so a player who
/// deletes it never gets it back: the address offered, so a new one moves the
/// list once. The launcher writes the same file.
const OFFICIAL_MARKER: &str = "horizon_official_server.txt";

/// An address as the game connects to it: any case, 25565 when no port is given.
fn address_key(ip: &str) -> Option<(String, u16)> {
    servers::parse_address(ip).map(|(h, p)| (h.to_ascii_lowercase(), p))
}

/// Puts the official server at the top of the list in `game_dir`, once: not
/// again after the player deletes it, and not when the list has its address.
/// When it moved (the marker names another address), the entries for its
/// earlier addresses move to the new one, once (`move_official`).
pub fn add_official_server(game_dir: &Path) -> std::io::Result<()> {
    let (name, address) = OFFICIAL_SERVER;
    let marker = game_dir.join(OFFICIAL_MARKER);
    // A marker that is there but can't be read: offered already, at an address not known.
    let offered = match std::fs::read_to_string(&marker) {
        Ok(text) => Some(text),
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
        Err(_) => Some(String::new()),
    };
    if offered
        .as_deref()
        .is_some_and(|a| address_key(a) == address_key(address))
    {
        return Ok(());
    }
    let file = game_dir.join("servers.dat");
    let _guard = SAVING.lock();
    let mut list = servers::load(&file);
    let previous = horizon_telemetry::server_status::OFFICIAL_PREVIOUS;
    if move_official(&mut list, address, previous) {
        servers::save(&file, &list)?;
    }
    if offered.is_none()
        && !list
            .iter()
            .any(|s| address_key(&s.ip) == address_key(address))
    {
        servers::prepend(&file, &ServerEntry::new(name, address))?;
    }
    std::fs::write(marker, format!("{address}\n"))
}

/// Points the entries for an earlier official address at `address`, each
/// keeping the player's name and fields. One entry for the server at most: an
/// old one goes when the list already has `address`. Whether anything changed.
fn move_official(list: &mut Vec<ServerEntry>, address: &str, previous: &[&str]) -> bool {
    let new = address_key(address);
    let old = |ip: &str| {
        let ip = address_key(ip);
        ip.is_some() && ip != new && previous.iter().any(|p| address_key(p) == ip)
    };
    let mut present = list.iter().any(|s| address_key(&s.ip) == new);
    let mut changed = false;
    list.retain_mut(|s| {
        if !old(&s.ip) {
            return true;
        }
        changed = true;
        if present {
            return false;
        }
        present = true;
        s.ip = address.to_owned();
        true
    });
    changed
}

/// The address and kind of list row `index`: saved servers, then discovered LAN games.
fn entry_address(servers: &[ServerEntry], lan: &Scanner, index: usize) -> Option<(String, bool)> {
    match servers.get(index) {
        Some(s) => Some((s.ip.clone(), false)),
        None => lan
            .games()
            .into_iter()
            .nth(index - servers.len())
            .map(|g| (g.address, true)),
    }
}

/// The Server Resource Packs button's label: `CommonComponents.optionNameValue`.
fn pack_setting_label(packs: Option<bool>) -> String {
    let (key, fallback) = match packs {
        Some(true) => ("manageServer.resourcePack.enabled", "Enabled"),
        Some(false) => ("manageServer.resourcePack.disabled", "Disabled"),
        None => ("manageServer.resourcePack.prompt", "Prompt"),
    };
    let name = crate::lang::get_or("manageServer.resourcePack", "Server Resource Packs");
    crate::lang::get_or("options.generic_value", "%s: %s")
        .replacen("%s", &name, 1)
        .replacen("%s", &crate::lang::get_or(key, fallback), 1)
}

/// JoinMultiplayerScreen's `HeaderAndFooterLayout(33, 60)`.
const HEADER: f32 = 33.0;
const FOOTER: f32 = 60.0;
/// ServerSelectionList: rows 305 wide and 36 high.
const ROW_WIDTH: f32 = 305.0;
const ROW_HEIGHT: f32 = 36.0;
/// One row of the list: the saved servers, the LAN header, the LAN games.
#[derive(Clone, Copy, Debug, PartialEq)]
enum Row {
    Server(usize),
    LanHeader,
    Lan(usize),
}
/// The list's top and bottom and its rows' left edge (`getRowLeft`).
fn list_area(w: f32, h: f32) -> (f32, f32, f32) {
    (
        HEADER,
        h - FOOTER,
        (w / 2.0).floor() - (ROW_WIDTH / 2.0).floor(),
    )
}
/// `NetworkServerEntry.getServerNarration`: "LAN World" and the MOTD.
fn lan_narration(motd: &str) -> Text {
    Text::empty()
        .append(Text::translate("lanServer.title", &[]))
        .append(Text::literal(" "))
        .append(Text::literal(motd))
}
fn rows(servers: usize, lan: usize) -> impl Iterator<Item = Row> {
    (0..servers)
        .map(Row::Server)
        .chain(std::iter::once(Row::LanHeader))
        .chain((0..lan).map(Row::Lan))
}
/// `contentHeight`: the rows and 4 pixels of padding.
fn content_height(servers: usize, lan: usize) -> f32 {
    (servers + 1 + lan) as f32 * ROW_HEIGHT + 4.0
}
/// The row under `(x, y)` (`getEntryAtPosition`), scrolled by `scroll`.
fn row_at(
    servers: usize,
    lan: usize,
    (x, y): (f32, f32),
    size: (f32, f32),
    scroll: f32,
) -> Option<Row> {
    let (top, bottom, left) = list_area(size.0, size.1);
    if y < top || y >= bottom || x < left || x >= left + ROW_WIDTH {
        return None;
    }
    let index = ((y - top - 2.0 + scroll.trunc()) / ROW_HEIGHT).floor();
    if index < 0.0 {
        return None;
    }
    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]
}

fn ping_tooltip(
    servers: &[ServerEntry],
    pings: &HashMap<String, Ping>,
    size: (f32, f32),
    scroll: f32,
    cursor: (f32, f32),
) -> Option<Text> {
    let Row::Server(i) = row_at(servers.len(), 0, cursor, size, scroll)? else {
        return None;
    };
    let (top, _, left) = list_area(size.0, size.1);
    let x = left + 2.0 + ROW_WIDTH - 4.0 - 15.0;
    let y = top + 4.0 - scroll.trunc() + i as f32 * ROW_HEIGHT;
    if cursor.0 < x || cursor.0 >= x + 10.0 || cursor.1 < y || cursor.1 >= y + 8.0 {
        return None;
    }
    Some(match pings.get(&servers[i].ip) {
        Some(Ping::Ok { ms, .. }) => format_translation(
            &crate::lang::get_or("multiplayer.status.ping", "%s ms"),
            &[Text::literal(ms.to_string())],
        ),
        Some(Ping::Incompatible { .. }) => Text::literal(crate::lang::get_or(
            "multiplayer.status.incompatible",
            "Incompatible version!",
        )),
        Some(Ping::Failed(_)) => Text::literal(crate::lang::get_or(
            "multiplayer.status.no_connection",
            "(no connection)",
        )),
        _ => Text::literal(crate::lang::get_or(
            "multiplayer.status.pinging",
            "Pinging...",
        )),
    })
}
/// OnlineServerEntry's player list, over the player count drawn left of
/// the status icon; `width` measures that count.
fn player_list_tooltip(
    servers: &[ServerEntry],
    pings: &HashMap<String, Ping>,
    size: (f32, f32),
    scroll: f32,
    cursor: (f32, f32),
    width: impl Fn(&Text) -> f32,
) -> Option<Vec<Text>> {
    let Row::Server(i) = row_at(servers.len(), 0, cursor, size, scroll)? else {
        return None;
    };
    let (status, player_list) = match pings.get(&servers[i].ip)? {
        Ping::Ok {
            players,
            player_list,
            ..
        } => (Ping::player_count(*players), player_list),
        Ping::Incompatible {
            player_list,
            version,
            ..
        } => (version.clone().with_color(crate::text::RED), player_list),
        _ => return None,
    };
    let (top, _, left) = list_area(size.0, size.1);
    let icon_x = left + 2.0 + ROW_WIDTH - 4.0 - 15.0;
    let y = top + 4.0 - scroll.trunc() + i as f32 * ROW_HEIGHT;
    let w = width(&status).ceil();
    let x = icon_x - w - 5.0;
    if cursor.0 < x || cursor.0 >= x + w || cursor.1 < y || cursor.1 >= y + 8.0 {
        return None;
    }
    (!player_list.is_empty()).then(|| player_list.clone())
}

impl Screen {
    /// Draw after the list and footer so the tooltip is neither clipped nor covered.
    pub fn draw_tooltip(&self, atlas: &HudAtlas, batch: &mut HudBatch, cursor: (f32, f32)) {
        let Self::List {
            servers,
            pings,
            lan,
            scroll,
            ..
        } = self
        else {
            return;
        };
        let size = (batch.width.ceil(), batch.height.ceil());
        let (top, bottom, _) = list_area(size.0, size.1);
        let mut scroll = *scroll;
        scroll.clamp(
            top,
            bottom,
            content_height(servers.len(), lan.games().len()),
        );
        let pings = pings.lock().unwrap();
        let lines = match ping_tooltip(servers, &pings, size, scroll.amount, cursor) {
            Some(text) => vec![text],
            None => player_list_tooltip(servers, &pings, size, scroll.amount, cursor, |t| {
                atlas.font.width_text(t)
            })
            .unwrap_or_default(),
        };
        crate::ui::tooltip(batch, atlas, &lines, cursor);
    }

    pub fn list(saves: &Path) -> Self {
        let servers = servers::load(&servers_file(saves));
        let pings: Pings = Arc::default();
        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(),
        }
    }
    pub fn buttons(&self, w: f32, h: f32) -> Vec<ButtonSpec> {
        let b = |x: f32, y: f32, bw: f32, label: &str, enabled: bool, id: u8| {
            (x, y, bw, label.to_owned(), enabled, id)
        };
        match self {
            // JoinMultiplayerScreen's footer: two rows of buttons, 4 apart,
            // centred in the 60-pixel footer. Join needs a server or LAN game
            // selected (onSelectedChange), Edit and Delete a saved server.
            Self::List {
                servers, selected, ..
            } => {
                let (w, h) = (w.ceil(), h.ceil());
                let x = ((w - 308.0) / 2.0).floor();
                let saved = selected.is_some_and(|i| i < servers.len());
                let label = |key: &str, fallback: &str| crate::lang::get_or(key, fallback);
                vec![
                    b(
                        x,
                        h - 52.0,
                        100.0,
                        &label("selectServer.select", "Join Server"),
                        selected.is_some(),
                        40,
                    ),
                    b(
                        x + 104.0,
                        h - 52.0,
                        100.0,
                        &label("selectServer.direct", "Direct Connection"),
                        true,
                        41,
                    ),
                    b(
                        x + 208.0,
                        h - 52.0,
                        100.0,
                        &label("selectServer.add", "Add Server"),
                        true,
                        42,
                    ),
                    b(
                        x,
                        h - 28.0,
                        74.0,
                        &label("selectServer.edit", "Edit"),
                        saved,
                        43,
                    ),
                    b(
                        x + 78.0,
                        h - 28.0,
                        74.0,
                        &label("selectServer.delete", "Delete"),
                        saved,
                        44,
                    ),
                    b(
                        x + 156.0,
                        h - 28.0,
                        74.0,
                        &label("selectServer.refresh", "Refresh"),
                        true,
                        45,
                    ),
                    b(
                        x + 234.0,
                        h - 28.0,
                        74.0,
                        &label("gui.back", "Back"),
                        true,
                        46,
                    ),
                ]
            }
            Self::Edit { address, packs, .. } => vec![
                // ManageServerScreen's CycleButton, above Done.
                b(
                    half(w) - 100.0,
                    quarter(h) + 72.0,
                    200.0,
                    &pack_setting_label(*packs),
                    true,
                    60,
                ),
                b(
                    half(w) - 100.0,
                    quarter(h) + 96.0 + 18.0,
                    200.0,
                    &crate::lang::get_or("gui.done", "Done"),
                    servers::parse_address(address).is_some(),
                    50,
                ),
                b(
                    half(w) - 100.0,
                    quarter(h) + 120.0 + 18.0,
                    200.0,
                    &crate::lang::get_or("gui.cancel", "Cancel"),
                    true,
                    51,
                ),
            ],
            // ConfirmScreen's two 150-wide buttons, 4 apart, under the message.
            Self::ConfirmDelete { lines, .. } => {
                let y = confirm_top(h, lines.get()) + 41.0 + lines.get() as f32 * 9.0;
                let x = (w.ceil() / 2.0).floor();
                vec![
                    b(
                        x - 152.0,
                        y,
                        150.0,
                        &crate::lang::get_or("selectServer.deleteButton", "Delete"),
                        true,
                        58,
                    ),
                    b(
                        x + 2.0,
                        y,
                        150.0,
                        &crate::lang::get_or("gui.cancel", "Cancel"),
                        true,
                        59,
                    ),
                ]
            }
            Self::Direct { address } => vec![
                b(
                    half(w) - 100.0,
                    quarter(h) + 96.0 + 12.0,
                    200.0,
                    &crate::lang::get_or("selectServer.select", "Join Server"),
                    servers::parse_address(address).is_some(),
                    52,
                ),
                b(
                    half(w) - 100.0,
                    quarter(h) + 120.0 + 12.0,
                    200.0,
                    &crate::lang::get_or("gui.cancel", "Cancel"),
                    true,
                    53,
                ),
            ],
            Self::Friend { code, .. } => vec![
                b(
                    half(w) - 100.0,
                    quarter(h) + 96.0 + 18.0,
                    200.0,
                    &crate::lang::get_or("horizon.multiplayer.join", "Join"),
                    horizon_friends::invite::parse(code).is_some(),
                    56,
                ),
                b(
                    half(w) - 100.0,
                    quarter(h) + 120.0 + 18.0,
                    200.0,
                    &crate::lang::get_or("gui.cancel", "Cancel"),
                    true,
                    57,
                ),
            ],
            Self::Disconnected { retry, .. } => {
                let mut v = vec![b(
                    half(w) - 100.0,
                    half(h) + 30.0,
                    200.0,
                    &crate::lang::get_or("gui.toMenu", "Back to Server List"),
                    true,
                    54,
                )];
                if retry.is_some() {
                    v.push(b(
                        half(w) - 100.0,
                        half(h) + 54.0,
                        200.0,
                        &crate::lang::get_or(
                            "horizon.multiplayer.cancel_reconnecting",
                            "Cancel Reconnecting",
                        ),
                        true,
                        55,
                    ));
                }
                v
            }
        }
    }
    /// An EditBox and its label: the label at `label_y` (one pixel in, in
    /// 0xA0A0A0), the 200x20 box at `box_y`. The box is the same `EditBox`
    /// the world screens edit (`Caret`): cursor, selection and scrolling.
    fn field(
        atlas: &HudAtlas,
        batch: &mut HudBatch,
        caret: &mut crate::ui::Caret,
        focused_at: Instant,
        label: &str,
        value: &str,
        id: crate::clipboard::FieldId,
        max: usize,
        (label_y, box_y): (f32, f32),
        focused: bool,
    ) {
        let x = (batch.width.ceil() / 2.0).floor() - 100.0;
        batch.text(
            atlas,
            label,
            x + 1.0,
            label_y,
            rgba(160, 160, 160, 255),
            true,
        );
        caret.draw(
            batch,
            atlas,
            (id, value, max),
            [x, box_y, 200.0, 20.0],
            focused,
            focused_at,
        );
        // The box's message is its label.
        crate::widgets::name_last_edit_box(|| label.to_owned());
    }
    /// The screen as the narrator reads it: its id and `getNarrationMessage`.
    fn narration(&self) -> crate::widgets::ScreenInfo {
        use crate::widgets::{ScreenInfo, join_for_narration as join};
        let get = crate::lang::get_or;
        match self {
            Self::List { .. } => {
                ScreenInfo::new("multiplayer", get("multiplayer.title", "Play Multiplayer"))
            }
            Self::Edit { index, .. } => ScreenInfo::new(
                "multiplayer/edit",
                if index.is_some() {
                    get("manageServer.edit.title", "Edit Server Info")
                } else {
                    get("manageServer.add.title", "Add Server")
                },
            ),
            Self::Direct { .. } => ScreenInfo::new(
                "multiplayer/direct",
                get("selectServer.direct", "Direct Connection"),
            ),
            // ConfirmScreen: its title and its message.
            Self::ConfirmDelete { name, .. } => {
                let warning = format_translation(
                    &get(
                        "selectServer.deleteWarning",
                        "'%s' will be lost forever! (A long time!)",
                    ),
                    &[Text::literal(name.clone())],
                );
                ScreenInfo::new(
                    "multiplayer/delete",
                    join(&[
                        &get(
                            "selectServer.deleteQuestion",
                            "Are you sure you want to remove this server?",
                        ),
                        &warning.plain(),
                    ]),
                )
            }
            Self::Friend { .. } => ScreenInfo::new(
                "multiplayer/friend",
                get("horizon.multiplayer.join_friend", "Join a Friend"),
            ),
            // DisconnectedScreen: its title and the reason.
            Self::Disconnected { reason, .. } => ScreenInfo::new(
                "multiplayer/disconnected",
                join(&[&get("disconnect.lost", "Connection Lost"), reason]),
            ),
        }
    }
    /// What button `id` narrates: Server Resource Packs is a CycleButton,
    /// the others say their label.
    pub fn button_narration(
        &self,
        id: u8,
        rect: [f32; 4],
        label: &str,
        enabled: bool,
    ) -> crate::widgets::Narratable {
        use crate::widgets::Narratable;
        match self {
            Self::Edit { packs, .. } if id == 60 => {
                let (key, fallback) = match packs {
                    Some(true) => ("manageServer.resourcePack.disabled", "Disabled"),
                    Some(false) => ("manageServer.resourcePack.prompt", "Prompt"),
                    None => ("manageServer.resourcePack.enabled", "Enabled"),
                };
                Narratable::cycle(label, crate::lang::get_or(key, fallback), rect, enabled)
            }
            _ => Narratable::button(label, rect, enabled),
        }
    }
    /// `OnlineServerEntry.getNarration`: the name, then its status.
    fn server_narration(server: &ServerEntry, ping: Option<&Ping>) -> String {
        let t = |key: &str, args: &[&str]| crate::screen_narrator::translate(key, args);
        let mut parts = vec![t("narrator.select", &[&server.name])];
        match ping {
            Some(Ping::Ok {
                motd,
                players,
                player_list,
                ms,
                ..
            }) => {
                parts.push(t("multiplayer.status.online", &[]));
                parts.push(t("multiplayer.status.ping.narration", &[&ms.to_string()]));
                parts.push(t("multiplayer.status.motd.narration", &[&motd.plain()]));
                if let Some((online, max)) = players {
                    parts.push(t(
                        "multiplayer.status.player_count.narration",
                        &[&online.to_string(), &max.to_string()],
                    ));
                    let names: Vec<String> = player_list.iter().map(Text::plain).collect();
                    parts.push(names.join(", "));
                }
            }
            Some(Ping::Failed(_)) => parts.push(t("multiplayer.status.no_connection", &[])),
            _ => parts.push(t("multiplayer.status.pinging", &[])),
        }
        let parts: Vec<&str> = parts.iter().map(String::as_str).collect();
        crate::widgets::join_for_narration(&parts)
    }
    pub fn draw(
        &self,
        atlas: &HudAtlas,
        batch: &mut HudBatch,
        caret: &mut crate::ui::Caret,
        focused_at: Instant,
        cursor: (f32, f32),
    ) {
        let (w, h) = (batch.width, batch.height);
        let max = self.max_length();
        crate::widgets::begin_screen(|| self.narration());
        crate::ui::menu_background(batch, atlas, 0.0, 0.0, w, h, false);
        // GuiGraphicsExtractor.centeredText at width / 2: x - width(text) / 2.
        let centered = |batch: &mut HudBatch, text: &str, y: f32, color: u32| {
            let tw = HudBatch::text_width(atlas, text);
            batch.text(atlas, text, centered_x(w, tw), y, color, true);
        };
        match self {
            Self::List {
                servers,
                selected,
                pings,
                icons,
                lan,
                scroll,
            } => {
                let (w, h) = (w.ceil(), h.ceil());
                let title = crate::lang::get_or("multiplayer.title", "Play Multiplayer");
                // The header's StringWidget, centred in its 33 pixels.
                let tw = HudBatch::text_width(atlas, &title);
                let tx = ((w - tw.ceil()) / 2.0).floor();
                batch.text(
                    atlas,
                    &title,
                    tx,
                    ((HEADER - 9.0) / 2.0).floor(),
                    u32::MAX,
                    true,
                );
                let games = lan.games();
                let (top, bottom, left) = list_area(w, h);
                let content = content_height(servers.len(), games.len());
                let mut scroll = *scroll;
                scroll.clamp(top, bottom, content);
                // AbstractSelectionList.extractWidgetRenderState: background,
                // the rows clipped to the list, separators, scrollbar.
                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);
                // ServerSelectionList: the saved servers, the LAN header, the
                // LAN games; the row under the mouse, else the selected one.
                crate::widgets::narratable(|| {
                    use crate::widgets::{ListKind, Narratable, Row as Narrated};
                    let all: Vec<Row> = rows(servers.len(), games.len()).collect();
                    let narrate = |i: usize| {
                        let text = match all[i] {
                            Row::Server(k) => {
                                Self::server_narration(&servers[k], pings.get(&servers[k].ip))
                            }
                            Row::LanHeader => crate::lang::get_or(
                                "lanServer.scanning",
                                "Scanning for games on your local network",
                            ),
                            Row::Lan(k) => crate::screen_narrator::translate(
                                "narrator.select",
                                &[&lan_narration(&games[k].motd).plain()],
                            ),
                        };
                        Narrated::new(i, text)
                    };
                    let selected = selected.and_then(|s| {
                        let row = if s < servers.len() {
                            Row::Server(s)
                        } else {
                            Row::Lan(s - servers.len())
                        };
                        all.iter().position(|r| *r == row)
                    });
                    Narratable::list(
                        ListKind::Object,
                        all.len(),
                        hovered
                            .and_then(|h| all.iter().position(|r| *r == h))
                            .map(narrate),
                        selected.map(narrate),
                        [0.0, top, w, bottom - top],
                    )
                    .key(crate::widgets::key_of(&"multiplayer/servers"))
                });
                let millis = std::time::SystemTime::now()
                    .duration_since(std::time::UNIX_EPOCH)
                    .map_or(0, |d| d.as_millis());
                let gray = rgba(128, 128, 128, 255);
                for (i, row) in rows(servers.len(), games.len()).enumerate() {
                    let y = top + 2.0 - scroll.amount.trunc() + i as f32 * ROW_HEIGHT;
                    if y + ROW_HEIGHT < top || y > bottom {
                        continue;
                    }
                    let index = match row {
                        Row::Server(k) => Some(k),
                        Row::Lan(k) => Some(servers.len() + k),
                        Row::LanHeader => None,
                    };
                    if index.is_some()
                        && y + ROW_HEIGHT / 2.0 > top
                        && y + ROW_HEIGHT / 2.0 < bottom
                    {
                        let rect = [left, y, ROW_WIDTH, ROW_HEIGHT];
                        // The control socket's widget tree names the row.
                        let name = match row {
                            Row::Server(k) => servers[k].name.as_str(),
                            Row::Lan(k) => games[k].motd.as_str(),
                            Row::LanHeader => "",
                        };
                        crate::widgets::record_as(name, rect, true, crate::widgets::Kind::Row);
                        crate::widgets::target_as(rect, crate::widgets::Kind::Row);
                    }
                    // extractSelection: a white outline round black (the list
                    // has focus once a row is clicked).
                    if index.is_some() && *selected == index {
                        batch.fill(atlas, left, y, ROW_WIDTH, ROW_HEIGHT, u32::MAX);
                        batch.fill(
                            atlas,
                            left + 1.0,
                            y + 1.0,
                            ROW_WIDTH - 2.0,
                            ROW_HEIGHT - 2.0,
                            rgba(0, 0, 0, 255),
                        );
                    }
                    // Entry content: 2 pixels in from the row.
                    let (cx, cy) = (left + 2.0, y + 2.0);
                    match row {
                        Row::Server(k) => {
                            let server = &servers[k];
                            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, all with
                            // GuiGraphics.text's shadow.
                            let (motd, status, sprite) = match pings.get(&server.ip) {
                                Some(Ping::Ok {
                                    motd, players, ms, ..
                                }) => (
                                    motd.resolve_legacy(),
                                    Ping::player_count(*players),
                                    format!(
                                        "gui/sprites/server_list/ping_{}",
                                        match ms {
                                            0..150 => 5,
                                            150..300 => 4,
                                            300..600 => 3,
                                            600..1000 => 2,
                                            _ => 1,
                                        }
                                    ),
                                ),
                                Some(Ping::Incompatible { motd, version, .. }) => (
                                    motd.resolve_legacy(),
                                    version.clone().with_color(crate::text::RED),
                                    "gui/sprites/server_list/incompatible".to_owned(),
                                ),
                                Some(Ping::Failed(_)) => (
                                    Text::translate("multiplayer.status.cannot_connect", &[])
                                        .with_color(0xFF0000),
                                    Text::empty(),
                                    "gui/sprites/server_list/unreachable".to_owned(),
                                ),
                                _ => {
                                    // The pinging bars bounce, offset by the row.
                                    let frame = (millis / 100 + i as u128 * 2) & 7;
                                    let frame = if frame > 4 { 8 - frame } else { frame };
                                    (
                                        Text::translate("multiplayer.status.pinging", &[]),
                                        Text::empty(),
                                        format!("gui/sprites/server_list/pinging_{}", frame + 1),
                                    )
                                }
                            };
                            for (n, line) in atlas
                                .font
                                .split(&motd, ROW_WIDTH - 4.0 - 32.0 - 2.0)
                                .iter()
                                .take(2)
                                .enumerate()
                            {
                                batch.text_styled(
                                    atlas,
                                    line,
                                    cx + 35.0,
                                    cy + 12.0 + 9.0 * n as f32,
                                    gray,
                                    true,
                                );
                            }
                            let icon_x = cx + ROW_WIDTH - 4.0 - 15.0;
                            batch.sprite_scaled(atlas, &sprite, icon_x, cy, 10.0, 8.0, u32::MAX);
                            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 => {
                            // LANHeader's LoadingDotsWidget: the label, then
                            // the dots on its last line, both centred.
                            let label = crate::lang::get_or(
                                "lanServer.scanning",
                                "Scanning for games on your local network",
                            );
                            let middle = cx + ((ROW_WIDTH - 4.0) / 2.0).floor();
                            let lw = HudBatch::text_width(atlas, &label).ceil();
                            let lx = middle - (lw / 2.0).floor();
                            let centre = lx + (lw / 2.0).floor();
                            batch.text(atlas, &label, lx, cy + 2.0, u32::MAX, false);
                            let dots = loading_dots(millis);
                            let dw = HudBatch::text_width(atlas, dots).ceil();
                            batch.text(
                                atlas,
                                dots,
                                centre - (dw / 2.0).floor(),
                                cy + 28.0 - 9.0 - 2.0,
                                gray,
                                false,
                            );
                        }
                        Row::Lan(k) => {
                            let game = &games[k];
                            let header = crate::lang::get_or("lanServer.title", "LAN World");
                            batch.text(atlas, &header, cx + 35.0, cy + 1.0, u32::MAX, false);
                            batch.text(atlas, &game.motd, cx + 35.0, cy + 12.0, gray, false);
                            batch.text(atlas, &game.address, cx + 35.0, cy + 23.0, gray, false);
                        }
                    }
                }
                batch.clip_since(first, 0.0, top, w, bottom);
                crate::ui::separators(batch, atlas, top, bottom, false);
                crate::ui::scrollbar(
                    batch,
                    atlas,
                    left + ROW_WIDTH + 8.0,
                    top,
                    bottom,
                    content,
                    scroll.amount,
                );
            }
            Self::Edit {
                index,
                name,
                address,
                focus,
                ..
            } => {
                centered(
                    batch,
                    &if index.is_some() {
                        crate::lang::get_or("manageServer.edit.title", "Edit Server Info")
                    } else {
                        crate::lang::get_or("manageServer.add.title", "Add Server")
                    },
                    17.0,
                    u32::MAX,
                );
                // ManageServerScreen: labels at 53 and 94, boxes at 66 and 106.
                Self::field(
                    atlas,
                    batch,
                    caret,
                    focused_at,
                    &crate::lang::get_or("manageServer.enterName", "Server Name"),
                    name,
                    SERVER_NAME,
                    max,
                    (53.0, 66.0),
                    *focus == 0,
                );
                Self::field(
                    atlas,
                    batch,
                    caret,
                    focused_at,
                    &crate::lang::get_or("manageServer.enterIp", "Server Address"),
                    address,
                    SERVER_ADDRESS,
                    max,
                    (94.0, 106.0),
                    *focus == 1,
                );
            }
            Self::Direct { address } => {
                // DirectJoinServerScreen: the title at 20, the label at 100
                // and the box at 116.
                centered(
                    batch,
                    &crate::lang::get_or("selectServer.direct", "Direct Connection"),
                    20.0,
                    u32::MAX,
                );
                Self::field(
                    atlas,
                    batch,
                    caret,
                    focused_at,
                    &crate::lang::get_or("manageServer.enterIp", "Server Address"),
                    address,
                    SERVER_DIRECT,
                    max,
                    (100.0, 116.0),
                    true,
                );
            }
            Self::ConfirmDelete { name, lines, .. } => {
                // ConfirmScreen: the title, then the message wrapped to
                // width - 50, centred as a block.
                let warning = format_translation(
                    &crate::lang::get_or(
                        "selectServer.deleteWarning",
                        "'%s' will be lost forever! (A long time!)",
                    ),
                    &[Text::literal(name.clone())],
                );
                let message = atlas.font.split(&warning, (w.ceil() - 50.0).max(1.0));
                lines.set(message.len());
                let top = confirm_top(h, message.len());
                centered(
                    batch,
                    &crate::lang::get_or(
                        "selectServer.deleteQuestion",
                        "Are you sure you want to remove this server?",
                    ),
                    top,
                    u32::MAX,
                );
                for (i, line) in message.iter().enumerate() {
                    centered(batch, &line.plain(), top + 17.0 + i as f32 * 9.0, u32::MAX);
                }
            }
            Self::Friend { code, relay, focus } => {
                centered(
                    batch,
                    &crate::lang::get_or("horizon.multiplayer.join_friend", "Join a Friend"),
                    20.0,
                    u32::MAX,
                );
                Self::field(
                    atlas,
                    batch,
                    caret,
                    focused_at,
                    &crate::lang::get_or("horizon.multiplayer.invite_code", "Invite Code"),
                    code,
                    FRIEND_CODE,
                    max,
                    (53.0, 64.0),
                    *focus == 0,
                );
                Self::field(
                    atlas,
                    batch,
                    caret,
                    focused_at,
                    &crate::lang::get_or("horizon.multiplayer.relay", "Relay (optional)"),
                    relay,
                    FRIEND_RELAY,
                    max,
                    (94.0, 105.0),
                    *focus == 1,
                );
            }
            Self::Disconnected { reason, retry } => {
                centered(
                    batch,
                    &crate::lang::get_or("disconnect.lost", "Connection Lost"),
                    half(h) - 40.0,
                    rgba(170, 170, 170, 255),
                );
                for (i, line) in wrap(reason, 300.0, atlas).iter().enumerate() {
                    centered(batch, line, half(h) - 16.0 + i as f32 * 9.0, u32::MAX);
                }
                if let Some(r) = retry {
                    let text = r.text(std::time::Instant::now());
                    centered(batch, &text, half(h) + 16.0, rgba(170, 170, 170, 255));
                }
            }
        }
    }
    /// `DirectJoinServerScreen.keyPressed`: Enter joins the typed address
    /// while the Join Server button is active.
    pub fn confirm(&self) -> Outcome {
        match self {
            Self::Direct { address } if servers::parse_address(address).is_some() => {
                Outcome::Connect {
                    address: direct_address(address),
                    lan: false,
                }
            }
            _ => Outcome::None,
        }
    }
    pub fn click(
        &mut self,
        id: Option<u8>,
        x: f32,
        y: f32,
        size: (f32, f32),
        saves: &Path,
    ) -> Outcome {
        let (w, h) = size;
        match (&mut *self, id) {
            (
                Self::List {
                    servers,
                    selected,
                    lan,
                    ..
                },
                Some(40),
            ) => {
                if let Some((address, lan)) = selected.and_then(|i| entry_address(servers, lan, i))
                {
                    return Outcome::Connect { address, lan };
                }
            }
            (Self::List { .. }, Some(41)) => {
                *self = Self::Direct {
                    address: String::new(),
                }
            }
            (Self::List { .. }, Some(47)) => *self = Self::friend(),
            (Self::List { .. }, Some(42)) => {
                *self = Self::Edit {
                    index: None,
                    name: crate::lang::get_or("selectServer.defaultName", "Minecraft Server"),
                    address: String::new(),
                    focus: 1,
                    packs: None,
                }
            }
            (
                Self::List {
                    servers, selected, ..
                },
                Some(43),
            ) => {
                if let Some((i, s)) = selected.and_then(|i| servers.get(i).map(|s| (i, s.clone())))
                {
                    *self = Self::Edit {
                        index: Some(i),
                        name: s.name,
                        address: s.ip,
                        focus: 0,
                        packs: s.accept_textures,
                    };
                }
            }
            (
                Self::List {
                    servers, selected, ..
                },
                Some(44),
            ) => {
                // JoinMultiplayerScreen's Delete asks first (ConfirmScreen).
                if let Some(name) = selected
                    .and_then(|i| servers.get(i))
                    .map(|s| s.name.clone())
                {
                    let list = std::mem::replace(
                        self,
                        Self::Direct {
                            address: String::new(),
                        },
                    );
                    *self = Self::ConfirmDelete {
                        list: Box::new(list),
                        name,
                        lines: std::cell::Cell::new(1),
                    };
                }
            }
            // deleteCallback: yes removes the server and clears the
            // selection; either answer returns to the list as it was.
            (Self::ConfirmDelete { .. }, Some(id @ (58 | 59))) => {
                let Self::ConfirmDelete { list, .. } = std::mem::replace(
                    self,
                    Self::Direct {
                        address: String::new(),
                    },
                ) else {
                    unreachable!()
                };
                *self = *list;
                if id == 58
                    && let Self::List {
                        servers, selected, ..
                    } = self
                    && let Some(i) = selected.take()
                    && i < servers.len()
                {
                    servers.remove(i);
                    save_servers(&servers_file(saves), servers);
                }
            }
            (Self::List { .. }, Some(45)) => *self = Self::list(saves),
            (Self::List { .. }, Some(46)) => return Outcome::Back,
            (
                Self::List {
                    servers,
                    selected,
                    lan,
                    scroll,
                    ..
                },
                None,
            ) => {
                let (w, h) = (w.ceil(), h.ceil());
                let games = lan.games().len();
                let (top, bottom, left) = list_area(w, h);
                let content = content_height(servers.len(), games);
                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 {
                            address: servers[k].ip.clone(),
                            lan: false,
                        };
                    }
                    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 {
                    Some(Row::Server(k)) => Some(k),
                    Some(Row::Lan(k)) => Some(servers.len() + k),
                    Some(Row::LanHeader) => {
                        *selected = None;
                        None
                    }
                    None => None,
                };
                if let Some(index) = index
                    && let Some((address, lan)) = entry_address(servers, lan, index)
                {
                    if *selected == Some(index) {
                        return Outcome::Connect { address, lan };
                    }
                    *selected = Some(index);
                }
            }
            // CycleButton: Enabled, Disabled, Prompt, and round again.
            (Self::Edit { packs, .. }, Some(60)) => {
                *packs = match *packs {
                    Some(true) => Some(false),
                    Some(false) => None,
                    None => Some(true),
                }
            }
            (
                Self::Edit {
                    index,
                    name,
                    address,
                    packs,
                    ..
                },
                Some(50),
            ) => {
                let mut list = servers::load(&servers_file(saves));
                let mut entry = ServerEntry::new(name.trim(), address.trim());
                entry.accept_textures = *packs;
                match index.and_then(|i| list.get_mut(i)) {
                    Some(e) => {
                        e.name = entry.name;
                        e.ip = entry.ip;
                        e.accept_textures = entry.accept_textures;
                    }
                    None => list.push(entry),
                }
                let _ = servers::save(&servers_file(saves), &list);
                *self = Self::list(saves);
            }
            (
                Self::Edit { .. }
                | Self::Direct { .. }
                | Self::Friend { .. }
                | Self::Disconnected { .. },
                Some(51 | 53 | 54 | 57),
            ) => *self = Self::list(saves),
            (Self::Disconnected { retry, .. }, Some(55)) => *retry = None,
            (Self::Direct { address }, Some(52)) => {
                return Outcome::Connect {
                    address: direct_address(address),
                    lan: false,
                };
            }
            (Self::Friend { code, relay, .. }, Some(56)) => {
                if horizon_friends::invite::parse(code).is_some() {
                    crate::net::save_friends_relay(relay.trim());
                    let code: String = code.chars().filter(|c| !c.is_whitespace()).collect();
                    return Outcome::Connect {
                        address: format!("{}{code}", crate::net::FRIEND),
                        lan: false,
                    };
                }
            }
            (Self::Edit { .. } | Self::Friend { .. }, None) => {
                let boxes = if matches!(self, Self::Edit { .. }) {
                    [66.0, 106.0]
                } else {
                    [64.0, 105.0]
                };
                let (Self::Edit { focus, .. } | Self::Friend { focus, .. }) = self else {
                    unreachable!()
                };
                for (i, fy) in [(0u8, boxes[0]), (1, boxes[1])] {
                    if y >= fy && y < fy + 20.0 && (half(w) - 100.0..half(w) + 100.0).contains(&x) {
                        *focus = i;
                    }
                }
            }
            _ => {}
        }
        Outcome::None
    }
    /// The mouse wheel over the server list (`scrollRate`: half a row).
    /// Up or Down on the list (`AbstractSelectionList.nextEntry`): the next
    /// server or LAN game, the first (Down) or last (Up) with none selected, and
    /// none past the ends. With Shift a saved server swaps with its neighbour
    /// (`OnlineServerEntry.keyPressed`) and stays selected. False when the screen
    /// is not the list or has no entries.
    pub fn arrow(&mut self, up: bool, shift: bool, size: (f32, f32), saves: &Path) -> bool {
        let Self::List {
            servers,
            selected,
            lan,
            scroll,
            ..
        } = self
        else {
            return false;
        };
        let total = servers.len() + lan.games().len();
        if total == 0 {
            return false;
        }
        let next = match *selected {
            Some(k) if shift => {
                // A LAN game has no place to move to.
                let to = if up { k.checked_sub(1) } else { Some(k + 1) };
                if let Some(to) = to.filter(|&to| k < servers.len() && to < servers.len()) {
                    servers.swap(k, to);
                    save_servers(&servers_file(saves), servers);
                    Some(to)
                } else {
                    Some(k)
                }
            }
            Some(k) if up => Some(k.saturating_sub(1)),
            Some(k) => Some((k + 1).min(total - 1)),
            None if shift => None,
            None => Some(if up { total - 1 } else { 0 }),
        };
        *selected = next;
        if let Some(k) = next {
            // scrollToEntry: the row, with the LAN header between the servers
            // and the games, into view.
            let row = if k < servers.len() { k } else { k + 1 };
            let (top, bottom, _) = list_area(size.0.ceil(), size.1.ceil());
            let content = content_height(servers.len(), lan.games().len());
            let (row_top, view) = (2.0 + row as f32 * ROW_HEIGHT, bottom - top);
            if row_top < scroll.amount {
                scroll.amount = row_top;
            } else if row_top + ROW_HEIGHT > scroll.amount + view {
                scroll.amount = row_top + ROW_HEIGHT - view;
            }
            scroll.clamp(top, bottom, content);
        }
        true
    }
    pub fn wheel(&mut self, delta: f32, cursor: (f32, f32), size: (f32, f32)) {
        if let Self::List {
            servers,
            lan,
            scroll,
            ..
        } = self
        {
            let (top, bottom, _) = list_area(size.0.ceil(), size.1.ceil());
            if cursor.1 >= top && cursor.1 < bottom {
                let content = content_height(servers.len(), lan.games().len());
                scroll.wheel(delta, ROW_HEIGHT / 2.0, top, bottom, content);
            }
        }
    }
    /// The pointer moved: a held scrollbar follows it.
    pub fn drag(&mut self, y: f32, size: (f32, f32)) {
        if let Self::List {
            servers,
            lan,
            scroll,
            ..
        } = self
        {
            let (top, bottom, _) = list_area(size.0.ceil(), size.1.ceil());
            scroll.drag(
                y,
                top,
                bottom,
                content_height(servers.len(), lan.games().len()),
            );
        }
    }
    pub fn release(&mut self) {
        if let Self::List { scroll, .. } = self {
            scroll.release();
        }
    }
    /// The focused box, in GUI pixels: name at 66, address at 106
    /// (`ManageServerScreen`), direct address at 116, friend fields at 64 and 105.
    pub fn focused_box(&self, (w, _h): (f32, f32)) -> Option<[f32; 4]> {
        let y = match self {
            Self::Edit { focus: 0, .. } => 66.0,
            Self::Edit { focus: 1, .. } => 106.0,
            Self::Edit { .. } => return None,
            Self::Direct { .. } => 116.0,
            Self::Friend { focus: 0, .. } => 64.0,
            Self::Friend { focus: 1, .. } => 105.0,
            Self::Friend { .. } => return None,
            _ => return None,
        };
        Some([(w / 2.0).floor() - 100.0, y, 200.0, 20.0])
    }
    fn focused_field(&mut self) -> Option<&mut String> {
        match self {
            Self::Edit {
                name,
                address,
                focus,
                ..
            } => match *focus {
                0 => Some(name),
                1 => Some(address),
                // A button has the focus.
                _ => None,
            },
            Self::Direct { address } => Some(address),
            Self::Friend {
                code, relay, focus, ..
            } => match *focus {
                0 => Some(code),
                1 => Some(relay),
                _ => None,
            },
            _ => None,
        }
    }
    /// Join a friend, with the relay the player set before.
    pub fn friend() -> Self {
        Self::Friend {
            code: String::new(),
            relay: crate::net::friends_relay_setting().unwrap_or_default(),
            focus: 0,
        }
    }
    /// Auto-reconnect's attempt, once its countdown is over.
    pub fn due_retry(&mut self) -> Option<crate::reconnect::Retry> {
        let Self::Disconnected { retry, .. } = self else {
            return None;
        };
        if !retry.as_ref()?.due(std::time::Instant::now()) {
            return None;
        }
        retry.take()
    }
    /// `ServerSelectionList.updateNetworkServers`' narration: for each LAN
    /// world found since the last call whose row is in the list's view,
    /// `multiplayer.lan.server_found` with its `getServerNarration`.
    pub fn lan_found_narrations(&self, (w, h): (f32, f32)) -> Vec<Text> {
        let Self::List {
            servers,
            lan,
            scroll,
            ..
        } = self
        else {
            return Vec::new();
        };
        let found = lan.take_found();
        if found.is_empty() {
            return Vec::new();
        }
        let (top, bottom, _) = list_area(w.ceil(), h.ceil());
        let mut scroll = *scroll;
        scroll.clamp(
            top,
            bottom,
            content_height(servers.len(), lan.games().len()),
        );
        found
            .into_iter()
            .filter(|(k, _)| {
                // getRowTop / getRowBottom of the entry after the servers and
                // the LAN header.
                let row = (servers.len() + 1 + k) as f32;
                let row_top = top + 2.0 - scroll.amount.trunc() + row * ROW_HEIGHT;
                row_top + ROW_HEIGHT >= top && row_top <= bottom
            })
            .map(|(_, game)| {
                Text::translate("multiplayer.lan.server_found", &[lan_narration(&game.motd)])
            })
            .collect()
    }
    /// The focused text field, its id and maximum length (copy and paste).
    pub fn focused_text(&mut self) -> Option<(crate::clipboard::FieldId, &mut String, usize)> {
        let id = match self {
            Self::Edit { focus: 0, .. } => SERVER_NAME,
            Self::Edit { .. } => SERVER_ADDRESS,
            Self::Direct { .. } => SERVER_DIRECT,
            Self::Friend { focus: 0, .. } => FRIEND_CODE,
            Self::Friend { .. } => FRIEND_RELAY,
            _ => return None,
        };
        let max = self.max_length();
        self.focused_field().map(|f| (id, f, max))
    }
    /// Invite codes with IPv6 and a relay run past a server address's 128.
    fn max_length(&self) -> usize {
        if matches!(self, Self::Friend { .. }) {
            256
        } else {
            128
        }
    }
    /// Tab (`reverse`: Shift+Tab) through the focus order of `ManageServerScreen`
    /// and the friend screen: the text fields, then the enabled `buttons`, then
    /// round to the first field. `button` is the focused button, if any; a field
    /// has the focus (`focus` below 2) only while no button does.
    pub fn tab_dir(&mut self, reverse: bool, buttons: &[u8], button: &mut Option<u8>) {
        let (Self::Edit { focus, .. } | Self::Friend { focus, .. }) = self else {
            return;
        };
        let stops = 2 + buttons.len();
        let at = match *button {
            Some(id) => buttons.iter().position(|&b| b == id).map(|i| 2 + i),
            None => Some(usize::from(*focus).min(1)),
        }
        .unwrap_or(0);
        let next = if reverse {
            (at + stops - 1) % stops
        } else {
            (at + 1) % stops
        };
        if next < 2 {
            *focus = next as u8;
            *button = None;
        } else {
            *focus = 2;
            *button = Some(buttons[next - 2]);
        }
    }
    /// Escape: back to the list, or out of it (true).
    pub fn escape(&mut self, saves: &Path) -> bool {
        match self {
            Self::List { .. } => true,
            // ConfirmScreen.keyPressed: Escape answers no.
            Self::ConfirmDelete { list, .. } => {
                let list = std::mem::replace(
                    &mut **list,
                    Self::Direct {
                        address: String::new(),
                    },
                );
                *self = list;
                false
            }
            _ => {
                *self = Self::list(saves);
                false
            }
        }
    }
}

/// Direct Connection's address; a full invite code pasted there joins the
/// friend (a short relay code could be a host name, so it needs Join a Friend).
fn direct_address(address: &str) -> String {
    let code: String = address.chars().filter(|c| !c.is_whitespace()).collect();
    if matches!(
        horizon_friends::invite::parse(&code),
        Some(horizon_friends::invite::Parsed::Long(_))
    ) {
        format!("{}{code}", crate::net::FRIEND)
    } else {
        address.trim().to_owned()
    }
}
/// Greedy word wrap to a pixel width.
pub fn wrap(text: &str, width: f32, atlas: &HudAtlas) -> Vec<String> {
    let mut lines = Vec::new();
    for paragraph in text.lines() {
        let mut line = String::new();
        for word in paragraph.split(' ') {
            let candidate = if line.is_empty() {
                word.to_owned()
            } else {
                format!("{line} {word}")
            };
            if HudBatch::text_width(atlas, &candidate) > width && !line.is_empty() {
                lines.push(std::mem::take(&mut line));
                line = word.to_owned();
            } else {
                line = candidate;
            }
        }
        lines.push(line);
    }
    lines
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn servers_dat_is_beside_saves_or_in_the_player_dir() {
        let saves = Path::new("/games/shared/saves");
        assert_eq!(
            servers_file_of(None, saves),
            Path::new("/games/shared/servers.dat")
        );
        assert_eq!(
            servers_file_of(Some(Path::new("/games/players/alex")), saves),
            Path::new("/games/players/alex/servers.dat")
        );
    }

    #[test]
    fn only_discovered_entries_get_lan_authentication() {
        let address = "127.0.0.1:25565";
        let mut screen = Screen::List {
            servers: vec![ServerEntry::new("Saved", address)],
            selected: Some(0),
            pings: Arc::default(),
            icons: Arc::default(),
            lan: Scanner::for_tests(vec![crate::lan::discovery::LanGame {
                motd: "LAN".into(),
                address: address.into(),
            }]),
            scroll: Default::default(),
        };
        for (index, expected_lan) in [(0, false), (1, true)] {
            if let Screen::List { selected, .. } = &mut screen {
                *selected = Some(index);
            }
            let Outcome::Connect {
                address: actual,
                lan,
            } = screen.click(Some(40), 0.0, 0.0, (640.0, 480.0), Path::new(""))
            else {
                panic!("join did not connect")
            };
            assert_eq!(actual, address);
            assert_eq!(lan, expected_lan);
        }
        let direct = Screen::Direct {
            address: address.into(),
        };
        assert!(matches!(
            direct.confirm(),
            Outcome::Connect { lan: false, .. }
        ));
    }

    #[test]
    fn direct_connection_joins_a_pasted_invite_and_keeps_host_names() {
        let invite = horizon_friends::invite::Invite {
            secret: *b"0123456789",
            port: 25580,
            endpoints: vec!["192.168.1.20:25580".parse().unwrap()],
            relay: None,
        }
        .encode();
        assert_eq!(
            direct_address(&format!(" {invite} ")),
            format!("{}{invite}", crate::net::FRIEND)
        );
        for host in ["localhost", "example.org:25566", "abcdefgh", "[::1]:25568"] {
            assert_eq!(direct_address(host), host);
        }
    }

    #[test]
    fn ping_tooltip_follows_only_visible_status_bars_and_current_ping() {
        let servers: Vec<_> = (0..6)
            .map(|i| ServerEntry::new("Test", &format!("server{i}")))
            .collect();
        let mut pings = HashMap::new();
        let size = (427.0, 240.0);
        let hover = |pings: &HashMap<String, Ping>, scroll, cursor| {
            ping_tooltip(&servers, pings, size, scroll, cursor).map(|t| t.plain())
        };
        // The first bar is at (349, 37), with a 10 by 8 hit area.
        assert_eq!(
            hover(&pings, 0.0, (349.0, 37.0)).as_deref(),
            Some("Pinging...")
        );
        pings.insert(
            "server0".into(),
            Ping::Ok {
                motd: Text::empty(),
                players: None,
                player_list: Vec::new(),
                ms: 42,
                version: String::new(),
            },
        );
        assert_eq!(hover(&pings, 0.0, (358.9, 44.9)).as_deref(), Some("42 ms"));
        pings.insert("server1".into(), Ping::Pinging);
        for cursor in [
            (348.9, 37.0),
            (359.0, 37.0),
            (349.0, 36.9),
            (349.0, 45.0),
            (100.0, 40.0),
            (349.0, 32.0),
            (349.0, 181.0),
        ] {
            assert!(hover(&pings, 0.0, cursor).is_none(), "{cursor:?}");
        }
        // Scrolling moves the next row's bars into the same location.
        assert_eq!(
            hover(&pings, 36.0, (349.0, 37.0)).as_deref(),
            Some("Pinging...")
        );
        assert_eq!(hover(&pings, 5.0, (349.0, 34.0)).as_deref(), Some("42 ms"));
        assert!(hover(&pings, 36.0, (349.0, 33.0)).is_none());
        assert!(hover(&pings, 0.0, (349.0, 179.0)).is_none());
        assert!(hover(&pings, 216.0, (349.0, 37.0)).is_none()); // LAN header
        pings.insert(
            "server0".into(),
            Ping::Failed("private connection error".into()),
        );
        assert_eq!(
            hover(&pings, 0.0, (349.0, 37.0)).as_deref(),
            Some("(no connection)")
        );
    }

    #[test]
    fn screens_lay_out_on_whole_gui_pixels_at_any_window_size() {
        // A 1000-pixel-high window at GUI scale 3 is 334 GUI pixels high and
        // a 1281-wide one 427 wide: vanilla's `height / 4` is 83 and
        // `width / 2` 213, never 83.5 and 213.5.
        let direct = Screen::Direct {
            address: "localhost".into(),
        };
        let at = |screen: &Screen, w, h| -> Vec<(f32, f32)> {
            screen.buttons(w, h).iter().map(|b| (b.0, b.1)).collect()
        };
        assert_eq!(at(&direct, 427.0, 334.0), [(113.0, 191.0), (113.0, 215.0)]);
        assert_eq!(at(&direct, 320.0, 240.0), [(60.0, 168.0), (60.0, 192.0)]);
        let friend = Screen::Friend {
            code: String::new(),
            relay: String::new(),
            focus: 0,
        };
        assert_eq!(at(&friend, 427.0, 253.0), [(113.0, 177.0), (113.0, 201.0)]);
        let lost = Screen::Disconnected {
            reason: String::new(),
            retry: None,
        };
        assert_eq!(at(&lost, 427.0, 253.0), [(113.0, 156.0)]);
        // centeredText: `width / 2 - font.width(text) / 2`.
        assert_eq!(centered_x(427.0, 85.0), 171.0);
        assert_eq!(centered_x(320.0, 84.0), 118.0);
    }

    #[test]
    fn player_list_styles_sample_names_and_counts_the_rest() {
        let players = serde_json::json!({
            "online": 5,
            "sample": [
                {"name": "\u{a7}b\u{a7}lBIT\u{a7}rMADE"},
                {"name": ""},
                {"name": "\u{a7}8\u{2022}\u{a7}r \u{a7}bLobby"},
            ]
        });
        let lines = player_list(&players, 5);
        assert_eq!(lines.len(), 4);
        let plain: Vec<String> = lines.iter().take(3).map(Text::plain).collect();
        assert_eq!(plain, ["BITMADE", "", "\u{2022} Lobby"]);
        assert_eq!(player_list(&players, 3).len(), 3);
        assert!(player_list(&serde_json::json!({"online": 2}), 2).is_empty());
        assert!(player_list(&serde_json::json!({"online": 2, "sample": []}), 2).is_empty());
    }

    #[test]
    fn player_list_tooltip_covers_only_the_player_count() {
        let servers = vec![ServerEntry::new("Test", "server0")];
        let size = (427.0, 240.0);
        let mut pings = HashMap::new();
        let hover = |pings: &HashMap<String, Ping>, cursor| {
            player_list_tooltip(&servers, pings, size, 0.0, cursor, |_| 20.0)
                .map(|l| l.iter().map(Text::plain).collect::<Vec<_>>())
        };
        assert!(hover(&pings, (324.0, 37.0)).is_none());
        let ok = |player_list| Ping::Ok {
            motd: Text::empty(),
            players: Some((0, 500)),
            player_list,
            ms: 1,
            version: String::new(),
        };
        pings.insert("server0".into(), ok(vec![Text::literal("Lobby")]));
        // The 20-wide count ends 5 pixels left of the bars at (349, 37).
        for cursor in [(324.0, 37.0), (343.9, 44.9)] {
            assert_eq!(hover(&pings, cursor), Some(vec!["Lobby".to_owned()]));
        }
        for cursor in [
            (323.9, 37.0),
            (344.0, 37.0),
            (324.0, 36.9),
            (324.0, 45.0),
            (349.0, 37.0),
        ] {
            assert!(hover(&pings, cursor).is_none(), "{cursor:?}");
        }
        pings.insert("server0".into(), ok(Vec::new()));
        assert!(hover(&pings, (324.0, 37.0)).is_none());
    }

    #[test]
    fn the_lan_header_follows_the_saved_servers() {
        let all: Vec<Row> = rows(2, 1).collect();
        assert_eq!(
            all,
            [Row::Server(0), Row::Server(1), Row::LanHeader, Row::Lan(0)]
        );
        // No saved servers: the list is the scanning header alone.
        assert_eq!(rows(0, 0).collect::<Vec<_>>(), [Row::LanHeader]);
        assert_eq!(content_height(0, 0), 40.0);
    }

    #[test]
    fn rows_sit_two_pixels_under_the_header_and_scroll_with_the_list() {
        // 427x240 GUI: the list spans 33..180, rows 305 wide from x 61.
        let size = (427.0, 240.0);
        assert_eq!(list_area(size.0, size.1), (33.0, 180.0, 61.0));
        assert_eq!(row_at(3, 0, (100.0, 35.0), size, 0.0), Some(Row::Server(0)));
        assert_eq!(row_at(3, 0, (100.0, 70.9), size, 0.0), Some(Row::Server(0)));
        assert_eq!(row_at(3, 0, (100.0, 71.0), size, 0.0), Some(Row::Server(1)));
        assert_eq!(
            row_at(3, 0, (100.0, 35.0), size, 36.0),
            Some(Row::Server(1))
        );
        assert_eq!(
            row_at(3, 0, (100.0, 143.0), size, 0.0),
            Some(Row::LanHeader)
        );
        assert_eq!(row_at(3, 0, (60.0, 40.0), size, 0.0), None);
        assert_eq!(row_at(3, 0, (100.0, 32.0), size, 0.0), None);
    }

    #[test]
    fn loading_dots_step_every_300_ms() {
        let frames: Vec<&str> = [0, 299, 300, 600, 900, 1200].map(loading_dots).to_vec();
        assert_eq!(
            frames,
            ["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<u8> {
        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 the_official_server_is_added_once_at_the_top() {
        let dir = std::env::temp_dir().join(format!("horizon-mp-official-{}", std::process::id()));
        let (name, address) = OFFICIAL_SERVER;
        let file = dir.join("servers.dat");
        let ips = || -> Vec<String> { servers::load(&file).into_iter().map(|s| s.ip).collect() };
        let fresh = |list: &[ServerEntry]| {
            let _ = std::fs::remove_dir_all(&dir);
            std::fs::create_dir_all(&dir).unwrap();
            if !list.is_empty() {
                servers::save(&file, list).unwrap();
            }
        };
        // A fresh list: just the official server, named like it.
        fresh(&[]);
        add_official_server(&dir).unwrap();
        assert_eq!(servers::load(&file), [ServerEntry::new(name, address)]);
        // An existing list: on top, the player's servers kept in their order.
        let mine = [
            ServerEntry::new("Mine", "127.0.0.1:2"),
            ServerEntry::new("Other", "example.org"),
        ];
        fresh(&mine);
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), [address, "127.0.0.1:2", "example.org"]);
        // Once only: a second start adds nothing.
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), [address, "127.0.0.1:2", "example.org"]);
        // Already there under the player's own name and spelling: not duplicated.
        fresh(&[
            ServerEntry::new("SMP", "Play.PlayHorizon.dev:25565"),
            mine[0].clone(),
        ]);
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), ["Play.PlayHorizon.dev:25565", "127.0.0.1:2"]);
        // Deleted by the player: never back.
        fresh(&mine);
        add_official_server(&dir).unwrap();
        servers::save(&file, &mine).unwrap();
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), ["127.0.0.1:2", "example.org"]);
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn a_moved_official_server_moves_the_old_entry_once() {
        let dir = std::env::temp_dir().join(format!("horizon-mp-moved-{}", std::process::id()));
        let address = OFFICIAL_SERVER.1;
        let file = dir.join("servers.dat");
        let marker = dir.join(OFFICIAL_MARKER);
        let ips = || -> Vec<String> { servers::load(&file).into_iter().map(|s| s.ip).collect() };
        let offered_before = |list: &[ServerEntry]| {
            let _ = std::fs::remove_dir_all(&dir);
            std::fs::create_dir_all(&dir).unwrap();
            servers::save(&file, list).unwrap();
            std::fs::write(&marker, "horizon.bunchy7s.dev\n").unwrap();
        };
        // The old address under the player's own name and spelling: moved, name and place kept.
        let mut old = ServerEntry::new("Our SMP", "Horizon.Bunchy7s.dev:25565");
        old.icon = Some("AAAA".into());
        offered_before(&[ServerEntry::new("Mine", "127.0.0.1:2"), old]);
        add_official_server(&dir).unwrap();
        let list = servers::load(&file);
        assert_eq!(ips(), ["127.0.0.1:2", address]);
        assert_eq!(
            (list[1].name.as_str(), list[1].icon.as_deref()),
            ("Our SMP", Some("AAAA"))
        );
        assert_eq!(
            std::fs::read_to_string(&marker).unwrap(),
            format!("{address}\n")
        );
        // Once: the old address added back afterwards is the player's.
        servers::prepend(&file, &ServerEntry::new("Old", "horizon.bunchy7s.dev")).unwrap();
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), ["horizon.bunchy7s.dev", "127.0.0.1:2", address]);
        // The new address already listed: no second entry.
        offered_before(&[
            ServerEntry::new("Old", "horizon.bunchy7s.dev"),
            ServerEntry::new("New", address),
        ]);
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), [address]);
        // Deleted by the player before the move: not offered again; another port is left alone.
        offered_before(&[ServerEntry::new("Test", "horizon.bunchy7s.dev:25570")]);
        add_official_server(&dir).unwrap();
        assert_eq!(ips(), ["horizon.bunchy7s.dev:25570"]);
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn arrow_keys_select_servers_and_shift_moves_them() {
        let dir = std::env::temp_dir().join(format!("horizon-mp-keys-{}", std::process::id()));
        let saves = dir.join("saves");
        std::fs::create_dir_all(&saves).unwrap();
        let file = servers_file(&saves);
        let list: Vec<ServerEntry> = ["a", "b", "c"]
            .iter()
            .map(|n| ServerEntry::new(n, "127.0.0.1:2"))
            .collect();
        servers::save(&file, &list).unwrap();
        let mut screen = Screen::list(&saves);
        let size = (427.0, 240.0);
        let state = |screen: &Screen| match screen {
            Screen::List {
                servers, selected, ..
            } => (
                servers.iter().map(|s| s.name.clone()).collect::<Vec<_>>(),
                *selected,
            ),
            _ => unreachable!(),
        };
        let abc = vec!["a".to_owned(), "b".into(), "c".into()];
        // None selected: Down takes the first, as vanilla's nextEntry does.
        assert!(screen.arrow(false, false, size, &saves));
        assert_eq!(state(&screen), (abc.clone(), Some(0)));
        // Up at the top stays; Down walks; the last stays.
        screen.arrow(true, false, size, &saves);
        assert_eq!(state(&screen).1, Some(0));
        screen.arrow(false, false, size, &saves);
        screen.arrow(false, false, size, &saves);
        screen.arrow(false, false, size, &saves);
        assert_eq!(state(&screen).1, Some(2));
        // Shift+Up moves "c" above "b", keeps it selected and saves the order.
        screen.arrow(true, true, size, &saves);
        assert_eq!(
            state(&screen),
            (vec!["a".to_owned(), "c".into(), "b".into()], Some(1))
        );
        let saved: Vec<String> = servers::load(&file).into_iter().map(|s| s.name).collect();
        assert_eq!(saved, ["a", "c", "b"]);
        // Nothing moves past the first server.
        screen.arrow(true, true, size, &saves);
        screen.arrow(true, true, size, &saves);
        assert_eq!(state(&screen).1, Some(0));
        assert_eq!(state(&screen).0[0], "c");
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[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<ServerEntry> = 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::<Vec<_>>(),
                *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<String> = 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, lan } => {
                assert_eq!(address, list[2].ip);
                assert!(!lan);
            }
            _ => panic!("the join arrow connects"),
        }
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn delete_asks_before_removing_the_server() {
        let dir = std::env::temp_dir().join(format!("horizon-mp-delete-{}", std::process::id()));
        let saves = dir.join("saves");
        std::fs::create_dir_all(&saves).unwrap();
        let file = servers_file(&saves);
        let list = vec![
            ServerEntry::new("Keep", "127.0.0.1:2"),
            ServerEntry::new("Gone", "127.0.0.1:3"),
        ];
        servers::save(&file, &list).unwrap();
        let size = (427.0, 240.0);
        let names =
            || -> Vec<String> { servers::load(&file).into_iter().map(|s| s.name).collect() };
        let mut screen = Screen::list(&saves);
        let select = |screen: &mut Screen| {
            if let Screen::List { selected, .. } = screen {
                *selected = Some(1);
            }
        };
        select(&mut screen);
        // Delete opens the ConfirmScreen: nothing is removed yet.
        screen.click(Some(44), 0.0, 0.0, size, &saves);
        assert!(matches!(&screen, Screen::ConfirmDelete { name, .. } if name == "Gone"));
        let labels: Vec<(f32, f32, String, u8)> = screen
            .buttons(size.0, size.1)
            .into_iter()
            .map(|b| (b.0, b.1, b.3, b.5))
            .collect();
        assert_eq!(
            labels,
            [
                (61.0, 135.0, "Delete".to_owned(), 58),
                (215.0, 135.0, "Cancel".to_owned(), 59),
            ]
        );
        assert_eq!(names(), ["Keep", "Gone"]);
        // Cancel and Escape return to the list with the selection kept.
        screen.click(Some(59), 0.0, 0.0, size, &saves);
        assert!(matches!(
            &screen,
            Screen::List {
                selected: Some(1),
                ..
            }
        ));
        screen.click(Some(44), 0.0, 0.0, size, &saves);
        assert!(!screen.escape(&saves));
        assert!(matches!(
            &screen,
            Screen::List {
                selected: Some(1),
                ..
            }
        ));
        assert_eq!(names(), ["Keep", "Gone"]);
        // Delete removes it, saves, and clears the selection.
        screen.click(Some(44), 0.0, 0.0, size, &saves);
        screen.click(Some(58), 0.0, 0.0, size, &saves);
        assert!(
            matches!(&screen, Screen::List { selected: None, servers, .. } if servers.len() == 1)
        );
        assert_eq!(names(), ["Keep"]);
        let _ = std::fs::remove_dir_all(&dir);
    }

    #[test]
    fn edit_cycles_and_saves_the_server_resource_pack_setting() {
        let dir = std::env::temp_dir().join(format!("horizon-mp-packs-{}", std::process::id()));
        let saves = dir.join("saves");
        std::fs::create_dir_all(&saves).unwrap();
        let file = servers_file(&saves);
        let mut entry = ServerEntry::new("Packs", "127.0.0.1:4");
        entry.accept_textures = Some(false);
        servers::save(&file, &[entry]).unwrap();
        let size = (427.0, 240.0);
        let mut screen = Screen::list(&saves);
        if let Screen::List { selected, .. } = &mut screen {
            *selected = Some(0);
        }
        screen.click(Some(43), 0.0, 0.0, size, &saves);
        let cycle = |screen: &Screen| {
            screen
                .buttons(size.0, size.1)
                .into_iter()
                .find(|b| b.5 == 60)
                .map(|b| (b.0, b.1, b.2, b.3))
        };
        // ManageServerScreen: 200 wide at width / 2 - 100 (ints: 427 / 2 is
        // 213) and height / 4 + 72, the saved value first.
        assert_eq!(
            cycle(&screen),
            Some((
                113.0,
                132.0,
                200.0,
                "Server Resource Packs: Disabled".into()
            ))
        );
        // Disabled, Prompt, Enabled: Cancel keeps what was saved.
        screen.click(Some(60), 0.0, 0.0, size, &saves);
        assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Prompt");
        screen.click(Some(51), 0.0, 0.0, size, &saves);
        assert_eq!(servers::load(&file)[0].accept_textures, Some(false));
        // Done saves it.
        if let Screen::List { selected, .. } = &mut screen {
            *selected = Some(0);
        }
        screen.click(Some(43), 0.0, 0.0, size, &saves);
        screen.click(Some(60), 0.0, 0.0, size, &saves);
        screen.click(Some(60), 0.0, 0.0, size, &saves);
        assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Enabled");
        screen.click(Some(50), 0.0, 0.0, size, &saves);
        assert_eq!(servers::load(&file)[0].accept_textures, Some(true));
        // A new server asks.
        screen.click(Some(42), 0.0, 0.0, size, &saves);
        assert_eq!(cycle(&screen).unwrap().3, "Server Resource Packs: Prompt");
        let _ = std::fs::remove_dir_all(&dir);
    }
}