Join a Friend's text moves to horizon-friends' own lang files (spec #14167 step 4)

horizon.multiplayer.{join,join_friend,invite_code,relay} leave every file of
crates/horizon-client/assets/horizon/lang for crates/horizon-friends/assets/lang/<code>.json,
each entry line byte for byte (only the commas between entries change), in the order the
file had them. The engine no longer uses them since Join a Friend became horizon-friends'
page. Their Turkish review record moves with them (tools/lang_review/horizon-friends/), and
the engine's form test uses test keys of its own.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

AGENTS.md

@@ -186,7 +186,7 @@ state stays separate from the library tests. This compiles gameplay twice for ex
 | Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `mobs/cem.rs` + `mobs/cem_anim.rs` (OptiFine/EMF entity models and their animations); `horizon-client-core/src/lang.rs`; crates `horizon-assets`, `horizon-optifine`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
-| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs` + `extras/` (each extra's glue: `mouse_tweaks.rs`, `sorting.rs`, `pvp.rs`, `reconnect.rs`), `options.rs` |
+| Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
 
 ## How `Game` is organised
 

CONTRIBUTING.md

@@ -13,6 +13,14 @@ else (videos, Discord and other community material) lives elsewhere.
 suggest something. A pull request for a roadmap item carries its `roadmap:<id>` label; ideas go to the suggestion
 queue (the hub, or `/suggest` on Discord) rather than to issues, which are for bugs.
 
+**Mod-related pull requests go to [arismoko/horizon](https://github.com/arismoko/horizon)**, the fork that carries the
+mod API and reviews and merges that work. That covers the mod API, native hooks and events for mods, native mods,
+content mods (`.hmod`), mixins, wasm mods, `cargo horizon-mod`, `horizon-mods`, mod builds and the registry, and
+their docs ([mods](docs/mods.md), [native mods](docs/native-mods.md)). Open the pull request there from your usual
+branch. Mod-related pull requests opened here are closed with a pointer to it. Engine extension points that Horizon's
+own crates register (the [layer split](docs/layers.md)), resource and shader pack formats, and gameplay fixes stay
+here.
+
 ## Build it
 
 - **Prerequisites:** Rust (stable), Python 3.10+, JDK 25, and on Linux the ALSA and udev headers

Cargo.lock

@@ -1418,6 +1418,7 @@ dependencies = [
 name = "horizon-chat-filter"
 version = "0.1.0"
 dependencies = [
+ "horizon-server-files",
  "serde",
  "serde_json",
  "toml",
@@ -1448,7 +1449,6 @@ dependencies = [
  "horizon-core",
  "horizon-cosmetics",
  "horizon-dualsense",
- "horizon-friends",
  "horizon-hdr",
  "horizon-hooks",
  "horizon-items",
@@ -1528,7 +1528,6 @@ dependencies = [
  "horizon-client-render",
  "horizon-command",
  "horizon-core",
- "horizon-friends",
  "horizon-hdr",
  "horizon-hooks",
  "horizon-items",
@@ -1592,7 +1591,6 @@ dependencies = [
  "horizon-optifine",
  "horizon-polytone",
  "horizon-protocol",
- "horizon-render-pipeline",
  "horizon-shader-api",
  "horizon-shaders",
  "horizon-system",
@@ -1668,6 +1666,7 @@ dependencies = [
  "getrandom 0.3.4",
  "hkdf",
  "horizon-addresses",
+ "horizon-platform",
  "if-addrs",
  "serde",
  "serde_json",
@@ -1793,6 +1792,7 @@ dependencies = [
 name = "horizon-official"
 version = "0.1.0"
 dependencies = [
+ "horizon-friends",
  "horizon-game",
  "horizon-heartbeat",
  "horizon-platform",
@@ -1891,10 +1891,6 @@ dependencies = [
  "ring",
 ]
 
-[[package]]
-name = "horizon-render-pipeline"
-version = "0.1.0"
-
 [[package]]
 name = "horizon-server"
 version = "0.1.0"
@@ -1957,7 +1953,6 @@ version = "0.1.0"
 dependencies = [
  "half",
  "horizon-core",
- "horizon-render-pipeline",
  "naga",
  "png",
  "zip",

Cargo.toml

@@ -43,7 +43,6 @@ members = [
     "crates/cargo-horizon-mod",
     "crates/horizon-port-pack",
     "crates/horizon-shaders",
-    "crates/horizon-render-pipeline",
     "crates/horizon-optifine",
     "crates/horizon-polytone",
     "crates/horizon-shader-api",

crates/horizon-chat-filter/Cargo.toml

@@ -7,6 +7,8 @@ rust-version.workspace = true
 description = "The dedicated server's chat filter: its [chat_filter] settings, the slur list's matcher and the mutes, with no game state (docs/chat-filter.md)"
 
 [dependencies]
+# The moderation durations, shared with `/tempban`.
+horizon-server-files = { path = "../horizon-server-files" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 toml = "1.1"

crates/horizon-chat-filter/src/lib.rs

@@ -10,6 +10,9 @@ use std::path::{Path, PathBuf};
 
 mod normalise;
 
+pub use horizon_server_files::duration::{
+    DurationUnit, duration_parts, duration_text, now_millis, parse_duration,
+};
 pub use normalise::{Run, Text};
 
 /// The list built into the game, used when `words_file` is empty.
@@ -474,61 +477,6 @@ pub fn append_log(path: &Path, line: &str) -> std::io::Result<()> {
     writeln!(f, "{line}")
 }
 
-/// `/tempmute`'s duration in milliseconds: a positive whole number and a unit, `s`, `m`, `h`, `d` or
-/// `w` (`10m`, `2h`, `1d`).
-pub fn parse_duration(text: &str) -> Option<i64> {
-    let unit = match text.chars().last()? {
-        's' => 1_000,
-        'm' => MINUTE,
-        'h' => 60 * MINUTE,
-        'd' => 24 * 60 * MINUTE,
-        'w' => 7 * 24 * 60 * MINUTE,
-        _ => return None,
-    };
-    let count: i64 = text[..text.len() - 1].parse().ok()?;
-    (count > 0).then(|| count.checked_mul(unit)).flatten()
-}
-
-/// The unit used when presenting a moderation duration to a player.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum DurationUnit {
-    Minute,
-    Hour,
-    Day,
-}
-
-/// A duration's rounded count and unit, shared by logs and translated replies.
-pub fn duration_parts(millis: i64) -> (i64, DurationUnit) {
-    let (unit, kind) = if millis <= 60 * MINUTE {
-        (MINUTE, DurationUnit::Minute)
-    } else if millis <= 48 * 60 * MINUTE {
-        (60 * MINUTE, DurationUnit::Hour)
-    } else {
-        (24 * 60 * MINUTE, DurationUnit::Day)
-    };
-    (
-        millis.div_euclid(unit) + i64::from(millis.rem_euclid(unit) > 0),
-        kind,
-    )
-}
-
-/// `millis` for logs, rounded up: minutes up to an hour, hours up to two days, then days.
-pub fn duration_text(millis: i64) -> String {
-    let (count, unit) = duration_parts(millis);
-    let unit = match unit {
-        DurationUnit::Minute => "minute",
-        DurationUnit::Hour => "hour",
-        DurationUnit::Day => "day",
-    };
-    format!("{count} {unit}{}", if count == 1 { "" } else { "s" })
-}
-
-pub fn now_millis() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .map_or(0, |d| d.as_millis() as i64)
-}
-
 /// `YYYY-MM-DDTHH:MM:SSZ` for epoch milliseconds.
 pub fn utc(millis: i64) -> String {
     let secs = millis.div_euclid(1000);

crates/horizon-client-core/src/lang.rs

@@ -74,11 +74,70 @@ pub trait ResourceSource {
         vec!["minecraft".into()]
     }
 }
+/// The bundled file a language reads, and whether it drops `ß`: a regional variant reads its
+/// language's file (Swiss German writes "ss" for "ß", as vanilla's de_ch does).
+fn bundled_code(code: &str) -> (&str, bool) {
+    match code {
+        "ko" => ("ko_kr", false),
+        "hr" => ("hr_hr", false),
+        "de_at" => ("de_de", false),
+        "de_ch" => ("de_de", true),
+        "fr_ca" | "fr_ch" => ("fr_fr", false),
+        "es_ar" | "es_cl" | "es_ec" | "es_mx" | "es_uy" | "es_ve" => ("es_es", false),
+        code => (code, false),
+    }
+}
+
+/// Lang files crates above the engine ship (`horizon_hooks::lang`), each a list of
+/// (code, JSON) pairs. The game's entry installs them once, before any language loads.
+static CRATE_FILES: std::sync::OnceLock<&'static [&'static [(&'static str, &'static str)]]> =
+    std::sync::OnceLock::new();
+
+/// Installs the crates' lang files (`horizon_hooks::lang::engine::all()`). Only the first call
+/// counts.
+pub fn install_crate_files(files: &'static [&'static [(&'static str, &'static str)]]) {
+    let _ = CRATE_FILES.set(files);
+}
+
+/// The crates' entries for language `code` (through [`bundled_code`]'s variants) that the
+/// engine's own `horizon` file for it doesn't have: on a key both have, the engine wins.
+fn read_crate_files(files: &[&[(&str, &str)]], code: &str, map: &mut HashMap<String, String>) {
+    if files.is_empty() {
+        return;
+    }
+    let (file, swiss) = bundled_code(code);
+    let mut own = HashMap::new();
+    if let Some(bytes) = Bundled.read(&format!("assets/horizon/lang/{code}.json")) {
+        read_lang_file(&bytes, &mut own);
+    }
+    for (c, json) in files.iter().flat_map(|f| f.iter()) {
+        if *c != file {
+            continue;
+        }
+        let mut theirs = HashMap::new();
+        if swiss {
+            read_lang_file(json.replace('ß', "ss").as_bytes(), &mut theirs);
+        } else {
+            read_lang_file(json.as_bytes(), &mut theirs);
+        }
+        for (key, value) in theirs {
+            if !own.contains_key(&key) {
+                map.insert(key, value);
+            }
+        }
+    }
+}
+
 /// Horizon's own strings, compiled in so they need no prepared resources.
 struct Bundled;
 impl ResourceSource for Bundled {
     fn read(&self, path: &str) -> Option<Vec<u8>> {
-        let body = match path {
+        let code = path
+            .strip_prefix("assets/horizon/lang/")?
+            .strip_suffix(".json")?;
+        let (file, swiss) = bundled_code(code);
+        let path = format!("assets/horizon/lang/{file}.json");
+        let body = match path.as_str() {
             "assets/horizon/lang/en_us.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/en_us.json")
             }
@@ -103,10 +162,10 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/tr_tr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
             }
-            "assets/horizon/lang/ko_kr.json" | "assets/horizon/lang/ko.json" => {
+            "assets/horizon/lang/ko_kr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/ko_kr.json")
             }
-            "assets/horizon/lang/hr_hr.json" | "assets/horizon/lang/hr.json" => {
+            "assets/horizon/lang/hr_hr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/hr_hr.json")
             }
             "assets/horizon/lang/pt_pt.json" => {
@@ -331,30 +390,20 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/vec_it.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/vec_it.json")
             }
-            "assets/horizon/lang/de_de.json" | "assets/horizon/lang/de_at.json" => {
+            "assets/horizon/lang/de_de.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/de_de.json")
             }
-            // Swiss German writes "ss" for "ß", as vanilla's de_ch does.
-            "assets/horizon/lang/de_ch.json" => {
-                let de = include_str!("../../horizon-client/assets/horizon/lang/de_de.json");
-                return Some(de.replace('ß', "ss").into_bytes());
-            }
-            "assets/horizon/lang/fr_fr.json"
-            | "assets/horizon/lang/fr_ca.json"
-            | "assets/horizon/lang/fr_ch.json" => {
+            "assets/horizon/lang/fr_fr.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/fr_fr.json")
             }
-            "assets/horizon/lang/es_es.json"
-            | "assets/horizon/lang/es_ar.json"
-            | "assets/horizon/lang/es_cl.json"
-            | "assets/horizon/lang/es_ec.json"
-            | "assets/horizon/lang/es_mx.json"
-            | "assets/horizon/lang/es_uy.json"
-            | "assets/horizon/lang/es_ve.json" => {
+            "assets/horizon/lang/es_es.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/es_es.json")
             }
             _ => return None,
         };
+        if swiss {
+            return Some(body.replace('ß', "ss").into_bytes());
+        }
         Some(body.as_bytes().to_vec())
     }
     fn namespaces(&self) -> Vec<String> {
@@ -438,6 +487,16 @@ impl Language {
     /// from every namespace and every source in priority order (later sources
     /// override).
     pub fn load(sources: &[&dyn ResourceSource], code: &str) -> Self {
+        let crate_files = CRATE_FILES.get().copied().unwrap_or_default();
+        Self::load_with(sources, code, crate_files)
+    }
+
+    /// [`Language::load`] with these crates' lang files.
+    fn load_with(
+        sources: &[&dyn ResourceSource],
+        code: &str,
+        crate_files: &[&[(&str, &str)]],
+    ) -> Self {
         let mut map = HashMap::new();
         let mut codes = vec![DEFAULT];
         if code != DEFAULT {
@@ -453,12 +512,14 @@ impl Language {
             sources.iter().flat_map(|s| s.namespaces()).collect();
         for c in codes {
             for namespace in &namespaces {
-                for source in sources {
-                    let Some(bytes) = source.read(&format!("assets/{namespace}/lang/{c}.json"))
-                    else {
-                        continue;
-                    };
-                    read_lang_file(&bytes, &mut map);
+                for (i, source) in sources.iter().enumerate() {
+                    if let Some(bytes) = source.read(&format!("assets/{namespace}/lang/{c}.json")) {
+                        read_lang_file(&bytes, &mut map);
+                    }
+                    // The crates' text right after the engine's own (`Bundled`, the first source).
+                    if i == 0 && namespace == "horizon" {
+                        read_crate_files(crate_files, c, &mut map);
+                    }
                 }
             }
         }
@@ -688,6 +749,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn a_crates_text_loads_after_the_engines_and_before_packs() {
+        static CRATE: &[(&str, &str)] = &[
+            (
+                "en_us",
+                r#"{"test.crate.hello": "Hello", "horizon.osk.close": "Shut", "test.crate.packed": "Crate"}"#,
+            ),
+            (
+                "de_de",
+                r#"{"test.crate.hello": "Grüß dich", "horizon.osk.close": "Zu"}"#,
+            ),
+            ("fr_fr", r#"{"test.crate.hello": "Bonjour"}"#),
+        ];
+        let pack = Mem(HashMap::from([(
+            "assets/horizon/lang/en_us.json".to_owned(),
+            br#"{"test.crate.packed": "Pack"}"#.to_vec(),
+        )]));
+        let load = |code| Language::load_with(&[&pack], code, &[CRATE]);
+        let en = load("en_us");
+        assert_eq!(en.get("test.crate.hello"), Some("Hello"));
+        // The engine's own file wins on a key both have; a pack wins over both.
+        assert_eq!(en.get("horizon.osk.close"), Some("Close"));
+        assert_eq!(en.get("test.crate.packed"), Some("Pack"));
+        let de = load("de_de");
+        assert_eq!(de.get("test.crate.hello"), Some("Grüß dich"));
+        assert_eq!(de.get("horizon.osk.close"), Some("Schließen"));
+        // Regional variants read their language's file, as the engine's do.
+        assert_eq!(load("de_ch").get("test.crate.hello"), Some("Grüss dich"));
+        assert_eq!(load("fr_ca").get("test.crate.hello"), Some("Bonjour"));
+        // A language the crate lacks falls back to its English.
+        assert_eq!(load("pl_pl").get("test.crate.hello"), Some("Hello"));
+        // Without crate files, nothing changes.
+        let plain = Language::load_with(&[&pack], "de_de", &[]);
+        assert_eq!(plain.get("test.crate.hello"), None);
+        assert_eq!(plain.len() + 1, de.len());
+    }
+
     #[test]
     fn a_scoped_language_is_the_calling_threads_and_reports_what_it_lacks() {
         let empty = Mem(HashMap::new());
@@ -739,6 +837,20 @@ mod tests {
         std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
             .join("../horizon-client/assets/horizon/lang")
     }
+    /// The crates whose own lang files the game loads (`crates/<name>/assets/lang`,
+    /// registered through `horizon_hooks::lang`), with that folder.
+    fn crate_lang_dirs() -> Vec<(String, std::path::PathBuf)> {
+        let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+        let mut dirs: Vec<_> = std::fs::read_dir(&crates)
+            .unwrap()
+            .flatten()
+            .map(|e| (e.file_name().into_string().unwrap(), e.path()))
+            .map(|(name, path)| (name, path.join("assets/lang")))
+            .filter(|(_, dir)| dir.join("en_us.json").is_file())
+            .collect();
+        dirs.sort();
+        dirs
+    }
     /// The keys of a flat bundled file in file order, duplicates included (a map
     /// would keep only the last of two equal keys). One `"key": "value"` per line.
     fn file_keys(body: &str) -> Vec<String> {
@@ -776,11 +888,33 @@ mod tests {
 
     #[test]
     fn bundled_files_are_served_and_have_no_stale_or_repeated_keys() {
-        let dir = bundled_dir();
+        let engine = check_lang_dir(&bundled_dir(), true);
+        assert!(
+            engine.1 >= 7,
+            "found {} bundled lang files in {}",
+            engine.1,
+            bundled_dir().display()
+        );
+        // A crate's files pass the same checks. Its keys are its own: on a key the engine's
+        // files also have, the engine's text would win and hide the crate's.
+        for (name, dir) in crate_lang_dirs() {
+            let (en, _) = check_lang_dir(&dir, false);
+            for key in en.keys() {
+                assert!(
+                    !engine.0.contains_key(key),
+                    "{name}: {key} is also the engine's"
+                );
+            }
+        }
+    }
+
+    /// The checks every lang folder passes: flat maps, no repeated key, no key en_us lacks, the
+    /// same placeholders as English, no empty text. Its en_us and how many files it has.
+    fn check_lang_dir(dir: &std::path::Path, bundled: bool) -> (HashMap<String, String>, usize) {
         let en_body = std::fs::read_to_string(dir.join("en_us.json")).unwrap();
         let en: HashMap<String, String> = serde_json::from_str(&en_body).unwrap();
         let mut seen = 0;
-        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
+        for entry in std::fs::read_dir(dir).unwrap().flatten() {
             let name = entry.file_name().into_string().unwrap();
             let Some(code) = name.strip_suffix(".json") else {
                 continue;
@@ -789,7 +923,7 @@ mod tests {
             // A file that Bundled::read does not name is never loaded.
             let path = format!("assets/horizon/lang/{name}");
             assert!(
-                Bundled.read(&path).is_some(),
+                !bundled || Bundled.read(&path).is_some(),
                 "{name} is not served by Bundled"
             );
             let body = std::fs::read_to_string(entry.path()).unwrap();
@@ -815,11 +949,7 @@ mod tests {
                 assert!(!value.trim().is_empty(), "{code}: {key} is empty");
             }
         }
-        assert!(
-            seen >= 7,
-            "found {seen} bundled lang files in {}",
-            dir.display()
-        );
+        (en, seen)
     }
 
     #[test]
@@ -834,10 +964,10 @@ mod tests {
                 }
             }
         }
-        let en: HashMap<String, String> = serde_json::from_str(
-            &std::fs::read_to_string(bundled_dir().join("en_us.json")).unwrap(),
-        )
-        .unwrap();
+        let english = |dir: &std::path::Path| -> HashMap<String, String> {
+            serde_json::from_str(&std::fs::read_to_string(dir.join("en_us.json")).unwrap()).unwrap()
+        };
+        let mut en = english(&bundled_dir());
         let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
         let mut files = Vec::new();
         for krate in [
@@ -847,6 +977,11 @@ mod tests {
         ] {
             rust_files(&crates.join(krate).join("src"), &mut files);
         }
+        // A crate that ships lang files names its keys in its own sources.
+        for (name, dir) in crate_lang_dirs() {
+            en.extend(english(&dir));
+            rust_files(&crates.join(name).join("src"), &mut files);
+        }
         assert!(files.len() > 100, "found only {} sources", files.len());
         let mut found = 0;
         for file in files {

crates/horizon-client-input/src/window.rs

@@ -670,6 +670,39 @@ pub fn with_horizon_icon(
     attributes
 }
 
+/// The screen a window is on: its size in physical pixels, its refresh rate where the OS gives
+/// it, and its scale. For `horizon-ctl status` and the performance statistics' `system.display`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Display {
+    pub width: u32,
+    pub height: u32,
+    pub refresh_hz: Option<u32>,
+    pub scale: f64,
+}
+
+/// The screen `window` is on, else the primary one, else the only one: right after the window
+/// is made, Wayland doesn't say yet which screen it is on.
+pub fn monitor(window: &winit::window::Window) -> Option<winit::monitor::MonitorHandle> {
+    let only = || {
+        let mut all = window.available_monitors();
+        all.next().filter(|_| all.next().is_none())
+    };
+    window
+        .current_monitor()
+        .or_else(|| window.primary_monitor())
+        .or_else(only)
+}
+
+/// [`monitor`]'s size, refresh rate and scale.
+pub fn display(window: &winit::window::Window) -> Option<Display> {
+    monitor(window).map(|m| Display {
+        width: m.size().width,
+        height: m.size().height,
+        refresh_hz: m.refresh_rate_millihertz().map(|r| r.div_ceil(1000)),
+        scale: m.scale_factor(),
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/horizon-client-lib/Cargo.toml

@@ -42,8 +42,6 @@ horizon-chat-filter = { path = "../horizon-chat-filter" }
 horizon-shaders = { path = "../horizon-shaders" }
 # Horizon's own shader packs: the format, the stages and the check (docs/shaders.md).
 horizon-shader-api = { path = "../horizon-shader-api" }
-# Play with Friends: invite codes and their tunnel; the `friends` feature.
-horizon-friends = { path = "../horizon-friends", optional = true }
 # The narrator (GameNarrator): text-to-speech of chat, system messages and screens.
 horizon-narrator = { path = "../horizon-narrator" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
@@ -111,16 +109,17 @@ objc2-foundation = { version = "0.3", default-features = false, features = ["std
 wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
 
 [features]
-default = ["audio", "controllers", "discord", "friends"]
+default = ["audio", "controllers", "horizon-extras"]
 # Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
 # Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
 audio = ["horizon-client-render/audio"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
 controllers = ["dep:gilrs", "horizon-client-input/controllers"]
+# Horizon's own parts (docs/forking.md, docs/layers.md): the features below, and the official
+# server in the list (`official_servers`).
+horizon-extras = ["discord"]
 # "Playing Horizon" on the player's Discord profile (`discord_presence`).
 discord = []
-# Play with Friends, joining side (`net.rs`): without it no invite code joins.
-friends = ["dep:horizon-friends"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]
 # Compatibility with earlier experiment commands: main already uses mimalloc.

crates/horizon-client-render/Cargo.toml

@@ -26,7 +26,6 @@ horizon-narrator = { path = "../horizon-narrator" }
 horizon-optifine = { path = "../horizon-optifine" }
 horizon-polytone = { path = "../horizon-polytone" }
 horizon-protocol = { path = "../horizon-protocol" }
-horizon-render-pipeline = { path = "../horizon-render-pipeline" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }
 horizon-system = { path = "../horizon-system" }
@@ -77,6 +76,10 @@ wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
 audio = ["dep:cpal"]
 # Helpers horizon-client's tests build their fixtures with.
 test-support = []
+# horizon-client's `horizon-extras`: asking the device for hardware ray tracing on request
+# (`gfx/ray_query.rs`, `HORIZON_RAY_TRACING=1`). Without it the device is requested as without
+# the variable.
+horizon-extras = []
 
 [lints]
 workspace = true

crates/horizon-client-render/examples/standard_pack_gpu_entities.rs

@@ -362,7 +362,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
         outline: Vec::new(),
         outline_after_terrain: false,
         outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],

crates/horizon-client-render/examples/world_warp_check.rs

@@ -430,7 +430,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
         outline: Vec::new(),
         outline_after_terrain: false,
         outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],

crates/horizon-client-render/src/assets.rs

@@ -382,8 +382,8 @@ impl RenderAssets {
         };
         // After the connected tiles: a tile identical to a block shares its layer, and the
         // overlays skip shared layers.
-        if draws {
-            emissive = crate::native_emissive::load_optifine(root, &mut sprites);
+        if draws && let Some(suffix) = crate::pack_hooks::formats().emissive_suffix(root) {
+            emissive = crate::native_emissive::load_overlays(root, &suffix, &mut sprites);
         }
         sprites.save_disk_cache();
         if draws {

crates/horizon-client-render/src/atlas_sources.rs

@@ -233,11 +233,11 @@ pub fn texture_path(root: &Path, texture: &str, directory: &str) -> PathBuf {
     }
     let (namespace, path) = texture.split_once(':').unwrap_or(("minecraft", texture));
     let rel = format!("assets/{namespace}/{directory}/{path}.png");
-    root.join(if horizon_optifine::paths::valid(&rel) {
-        &rel
-    } else {
-        NOWHERE
-    })
+    // No `.`, `..` or empty segment, and no `\` (a separator on Windows, where `..\..` climbs).
+    let stays = rel
+        .split('/')
+        .all(|segment| !matches!(segment, "" | "." | "..") && !segment.contains('\\'));
+    root.join(if stays { &rel } else { NOWHERE })
 }
 
 /// `SpriteSourceList.list`: every sprite id of the atlas and its origin.

crates/horizon-client-render/src/command_block.rs

@@ -121,8 +121,8 @@ impl CommandBlock {
             condition_met: flag("conditionMet", false),
         }
     }
-    /// `CommandBlockEntity.saveAdditional`. The last output is written as a
-    /// plain string component.
+    /// `CommandBlockEntity.saveAdditional`. The last output is the component
+    /// itself (`ComponentSerialization.CODEC`), styles and click events kept.
     pub fn save(&self) -> Vec<(&'static str, Tag)> {
         let mut out = vec![
             ("Command", Tag::String(self.command.as_str().into())),
@@ -135,7 +135,7 @@ impl CommandBlock {
         if self.track_output
             && let Some(last) = &self.last_output
         {
-            out.push(("LastOutput", Tag::String(last.plain().as_str().into())));
+            out.push(("LastOutput", scoreboard::component_tag(&last.component())));
         }
         out.push((
             "UpdateLastExecution",

crates/horizon-client-render/src/custom_sky.rs

@@ -1,27 +1,34 @@
-//! OptiFine custom skies (`horizon_optifine::sky`) as the game draws them: a pack's layers with
-//! their decoded textures, read once with the pack, and each frame's choice of layers, their
-//! brightness and rotation ([`CustomSky::draws`]), which `gfx::custom_sky` draws over the
-//! vanilla sky. A pack without `optifine/sky` gives an empty [`CustomSky`] and the sky stays
-//! vanilla.
+//! Custom sky layers: skyboxes a pack draws over the vanilla sky, in a format vanilla doesn't read
+//! (OptiFine's), which the platform's pack formats fill ([`crate::pack_hooks`]). The layers'
+//! textures are read once with the pack; each frame the game asks for the layers to draw, their
+//! brightness and rotation ([`SkyLayers::draws`]), and `gfx::custom_sky` draws them over the
+//! vanilla sky. A pack without layers keeps the vanilla sky.
 
 use std::path::Path;
+use std::sync::Arc;
 
-use glam::{Mat4, Vec3};
-use horizon_optifine::sky::{Blend, Conditions, Skies, SkyLayer, Transition};
+use glam::Mat4;
 
-/// A layer's texture, RGBA8.
+/// A layer's texture, RGBA8: the skybox's six faces in a 3x2 grid, bottom, top and south in the
+/// top row, west, north and east below (`gfx::custom_sky`'s faces).
 pub struct Image {
     pub width: u32,
     pub height: u32,
     pub rgba: Vec<u8>,
 }
 
-/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
-/// over all worlds, in `worlds` order).
-#[derive(Default)]
-pub struct CustomSky {
-    worlds: Vec<(i32, Vec<SkyLayer>)>,
-    pub images: Vec<Image>,
+/// How a layer mixes with what is drawn below it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Blend {
+    Add,
+    Subtract,
+    Multiply,
+    Dodge,
+    Burn,
+    Screen,
+    Replace,
+    Overlay,
+    Alpha,
 }
 
 /// One layer of a frame: which texture, with which blend, how bright and turned how.
@@ -34,62 +41,44 @@ pub struct Draw {
     pub rotation: Mat4,
 }
 
+/// The weather of a frame: thunder is a storm's rain, so it is only `Thunder`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Weather {
+    Clear,
+    Rain,
+    Thunder,
+}
+
+/// What a frame's layers may depend on.
+#[derive(Clone, Copy, Debug)]
+pub struct Conditions<'a> {
+    /// Ticks of the day, counting the days.
+    pub day_time: i64,
+    pub weather: Weather,
+    /// The biome at the camera, namespaced.
+    pub biome: &'a str,
+    /// The camera's block height.
+    pub y: i32,
+}
+
 /// The eased brightness of each layer, kept by the game between frames.
 #[derive(Default)]
 pub struct State {
-    world: Option<i32>,
-    eased: Vec<Transition>,
+    /// The world the layers were last drawn for.
+    pub world: Option<i32>,
+    /// Each layer's eased visibility, 0 to 1.
+    pub eased: Vec<f32>,
 }
 
-/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
-const TEXEL_BUDGET: u64 = 64 << 20;
-
-impl CustomSky {
-    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
-    /// dropped with a warning.
-    pub fn load(root: &Path) -> Self {
-        let skies = Skies::scan(root);
-        let mut out = Self::default();
-        let mut texels = 0u64;
-        for (world, sky) in skies.worlds {
-            let mut layers = Vec::new();
-            for layer in sky.layers {
-                match crate::hud::decode(&root.join(&layer.source)) {
-                    Ok((width, height, rgba))
-                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
-                    {
-                        texels += u64::from(width) * u64::from(height);
-                        out.images.push(Image {
-                            width,
-                            height,
-                            rgba,
-                        });
-                        layers.push(layer);
-                    }
-                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
-                    Err(e) => log::warn!("{}: {e:#}", layer.source),
-                }
-            }
-            if !layers.is_empty() {
-                out.worlds.push((world, layers));
-            }
-        }
-        out
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.worlds.is_empty()
-    }
-
-    /// Whether `world` has layers (`0` the Overworld, `1` the End).
-    pub fn has(&self, world: i32) -> bool {
-        self.worlds.iter().any(|(w, _)| *w == world)
-    }
-
-    /// This frame's layers of `world` into `out` (cleared first), in drawing order: those whose
-    /// conditions hold, eased over their `transition` by `seconds` since the last frame, at the
-    /// brightness of their fade times. `sun_turns` is the sun's angle over 360° (`0` at noon).
-    pub fn draws(
+/// A pack's custom sky layers, by world (`0` the Overworld, `1` the End).
+pub trait SkyLayers: Send + Sync {
+    /// Every layer's texture: [`Draw::image`] indexes it.
+    fn images(&self) -> &[Image];
+    /// Whether `world` has layers.
+    fn has(&self, world: i32) -> bool;
+    /// This frame's layers of `world` into `out` (cleared first), in drawing order, eased by
+    /// `seconds` since the last frame. `sun_turns` is the sun's angle over 360° (`0` at noon).
+    fn draws(
         &self,
         world: i32,
         conditions: &Conditions,
@@ -97,147 +86,30 @@ impl CustomSky {
         seconds: f32,
         state: &mut State,
         out: &mut Vec<Draw>,
-    ) {
+    );
+}
+
+/// No layers: the vanilla sky.
+struct NoLayers;
+
+impl SkyLayers for NoLayers {
+    fn images(&self) -> &[Image] {
+        &[]
+    }
+
+    fn has(&self, _: i32) -> bool {
+        false
+    }
+
+    fn draws(&self, _: i32, _: &Conditions, _: f32, _: f32, s: &mut State, out: &mut Vec<Draw>) {
         out.clear();
-        let mut first = 0;
-        let mut found = None;
-        for (w, layers) in &self.worlds {
-            if *w == world {
-                found = Some(layers);
-                break;
-            }
-            first += layers.len();
-        }
-        let Some(layers) = found else {
-            state.world = None;
-            return;
-        };
-        // A new world (or pack) starts each layer where its conditions put it: no fade in.
-        let snap = state.world != Some(world) || state.eased.len() != layers.len();
-        if snap {
-            state.world = Some(world);
-            state.eased.clear();
-            state.eased.resize(layers.len(), Transition::default());
-        }
-        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
-            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
-            let shown = if snap {
-                eased.value = target;
-                target
-            } else {
-                eased.step(target, seconds, layer.transition)
-            };
-            let brightness = shown * layer.brightness(conditions.day_time);
-            if brightness <= 0.0 {
-                continue;
-            }
-            let turns = layer.turns(conditions.day_time, sun_turns);
-            let rotation = if turns == 0.0 {
-                Mat4::IDENTITY
-            } else {
-                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
-            };
-            out.push(Draw {
-                image: (first + i) as u16,
-                blend: layer.blend,
-                brightness,
-                rotation,
-            });
-        }
+        s.world = None;
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use horizon_optifine::sky::Now;
-
-    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
-        let root = std::env::temp_dir().join(format!(
-            "horizon-custom-sky-{}-{}",
-            std::process::id(),
-            files.len()
-        ));
-        let _ = std::fs::remove_dir_all(&root);
-        let dir = root.join("assets/minecraft/optifine/sky/world0");
-        std::fs::create_dir_all(&dir).unwrap();
-        let png = {
-            let mut bytes = Vec::new();
-            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
-            encoder.set_color(png::ColorType::Rgba);
-            encoder.set_depth(png::BitDepth::Eight);
-            let mut writer = encoder.write_header().unwrap();
-            writer
-                .write_image_data(&[255, 0, 0, 255].repeat(24))
-                .unwrap();
-            writer.finish().unwrap();
-            bytes
-        };
-        for (name, text) in files {
-            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
-            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
-        }
-        let sky = CustomSky::load(&root);
-        (root, sky)
-    }
-
-    fn noon(biome: &str) -> Conditions<'_> {
-        Conditions {
-            day_time: 6000,
-            weather: Now::Clear,
-            biome,
-            y: 64,
-        }
-    }
-
-    #[test]
-    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
-        let (root, sky) = pack(&[
-            ("sky1", "biomes=desert\ntransition=2"),
-            ("sky2", "blend=alpha\nrotate=false"),
-        ]);
-        let _ = std::fs::remove_dir_all(root);
-        assert!(sky.has(0) && !sky.has(1));
-        assert_eq!(sky.images[0].width, 6);
-        let (mut state, mut out) = (State::default(), Vec::new());
-        sky.draws(
-            0,
-            &noon("minecraft:desert"),
-            0.0,
-            0.05,
-            &mut state,
-            &mut out,
-        );
-        assert_eq!(
-            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
-            [1.0, 1.0]
-        );
-        // Out of the desert: the first layer fades over its two seconds.
-        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
-        assert_eq!(out[0].brightness, 0.75);
-        assert_eq!(out[1].blend, Blend::Alpha);
-        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
-        assert_eq!(out.len(), 1, "a dark layer is not drawn");
-        assert_eq!(out[0].image, 1);
-        // Into the End, which has no layers, and back: no fade.
-        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
-        assert!(out.is_empty());
-        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
-        assert_eq!(out.len(), 2);
-    }
-
-    #[test]
-    fn a_layer_turns_west_like_the_sun() {
-        let (root, sky) = pack(&[("sky1", "")]);
-        let _ = std::fs::remove_dir_all(root);
-        let (mut state, mut out) = (State::default(), Vec::new());
-        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
-        let c = Conditions {
-            day_time: 12000,
-            ..noon("minecraft:plains")
-        };
-        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
-        let up = out[0].rotation.transform_vector3(Vec3::Y);
-        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
-    }
+/// The custom sky layers of the overlay at `root`, from the installed pack formats.
+pub fn load(root: &Path) -> Arc<dyn SkyLayers> {
+    crate::pack_hooks::formats()
+        .custom_sky(root)
+        .unwrap_or_else(|| Arc::new(NoLayers))
 }

crates/horizon-client-render/src/extras_ui.rs

@@ -1,5 +1,6 @@
 //! The Horizon Extras page, on the settings shell (`settings_shell`): which rows it has and what
-//! pressing them does. Each one's value and what it does stay in `extras::Item`.
+//! pressing them does. Each one's value and what it does stay in `extras::Item`; the sections crates
+//! add (`horizon_hooks::pages::Place::Extras`) keep theirs.
 use crate::{
     extras::{self, Item},
     lang,
@@ -7,6 +8,7 @@ use crate::{
     settings::Settings,
     settings_shell::{self as shell, Binding, Group, Output, Row, Screen, Sheet, Value},
 };
+use horizon_hooks::pages::{self as added, Act, Label};
 
 const TITLE: &str = "horizon.pages.extras";
 const ABOUT: &str = "horizon.pages.extras.tooltip";
@@ -31,6 +33,125 @@ pub(crate) enum ExtraRow {
     /// It isn't installed: where to get it. A note, not a button: Options > Mods already has the
     /// one way into the Mods page (`every_setting_and_page_is_reached_from_one_place`).
     ZoomInstall,
+    /// Row `.1` of the section registered page `.0` adds (`Place::Extras`).
+    Added(usize, usize),
+}
+
+#[cfg(test)]
+thread_local! {
+    /// A test's own pages, instead of the game's registered ones: each test runs on its thread.
+    static TEST_PAGES: std::cell::Cell<Option<&'static [&'static dyn added::Page]>> =
+        const { std::cell::Cell::new(None) };
+}
+
+/// The pages crates registered, all places.
+fn pages() -> &'static [&'static dyn added::Page] {
+    #[cfg(test)]
+    if let Some(pages) = TEST_PAGES.get() {
+        return pages;
+    }
+    added::engine::all()
+}
+
+/// The sections of this page, by their index among the registered pages.
+fn sections() -> impl Iterator<Item = (usize, &'static dyn added::Page)> {
+    let pages = pages().iter().copied().enumerate();
+    pages.filter(|(_, page)| page.place() == added::Place::Extras)
+}
+
+fn label_text(label: Label) -> String {
+    match label {
+        Label::Key(key) => lang::get(key),
+        Label::Value(text) => text,
+    }
+}
+
+/// The page's group named `name`, made at the end if it has none.
+fn group_named<'a>(
+    groups: &'a mut Vec<Group<ExtraRow>>,
+    name: &'static str,
+) -> &'a mut Group<ExtraRow> {
+    let at = groups.iter().position(|group| group.name == name);
+    let at = at.unwrap_or_else(|| {
+        groups.push(Group {
+            name,
+            rows: Vec::new(),
+        });
+        groups.len() - 1
+    });
+    &mut groups[at]
+}
+
+/// The sections' rows, in the groups their titles and headings name.
+fn add_sections(groups: &mut Vec<Group<ExtraRow>>) {
+    for (page, section) in sections() {
+        let mut rows = Vec::new();
+        section.rows(&mut rows);
+        let mut name = section.title();
+        for (r, row) in rows.into_iter().enumerate() {
+            let id = ExtraRow::Added(page, r);
+            let row = match row {
+                added::Row::Heading(key) => {
+                    name = key;
+                    continue;
+                }
+                added::Row::Note(text) => Row::new(id, text, Value::Note).live(false),
+                added::Row::Toggle { label, on } => {
+                    Row::new(id, lang::get(label), Value::Switch(on))
+                }
+                added::Row::Cycle { label, value } => {
+                    Row::new(id, lang::get(label), Value::Choice(label_text(value)))
+                }
+                added::Row::Slider { label, value, text } => {
+                    let position = value.clamp(0.0, 1.0);
+                    let text = label_text(text);
+                    let value = Value::Slider {
+                        position,
+                        steps: None,
+                        text,
+                    };
+                    Row::new(id, lang::get(label), value)
+                }
+                added::Row::Button {
+                    label,
+                    active: true,
+                    ..
+                } => Row::new(id, lang::get(label), Value::Press),
+                added::Row::Key { label, key } => {
+                    let key = crate::keybinds::display_name(&key).plain();
+                    Row::new(id, lang::get(label), Value::Read(key))
+                }
+                // A row kind newer than this engine.
+                _ => continue,
+            };
+            let row = match section.tooltip(r) {
+                Some(about) => row.about(label_text(about)),
+                None => row,
+            };
+            group_named(groups, name).rows.push(row);
+        }
+    }
+}
+
+/// Row `r` of registered page `page` was acted on: the options screen saves when it closes.
+fn act(page: usize, r: usize, act: Act) -> Vec<Output> {
+    let Some(section) = pages().get(page) else {
+        return Vec::new();
+    };
+    section.act(r, act);
+    vec![Output::Event(Event::Changed)]
+}
+
+/// Whether row `r` of registered page `page` steps (a switch or a cycle).
+fn steps(page: usize, r: usize) -> bool {
+    let mut rows = Vec::new();
+    if let Some(section) = pages().get(page) {
+        section.rows(&mut rows);
+    }
+    matches!(
+        rows.get(r),
+        Some(added::Row::Toggle { .. } | added::Row::Cycle { .. })
+    )
 }
 
 fn item_row(item: Item, s: &Settings) -> Row<ExtraRow> {
@@ -85,9 +206,14 @@ impl Screen for ExtrasScreen {
     fn note_lines(&self) -> usize {
         NOTE_LINES
     }
-    /// The rows read the extras, the mods and whether cosmetics are offered.
+    /// The rows read the extras, the mods, whether cosmetics are offered and the sections' rows.
     fn stamp(&self, s: &Settings) -> u64 {
-        shell::stamp_of(&(&s.extras, &s.mods, horizon_cosmetics::enabled()))
+        let mut added = Vec::new();
+        for (_, section) in sections() {
+            section.rows(&mut added);
+        }
+        let cosmetics = horizon_cosmetics::enabled();
+        shell::stamp_of(&(&s.extras, &s.mods, cosmetics, added))
     }
     fn sheets(&self, s: &Settings) -> Vec<Sheet<(), ExtraRow>> {
         let mut groups = vec![Group {
@@ -107,6 +233,7 @@ impl Screen for ExtrasScreen {
                 }
             }
         }
+        add_sections(&mut groups);
         vec![Sheet::new((), lang::get(TITLE), lang::get(ABOUT), groups)]
     }
     fn press(&mut self, s: &mut Settings, row: ExtraRow, back: bool) -> Vec<Output> {
@@ -125,16 +252,29 @@ impl Screen for ExtrasScreen {
                 Output::Event(Event::NativeSettings(i)),
             ],
             ExtraRow::ZoomInstall => Vec::new(),
+            ExtraRow::Added(page, r) => {
+                act(page, r, if back { Act::PressBack } else { Act::Press })
+            }
+        }
+    }
+    fn slide(&mut self, _s: &mut Settings, row: ExtraRow, position: f32) {
+        if let ExtraRow::Added(page, r) = row {
+            act(page, r, Act::Slide(position));
         }
     }
     /// With the wheel extra on, the wheel over an item changes it, without a click; the mod's rows
     /// let the list scroll.
     fn wheel_step(&mut self, s: &mut Settings, row: ExtraRow, back: bool) -> Option<Vec<Output>> {
-        let ExtraRow::Item(item) = row else {
-            return None;
-        };
-        item.cycle(&mut s.extras, back);
-        Some(vec![Output::Event(Event::Changed)])
+        match row {
+            ExtraRow::Item(item) => {
+                item.cycle(&mut s.extras, back);
+                Some(vec![Output::Event(Event::Changed)])
+            }
+            ExtraRow::Added(page, r) if steps(page, r) => {
+                Some(act(page, r, if back { Act::PressBack } else { Act::Press }))
+            }
+            _ => None,
+        }
     }
 }
 
@@ -292,4 +432,146 @@ mod tests {
         shell.key(&mut s, K::ArrowDown, None, false, size);
         assert_eq!(shell.focused_row(), Some(first));
     }
+
+    /// A section with a switch in the page's Multiplayer group, then a heading of its own with a
+    /// number that steps either way, a note and a volume.
+    struct Section {
+        on: std::sync::Mutex<bool>,
+        step: std::sync::Mutex<i32>,
+        volume: std::sync::Mutex<f32>,
+    }
+    impl added::Page for Section {
+        fn id(&self) -> &'static str {
+            "test.section"
+        }
+        fn title(&self) -> &'static str {
+            "horizon.extras.header.multiplayer"
+        }
+        fn place(&self) -> added::Place {
+            added::Place::Extras
+        }
+        fn rows(&self, rows: &mut Vec<added::Row>) {
+            rows.push(added::Row::Toggle {
+                label: "test.section.switch",
+                on: *self.on.lock().unwrap(),
+            });
+            rows.push(added::Row::Heading("test.section.heading"));
+            rows.push(added::Row::Cycle {
+                label: "test.section.step",
+                value: Label::Value(self.step.lock().unwrap().to_string()),
+            });
+            rows.push(added::Row::Note("a note".into()));
+            rows.push(added::Row::Slider {
+                label: "test.section.volume",
+                value: *self.volume.lock().unwrap(),
+                text: Label::Value(String::new()),
+            });
+        }
+        fn act(&self, row: usize, act: Act) {
+            match (row, act) {
+                (0, Act::Press | Act::PressBack) => {
+                    let mut on = self.on.lock().unwrap();
+                    *on = !*on;
+                }
+                (2, Act::Press) => *self.step.lock().unwrap() += 1,
+                (2, Act::PressBack) => *self.step.lock().unwrap() -= 1,
+                (4, Act::Slide(v)) => *self.volume.lock().unwrap() = v,
+                _ => {}
+            }
+        }
+    }
+
+    /// A page for Horizon Settings: never on Extras.
+    struct Elsewhere;
+    impl added::Page for Elsewhere {
+        fn id(&self) -> &'static str {
+            "test.elsewhere"
+        }
+        fn title(&self) -> &'static str {
+            "test.elsewhere"
+        }
+        fn place(&self) -> added::Place {
+            added::Place::HorizonSettings
+        }
+        fn rows(&self, rows: &mut Vec<added::Row>) {
+            rows.push(added::Row::button("test.elsewhere.button"));
+        }
+        fn act(&self, _: usize, _: Act) {}
+    }
+
+    fn with_section() -> &'static Section {
+        let section: &'static Section = Box::leak(Box::new(Section {
+            on: false.into(),
+            step: 0.into(),
+            volume: 0.5.into(),
+        }));
+        let pages: &'static [&'static dyn added::Page] = Box::leak(Box::new([
+            &Elsewhere as &dyn added::Page,
+            section as &dyn added::Page,
+        ]));
+        TEST_PAGES.set(Some(pages));
+        section
+    }
+
+    /// The section's first row joins the page's own Multiplayer group, after its rows; its heading
+    /// starts a group after the page's; a page for elsewhere adds nothing.
+    #[test]
+    fn a_section_joins_the_group_its_title_names_and_heads_its_own() {
+        with_section();
+        let s = Settings::default();
+        let sheets = ExtrasScreen.sheets(&s);
+        let groups = &sheets[0].groups;
+        let ids = |name: &str| -> Vec<ExtraRow> {
+            let group = groups.iter().find(|g| g.name == name).unwrap();
+            group.rows.iter().map(|r| r.id).collect()
+        };
+        let multiplayer = ids("horizon.extras.header.multiplayer");
+        assert_eq!(multiplayer.last(), Some(&ExtraRow::Added(1, 0)));
+        assert_eq!(groups.last().unwrap().name, "test.section.heading");
+        let own = [
+            ExtraRow::Added(1, 2),
+            ExtraRow::Added(1, 3),
+            ExtraRow::Added(1, 4),
+        ];
+        assert_eq!(ids("test.section.heading"), own);
+        let all = rows_of(&s);
+        assert!(!all.iter().any(|r| matches!(r.id, ExtraRow::Added(0, _))));
+    }
+
+    /// A click flips the switch, a Shift click steps the number back, the wheel steps it, and the
+    /// note takes no click; the rows show what the section holds after each.
+    #[test]
+    fn a_sections_rows_act_on_it() {
+        let section = with_section();
+        let mut s = Settings::default();
+        let mut shell = Shell::<ExtrasScreen>::default();
+        let switch = ExtraRow::Added(1, 0);
+        let at = shell.point_at(&s, SIZE, switch);
+        assert!(
+            !shell
+                .click(&mut s, at, SIZE, false, false, false)
+                .is_empty()
+        );
+        assert!(*section.on.lock().unwrap());
+        let value = |s: &Settings, id| rows_of(s).into_iter().find(|r| r.id == id).unwrap().value;
+        assert_eq!(value(&s, switch), Value::Switch(true));
+        let step = ExtraRow::Added(1, 2);
+        let mut screen = ExtrasScreen;
+        screen.press(&mut s, step, true);
+        assert_eq!(value(&s, step), Value::Choice("-1".into()));
+        assert!(screen.wheel_step(&mut s, step, false).is_some());
+        assert_eq!(*section.step.lock().unwrap(), 0);
+        assert_eq!(
+            screen.wheel_step(&mut s, ExtraRow::Added(1, 3), false),
+            None
+        );
+        let note = shell.point_at(&s, SIZE, ExtraRow::Added(1, 3));
+        assert!(
+            shell
+                .click(&mut s, note, SIZE, false, false, false)
+                .is_empty()
+        );
+        screen.slide(&mut s, ExtraRow::Added(1, 4), 0.25);
+        assert_eq!(*section.volume.lock().unwrap(), 0.25);
+    }
 }

crates/horizon-client-render/src/fog.rs

@@ -231,8 +231,8 @@ pub struct FogInputs<'a> {
     /// `GameRenderer.nightVisionScale` while Night Vision is on without
     /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
     pub night_vision: f32,
-    /// The packs' Polytone `environment` fog settings.
-    pub environment: horizon_polytone::colors::Environment,
+    /// The packs' `environment` fog settings (Polytone's).
+    pub environment: crate::pack_palette::Environment,
 }
 
 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -581,7 +581,7 @@ mod tests {
         let tables = FogTables {
             water_fog_end: vec![1.0],
         };
-        let environment = horizon_polytone::colors::Environment {
+        let environment = crate::pack_palette::Environment {
             powder_snow_fog: Some(0xFF0000),
             blindness_fog_distance: 40.0,
             water_fog_brightening: 0.0,
@@ -613,7 +613,7 @@ mod tests {
     }
     fn inputs_with<'a>(
         input: &FogInputs<'a>,
-        environment: horizon_polytone::colors::Environment,
+        environment: crate::pack_palette::Environment,
     ) -> FogInputs<'a> {
         FogInputs {
             environment,

crates/horizon-client-render/src/gfx.rs

@@ -239,6 +239,7 @@ mod reuse;
 mod stars;
 mod surface_setup;
 use surface_setup::{AdapterChoice, AdapterFailure, open_adapter, pick_adapter, set_up_surface};
+mod off_page;
 pub mod submit;
 mod sunrise_fan;
 mod timing;
@@ -250,6 +251,7 @@ mod wgsl_prefix;
 mod world_post;
 pub mod world_primitives;
 mod world_warp;
+use off_page::move_off_page;
 
 /// A section's instance: its camera-relative origin and, in `w`, the step of
 /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
@@ -726,62 +728,6 @@ impl Part {
         }
     }
 }
-/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
-/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
-/// until the next range would pass `budget` bytes (it keeps what is left; the
-/// first range moves whatever its size, so none keeps the page closed), the
-/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
-/// section arena, GPU culling's records (`records`) along. False when the other
-/// pages have no room left.
-fn move_off_page<'a>(
-    arena: &mut arena::Arena,
-    encoder: &mut wgpu::CommandEncoder,
-    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
-    mut records: Option<&mut gpu_culling::Records>,
-    meshes: impl Iterator<Item = &'a mut SectionGpu>,
-    page: u32,
-    part: Part,
-    budget: &mut u64,
-) -> bool {
-    debug_assert!(
-        records.is_none() || matches!(part, Part::Section { .. }),
-        "records follow the section arena's ranges"
-    );
-    let mut moved = false;
-    for s in meshes {
-        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
-        // range of page 0); in the other arenas, one without translucent quads.
-        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
-            continue;
-        };
-        let bytes = vertices * arena.stride();
-        if moved && bytes > *budget {
-            break;
-        }
-        let Some(to) = arena.alloc_moved(vertices) else {
-            return false;
-        };
-        arena.copy(encoder, (page, start), to, vertices);
-        arena.release(page, start, vertices);
-        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
-            let key = match part {
-                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
-                _ => to.0,
-            };
-            flat.place(device, encoder, uploads, id, key, to.1, vertices);
-        }
-        part.set(s, to);
-        // Its solid quads start the range in either layout.
-        if let (Part::Section { .. }, Some(records), Some(id)) =
-            (part, records.as_deref_mut(), s.gpu_id)
-        {
-            records.relocate(id, to.0, u64::from(s.solid_base()));
-        }
-        *budget = budget.saturating_sub(bytes);
-        moved = true;
-    }
-    true
-}
 /// Starts moving a page of a large arena far larger than its ranges in use
 /// (`Arena::oversized`) into a new page of the size they get (`Arena::open_page`),
 /// for `Renderer::shrink_translucent`: the page closes and `move_off_page` empties
@@ -1001,8 +947,8 @@ pub struct Frame<'a> {
     pub outline_after_terrain: bool,
     /// `BlockOutlineRenderState.highContrast`: a thick black outline under a bright one.
     pub outline_high_contrast: bool,
-    /// The outline, hurt overlay and glint colours a crate above set (`horizon_hooks::look`).
-    pub look: horizon_hooks::look::Frame,
+    /// The PvP & HUD page's outline and hit colour (`pvp::Frame`; default: vanilla's).
+    pub pvp: crate::pvp::Frame,
     /// `lines` with a colour and pixel width (`gizmos::camera_relative`):
     /// the fishing line and debug gizmos, depth tested, then gizmos drawn
     /// over everything.
@@ -1329,7 +1275,7 @@ pub struct Renderer {
     celestial_buffer: wgpu::Buffer,
     end_sky: end_sky::EndSky,
     stars: stars::Stars,
-    /// OptiFine custom sky layers (`crate::custom_sky`), and the frame's from the game.
+    /// Custom sky layers (`crate::custom_sky`), and the frame's from the game.
     custom_sky: custom_sky::CustomSky,
     custom_sky_draws: Vec<crate::custom_sky::Draw>,
     /// The glowing entities' outline (`LevelRenderer.entityOutlineTarget`).
@@ -5517,11 +5463,11 @@ impl Renderer {
             ))
         });
     }
-    /// The pack's OptiFine custom sky layer textures (`crate::custom_sky::CustomSky::load`).
-    pub fn set_custom_sky(&mut self, pack: &crate::custom_sky::CustomSky) {
+    /// The pack's custom sky layer textures (`crate::custom_sky::load`).
+    pub fn set_custom_sky(&mut self, pack: &dyn crate::custom_sky::SkyLayers) {
         self.custom_sky.set_pack(&self.device, &self.queue, pack);
     }
-    /// The custom sky layers the next frame draws (`CustomSky::draws`): the game refills it each
+    /// The custom sky layers the next frame draws (`SkyLayers::draws`): the game refills it each
     /// frame, empty when the world's sky has none.
     pub fn custom_sky_draws(&mut self) -> &mut Vec<crate::custom_sky::Draw> {
         &mut self.custom_sky_draws
@@ -8506,9 +8452,9 @@ impl Renderer {
             colored_count: [
                 frame.colored_lights.len().min(crate::dynamic_light::MAX) as u32,
                 // PvP & HUD's hit colour: entity.wgsl's hurt texel, 0 for vanilla's.
-                frame.look.hurt_texel,
+                frame.pvp.hurt_texel,
                 // PvP & HUD's glint colour: entity.wgsl's `tinted_glint`, 0 for vanilla's.
-                frame.look.glint,
+                frame.pvp.glint,
                 0,
             ],
             emissive_layers: {
@@ -9495,7 +9441,7 @@ impl Renderer {
                 }
             };
             // A custom outline (PvP & HUD) takes the bright stroke's colour, scales both widths.
-            let (custom, scale) = frame.look.outline.map_or((None, 1.0), |o| (Some(o.0), o.1));
+            let (custom, scale) = frame.pvp.outline.map_or((None, 1.0), |(c, s)| (Some(c), s));
             if frame.outline_high_contrast {
                 stroke(0xff00_0000, 7.0 * scale, lines);
                 stroke(custom.unwrap_or(0xff57_ffe1), width * scale, lines);
@@ -10116,7 +10062,11 @@ impl Renderer {
         let pack_reads_world = pack_post || native_post;
         laps.lap("r_uploads");
         // Phase 2 of occlusion culling draws over the depth, and a shader pack or TAA reads it.
+        // Post effects (a resource pack's chains, `use_depth_buffer`) read the world's depth
+        // after the world pass, as `GameRenderer.render` hands them the main target's.
+        let post_reads_depth = !frame.title && !frame.post_effects.effects.is_empty();
         let keep_depth = pack_reads_world
+            || post_reads_depth
             || (taa && self.world_post.taa)
             || oit_on
             || native_render::render_needs().world_depth
@@ -13714,6 +13664,7 @@ mod tests {
             Some(Reported {
                 paper_white: 240,
                 peak: 998,
+                peak_guessed: true,
             })
         );
         assert_eq!(
@@ -13721,6 +13672,7 @@ mod tests {
             Some(Reported {
                 paper_white: 480,
                 peak: 480,
+                peak_guessed: true,
             })
         );
         // White above the calibrated peak (a Samsung QD-OLED's 380, the slider at 456).
@@ -13729,6 +13681,7 @@ mod tests {
             Some(Reported {
                 paper_white: 456,
                 peak: 456,
+                peak_guessed: true,
             })
         );
         assert_eq!(os_reported(&info(Some(1000.0), None)), None);
@@ -15419,11 +15372,9 @@ fn log_os_reported(reported: Option<crate::graphics::Reported>) {
         None => "Horizon renderer: the system doesn't report the display's luminance".into(),
     });
 }
-/// What the OS reports in absolute nits (Windows: DXGI's `MaxLuminance` and the SDR
-/// white level the brightness slider sets), which is HDR output's scale there: SDR
-/// white is Paper White, the display's peak is Peak Brightness. Both are kept within
-/// the settings' ranges. The OS's figures often come from the display's EDID and may
-/// run optimistic; the player's own value always wins.
+/// What the OS reports in absolute nits, HDR output's scale (Windows: DXGI's SDR white level,
+/// the brightness slider's, as Paper White, and its `MaxLuminance`, mostly the display's EDID
+/// guess, as Peak Brightness), kept within the settings' ranges. The player's values win.
 fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
     let luminance = info.luminance?;
     let usable = |n: f32| n.is_finite() && n > 0.0;
@@ -15435,6 +15386,7 @@ fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported>
         // Windows' SDR brightness slider can set white above the reported peak (480 against
         // a calibrated 380): the highlights then stay at white instead of dropping below it.
         peak: (peak.round() as u32).clamp(200, 10_000).max(paper_white),
+        peak_guessed: true,
     })
 }
 
@@ -15470,6 +15422,7 @@ fn reported(l: horizon_hdr::wayland::Luminances) -> crate::graphics::Reported {
     crate::graphics::Reported {
         paper_white: 203,
         peak: peak.clamp(200, 10_000),
+        peak_guessed: false,
     }
 }
 
@@ -15718,11 +15671,11 @@ mod shadow_caster_tests {
     #[test]
     fn the_shadow_pass_draws_terrain_outside_the_pack_s_planes() {
         let kept = |near: Option<f32>, far: Option<f32>, y: f64, min: [f32; 3], depth: bool| {
-            let shadow = horizon_render_pipeline::Shadow {
+            let shadow = horizon_shaders::Shadow {
                 distance: 128.0,
                 near,
                 far,
-                ..horizon_render_pipeline::Shadow::default()
+                ..horizon_shaders::Shadow::default()
             };
             let camera = DVec3::new(13.5, y + 1.62, -13.5);
             let view = pack_post::ShadowView {

crates/horizon-client-render/src/gfx/capture.rs

@@ -524,7 +524,7 @@ impl Scene {
             outline: Vec::new(),
             outline_after_terrain: false,
             outline_high_contrast: false,
-            look: Default::default(),
+            pvp: Default::default(),
             debug_lines: &[],
             debug_lines_on_top: &[],
             debug_crosshair: &[],

crates/horizon-client-render/src/gfx/custom_sky.rs

@@ -1,12 +1,11 @@
-//! OptiFine custom sky layers on the GPU: one texture per layer, kept with the renderer (its pack),
+//! Custom sky layers (`crate::custom_sky`) on the GPU: one texture per layer, kept with the renderer (its pack),
 //! a static skybox mesh of the 3x2 grid's six faces, and one pipeline per blend mode. A frame
 //! uploads one small uniform per drawn layer ([`crate::custom_sky::Draw`]) and draws 36 vertices
 //! each, after the vanilla sky's disc and sunrise and before the sun, moon and stars.
 use glam::Mat4;
-use horizon_optifine::sky::{Blend, Face};
 use wgpu::util::DeviceExt;
 
-use crate::custom_sky::{CustomSky as Pack, Draw};
+use crate::custom_sky::{Blend, Draw, SkyLayers};
 
 /// The blend modes in the shader's `mode` order (custom_sky.wgsl).
 const MODES: [Blend; 9] = [
@@ -85,6 +84,76 @@ fn blend(mode: Blend) -> wgpu::BlendComponent {
     }
 }
 
+/// A face of the skybox, as the 3x2 grid of its texture holds them: `Bottom`, `Top`, `South` in
+/// the top row, `West`, `North`, `East` below.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Face {
+    Bottom,
+    Top,
+    South,
+    West,
+    North,
+    East,
+}
+
+impl Face {
+    const ALL: [Self; 6] = [
+        Self::Bottom,
+        Self::Top,
+        Self::South,
+        Self::West,
+        Self::North,
+        Self::East,
+    ];
+
+    /// The face's cell of the texture, `[u0, v0, u1, v1]` in 0..1.
+    fn cell(self) -> [f32; 4] {
+        let (col, row) = match self {
+            Self::Bottom => (0, 0),
+            Self::Top => (1, 0),
+            Self::South => (2, 0),
+            Self::West => (0, 1),
+            Self::North => (1, 1),
+            Self::East => (2, 1),
+        };
+        let (u, v) = (col as f32 / 3.0, row as f32 / 2.0);
+        [u, v, u + 1.0 / 3.0, v + 0.5]
+    }
+
+    /// The face's corners (on the unit cube around the camera; x east, y up, z south) in the
+    /// order of its cell's `(u0, v0)`, `(u1, v0)`, `(u1, v1)`, `(u0, v1)`. The side faces are
+    /// seen from inside with up at the top of their cell; the top face has north at the bottom of
+    /// its cell, the bottom face north at the top (the template's `N` marks).
+    fn corners(self) -> [[f32; 3]; 4] {
+        match self {
+            // Seen looking north: west on the left.
+            Self::North => [
+                [-1., 1., -1.],
+                [1., 1., -1.],
+                [1., -1., -1.],
+                [-1., -1., -1.],
+            ],
+            Self::South => [[1., 1., 1.], [-1., 1., 1.], [-1., -1., 1.], [1., -1., 1.]],
+            Self::East => [[1., 1., -1.], [1., 1., 1.], [1., -1., 1.], [1., -1., -1.]],
+            Self::West => [
+                [-1., 1., 1.],
+                [-1., 1., -1.],
+                [-1., -1., -1.],
+                [-1., -1., 1.],
+            ],
+            // Looking up with north toward the cell's bottom edge: east on the right.
+            Self::Top => [[-1., 1., 1.], [1., 1., 1.], [1., 1., -1.], [-1., 1., -1.]],
+            // Looking down with north toward the cell's top edge: east on the right.
+            Self::Bottom => [
+                [-1., -1., -1.],
+                [1., -1., -1.],
+                [1., -1., 1.],
+                [-1., -1., 1.],
+            ],
+        }
+    }
+}
+
 /// The skybox's 36 vertices: two triangles per face, each corner with its cell's UV.
 fn mesh() -> Vec<Vertex> {
     let mut out = Vec::with_capacity(36);
@@ -256,10 +325,15 @@ impl CustomSky {
     }
 
     /// The pack's layer textures, replacing any before.
-    pub(super) fn set_pack(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, pack: &Pack) {
+    pub(super) fn set_pack(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        pack: &dyn SkyLayers,
+    ) {
         let limit = device.limits().max_texture_dimension_2d;
         self.groups = pack
-            .images
+            .images()
             .iter()
             .map(|image| {
                 // Too large for this GPU: a 1x1 transparent texel, so the layer draws nothing.
@@ -413,6 +487,38 @@ impl CustomSky {
 mod tests {
     use super::*;
 
+    #[test]
+    fn the_grid_holds_each_face_once_and_faces_point_out() {
+        let mut cells: Vec<_> = Face::ALL
+            .iter()
+            .map(|f| f.cell().map(|x| (x * 6.0) as i32))
+            .collect();
+        cells.dedup();
+        assert_eq!(cells.len(), 6);
+        assert_eq!(Face::East.cell(), [2.0 / 3.0, 0.5, 1.0, 1.0]);
+        for face in Face::ALL {
+            let c = face.corners();
+            let sub = |a: [f32; 3], b: [f32; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+            let (a, b) = (sub(c[1], c[0]), sub(c[3], c[0]));
+            let n = [
+                a[1] * b[2] - a[2] * b[1],
+                a[2] * b[0] - a[0] * b[2],
+                a[0] * b[1] - a[1] * b[0],
+            ];
+            let centre: [f32; 3] =
+                std::array::from_fn(|i| c.iter().map(|p| p[i]).sum::<f32>() / 4.0);
+            // Seen from inside, u runs right and v down, so u x v points away from the camera.
+            let dot: f32 = (0..3).map(|i| n[i] * centre[i]).sum();
+            assert!(dot > 0.0, "{face:?} is mirrored");
+        }
+        // The top cell's bottom edge (v1) is north: its corners 2 and 3 have z = -1.
+        assert_eq!(Face::Top.corners()[2][2], -1.0);
+        assert_eq!(Face::Top.corners()[3][2], -1.0);
+        // The bottom cell's top edge (v0) is north.
+        assert_eq!(Face::Bottom.corners()[0][2], -1.0);
+        assert_eq!(Face::Bottom.corners()[1][2], -1.0);
+    }
+
     /// What a blend leaves a sky texel of `dst` with when the shader outputs `src`
     /// (custom_sky.wgsl) for a layer texel `t` at brightness `b`, per channel.
     fn mix(mode: Blend, dst: f32, t: f32, a: f32, b: f32) -> f32 {

crates/horizon-client-render/src/gfx/custom_sky.wgsl

@@ -6,7 +6,7 @@ struct Layer {
     // Projection * view (camera-relative) * the layer's rotation.
     clip_from_sky: mat4x4<f32>,
     brightness: f32,
-    // horizon_optifine::sky::Blend, in gfx/custom_sky.rs's MODES order.
+    // crate::custom_sky::Blend, in gfx/custom_sky.rs's MODES order.
     mode: u32,
     pad: vec2<u32>,
     hdr_settings: vec4<f32>,

crates/horizon-client-render/src/gfx/native_post.rs

@@ -338,7 +338,7 @@ pub struct NativeFrame {
     reflection_sampler: wgpu::Sampler,
     /// The shadow map the stages read, and the camera that draws it when the pack asks for one.
     pub shadow_map: super::native_shadow::ShadowMap,
-    shadow_camera: Option<horizon_render_pipeline::Shadow>,
+    shadow_camera: Option<horizon_shaders::Shadow>,
     /// Whether the pack's material reads `reflection` (`NativePack::new`): else no mirror
     /// is drawn and `has_reflection` stays 0.
     pub reflects: bool,
@@ -1497,7 +1497,7 @@ pub fn frame_inputs(
     size: [u32; 2],
     seconds: f32,
     index: u32,
-    shadow: Option<&horizon_render_pipeline::Shadow>,
+    shadow: Option<&horizon_shaders::Shadow>,
 ) -> FrameInputs {
     let aspect = size[0] as f32 / size[1].max(1) as f32;
     let view = crate::camera::view_matrix(frame.yaw, frame.pitch);

crates/horizon-client-render/src/gfx/native_shadow.rs

@@ -6,8 +6,8 @@
 //! draw lists (`ShadowView`) serve both; the map's texels are distorted toward the camera as the
 //! prelude's `shadow_position` undoes.
 
-use horizon_render_pipeline::Shadow;
 use horizon_shader_api::{Api, Frame as FrameInputs, manifest::Shadow as Settings, stages::GROUP};
+use horizon_shaders::Shadow;
 
 use super::native_material::TerrainShape;
 use super::wgsl_prefix::{TERRAIN, prefixed, section};

crates/horizon-client-render/src/gfx/off_page.rs

@@ -0,0 +1,59 @@
+//! `move_off_page`, moved out of `gfx.rs` unchanged.
+use super::*;
+
+/// `Renderer::compact_arena`'s and `shrink_translucent`'s moves: what the meshes
+/// hold on `page` of `arena` (`part`) goes to its other pages in video memory,
+/// until the next range would pass `budget` bytes (it keeps what is left; the
+/// first range moves whatever its size, so none keeps the page closed), the
+/// copies into `encoder`, the ranges' flat draw ids (`flat`) and, in the
+/// section arena, GPU culling's records (`records`) along. False when the other
+/// pages have no room left.
+pub(super) fn move_off_page<'a>(
+    arena: &mut arena::Arena,
+    encoder: &mut wgpu::CommandEncoder,
+    mut flat: Option<(&mut flat::Flat, &wgpu::Device, &mut upload::Uploads)>,
+    mut records: Option<&mut gpu_culling::Records>,
+    meshes: impl Iterator<Item = &'a mut SectionGpu>,
+    page: u32,
+    part: Part,
+    budget: &mut u64,
+) -> bool {
+    debug_assert!(
+        records.is_none() || matches!(part, Part::Section { .. }),
+        "records follow the section arena's ranges"
+    );
+    let mut moved = false;
+    for s in meshes {
+        // Nothing of a mesh here: split, one without solid quads (its (0, 0) is no
+        // range of page 0); in the other arenas, one without translucent quads.
+        let Some((_, start, vertices)) = part.of(s).filter(|r| r.0 == page) else {
+            continue;
+        };
+        let bytes = vertices * arena.stride();
+        if moved && bytes > *budget {
+            break;
+        }
+        let Some(to) = arena.alloc_moved(vertices) else {
+            return false;
+        };
+        arena.copy(encoder, (page, start), to, vertices);
+        arena.release(page, start, vertices);
+        if let (Some((flat, device, uploads)), Some(id)) = (&mut flat, s.flat_id) {
+            let key = match part {
+                Part::Translucent => to.0 + flat::TRANSLUCENT_KEYS,
+                _ => to.0,
+            };
+            flat.place(device, encoder, uploads, id, key, to.1, vertices);
+        }
+        part.set(s, to);
+        // Its solid quads start the range in either layout.
+        if let (Part::Section { .. }, Some(records), Some(id)) =
+            (part, records.as_deref_mut(), s.gpu_id)
+        {
+            records.relocate(id, to.0, u64::from(s.solid_base()));
+        }
+        *budget = budget.saturating_sub(bytes);
+        moved = true;
+    }
+    true
+}

crates/horizon-client-render/src/gfx/output.rs

@@ -300,6 +300,7 @@ pub(crate) mod tests {
                 luminance: Some(Reported {
                     paper_white: 400,
                     peak: 1000,
+                    peak_guessed: false,
                 }),
                 hdr: system,
             },
@@ -650,6 +651,7 @@ pub(crate) mod tests {
         window_reading.luminance = Some(Reported {
             paper_white: 300,
             peak: 800,
+            peak_guessed: false,
         });
         assert_eq!(window_output(window_reading).nits[..2], [300.0, 800.0]);
         assert_eq!(

crates/horizon-client-render/src/gfx/output_apply.rs

@@ -549,6 +549,7 @@ mod tests {
         reading.luminance = Some(Reported {
             paper_white: 250,
             peak: 600,
+            peak_guessed: false,
         });
         // 150 nits under the reported paper white of 250: 0.6 of it.
         settings.hdr_ui_nits = 150;
@@ -584,6 +585,7 @@ mod tests {
             reading.luminance = Some(Reported {
                 paper_white,
                 peak: 1000,
+                peak_guessed: false,
             });
             let next = candidate(&settings, caps, reading, &published);
             let again = commit(&mut swapchain, &published, next, caps, &mut rejected);
@@ -729,6 +731,7 @@ mod tests {
                 luminance: (hdr == Some(true)).then_some(Reported {
                     paper_white: 300,
                     peak: 800,
+                    peak_guessed: false,
                 }),
                 hdr,
             };

crates/horizon-client-render/src/gfx/pack_images.rs

@@ -4,8 +4,7 @@
 
 use std::collections::BTreeMap;
 
-use horizon_render_pipeline::{Format, Kind};
-use horizon_shaders::{BufferObject, CustomImage};
+use horizon_shaders::{BufferObject, CustomImage, Format, Kind};
 
 pub(super) struct PackImage {
     pub(super) def: CustomImage,

crates/horizon-client-render/src/gfx/pack_post.rs

@@ -18,8 +18,7 @@
 use std::collections::HashMap;
 
 use glam::{DMat4, DVec3};
-use horizon_render_pipeline::{BUFFERS, Format, Kind, SHADOW_COLORS};
-use horizon_shaders::{Group, Post};
+use horizon_shaders::{BUFFERS, Format, Group, Kind, Post, SHADOW_COLORS};
 use smallvec::SmallVec;
 
 use super::pack_draw::DrawUniforms;
@@ -893,7 +892,7 @@ fn depth_linear(interface: &horizon_shaders::Interface, linear: u8) -> [f32; 4]
 }
 
 fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
-    let shadow_color = horizon_render_pipeline::shadow_color(name);
+    let shadow_color = horizon_shaders::shadow_color(name);
     let shadow_depth = match name {
         "shadowtex0" | "watershadow" | "shadowtex0HW" => Some(0),
         "shadowtex1" | "shadowtex1HW" => Some(1),
@@ -912,7 +911,7 @@ fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool)
             };
         }
     }
-    if shadow_space && horizon_render_pipeline::buffer_index(name).is_some() {
+    if shadow_space && horizon_shaders::buffer_index(name).is_some() {
         // colortex buffers are not this pass's.
         return Source::Dummy;
     }
@@ -926,7 +925,7 @@ fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool)
         "normals" => Source::Normals,
         "specular" => Source::Specular,
         horizon_shaders::WATER_MASK => Source::WaterMask,
-        n => horizon_render_pipeline::buffer_index(n).map_or(Source::Dummy, Source::Color),
+        n => horizon_shaders::buffer_index(n).map_or(Source::Dummy, Source::Color),
     }
 }
 
@@ -1583,7 +1582,7 @@ fn bindings(
             !unbound
                 && (t.stage != pack_textures::stage(group)
                     || released.0 != t.stage
-                    || horizon_render_pipeline::buffer_index(&t.name)
+                    || horizon_shaders::buffer_index(&t.name)
                         .is_none_or(|b| released.1 & 1 << b == 0))
         });
         let image = pack
@@ -2433,7 +2432,7 @@ impl PackPost {
         let shadow_config = post.config.shadow.clone();
         let noise_size = post.config.noise_resolution.unwrap_or(256);
         let half_lives = post.config.half_lives;
-        for (name, ticks) in horizon_render_pipeline::HALF_LIVES.iter().zip(half_lives) {
+        for (name, ticks) in horizon_shaders::HALF_LIVES.iter().zip(half_lives) {
             if let Some(t) = ticks {
                 notes.push(format!("`{name}` is {t} ticks"));
             }

crates/horizon-client-render/src/gfx/pack_post/depth_test.rs

@@ -602,7 +602,7 @@ pub(super) fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
         outline: Vec::new(),
         outline_after_terrain: false,
         outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],

crates/horizon-client-render/src/gfx/pack_post/destination_tests.rs

@@ -440,7 +440,7 @@ fn fixture_frame(hud: &HudBatch) -> Frame<'_> {
         outline: Vec::new(),
         outline_after_terrain: false,
         outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],

crates/horizon-client-render/src/gfx/pack_post/packed.rs

@@ -10,7 +10,7 @@
 //! a fit to one driver's values, not a rule Iris states. `RGBA4` and `RGBA2` read back the `RGBA8`
 //! bytes in the same probe, as Horizon's 8-bit buffers already do.
 
-use horizon_render_pipeline::{Format, Kind};
+use horizon_shaders::{Format, Kind};
 use naga::{BinaryOperator, Expression, Literal, MathFunction, Statement, VectorSize};
 
 /// The bits each channel keeps in a buffer of format `f`, for the formats that keep fewer than

crates/horizon-client-render/src/gfx/pack_post/world_target_tests.rs

@@ -409,7 +409,7 @@ fn frame(hud: &HudBatch) -> Frame<'_> {
         outline: Vec::new(),
         outline_after_terrain: false,
         outline_high_contrast: false,
-        look: Default::default(),
+        pvp: Default::default(),
         debug_lines: &[],
         debug_lines_on_top: &[],
         debug_crosshair: &[],

crates/horizon-client-render/src/gfx/pack_shadow.rs

@@ -3,7 +3,7 @@
 //! with two sides that `shadowcomp` programs flip as composite programs flip colortex (6.1.6).
 //! Square, `shadowMapResolution` pixels.
 
-use horizon_render_pipeline::SHADOW_COLORS;
+use horizon_shaders::SHADOW_COLORS;
 
 type Ops<T> = wgpu::Operations<T>;
 type Color = wgpu::Color;
@@ -97,11 +97,7 @@ pub(super) fn stand_in(device: &wgpu::Device) -> wgpu::TextureView {
 }
 
 impl ShadowTargets {
-    pub fn reset_history(
-        &mut self,
-        device: &wgpu::Device,
-        shadow: &horizon_render_pipeline::Shadow,
-    ) {
+    pub fn reset_history(&mut self, device: &wgpu::Device, shadow: &horizon_shaders::Shadow) {
         let mut colors = 0;
         let mut doubled = 0;
         let formats = std::array::from_fn(|n| match &self.color[n] {
@@ -129,7 +125,7 @@ impl ShadowTargets {
     /// resolution is kept within the device's limit.
     pub fn new(
         device: &wgpu::Device,
-        shadow: &horizon_render_pipeline::Shadow,
+        shadow: &horizon_shaders::Shadow,
         formats: [wgpu::TextureFormat; SHADOW_COLORS],
         colors: u16,
         doubled: u16,

crates/horizon-client-render/src/gfx/pack_textures.rs

@@ -1,8 +1,7 @@
 //! A shader pack's custom textures (`texture.<stage>.<name>`, `texture.noise`) on the GPU, and
 //! which of them a program's sampler reads.
 
-use horizon_render_pipeline::Kind;
-use horizon_shaders::{CustomTexture, Group, Texels, Texture, TextureDim, TextureSource};
+use horizon_shaders::{CustomTexture, Group, Kind, Texels, Texture, TextureDim, TextureSource};
 
 /// What a custom texture is once uploaded: an image of ours, or one the game already has.
 pub(super) enum Image {
@@ -119,12 +118,12 @@ pub(super) fn find(textures: &[PackTexture], group: Group, ty: &str, name: &str)
     } else {
         wgpu::TextureViewDimension::D2
     };
-    let buffer = horizon_render_pipeline::buffer_index(name);
+    let buffer = horizon_shaders::buffer_index(name);
     let staged = textures.iter().position(|t| {
         t.stage == stage(group)
             && t.dimension == dimension
             && (t.name == name
-                || buffer.is_some() && horizon_render_pipeline::buffer_index(&t.name) == buffer)
+                || buffer.is_some() && horizon_shaders::buffer_index(&t.name) == buffer)
     });
     staged.or_else(|| {
         textures.iter().position(|t| {

crates/horizon-client-render/src/gfx/pack_uniforms.rs

@@ -28,7 +28,7 @@
 //! [-w, w], and the depth buffers packs read hold GL window depth.
 
 use glam::{DMat4, DVec3, Mat4, Vec3, Vec4};
-use horizon_render_pipeline::Shadow;
+use horizon_shaders::Shadow;
 
 use super::Frame;
 
@@ -440,7 +440,7 @@ pub struct FrameUniforms {
     center_depth: Option<f32>,
     /// The pack's shadow settings (7.1).
     pub shadow: Shadow,
-    /// The pack's smoothing half-lives in ticks (`horizon_render_pipeline::HALF_LIVES`).
+    /// The pack's smoothing half-lives in ticks (`horizon_shaders::HALF_LIVES`).
     pub half_lives: [Option<f32>; 4],
 }
 
@@ -2664,7 +2664,7 @@ pub(super) mod initial_history_tests {
             outline: Vec::new(),
             outline_after_terrain: false,
             outline_high_contrast: false,
-            look: Default::default(),
+            pvp: Default::default(),
             debug_lines: &[],
             debug_lines_on_top: &[],
             debug_crosshair: &[],

crates/horizon-client-render/src/gfx/ray_query.rs

@@ -0,0 +1,79 @@
+//! Hardware ray queries, only on request (#13780, after the #1180 spike): `HORIZON_RAY_TRACING=1`
+//! at startup asks the device for wgpu's `EXPERIMENTAL_RAY_QUERY` when the GPU has it. Nothing
+//! draws with it yet. Without the variable, and in a build without `horizon-extras` (a Horizon
+//! extra, docs/layers.md), the device is opened exactly as before.
+
+/// The ray query feature.
+const RAY_QUERY: wgpu::Features = wgpu::Features::EXPERIMENTAL_RAY_QUERY;
+
+/// Whether the player asked for ray tracing (the device needs the feature from its creation).
+fn requested() -> bool {
+    asked(std::env::var("HORIZON_RAY_TRACING").ok().as_deref())
+}
+
+/// Whether `HORIZON_RAY_TRACING` set to `var` asks for ray tracing: only in a `horizon-extras`
+/// build.
+fn asked(var: Option<&str>) -> bool {
+    cfg!(feature = "horizon-extras") && var == Some("1")
+}
+
+/// The features to request on `adapter`: ray queries, when asked for and offered.
+pub(super) fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
+    let features = pick(requested(), adapter.features());
+    if requested() {
+        let info = adapter.get_info();
+        if features.is_empty() {
+            log::warn!(
+                "Horizon renderer: ray tracing asked for, but {} on {:?} has no hardware ray \
+                 queries; it stays off",
+                info.name,
+                info.backend
+            );
+        } else {
+            log::info!(
+                "Horizon renderer: ray queries on ({} on {:?})",
+                info.name,
+                info.backend
+            );
+        }
+    }
+    features
+}
+
+fn pick(requested: bool, offered: wgpu::Features) -> wgpu::Features {
+    if requested {
+        offered & RAY_QUERY
+    } else {
+        wgpu::Features::empty()
+    }
+}
+
+/// The device's opt-in to `features`' experimental ones.
+pub(super) fn experimental(features: wgpu::Features) -> wgpu::ExperimentalFeatures {
+    if features.contains(RAY_QUERY) {
+        horizon_hdr::experimental_features()
+    } else {
+        wgpu::ExperimentalFeatures::disabled()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn only_an_extras_build_asks_for_ray_tracing() {
+        assert_eq!(asked(Some("1")), cfg!(feature = "horizon-extras"));
+        assert!(!asked(None));
+        assert!(!asked(Some("0")));
+    }
+
+    #[test]
+    fn ray_queries_only_when_asked_and_offered() {
+        let all = wgpu::Features::all();
+        assert_eq!(pick(true, all), RAY_QUERY);
+        assert!(pick(false, all).is_empty());
+        assert!(pick(true, all - RAY_QUERY).is_empty());
+        assert!(!experimental(wgpu::Features::empty()).is_enabled());
+    }
+}

crates/horizon-client-render/src/gfx/surface_setup.rs

@@ -5,6 +5,9 @@ use super::{
     Renderer, check_layers, cull, describe_adapter, is_software, oit, startup_step, surface_format,
     timing,
 };
+// Ray tracing on request, which the device needs from its creation (gfx.rs may not grow).
+#[path = "ray_query.rs"]
+mod ray_query;
 use std::sync::Arc;
 use winit::window::Window;
 
@@ -134,6 +137,7 @@ pub(super) async fn open_adapter(
     let features = timing::GpuTimer::features(adapter)
         | cull::Cull::features(adapter)
         | oit::features(adapter)
+        | ray_query::features(adapter)
         | (adapter.features()
             & (wgpu::Features::INDIRECT_FIRST_INSTANCE
                 | wgpu::Features::MULTI_DRAW_INDIRECT_COUNT
@@ -166,6 +170,7 @@ pub(super) async fn open_adapter(
         // with the larger blocks a few small buffers kept whole blocks the arena's pages had
         // left, and over half the video memory reserved was unused (1,344 MiB for 500).
         memory_hints: wgpu::MemoryHints::MemoryUsage,
+        experimental_features: ray_query::experimental(features),
         ..Default::default()
     };
     #[cfg(not(target_os = "macos"))]

crates/horizon-client-render/src/graphics.rs

@@ -30,6 +30,22 @@ fn marker_driver(text: &str) -> &str {
 pub struct Reported {
     pub paper_white: u32,
     pub peak: u32,
+    /// The peak is the display's own claim (DXGI's `MaxLuminance`, mostly its EDID figure),
+    /// which often runs high: Auto still uses it, but the HDR page asks to calibrate.
+    pub peak_guessed: bool,
+}
+
+/// Whether HDR is set up for the display, and whether the player kept the system's setup.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HdrSetup {
+    /// The system says nothing: the player calibrates.
+    Unknown,
+    /// The system says, but only guesses the peak: the player calibrates.
+    Guessed,
+    /// Peak Brightness and Paper White follow the system.
+    Automatic,
+    /// The system said, and the player changed them anyway.
+    Changed,
 }
 
 /// The top of Peak Brightness's scale: `peak_nits_at(PEAK_STEPS)` is PQ's 10 000 nits.
@@ -1207,6 +1223,15 @@ impl Graphics {
             n => n,
         }
     }
+    /// How HDR is set up for the display the system `reported`.
+    pub fn hdr_setup(&self, reported: Option<Reported>) -> HdrSetup {
+        match reported {
+            None => HdrSetup::Unknown,
+            Some(_) if self.hdr_peak != 0 || self.hdr_paper_white != 0 => HdrSetup::Changed,
+            Some(r) if r.peak_guessed => HdrSetup::Guessed,
+            Some(_) => HdrSetup::Automatic,
+        }
+    }
     /// The black level, in nits. Not the system's: files from before saved 0 for that
     /// (Auto), and a reported black would lift every display's shadows by default.
     pub fn black_level_nits(&self) -> f32 {
@@ -1320,6 +1345,7 @@ mod tests {
         let reported = Some(Reported {
             paper_white: 300,
             peak: 1000,
+            peak_guessed: false,
         });
         assert_eq!(g.ui_nits(reported), 300);
         g.hdr_paper_white = 120;
@@ -1328,6 +1354,33 @@ mod tests {
         assert_eq!((g.ui_nits(None), g.ui_nits(reported)), (400, 400));
     }
 
+    #[test]
+    fn hdr_setup_asks_to_calibrate_where_the_peak_is_guessed() {
+        let wayland = Reported {
+            paper_white: 203,
+            peak: 1015,
+            peak_guessed: false,
+        };
+        let windows = Reported {
+            paper_white: 400,
+            peak: 1000,
+            peak_guessed: true,
+        };
+        let mut g = Graphics::default();
+        assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
+        assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Automatic);
+        assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Guessed);
+        // Auto still takes the guess, over the 1000-nit default.
+        assert_eq!(g.peak_nits(Some(windows)), 1000);
+        assert_eq!(g.paper_white_nits(Some(windows)), 400);
+        for (peak, paper_white) in [(800, 0), (0, 240)] {
+            (g.hdr_peak, g.hdr_paper_white) = (peak, paper_white);
+            assert_eq!(g.hdr_setup(Some(windows)), HdrSetup::Changed);
+            assert_eq!(g.hdr_setup(Some(wayland)), HdrSetup::Changed);
+            assert_eq!(g.hdr_setup(None), HdrSetup::Unknown);
+        }
+    }
+
     #[test]
     fn hdr_modes_keep_boolean_files_and_round_trip_auto() {
         assert_eq!(Graphics::parse("").hdr, HdrMode::Off);

crates/horizon-client-render/src/graphics_ui.rs

@@ -8,7 +8,8 @@ use crate::{
     gfx::EffectiveOutput,
     graphics::{
         EntityCullingMode, FarDetail, FrameGeneration, GpuCullingMode, GraphicsApi, HdrMode,
-        LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode, Preset, Upscaling,
+        HdrSetup as Setup, LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode,
+        Preset, Upscaling,
     },
     graphics_style::Cost,
     lang,
@@ -675,28 +676,9 @@ const LOD_STEPS: [u32; 24] = [
     crate::lod::MAX_CHUNKS,
 ];
 
-/// Whether the system set HDR up for the display, and whether the player kept it.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Setup {
-    /// The system says nothing: the player calibrates.
-    Unknown,
-    /// Peak Brightness and Paper White follow the system.
-    Automatic,
-    /// The system said, and the player changed them anyway.
-    Changed,
-}
 /// `out`: the output of the renderer the settings are shown for, with what its display reports.
 fn setup(s: &Settings, out: &EffectiveOutput) -> Setup {
-    setup_of(&s.horizon, out.reported.is_some())
-}
-fn setup_of(g: &crate::graphics::Graphics, reported: bool) -> Setup {
-    if !reported {
-        Setup::Unknown
-    } else if g.hdr_peak == 0 && g.hdr_paper_white == 0 {
-        Setup::Automatic
-    } else {
-        Setup::Changed
-    }
+    s.horizon.hdr_setup(out.reported)
 }
 /// What the HDR page says while HDR output is held back on this window's graphics driver
 /// (`EffectiveOutput::held`): picking a mode tries again (`H::cycle`).
@@ -714,13 +696,19 @@ fn description(
         (Item::Horizon(H::HdrCalibrate), Setup::Unknown) => {
             "Your display didn't say how bright it gets: calibrate to set it up."
         }
+        (Item::Horizon(H::HdrCalibrate), Setup::Guessed) => {
+            "Your display's reported peak is often too high: calibrate to set it up."
+        }
         (Item::Horizon(H::HdrCalibrate), Setup::Automatic) => {
             "Already set up for your display. Only calibrate if HDR looks wrong."
         }
         (Item::Horizon(H::HdrCalibrate), Setup::Changed) => {
             "Puts Peak Brightness and Paper White back to your display's setup."
         }
-        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
+        // A guessed peak's Auto is what calibration replaced; paper white is the player's own.
+        (Item::Horizon(h @ (H::HdrPeak | H::HdrPaperWhite)), Setup::Automatic | Setup::Changed)
+            if h == H::HdrPaperWhite || out.reported.is_some_and(|r| !r.peak_guessed) =>
+        {
             "Set up for your display. Leave on Auto unless it looks wrong."
         }
         (Item::Horizon(H::GpuCulling), _) if s.horizon.gpu_culling == GpuCullingMode::Auto => {
@@ -944,7 +932,7 @@ impl H {
             H::FrameGeneration => labelled("Frame Generation", g.frame_generation.label()),
             H::Hdr => labelled("HDR", g.hdr.label()),
             H::HdrCalibrate => Text::literal(lang::get(match setup(s, out) {
-                Setup::Unknown => "Calibrate...",
+                Setup::Unknown | Setup::Guessed => "Calibrate...",
                 Setup::Automatic => "Calibrate Anyway...",
                 Setup::Changed => "Use Automatic Setup",
             })),

crates/horizon-client-render/src/graphics_ui_hdr_tests.rs

@@ -120,14 +120,86 @@ fn auto_levels_and_setup_read_their_own_renderers_report() {
     assert_eq!(label(H::HdrCalibrate, &silent), "Calibrate...");
 }
 
+/// The setup rows' label and description for each kind of report: none, a compositor's
+/// (Wayland), and Windows', whose peak is the display's own guess.
 #[test]
-fn hdr_setup_follows_what_the_system_reported() {
-    let mut g = crate::graphics::Graphics::default();
-    assert_eq!(setup_of(&g, false), Setup::Unknown);
-    assert_eq!(setup_of(&g, true), Setup::Automatic);
-    g.hdr_paper_white = 80;
-    assert_eq!(setup_of(&g, true), Setup::Changed);
-    assert_eq!(setup_of(&g, false), Setup::Unknown);
+fn the_setup_rows_ask_to_calibrate_unless_the_system_set_the_display_up() {
+    let trusted = offering(true, Some(true));
+    let mut guessed = trusted;
+    guessed.reported = guessed.reported.map(|r| crate::graphics::Reported {
+        peak_guessed: true,
+        ..r
+    });
+    let rows = |s: &Settings, out: &EffectiveOutput| {
+        [H::HdrCalibrate, H::HdrPeak, H::HdrPaperWhite].map(|h| {
+            let item = Item::Horizon(h);
+            (item.label(s, out).plain(), description(item, s, out, "-"))
+        })
+    };
+    let calibrate = "Calibrate...";
+    let set_up = "Set up for your display. Leave on Auto unless it looks wrong.";
+    let mut s = Settings::default();
+    s.horizon.hdr = HdrMode::On;
+    let none = (
+        calibrate.into(),
+        "Your display didn't say how bright it gets: calibrate to set it up.",
+    );
+    assert_eq!(
+        rows(&s, &NONE),
+        [
+            none.clone(),
+            ("Peak Brightness: Auto (1000)".into(), "-"),
+            ("Paper White: Auto (203)".into(), "-"),
+        ]
+    );
+    assert_eq!(
+        rows(&s, &guessed),
+        [
+            (
+                calibrate.into(),
+                "Your display's reported peak is often too high: calibrate to set it up."
+            ),
+            ("Peak Brightness: Auto (1000)".into(), "-"),
+            ("Paper White: Auto (400)".into(), "-"),
+        ]
+    );
+    assert_eq!(
+        rows(&s, &trusted),
+        [
+            (
+                "Calibrate Anyway...".into(),
+                "Already set up for your display. Only calibrate if HDR looks wrong."
+            ),
+            ("Peak Brightness: Auto (1000)".into(), set_up),
+            ("Paper White: Auto (400)".into(), set_up),
+        ]
+    );
+    // Calibrated or set by hand, either report offers its automatic setup back.
+    s.horizon.hdr_peak = 800;
+    // Peak's Auto stays a guess on Windows: only Paper White is said to be set up there.
+    let changed = |peak| {
+        [
+            (
+                "Use Automatic Setup".into(),
+                "Puts Peak Brightness and Paper White back to your display's setup.",
+            ),
+            ("Peak Brightness: 800".into(), peak),
+            ("Paper White: Auto (400)".into(), set_up),
+        ]
+    };
+    assert_eq!(rows(&s, &guessed), changed("-"));
+    assert_eq!(rows(&s, &trusted), changed(set_up));
+    assert_eq!(rows(&s, &NONE)[0], none);
+    let mut ui = ui();
+    ui.screen.output = guessed;
+    let at = |[x, y, ..]: [f32; 4]| (x + 8.0, y + 4.0);
+    let calibrate = row(&mut ui, &s, Item::Horizon(H::HdrCalibrate));
+    assert_eq!(press(&mut ui, &mut s, at(calibrate)), [CLICK, CHANGED]);
+    assert_eq!((s.horizon.hdr_peak, s.horizon.hdr_paper_white), (0, 0));
+    assert_eq!(
+        press(&mut ui, &mut s, at(calibrate)),
+        [CLICK, Output::Push(OptionsPage::HdrCalibration)]
+    );
 }
 
 /// UI Brightness reads as Paper White does, in nits apart from it: Auto shows the paper white

crates/horizon-client-render/src/lib.rs

@@ -67,7 +67,6 @@ mod jei_sprites;
 pub mod jigsaw_block;
 pub mod keypad;
 pub mod terrain_model;
-pub use horizon_polytone::colors as polytone_colors;
 pub use horizon_polytone::creative_tabs as polytone_creative_tabs;
 pub use horizon_world::json_folder;
 pub mod level_loading;
@@ -89,6 +88,8 @@ pub mod options_fixes;
 pub mod options_ui;
 pub mod overlay;
 pub mod pack_browser;
+pub mod pack_formats;
+pub mod pack_hooks;
 pub mod pack_options_ui;
 pub mod pack_palette;
 pub mod pack_screen;

crates/horizon-client-render/src/lod.rs

@@ -2593,8 +2593,7 @@ impl Lod {
         self.returned_at = std::time::Instant::now();
         let nodes = &self.plan.nodes;
         self.mesh_samples.retain(|key| nodes.contains(key));
-        // Queued tiles the view left are not sampled (a running one is
-        // dropped when it finishes, `finish_sample`).
+        // Queued tiles the view left are not sampled; a running one is dropped (`finish_sample`).
         drop_queued_samples(&self.shared, &mut self.pending, |key| {
             self.plan.nodes.contains(key)
         });
@@ -2680,6 +2679,7 @@ impl Lod {
             }
             if let Some((columns, mask)) = self.kept.take(&key) {
                 self.ready.insert(key, columns);
+                self.sync_sample(key);
                 if let Some(mask) = mask {
                     self.detail_masks.insert(key, mask);
                 }

crates/horizon-client-render/src/native_emissive.rs

@@ -1,6 +1,7 @@
 //! Optional, texture-matched overlays drawn full bright over their base texture in the same
-//! terrain fragment: native mods' (`<ns>:emissive/...`) and OptiFine's emissive block textures
-//! (`block/stone_e.png` beside `block/stone.png`). No extra draw calls or world light changes.
+//! terrain fragment: native mods' (`<ns>:emissive/...`) and a pack's emissive block textures
+//! (OptiFine's `block/stone_e.png` beside `block/stone.png`, the suffix from the pack formats,
+//! [`crate::pack_hooks`]). No extra draw calls or world light changes.
 use crate::sprites::Sprites;
 use std::{collections::BTreeMap, path::Path};
 
@@ -35,14 +36,12 @@ fn tile_file(name: &str) -> Option<&str> {
     name.strip_suffix(".png")
 }
 
-/// OptiFine's emissive overlays of the block sprites already loaded (what the terrain draws;
-/// items draw from the HUD atlas): for each
-/// `<ns>:block/<name>`, or connected-texture tile `assets/<ns>/.../<name>.png`, whose
-/// `<name><suffix>.png` sits beside it, the overlay is loaded too and paired with it, blocks
-/// first, then tiles, each by name, at most [`MAX`] - [`NATIVE`] (native mods keep their share of
-/// the table). A pack without such files adds nothing.
-pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)> {
-    let suffix = horizon_optifine::emissive::suffix(root);
+/// A pack's emissive overlays of the block sprites already loaded (what the terrain draws;
+/// items draw from the HUD atlas): for each `<ns>:block/<name>`, or connected-texture tile
+/// `assets/<ns>/.../<name>.png`, whose `<name><suffix>.png` sits beside it, the overlay is loaded
+/// too and paired with it, blocks first, then tiles, each by name, at most [`MAX`] - [`NATIVE`]
+/// (native mods keep their share of the table). A pack without such files adds nothing.
+pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(String, String)> {
     // Blocks with identical pixels share a layer (and the shader pairs by layer): a shared
     // base would glow on every block that shares it, so it gets no overlay.
     let mut sharing: BTreeMap<u32, usize> = BTreeMap::new();
@@ -56,8 +55,8 @@ pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)
             sharing[layer] == 1
                 && (name
                     .split_once(':')
-                    .is_some_and(|(_, p)| p.starts_with("block/") && !p.ends_with(&suffix))
-                    || tile_file(name).is_some_and(|stem| !stem.ends_with(&suffix)))
+                    .is_some_and(|(_, p)| p.starts_with("block/") && !p.ends_with(suffix))
+                    || tile_file(name).is_some_and(|stem| !stem.ends_with(suffix)))
         })
         .map(|(name, _)| name.clone())
         .collect();
@@ -110,7 +109,7 @@ pub fn load_optifine(root: &Path, sprites: &mut Sprites) -> Vec<(String, String)
 pub const CUTOUT: u32 = 1 << 31;
 
 /// The frame's overlay table: native mods' pairs (at most [`NATIVE`] requested), then the packs'
-/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_optifine`] loads),
+/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_overlays`] loads),
 /// one per base layer with native mods' first, sorted by base layer for the shader's early exit.
 pub fn table<'a>(
     layers: &BTreeMap<String, u32>,
@@ -204,7 +203,7 @@ mod tests {
         // Items draw from the HUD atlas, not the terrain: no pair.
         sprites.insert(&root, "minecraft:item/stick").unwrap();
         // glowstone isn't loaded: its overlay pairs with nothing.
-        let pairs = load_optifine(&root, &mut sprites);
+        let pairs = load_overlays(&root, "_e", &mut sprites);
         assert_eq!(
             pairs,
             [(
@@ -215,9 +214,6 @@ mod tests {
         assert!(sprites.layers.contains_key("minecraft:block/stone_e"));
         assert!(!sprites.layers.contains_key("minecraft:block/granite_e"));
         // The pack's own suffix.
-        let props = root.join("assets/minecraft/optifine/emissive.properties");
-        std::fs::create_dir_all(props.parent().unwrap()).unwrap();
-        std::fs::write(&props, "suffix.emissive=_glow").unwrap();
         // Connected-texture tiles pair with the overlay beside them.
         let tiles = root.join("assets/minecraft/optifine/ctm/lamp");
         png(&tiles.join("0.png"), 230);
@@ -234,7 +230,7 @@ mod tests {
                 .insert_file(&root, &format!("assets/minecraft/optifine/{tile}.png"))
                 .unwrap();
         }
-        let pairs = load_optifine(&root, &mut sprites);
+        let pairs = load_overlays(&root, "_glow", &mut sprites);
         assert_eq!(
             pairs,
             // Blocks first, then tiles.

crates/horizon-client-render/src/options_ui.rs

@@ -339,6 +339,7 @@ impl Opt {
             Opt::SharePresence => "options.sharePresence",
             Opt::DirectionalAudio => "options.directionalAudio",
             Opt::MusicToast => "options.musicToast",
+            Opt::Page(page, row) => pages::slider_caption(page, row),
         }
     }
     pub(crate) fn kind(self, s: &Settings) -> Kind {
@@ -402,6 +403,7 @@ impl Opt {
             Opt::PadLookDeadzone => unit(s.controller.look_deadzone, 0.0, 0.5),
             Opt::PadTriggerThreshold => unit(s.controller.trigger_threshold, 0.1, 0.9),
             Opt::SprintWindow => unit(s.sprint_window as f32, 0.0, 10.0),
+            Opt::Page(page, row) => pages::slider_kind(page, row),
             _ => Kind::Cycle,
         }
     }
@@ -878,6 +880,7 @@ impl Opt {
                 gamepad::TextKeyboard::Horizon => "horizon.options.keyboard.horizon",
                 gamepad::TextKeyboard::Steam => "horizon.options.keyboard.steam",
             }),
+            Opt::Page(page, row) => pages::slider_text(page, row),
             _ => Text::empty(),
         }
     }
@@ -952,6 +955,7 @@ impl Opt {
             Opt::PadLookDeadzone => s.controller.look_deadzone = step(0.0, 50.0) / 100.0,
             Opt::PadTriggerThreshold => s.controller.trigger_threshold = step(10.0, 90.0) / 100.0,
             Opt::SprintWindow => s.sprint_window = step(0.0, 10.0) as i32,
+            Opt::Page(page, row) => pages::slide(page, row, v),
             _ => {}
         }
         if self.affects_preset() {
@@ -1624,8 +1628,6 @@ pub struct OptionsUi {
     /// The native mod's key waiting: (mod, key) in `mods.installed`, or a registered page's
     /// (page, row) ([`pages::PAGE_KEY`]).
     selected_native_key: Option<(usize, usize)>,
-    /// The pages crates registered (`horizon_hooks::pages`).
-    pages: &'static [&'static dyn horizon_hooks::pages::Page],
     /// Bindings: the action waiting for a pad button.
     pub selected_pad_action: Option<&'static str>,
     /// The glyphs menus show (`Glyphs::of`: the setting, else the pad's family, and a Nintendo
@@ -1737,7 +1739,6 @@ impl Default for OptionsUi {
             scrollbar_drag_y: None,
             selected_key: None,
             selected_native_key: None,
-            pages: horizon_hooks::pages::engine::all(),
             selected_pad_action: None,
             pad_glyphs: crate::pad_glyph::Glyphs::default(),
             pad_driving: false,
@@ -1869,25 +1870,6 @@ fn wide_extras(s: &Settings, width: impl Fn(&str) -> f32) -> Vec<crate::extras::
         })
         .collect()
 }
-/// What a button opening one of Horizon's pages says on hover.
-fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
-    Some(match page {
-        Page::Horizon => "horizon.pages.settings.tooltip",
-        Page::Studio => "horizon.pages.studio.tooltip",
-        Page::Graphics => "horizon.pages.graphics.tooltip",
-        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
-        Page::Controller => "horizon.pages.controller.tooltip",
-        Page::Extras => "horizon.pages.extras.tooltip",
-        Page::Pvp => "horizon.pages.pvp.tooltip",
-        Page::Agent => "horizon.pages.agent.tooltip",
-        Page::SplitProfiles => "horizon.pages.split_profiles.tooltip",
-        Page::ShaderPacks => "horizon.pages.shader_packs.tooltip",
-        Page::Mods => "horizon.pages.mods.tooltip",
-        Page::SplitSetup => "horizon.pages.split_setup.tooltip",
-        Page::Music => "horizon.pages.music.tooltip",
-        _ => return None,
-    })
-}
 /// Rows of an OptionsList: (big?, options) or a header.
 enum Row {
     Big(Opt),
@@ -1907,14 +1889,17 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
             return None;
         };
         let key = opt.tooltip_key(s);
-        return lang::has(&key).then(|| tr(&key));
+        let Opt::Page(page, row) = opt else {
+            return lang::has(&key).then(|| tr(&key));
+        };
+        return pages::tooltip(*page, *row);
     };
     let mut tip = None;
     if let Act::Extra(item) = act {
         tip = Some(Text::literal(item.description_text()));
     }
     if let Act::Push(page) = act
-        && let Some(text) = horizon_page_tooltip(*page)
+        && let Some(text) = pages::horizon_page_tooltip(*page)
     {
         tip = Some(tr(text));
     }
@@ -1934,6 +1919,7 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
     }
     match act {
         Act::Cycle(opt) if !opt.available() => Some(tr("horizon.options.unavailable")),
+        Act::PageRow(page, row) => pages::tooltip(*page, *row),
         Act::ToggleMod(i) => match s.mods.installed.get(*i) {
             Some(installed) => {
                 let description = installed

crates/horizon-client-render/src/options_ui_pages.rs

@@ -8,9 +8,88 @@ use horizon_hooks::pages as added;
 /// `selected_key` while a registered page's key waits (`selected_native_key`: page, row).
 pub(super) const PAGE_KEY: &str = "horizon.pageKey";
 
+#[cfg(test)]
+thread_local! {
+    /// A test's own pages, instead of the game's registered ones: each test runs on its thread.
+    static TEST_PAGES: std::cell::Cell<Option<&'static [&'static dyn added::Page]>> =
+        const { std::cell::Cell::new(None) };
+}
+
+/// The pages crates registered.
+fn registered() -> &'static [&'static dyn added::Page] {
+    #[cfg(test)]
+    if let Some(pages) = TEST_PAGES.get() {
+        return pages;
+    }
+    added::engine::all()
+}
+
 /// A registered page's title (a translation key).
 pub(super) fn title(page: usize) -> &'static str {
-    added::engine::all().get(page).map_or("", |p| p.title())
+    registered().get(page).map_or("", |p| p.title())
+}
+
+/// Row `r` of a registered page, as it is now.
+fn row(page: usize, r: usize) -> Option<added::Row> {
+    let mut rows = Vec::new();
+    registered().get(page)?.rows(&mut rows);
+    rows.into_iter().nth(r)
+}
+
+/// A registered page's slider ([`Opt::Page`]): its caption (a translation key).
+pub(super) fn slider_caption(page: usize, r: usize) -> &'static str {
+    match row(page, r) {
+        Some(added::Row::Slider { label, .. }) => label,
+        _ => "",
+    }
+}
+
+/// A registered page's slider: its position.
+pub(super) fn slider_kind(page: usize, r: usize) -> Kind {
+    match row(page, r) {
+        Some(added::Row::Slider { value, .. }) => Kind::Slider(value.clamp(0.0, 1.0)),
+        _ => Kind::Cycle,
+    }
+}
+
+/// A registered page's slider: the value its message shows after the caption.
+pub(super) fn slider_text(page: usize, r: usize) -> Text {
+    match row(page, r) {
+        Some(added::Row::Slider { text, .. }) => label_text(text),
+        _ => Text::empty(),
+    }
+}
+
+/// A registered page's slider moved.
+pub(super) fn slide(page: usize, r: usize, value: f32) {
+    if let Some(registered) = registered().get(page) {
+        registered.act(r, added::Act::Slide(value));
+    }
+}
+
+/// What a registered page's row says on hover.
+pub(super) fn tooltip(page: usize, r: usize) -> Option<Text> {
+    registered().get(page)?.tooltip(r).map(label_text)
+}
+
+/// What a button opening one of Horizon's pages says on hover.
+pub(super) fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
+    Some(match page {
+        Page::Horizon => "horizon.pages.settings.tooltip",
+        Page::Studio => "horizon.pages.studio.tooltip",
+        Page::Graphics => "horizon.pages.graphics.tooltip",
+        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
+        Page::Controller => "horizon.pages.controller.tooltip",
+        Page::Extras => "horizon.pages.extras.tooltip",
+        Page::Pvp => "horizon.pages.pvp.tooltip",
+        Page::Agent => "horizon.pages.agent.tooltip",
+        Page::SplitProfiles => "horizon.pages.split_profiles.tooltip",
+        Page::ShaderPacks => "horizon.pages.shader_packs.tooltip",
+        Page::Mods => "horizon.pages.mods.tooltip",
+        Page::SplitSetup => "horizon.pages.split_setup.tooltip",
+        Page::Music => "horizon.pages.music.tooltip",
+        _ => return None,
+    })
 }
 
 fn label_text(label: added::Label) -> Text {
@@ -66,8 +145,7 @@ impl OptionsUi {
 
     /// The entries of the pages registered for Horizon Settings, two to a row like the engine's.
     fn added_entries(&self, rows: &mut Vec<Row>) {
-        let mut entries = self
-            .pages
+        let mut entries = registered()
             .iter()
             .enumerate()
             .filter(|(_, page)| page.place() == added::Place::HorizonSettings)
@@ -79,15 +157,43 @@ impl OptionsUi {
 
     /// A registered page's rows, asked of it each time the page is drawn.
     pub(super) fn added_rows(&self, page: usize) -> Vec<Row> {
-        let Some(registered) = self.pages.get(page) else {
+        let Some(registered) = registered().get(page) else {
             return Vec::new();
         };
         let mut rows = Vec::new();
         registered.rows(&mut rows);
-        rows.into_iter()
-            .enumerate()
-            .map(|(r, row)| self.added_row(page, r, row))
-            .collect()
+        let mut out = Vec::new();
+        // The row a half-width button started, waiting for the next to sit beside it.
+        let mut half_open = false;
+        for (r, row) in rows.into_iter().enumerate() {
+            match row {
+                // Wrapped as the engine's own notes; space is for pages drawn as a screen.
+                added::Row::Text { text, .. } => {
+                    out.extend(wrap(&text, 64).into_iter().map(Row::Note))
+                }
+                added::Row::Space(_) | added::Row::Field { .. } => continue,
+                added::Row::Button {
+                    label,
+                    active,
+                    half: true,
+                    ..
+                } => {
+                    let mut half = button(0.0, 0.0, 150.0, tr(label), Act::PageRow(page, r));
+                    if !active {
+                        half = inactive(half);
+                    }
+                    match out.last_mut() {
+                        Some(Row::Buttons(_, second @ None)) if half_open => *second = Some(half),
+                        _ => out.push(Row::Buttons(half, None)),
+                    }
+                    half_open = !half_open;
+                    continue;
+                }
+                row => out.push(self.added_row(page, r, row)),
+            }
+            half_open = false;
+        }
+        out
     }
 
     fn added_row(&self, page: usize, r: usize, row: added::Row) -> Row {
@@ -98,7 +204,11 @@ impl OptionsUi {
             added::Row::Note(text) => Row::Note(text),
             added::Row::Toggle { label, on } => wide(generic(label, on_off(on))),
             added::Row::Cycle { label, value } => wide(generic(label, label_text(value))),
-            added::Row::Button { label } => wide(tr(label)),
+            added::Row::Slider { .. } => Row::Big(Opt::Page(page, r)),
+            added::Row::Button { label, active, .. } => {
+                let wide = button(0.0, 0.0, 310.0, tr(label), act);
+                Row::Buttons(if active { wide } else { inactive(wide) }, None)
+            }
             added::Row::Key { label, key } => {
                 let mut message = keybinds::display_name(&key);
                 if self.selected_key == Some(PAGE_KEY)
@@ -120,7 +230,7 @@ impl OptionsUi {
 
     /// A registered page's row was pressed: a key row waits for a key, any other row hears it.
     pub(super) fn page_act(&mut self, page: usize, r: usize, shift: bool) -> Vec<Event> {
-        let Some(registered) = self.pages.get(page) else {
+        let Some(registered) = registered().get(page) else {
             return Vec::new();
         };
         let mut rows = Vec::new();
@@ -199,7 +309,7 @@ impl OptionsUi {
     ) -> Vec<Event> {
         let (i, k) = self.selected_native_key.take().unwrap_or_default();
         if name == PAGE_KEY {
-            if let Some(page) = self.pages.get(i) {
+            if let Some(page) = registered().get(i) {
                 page.act(k, added::Act::Bind(value));
             }
             return vec![Event::Changed];
@@ -221,11 +331,12 @@ mod tests {
     use super::*;
     use std::sync::Mutex;
 
-    /// A page with a heading, a switch, a number that steps either way and a key.
+    /// A page with a heading, a switch, a number that steps either way, a key and a volume.
     struct Sample {
         on: Mutex<bool>,
         step: Mutex<i32>,
         key: Mutex<String>,
+        volume: Mutex<f32>,
     }
 
     impl added::Page for Sample {
@@ -252,6 +363,12 @@ mod tests {
                 label: "test.sample.key",
                 key: self.key.lock().unwrap().clone(),
             });
+            let volume = *self.volume.lock().unwrap();
+            rows.push(added::Row::Slider {
+                label: "test.sample.volume",
+                value: volume,
+                text: added::Label::Value(format!("{}%", (volume * 100.0).round())),
+            });
         }
         fn act(&self, row: usize, act: added::Act) {
             match (row, act) {
@@ -262,15 +379,20 @@ mod tests {
                 (2, added::Act::Press) => *self.step.lock().unwrap() += 1,
                 (2, added::Act::PressBack) => *self.step.lock().unwrap() -= 1,
                 (3, added::Act::Bind(key)) => *self.key.lock().unwrap() = key,
+                (4, added::Act::Slide(v)) => *self.volume.lock().unwrap() = v,
                 other => panic!("row and act the page doesn't expect: {other:?}"),
             }
         }
+        fn tooltip(&self, row: usize) -> Option<added::Label> {
+            (row == 1).then_some(added::Label::Key("test.sample.switch.tooltip"))
+        }
     }
 
     static SAMPLE: Sample = Sample {
         on: Mutex::new(false),
         step: Mutex::new(0),
         key: Mutex::new(String::new()),
+        volume: Mutex::new(0.0),
     };
     static PAGES: [&dyn added::Page; 1] = [&SAMPLE];
 
@@ -297,10 +419,8 @@ mod tests {
     #[test]
     fn a_registered_page_opens_from_horizon_settings_and_hears_its_rows() {
         let mut s = Settings::default();
-        let mut ui = OptionsUi {
-            pages: &PAGES,
-            ..OptionsUi::default()
-        };
+        TEST_PAGES.set(Some(&PAGES));
+        let mut ui = OptionsUi::default();
         ui.show(Page::Horizon);
         press(&mut ui, &mut s, Act::Push(Page::Added(0)), false);
         assert_eq!(ui.page(), Page::Added(0));
@@ -323,5 +443,133 @@ mod tests {
         assert_eq!(events, [Event::Changed]);
         assert_eq!(*SAMPLE.key.lock().unwrap(), "key.keyboard.z");
         assert_eq!(ui.selected_key, None);
+        // The volume is one of the screen's own sliders: dragged to its middle, then let go.
+        let size = (480.0, 240.0);
+        let (widgets, ..) = ui.layout(&s, size.0, size.1);
+        let slider = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    w.kind,
+                    WKind::Slider {
+                        opt: Opt::Page(0, 4),
+                        ..
+                    }
+                )
+            })
+            .expect("the volume's slider");
+        let (x, y) = (slider.x + slider.w / 2.0, slider.y + 1.0);
+        ui.click(&mut s, &atlas, x, y, size, [480, 240], false, false);
+        let volume = *SAMPLE.volume.lock().unwrap();
+        assert!((0.45..0.55).contains(&volume), "{volume}");
+        assert!(ui.release().contains(&Event::Changed));
+        // The slider shows the page's value once let go.
+        let (widgets, ..) = ui.layout(&s, size.0, size.1);
+        let shown = widgets.iter().find_map(|w| match w.kind {
+            WKind::Slider {
+                opt: Opt::Page(0, 4),
+                value,
+                ..
+            } => Some(value),
+            _ => None,
+        });
+        assert_eq!(shown, Some(volume));
+        // The page's tooltip for its switch.
+        let switch = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    &w.kind,
+                    WKind::Button {
+                        act: Act::PageRow(0, 1),
+                        ..
+                    }
+                )
+            })
+            .expect("the switch");
+        assert_eq!(
+            tooltip_text(&s, switch).map(|t| t.plain()),
+            Some(tr("test.sample.switch.tooltip").plain())
+        );
+    }
+
+    /// Text, a grey note, space, two half buttons (the second inactive) and a footer button.
+    struct Shaped(Mutex<Vec<usize>>);
+
+    impl added::Page for Shaped {
+        fn id(&self) -> &'static str {
+            "test.shaped"
+        }
+        fn title(&self) -> &'static str {
+            "test.shaped.title"
+        }
+        fn place(&self) -> added::Place {
+            added::Place::HorizonSettings
+        }
+        fn rows(&self, rows: &mut Vec<added::Row>) {
+            rows.push(added::Row::text("ABCDE-FGHIJ").groups());
+            rows.push(added::Row::text("grey").quiet());
+            rows.push(added::Row::Space(6));
+            rows.push(added::Row::button("test.shaped.copy").half());
+            rows.push(added::Row::button("test.shaped.stop").half().active(false));
+            rows.push(added::Row::button("test.shaped.help").footer());
+        }
+        fn act(&self, row: usize, _: added::Act) {
+            self.0.lock().unwrap().push(row);
+        }
+    }
+
+    static SHAPED: Shaped = Shaped(Mutex::new(Vec::new()));
+    static SHAPED_PAGES: [&dyn added::Page; 1] = [&SHAPED];
+
+    #[test]
+    fn half_buttons_share_a_row_and_an_inactive_one_is_never_pressed() {
+        let mut s = Settings::default();
+        TEST_PAGES.set(Some(&SHAPED_PAGES));
+        let ui = OptionsUi::default();
+        let rows = ui.added_rows(0);
+        // The two texts as notes (space shows nothing here), the halves on one row, the
+        // footer button below them (the settings shell has no footer of its own).
+        assert!(matches!(&rows[0], Row::Note(t) if t == "ABCDE-FGHIJ"));
+        assert!(matches!(&rows[1], Row::Note(t) if t == "grey"));
+        let Row::Buttons(copy, Some(stop)) = &rows[2] else {
+            panic!("the halves sit side by side: {:?}", rows.len());
+        };
+        assert_eq!((copy.w, stop.w), (150.0, 150.0));
+        assert!(matches!(&rows[3], Row::Buttons(help, None) if help.w == 310.0));
+        assert_eq!(rows.len(), 4);
+        let mut ui = ui;
+        ui.show(Page::Added(0));
+        press(&mut ui, &mut s, Act::PageRow(0, 3), false);
+        press(&mut ui, &mut s, Act::PageRow(0, 5), false);
+        let (widgets, ..) = ui.layout(&s, 480.0, 240.0);
+        let stop = widgets
+            .iter()
+            .find(|w| {
+                matches!(
+                    &w.kind,
+                    WKind::Button {
+                        act: Act::PageRow(0, 4),
+                        ..
+                    }
+                )
+            })
+            .expect("Stop is drawn");
+        let atlas = super::super::tests::atlas();
+        ui.click(
+            &mut s,
+            &atlas,
+            stop.x + 1.0,
+            stop.y + 1.0,
+            (480.0, 240.0),
+            [480, 240],
+            false,
+            false,
+        );
+        assert_eq!(
+            *SHAPED.0.lock().unwrap(),
+            [3, 5],
+            "the inactive half heard nothing"
+        );
     }
 }

crates/horizon-client-render/src/pack_formats/colors.rs

@@ -0,0 +1,67 @@
+//! Polytone's custom colours (`horizon_polytone::colors`, `colors.json` or `color.properties`)
+//! as the engine's pack colours ([`crate::pack_palette::PackColors`]).
+use std::path::Path;
+
+use horizon_polytone::colors::PackColors;
+
+use crate::block_entity_render::DYES;
+use crate::pack_palette::{self, Environment};
+
+/// The colours of every namespace's file under the pack overlay at `root`.
+pub fn read(root: &Path) -> pack_palette::PackColors {
+    let colors = PackColors::read(root);
+    let by_dye = |f: &dyn Fn(&str) -> Option<u32>| std::array::from_fn(|i| f(DYES[i].0));
+    let env = colors.env;
+    pack_palette::PackColors {
+        dye_diffuse: by_dye(&|name| colors.dye(name, "diffuse")),
+        dye_text: by_dye(&|name| colors.dye(name, "text")),
+        sheep: by_dye(&|name| colors.sheep(name)),
+        redstone: std::array::from_fn(|i| colors.redstone(i as u8)),
+        effects: colors.effects(),
+        entity_shadows: colors.entity_shadows(),
+        xp_bar: colors.xp_bar(),
+        env: Environment {
+            powder_snow_fog: env.powder_snow_fog,
+            blindness_fog_distance: env.blindness_fog_distance,
+            darkness_fog_distance: env.darkness_fog_distance,
+            boss_fog_distance: env.boss_fog_distance,
+            water_fog_brightening: env.water_fog_brightening,
+            water_fog_brightening_time: env.water_fog_brightening_time,
+            horizon_height: env.horizon_height,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::pack_palette::{diffuse, redstone, sheep_wool, text};
+
+    #[test]
+    fn a_pack_recolours_only_what_it_names() {
+        // Dyes no other test draws: the table is process-wide.
+        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
+        let polytone = dir.join("assets/obs/polytone");
+        std::fs::create_dir_all(&polytone).unwrap();
+        std::fs::write(
+            polytone.join("colors.json"),
+            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
+        )
+        .unwrap();
+        crate::pack_palette::set(&read(&dir));
+        let (cyan, pink, purple) = (9, 6, 10);
+        assert_eq!(diffuse(cyan), 0x00ff00);
+        assert_eq!(text(cyan), 0x0000ff);
+        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
+        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
+        assert_eq!(sheep_wool(cyan as u8), 0x107575);
+        assert_eq!(diffuse(purple), 0x8932B8);
+        assert_eq!(text(purple), 0xA020F0);
+        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
+        crate::pack_palette::set(&Default::default());
+        assert_eq!(redstone(7), None);
+        assert_eq!(diffuse(cyan), 0x169C9C);
+        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}

crates/horizon-client-render/src/pack_formats/custom_sky.rs

@@ -0,0 +1,252 @@
+//! OptiFine custom skies (`horizon_optifine::sky`) on the engine's sky layers
+//! ([`crate::custom_sky`]): a pack's layers with their decoded textures, read once with the pack,
+//! and each frame's choice of layers, their brightness and rotation. A pack without
+//! `optifine/sky` has none, and the sky stays vanilla.
+
+use std::path::Path;
+
+use glam::{Mat4, Vec3};
+use horizon_optifine::sky::{Blend, Conditions, Now, Skies, SkyLayer, Transition};
+
+use crate::custom_sky::{self as engine, Draw, Image, SkyLayers, State};
+
+/// The pack's layers, by world, with one texture per layer (`images[i]` for the `i`th layer
+/// over all worlds, in `worlds` order).
+#[derive(Default)]
+pub struct CustomSky {
+    worlds: Vec<(i32, Vec<SkyLayer>)>,
+    pub images: Vec<Image>,
+}
+
+/// Textures past this many texels in all are left out (a skybox is a few megapixels at most).
+const TEXEL_BUDGET: u64 = 64 << 20;
+
+impl CustomSky {
+    /// The custom skies of the overlay at `root`. A layer whose texture does not decode is
+    /// dropped with a warning.
+    pub fn load(root: &Path) -> Self {
+        let skies = Skies::scan(root);
+        let mut out = Self::default();
+        let mut texels = 0u64;
+        for (world, sky) in skies.worlds {
+            let mut layers = Vec::new();
+            for layer in sky.layers {
+                match crate::hud::decode(&root.join(&layer.source)) {
+                    Ok((width, height, rgba))
+                        if texels + u64::from(width) * u64::from(height) <= TEXEL_BUDGET =>
+                    {
+                        texels += u64::from(width) * u64::from(height);
+                        out.images.push(Image {
+                            width,
+                            height,
+                            rgba,
+                        });
+                        layers.push(layer);
+                    }
+                    Ok(_) => log::warn!("{}: past the custom sky's texture budget", layer.source),
+                    Err(e) => log::warn!("{}: {e:#}", layer.source),
+                }
+            }
+            if !layers.is_empty() {
+                out.worlds.push((world, layers));
+            }
+        }
+        out
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.worlds.is_empty()
+    }
+}
+
+/// The engine's sky blend for OptiFine's.
+fn blend(blend: Blend) -> engine::Blend {
+    match blend {
+        Blend::Add => engine::Blend::Add,
+        Blend::Subtract => engine::Blend::Subtract,
+        Blend::Multiply => engine::Blend::Multiply,
+        Blend::Dodge => engine::Blend::Dodge,
+        Blend::Burn => engine::Blend::Burn,
+        Blend::Screen => engine::Blend::Screen,
+        Blend::Replace => engine::Blend::Replace,
+        Blend::Overlay => engine::Blend::Overlay,
+        Blend::Alpha => engine::Blend::Alpha,
+    }
+}
+
+impl SkyLayers for CustomSky {
+    fn images(&self) -> &[Image] {
+        &self.images
+    }
+
+    /// Whether `world` has layers (`0` the Overworld, `1` the End).
+    fn has(&self, world: i32) -> bool {
+        self.worlds.iter().any(|(w, _)| *w == world)
+    }
+
+    /// The layers whose conditions hold, eased over their `transition`, at the brightness of
+    /// their fade times.
+    fn draws(
+        &self,
+        world: i32,
+        conditions: &engine::Conditions,
+        sun_turns: f32,
+        seconds: f32,
+        state: &mut State,
+        out: &mut Vec<Draw>,
+    ) {
+        let conditions = &Conditions {
+            day_time: conditions.day_time,
+            weather: match conditions.weather {
+                engine::Weather::Clear => Now::Clear,
+                engine::Weather::Rain => Now::Rain,
+                engine::Weather::Thunder => Now::Thunder,
+            },
+            biome: conditions.biome,
+            y: conditions.y,
+        };
+        out.clear();
+        let mut first = 0;
+        let mut found = None;
+        for (w, layers) in &self.worlds {
+            if *w == world {
+                found = Some(layers);
+                break;
+            }
+            first += layers.len();
+        }
+        let Some(layers) = found else {
+            state.world = None;
+            return;
+        };
+        // A new world (or pack) starts each layer where its conditions put it: no fade in.
+        let snap = state.world != Some(world) || state.eased.len() != layers.len();
+        if snap {
+            state.world = Some(world);
+            state.eased.clear();
+            state.eased.resize(layers.len(), 0.0);
+        }
+        for (i, (layer, eased)) in layers.iter().zip(&mut state.eased).enumerate() {
+            let target = if layer.shows(conditions) { 1.0 } else { 0.0 };
+            let shown = if snap {
+                *eased = target;
+                target
+            } else {
+                let mut t = Transition { value: *eased };
+                *eased = t.step(target, seconds, layer.transition);
+                *eased
+            };
+            let brightness = shown * layer.brightness(conditions.day_time);
+            if brightness <= 0.0 {
+                continue;
+            }
+            let turns = layer.turns(conditions.day_time, sun_turns);
+            let rotation = if turns == 0.0 {
+                Mat4::IDENTITY
+            } else {
+                Mat4::from_axis_angle(Vec3::from_array(layer.axis), turns * std::f32::consts::TAU)
+            };
+            out.push(Draw {
+                image: (first + i) as u16,
+                blend: blend(layer.blend),
+                brightness,
+                rotation,
+            });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::custom_sky::{Conditions, Weather};
+
+    fn pack(files: &[(&str, &str)]) -> (std::path::PathBuf, CustomSky) {
+        let root = std::env::temp_dir().join(format!(
+            "horizon-custom-sky-{}-{}",
+            std::process::id(),
+            files.len()
+        ));
+        let _ = std::fs::remove_dir_all(&root);
+        let dir = root.join("assets/minecraft/optifine/sky/world0");
+        std::fs::create_dir_all(&dir).unwrap();
+        let png = {
+            let mut bytes = Vec::new();
+            let mut encoder = png::Encoder::new(&mut bytes, 6, 4);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let mut writer = encoder.write_header().unwrap();
+            writer
+                .write_image_data(&[255, 0, 0, 255].repeat(24))
+                .unwrap();
+            writer.finish().unwrap();
+            bytes
+        };
+        for (name, text) in files {
+            std::fs::write(dir.join(format!("{name}.properties")), text).unwrap();
+            std::fs::write(dir.join(format!("{name}.png")), &png).unwrap();
+        }
+        let sky = CustomSky::load(&root);
+        (root, sky)
+    }
+
+    fn noon(biome: &str) -> Conditions<'_> {
+        Conditions {
+            day_time: 6000,
+            weather: Weather::Clear,
+            biome,
+            y: 64,
+        }
+    }
+
+    #[test]
+    fn layers_ease_in_at_a_biome_border_but_not_on_arrival() {
+        let (root, sky) = pack(&[
+            ("sky1", "biomes=desert\ntransition=2"),
+            ("sky2", "blend=alpha\nrotate=false"),
+        ]);
+        let _ = std::fs::remove_dir_all(root);
+        assert!(sky.has(0) && !sky.has(1));
+        assert_eq!(sky.images[0].width, 6);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        sky.draws(
+            0,
+            &noon("minecraft:desert"),
+            0.0,
+            0.05,
+            &mut state,
+            &mut out,
+        );
+        assert_eq!(
+            out.iter().map(|d| d.brightness).collect::<Vec<_>>(),
+            [1.0, 1.0]
+        );
+        // Out of the desert: the first layer fades over its two seconds.
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 0.5, &mut state, &mut out);
+        assert_eq!(out[0].brightness, 0.75);
+        assert_eq!(out[1].blend, engine::Blend::Alpha);
+        sky.draws(0, &noon("minecraft:plains"), 0.0, 2.0, &mut state, &mut out);
+        assert_eq!(out.len(), 1, "a dark layer is not drawn");
+        assert_eq!(out[0].image, 1);
+        // Into the End, which has no layers, and back: no fade.
+        sky.draws(1, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert!(out.is_empty());
+        sky.draws(0, &noon("minecraft:desert"), 0.0, 0.0, &mut state, &mut out);
+        assert_eq!(out.len(), 2);
+    }
+
+    #[test]
+    fn a_layer_turns_west_like_the_sun() {
+        let (root, sky) = pack(&[("sky1", "")]);
+        let _ = std::fs::remove_dir_all(root);
+        let (mut state, mut out) = (State::default(), Vec::new());
+        // A quarter turn after noon (sunset): the skybox's zenith has gone down to the west.
+        let c = Conditions {
+            day_time: 12000,
+            ..noon("minecraft:plains")
+        };
+        sky.draws(0, &c, 0.25, 0.0, &mut state, &mut out);
+        let up = out[0].rotation.transform_vector3(Vec3::Y);
+        assert!((up - Vec3::NEG_X).length() < 1e-5, "{up}");
+    }
+}

crates/horizon-client-render/src/pack_formats/item_bars.rs

@@ -0,0 +1,146 @@
+//! Polytone's item modifiers' durability bar colours, on the engine's
+//! [`crate::pack_palette::ItemBars`].
+use std::path::Path;
+use std::sync::Arc;
+
+/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
+/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
+struct DamageBar {
+    targets: horizon_polytone::Targets,
+    row: Vec<u32>,
+}
+
+/// The packs' damage bars, the last read first.
+struct Bars(Vec<DamageBar>);
+
+impl crate::pack_palette::ItemBars for Bars {
+    fn color(&self, item: &str, damage: f32) -> Option<u32> {
+        let bar = self
+            .0
+            .iter()
+            .rev()
+            .find(|b| b.targets.matches(item, |_| false))?;
+        let last = (bar.row.len() - 1) as f32;
+        Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
+    }
+}
+
+/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
+/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
+/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read. `None` without any.
+pub fn read(root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
+    let mut bars = Vec::new();
+    for namespace in std::fs::read_dir(root.join("assets"))
+        .into_iter()
+        .flatten()
+        .flatten()
+    {
+        let base = namespace.path().join("polytone/item_modifiers");
+        let mut stack = vec![base.clone()];
+        while let Some(dir) = stack.pop() {
+            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    stack.push(path);
+                } else if let Some(bar) = item_bar(root, &base, &path) {
+                    bars.push(bar);
+                }
+            }
+        }
+    }
+    (!bars.is_empty()).then(|| Arc::new(Bars(bars)) as _)
+}
+
+fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
+    let name = path.file_name()?.to_str()?;
+    let row = |png: &Path| {
+        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
+        let row: Vec<u32> = rgba[..width as usize * 4]
+            .as_chunks::<4>()
+            .0
+            .iter()
+            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
+            .collect();
+        (!row.is_empty()).then_some(row)
+    };
+    if let Some(stem) = name.strip_suffix("_bar.png") {
+        // A json of the same name owns its png.
+        if path.with_file_name(format!("{stem}.json")).exists() {
+            return None;
+        }
+        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
+        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
+        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
+        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
+        return Some(DamageBar {
+            targets,
+            row: row(path)?,
+        });
+    }
+    let stem = name.strip_suffix(".json")?;
+    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
+    if json.get("bar_color")?.as_str()? != "damage" {
+        return None;
+    }
+    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
+        .into_iter()
+        .map(|png| path.with_file_name(png))
+        .find(|png| png.exists())?;
+    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
+    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
+    let targets =
+        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
+    Some(DamageBar {
+        targets,
+        row: row(&png)?,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        let file = std::fs::File::create(path).unwrap();
+        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
+        encoder.set_color(png::ColorType::Rgba);
+        let data: Vec<u8> = pixels
+            .iter()
+            .flat_map(|p| [p[0], p[1], p[2], 255])
+            .collect();
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&data)
+            .unwrap();
+    }
+
+    #[test]
+    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
+        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
+        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
+        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
+        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
+        std::fs::write(
+            modifiers.join("tools.json"),
+            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
+        )
+        .unwrap();
+        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
+        let bars = read(&dir).unwrap();
+        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
+        assert_eq!(
+            bars.color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
+            Some(0xFF0000)
+        );
+        assert_eq!(
+            bars.color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
+            Some(0xFFFF00)
+        );
+        assert_eq!(bars.color("minecraft:iron_axe", 0.9), Some(0x040506));
+        assert_eq!(bars.color("minecraft:diamond_shovel", 0.5), None);
+        assert!(read(&dir.join("none")).is_none());
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}

crates/horizon-client-render/src/pack_formats/mod.rs

@@ -0,0 +1,40 @@
+//! The resource pack formats vanilla doesn't read (OptiFine's, Polytone's) on the engine's
+//! extension points ([`crate::pack_hooks`]). This is platform code (docs/layers.md) kept in this
+//! crate until the platform's executable installs it: it uses only the crate's public API, so it
+//! moves to a platform crate unchanged, and nothing else in the crate names it.
+
+mod colors;
+mod custom_sky;
+mod item_bars;
+
+use std::path::Path;
+use std::sync::Arc;
+
+use crate::pack_hooks::PackFormats;
+
+/// OptiFine's and Polytone's formats.
+pub struct Formats;
+
+impl PackFormats for Formats {
+    fn colors(&self, root: &Path) -> Option<crate::pack_palette::PackColors> {
+        Some(colors::read(root))
+    }
+
+    fn emissive_suffix(&self, root: &Path) -> Option<String> {
+        Some(horizon_optifine::emissive::suffix(root))
+    }
+
+    fn custom_sky(&self, root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
+        let sky = custom_sky::CustomSky::load(root);
+        (!sky.is_empty()).then(|| Arc::new(sky) as _)
+    }
+
+    fn item_bars(&self, root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
+        item_bars::read(root)
+    }
+}
+
+/// Installs these formats ([`crate::pack_hooks::install`]); the game does at startup.
+pub fn install() {
+    crate::pack_hooks::install(&Formats);
+}

crates/horizon-client-render/src/pack_hooks.rs

@@ -0,0 +1,51 @@
+//! The engine's extension points for resource pack formats vanilla doesn't read (OptiFine's,
+//! Polytone's: platform code, docs/layers.md). The engine asks [`formats`] once per pack load and
+//! gets engine types back (tables, or an object it calls at most once a frame), never a format's
+//! own types. The platform installs its formats at startup ([`install`]); with none installed,
+//! packs load as vanilla reads them.
+
+use std::path::Path;
+use std::sync::{Arc, OnceLock};
+
+/// What the pack formats beyond vanilla's add to a pack. Each method reads one overlay of a pack
+/// (its folder at `root`); the default is "nothing in this format".
+pub trait PackFormats: Send + Sync {
+    /// The colours the overlay replaces where vanilla hardcodes them.
+    fn colors(&self, _root: &Path) -> Option<crate::pack_palette::PackColors> {
+        None
+    }
+
+    /// The name ending of the overlay's emissive textures (`stone_e.png` beside `stone.png`),
+    /// if its format has them.
+    fn emissive_suffix(&self, _root: &Path) -> Option<String> {
+        None
+    }
+
+    /// The sky layers the overlay draws over the vanilla sky, if it has any.
+    fn custom_sky(&self, _root: &Path) -> Option<Arc<dyn crate::custom_sky::SkyLayers>> {
+        None
+    }
+
+    /// The durability bar colours the overlay sets by item, if any.
+    fn item_bars(&self, _root: &Path) -> Option<Arc<dyn crate::pack_palette::ItemBars>> {
+        None
+    }
+}
+
+/// No format beyond vanilla's.
+struct Vanilla;
+
+impl PackFormats for Vanilla {}
+
+static FORMATS: OnceLock<&'static dyn PackFormats> = OnceLock::new();
+
+/// Installs the pack formats, before the first pack loads. The first call wins: later ones are
+/// ignored, so each test or probe that needs the formats may install them.
+pub fn install(formats: &'static dyn PackFormats) {
+    let _ = FORMATS.set(formats);
+}
+
+/// The installed pack formats, or vanilla's alone.
+pub fn formats() -> &'static dyn PackFormats {
+    FORMATS.get().copied().unwrap_or(&Vanilla)
+}

crates/horizon-client-render/src/pack_palette.rs

@@ -1,14 +1,87 @@
-//! Polytone's dye, sheep and redstone colours (`dye.<name>.diffuse|text`, `sheep.<name>`,
-//! `redstone.<power>`), for drawing only: the pack recolours collars, tropical fish, banners, wool,
-//! sign text and redstone wire and dust, while gameplay (crafting, item data, the beacon) keeps
-//! vanilla's `DyeColor`. Lock-free: the draw paths and the mesher's workers read it per face.
+//! The colours a pack replaces where vanilla hardcodes them (Polytone's `colors.json`, read by the
+//! platform's pack formats, [`crate::pack_hooks`]): dye, sheep and redstone colours, for drawing
+//! only (the pack recolours collars, tropical fish, banners, wool, sign text and redstone wire and
+//! dust, while gameplay keeps vanilla's `DyeColor`), mob effect colours, the experience number's,
+//! entity shadows, the effect fogs' settings and durability bar colours. Lock-free: the draw paths
+//! and the mesher's workers read the dye, sheep and redstone tables per face.
 use std::path::Path;
-use std::sync::RwLock;
 use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
+use std::sync::{Arc, RwLock};
 
 use crate::block_entity_render::DYES;
 use crate::signs::DYE_TEXT;
-use horizon_polytone::colors::PackColors;
+
+/// The fog settings vanilla hardcodes, as the packs set them (vanilla's by default).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Environment {
+    /// The fog colour inside powder snow (RGB).
+    pub powder_snow_fog: Option<u32>,
+    /// The fog ends of Blindness (5), Darkness (15) and bosses that add world fog (96).
+    pub blindness_fog_distance: f32,
+    pub darkness_fog_distance: f32,
+    pub boss_fog_distance: f32,
+    /// How much the underwater fog colour washes out (1 vanilla, 0 none).
+    pub water_fog_brightening: f32,
+    /// The ticks under water it takes (vanilla's 600).
+    pub water_fog_brightening_time: f32,
+    /// Below it the sky draws its dark disc (vanilla's 63; flat worlds keep their floor).
+    pub horizon_height: f32,
+}
+
+impl Default for Environment {
+    fn default() -> Self {
+        Self {
+            powder_snow_fog: None,
+            blindness_fog_distance: 5.0,
+            darkness_fog_distance: 15.0,
+            boss_fog_distance: 96.0,
+            water_fog_brightening: 1.0,
+            water_fog_brightening_time: 600.0,
+            horizon_height: 63.0,
+        }
+    }
+}
+
+/// The packs' colours; `None` (and the defaults) where they keep vanilla's.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PackColors {
+    /// By dye id (`DyeColor` order): `getTextureDiffuseColor`, `getTextColor`, the sheep's wool.
+    pub dye_diffuse: [Option<u32>; 16],
+    pub dye_text: [Option<u32>; 16],
+    pub sheep: [Option<u32>; 16],
+    /// `RedStoneWireBlock.COLORS` by power.
+    pub redstone: [Option<u32>; 16],
+    /// Mob effects' colours, by effect id without vanilla's namespace.
+    pub effects: Vec<(String, u32)>,
+    /// False hides every entity's round shadow, whatever the video option says.
+    pub entity_shadows: bool,
+    /// The experience level number's colour and outline.
+    pub xp_bar: [Option<u32>; 2],
+    /// The effect fogs' settings: the fog reads them every frame.
+    pub env: Environment,
+}
+
+impl Default for PackColors {
+    fn default() -> Self {
+        Self {
+            dye_diffuse: [None; 16],
+            dye_text: [None; 16],
+            sheep: [None; 16],
+            redstone: [None; 16],
+            effects: Vec::new(),
+            entity_shadows: true,
+            xp_bar: [None; 2],
+            env: Environment::default(),
+        }
+    }
+}
+
+impl PackColors {
+    /// Whether entities draw their round shadow, as far as the packs say.
+    pub fn entity_shadows(&self) -> bool {
+        self.entity_shadows
+    }
+}
 
 /// 0 is unset, else `1 << 32 | rgb`.
 static DIFFUSE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
@@ -16,6 +89,30 @@ static TEXT: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static SHEEP: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 static REDSTONE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
 
+/// The colours of the pack overlay at `root`, from the installed pack formats; their dye, sheep
+/// and redstone colours go to the draw paths' tables ([`set`]).
+pub fn read(root: &Path) -> PackColors {
+    let formats = crate::pack_hooks::formats();
+    let colors = formats.colors(root).unwrap_or_default();
+    set(&colors);
+    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = formats.item_bars(root);
+    colors
+}
+
+/// The packs' durability bar colours by item (Polytone's item modifiers' `bar_color`).
+pub trait ItemBars: Send + Sync {
+    /// The bar colour (RGB) of `item` at this damage (0 to 1), when a pack sets one.
+    fn color(&self, item: &str, damage: f32) -> Option<u32>;
+}
+
+static ITEM_BARS: RwLock<Option<Arc<dyn ItemBars>>> = RwLock::new(None);
+
+/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
+pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
+    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
+    bars.as_ref()?.color(item, damage)
+}
+
 /// Takes the colours of the packs just loaded (vanilla's where they set none).
 pub fn set(colors: &PackColors) {
     let store = |table: &[AtomicU64; 16], i: usize, color: Option<u32>| {
@@ -24,129 +121,39 @@ pub fn set(colors: &PackColors) {
             Relaxed,
         );
     };
-    for (i, (name, _)) in DYES.iter().enumerate() {
-        store(&DIFFUSE, i, colors.dye(name, "diffuse"));
-        store(&TEXT, i, colors.dye(name, "text"));
-        store(&SHEEP, i, colors.sheep(name));
-        store(&REDSTONE, i, colors.redstone(i as u8));
+    for i in 0..16 {
+        store(&DIFFUSE, i, colors.dye_diffuse[i]);
+        store(&TEXT, i, colors.dye_text[i]);
+        store(&SHEEP, i, colors.sheep[i]);
+        store(&REDSTONE, i, colors.redstone[i]);
     }
 }
 
-/// An item modifier's `bar_color` of the `damage` type: a row of colours picked by the stack's
-/// damage, the first pixel undamaged, the last at full damage (measured on the real mod).
-struct DamageBar {
-    targets: horizon_polytone::Targets,
-    row: Vec<u32>,
-}
-static ITEM_BARS: RwLock<Vec<DamageBar>> = RwLock::new(Vec::new());
-
-/// Reads the packs' item modifiers' durability bar colours under a pack overlay root: an
-/// `<item>_bar.png` alone, or a json whose `bar_color` is `damage` with its `<name>_bar.png` (or
-/// `<name>.png`) beside it. Colormap ids and inline colormaps aren't read.
-pub fn set_item_bars(root: &Path) {
-    let mut bars = Vec::new();
-    for namespace in std::fs::read_dir(root.join("assets"))
-        .into_iter()
-        .flatten()
-        .flatten()
-    {
-        let base = namespace.path().join("polytone/item_modifiers");
-        let mut stack = vec![base.clone()];
-        while let Some(dir) = stack.pop() {
-            for entry in std::fs::read_dir(&dir).into_iter().flatten().flatten() {
-                let path = entry.path();
-                if path.is_dir() {
-                    stack.push(path);
-                } else if let Some(bar) = item_bar(root, &base, &path) {
-                    bars.push(bar);
-                }
-            }
-        }
-    }
-    *ITEM_BARS.write().unwrap_or_else(|e| e.into_inner()) = bars;
-}
-
-fn item_bar(root: &Path, base: &Path, path: &Path) -> Option<DamageBar> {
-    let name = path.file_name()?.to_str()?;
-    let row = |png: &Path| {
-        let (width, _, rgba) = crate::sprites::read_rgba(png).ok()?;
-        let row: Vec<u32> = rgba[..width as usize * 4]
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .map(|p| u32::from(p[0]) << 16 | u32::from(p[1]) << 8 | u32::from(p[2]))
-            .collect();
-        (!row.is_empty()).then_some(row)
-    };
-    if let Some(stem) = name.strip_suffix("_bar.png") {
-        // A json of the same name owns its png.
-        if path.with_file_name(format!("{stem}.json")).exists() {
-            return None;
-        }
-        let relative = path.parent()?.strip_prefix(base).ok()?.join(stem);
-        let namespace = base.parent()?.parent()?.file_name()?.to_str()?;
-        let id = format!("{namespace}:{}", relative.to_str()?.replace('\\', "/"));
-        let targets = horizon_polytone::Targets::parse(None, Some(&id)).ok()?;
-        return Some(DamageBar {
-            targets,
-            row: row(path)?,
-        });
-    }
-    let stem = name.strip_suffix(".json")?;
-    let json: serde_json::Value = horizon_world::json_file::read(path).ok()?;
-    if json.get("bar_color")?.as_str()? != "damage" {
-        return None;
-    }
-    let png = [format!("{stem}_bar.png"), format!("{stem}.png")]
-        .into_iter()
-        .map(|png| path.with_file_name(png))
-        .find(|png| png.exists())?;
-    let relative = path.strip_prefix(root).unwrap_or(path).to_string_lossy();
-    let implicit = horizon_polytone::implicit_id(&relative, "item_modifiers");
-    let targets =
-        horizon_polytone::Targets::parse(json.get("targets"), implicit.as_deref()).ok()?;
-    Some(DamageBar {
-        targets,
-        row: row(&png)?,
-    })
-}
-
-/// A pack's durability bar colour (RGB) for an item at this damage (0 to 1).
-pub fn item_bar_color(item: &str, damage: f32) -> Option<u32> {
-    let bars = ITEM_BARS.read().unwrap_or_else(|e| e.into_inner());
-    let bar = bars
-        .iter()
-        .rev()
-        .find(|b| b.targets.matches(item, |_| false))?;
-    let last = (bar.row.len() - 1) as f32;
-    Some(bar.row[(damage.clamp(0.0, 1.0) * last).round() as usize])
-}
-
-fn read(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
+fn get(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
     let v = table[i & 15].load(Relaxed);
     (v != 0).then_some(v as u32)
 }
 
 /// `DyeColor.getTextureDiffuseColor` (RGB) as the packs draw it.
 pub fn diffuse(dye: usize) -> u32 {
-    read(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
+    get(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
 }
 
 /// `DyeColor.getTextColor` (RGB) as the packs draw it.
 pub fn text(dye: usize) -> u32 {
-    read(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
+    get(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
 }
 
 /// A pack's `RedStoneWireBlock.COLORS` entry for this power (RGB), when it sets one.
 pub fn redstone(power: u8) -> Option<u32> {
-    read(&REDSTONE, usize::from(power))
+    get(&REDSTONE, usize::from(power))
 }
 
 /// `ColorLerper.Type.SHEEP` wool colour: a pack's `sheep.<name>`, else white 0xE6E6E6 and the
 /// others 75% of vanilla's dye (a pack's `dye.*.diffuse` doesn't reach wool).
 pub fn sheep_wool(dye: u8) -> u32 {
     let i = usize::from(dye & 15);
-    if let Some(color) = read(&SHEEP, i) {
+    if let Some(color) = get(&SHEEP, i) {
         return color;
     }
     if i == 0 {
@@ -156,81 +163,3 @@ pub fn sheep_wool(dye: u8) -> u32 {
     let f = |c: u32| ((c as f32 * 0.75).floor() as u32).min(255);
     f(src >> 16 & 255) << 16 | f(src >> 8 & 255) << 8 | f(src & 255)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_pack_recolours_only_what_it_names() {
-        // Dyes no other test draws: the table is process-wide.
-        let dir = std::env::temp_dir().join(format!("pack-dyes-{}", std::process::id()));
-        let polytone = dir.join("assets/obs/polytone");
-        std::fs::create_dir_all(&polytone).unwrap();
-        std::fs::write(
-            polytone.join("colors.json"),
-            r#"{"dye": {"cyan": {"diffuse": "00ff00", "text": "0000ff"}}, "sheep": {"pink": "2040ff"}, "redstone": {"7": "0x123456"}}"#,
-        )
-        .unwrap();
-        set(&PackColors::read(&dir));
-        let (cyan, pink, purple) = (9, 6, 10);
-        assert_eq!(diffuse(cyan), 0x00ff00);
-        assert_eq!(text(cyan), 0x0000ff);
-        assert_eq!(sheep_wool(pink as u8), 0x2040ff);
-        // Wool reads vanilla's dye, not the pack's diffuse: 75% of 0x169C9C.
-        assert_eq!(sheep_wool(cyan as u8), 0x107575);
-        assert_eq!(diffuse(purple), 0x8932B8);
-        assert_eq!(text(purple), 0xA020F0);
-        assert_eq!((redstone(7), redstone(15)), (Some(0x123456), None));
-        set(&PackColors::default());
-        assert_eq!(redstone(7), None);
-        assert_eq!(diffuse(cyan), 0x169C9C);
-        assert_eq!(sheep_wool(pink as u8), 0xB6687F);
-        std::fs::remove_dir_all(&dir).ok();
-    }
-
-    fn png_row(path: &Path, pixels: &[[u8; 3]]) {
-        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
-        let file = std::fs::File::create(path).unwrap();
-        let mut encoder = png::Encoder::new(file, pixels.len() as u32, 1);
-        encoder.set_color(png::ColorType::Rgba);
-        let data: Vec<u8> = pixels
-            .iter()
-            .flat_map(|p| [p[0], p[1], p[2], 255])
-            .collect();
-        encoder
-            .write_header()
-            .unwrap()
-            .write_image_data(&data)
-            .unwrap();
-    }
-
-    #[test]
-    fn a_damage_bar_picks_its_pixel_by_the_stacks_damage() {
-        let dir = std::env::temp_dir().join(format!("pack-bars-{}", std::process::id()));
-        let modifiers = dir.join("assets/minecraft/polytone/item_modifiers");
-        let rgby = [[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 0]];
-        png_row(&modifiers.join("diamond_pickaxe_bar.png"), &rgby);
-        std::fs::write(
-            modifiers.join("tools.json"),
-            r#"{"targets": ["minecraft:iron_axe"], "bar_color": "damage"}"#,
-        )
-        .unwrap();
-        png_row(&modifiers.join("tools_bar.png"), &[[1, 2, 3], [4, 5, 6]]);
-        set_item_bars(&dir);
-        // The real mod: damage 200 of 1561 shows the first pixel, 1400 the last.
-        assert_eq!(
-            item_bar_color("minecraft:diamond_pickaxe", 200.0 / 1561.0),
-            Some(0xFF0000)
-        );
-        assert_eq!(
-            item_bar_color("minecraft:diamond_pickaxe", 1400.0 / 1561.0),
-            Some(0xFFFF00)
-        );
-        assert_eq!(item_bar_color("minecraft:iron_axe", 0.9), Some(0x040506));
-        assert_eq!(item_bar_color("minecraft:diamond_shovel", 0.5), None);
-        set_item_bars(&dir.join("none"));
-        assert_eq!(item_bar_color("minecraft:diamond_pickaxe", 0.5), None);
-        std::fs::remove_dir_all(&dir).ok();
-    }
-}

crates/horizon-client-render/src/particles.rs

@@ -31,6 +31,7 @@ mod native;
 pub mod polytone;
 mod polytone_gpu;
 mod polytone_model;
+mod spawn;
 pub use native::{ParticleController, ParticleUpdate};
 
 /// `ParticleOptions` with the parameters of the option classes used here.
@@ -1222,8 +1223,9 @@ pub struct ParticleLevel<'a> {
     pub collision: &'a BlockCollisionRegistry<'a>,
     /// Local player feet position and vertical velocity (`PlayerCloudParticle`).
     pub player: Option<([f64; 3], f64)>,
+    pub cached_chunk: std::cell::Cell<Option<((i32, i32), Option<&'a crate::chunk::Chunk>)>>,
 }
-impl ParticleLevel<'_> {
+impl<'a> ParticleLevel<'a> {
     fn collide(&self, bb: Aabb, d: [f64; 3]) -> [f64; 3] {
         let mut scene = SceneCollisions {
             world: self.world,
@@ -1231,9 +1233,6 @@ impl ParticleLevel<'_> {
             subject: None,
         };
         let movement = Vec3::new(d[0], d[1], d[2]);
-        // `Entity.collideBoundingBox(null, ...)`: no entity shapes, no border. Where no
-        // block of the swept box's cells can collide, it finds no shape and the
-        // movement stands, as the resolution below would return it.
         if scene.cells_without_collision(bb.expand_towards(movement)) {
             return d;
         }
@@ -1249,38 +1248,46 @@ impl ParticleLevel<'_> {
             p[2].floor() as i32,
         ]
     }
+    #[inline]
+    pub fn block(&self, x: i32, y: i32, z: i32) -> horizon_world::registry::BlockStateId {
+        let (cx, cz) = (x >> 4, z >> 4);
+        let chunk = match self.cached_chunk.get() {
+            Some(((ccx, ccz), c)) if ccx == cx && ccz == cz => c,
+            _ => {
+                let c = self.world.chunks.get(&(cx, cz)).map(|c| c.as_ref());
+                self.cached_chunk.set(Some(((cx, cz), c)));
+                c
+            }
+        };
+        chunk.map_or(self.world.air, |c| c.block(x & 15, y, z & 15))
+    }
     /// The fluid at a block and `FluidState.getHeight`.
     fn fluid(&self, b: [i32; 3]) -> (Fluid, f64) {
-        let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
+        let s = self.facts.get(self.block(b[0], b[1], b[2]));
         if s.fluid == Fluid::None {
             return (Fluid::None, 0.0);
         }
-        let above = self.facts.get(self.world.block(b[0], b[1] + 1, b[2]));
-        let height = if above.fluid == s.fluid {
+        let above = self.facts.get(self.block(b[0], b[1] + 1, b[2]));
+        let h = if above.fluid == s.fluid {
             1.0
         } else {
             f64::from(s.fluid_level) / 9.0
         };
-        (s.fluid, height)
+        (s.fluid, h)
     }
     /// The fluid at a block and whether it is a source (`FluidState.isSource`).
     pub(crate) fn fluid_source(&self, b: [i32; 3]) -> (Fluid, bool) {
-        let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
+        let s = self.facts.get(self.block(b[0], b[1], b[2]));
         (s.fluid, s.fluid_level == 8 && !s.fluid_falling)
     }
     /// `getCollisionShape(...).max(Y, x, z)` for cached shapes.
     fn collision_top(&self, b: [i32; 3], fx: f64, fz: f64) -> f64 {
-        let state = self.world.block(b[0], b[1], b[2]);
+        let state = self.block(b[0], b[1], b[2]);
         match self.collision.cached_shapes().cached_shape(state) {
             Ok(Some(shape)) if !shape.is_empty() => shape.max_at(Axis::Y, fx, fz),
             Ok(Some(_)) => 0.0,
-            _ => {
-                if self.facts.get(state).full_collision {
-                    1.0
-                } else {
-                    0.0
-                }
-            }
+            _ if self.facts.get(state).full_collision => 1.0,
+            _ => 0.0,
         }
     }
 }
@@ -2020,73 +2027,6 @@ impl ParticleEngine {
             (eye[0] - pos[0]).powi(2) + (eye[1] - pos[1]).powi(2) + (eye[2] - pos[2]).powi(2) <= 9.0
         })
     }
-    /// `ClientPacketListener.handleParticleEvent` for `ServerLevel.sendParticles`.
-    pub fn send_particles(
-        &mut self,
-        options: &ParticleOptions,
-        at: [f64; 3],
-        spread: [f64; 3],
-        speed: f64,
-        count: u32,
-    ) {
-        if count == 0 {
-            let v = [speed * spread[0], speed * spread[1], speed * spread[2]];
-            self.add(options, at, v);
-            return;
-        }
-        for _ in 0..count {
-            let r = &mut self.random;
-            let p = [
-                at[0] + r.next_gaussian() * spread[0],
-                at[1] + r.next_gaussian() * spread[1],
-                at[2] + r.next_gaussian() * spread[2],
-            ];
-            let v = [
-                r.next_gaussian() * speed,
-                r.next_gaussian() * speed,
-                r.next_gaussian() * speed,
-            ];
-            self.add(options, p, v);
-        }
-    }
-    /// `ParticleEngine.createParticle`: always spawned, but `ParticleEngine.add`
-    /// drops a spore blossom air particle once `ParticleLimit.SPORE_BLOSSOM` is full.
-    pub fn create(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
-        if let Some(requests) = &mut self.created_requests {
-            requests.push((options.clone(), p, v));
-            return;
-        }
-        let seed = self.seeds.next_long();
-        if let Some(mut particle) = self.make(options, p, v, seed) {
-            *self.made.entry(options.ty.name()).or_default() += 1;
-            // Resource packs' Polytone particle modifiers (#11486), once as it spawns.
-            if let Some(registry) = &self.polytone
-                && registry.modifies_particles()
-            {
-                let id = match &options.mod_particle {
-                    Some(name) => name.clone(),
-                    None => format!("minecraft:{}", options.ty.name()),
-                };
-                polytone::modify(registry, &id, options.source.as_deref(), &mut particle);
-            }
-            // The provider has drawn, so rejecting here keeps vanilla's RNG order.
-            // shortcut: counts live plus queued particles by scanning instead of
-            // vanilla's counted map; use a counter if spore spawning shows in profiles.
-            if particle.ty == ParticleType::SporeBlossomAir
-                && self.particles.len() + self.pending.len() >= SPORE_BLOSSOM_LIMIT
-                && self
-                    .particles
-                    .iter()
-                    .chain(self.pending.iter())
-                    .filter(|q| q.ty == ParticleType::SporeBlossomAir)
-                    .count()
-                    >= SPORE_BLOSSOM_LIMIT
-            {
-                return;
-            }
-            self.pending.push(particle);
-        }
-    }
     /// How many particles of each type were made so far.
     pub fn made(&self) -> &std::collections::BTreeMap<&'static str, u64> {
         &self.made
@@ -4052,15 +3992,12 @@ impl ParticleEngine {
             }
             Behaviour::Lava => {
                 p.base_tick(level);
-                if !p.removed {
-                    let odds = p.age as f32 / p.lifetime as f32;
-                    if p.random.next_float() > odds {
-                        self.add(
-                            &ParticleOptions::simple(ParticleType::Smoke),
-                            p.position,
-                            p.velocity,
-                        );
-                    }
+                if !p.removed && p.random.next_float() > p.age as f32 / p.lifetime as f32 {
+                    self.add(
+                        &ParticleOptions::simple(ParticleType::Smoke),
+                        p.position,
+                        p.velocity,
+                    );
                 }
             }
             Behaviour::Crit => {
@@ -4144,9 +4081,7 @@ impl ParticleEngine {
                     *c *= f64::from(0.98f32);
                 }
                 if p.on_ground {
-                    if p.random.next_float() < 0.5 {
-                        p.removed = true;
-                    }
+                    p.removed |= p.random.next_float() < 0.5;
                     p.velocity[0] *= f64::from(0.7f32);
                     p.velocity[2] *= f64::from(0.7f32);
                 }
@@ -4186,13 +4121,10 @@ impl ParticleEngine {
             } => {
                 p.base_tick(level);
                 let (fluid, source) = level.fluid_source(ParticleLevel::block_at(p.position));
-                if !(p.removed || (fluid == Fluid::Water && source)) {
-                    p.removed = true;
-                }
-                if !p.removed && p.position[1] >= y_end {
-                    p.removed = true;
-                }
-                if !p.removed && p.position[1] <= y_prev {
+                if !(fluid == Fluid::Water && source)
+                    || p.position[1] >= y_end
+                    || p.position[1] <= y_prev
+                {
                     p.removed = true;
                 }
                 // randomHorizontalWiggling, then a second, horizontal move.
@@ -4216,9 +4148,8 @@ impl ParticleEngine {
                 p.base_tick(level);
                 self.sprite_from_age(p);
                 if p.age as f32 > fade_start {
-                    let frames_since_fade_out_start = p.age as f32 - fade_start;
                     p.rgba[3] =
-                        (p.lifetime as f32 - frames_since_fade_out_start) / p.lifetime as f32;
+                        (p.lifetime as f32 - (p.age as f32 - fade_start)) / p.lifetime as f32;
                 }
             }
             Behaviour::NoxiousGasCloud => {
@@ -4682,7 +4613,7 @@ impl ParticleEngine {
                     self.sprite_from_age(p);
                     half(p);
                     let b = ParticleLevel::block_at(p.position);
-                    if level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
+                    if level.facts.is_air(level.block(b[0], b[1], b[2])) {
                         p.velocity[1] -= f64::from(0.0074f32);
                     }
                 }
@@ -4690,7 +4621,7 @@ impl ParticleEngine {
             Behaviour::Firefly => {
                 p.base_tick(level);
                 let b = ParticleLevel::block_at(p.position);
-                if !level.facts.is_air(level.world.block(b[0], b[1], b[2])) {
+                if !level.facts.is_air(level.block(b[0], b[1], b[2])) {
                     p.removed = true;
                 } else {
                     p.rgba[3] = fade_amount(p.lifetime_progress(p.age as f32), 0.3, 0.5);
@@ -5154,11 +5085,12 @@ fn hdr_tier(ty: ParticleType) -> u8 {
 }
 /// `Particle.LifetimeAlpha.currentAlphaForAge`.
 fn lifetime_alpha(a: [f32; 4], age: i32, lifetime: i32, partial: f32) -> f32 {
-    if (a[0] - a[1]).abs() < 1.0e-5 {
-        return a[0];
-    }
     let t = ((age as f32 + partial) / lifetime as f32 - a[2]) / (a[3] - a[2]);
-    a[0] + (a[1] - a[0]) * t.clamp(0.0, 1.0)
+    if (a[0] - a[1]).abs() < 1.0e-5 {
+        a[0]
+    } else {
+        a[0] + (a[1] - a[0]) * t.clamp(0.0, 1.0)
+    }
 }
 
 struct Starter {
@@ -5589,6 +5521,7 @@ mod tests {
             facts: &facts,
             collision: &collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
         engine.set_sprites.push(vec![10, 11, 12]);
@@ -5680,6 +5613,7 @@ mod tests {
             facts: &facts,
             collision: &collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = ParticleEngine::new(Path::new(""), &HashMap::new(), &HashSet::new());
         let mut particle = Particle::blank(ParticleType::Smoke, [0.0; 3]);

crates/horizon-client-render/src/particles/native.rs

@@ -124,6 +124,7 @@ mod tests {
             facts: &facts,
             collision: &collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut e = engine();
         let mut p = e

crates/horizon-client-render/src/particles/polytone.rs

@@ -490,14 +490,14 @@ enum Subject<'a> {
 }
 
 /// What one expression runs against: its subject, the frame and the level.
-struct Ctx<'a> {
+struct Ctx<'a, 'l> {
     subject: Subject<'a>,
     random: &'a mut LegacyRandom,
     custom: &'a mut f64,
     customs: &'a mut BTreeMap<String, f64>,
     frame: &'a Frame,
     registry: &'a Registry,
-    level: Option<&'a ParticleLevel<'a>>,
+    level: Option<&'a ParticleLevel<'l>>,
     blocks: Vec<[i32; 3]>,
 }
 
@@ -515,7 +515,7 @@ fn axis(name: &str) -> usize {
     usize::from(name.as_bytes()[0] - b'x')
 }
 
-impl Ctx<'_> {
+impl Ctx<'_, '_> {
     fn position(&self) -> [f64; 3] {
         match &self.subject {
             Subject::Particle(p) => p.position,
@@ -683,7 +683,7 @@ impl Ctx<'_> {
     }
 }
 
-impl Host for Ctx<'_> {
+impl Host for Ctx<'_, '_> {
     fn root(&mut self, root: Root) -> V {
         match root {
             Root::Object => V::Object(SELF),
@@ -1662,6 +1662,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         // Air has no emitters; the torch fires its first emitter only.
@@ -1701,6 +1702,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_animate(&level, [1, 64, 1]);
@@ -1722,6 +1724,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_animate(&level, [1, 64, 1]);
@@ -1767,6 +1770,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let registry = Registry::read(&root, Default::default(), blocks);
         let frame = registry.frame.clone();
@@ -1820,6 +1824,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let registry = Registry::read(&root, Default::default(), blocks);
         let mut engine = engine(registry);
@@ -1853,6 +1858,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         let rect = crate::hud::Rect {
@@ -1905,6 +1911,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         let rect = crate::hud::Rect {
@@ -1966,6 +1973,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_entity(&level, "minecraft:player", [1.0, 70.0, 1.0]);
@@ -2014,6 +2022,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         let rect = crate::hud::Rect {
@@ -2080,6 +2089,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let registry = Arc::new(Registry::read(&root, Default::default(), blocks));
         // The chunk's biome is id 0: plains, whose foliage is #336699.
@@ -2198,6 +2208,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         engine.polytone_entity(&level, "minecraft:player", [1.5, 70.0, 1.5]);
@@ -2276,6 +2287,7 @@ mod tests {
             facts: &scene.facts,
             collision: &scene.collision,
             player: None,
+            cached_chunk: std::cell::Cell::new(None),
         };
         let mut engine = engine(Registry::read(&root, Default::default(), blocks));
         // The test chunk's biome is the table's first: a cold one first, then a warm one.

crates/horizon-client-render/src/particles/spawn.rs

@@ -0,0 +1,73 @@
+//! Where particles come into the engine: a server's particle packet and a single particle made
+//! where the game asks for one.
+use super::*;
+
+impl ParticleEngine {
+    /// `ClientPacketListener.handleParticleEvent` for `ServerLevel.sendParticles`.
+    pub fn send_particles(
+        &mut self,
+        options: &ParticleOptions,
+        at: [f64; 3],
+        spread: [f64; 3],
+        speed: f64,
+        count: u32,
+    ) {
+        if count == 0 {
+            let v = [speed * spread[0], speed * spread[1], speed * spread[2]];
+            self.add(options, at, v);
+            return;
+        }
+        for _ in 0..count {
+            let r = &mut self.random;
+            let p = [
+                at[0] + r.next_gaussian() * spread[0],
+                at[1] + r.next_gaussian() * spread[1],
+                at[2] + r.next_gaussian() * spread[2],
+            ];
+            let v = [
+                r.next_gaussian() * speed,
+                r.next_gaussian() * speed,
+                r.next_gaussian() * speed,
+            ];
+            self.add(options, p, v);
+        }
+    }
+    /// `ParticleEngine.createParticle`: always spawned, but `ParticleEngine.add`
+    /// drops a spore blossom air particle once `ParticleLimit.SPORE_BLOSSOM` is full.
+    pub fn create(&mut self, options: &ParticleOptions, p: [f64; 3], v: [f64; 3]) {
+        if let Some(requests) = &mut self.created_requests {
+            requests.push((options.clone(), p, v));
+            return;
+        }
+        let seed = self.seeds.next_long();
+        if let Some(mut particle) = self.make(options, p, v, seed) {
+            *self.made.entry(options.ty.name()).or_default() += 1;
+            // Resource packs' Polytone particle modifiers (#11486), once as it spawns.
+            if let Some(registry) = &self.polytone
+                && registry.modifies_particles()
+            {
+                let id = match &options.mod_particle {
+                    Some(name) => name.clone(),
+                    None => format!("minecraft:{}", options.ty.name()),
+                };
+                polytone::modify(registry, &id, options.source.as_deref(), &mut particle);
+            }
+            // The provider has drawn, so rejecting here keeps vanilla's RNG order.
+            // shortcut: counts live plus queued particles by scanning instead of
+            // vanilla's counted map; use a counter if spore spawning shows in profiles.
+            if particle.ty == ParticleType::SporeBlossomAir
+                && self.particles.len() + self.pending.len() >= SPORE_BLOSSOM_LIMIT
+                && self
+                    .particles
+                    .iter()
+                    .chain(self.pending.iter())
+                    .filter(|q| q.ty == ParticleType::SporeBlossomAir)
+                    .count()
+                    >= SPORE_BLOSSOM_LIMIT
+            {
+                return;
+            }
+            self.pending.push(particle);
+        }
+    }
+}

crates/horizon-client-render/src/particles/tick_bench.rs

@@ -93,6 +93,7 @@ fn particle_tick_cost() {
         facts: &facts,
         collision: &collision,
         player: None,
+        cached_chunk: std::cell::Cell::new(None),
     };
     let ty = |name: &str| ParticleType::from_name(name).unwrap();
     let (fx, fy, fz) = (0.5, f64::from(FLOOR_Y + 5), 20.5);

crates/horizon-client-render/src/pvp.rs

@@ -4,7 +4,6 @@
 //! Horizon Settings > PvP & HUD. Every option is off by default, so the game looks like
 //! vanilla until the player changes one, and none of them shows anything vanilla doesn't
 //! already tell the player.
-use horizon_hooks::look::Look;
 
 /// Colours the PvP options pick from. `Inverted` is vanilla's crosshair blend: the colour
 /// under it, inverted.
@@ -264,6 +263,15 @@ impl ViewWeather {
         Self::ALL.into_iter().find(|c| c.name() == s)
     }
 }
+/// The day time this player sees with `fixed` set: the same day (the moon's phase follows the
+/// world's), at that time.
+pub fn view_day_time(world: i64, fixed: Option<ViewTime>) -> i64 {
+    match fixed {
+        Some(t) => world.div_euclid(24000) * 24000 + t.day_time(),
+        None => world,
+    }
+}
+
 /// The crosshair's look. Its defaults draw vanilla's: a 15-pixel cross, one pixel thick,
 /// inverting what is under it.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -520,36 +528,24 @@ impl Hit {
     }
 }
 
+/// What the renderer reads of these options each frame (`FrameInputs::pvp`); the default is
+/// vanilla's look.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct Frame {
+    /// The block outline's stroke ([`Outline::stroke`]).
+    pub outline: Option<(u32, f32)>,
+    /// The hurt overlay texel ([`Hit::texel`]), 0 for vanilla's.
+    pub hurt_texel: u32,
+    /// The glint's colour ([`Tweaks::glint_texel`]), 0 for vanilla's.
+    pub glint: u32,
+}
 impl Pvp {
-    /// What the engine reads of these options (`horizon_hooks::look`): all it draws differently.
-    /// Sets PvP & HUD's fields of `look`, the others' stay.
-    pub fn apply(&self, look: &mut Look) {
-        let (c, t) = (self.combat, self.tweaks);
-        look.legacy_pose = c.legacy;
-        look.hide_attack_indicator = c.legacy && !c.indicator;
-        look.mute_attack_sounds = c.legacy && c.sounds;
-        look.hide_attack_particles = c.legacy;
-        look.frame.outline = self.outline.stroke();
-        look.frame.hurt_texel = self.hit.texel();
-        look.frame.glint = t.glint_texel();
-        look.shield_size = t.shield_size;
-        look.totem_scale = f32::from(t.totem_size) / 100.0;
-        look.fire_lower = f32::from(t.fire_lower) / 100.0;
-        look.clear_lava = t.clear_lava;
-        look.clear_water = t.clear_water;
-        look.chat.timestamps = self.chat.timestamps;
-        look.chat.compact = self.chat.compact;
-        look.chat.copy = self.chat.copy;
-        look.chat.search = self.chat.search;
-        look.hide_effect_icons = self.hud.effects;
-        look.time_of_day = t.time.map(ViewTime::day_time);
-        look.weather = t.weather.map(ViewWeather::levels);
-    }
-    /// [`Pvp::apply`] on vanilla's look.
-    pub fn look(&self) -> Look {
-        let mut look = Look::default();
-        self.apply(&mut look);
-        look
+    pub fn frame(&self) -> Frame {
+        Frame {
+            outline: self.outline.stroke(),
+            hurt_texel: self.hit.texel(),
+            glint: self.tweaks.glint_texel(),
+        }
     }
 }
 
@@ -745,6 +741,15 @@ pub struct ChatOptions {
     /// Ctrl+F in the chat searches the chat's messages.
     pub search: bool,
 }
+impl ChatOptions {
+    /// What `chat::Chat` lays its lines out with.
+    pub fn qol(&self) -> crate::chat::ChatQol {
+        crate::chat::ChatQol {
+            timestamps: self.timestamps,
+            compact: self.compact,
+        }
+    }
+}
 
 /// Combat feel (`docs/pvp.md`): how fights look. Legacy draws them as 1.8.9 did; what the
 /// game sends to a server never changes, so a vanilla server and its anticheat see 26.3.
@@ -761,6 +766,21 @@ pub struct Combat {
     /// (`horizon_client::legacy_combat`). Never used as a client of a server.
     pub rules: bool,
 }
+impl Combat {
+    /// Whether this client leaves out sound `name` a server sent: under Legacy with its
+    /// sounds, the `entity.player.attack.*` family (strong, weak, crit, sweep, knockback,
+    /// nodamage), which 1.9 brought with the attack cooldown.
+    pub fn mutes_sound(&self, name: &str) -> bool {
+        let name = name.strip_prefix("minecraft:").unwrap_or(name);
+        self.legacy && self.sounds && name.starts_with("entity.player.attack.")
+    }
+    /// Whether this client leaves out particles of `ty` a server sent: under Legacy, the
+    /// sweep and the damage hearts, which 1.9 brought (1.8.9's hits show crits only).
+    pub fn hides_particle(&self, ty: crate::particles::ParticleType) -> bool {
+        use crate::particles::ParticleType as T;
+        self.legacy && matches!(ty, T::SweepAttack | T::DamageIndicator)
+    }
+}
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct Pvp {
@@ -1687,6 +1707,18 @@ mod tests {
         assert_eq!(fresh.extras.pvp.tweaks.fire_lower, PRESET_FIRE_LOWER);
     }
 
+    #[test]
+    fn a_fixed_time_keeps_the_worlds_day() {
+        // Day 9 at 5000: the moon's phase (the day number) stays, the time of day is the chosen.
+        let world = 9 * 24000 + 5000;
+        assert_eq!(view_day_time(world, None), world);
+        assert_eq!(
+            view_day_time(world, Some(ViewTime::Midnight)),
+            9 * 24000 + 18000
+        );
+        assert_eq!(view_day_time(-100, Some(ViewTime::Noon)), -24000 + 6000);
+    }
+
     #[test]
     fn the_glint_colour_reaches_the_shaders_as_rgb_bytes() {
         let mut t = Tweaks::default();
@@ -1773,33 +1805,31 @@ mod tests {
         }
     }
 
-    /// Legacy leaves out what 1.9 added to a hit: its sounds only with the sounds option, the
-    /// sweep and hearts always; the indicator stays when kept. Modern changes nothing.
     #[test]
-    fn combat_feel_reaches_the_look() {
-        let mut pvp = Pvp::default();
-        assert_eq!(pvp.look(), Look::default(), "vanilla's look");
-        let strong = "minecraft:entity.player.attack.strong";
-        pvp.combat.legacy = true;
-        let look = pvp.look();
-        assert!(look.legacy_pose && look.hide_attack_particles && look.hide_attack_indicator);
-        assert!(!look.mutes_sound(strong), "only with the sounds option");
-        pvp.combat.sounds = true;
-        pvp.combat.indicator = true;
-        let look = pvp.look();
-        assert!(look.mutes_sound(strong) && !look.hide_attack_indicator);
-    }
-
-    #[test]
-    fn view_time_weather_and_sizes_reach_the_look() {
-        let mut pvp = Pvp::default();
-        pvp.tweaks.time = Some(ViewTime::Midnight);
-        pvp.tweaks.weather = Some(ViewWeather::Thunder);
-        pvp.tweaks.totem_size = 50;
-        pvp.tweaks.fire_lower = 40;
-        let look = pvp.look();
-        assert_eq!(look.day_time(9 * 24000 + 5000), 9 * 24000 + 18000);
-        assert_eq!(look.weather, Some((1.0, 1.0)));
-        assert_eq!((look.totem_scale, look.fire_lower), (0.5, 0.4));
+    fn legacy_leaves_out_what_1_9_added_to_a_hit() {
+        use crate::particles::ParticleType as T;
+        let modern = Combat::default();
+        let legacy = Combat {
+            legacy: true,
+            ..Combat::default()
+        };
+        let sounds = Combat {
+            sounds: true,
+            ..legacy
+        };
+        for name in [
+            "minecraft:entity.player.attack.strong",
+            "entity.player.attack.sweep",
+            "minecraft:entity.player.attack.nodamage",
+        ] {
+            assert!(sounds.mutes_sound(name), "{name}");
+            assert!(!legacy.mutes_sound(name), "only with the sounds option");
+            assert!(!modern.mutes_sound(name));
+        }
+        // 1.8.9 had the hurt sound: it stays.
+        assert!(!sounds.mutes_sound("minecraft:entity.player.hurt"));
+        assert!(legacy.hides_particle(T::SweepAttack) && legacy.hides_particle(T::DamageIndicator));
+        assert!(!legacy.hides_particle(T::Crit) && !legacy.hides_particle(T::EnchantedHit));
+        assert!(!modern.hides_particle(T::SweepAttack));
     }
 }

crates/horizon-client-render/src/settings.rs

@@ -337,13 +337,6 @@ impl Settings {
             .and_then(|mode| self.video_modes.iter().position(|m| *m == mode))
             .map_or(-1, |i| i as i32)
     }
-    /// Loads only the crates' settings stores (`horizon_hooks::settings`) from the files next to
-    /// `path`, into the seat whose turn it is (`horizon_hooks::seat`): a splitscreen player whose
-    /// settings were made from P1's rather than loaded.
-    pub fn load_stores(path: &Path) {
-        let dir = path.parent();
-        horizon_hooks::settings::engine::load(&mut |file| fs::read_to_string(dir?.join(file)).ok());
-    }
     pub fn load(path: &Path) -> Self {
         let mut horizon = path
             .parent()
@@ -871,6 +864,8 @@ pub enum Opt {
     PadGameplayGuide,
     /// `options.modelPart.*`: one skin layer (index into `options_file::MODEL_PARTS`).
     ModelPart(usize),
+    /// A slider of a page a crate registered (`horizon_hooks::pages`): (page, row).
+    Page(usize, usize),
     /// 3D skin layers: the player's outer layer as extruded slabs.
     SkinLayers3d,
     MainHand,

crates/horizon-client-render/src/signs.rs

@@ -192,7 +192,12 @@ impl SignData {
         let side = |t: Option<&Tag>| -> SignText {
             let mut out = SignText::default();
             let Some(t) = t else { return out };
-            if let Some(Tag::List(messages)) = t.get("messages") {
+            if let Some(messages) = t.get("messages") {
+                // `SignText.CODEC` reads a side all or nothing: a messages
+                // field that is not a list leaves the side empty.
+                let Tag::List(messages) = messages else {
+                    return SignText::default();
+                };
                 for (i, m) in messages.iter().take(4).enumerate() {
                     out.lines[i] = component_text(m);
                     out.click[i] = click_event(m);
@@ -307,6 +312,27 @@ pub fn editor_sprite(folder: &str, wood: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
+    /// `SignText.CODEC` reads messages as a list: a string field fails the
+    /// whole side, taking its colour and glow with it.
+    #[test]
+    fn messages_that_are_not_a_list_load_an_empty_side() {
+        let tag = Tag::compound([(
+            "front_text",
+            Tag::compound([
+                ("messages", Tag::String("not a list".into())),
+                ("color", Tag::String("red".into())),
+                ("has_glowing_text", Tag::Byte(1)),
+            ]),
+        )]);
+        let mut decoded = SignData::default();
+        decoded.decode(&tag);
+        assert_eq!(
+            decoded.front,
+            SignText::default(),
+            "a failed message list takes the side's colour and glow with it"
+        );
+    }
+
     #[test]
     fn waxed_and_glowing_text_take_any_number() {
         let tag = Tag::compound([

crates/horizon-client-render/src/ui.rs

@@ -1238,6 +1238,9 @@ pub struct EditBox {
     /// Grey completion shown after the text (EditBox.setSuggestion).
     pub suggestion: Option<String>,
     pub text_color: u32,
+    /// `EditBox.setCentered`: the text starts in the middle of the box's
+    /// width, not at its left edge (`BookSignScreen`'s title).
+    pub centered: bool,
     /// `EditBox.textColorUneditable`: the colour of a box `setEditable(false)`
     /// made read-only, which still shows its value and caret.
     pub text_color_uneditable: u32,
@@ -1536,6 +1539,7 @@ impl EditBox {
             focused_at: Instant::now(),
             suggestion: None,
             text_color: rgba(224, 224, 224, 255),
+            centered: false,
             text_color_uneditable: rgba(112, 112, 112, 255),
             editable: true,
             message: String::new(),
@@ -1559,6 +1563,16 @@ impl EditBox {
             self.y
         }
     }
+    /// `EditBox.updateTextPosition`: where the text starts, `(width - text
+    /// width) / 2` in for a centred box (vanilla's `textX`), else at
+    /// `text_x` (4 in from a border).
+    pub fn text_start_x(&self, text_width: f32) -> f32 {
+        if self.centered {
+            self.x + ((self.width - text_width) / 2.0).floor()
+        } else {
+            self.text_x()
+        }
+    }
     pub fn reset_blink(&mut self) {
         self.focused_at = Instant::now();
     }
@@ -1641,8 +1655,13 @@ impl EditBox {
     /// EditBox.findClickedPositionInText: the character boundary under GUI `x`.
     pub fn position_at(&mut self, atlas: &HudAtlas, x: f32) -> usize {
         self.layout(atlas);
-        let room = (x.floor() - self.text_x()).min(self.inner_width());
         let rest: String = self.value.chars().skip(self.display).collect();
+        let shown: String = rest
+            .chars()
+            .take(atlas.font.fit(&rest, self.inner_width()))
+            .collect();
+        let start = self.text_start_x(atlas.font.width_text(&Text::literal(shown.as_str())));
+        let room = (x.floor() - start).min(self.inner_width());
         self.display + atlas.font.fit(&rest, room)
     }
     /// EditBox.onClick: the cursor to the pointer, extending the selection
@@ -1849,7 +1868,12 @@ impl EditBox {
                 ),
             }
         };
-        let (tx, ty) = (self.text_x(), self.text_y());
+        let start = if self.centered {
+            self.text_start_x(atlas.font.width_text(&Text::literal(displayed.as_str())))
+        } else {
+            self.text_x()
+        };
+        let (tx, ty) = (start, self.text_y());
         let mut draw_x = tx;
         if !displayed.is_empty() {
             let half = if on_screen {
@@ -2650,4 +2674,19 @@ mod tests {
         assert!(edit.key(winit::keyboard::KeyCode::Backspace, false, false));
         assert_eq!(edit.value, "name");
     }
+
+    /// `EditBox.setCentered` (`BookSignScreen`'s title box): with the flag the
+    /// text starts `(width - text width) / 2` in, which is also where a click
+    /// maps; without it the text starts at the box's left edge.
+    #[test]
+    fn a_centred_box_starts_its_text_in_the_middle() {
+        let mut edit = EditBox::new(10.0, 0.0, 114.0, 9.0);
+        edit.bordered = false;
+        assert_eq!(edit.text_start_x(0.0), 10.0);
+        edit.centered = true;
+        assert_eq!(edit.text_start_x(0.0), 67.0);
+        assert_eq!(edit.text_start_x(18.0), 58.0);
+        // (114 - 5) / 2 = 54.5, rounded down.
+        assert_eq!(edit.text_start_x(5.0), 64.0);
+    }
 }

crates/horizon-client/Cargo.toml

@@ -39,8 +39,6 @@ horizon-chat-filter = { path = "../horizon-chat-filter" }
 horizon-shaders = { path = "../horizon-shaders" }
 # Horizon's own shader packs: the format, the stages and the check (docs/shaders.md).
 horizon-shader-api = { path = "../horizon-shader-api" }
-# Play with Friends: invite codes and their tunnel; the `friends` feature.
-horizon-friends = { path = "../horizon-friends", optional = true }
 # The narrator (GameNarrator): text-to-speech of chat, system messages and screens.
 horizon-narrator = { path = "../horizon-narrator" }
 # Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
@@ -119,15 +117,14 @@ audio = ["horizon-client-render/audio", "horizon-client-lib/audio"]
 controllers = ["horizon-client-lib/controllers", "dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
 # Horizon's own extras over the vanilla game, for a fork that wants them out (docs/forking.md):
 # cosmetics and emotes, the "Horizon player" presence, the official server added to
-# the server list, the Horizon Settings and Mods pages, Discord and Play with Friends. Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
+# the server list, the Horizon Settings and Mods pages, Discord and Play with Friends, and ray
+# tracing on request (`HORIZON_RAY_TRACING=1`). Players always get them; there is no switch. `grep -rn horizon-extras crates/` lists
 # every place it gates. Without it (`--no-default-features --features audio,controllers`) the
 # client is best effort: CI builds only the default.
-horizon-extras = ["discord", "friends"]
+horizon-extras = ["horizon-client-lib/horizon-extras", "horizon-client-render/horizon-extras", "discord"]
 # Online extras a server or a port can leave out; the server build has none of them. "Playing Horizon"
 # on Discord (game/discord.rs).
 discord = ["horizon-client-lib/discord"]
-# Play with Friends: sharing a world behind an invite code (game/friends.rs) and joining one.
-friends = ["horizon-client-lib/friends", "dep:horizon-friends"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace", "horizon-client-lib/rng-trace"]
 # Rust's allocations go to the system heap instead of mimalloc, where heap profilers that replace

crates/horizon-client/assets/horizon/lang/af_za.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Herbegin die speletjie om %s toe te pas: hulle voeg blokke, items of wêreldgenerering by.",
   "horizon.shader_options.profile": "Profiel",
   "horizon.agent.copy_details": "Kopieer verbindingbesonderhede",
-  "horizon.multiplayer.join": "Sluit aan",
   "horizon.multiplayer.cancel_reconnecting": "Kanselleer Herkoppel",
-  "horizon.multiplayer.join_friend": "Sluit aan by 'n Vriend",
-  "horizon.multiplayer.invite_code": "Uitnodigingskode",
-  "horizon.multiplayer.relay": "Aflos (opsioneel)",
   "Preset": "Vooraf ingesteld",
   "LOD Distance": "LOD Afstand",
   "Far Detail": "Verre Detail",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Vanlyn profiele behoort aan hierdie geval",
   "horizon.splitscreen.profiles.move": "Beweeg waar jy speel",
   "horizon.splitscreen.profiles.move_place": "Beweeg waar jy speel: %s",
-  "horizon.friends.title": "Speel met vriende",
-  "horizon.friends.hint": "Vriende plak die kode na die titelskerm se Vriende-knoppie, in Direkte verbinding, of op die lanseerder se Speel-bladsy.",
-  "horizon.friends.copied": "Gekopieer",
-  "horizon.friends.copy_code": "Kopieer kode",
-  "horizon.friends.stop_sharing": "Hou op deel",
-  "horizon.friends.none_yet": "Nog geen vriende hier nie.",
-  "horizon.friends.here_now": "Hier nou: %s",
-  "horizon.friends.share_intro": "Deel hierdie wêreld agter 'n uitnodigingskode: dit maak oop na LAN, en vriende op die internet sluit aan met die kode. Geen bediener van ons is betrokke nie.",
-  "horizon.friends.start_sharing": "Begin deel",
-  "horizon.friends.troubleshooting": "Foutsporing …",
-  "horizon.friends.stopped": "Het opgehou om die uitnodigingkode te deel.",
-  "horizon.friends.short_code_changed": "Iemand het aanhou om 'n verkeerde kort kode te probeer, so dit het verander.",
-  "horizon.friends.wrong_code": "Iemand het 'n verkeerde kode probeer.",
-  "horizon.friends.relay_stopped": "Te veel verkeerde kort kodes, so die aflos is af totdat jy weer deel. Vriende kan steeds met die volle kode aansluit.",
-  "horizon.friends.code_ready": "Jou uitnodigingskode is gereed: Speletjie-kieslys, Speel met vriende. Kopieer dit en stuur dit aan jou vriende.",
-  "horizon.friends.share_failed": "Kon nie die wêreld deel nie: %s",
-  "horizon.friends.finding_route": "Vind tans hoe vriende jou kan bereik …",
   "horizon.osk.shift": "Verskuiwing",
   "horizon.osk.space": "Ruimte",
   "horizon.osk.delete": "Vee uit",

crates/horizon-client/assets/horizon/lang/ar_sa.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "أعد تشغيل اللعبة لتطبيق %s: فهي تضيف كتلًا أو عناصر أو توليد عالم.",
   "horizon.shader_options.profile": "الملف الشخصي",
   "horizon.agent.copy_details": "نسخ تفاصيل الاتصال",
-  "horizon.multiplayer.join": "انضم",
   "horizon.multiplayer.cancel_reconnecting": "إلغاء إعادة الاتصال",
-  "horizon.multiplayer.join_friend": "انضم إلى صديق",
-  "horizon.multiplayer.invite_code": "رمز الدعوة",
-  "horizon.multiplayer.relay": "التتابع (اختياري)",
   "Preset": "محددة مسبقا",
   "LOD Distance": "مسافة اللد",
   "Far Detail": "تفاصيل بعيدة",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "تنتمي الملفات الشخصية غير المتصلة بالإنترنت إلى هذه الحالة",
   "horizon.splitscreen.profiles.move": "تحرك حيث تلعب",
   "horizon.splitscreen.profiles.move_place": "تحرك حيث تلعب: %s",
-  "horizon.friends.title": "العب مع الأصدقاء",
-  "horizon.friends.hint": "يقوم الأصدقاء بلصق الرمز بعد زر الأصدقاء على شاشة العنوان، أو في الاتصال المباشر، أو على صفحة التشغيل الخاصة بالمشغل.",
-  "horizon.friends.copied": "منقول",
-  "horizon.friends.copy_code": "نسخ الرمز",
-  "horizon.friends.stop_sharing": "توقف عن المشاركة",
-  "horizon.friends.none_yet": "لا يوجد أصدقاء هنا بعد.",
-  "horizon.friends.here_now": "هنا الآن: %s",
-  "horizon.friends.share_intro": "شارك هذا العالم خلف رمز الدعوة: فهو يفتح على شبكة LAN، وينضم الأصدقاء على الإنترنت باستخدام الرمز. لا يوجد خادم خاص بنا متورط.",
-  "horizon.friends.start_sharing": "ابدأ المشاركة",
-  "horizon.friends.troubleshooting": "استكشاف الأخطاء وإصلاحها...",
-  "horizon.friends.stopped": "تم إيقاف مشاركة رمز الدعوة.",
-  "horizon.friends.short_code_changed": "استمر شخص ما في تجربة رمز قصير خاطئ، لذلك تغير.",
-  "horizon.friends.wrong_code": "حاول شخص ما رمزا خاطئا.",
-  "horizon.friends.relay_stopped": "رموز قصيرة خاطئة كثيرة، لذا أُوقف التتابع حتى تشارك مجددًا. يمكن للأصدقاء الانضمام بالرمز الكامل.",
-  "horizon.friends.code_ready": "رمز الدعوة الخاص بك جاهز: قائمة الألعاب، العب مع الأصدقاء. انسخها وأرسلها إلى أصدقائك.",
-  "horizon.friends.share_failed": "لا يمكن مشاركة العالم: %s",
-  "horizon.friends.finding_route": "التعرف على كيفية وصول الأصدقاء إليك...",
   "horizon.osk.shift": "التحول",
   "horizon.osk.space": "الفضاء",
   "horizon.osk.delete": "حذف",

crates/horizon-client/assets/horizon/lang/az_az.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "%s tətbiq etmək üçün oyunu yenidən başladın: onlar bloklar, əşyalar və ya dünya yaradılması əlavə edir.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Bağlantı təfərrüatlarını kopyalayın",
-  "horizon.multiplayer.join": "Qoşulun",
   "horizon.multiplayer.cancel_reconnecting": "Yenidən qoşulmanı ləğv edin",
-  "horizon.multiplayer.join_friend": "Dosta Qoşulun",
-  "horizon.multiplayer.invite_code": "Dəvət Kodu",
-  "horizon.multiplayer.relay": "Rele (isteğe bağlı)",
   "Preset": "Əvvəlcədən təyin",
   "LOD Distance": "LOD məsafəsi",
   "Far Detail": "Uzaq Detal",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Oflayn profillər bu instansiyaya aiddir",
   "horizon.splitscreen.profiles.move": "Oynadığınız yerdə hərəkət edin",
   "horizon.splitscreen.profiles.move_place": "Oynadığınız yerə köçürün: %s",
-  "horizon.friends.title": "Dostlarla oynayın",
-  "horizon.friends.hint": "Dostlar kodu başlıq ekranının Dostlar düyməsindən sonra, Birbaşa Bağlantıda və ya başlatma qurğusunun Play səhifəsində yerləşdirin.",
-  "horizon.friends.copied": "Kopyalandı",
-  "horizon.friends.copy_code": "Kodu kopyalayın",
-  "horizon.friends.stop_sharing": "Paylaşmağı dayandırın",
-  "horizon.friends.none_yet": "Burada hələ dost yoxdur.",
-  "horizon.friends.here_now": "İndi burada: %s",
-  "horizon.friends.share_intro": "Bu dünyanı dəvət kodunun arxasında paylaşın: o, LAN-a açılır və internetdəki dostlar kodla qoşulur. Heç bir serverimiz iştirak etmir.",
-  "horizon.friends.start_sharing": "Paylaşmağa başlayın",
-  "horizon.friends.troubleshooting": "Problem həll olunur...",
-  "horizon.friends.stopped": "Dəvət kodunu paylaşmağı dayandırdı.",
-  "horizon.friends.short_code_changed": "Kimsə səhv qısa kodu sınamağa davam etdi, ona görə də dəyişdi.",
-  "horizon.friends.wrong_code": "Kimsə səhv kodu sınadı.",
-  "horizon.friends.relay_stopped": "Çox sayda yanlış qısa kod daxil edildi, ona görə yenidən paylaşana qədər rele söndürülüb. Dostlar hələ də tam kodla qoşula bilər.",
-  "horizon.friends.code_ready": "Dəvət kodunuz hazırdır: Oyun Menyu, Dostlarla Oyna. Kopyalayın və dostlarınıza göndərin.",
-  "horizon.friends.share_failed": "Dünyanı paylaşmaq mümkün olmadı: %s",
-  "horizon.friends.finding_route": "Dostların sizinlə necə əlaqə saxlaya biləcəyi tapılır...",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Kosmos",
   "horizon.osk.delete": "Sil",

crates/horizon-client/assets/horizon/lang/ba_ru.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "%s ҡулланыу өсөн уйынды яңынан эшләтегеҙ: улар блоктар, әйберҙәр йәки донъя генерацияһын өҫтәй.",
   "horizon.shader_options.profile": "Профиль",
   "horizon.agent.copy_details": "Тоташыу тураһында мәғлүмәтте күсерергә",
-  "horizon.multiplayer.join": "Ҡушылыу",
   "horizon.multiplayer.cancel_reconnecting": "Яңынан тоташтырыуҙы юҡҡа сығарыу",
-  "horizon.multiplayer.join_friend": "Дуҫҡа ҡушыл",
-  "horizon.multiplayer.invite_code": "Саҡырыу коды",
-  "horizon.multiplayer.relay": "Реле (теләк буйынса)",
   "Preset": "Алдан ҡуйылған",
   "LOD Distance": "LOD арауығы",
   "Far Detail": "Алыҫ деталь",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Офлайн профилдәр был данаға ҡарай",
   "horizon.splitscreen.profiles.move": "Уйнаған ергә күсерегеҙ .",
   "horizon.splitscreen.profiles.move_place": "Уйнаған урынға күсегеҙ: %s .",
-  "horizon.friends.title": "Дуҫтар менән уйнау .",
-  "horizon.friends.hint": "Дуҫтар кодты титул экранының «Дуҫтар» төймәһенән һуң, туранан-тура бәйләнештә йәки стартердың «Уйнау» битендә йәбештерә.",
-  "horizon.friends.copied": "Күсерелгән",
-  "horizon.friends.copy_code": "Код күсермәһе",
-  "horizon.friends.stop_sharing": "Бүлешеүҙе туҡтатығыҙ",
-  "horizon.friends.none_yet": "Бында әлегә дуҫтар юҡ.",
-  "horizon.friends.here_now": "Бында хәҙер: %s",
-  "horizon.friends.share_intro": "Был донъя менән бүлешергә артында саҡырыу коды: ул LAN асыла, һәм дуҫтар интернетта код менән ҡушыла. Беҙҙең бер сервер ҙа ҡатнашмай.",
-  "horizon.friends.start_sharing": "Бүлешергә башлағыҙ",
-  "horizon.friends.troubleshooting": "Неисправность...",
-  "horizon.friends.stopped": "Саҡырыу коды менән бүлешеүҙе туҡтатты.",
-  "horizon.friends.short_code_changed": "Кемдер дөрөҫ булмаған ҡыҫҡа кодты һынап ҡараны, шуға күрә ул үҙгәрҙе.",
-  "horizon.friends.wrong_code": "Кемдер дөрөҫ булмаған кодты ҡулланып ҡараған.",
-  "horizon.friends.relay_stopped": "Дөрөҫ булмаған ҡыҫҡа кодтар бик күп булды, шуға күрә ҡабат бүлешкәнгә тиклем реле һүндерелгән. Дуҫтар тулы код менән килеүен дауам итә ала.",
-  "horizon.friends.code_ready": "Һеҙҙең саҡырыу коды әҙер: Уйын Менюһы, Дуҫтар менән уйнау. Күсереп яҙып, дуҫтарығыҙға ебәрегеҙ.",
-  "horizon.friends.share_failed": "Донъяны бүлешә алманым: %s",
-  "horizon.friends.finding_route": "Һеҙгә дуҫтар нисек барып етә алыуын табыу...",
   "horizon.osk.shift": "Смена",
   "horizon.osk.space": "Йыһан",
   "horizon.osk.delete": "Юйырға",

crates/horizon-client/assets/horizon/lang/be_by.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Перазапусціце гульню, каб ужыць %s: яны дадаюць блокі, прадметы або генерацыю свету.",
   "horizon.shader_options.profile": "Профіль",
   "horizon.agent.copy_details": "Скапіруйце звесткі аб падключэнні",
-  "horizon.multiplayer.join": "Далучайцеся",
   "horizon.multiplayer.cancel_reconnecting": "Адмяніць паўторнае падключэнне",
-  "horizon.multiplayer.join_friend": "Далучайцеся да сяброў",
-  "horizon.multiplayer.invite_code": "Код запрашэння",
-  "horizon.multiplayer.relay": "Рэле (неабавязкова)",
   "Preset": "Прадусталяваная",
   "LOD Distance": "LOD Адлегласць",
   "Far Detail": "Далёкая дэталь",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Афлайн-профілі належаць да гэтага асобніка",
   "horizon.splitscreen.profiles.move": "Рухайцеся туды, дзе гуляеце",
   "horizon.splitscreen.profiles.move_place": "Рухайцеся туды, дзе вы гуляеце: %s",
-  "horizon.friends.title": "Гуляць з сябрамі",
-  "horizon.friends.hint": "Сябры ўстаўце код пасля кнопкі \"Сябры\" на тытульным экране ў раздзеле \"Прамое злучэнне\" або на старонцы \"Прайграванне\" праграмы запуску.",
-  "horizon.friends.copied": "Скапіравана",
-  "horizon.friends.copy_code": "Скапіруйце код",
-  "horizon.friends.stop_sharing": "Спыніць абагульванне",
-  "horizon.friends.none_yet": "Тут пакуль няма сяброў.",
-  "horizon.friends.here_now": "Вось зараз: %s",
-  "horizon.friends.share_intro": "Падзяліцеся гэтым светам за кодам запрашэння: ён адкрываецца ў лакальнай сеткі, і сябры ў Інтэрнэце далучаюцца з кодам. Наш сервер не задзейнічаны.",
-  "horizon.friends.start_sharing": "Пачніце абагульваць",
-  "horizon.friends.troubleshooting": "Ліквідацыя непаладак...",
-  "horizon.friends.stopped": "Абагульванне кода запрашэння спынена.",
-  "horizon.friends.short_code_changed": "Хтосьці спрабаваў увесці няправільны кароткі код, таму ён змяніўся.",
-  "horizon.friends.wrong_code": "Хтосьці паспрабаваў увесці няправільны код.",
-  "horizon.friends.relay_stopped": "Занадта шмат няправільных кароткіх кодаў, таму рэле выключана, пакуль вы не падзеліцеся зноў. Сябры ўсё яшчэ могуць далучыцца з поўным кодам.",
-  "horizon.friends.code_ready": "Ваш код запрашэння гатовы: меню гульні, гульня з сябрамі. Скапіруйце яго і адпраўце сваім сябрам.",
-  "horizon.friends.share_failed": "Не атрымалася падзяліцца светам: %s",
-  "horizon.friends.finding_route": "Пошук, як сябры могуць звязацца з вамі...",
   "horizon.osk.shift": "зрух",
   "horizon.osk.space": "космас",
   "horizon.osk.delete": "Выдаліць",

crates/horizon-client/assets/horizon/lang/bg_bg.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Рестартирайте играта, за да приложите %s: те добавят блокове, предмети или генериране на света.",
   "horizon.shader_options.profile": "Профил",
   "horizon.agent.copy_details": "Копиране на подробности за връзката",
-  "horizon.multiplayer.join": "Присъединете се",
   "horizon.multiplayer.cancel_reconnecting": "Отказ Повторно свързване",
-  "horizon.multiplayer.join_friend": "Присъединете се към приятел",
-  "horizon.multiplayer.invite_code": "Код за покана",
-  "horizon.multiplayer.relay": "Реле (по избор)",
   "Preset": "Предварителна настройка",
   "LOD Distance": "LOD разстояние",
   "Far Detail": "Далечен детайл",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Офлайн профилите принадлежат към този екземпляр",
   "horizon.splitscreen.profiles.move": "Движете се там, където играете",
   "horizon.splitscreen.profiles.move_place": "Преместете се там, където играете: %s",
-  "horizon.friends.title": "Играйте с приятели",
-  "horizon.friends.hint": "Приятели поставете кода след бутона Приятели на заглавния екран, в Direct Connection или на страницата за възпроизвеждане на стартовия панел.",
-  "horizon.friends.copied": "Копирано",
-  "horizon.friends.copy_code": "Копиране на код",
-  "horizon.friends.stop_sharing": "Спиране на споделянето",
-  "horizon.friends.none_yet": "Тук все още няма приятели.",
-  "horizon.friends.here_now": "Тук сега: %s",
-  "horizon.friends.share_intro": "Споделете този свят зад код за покана: той се отваря към LAN и приятели в интернет се присъединяват с кода. Не е включен наш сървър.",
-  "horizon.friends.start_sharing": "Започнете споделяне",
-  "horizon.friends.troubleshooting": "Отстраняване на неизправности...",
-  "horizon.friends.stopped": "Спря споделянето на кода за покана.",
-  "horizon.friends.short_code_changed": "Някой продължаваше да опитва грешен кратък код, така че той се промени.",
-  "horizon.friends.wrong_code": "Някой е опитал грешен код.",
-  "horizon.friends.relay_stopped": "Твърде много грешни кратки кодове, затова релето е изключено, докато не споделите отново. Приятелите все още могат да се присъединят с пълния код.",
-  "horizon.friends.code_ready": "Вашият код за покана е готов: Меню за игри, Играйте с приятели. Копирайте го и го изпратете на приятелите си.",
-  "horizon.friends.share_failed": "Не можах да споделя света: %s",
-  "horizon.friends.finding_route": "Търся как приятелите могат да се свържат с вас...",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "пространство",
   "horizon.osk.delete": "Изтриване",

crates/horizon-client/assets/horizon/lang/br_fr.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Adloc'hit ar c'hoari evit arloañ %s : ouzhpennañ a reont bloc'hoù, elfennoù pe krouidigezh bed.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Eilañ munudoù ar c'hennask",
-  "horizon.multiplayer.join": "Kemer perzh",
   "horizon.multiplayer.cancel_reconnecting": "Nullañ an adkennaskañ",
-  "horizon.multiplayer.join_friend": "Kemer perzh en ur mignon",
-  "horizon.multiplayer.invite_code": "Kod pediñ",
-  "horizon.multiplayer.relay": "Treuzkas (dibar)",
   "Preset": "Raktreset",
   "LOD Distance": "Pellder LOD",
   "Far Detail": "Munudoù pell",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Ar profiloù ezlinenn a ya d'ober an ensavadur-mañ",
   "horizon.splitscreen.profiles.move": "Dilec'hiañ el lec'h ma c'hoarier",
   "horizon.splitscreen.profiles.move_place": "Dilec'hiañ el lec'h ma c'hoarier : %s",
-  "horizon.friends.title": "C'hoari gant mignoned",
-  "horizon.friends.hint": "Pegañ a ra ar vignoned ar c'hod goude bouton Mignoned ar skramm titl, e Kevreadur war-eeun, pe war bajenn C'hoari al lañser.",
-  "horizon.friends.copied": "Eilet",
-  "horizon.friends.copy_code": "Eilañ ar c'hod",
-  "horizon.friends.stop_sharing": "Paouez da rannañ",
-  "horizon.friends.none_yet": "Mignon ebet amañ c'hoazh.",
-  "horizon.friends.here_now": "Setu bremañ : %s",
-  "horizon.friends.share_intro": "Rannañ ar bed-mañ a-dreñv ur c'hod pediñ : digeriñ a ra d'ar LAN, ha mignoned war internet a gemer perzh gant ar c'hod. N'eus servijer ebet ac'hanomp e-barzh.",
-  "horizon.friends.start_sharing": "Kregiñ da rannañ",
-  "horizon.friends.troubleshooting": "Diskoulmañ kudennoù...",
-  "horizon.friends.stopped": "Paouezet da rannañ ar c'hod pediñ.",
-  "horizon.friends.short_code_changed": "Unan bennak a gendalc'has da glask ur c'hod berr fazius, setu m'eo cheñchet.",
-  "horizon.friends.wrong_code": "Unan bennak en deus klasket ur c'hod fall.",
-  "horizon.friends.relay_stopped": "Re a godoù berr fazius, setu m'eo diweredekaet an treuzkas betek ma rannit en-dro. Ar vignoned a c'hall c'hoazh mont e-barzh gant ar c'hod klok.",
-  "horizon.friends.code_ready": "Prest eo ho kod pediñ : Menü ar c'hoari, C'hoari gant mignoned. Eilañ anezhañ ha kas anezhañ d'ho mignoned.",
-  "horizon.friends.share_failed": "N'hall ket rannañ ar bed : %s",
-  "horizon.friends.finding_route": "Kavout penaos e c'hall mignoned tizhout ac'hanoc'h...",
   "horizon.osk.shift": "Dilec'hiañ",
   "horizon.osk.space": "Egor",
   "horizon.osk.delete": "Dilemel",

crates/horizon-client/assets/horizon/lang/bs_ba.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Restartujte igru da primijenite %s: dodaju blokove, predmete ili generisanje svijeta.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Kopiraj detalje veze",
-  "horizon.multiplayer.join": "Pridružite se",
   "horizon.multiplayer.cancel_reconnecting": "Otkaži ponovno povezivanje",
-  "horizon.multiplayer.join_friend": "Pridružite se prijatelju",
-  "horizon.multiplayer.invite_code": "Pozivni kod",
-  "horizon.multiplayer.relay": "Relej (opciono)",
   "Preset": "Predložak",
   "LOD Distance": "LOD Udaljenost",
   "Far Detail": "Daleki detalj",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profili pripadaju ovoj instanci",
   "horizon.splitscreen.profiles.move": "Krećite se tamo gdje igrate",
   "horizon.splitscreen.profiles.move_place": "Premjestite se gdje igrate: %s",
-  "horizon.friends.title": "Igrajte se s prijateljima",
-  "horizon.friends.hint": "Prijatelji zalijepe kod iza dugmeta Prijatelji na naslovnom ekranu, u Direktnu vezu ili na Play stranicu pokretača.",
-  "horizon.friends.copied": "Kopirano",
-  "horizon.friends.copy_code": "Kopiraj kod",
-  "horizon.friends.stop_sharing": "Prekini dijeljenje",
-  "horizon.friends.none_yet": "Ovdje još nema prijatelja.",
-  "horizon.friends.here_now": "Evo sada: %s",
-  "horizon.friends.share_intro": "Podijelite ovaj svijet iza pozivnog koda: otvara se na LAN, a prijatelji na internetu se pridružuju kodu. Nijedan naš server nije uključen.",
-  "horizon.friends.start_sharing": "Počnite dijeliti",
-  "horizon.friends.troubleshooting": "Rješavanje problema...",
-  "horizon.friends.stopped": "Zaustavljeno je dijeljenje pozivnog koda.",
-  "horizon.friends.short_code_changed": "Neko je nastavio pokušavati s pogrešnim kratkim kodom, pa se to promijenilo.",
-  "horizon.friends.wrong_code": "Neko je probao pogrešan kod.",
-  "horizon.friends.relay_stopped": "Previše pogrešnih kratkih kodova, pa je relej isključen dok ponovo ne podijelite. Prijatelji se još mogu pridružiti s punim kodom.",
-  "horizon.friends.code_ready": "Vaš pozivni kod je spreman: Meni igre, Igrajte se sa prijateljima. Kopirajte ga i pošaljite svojim prijateljima.",
-  "horizon.friends.share_failed": "Ne mogu dijeliti svijet: %s",
-  "horizon.friends.finding_route": "Pronalaženje načina na koji prijatelji mogu doći do vas…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Razmak",
   "horizon.osk.delete": "Izbriši",

crates/horizon-client/assets/horizon/lang/ca_es.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Reinicia el joc per aplicar-hi %s: afegeixen blocs, objectes o generació del món.",
   "horizon.shader_options.profile": "Perfil",
   "horizon.agent.copy_details": "Copia els detalls de la connexió",
-  "horizon.multiplayer.join": "Uneix-te",
   "horizon.multiplayer.cancel_reconnecting": "Cancel·la la tornada a connectar",
-  "horizon.multiplayer.join_friend": "Uneix-te a un amic",
-  "horizon.multiplayer.invite_code": "Codi d'invitació",
-  "horizon.multiplayer.relay": "Relé (opcional)",
   "Preset": "Preestablert",
   "LOD Distance": "Distància LOD",
   "Far Detail": "Detall llunyà",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Els perfils fora de línia pertanyen a aquesta instància",
   "horizon.splitscreen.profiles.move": "Mou-te on jugues",
   "horizon.splitscreen.profiles.move_place": "Mou on jugues: %s",
-  "horizon.friends.title": "Juga amb els amics",
-  "horizon.friends.hint": "Els amics enganxen el codi després del botó Amics de la pantalla del títol, a la connexió directa o a la pàgina de reproducció del llançador.",
-  "horizon.friends.copied": "Copiat",
-  "horizon.friends.copy_code": "Copia el codi",
-  "horizon.friends.stop_sharing": "Deixa de compartir",
-  "horizon.friends.none_yet": "Encara no hi ha amics.",
-  "horizon.friends.here_now": "Aquí ara: %s",
-  "horizon.friends.share_intro": "Comparteix aquest món darrere d'un codi d'invitació: s'obre a LAN i els amics d'Internet s'uneixen amb el codi. Cap servidor nostre està implicat.",
-  "horizon.friends.start_sharing": "Comenceu a compartir",
-  "horizon.friends.troubleshooting": "Resolució de problemes...",
-  "horizon.friends.stopped": "S'ha deixat de compartir el codi d'invitació.",
-  "horizon.friends.short_code_changed": "Algú va seguir provant un codi curt equivocat, així que va canviar.",
-  "horizon.friends.wrong_code": "Algú ha provat un codi incorrecte.",
-  "horizon.friends.relay_stopped": "Massa codis curts incorrectes, així que el relé està aturat fins que tornis a compartir. Els amics encara s'hi poden unir amb el codi complet.",
-  "horizon.friends.code_ready": "El teu codi d'invitació està preparat: Menú de joc, Juga amb els amics. Copia'l i envia'l als teus amics.",
-  "horizon.friends.share_failed": "No s'ha pogut compartir el món: %s",
-  "horizon.friends.finding_route": "Trobar com els amics et poden arribar...",
   "horizon.osk.shift": "Canvi",
   "horizon.osk.space": "Espai",
   "horizon.osk.delete": "Suprimeix",

crates/horizon-client/assets/horizon/lang/cs_cz.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Restartujte hru, aby se %s projevilo: přidává bloky, předměty nebo generování světa.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Kopírovat podrobnosti o připojení",
-  "horizon.multiplayer.join": "Připojte se",
   "horizon.multiplayer.cancel_reconnecting": "Zrušit opětovné připojení",
-  "horizon.multiplayer.join_friend": "Přidejte se k příteli",
-  "horizon.multiplayer.invite_code": "Kód pozvánky",
-  "horizon.multiplayer.relay": "relé (volitelné)",
   "Preset": "Přednastaveno",
   "LOD Distance": "LOD Vzdálenost",
   "Far Detail": "Daleký detail",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profily patří k této instanci",
   "horizon.splitscreen.profiles.move": "Pohybujte se tam, kde hrajete",
   "horizon.splitscreen.profiles.move_place": "Přesuňte se, kde hrajete: %s",
-  "horizon.friends.title": "Hrajte s přáteli",
-  "horizon.friends.hint": "Přátelé vloží kód za tlačítko Přátelé na titulní obrazovce, do Přímého připojení nebo na stránku Play spouštěče.",
-  "horizon.friends.copied": "Zkopírováno",
-  "horizon.friends.copy_code": "Kopírovat kód",
-  "horizon.friends.stop_sharing": "Přestat sdílet",
-  "horizon.friends.none_yet": "Zatím tu nejsou žádní přátelé.",
-  "horizon.friends.here_now": "Tady teď: %s",
-  "horizon.friends.share_intro": "Sdílejte tento svět pomocí zvacího kódu: otevře se na LAN a přátelé na internetu se připojí pomocí kódu. Není zapojen žádný náš server.",
-  "horizon.friends.start_sharing": "Začněte sdílet",
-  "horizon.friends.troubleshooting": "Odstraňování problémů...",
-  "horizon.friends.stopped": "Sdílení kódu pozvánky bylo zastaveno.",
-  "horizon.friends.short_code_changed": "Někdo neustále zkoušel špatný krátký kód, takže se to změnilo.",
-  "horizon.friends.wrong_code": "Někdo zkusil špatný kód.",
-  "horizon.friends.relay_stopped": "Příliš mnoho špatných krátkých kódů, takže relé je vypnuté, dokud nebudete sdílet znovu. Přátelé se stále mohou připojit s plným kódem.",
-  "horizon.friends.code_ready": "Váš zvací kód je připraven: Herní menu, Hrajte s přáteli. Zkopírujte jej a pošlete svým přátelům.",
-  "horizon.friends.share_failed": "Nepodařilo se sdílet svět: %s",
-  "horizon.friends.finding_route": "Zjištění, jak vás mohou přátelé kontaktovat…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Prostor",
   "horizon.osk.delete": "Smazat",

crates/horizon-client/assets/horizon/lang/cv_cu.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "%s ӗҫлеттерес тесен вӑйӑна ҫӗнӗрен пуҫлӑр: вӗсем блоксем, япаласем е тӗнче генерацийӗ хушса параҫҫӗ.",
   "horizon.shader_options.profile": "Профиль",
   "horizon.agent.copy_details": "Ҫыхӑну даннӑйӗсене копилесе илӗр",
-  "horizon.multiplayer.join": "Пӗрлешӗр",
   "horizon.multiplayer.cancel_reconnecting": "Ҫӗнӗрен ҫыхӑнассине пӑрахӑҫла",
-  "horizon.multiplayer.join_friend": "Тус ҫумне хутшӑн",
-  "horizon.multiplayer.invite_code": "Йыхрав кодӗ",
-  "horizon.multiplayer.relay": "Реле (опционально)",
   "Preset": "Малтанах лартнӑ",
   "LOD Distance": "LOD дистанцийӗ",
   "Far Detail": "Инҫетри вак-тӗвек",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Офлайн профильсем ҫак экземпляра кӗреҫҫӗ",
   "horizon.splitscreen.profiles.move": "Ӑҫта вылятӑн, ҫавӑнта куҫ",
   "horizon.splitscreen.profiles.move_place": "Ӑҫта вылятӑн, ҫавӑнта куҫ: %s",
-  "horizon.friends.title": "Юлташсемпе выля",
-  "horizon.friends.hint": "Туссем ҫак кода титул экранӗнчи Туссем кнопки хыҫҫӑн, Тӳрӗ ҫыхӑнура е пуҫлаканӑн Play страницинче ҫыпӑҫтараҫҫӗ.",
-  "horizon.friends.copied": "Копиленӗ",
-  "horizon.friends.copy_code": "Код копийӗ",
-  "horizon.friends.stop_sharing": "Пайлама пӑрахӑр",
-  "horizon.friends.none_yet": "Кунта туссем ҫук-ха.",
-  "horizon.friends.here_now": "Акӑ халӗ: %s",
-  "horizon.friends.share_intro": "Ҫак тӗнчене йыхрав кодӗ хыҫӗнче пайла: вӑл LAN-а уҫӑлать, интернетри туссем вара ҫав кодпа хутшӑнаҫҫӗ. Пирӗн пӗр сервер та ҫак ӗҫе хутшӑнмасть.",
-  "horizon.friends.start_sharing": "Пайлама пуҫлӑр",
-  "horizon.friends.troubleshooting": "Ҫитменлӗхсене пӗтересси...",
-  "horizon.friends.stopped": "Чӗнӳ кодне пайлама пӑрахрӑм.",
-  "horizon.friends.short_code_changed": "Такам кӗске кода йӑнӑш ҫырса пӑхрӗ, ҫавӑнпа вӑл улшӑнчӗ.",
-  "horizon.friends.wrong_code": "Такам йӑнӑш кодпа усӑ курса пӑхнӑ.",
-  "horizon.friends.relay_stopped": "Ытла нумай тӗрӗс мар кӗске код, ҫавӑнпа реле эсир тепӗр хут пайласан ҫеҫ ӗҫлӗ. Тусем тулли кодпа кӗме пултараҫҫӗ.",
-  "horizon.friends.code_ready": "Сирӗн чӗнӳ кодӗ хатӗр: Вӑйӑ меню, Туссемпе выля. Ӑна копилесе юлташсене ярса парӑр.",
-  "horizon.friends.share_failed": "Тӗнчене пайлаймарӑм: %s",
-  "horizon.friends.finding_route": "Юлташсем сирӗн пата мӗнле ҫитме пултарнине тупасси...",
   "horizon.osk.shift": "Смена",
   "horizon.osk.space": "Космос",
   "horizon.osk.delete": "Пӗтер",

crates/horizon-client/assets/horizon/lang/cy_gb.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Ailgychwynnwch y gêm i gymhwyso %s: maent yn ychwanegu blociau, eitemau neu gynhyrchu bydoedd.",
   "horizon.shader_options.profile": "Proffil",
   "horizon.agent.copy_details": "Copïo Manylion Cysylltiad",
-  "horizon.multiplayer.join": "Ymuno",
   "horizon.multiplayer.cancel_reconnecting": "Canslo Ailgysylltu",
-  "horizon.multiplayer.join_friend": "Ymunwch â Ffrind",
-  "horizon.multiplayer.invite_code": "Cod Gwahodd",
-  "horizon.multiplayer.relay": "Cyfnewid (dewisol)",
   "Preset": "Rhagosodedig",
   "LOD Distance": "Pellter LOD",
   "Far Detail": "Manylyn Pell",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Mae proffiliau all-lein yn perthyn i'r achos hwn",
   "horizon.splitscreen.profiles.move": "Symudwch lle rydych chi'n chwarae",
   "horizon.splitscreen.profiles.move_place": "Symudwch ble rydych chi'n chwarae: %s",
-  "horizon.friends.title": "Chwarae gyda Ffrindiau",
-  "horizon.friends.hint": "Mae ffrindiau'n gludo'r cod ar ôl botwm Friends y sgrin deitl, yn Direct Connection, neu ar dudalen Chwarae'r lansiwr.",
-  "horizon.friends.copied": "Wedi'i gopïo",
-  "horizon.friends.copy_code": "Copi Cod",
-  "horizon.friends.stop_sharing": "Stopio Rhannu",
-  "horizon.friends.none_yet": "Dim ffrindiau yma eto.",
-  "horizon.friends.here_now": "Yma nawr: %s",
-  "horizon.friends.share_intro": "Rhannwch y byd hwn y tu ôl i god gwahoddiad: mae'n agor i LAN, ac mae ffrindiau ar y rhyngrwyd yn ymuno â'r cod. Nid oes unrhyw weinydd ohonom yn cymryd rhan.",
-  "horizon.friends.start_sharing": "Dechrau Rhannu",
-  "horizon.friends.troubleshooting": "Datrys Problemau...",
-  "horizon.friends.stopped": "Wedi stopio rhannu'r cod gwahoddiad.",
-  "horizon.friends.short_code_changed": "Roedd rhywun yn ceisio cod byr anghywir o hyd, felly fe newidiodd.",
-  "horizon.friends.wrong_code": "Ceisiodd rhywun god anghywir.",
-  "horizon.friends.relay_stopped": "Gormod o godau byr anghywir, felly mae'r cyfnewidydd i ffwrdd nes i chi rannu eto. Gall ffrindiau ymuno o hyd â'r cod llawn.",
-  "horizon.friends.code_ready": "Mae eich cod gwahoddiad yn barod: Dewislen Gêm, Chwarae gyda Ffrindiau. Copïwch ef a'i anfon at eich ffrindiau.",
-  "horizon.friends.share_failed": "Methu rhannu'r byd: %s",
-  "horizon.friends.finding_route": "Darganfod sut y gall ffrindiau eich cyrraedd…",
   "horizon.osk.shift": "Turn",
   "horizon.osk.space": "Gofod",
   "horizon.osk.delete": "Dileu",

crates/horizon-client/assets/horizon/lang/da_dk.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Genstart spillet for at anvende %s: de tilføjer blokke, genstande eller verdensgenerering.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Kopier forbindelsesoplysninger",
-  "horizon.multiplayer.join": "Deltag",
   "horizon.multiplayer.cancel_reconnecting": "Annuller Gentilslutning",
-  "horizon.multiplayer.join_friend": "Slut dig til en ven",
-  "horizon.multiplayer.invite_code": "Invitationskode",
-  "horizon.multiplayer.relay": "Relæ (valgfrit)",
   "Preset": "Forudindstillet",
   "LOD Distance": "LOD Afstand",
   "Far Detail": "Fjern detalje",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offlineprofiler hører til denne instans",
   "horizon.splitscreen.profiles.move": "Flyt hvor du spiller",
   "horizon.splitscreen.profiles.move_place": "Flyt hvor du spiller: %s",
-  "horizon.friends.title": "Spil med venner",
-  "horizon.friends.hint": "Venner indsætter koden efter titelskærmens Venner-knap, i Direct Connection eller på launcherens Play-side.",
-  "horizon.friends.copied": "Kopieret",
-  "horizon.friends.copy_code": "Kopiér kode",
-  "horizon.friends.stop_sharing": "Stop deling",
-  "horizon.friends.none_yet": "Ingen venner her endnu.",
-  "horizon.friends.here_now": "Her nu: %s",
-  "horizon.friends.share_intro": "Del denne verden bag en invitationskode: den åbner til LAN, og venner på internettet deltager med koden. Ingen af vores servere er involveret.",
-  "horizon.friends.start_sharing": "Begynd at dele",
-  "horizon.friends.troubleshooting": "Fejlfinding...",
-  "horizon.friends.stopped": "Stoppet med at dele invitationskoden.",
-  "horizon.friends.short_code_changed": "Nogen blev ved med at prøve en forkert kort kode, så den ændrede sig.",
-  "horizon.friends.wrong_code": "Nogen prøvede en forkert kode.",
-  "horizon.friends.relay_stopped": "For mange forkerte kortkoder, så relæet er slået fra, indtil du deler igen. Venner kan stadig deltage med den fulde kode.",
-  "horizon.friends.code_ready": "Din invitationskode er klar: Spilmenu, Spil med venner. Kopier det og send det til dine venner.",
-  "horizon.friends.share_failed": "Kunne ikke dele verden: %s",
-  "horizon.friends.finding_route": "Finder, hvordan venner kan nå dig...",
   "horizon.osk.shift": "Skift",
   "horizon.osk.space": "Plads",
   "horizon.osk.delete": "Slet",

crates/horizon-client/assets/horizon/lang/de_de.json

@@ -209,11 +209,7 @@
   "horizon.mods.switch.restart": "Starte das Spiel neu, um %s anzuwenden: Sie fügen Blöcke, Gegenstände oder Weltgenerierung hinzu.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Verbindungsdaten kopieren",
-  "horizon.multiplayer.join": "Beitreten",
   "horizon.multiplayer.cancel_reconnecting": "Neuverbindung abbrechen",
-  "horizon.multiplayer.join_friend": "Freund beitreten",
-  "horizon.multiplayer.invite_code": "Einladungscode",
-  "horizon.multiplayer.relay": "Relay (optional)",
   "Preset": "Preset",
   "LOD Distance": "LOD-Weite",
   "Far Detail": "Ferndetails",
@@ -323,7 +319,6 @@
   "horizon.extras.wheel_cycles_settings": "Mausrad ändert Einstellungen",
   "horizon.extras.pack_browser": "Ressourcenpaket-Browser",
   "horizon.extras.music_page.tooltip": "Musik & Geräusche erhält eine Seite „Musik …“: Spiele jeden eingebauten Titel jetzt ab oder schalte einen aus, damit das Spiel ihn nicht mehr wählt. Nichts ändert sich, bis du einen Titel ausschaltest.",
-  "horizon.friends.relay_stopped": "Zu viele falsche Kurzcodes, deshalb ist das Relay aus, bis du erneut teilst. Freunde können weiterhin mit dem vollständigen Code beitreten.",
   "horizon.extras.pack_browser.tooltip": "Ressourcenpakete auswählen erhält eine Schaltfläche „Hinzufügen“, die Modrinth durchsucht und ein Paket in deinen Paketordner installiert. Aus kontaktiert das Spiel Modrinth nie.",
   "horizon.splitscreen.setup.monitor": "Monitor %s",
   "horizon.splitscreen.setup.monitor_unknown": "ein Monitor",
@@ -543,22 +538,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline-Profile gehören zu dieser Instanz",
   "horizon.splitscreen.profiles.move": "Spielort wechseln",
   "horizon.splitscreen.profiles.move_place": "Spielort wechseln: %s",
-  "horizon.friends.title": "Mit Freunden spielen",
-  "horizon.friends.hint": "Freunde fügen den Code nach dem Freunde-Knopf des Titelbildschirms ein, bei „Direktverbindung“ oder auf der Spielen-Seite des Launchers.",
-  "horizon.friends.copied": "Kopiert",
-  "horizon.friends.copy_code": "Code kopieren",
-  "horizon.friends.stop_sharing": "Teilen beenden",
-  "horizon.friends.none_yet": "Noch keine Freunde hier.",
-  "horizon.friends.here_now": "Gerade hier: %s",
-  "horizon.friends.share_intro": "Teile diese Welt mit einem Einladungscode: Sie wird im LAN geöffnet, und Freunde im Internet treten mit dem Code bei. Es ist kein Server von uns beteiligt.",
-  "horizon.friends.start_sharing": "Teilen starten",
-  "horizon.friends.troubleshooting": "Fehlerbehebung …",
-  "horizon.friends.stopped": "Das Teilen des Einladungscodes wurde beendet.",
-  "horizon.friends.short_code_changed": "Jemand hat immer wieder einen falschen Kurzcode versucht, deshalb wurde er geändert.",
-  "horizon.friends.wrong_code": "Jemand hat einen falschen Code versucht.",
-  "horizon.friends.code_ready": "Dein Einladungscode ist bereit: Spielmenü, Mit Freunden spielen. Kopiere ihn und schicke ihn an deine Freunde.",
-  "horizon.friends.share_failed": "Die Welt konnte nicht geteilt werden: %s",
-  "horizon.friends.finding_route": "Es wird ermittelt, wie Freunde dich erreichen können …",
   "horizon.osk.shift": "Umschalt",
   "horizon.osk.space": "Leertaste",
   "horizon.osk.delete": "Löschen",

crates/horizon-client/assets/horizon/lang/el_gr.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Επανεκκινήστε το παιχνίδι για να εφαρμόσετε το %s: προσθέτουν μπλοκ, αντικείμενα ή παραγωγή κόσμου.",
   "horizon.shader_options.profile": "Προφίλ",
   "horizon.agent.copy_details": "Αντιγραφή στοιχείων σύνδεσης",
-  "horizon.multiplayer.join": "Εγγραφείτε",
   "horizon.multiplayer.cancel_reconnecting": "Ακύρωση επανασύνδεσης",
-  "horizon.multiplayer.join_friend": "Γίνετε μέλος ενός φίλου",
-  "horizon.multiplayer.invite_code": "Κωδικός πρόσκλησης",
-  "horizon.multiplayer.relay": "Ρελέ (προαιρετικό)",
   "Preset": "Προκαθορισμένη",
   "LOD Distance": "Απόσταση LOD",
   "Far Detail": "Μακρινή λεπτομέρεια",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Τα προφίλ εκτός σύνδεσης ανήκουν σε αυτήν την περίπτωση",
   "horizon.splitscreen.profiles.move": "Μετακινηθείτε όπου παίζετε",
   "horizon.splitscreen.profiles.move_place": "Μετακινηθείτε όπου παίζετε: %s",
-  "horizon.friends.title": "Παίξτε με φίλους",
-  "horizon.friends.hint": "Οι φίλοι επικολλούν τον κώδικα μετά το κουμπί Φίλοι της οθόνης τίτλου, στην Άμεση σύνδεση ή στη σελίδα Αναπαραγωγή του προγράμματος εκκίνησης.",
-  "horizon.friends.copied": "Αντιγράφηκε",
-  "horizon.friends.copy_code": "Αντιγραφή Κωδικού",
-  "horizon.friends.stop_sharing": "Διακοπή κοινής χρήσης",
-  "horizon.friends.none_yet": "Δεν υπάρχουν φίλοι εδώ ακόμα.",
-  "horizon.friends.here_now": "Εδώ τώρα: %s",
-  "horizon.friends.share_intro": "Μοιραστείτε αυτόν τον κόσμο πίσω από έναν κωδικό πρόσκλησης: ανοίγει σε LAN και οι φίλοι στο Διαδίκτυο συμμετέχουν με τον κωδικό. Κανένας διακομιστής μας δεν εμπλέκεται.",
-  "horizon.friends.start_sharing": "Ξεκινήστε την κοινή χρήση",
-  "horizon.friends.troubleshooting": "Αντιμετώπιση προβλημάτων...",
-  "horizon.friends.stopped": "Σταμάτησε η κοινή χρήση του κωδικού πρόσκλησης.",
-  "horizon.friends.short_code_changed": "Κάποιος συνέχισε να δοκιμάζει έναν λάθος σύντομο κωδικό, οπότε άλλαξε.",
-  "horizon.friends.wrong_code": "Κάποιος δοκίμασε λάθος κωδικό.",
-  "horizon.friends.relay_stopped": "Πολλοί λάθος σύντομοι κωδικοί, οπότε το ρελέ είναι κλειστό μέχρι να μοιραστείτε ξανά. Οι φίλοι μπορούν ακόμη να συνδεθούν με τον πλήρη κωδικό.",
-  "horizon.friends.code_ready": "Ο κωδικός πρόσκλησής σας είναι έτοιμος: Μενού παιχνιδιού, Παίξτε με φίλους. Αντιγράψτε το και στείλτε το στους φίλους σας.",
-  "horizon.friends.share_failed": "Δεν μπορούσα να μοιραστώ τον κόσμο: %s",
-  "horizon.friends.finding_route": "Βρείτε πώς μπορούν να σας φτάσουν οι φίλοι…",
   "horizon.osk.shift": "Μετατόπιση",
   "horizon.osk.space": "Διάστημα",
   "horizon.osk.delete": "Διαγραφή",

crates/horizon-client/assets/horizon/lang/en_us.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Restart the game to apply %s: they add blocks, items or world generation.",
   "horizon.shader_options.profile": "Profile",
   "horizon.agent.copy_details": "Copy Connection Details",
-  "horizon.multiplayer.join": "Join",
   "horizon.multiplayer.cancel_reconnecting": "Cancel Reconnecting",
-  "horizon.multiplayer.join_friend": "Join a Friend",
-  "horizon.multiplayer.invite_code": "Invite Code",
-  "horizon.multiplayer.relay": "Relay (optional)",
   "Preset": "Preset",
   "LOD Distance": "LOD Distance",
   "Far Detail": "Far Detail",
@@ -441,6 +437,7 @@
   "HDR Calibration %s/%s: %s": "HDR Calibration %s/%s: %s",
   "Sets the three below full screen, one test picture at a time.": "Sets the three below full screen, one test picture at a time.",
   "Your display didn't say how bright it gets: calibrate to set it up.": "Your display didn't say how bright it gets: calibrate to set it up.",
+  "Your display's reported peak is often too high: calibrate to set it up.": "Your display's reported peak is often too high: calibrate to set it up.",
   "Already set up for your display. Only calibrate if HDR looks wrong.": "Already set up for your display. Only calibrate if HDR looks wrong.",
   "Puts Peak Brightness and Paper White back to your display's setup.": "Puts Peak Brightness and Paper White back to your display's setup.",
   "Set up for your display. Leave on Auto unless it looks wrong.": "Set up for your display. Leave on Auto unless it looks wrong.",
@@ -464,23 +461,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profiles belong to this instance",
   "horizon.splitscreen.profiles.move": "Move where you play",
   "horizon.splitscreen.profiles.move_place": "Move where you play: %s",
-  "horizon.friends.title": "Play with Friends",
-  "horizon.friends.hint": "Friends paste the code after the title screen's Friends button, in Direct Connection, or on the launcher's Play page.",
-  "horizon.friends.copied": "Copied",
-  "horizon.friends.copy_code": "Copy Code",
-  "horizon.friends.stop_sharing": "Stop Sharing",
-  "horizon.friends.none_yet": "No friends here yet.",
-  "horizon.friends.here_now": "Here now: %s",
-  "horizon.friends.share_intro": "Share this world behind an invite code: it opens to LAN, and friends on the internet join with the code. No server of ours is involved.",
-  "horizon.friends.start_sharing": "Start Sharing",
-  "horizon.friends.troubleshooting": "Troubleshooting...",
-  "horizon.friends.stopped": "Stopped sharing the invite code.",
-  "horizon.friends.short_code_changed": "Someone kept trying a wrong short code, so it changed.",
-  "horizon.friends.wrong_code": "Someone tried a wrong code.",
-  "horizon.friends.relay_stopped": "Too many wrong short codes, so the relay is off until you share again. Friends can still join with the full code.",
-  "horizon.friends.code_ready": "Your invite code is ready: Game Menu, Play with Friends. Copy it and send it to your friends.",
-  "horizon.friends.share_failed": "Couldn't share the world: %s",
-  "horizon.friends.finding_route": "Finding how friends can reach you…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Space",
   "horizon.osk.delete": "Delete",

crates/horizon-client/assets/horizon/lang/eo_uy.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Restartigu la ludon por apliki %s: ili aldonas blokojn, objektojn aŭ mondgeneradon.",
   "horizon.shader_options.profile": "Profilo",
   "horizon.agent.copy_details": "Kopiu Detalojn pri Konekto",
-  "horizon.multiplayer.join": "Aliĝu",
   "horizon.multiplayer.cancel_reconnecting": "Nuligi Rekonekti",
-  "horizon.multiplayer.join_friend": "Aliĝu al Amiko",
-  "horizon.multiplayer.invite_code": "Inviti Kodon",
-  "horizon.multiplayer.relay": "Relajso (laŭvola)",
   "Preset": "Antaŭdifinita",
   "LOD Distance": "LOD Distanco",
   "Far Detail": "Malproksima Detalo",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Senretaj profiloj apartenas al ĉi tiu kazo",
   "horizon.splitscreen.profiles.move": "Movu kien vi ludas",
   "horizon.splitscreen.profiles.move_place": "Movu kien vi ludas: %s",
-  "horizon.friends.title": "Ludu kun Amikoj",
-  "horizon.friends.hint": "Amikoj algluas la kodon post la butono Amikoj de la titolekrano, en Rekta Konekto aŭ sur la Luda paĝo de la lanĉilo.",
-  "horizon.friends.copied": "Kopiita",
-  "horizon.friends.copy_code": "Kopiu Kodon",
-  "horizon.friends.stop_sharing": "Ĉesu Kundividon",
-  "horizon.friends.none_yet": "Ankoraŭ neniuj amikoj ĉi tie.",
-  "horizon.friends.here_now": "Ĉi tie nun: %s",
-  "horizon.friends.share_intro": "Kunhavigu ĉi tiun mondon malantaŭ invitkodo: ĝi malfermiĝas al LAN, kaj amikoj en la interreto aliĝas kun la kodo. Neniu servilo nia estas implikita.",
-  "horizon.friends.start_sharing": "Komencu Kunhavigi",
-  "horizon.friends.troubleshooting": "Solvado de problemoj...",
-  "horizon.friends.stopped": "Ĉesis kunhavigi la invitkodon.",
-  "horizon.friends.short_code_changed": "Iu daŭre provis malĝustan mallongan kodon, do ĝi ŝanĝiĝis.",
-  "horizon.friends.wrong_code": "Iu provis malĝustan kodon.",
-  "horizon.friends.relay_stopped": "Tro da malĝustaj mallongaj kodoj, do la relajso estas malŝaltita ĝis vi denove kundividos. Amikoj ankoraŭ povas aliĝi per la plena kodo.",
-  "horizon.friends.code_ready": "Via invitkodo estas preta: Luda Menuo, Ludu kun Amikoj. Kopiu ĝin kaj sendu ĝin al viaj amikoj.",
-  "horizon.friends.share_failed": "Ne povis dividi la mondon: %s",
-  "horizon.friends.finding_route": "Trovi kiel amikoj povas atingi vin...",
   "horizon.osk.shift": "Majusklo",
   "horizon.osk.space": "Spaco",
   "horizon.osk.delete": "Forigi",

crates/horizon-client/assets/horizon/lang/es_es.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Reinicia el juego para aplicar %s: añaden bloques, objetos o generación del mundo.",
   "horizon.shader_options.profile": "Perfil",
   "horizon.agent.copy_details": "Copiar datos de conexión",
-  "horizon.multiplayer.join": "Unirse",
   "horizon.multiplayer.cancel_reconnecting": "Cancelar reconexión",
-  "horizon.multiplayer.join_friend": "Unirse a un amigo",
-  "horizon.multiplayer.invite_code": "Código de invitación",
-  "horizon.multiplayer.relay": "Relay (opcional)",
   "Preset": "Preajuste",
   "LOD Distance": "Distancia LOD",
   "Far Detail": "Detalle lejano",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Los perfiles sin conexión pertenecen a esta instancia",
   "horizon.splitscreen.profiles.move": "Mover dónde juegas",
   "horizon.splitscreen.profiles.move_place": "Mover dónde juegas: %s",
-  "horizon.friends.title": "Jugar con amigos",
-  "horizon.friends.hint": "Tus amigos pegan el código tras el botón Amigos de la pantalla de título, en Conexión directa o en la página Jugar del launcher.",
-  "horizon.friends.copied": "Copiado",
-  "horizon.friends.copy_code": "Copiar código",
-  "horizon.friends.stop_sharing": "Dejar de compartir",
-  "horizon.friends.none_yet": "Aún no hay amigos aquí.",
-  "horizon.friends.here_now": "Aquí ahora: %s",
-  "horizon.friends.share_intro": "Comparte este mundo con un código de invitación: se abre a la LAN y tus amigos de internet se unen con el código. No interviene ningún servidor nuestro.",
-  "horizon.friends.start_sharing": "Empezar a compartir",
-  "horizon.friends.troubleshooting": "Solución de problemas...",
-  "horizon.friends.stopped": "Se ha dejado de compartir el código de invitación.",
-  "horizon.friends.short_code_changed": "Alguien intentó varias veces un código corto incorrecto, así que ha cambiado.",
-  "horizon.friends.wrong_code": "Alguien ha probado un código incorrecto.",
-  "horizon.friends.relay_stopped": "Demasiados códigos cortos incorrectos: el relé queda apagado hasta que vuelvas a compartir. Tus amigos aún pueden unirse con el código completo.",
-  "horizon.friends.code_ready": "Tu código de invitación está listo: Menú del juego, Jugar con amigos. Cópialo y envíaselo a tus amigos.",
-  "horizon.friends.share_failed": "No se pudo compartir el mundo: %s",
-  "horizon.friends.finding_route": "Buscando cómo pueden llegar tus amigos hasta ti…",
   "horizon.osk.shift": "Mayús",
   "horizon.osk.space": "Espacio",
   "horizon.osk.delete": "Borrar",

crates/horizon-client/assets/horizon/lang/et_ee.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Taaskäivita mäng, et rakendada %s: need lisavad plokke, esemeid või maailma genereerimist.",
   "horizon.shader_options.profile": "Profiil",
   "horizon.agent.copy_details": "Kopeerige ühenduse üksikasjad",
-  "horizon.multiplayer.join": "Liitu",
   "horizon.multiplayer.cancel_reconnecting": "Tühista uuesti ühendamine",
-  "horizon.multiplayer.join_friend": "Liituge sõbraga",
-  "horizon.multiplayer.invite_code": "Kutsekood",
-  "horizon.multiplayer.relay": "Relee (valikuline)",
   "Preset": "Eelseadistatud",
   "LOD Distance": "LOD vahemaa",
   "Far Detail": "Kauge detail",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Sellesse eksemplari kuuluvad võrguühenduseta profiilid",
   "horizon.splitscreen.profiles.move": "Liikuge sinna, kus mängite",
   "horizon.splitscreen.profiles.move_place": "Liikuge sinna, kus mängite: %s",
-  "horizon.friends.title": "Mängige sõpradega",
-  "horizon.friends.hint": "Sõbrad kleebivad koodi pealkirjaekraani nupu Sõbrad järele, otseühenduses või käivitusprogrammi Play lehel.",
-  "horizon.friends.copied": "Kopeeritud",
-  "horizon.friends.copy_code": "Kopeeri kood",
-  "horizon.friends.stop_sharing": "Lõpeta jagamine",
-  "horizon.friends.none_yet": "Siin pole veel sõpru.",
-  "horizon.friends.here_now": "Siin praegu: %s",
-  "horizon.friends.share_intro": "Jagage seda maailma kutsekoodi taga: see avaneb LAN-i ja Internetis olevad sõbrad liituvad koodiga. Ükski meie server ei ole sellega seotud.",
-  "horizon.friends.start_sharing": "Alusta jagamist",
-  "horizon.friends.troubleshooting": "Veaotsing...",
-  "horizon.friends.stopped": "Kutsekoodi jagamine lõpetati.",
-  "horizon.friends.short_code_changed": "Keegi proovis pidevalt valet lühikoodi, nii et see muutus.",
-  "horizon.friends.wrong_code": "Keegi proovis vale koodi.",
-  "horizon.friends.relay_stopped": "Liiga palju valesid lühikoode, seega relee on väljas, kuni uuesti jagad. Sõbrad saavad siiski täiskoodiga liituda.",
-  "horizon.friends.code_ready": "Teie kutsekood on valmis: Mängumenüü, Mängige sõpradega. Kopeerige see ja saatke see oma sõpradele.",
-  "horizon.friends.share_failed": "Ei saanud maailma jagada: %s",
-  "horizon.friends.finding_route": "Kuidas sõbrad teiega ühendust saavad…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Kosmos",
   "horizon.osk.delete": "Kustuta",

crates/horizon-client/assets/horizon/lang/eu_es.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Berrabiarazi jokoa %s aplikatzeko: blokeak, elementuak edo mundu-sorrera gehitzen dituzte.",
   "horizon.shader_options.profile": "Profila",
   "horizon.agent.copy_details": "Kopiatu konexioaren xehetasunak",
-  "horizon.multiplayer.join": "Sartu",
   "horizon.multiplayer.cancel_reconnecting": "Utzi berriro konektatzea",
-  "horizon.multiplayer.join_friend": "Sartu Lagun batekin",
-  "horizon.multiplayer.invite_code": "Gonbidatu kodea",
-  "horizon.multiplayer.relay": "Erreleboa (aukerakoa)",
   "Preset": "Aurrez ezarritakoa",
   "LOD Distance": "LOD Distantzia",
   "Far Detail": "Urruneko xehetasuna",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Lineaz kanpoko profilak instantzia honetakoak dira",
   "horizon.splitscreen.profiles.move": "Mugitu jolasten duzun tokira",
   "horizon.splitscreen.profiles.move_place": "Mugitu jolasten duzun tokira: %s",
-  "horizon.friends.title": "Jolastu Lagunekin",
-  "horizon.friends.hint": "Lagunek itsatsi dute kodea izenburu-pantailaren Lagunak botoian, Zuzeneko konexioan edo abiarazlearen Play orrian.",
-  "horizon.friends.copied": "Kopiatua",
-  "horizon.friends.copy_code": "Kopiatu kodea",
-  "horizon.friends.stop_sharing": "Utzi partekatzeari",
-  "horizon.friends.none_yet": "Hemen oraindik ez dago lagunik.",
-  "horizon.friends.here_now": "Hemen orain: %s",
-  "horizon.friends.share_intro": "Partekatu mundu hau gonbidapen-kode baten atzean: LANera irekitzen da eta Interneteko lagunak bat egiten dute kodearekin. Ez dago gure zerbitzaririk parte hartzen.",
-  "horizon.friends.start_sharing": "Hasi Partekatzen",
-  "horizon.friends.troubleshooting": "Arazoak konpontzen...",
-  "horizon.friends.stopped": "Gonbidapen kodea partekatzeari utzi dio.",
-  "horizon.friends.short_code_changed": "Norbaitek kode labur oker bat probatzen jarraitu zuen, beraz, aldatu egin zen.",
-  "horizon.friends.wrong_code": "Norbaitek kode oker batekin saiatu da.",
-  "horizon.friends.relay_stopped": "Kode labur oker gehiegi, beraz erreleboa itzalita dago berriro partekatu arte. Lagunek kode osoarekin sartzen jarrai dezakete.",
-  "horizon.friends.code_ready": "Zure gonbidapen-kodea prest dago: Jokoen menua, Jolastu lagunekin. Kopiatu eta bidali zure lagunei.",
-  "horizon.friends.share_failed": "Ezin izan da mundua partekatu: %s",
-  "horizon.friends.finding_route": "Lagunak zurekin nola irits daitezkeen aurkitzen...",
   "horizon.osk.shift": "Txanda",
   "horizon.osk.space": "Espazioa",
   "horizon.osk.delete": "Ezabatu",

crates/horizon-client/assets/horizon/lang/fa_ir.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "برای اعمال %s بازی را دوباره راه‌اندازی کنید: آن‌ها بلوک، آیتم یا تولید دنیا می‌افزایند.",
   "horizon.shader_options.profile": "نمایه",
   "horizon.agent.copy_details": "کپی جزئیات اتصال",
-  "horizon.multiplayer.join": "بپیوندید",
   "horizon.multiplayer.cancel_reconnecting": "لغو اتصال مجدد",
-  "horizon.multiplayer.join_friend": "به یک دوست بپیوندید",
-  "horizon.multiplayer.invite_code": "کد دعوت",
-  "horizon.multiplayer.relay": "رله (اختیاری)",
   "Preset": "از پیش تعیین شده",
   "LOD Distance": "فاصله LOD",
   "Far Detail": "جزئیات دور",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "پروفایل های آفلاین متعلق به این نمونه است",
   "horizon.splitscreen.profiles.move": "جایی که بازی می کنید حرکت کنید",
   "horizon.splitscreen.profiles.move_place": "جایی را که بازی می کنید حرکت دهید: %s",
-  "horizon.friends.title": "با دوستان بازی کنید",
-  "horizon.friends.hint": "دوستان کد را بعد از دکمه Friends صفحه عنوان، در اتصال مستقیم یا در صفحه Play راه‌انداز قرار می‌دهند.",
-  "horizon.friends.copied": "کپی شده است",
-  "horizon.friends.copy_code": "کد را کپی کنید",
-  "horizon.friends.stop_sharing": "اشتراک گذاری را متوقف کنید",
-  "horizon.friends.none_yet": "هنوز دوستی اینجا نیست",
-  "horizon.friends.here_now": "اکنون اینجا: %s",
-  "horizon.friends.share_intro": "این دنیا را پشت یک کد دعوت به اشتراک بگذارید: به شبکه LAN باز می شود و دوستانی که در اینترنت هستند با این کد ملحق می شوند. هیچ سروری از ما درگیر نیست.",
-  "horizon.friends.start_sharing": "اشتراک گذاری را شروع کنید",
-  "horizon.friends.troubleshooting": "عیب یابی ...",
-  "horizon.friends.stopped": "اشتراک‌گذاری کد دعوت متوقف شد.",
-  "horizon.friends.short_code_changed": "کسی مدام یک کد کوتاه اشتباه را امتحان می‌کرد، بنابراین تغییر کرد.",
-  "horizon.friends.wrong_code": "شخصی کد اشتباهی را امتحان کرده است.",
-  "horizon.friends.relay_stopped": "کدهای کوتاه اشتباه بیش از حد بود، بنابراین رله تا اشتراک‌گذاری دوباره خاموش است. دوستان هنوز می‌توانند با کد کامل بپیوندند.",
-  "horizon.friends.code_ready": "کد دعوت شما آماده است: منوی بازی، بازی با دوستان. کپی کنید و برای دوستانتان ارسال کنید.",
-  "horizon.friends.share_failed": "نمی توان جهان را به اشتراک گذاشت: %s",
-  "horizon.friends.finding_route": "یافتن نحوه ارتباط دوستان با شما…",
   "horizon.osk.shift": "شیفت",
   "horizon.osk.space": "فضا",
   "horizon.osk.delete": "حذف کنید",

crates/horizon-client/assets/horizon/lang/fi_fi.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Käynnistä peli uudelleen, jotta %s tulee voimaan: ne lisäävät lohkoja, esineitä tai maailmanluontia.",
   "horizon.shader_options.profile": "Profiili",
   "horizon.agent.copy_details": "Kopioi yhteystiedot",
-  "horizon.multiplayer.join": "Liity",
   "horizon.multiplayer.cancel_reconnecting": "Peruuta yhteyden muodostaminen",
-  "horizon.multiplayer.join_friend": "Liity ystäväksi",
-  "horizon.multiplayer.invite_code": "Kutsukoodi",
-  "horizon.multiplayer.relay": "Rele (valinnainen)",
   "Preset": "Esiasetus",
   "LOD Distance": "LOD Etäisyys",
   "Far Detail": "Kaukainen yksityiskohta",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline-profiilit kuuluvat tähän esiintymään",
   "horizon.splitscreen.profiles.move": "Muuta missä pelaat",
   "horizon.splitscreen.profiles.move_place": "Siirry paikkaan, jossa pelaat: %s",
-  "horizon.friends.title": "Pelaa ystävien kanssa",
-  "horizon.friends.hint": "Ystävät liittävät koodin otsikkonäytön Ystävät-painikkeen perään, Suoraan yhteyteen tai käynnistysohjelman Play-sivulle.",
-  "horizon.friends.copied": "Kopioitu",
-  "horizon.friends.copy_code": "Kopioi koodi",
-  "horizon.friends.stop_sharing": "Lopeta jakaminen",
-  "horizon.friends.none_yet": "Täällä ei ole vielä ystäviä.",
-  "horizon.friends.here_now": "Täällä nyt: %s",
-  "horizon.friends.share_intro": "Jaa tämä maailma kutsukoodin takana: se avautuu lähiverkkoon, ja ystävät Internetissä liittyvät koodin avulla. Yksikään palvelin ei ole mukana.",
-  "horizon.friends.start_sharing": "Aloita jakaminen",
-  "horizon.friends.troubleshooting": "Vianmääritys...",
-  "horizon.friends.stopped": "Kutsukoodin jakaminen lopetettiin.",
-  "horizon.friends.short_code_changed": "Joku yritti jatkuvasti käyttää väärää lyhytkoodia, joten se muuttui.",
-  "horizon.friends.wrong_code": "Joku yritti väärää koodia.",
-  "horizon.friends.relay_stopped": "Liian monta väärää lyhytkoodia, joten rele on pois päältä, kunnes jaat uudelleen. Ystävät voivat yhä liittyä täydellä koodilla.",
-  "horizon.friends.code_ready": "Kutsukoodisi on valmis: Pelivalikko, Pelaa ystävien kanssa. Kopioi se ja lähetä se ystävillesi.",
-  "horizon.friends.share_failed": "Ei voinut jakaa maailmaa: %s",
-  "horizon.friends.finding_route": "Selvitetään, kuinka ystävät voivat tavoittaa sinut…",
   "horizon.osk.shift": "Vaihto",
   "horizon.osk.space": "Avaruus",
   "horizon.osk.delete": "Poista",

crates/horizon-client/assets/horizon/lang/fil_ph.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "I-restart ang laro para mailapat ang %s: nagdadagdag sila ng mga bloke, item o pagbuo ng mundo.",
   "horizon.shader_options.profile": "Profile",
   "horizon.agent.copy_details": "Kopyahin ang Mga Detalye ng Koneksyon",
-  "horizon.multiplayer.join": "Sumali",
   "horizon.multiplayer.cancel_reconnecting": "Kanselahin ang Muling Pagkonekta",
-  "horizon.multiplayer.join_friend": "Sumali sa isang Kaibigan",
-  "horizon.multiplayer.invite_code": "Code ng Imbitasyon",
-  "horizon.multiplayer.relay": "Relay (opsyonal)",
   "Preset": "Preset",
   "LOD Distance": "LOD Distansya",
   "Far Detail": "Malayong Detalye",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Ang mga offline na profile ay kabilang sa pagkakataong ito",
   "horizon.splitscreen.profiles.move": "Lumipat kung saan ka naglalaro",
   "horizon.splitscreen.profiles.move_place": "Ilipat kung saan ka naglalaro: %s",
-  "horizon.friends.title": "Makipaglaro sa Kaibigan",
-  "horizon.friends.hint": "I-paste ng mga kaibigan ang code pagkatapos ng button na Friends ng screen ng pamagat, sa Direktang Koneksyon, o sa Play page ng launcher.",
-  "horizon.friends.copied": "Kinopya",
-  "horizon.friends.copy_code": "Kopyahin ang Code",
-  "horizon.friends.stop_sharing": "Itigil ang Pagbabahagi",
-  "horizon.friends.none_yet": "Wala pang kaibigan dito.",
-  "horizon.friends.here_now": "Narito ngayon: %s",
-  "horizon.friends.share_intro": "Ibahagi ang mundong ito sa likod ng code ng imbitasyon: bumubukas ito sa LAN, at sumali ang mga kaibigan sa internet gamit ang code. Walang kasamang server namin.",
-  "horizon.friends.start_sharing": "Simulan ang Pagbabahagi",
-  "horizon.friends.troubleshooting": "Pag-troubleshoot...",
-  "horizon.friends.stopped": "Huminto sa pagbabahagi ng code ng imbitasyon.",
-  "horizon.friends.short_code_changed": "May sumubok ng maling maikling code, kaya nagbago ito.",
-  "horizon.friends.wrong_code": "May sumubok ng maling code.",
-  "horizon.friends.relay_stopped": "Napakaraming maling short code, kaya naka-off ang relay hanggang magbahagi ka muli. Nakakasali pa rin ang mga kaibigan gamit ang buong code.",
-  "horizon.friends.code_ready": "Handa na ang iyong code ng imbitasyon: Game Menu, Play with Friends. Kopyahin ito at ipadala sa iyong mga kaibigan.",
-  "horizon.friends.share_failed": "Hindi maibahagi ang mundo: %s",
-  "horizon.friends.finding_route": "Hinahanap kung paano ka maaabot ng mga kaibigan...",
   "horizon.osk.shift": "Paglipat",
   "horizon.osk.space": "kalawakan",
   "horizon.osk.delete": "Tanggalin",

crates/horizon-client/assets/horizon/lang/fo_fo.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Endurbyrja spælið fyri at nýta %s: tey leggja afturat blokkar, lutir ella heimsframleiðslu.",
   "horizon.shader_options.profile": "Vangamynd",
   "horizon.agent.copy_details": "Avrita sambandsupplýsingar",
-  "horizon.multiplayer.join": "Ver við",
   "horizon.multiplayer.cancel_reconnecting": "Avlýs aftursamband",
-  "horizon.multiplayer.join_friend": "Melda teg til ein vin",
-  "horizon.multiplayer.invite_code": "Boðkoda",
-  "horizon.multiplayer.relay": "Stafett (valfrítt)",
   "Preset": "Forsett",
   "LOD Distance": "LOD Fjarstøða",
   "Far Detail": "Fjar Detalja",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profilar hoyra til hesa instans",
   "horizon.splitscreen.profiles.move": "Flyt har tú spælir",
   "horizon.splitscreen.profiles.move_place": "Flyt har tú spælir: %s .",
-  "horizon.friends.title": "Spæl við vinum",
-  "horizon.friends.hint": "Vinir líma kotuna eftir Vinir knøttin á tittulskjálvtanum, í Beinleiðis sambandi ella á Spæla síðuni á sjósetaranum.",
-  "horizon.friends.copied": "Avritað",
-  "horizon.friends.copy_code": "Avritskotu",
-  "horizon.friends.stop_sharing": "Steðga við at deila",
-  "horizon.friends.none_yet": "Eingir vinir her enn.",
-  "horizon.friends.here_now": "Her nú: %s",
-  "horizon.friends.share_intro": "Deil hendan heimin aftanfyri eina boðkotu: hon letur upp fyri LAN, og vinir á internetinum melda seg til við koduni. Eingin servari hjá okkum er við.",
-  "horizon.friends.start_sharing": "Byrja at deila",
-  "horizon.friends.troubleshooting": "Trupulleikaloysn...",
-  "horizon.friends.stopped": "Steðgaði við at deila boðkotuna.",
-  "horizon.friends.short_code_changed": "Onkur bleiv við at royna eina skeiva stutta kodu, so hon broyttist.",
-  "horizon.friends.wrong_code": "Onkur royndi eina skeiva kodu.",
-  "horizon.friends.relay_stopped": "Ov nógvar skeivar stuttkour, so stafettin er sløkt, til tú deilir aftur. Vinir kunnu framvegis melda seg til við fullu koduni.",
-  "horizon.friends.code_ready": "Tín boðkoda er klár: Spælvalmynd, Spæl við vinum. Kopiera tað og send tað til tínar vinir.",
-  "horizon.friends.share_failed": "Kundi ikki deila heimin: %s",
-  "horizon.friends.finding_route": "At finna útav, hvussu vinir kunnu røkka tær...",
   "horizon.osk.shift": "Vakt",
   "horizon.osk.space": "Rúm",
   "horizon.osk.delete": "Strika",

crates/horizon-client/assets/horizon/lang/fr_fr.json

@@ -208,11 +208,7 @@
   "horizon.mods.switch.restart": "Redémarre le jeu pour appliquer %s : ils ajoutent des blocs, des objets ou de la génération de monde.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Copier les détails de connexion",
-  "horizon.multiplayer.join": "Rejoindre",
   "horizon.multiplayer.cancel_reconnecting": "Annuler la reconnexion",
-  "horizon.multiplayer.join_friend": "Rejoindre un ami",
-  "horizon.multiplayer.invite_code": "Code d'invitation",
-  "horizon.multiplayer.relay": "Relais (facultatif)",
   "Preset": "Préréglage",
   "LOD Distance": "Distance LOD",
   "Far Detail": "Détails lointains",
@@ -302,7 +298,6 @@
   "horizon.extras.zoom_mod_install": "Zoom : à installer depuis Mods",
   "horizon.extras.pack_browser": "Navigateur de packs de ressources",
   "horizon.extras.music_page.tooltip": "Musique et sons gagne une page Musique... : lancez n'importe quelle piste intégrée maintenant, ou désactivez-en une pour que le jeu arrête de la choisir. Rien ne change tant que vous ne désactivez pas une piste.",
-  "horizon.friends.relay_stopped": "Trop de codes courts erronés : le relais est désactivé jusqu'à ce que vous partagiez à nouveau. Vos amis peuvent toujours rejoindre avec le code complet.",
   "horizon.extras.pack_browser.tooltip": "La sélection des packs de ressources gagne un bouton Ajouter qui cherche sur Modrinth et installe un pack dans votre dossier de packs. Désactivé, le jeu ne contacte jamais Modrinth.",
   "horizon.splitscreen.setup.layout.two.0": "Auto",
   "Opaque Ice": "Glace opaque",
@@ -432,22 +427,6 @@
   "horizon.splitscreen.profiles.offline_note": "Les profils hors ligne appartiennent à cette instance",
   "horizon.splitscreen.profiles.move": "Changer d'emplacement de jeu",
   "horizon.splitscreen.profiles.move_place": "Changer d'emplacement de jeu : %s",
-  "horizon.friends.title": "Jouer avec des amis",
-  "horizon.friends.hint": "Vos amis collent le code après le bouton Amis de l'écran titre, dans « Connexion rapide » ou sur la page Jouer du lanceur.",
-  "horizon.friends.copied": "Copié",
-  "horizon.friends.copy_code": "Copier le code",
-  "horizon.friends.stop_sharing": "Arrêter le partage",
-  "horizon.friends.none_yet": "Aucun ami pour l'instant.",
-  "horizon.friends.here_now": "Présents : %s",
-  "horizon.friends.share_intro": "Partagez ce monde avec un code d'invitation : il s'ouvre au LAN, et vos amis sur internet le rejoignent avec le code. Aucun serveur de notre part n'est impliqué.",
-  "horizon.friends.start_sharing": "Commencer le partage",
-  "horizon.friends.troubleshooting": "Dépannage...",
-  "horizon.friends.stopped": "Le partage du code d'invitation est arrêté.",
-  "horizon.friends.short_code_changed": "Quelqu'un a essayé plusieurs fois un mauvais code court, il a donc été changé.",
-  "horizon.friends.wrong_code": "Quelqu'un a essayé un mauvais code.",
-  "horizon.friends.code_ready": "Votre code d'invitation est prêt : Menu du jeu, Jouer avec des amis. Copiez-le et envoyez-le à vos amis.",
-  "horizon.friends.share_failed": "Impossible de partager le monde : %s",
-  "horizon.friends.finding_route": "Recherche de la manière dont vos amis peuvent vous joindre…",
   "horizon.osk.shift": "Maj.",
   "horizon.osk.space": "Espace",
   "horizon.osk.delete": "Effacer",

crates/horizon-client/assets/horizon/lang/fur_it.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Torne a inviâ il zûc par aplicâ %s: a zontin blocs, ogjets o generazion dal mont.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Copiâ i detais de conession",
-  "horizon.multiplayer.join": "Iscrivitvi",
   "horizon.multiplayer.cancel_reconnecting": "Annulâ la riconession",
-  "horizon.multiplayer.join_friend": "Iscrivitvi a un amì",
-  "horizon.multiplayer.invite_code": "Codiç di invit",
-  "horizon.multiplayer.relay": "Relê (opzionâl)",
   "Preset": "Preset",
   "LOD Distance": "Distance LOD",
   "Far Detail": "Detai lontan",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "I profîi fûr linie a apartegnin a cheste esemplificazion",
   "horizon.splitscreen.profiles.move": "Spostâsi dulà che tu zuiis",
   "horizon.splitscreen.profiles.move_place": "Spostâsi dulà che si zuie: %s",
-  "horizon.friends.title": "Zuegâ cui amîs",
-  "horizon.friends.hint": "I amîs a incolin il codiç dopo dal botôn Amîs de scherme dal titul, in Conession direte, o su la pagjine Play dal lançadôr.",
-  "horizon.friends.copied": "Copiât",
-  "horizon.friends.copy_code": "Codiç di copie",
-  "horizon.friends.stop_sharing": "Fermâ di condividi",
-  "horizon.friends.none_yet": "Ancjemò nissun amì culì.",
-  "horizon.friends.here_now": "Eco cumò: %s",
-  "horizon.friends.share_intro": "Condividi chest mont daûr di un codiç di invit: al si vierç ae LAN, e i amîs su internet a si unissin cul codiç. Nissun nestri servidôr al è coinvolt.",
-  "horizon.friends.start_sharing": "Scomencia a condividi",
-  "horizon.friends.troubleshooting": "Risoluzion dai problemis...",
-  "horizon.friends.stopped": "Fermât di condividi il codiç di invit.",
-  "horizon.friends.short_code_changed": "Cualchidun al continuave a provâ un codiç curt sbalît, cussì al cambià.",
-  "horizon.friends.wrong_code": "Cualchidun al à provât un codiç sbalît.",
-  "horizon.friends.relay_stopped": "Masse codiçs curts sbalâts, cussì il relê al è spent fin che no tu condividis di gnûf. I amîs a puedin ancjemò jentrâ cul codiç complet.",
-  "horizon.friends.code_ready": "Il to codiç di invit al è pront: Menu dal zûc, Zugâ cui amîs. Copielu e mandâlu ai tois amiis.",
-  "horizon.friends.share_failed": "No rivave a condividi il mont: %s",
-  "horizon.friends.finding_route": "Cjatâ cemût che i amîs a puedin rivâ a te...",
   "horizon.osk.shift": "Cambi",
   "horizon.osk.space": "Spazi",
   "horizon.osk.delete": "Elimina",

crates/horizon-client/assets/horizon/lang/fy_nl.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Start it spul opnij om %s tapasse te litten: se foegje blokken, items of wrâldgeneraasje ta.",
   "horizon.shader_options.profile": "Profyl",
   "horizon.agent.copy_details": "Kopiearje Ferbiningsdetails",
-  "horizon.multiplayer.join": "Meidwaan",
   "horizon.multiplayer.cancel_reconnecting": "Ofbrekke opnij ferbinen",
-  "horizon.multiplayer.join_friend": "Doch mei oan in freon",
-  "horizon.multiplayer.invite_code": "Koade útnoegje",
-  "horizon.multiplayer.relay": "Relais (opsjoneel)",
   "Preset": "Foarynsteld",
   "LOD Distance": "LOD Ofstân",
   "Far Detail": "Fier Detail",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Offline profilen hearre ta dit eksimplaar",
   "horizon.splitscreen.profiles.move": "Ferpleats wêr't jo spylje",
   "horizon.splitscreen.profiles.move_place": "Ferpleats wêr't jo spylje: %s",
-  "horizon.friends.title": "Boartsje mei freonen",
-  "horizon.friends.hint": "Freonen plakke de koade nei de knop Freonen fan it titelskerm, yn Direkte ferbining, of op 'e Play-side fan 'e launcher.",
-  "horizon.friends.copied": "Kopiearre",
-  "horizon.friends.copy_code": "Kopiearje Code",
-  "horizon.friends.stop_sharing": "Stopje mei dielen",
-  "horizon.friends.none_yet": "Gjin freonen hjir noch.",
-  "horizon.friends.here_now": "Hjir no: %s",
-  "horizon.friends.share_intro": "Diel dizze wrâld efter in útnoegingskoade: it iepenet nei LAN, en freonen op it ynternet dogge mei mei de koade. Gjin tsjinner fan ús is belutsen.",
-  "horizon.friends.start_sharing": "Begjin te dielen",
-  "horizon.friends.troubleshooting": "Problemen oplosse...",
-  "horizon.friends.stopped": "Stoppe mei it dielen fan de útnoegingskoade.",
-  "horizon.friends.short_code_changed": "Immen besocht hieltyd in ferkearde koarte koade, dus it feroare.",
-  "horizon.friends.wrong_code": "Immen besocht in ferkearde koade.",
-  "horizon.friends.relay_stopped": "Te folle ferkearde koadekoarten, dus de estafette stiet út oant jo wer diele. Freonen kinne noch altyd mei de folsleine koade meidwaan.",
-  "horizon.friends.code_ready": "Jo útnoegingskoade is klear: Game Menu, Boartsje mei freonen. Kopiearje it en stjoer it nei jo freonen.",
-  "horizon.friends.share_failed": "Koe de wrâld net diele: %s",
-  "horizon.friends.finding_route": "Fyn hoe't freonen jo kinne berikke ...",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Romte",
   "horizon.osk.delete": "Wiskje",

crates/horizon-client/assets/horizon/lang/ga_ie.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Atosaigh an cluiche chun %s a chur i bhfeidhm: cuireann siad bloic, míreanna nó giniúint domhain leis.",
   "horizon.shader_options.profile": "Próifíl",
   "horizon.agent.copy_details": "Cóipeáil Sonraí Ceangail",
-  "horizon.multiplayer.join": "Bígí",
   "horizon.multiplayer.cancel_reconnecting": "Cealaigh Athnascadh",
-  "horizon.multiplayer.join_friend": "Bígí le Cara",
-  "horizon.multiplayer.invite_code": "Cód Cuireadh",
-  "horizon.multiplayer.relay": "Sealaíocht (roghnach)",
   "Preset": "Réamhshocraithe",
   "LOD Distance": "LOD Fad",
   "Far Detail": "Far Sonraigh",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Baineann próifílí as líne leis an gcás seo",
   "horizon.splitscreen.profiles.move": "Bog áit a imríonn tú",
   "horizon.splitscreen.profiles.move_place": "Bog áit a imríonn tú: %s",
-  "horizon.friends.title": "Seinn le Cairde",
-  "horizon.friends.hint": "Greamaigh Cairde an cód tar éis cnaipe Cairde an scáileáin teidil, i Ceangal Díreach, nó ar leathanach Súgartha an Tosaitheora.",
-  "horizon.friends.copied": "Cóipeáladh",
-  "horizon.friends.copy_code": "Cóipeáil Cód",
-  "horizon.friends.stop_sharing": "Stop Roinnt",
-  "horizon.friends.none_yet": "Níl aon chairde anseo fós.",
-  "horizon.friends.here_now": "Anseo anois: %s",
-  "horizon.friends.share_intro": "Roinn an domhan seo taobh thiar de chód cuirí: osclaíonn sé go LAN, agus glacann cairde ar an idirlíon leis an gcód. Níl aon fhreastalaí dár gcuid i gceist.",
-  "horizon.friends.start_sharing": "Tosaigh ag Roinnt",
-  "horizon.friends.troubleshooting": "Fabhtcheartú...",
-  "horizon.friends.stopped": "Stopadh an cód cuirí a roinnt.",
-  "horizon.friends.short_code_changed": "Lean duine éigin ag iarraidh cód gearr mícheart, mar sin d'athraigh sé.",
-  "horizon.friends.wrong_code": "Bhain duine éigin triail as cód mícheart.",
-  "horizon.friends.relay_stopped": "An iomarca cóid ghearra míchearta, mar sin tá an sealaíocht as go dtí go roinnfidh tú arís. Is féidir le cairde teacht isteach fós leis an gcód iomlán.",
-  "horizon.friends.code_ready": "Tá do chód cuireadh réidh: Roghchlár Cluiche, Spraoi le Cairde. Cóipeáil é agus seol chuig do chairde é.",
-  "horizon.friends.share_failed": "Níorbh fhéidir an domhan a roinnt: %s",
-  "horizon.friends.finding_route": "Ag fáil amach conas is féidir le cairde dul i dteagmháil leat…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Spás",
   "horizon.osk.delete": "Scrios",

crates/horizon-client/assets/horizon/lang/gd_gb.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Ath-thòisich an geama gus %s a chur an sàs: tha iad a' cur blocaichean, nithean no gineadh saoghail ris.",
   "horizon.shader_options.profile": "Pròifil",
   "horizon.agent.copy_details": "Dèan lethbhreac den fhiosrachadh ceangail",
-  "horizon.multiplayer.join": "Thig còmhla",
   "horizon.multiplayer.cancel_reconnecting": "Sguir dhen ath-cheangal",
-  "horizon.multiplayer.join_friend": "Thig còmhla ri Caraid",
-  "horizon.multiplayer.invite_code": "Còd cuireadh",
-  "horizon.multiplayer.relay": "Ath-chraoladh (roghainneil)",
   "Preset": "Ro-shuidhichte",
   "LOD Distance": "Astar LOD",
   "Far Detail": "Fada mionaideach",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Buinidh pròifilean far-loidhne don t-suidheachadh seo",
   "horizon.splitscreen.profiles.move": "Gluais far a bheil thu a 'cluich",
   "horizon.splitscreen.profiles.move_place": "Gluais far a bheil thu a’ cluich: %s",
-  "horizon.friends.title": "Cluich le caraidean",
-  "horizon.friends.hint": "Bidh caraidean a’ cuir a-steach an còd às deidh putan Caraidean an sgrion tiotal, ann an Direct Connection, no air duilleag Cluich an lannsair.",
-  "horizon.friends.copied": "Rinn lethbhreac",
-  "horizon.friends.copy_code": "Dèan lethbhreac den Chòd",
-  "horizon.friends.stop_sharing": "Stad air roinneadh",
-  "horizon.friends.none_yet": "Chan eil caraidean an seo fhathast.",
-  "horizon.friends.here_now": "Seo agaibh a-nis: %s",
-  "horizon.friends.share_intro": "Roinn an saoghal seo air cùl còd cuireadh: bidh e a’ fosgladh gu LAN, agus bidh caraidean air an eadar-lìn a’ tighinn còmhla ris a’ chòd. Chan eil seirbheisiche sam bith againn an sàs.",
-  "horizon.friends.start_sharing": "Tòisich a 'roinneadh",
-  "horizon.friends.troubleshooting": "Fuasgladh thrioblaidean...",
-  "horizon.friends.stopped": "Sguir a bhith a’ roinneadh a’ chòd cuireadh.",
-  "horizon.friends.short_code_changed": "Chùm cuideigin a’ feuchainn còd goirid ceàrr, agus mar sin dh’atharraich e.",
-  "horizon.friends.wrong_code": "Dh’fheuch cuideigin còd ceàrr.",
-  "horizon.friends.relay_stopped": "Cus de chòdan goirid ceàrr, agus mar sin tha an t-sealaidheachd dheth gus an roinn thu a-rithist. Faodaidh caraidean a dhol còmhla leis a' chòd slàn fhathast.",
-  "horizon.friends.code_ready": "Tha an còd cuireadh agad deiseil: Clàr Gèam, Cluich le Caraidean. Dèan lethbhreac dheth agus cuir gu do charaidean e.",
-  "horizon.friends.share_failed": "Cha b’ urrainn dhuinn an saoghal a cho-roinn: %s",
-  "horizon.friends.finding_route": "Faigh a-mach mar as urrainn do charaidean ruighinn ort…",
   "horizon.osk.shift": "Gluasad",
   "horizon.osk.space": "Àite",
   "horizon.osk.delete": "Sguab às",

crates/horizon-client/assets/horizon/lang/gl_es.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Reinicia o xogo para aplicar %s: engaden bloques, obxectos ou xeración do mundo.",
   "horizon.shader_options.profile": "Perfil",
   "horizon.agent.copy_details": "Copiar os detalles da conexión",
-  "horizon.multiplayer.join": "Únete",
   "horizon.multiplayer.cancel_reconnecting": "Cancelar a conexión",
-  "horizon.multiplayer.join_friend": "Únete a un amigo",
-  "horizon.multiplayer.invite_code": "Código de invitación",
-  "horizon.multiplayer.relay": "Relé (opcional)",
   "Preset": "Predefinido",
   "LOD Distance": "Distancia LOD",
   "Far Detail": "Detalle lonxano",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Os perfís sen conexión pertencen a esta instancia",
   "horizon.splitscreen.profiles.move": "Móvete onde xogas",
   "horizon.splitscreen.profiles.move_place": "Move onde xogas: %s",
-  "horizon.friends.title": "Xoga cos amigos",
-  "horizon.friends.hint": "Os amigos pegan o código despois do botón Amigos da pantalla de título, na Conexión directa ou na páxina Play do iniciador.",
-  "horizon.friends.copied": "Copiouse",
-  "horizon.friends.copy_code": "Copiar código",
-  "horizon.friends.stop_sharing": "Deixa de compartir",
-  "horizon.friends.none_yet": "Aínda non hai amigos aquí.",
-  "horizon.friends.here_now": "Aquí agora: %s",
-  "horizon.friends.share_intro": "Comparte este mundo detrás dun código de invitación: ábrese a LAN e os amigos de Internet únense co código. Ningún servidor noso está implicado.",
-  "horizon.friends.start_sharing": "Comeza a compartir",
-  "horizon.friends.troubleshooting": "Solución de problemas...",
-  "horizon.friends.stopped": "Deixou de compartir o código de invitación.",
-  "horizon.friends.short_code_changed": "Alguén seguiu probando un código curto incorrecto, polo que cambiou.",
-  "horizon.friends.wrong_code": "Alguén intentou un código incorrecto.",
-  "horizon.friends.relay_stopped": "Demasiados códigos curtos incorrectos, polo que o relé está desactivado ata que volvas compartir. Os amigos aínda poden unirse co código completo.",
-  "horizon.friends.code_ready": "O teu código de invitación está listo: Menú Xogo, Xoga cos amigos. Cópiao e envíao aos teus amigos.",
-  "horizon.friends.share_failed": "Non se puido compartir o mundo: %s",
-  "horizon.friends.finding_route": "Buscando como os amigos poden contactar contigo...",
   "horizon.osk.shift": "Cambio",
   "horizon.osk.space": "Espazo",
   "horizon.osk.delete": "Eliminar",

crates/horizon-client/assets/horizon/lang/haw_us.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "E hoʻomaka hou i ka pāʻani e hoʻohana iā %s: hoʻohui lākou i nā poloka, nā mea a i ʻole ka hana honua.",
   "horizon.shader_options.profile": "Pilikino",
   "horizon.agent.copy_details": "E kope i nā kikoʻī pili",
-  "horizon.multiplayer.join": "Hui",
   "horizon.multiplayer.cancel_reconnecting": "Hoʻopau i ka hoʻohui hou ʻana",
-  "horizon.multiplayer.join_friend": "E hui me kahi Hoa",
-  "horizon.multiplayer.invite_code": "Code kono",
-  "horizon.multiplayer.relay": "Relay (koho)",
   "Preset": "Hoʻonohonoho mua",
   "LOD Distance": "LOD mamao",
   "Far Detail": "ʻIke lōʻihi",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "No kēia laʻana nā ʻaoʻao pahemo",
   "horizon.splitscreen.profiles.move": "E neʻe i kahi āu e pāʻani ai",
   "horizon.splitscreen.profiles.move_place": "E neʻe i kahi āu e pāʻani ai: %s",
-  "horizon.friends.title": "E pāʻani me nā hoa",
-  "horizon.friends.hint": "Hoʻopili nā hoa i ke code ma hope o ke pihi Hoa o ka pale poʻo inoa, ma Direct Connection, a i ʻole ma ka ʻaoʻao Play o ka mea hoʻolaha.",
-  "horizon.friends.copied": "Kope ʻia",
-  "horizon.friends.copy_code": "Kāhea kope",
-  "horizon.friends.stop_sharing": "Hooki i ka Kaʻana like",
-  "horizon.friends.none_yet": "ʻAʻohe hoa ma ʻaneʻi.",
-  "horizon.friends.here_now": "Eia i kēia manawa: %s",
-  "horizon.friends.share_intro": "E kaʻana like i kēia ao ma hope o kahi code kono: wehe ia i LAN, a hui pū nā hoaaloha ma ka pūnaewele me ke code. ʻAʻohe kikowaena o kā mākou pili.",
-  "horizon.friends.start_sharing": "Hoʻomaka Kaʻana like",
-  "horizon.friends.troubleshooting": "Hoʻoponopono pilikia...",
-  "horizon.friends.stopped": "Ua ho'ōki i ka hāʻawi ʻana i ke code kono.",
-  "horizon.friends.short_code_changed": "Ke hoʻāʻo nei kekahi i kahi code pōkole hewa, no laila ua loli.",
-  "horizon.friends.wrong_code": "Ua hoʻāʻo kekahi i kahi code hewa.",
-  "horizon.friends.relay_stopped": "Nui loa nā code pōkole hewa, no laila ua paʻa ka relay a hiki i kou kaʻana hou ʻana. Hiki nō i nā hoaaloha ke hui me ka code piha.",
-  "horizon.friends.code_ready": "Ua mākaukau kāu code kono: Game Menu, Play with Friends. E kope a hoʻouna aku i kāu mau hoaaloha.",
-  "horizon.friends.share_failed": "ʻAʻole hiki ke kaʻana like i ka honua: %s",
-  "horizon.friends.finding_route": "Ke ʻimi nei pehea e hiki ai i nā hoaaloha ke loaʻa iā ʻoe…",
   "horizon.osk.shift": "Hoʻololi",
   "horizon.osk.space": "Pā Hakahaka",
   "horizon.osk.delete": "Holoi",

crates/horizon-client/assets/horizon/lang/he_il.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "הפעל מחדש את המשחק כדי להחיל %s: הם מוסיפים בלוקים, פריטים או יצירת עולם.",
   "horizon.shader_options.profile": "פרופיל",
   "horizon.agent.copy_details": "העתק את פרטי החיבור",
-  "horizon.multiplayer.join": "הצטרף",
   "horizon.multiplayer.cancel_reconnecting": "בטל חיבור מחדש",
-  "horizon.multiplayer.join_friend": "הצטרף לחבר",
-  "horizon.multiplayer.invite_code": "קוד הזמנה",
-  "horizon.multiplayer.relay": "ממסר (אופציונלי)",
   "Preset": "מוגדר מראש",
   "LOD Distance": "מרחק LOD",
   "Far Detail": "פרט רחוק",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "פרופילים לא מקוונים שייכים למופע הזה",
   "horizon.splitscreen.profiles.move": "זז לאן שאתה משחק",
   "horizon.splitscreen.profiles.move_place": "זז לאן שאתה משחק: %s",
-  "horizon.friends.title": "שחקו עם חברים",
-  "horizon.friends.hint": "חברים מדביקים את הקוד אחרי כפתור החברים של מסך הכותרת, בחיבור ישיר או בדף ההפעלה של המשגר.",
-  "horizon.friends.copied": "הועתק",
-  "horizon.friends.copy_code": "העתק קוד",
-  "horizon.friends.stop_sharing": "תפסיק לשתף",
-  "horizon.friends.none_yet": "אין כאן חברים עדיין.",
-  "horizon.friends.here_now": "כאן עכשיו: %s",
-  "horizon.friends.share_intro": "שתף את העולם הזה מאחורי קוד הזמנה: הוא נפתח ל-LAN, וחברים באינטרנט מצטרפים עם הקוד. אף שרת שלנו לא מעורב.",
-  "horizon.friends.start_sharing": "התחל לשתף",
-  "horizon.friends.troubleshooting": "פתרון בעיות...",
-  "horizon.friends.stopped": "הפסיק לשתף את קוד ההזמנה.",
-  "horizon.friends.short_code_changed": "מישהו כל הזמן ניסה קוד קצר שגוי, אז זה השתנה.",
-  "horizon.friends.wrong_code": "מישהו ניסה קוד שגוי.",
-  "horizon.friends.relay_stopped": "יותר מדי קודים קצרים שגויים, ולכן הממסר כבוי עד שתשתף שוב. חברים עדיין יכולים להצטרף עם הקוד המלא.",
-  "horizon.friends.code_ready": "קוד ההזמנה שלך מוכן: תפריט משחק, שחק עם חברים. העתק אותו ושלח אותו לחברים שלך.",
-  "horizon.friends.share_failed": "לא יכולתי לשתף את העולם: %s",
-  "horizon.friends.finding_route": "מוצא כיצד חברים יכולים להגיע אליך...",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "חלל",
   "horizon.osk.delete": "מחק",

crates/horizon-client/assets/horizon/lang/hi_in.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "%s लागू करने के लिए गेम रीस्टार्ट करें: वे ब्लॉक, आइटम या विश्व जनरेशन जोड़ते हैं।",
   "horizon.shader_options.profile": "प्रोफ़ाइल",
   "horizon.agent.copy_details": "कनेक्शन विवरण कॉपी करें",
-  "horizon.multiplayer.join": "शामिल हों",
   "horizon.multiplayer.cancel_reconnecting": "पुनः कनेक्ट करना रद्द करें",
-  "horizon.multiplayer.join_friend": "मित्र से जुड़ें",
-  "horizon.multiplayer.invite_code": "आमंत्रण कोड",
-  "horizon.multiplayer.relay": "रिले (वैकल्पिक)",
   "Preset": "प्रीसेट",
   "LOD Distance": "LOD दूरी",
   "Far Detail": "दूर के विवरण",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "ऑफ़लाइन प्रोफ़ाइल इस इंस्टेंस के हैं",
   "horizon.splitscreen.profiles.move": "स्थानांतरित करें जहाँ आप खेलते हैं",
   "horizon.splitscreen.profiles.move_place": "स्थानांतरित करें जहाँ आप खेलते हैं: %s",
-  "horizon.friends.title": "मित्रों के साथ खेलें",
-  "horizon.friends.hint": "मित्र शीर्षक स्क्रीन के फ्रेंड्स बटन के बाद, डायरेक्ट कनेक्शन में, या लॉन्चर के प्ले पेज पर कोड पेस्ट करते हैं।",
-  "horizon.friends.copied": "कॉपी किया गया",
-  "horizon.friends.copy_code": "कोड कॉपी करें",
-  "horizon.friends.stop_sharing": "साझा करना बंद करें",
-  "horizon.friends.none_yet": "यहाँ अभी कोई मित्र नहीं है।",
-  "horizon.friends.here_now": "अभी यहाँ हैं: %s",
-  "horizon.friends.share_intro": "इस दुनिया को आमंत्रण कोड के पीछे साझा करें: यह LAN के लिए खुलता है, और इंटरनेट पर मित्र कोड के साथ जुड़ते हैं। इसमें हमारा कोई सर्वर शामिल नहीं है।",
-  "horizon.friends.start_sharing": "साझा करना शुरू करें",
-  "horizon.friends.troubleshooting": "समस्या निवारण...",
-  "horizon.friends.stopped": "आमंत्रण कोड साझा करना बंद कर दिया।",
-  "horizon.friends.short_code_changed": "किसी ने बार-बार गलत शॉर्ट कोड आजमाया, इसलिए यह बदल गया।",
-  "horizon.friends.wrong_code": "किसी ने गलत कोड आजमाया।",
-  "horizon.friends.relay_stopped": "बहुत अधिक गलत शॉर्ट कोड, इसलिए दोबारा साझा करने तक रिले बंद है। मित्र अभी भी पूर्ण कोड से जुड़ सकते हैं।",
-  "horizon.friends.code_ready": "आपका आमंत्रण कोड तैयार है: गेम मेनू, प्ले विद फ्रेंड्स। इसे कॉपी करें और अपने मित्रों को भेजें।",
-  "horizon.friends.share_failed": "दुनिया साझा नहीं की जा सकी: %s",
-  "horizon.friends.finding_route": "ढूंढ रहे हैं कि मित्र आप तक कैसे पहुँच सकते हैं…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Space",
   "horizon.osk.delete": "Delete",

crates/horizon-client/assets/horizon/lang/hr_hr.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Ponovno pokrenite igru da biste primijenili %s: dodaju blokove, predmete ili generiranje svijeta.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Kopiraj pojedinosti veze",
-  "horizon.multiplayer.join": "Pridruži se",
   "horizon.multiplayer.cancel_reconnecting": "Otkaži ponovno povezivanje",
-  "horizon.multiplayer.join_friend": "Pridruži se prijatelju",
-  "horizon.multiplayer.invite_code": "Pozivni kod",
-  "horizon.multiplayer.relay": "Prijenos (neobavezno)",
   "Preset": "Predložak",
   "LOD Distance": "LOD udaljenost",
   "Far Detail": "Udaljeni detalji",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Izvanmrežni profili pripadaju ovoj instanci",
   "horizon.splitscreen.profiles.move": "Premjesti mjesto igranja",
   "horizon.splitscreen.profiles.move_place": "Premjesti mjesto igranja: %s",
-  "horizon.friends.title": "Igraj s prijateljima",
-  "horizon.friends.hint": "Prijatelji lijepe kod nakon gumba Prijatelji na naslovnom zaslonu, u izravnom povezivanju ili na stranici za igranje pokretača.",
-  "horizon.friends.copied": "Kopirano",
-  "horizon.friends.copy_code": "Kopiraj kod",
-  "horizon.friends.stop_sharing": "Zaustavi dijeljenje",
-  "horizon.friends.none_yet": "Ovdje još nema prijatelja.",
-  "horizon.friends.here_now": "Ovdje sada: %s",
-  "horizon.friends.share_intro": "Podijelite ovaj svijet iza pozivnog koda: otvara se za LAN, a prijatelji na internetu pridružuju se s kodom. Nijedan naš poslužitelj nije uključen.",
-  "horizon.friends.start_sharing": "Započni dijeljenje",
-  "horizon.friends.troubleshooting": "Rješavanje problema...",
-  "horizon.friends.stopped": "Zaustavljeno dijeljenje pozivnog koda.",
-  "horizon.friends.short_code_changed": "Netko je stalno pokušavao unijeti pogrešan kratki kod, pa se on promijenio.",
-  "horizon.friends.wrong_code": "Netko je pokušao unijeti pogrešan kod.",
-  "horizon.friends.relay_stopped": "Previše pogrešnih kratkih kodova, pa je prijenos isključen dok ponovno ne podijelite. Prijatelji se još mogu pridružiti s punim kodom.",
-  "horizon.friends.code_ready": "Vaš pozivni kod je spreman: Izbornik igre, Igraj s prijateljima. Kopirajte ga i pošaljite svojim prijateljima.",
-  "horizon.friends.share_failed": "Nije moguće dijeliti svijet: %s",
-  "horizon.friends.finding_route": "Pronalaženje načina na koji vas prijatelji mogu dosegnuti…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Razmaknica",
   "horizon.osk.delete": "Izbriši",

crates/horizon-client/assets/horizon/lang/hu_hu.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Indítsa újra a játékot a(z) %s érvényesítéséhez: blokkokat, tárgyakat vagy világgenerálást ad hozzá.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Másolja a kapcsolat részleteit",
-  "horizon.multiplayer.join": "Csatlakozz",
   "horizon.multiplayer.cancel_reconnecting": "Az újracsatlakozás megszakítása",
-  "horizon.multiplayer.join_friend": "Csatlakozz egy baráthoz",
-  "horizon.multiplayer.invite_code": "Meghívó kód",
-  "horizon.multiplayer.relay": "Relé (opcionális)",
   "Preset": "Előre beállított",
   "LOD Distance": "LOD távolság",
   "Far Detail": "Távoli részlet",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Az offline profilok ehhez a példányhoz tartoznak",
   "horizon.splitscreen.profiles.move": "Menj oda, ahol játszol",
   "horizon.splitscreen.profiles.move_place": "Menjen oda, ahol játszik: %s",
-  "horizon.friends.title": "Játssz a barátokkal",
-  "horizon.friends.hint": "Az ismerősök beillesztik a kódot a címképernyő Barátok gombja mögé, a Közvetlen kapcsolatba vagy az indító Play oldalára.",
-  "horizon.friends.copied": "Másolva",
-  "horizon.friends.copy_code": "Kód másolása",
-  "horizon.friends.stop_sharing": "Megosztás leállítása",
-  "horizon.friends.none_yet": "Még nincsenek itt barátok.",
-  "horizon.friends.here_now": "Itt most: %s",
-  "horizon.friends.share_intro": "Oszd meg ezt a világot egy meghívókód mögött: megnyílik a LAN-hoz, és az interneten lévő ismerősök is csatlakoznak a kódhoz. A mi szerverünk nem érintett.",
-  "horizon.friends.start_sharing": "Indítsa el a Megosztást",
-  "horizon.friends.troubleshooting": "Hibaelhárítás...",
-  "horizon.friends.stopped": "A meghívókód megosztása leállt.",
-  "horizon.friends.short_code_changed": "Valaki folyamatosan rossz rövid kóddal próbálkozott, ezért megváltozott.",
-  "horizon.friends.wrong_code": "Valaki rossz kóddal próbálkozott.",
-  "horizon.friends.relay_stopped": "Túl sok rossz rövid kód érkezett, ezért a relé ki van kapcsolva, amíg újra nem osztja meg. A barátok a teljes kóddal továbbra is csatlakozhatnak.",
-  "horizon.friends.code_ready": "A meghívókód készen áll: Játékmenü, Játssz a barátokkal. Másold ki és küldd el ismerőseidnek.",
-  "horizon.friends.share_failed": "Nem sikerült megosztani a világot: %s",
-  "horizon.friends.finding_route": "Megtudja, hogyan érhetnek el barátaid…",
   "horizon.osk.shift": "Váltás",
   "horizon.osk.space": "Tér",
   "horizon.osk.delete": "Törölje",

crates/horizon-client/assets/horizon/lang/hy_am.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Վերագործարկեք խաղը՝ %s-ը կիրառելու համար. դրանք ավելացնում են բլոկներ, իրեր կամ աշխարհի գեներացիա։",
   "horizon.shader_options.profile": "Անձնագիր",
   "horizon.agent.copy_details": "Պատճենել կապի մանրամասները",
-  "horizon.multiplayer.join": "Միանալ",
   "horizon.multiplayer.cancel_reconnecting": "Չեղարկել վերամիացումը",
-  "horizon.multiplayer.join_friend": "Միացեք ընկերոջը",
-  "horizon.multiplayer.invite_code": "Հրավիրել կոդը",
-  "horizon.multiplayer.relay": "Ռելե (ըստ ցանկության)",
   "Preset": "Նախադրված",
   "LOD Distance": "LOD Հեռավորություն",
   "Far Detail": "Հեռավոր մանրամասն",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Անցանց պրոֆիլները պատկանում են այս օրինակին",
   "horizon.splitscreen.profiles.move": "Տեղափոխեք այնտեղ, որտեղ խաղում եք",
   "horizon.splitscreen.profiles.move_place": "Տեղափոխեք այնտեղ, որտեղ խաղում եք՝ %s",
-  "horizon.friends.title": "Խաղացեք ընկերների հետ",
-  "horizon.friends.hint": "Ընկերները տեղադրում են կոդը վերնագրի էկրանի Ընկերներ կոճակից հետո, ուղիղ միացումում կամ գործարկողի Play էջում:",
-  "horizon.friends.copied": "Պատճենվել է",
-  "horizon.friends.copy_code": "Պատճենել կոդը",
-  "horizon.friends.stop_sharing": "Դադարեցնել համօգտագործումը",
-  "horizon.friends.none_yet": "Այստեղ դեռ ընկերներ չկան:",
-  "horizon.friends.here_now": "Ահա հիմա: %s",
-  "horizon.friends.share_intro": "Կիսվեք այս աշխարհով հրավերի կոդով. այն բացվում է LAN-ի համար, և ինտերնետում գտնվող ընկերները միանում են կոդով: Մեր ոչ մի սերվեր ներգրավված չէ:",
-  "horizon.friends.start_sharing": "Սկսեք համօգտագործել",
-  "horizon.friends.troubleshooting": "Անսարքությունների վերացում...",
-  "horizon.friends.stopped": "Դադարեցվել է հրապարակել հրավերի կոդը:",
-  "horizon.friends.short_code_changed": "Ինչ-որ մեկը շարունակում էր սխալ կարճ կոդ փորձել, ուստի այն փոխվեց:",
-  "horizon.friends.wrong_code": "Ինչ-որ մեկը սխալ կոդ է փորձել:",
-  "horizon.friends.relay_stopped": "Չափից շատ սխալ կարճ կոդեր, ուստի ռելեն անջատված է, մինչև նորից կիսվեք։ Ընկերները դեռ կարող են միանալ ամբողջական կոդով։",
-  "horizon.friends.code_ready": "Ձեր հրավերի կոդը պատրաստ է. Խաղի ընտրացանկ, Խաղացեք ընկերների հետ: Պատճենեք այն և ուղարկեք ձեր ընկերներին։",
-  "horizon.friends.share_failed": "Չեմ կարող կիսվել աշխարհով. %s",
-  "horizon.friends.finding_route": "Գտեք, թե ինչպես ընկերները կարող են կապվել ձեզ հետ…",
   "horizon.osk.shift": "Հերթափոխ",
   "horizon.osk.space": "Տիեզերք",
   "horizon.osk.delete": "Ջնջել",

crates/horizon-client/assets/horizon/lang/id_id.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Mulai ulang game untuk menerapkan %s: mod ini menambahkan blok, item, atau pembuatan dunia.",
   "horizon.shader_options.profile": "Profil",
   "horizon.agent.copy_details": "Salin Detail Koneksi",
-  "horizon.multiplayer.join": "Gabung",
   "horizon.multiplayer.cancel_reconnecting": "Batalkan Menyambungkan Ulang",
-  "horizon.multiplayer.join_friend": "Gabung dengan Teman",
-  "horizon.multiplayer.invite_code": "Kode Undangan",
-  "horizon.multiplayer.relay": "Relay (opsional)",
   "Preset": "Prasetel",
   "LOD Distance": "Jarak LOD",
   "Far Detail": "Detail Jauh",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Profil offline milik instans ini",
   "horizon.splitscreen.profiles.move": "Pindahkan posisi bermain",
   "horizon.splitscreen.profiles.move_place": "Pindahkan posisi bermain: %s",
-  "horizon.friends.title": "Bermain dengan Teman",
-  "horizon.friends.hint": "Teman menempelkan kode setelah mengeklik tombol Teman di layar judul, melalui Koneksi Langsung (Direct Connection), atau di halaman Main peluncur.",
-  "horizon.friends.copied": "Disalin",
-  "horizon.friends.copy_code": "Salin Kode",
-  "horizon.friends.stop_sharing": "Berhenti Berbagi",
-  "horizon.friends.none_yet": "Belum ada teman di sini.",
-  "horizon.friends.here_now": "Di sini sekarang: %s",
-  "horizon.friends.share_intro": "Bagikan dunia ini di balik kode undangan: dunia akan terbuka untuk LAN, dan teman di internet dapat bergabung menggunakan kode tersebut. Tidak ada server kami yang dilibatkan.",
-  "horizon.friends.start_sharing": "Mulai Berbagi",
-  "horizon.friends.troubleshooting": "Pemecahan Masalah...",
-  "horizon.friends.stopped": "Berhenti berbagi kode undangan.",
-  "horizon.friends.short_code_changed": "Seseorang terus mencoba kode pendek yang salah, sehingga kode telah diubah.",
-  "horizon.friends.wrong_code": "Seseorang mencoba memasukkan kode yang salah.",
-  "horizon.friends.relay_stopped": "Terlalu banyak kode pendek yang salah, sehingga relay nonaktif hingga Anda berbagi lagi. Teman tetap dapat bergabung dengan kode lengkap.",
-  "horizon.friends.code_ready": "Kode undangan Anda sudah siap: Menu Game -> Bermain dengan Teman. Salin dan kirimkan ke teman-teman Anda.",
-  "horizon.friends.share_failed": "Tidak dapat membagikan dunia: %s",
-  "horizon.friends.finding_route": "Mencari cara agar teman dapat menjangkau Anda…",
   "horizon.osk.shift": "Shift",
   "horizon.osk.space": "Spasi",
   "horizon.osk.delete": "Hapus",

crates/horizon-client/assets/horizon/lang/ig_ng.json

@@ -213,11 +213,7 @@
   "horizon.mods.switch.restart": "Malitegharịa egwuregwu ka itinye %s n'ọrụ: ha na-agbakwunye blọk, ihe ma ọ bụ imepụta ụwa.",
   "horizon.shader_options.profile": "Profaịlụ",
   "horizon.agent.copy_details": "Detuo nkọwa njikọ",
-  "horizon.multiplayer.join": "Soro",
   "horizon.multiplayer.cancel_reconnecting": "Kagbuo njikọ ọzọ",
-  "horizon.multiplayer.join_friend": "Soro enyi",
-  "horizon.multiplayer.invite_code": "Koodu ịkpọ oku",
-  "horizon.multiplayer.relay": "Ntugharị (nhọrọ)",
   "Preset": "Ntọala",
   "LOD Distance": "Ogologo LOD",
   "Far Detail": "Nkọwa zuru oke",
@@ -462,23 +458,6 @@
   "horizon.splitscreen.profiles.offline_note": "Profaịlụ ndị na-anọghị n'ịntanetị bụ nke ihe atụ a",
   "horizon.splitscreen.profiles.move": "Bugharịa ebe ị na-egwu",
   "horizon.splitscreen.profiles.move_place": "Bugharịa ebe ị na-egwu: %s",
-  "horizon.friends.title": "Soro ndị enyi gwuo egwu",
-  "horizon.friends.hint": "Ndị enyi na-amanye koodu ahụ ka bọtịnụ ndị enyi gachara aha ihuenyo ahụ, na njikọ Direct, ma ọ bụ na ibe Play nke onye mbido.",
-  "horizon.friends.copied": "Eṅomiri",
-  "horizon.friends.copy_code": "Detuo koodu",
-  "horizon.friends.stop_sharing": "Kwụsị ikekọrịta",
-  "horizon.friends.none_yet": "Onweghi enyi ebea.",
-  "horizon.friends.here_now": "Ebe a ugbu a: %s",
-  "horizon.friends.share_intro": "Kekọrịta ụwa a n'azụ koodu ịkpọ òkù: ọ ga-emepe na LAN, ndị enyi na ịntanetị sonye na koodu ahụ. Ọ nweghị ihe nkesa nke anyị metụtara.",
-  "horizon.friends.start_sharing": "Malite ikekọrịta",
-  "horizon.friends.troubleshooting": "Nchọpụta nsogbu...",
-  "horizon.friends.stopped": "Kwụsị ikesa koodu ịkpọ òkù.",
-  "horizon.friends.short_code_changed": "Mmadụ nọgidere na-agbalị koodu dị mkpirikpi na-ezighi ezi, ya mere ọ gbanwere.",
-  "horizon.friends.wrong_code": "Mmadụ nwara koodu na-ezighi ezi.",
-  "horizon.friends.relay_stopped": "Koodu mkpụmkpụ na-ezighi ezi karịrị oke, ya mere relay agbanyụrụ ruo mgbe i ga-ekerịta ọzọ. Ndị enyi ka nwere ike iso na koodu zuru oke.",
-  "horizon.friends.code_ready": "Koodu ịkpọ oku gị adịla njikere: NchNhr Egwuregwu, Soro ndị enyi gwuo egwu. Detuo ya ma ziga ya ndị enyi gị.",
-  "horizon.friends.share_failed": "Enweghị ike ịkekọrịta ụwa: %s",
-  "horizon.friends.finding_route": "Ịchọta ka ndị enyi ga-esi nweta gị…",
   "horizon.osk.shift": "Mgbanwe",
   "horizon.osk.space": "Oghere",
   "horizon.osk.delete": "Hichapụ",