Put the aura test's item at the feet

It reused the crown's 18-pixel attach offset, which an aura may not have
(at most 6 pixels above the feet), so the item failed to parse.

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

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

@@ -1441,16 +1441,6 @@ pub enum Rumble {
     },
     Totem,
 }
-impl From<crate::input_source::Feedback> for Rumble {
-    fn from(event: crate::input_source::Feedback) -> Self {
-        use crate::input_source::Feedback;
-        match event {
-            Feedback::BlockBroken => Rumble::BlockBroken,
-            Feedback::Explosion { distance, radius } => Rumble::Explosion { distance, radius },
-            Feedback::Totem => Rumble::Totem,
-        }
-    }
-}
 /// A vibration: the heavy (low-frequency) and light motors, 0..1, and how
 /// long it lasts.
 #[derive(Clone, Copy, Debug, PartialEq)]

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

@@ -1,15 +0,0 @@
-//! The engine's side of the input source (docs/layers.md, "Controllers, splitscreen, replays and
-//! UI pages"): what gameplay tells a device beyond the keyboard and mouse. Gameplay names these
-//! types, never a controller's; the controller code answers.
-
-/// Something that happened to the player that a device may let them feel (a controller's
-/// vibration). The device decides how, or whether.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Feedback {
-    /// The player broke a block.
-    BlockBroken,
-    /// An explosion this far away (blocks) with this power.
-    Explosion { distance: f64, radius: f32 },
-    /// A totem of undying saved the player.
-    Totem,
-}

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

@@ -9,7 +9,6 @@ pub mod gamepad;
 pub mod gameplay_guide;
 pub mod held;
 pub mod input;
-pub mod input_source;
 pub mod interaction_input;
 pub mod key_names;
 pub mod keybinds;

crates/horizon-client-render/Cargo.toml

@@ -76,10 +76,6 @@ 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/audio_bench.rs

@@ -1,158 +0,0 @@
-//! Audio occlusion, attenuation and mixing benchmark.
-//! Run with: `cargo run --profile fast -p horizon-client-render --example audio_bench`
-use horizon_client_render::{
-    audio::Audio,
-    sound_engine::{MobSound, SoundInstance, Sounds, TickContext},
-};
-use std::{path::Path, time::Instant};
-
-fn main() {
-    println!("=== Horizon Audio Attenuation & Mixing Benchmark ===");
-
-    let mut audio = Audio::silent(Path::new("/nonexistent"));
-    audio.engine.loaded = true;
-    audio.backend_live_for_bench();
-    audio.record_heard = false;
-
-    // Register a sound event with attenuation distance 16
-    audio.engine.registry.add_file(
-        "minecraft",
-        br#"{"bench.loop":{"attenuation_distance":16,"sounds":[{"name":"bench/loop","stream":false}]}}"#,
-        &|_, _| true,
-    );
-    // Insert 1 second of audio into cache (48000 mono samples)
-    let samples: Vec<f32> = (0..48_000)
-        .map(|i| ((i as f32) * 440.0 * 2.0 * std::f32::consts::PI / 48000.0).sin() * 0.5)
-        .collect();
-    audio.insert_cached_sound("minecraft:bench/loop", samples, 48_000, 1);
-
-    // 1. Benchmark set_listener (called every client render frame)
-    let listener_iterations = 200_000;
-    let start = Instant::now();
-    for i in 0..listener_iterations {
-        let angle = (i as f32) * 0.01;
-        audio.set_listener(
-            [
-                100.0 + (angle.cos() as f64) * 5.0,
-                64.0,
-                200.0 + (angle.sin() as f64) * 5.0,
-            ],
-            angle,
-            0.0,
-        );
-    }
-    let listener_elapsed = start.elapsed();
-    println!(
-        "1. set_listener moving (render frame): {:?} for {} calls ({:.2} ns/call)",
-        listener_elapsed,
-        listener_iterations,
-        (listener_elapsed.as_nanos() as f64) / (listener_iterations as f64)
-    );
-
-    // 1b. Benchmark set_listener stationary (lock elimination early-out)
-    let stationary_iterations = 200_000;
-    let start = Instant::now();
-    for _ in 0..stationary_iterations {
-        audio.set_listener([100.0, 64.0, 200.0], 0.0, 0.0);
-    }
-    let stationary_elapsed = start.elapsed();
-    println!(
-        "1b. set_listener stationary (lock early-out): {:?} for {} calls ({:.2} ns/call)",
-        stationary_elapsed,
-        stationary_iterations,
-        (stationary_elapsed.as_nanos() as f64) / (stationary_iterations as f64)
-    );
-
-    // 2. Play 128 sounds in the world at various distances from listener at [100.0, 64.0, 200.0]
-    // 64 sounds within attenuation distance (<16 blocks)
-    // 64 sounds outside attenuation distance (>16 blocks)
-    for i in 0..128 {
-        let dist = if i < 64 {
-            (i as f64) * 0.24 // 0 to 15.1 blocks (audible)
-        } else {
-            17.0 + ((i - 64) as f64) * 1.5 // 17 to 111.5 blocks (out of attenuation range)
-        };
-        let pos = [100.0 + dist, 64.0, 200.0];
-        let instance = SoundInstance::new(
-            "minecraft:bench.loop",
-            crate_sound_source(i),
-            1.0,
-            1.0,
-            horizon_core::random::LegacyRandom::new(i as i64),
-            true, // looping
-            0,
-            horizon_client_render::sound_engine::Attenuation::Linear,
-            pos,
-            false,
-        );
-        audio.play_instance(instance, false);
-    }
-
-    // 3. Benchmark mix_buffer (5000 buffers of 1024 stereo frames @ 48kHz = ~106 seconds of audio mixing)
-    let mut buffer = vec![0.0f32; 1024 * 2];
-    let mix_iterations = 5_000;
-    let start = Instant::now();
-    for _ in 0..mix_iterations {
-        audio.mix_buffer(&mut buffer, 2, 48_000);
-    }
-    let mix_elapsed = start.elapsed();
-    println!(
-        "2. mix_buffer (128 active channels, 1024 stereo frames): {:?} for {} buffers ({:.2} µs/buffer)",
-        mix_elapsed,
-        mix_iterations,
-        (mix_elapsed.as_micros() as f64) / (mix_iterations as f64)
-    );
-
-    // 4. Benchmark SoundEngine::tick with ticking mob sounds
-    let mut mobs = Vec::new();
-    for i in 0..64 {
-        mobs.push(MobSound {
-            id: 2000 + i,
-            position: [100.0 + (i as f64) * 0.5, 64.0, 200.0 + (i as f64) * 0.5],
-            speed: 0.25,
-            baby: false,
-            angry: i % 2 == 0,
-            silent: false,
-            attack_scale: 0.5,
-            sniffer_digging: false,
-        });
-    }
-
-    let tick_ctx = TickContext {
-        player_underwater: false,
-        player_removed: false,
-        vehicle: None,
-        carts: Vec::new(),
-        mobs: mobs.clone(),
-        frozen: false,
-        player_position: [100.0, 64.0, 200.0],
-        player_speed_sqr: 0.1,
-        player_fall_flying: false,
-        ridden: None,
-        camera_position: [100.0, 64.0, 200.0],
-    };
-
-    let tick_iterations = 10_000;
-    let start = Instant::now();
-    for _ in 0..tick_iterations {
-        audio.tick(false, &tick_ctx);
-    }
-    let tick_elapsed = start.elapsed();
-    println!(
-        "3. SoundEngine::tick (64 channels + ticking): {:?} for {} ticks ({:.2} µs/tick)",
-        tick_elapsed,
-        tick_iterations,
-        (tick_elapsed.as_micros() as f64) / (tick_iterations as f64)
-    );
-}
-
-fn crate_sound_source(i: u32) -> usize {
-    match i % 6 {
-        0 => 0, // master
-        1 => 1, // music
-        2 => 2, // records
-        3 => 3, // weather
-        4 => 4, // blocks
-        _ => 5, // hostile
-    }
-}

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 && let Some(suffix) = crate::pack_hooks::formats().emissive_suffix(root) {
-            emissive = crate::native_emissive::load_overlays(root, &suffix, &mut sprites);
+        if draws {
+            emissive = crate::native_emissive::load_optifine(root, &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");
-    // 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 })
+    root.join(if horizon_optifine::paths::valid(&rel) {
+        &rel
+    } else {
+        NOWHERE
+    })
 }
 
 /// `SpriteSourceList.list`: every sprite id of the atlas and its origin.

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

@@ -478,7 +478,6 @@ pub struct Audio {
     pub record_heard: bool,
     pub listener: [f64; 3],
     pub listener_yaw: f32,
-    pub listener_pitch: f32,
     pub master: f32,
     /// Seeds of positional plays (the client level random's `nextLong`).
     random: LegacyRandom,
@@ -723,29 +722,6 @@ impl Backend for MixerBackend {
     fn set_unmuffled(&mut self, channel: ChannelId, unmuffled: bool) {
         self.with(channel, |c| c.unmuffled = unmuffled);
     }
-    fn update_channel(&mut self, channel: ChannelId, volume: f32, pitch: f32, position: [f64; 3]) {
-        if let Ok(mut m) = self.mixer.lock()
-            && let Some(c) = m.channels.get_mut(&channel)
-        {
-            c.gain = volume;
-            c.pitch = pitch;
-            c.at = [position[0] as f32, position[1] as f32, position[2] as f32];
-        }
-    }
-    fn filter_stopped(&mut self, live: &[(u64, ChannelId)], stopped: &mut Vec<u64>) {
-        if let Ok(m) = self.mixer.lock() {
-            for &(h, c) in live {
-                if m.channels
-                    .get(&c)
-                    .is_none_or(|ch| ch.state == State::Stopped)
-                {
-                    stopped.push(h);
-                }
-            }
-        } else {
-            stopped.extend(live.iter().map(|&(h, _)| h));
-        }
-    }
     /// `getCompleteBuffer` (cached, else decoded on the decoder thread) or
     /// `getStream` (decoded on a thread of its own), then attach and
     /// `alSourcePlay`. A sound that cannot load leaves its source initial,
@@ -846,24 +822,18 @@ impl Backend for MixerBackend {
 /// pinned client's) rendered through `ALC_SOFT_loopback` within 1e-5.
 fn stereo_gains(right: f32, up: f32, forward: f32) -> [f32; 2] {
     let length = (right * right + up * up + forward * forward).sqrt();
-    stereo_gains_with_length(right, up, forward, length)
-}
-#[inline]
-fn stereo_gains_with_length(right: f32, up: f32, forward: f32, length: f32) -> [f32; 2] {
     if length <= f32::EPSILON {
-        return stereo_gains_with_length(0.0, 0.0, 1.0, 1.0);
+        return stereo_gains(0.0, 0.0, 1.0);
     }
-    let u = (up / length).clamp(-1.0, 1.0);
-    let cos_elev = (1.0 - u * u).max(0.0).sqrt();
+    let elevation = (up / length).clamp(-1.0, 1.0).asin();
     let mut azimuth = right.atan2(forward);
     if azimuth.abs() < std::f32::consts::FRAC_PI_2 {
         azimuth = (azimuth.abs() * 1.5)
             .min(std::f32::consts::FRAC_PI_2)
             .copysign(azimuth);
     }
-    let (sin_az, cos_az) = azimuth.sin_cos();
-    let side = sin_az * cos_elev;
-    let front = cos_az * cos_elev * 0.095_660_8;
+    let side = azimuth.sin() * elevation.cos();
+    let front = azimuth.cos() * elevation.cos() * 0.095_660_8;
     [0.5 - 0.5 * side + front, 0.5 + 0.5 * side + front]
 }
 /// The gain OpenAL applies for distance (`AL_LINEAR_DISTANCE` with reference
@@ -883,10 +853,16 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
     // and OpenAL's right = forward x up.
     let basis = |yaw: f32, pitch: f32| {
         let (yaw, pitch) = (f64::from(yaw.to_radians()), f64::from(pitch.to_radians()));
-        let (yaw_sin, yaw_cos) = yaw.sin_cos();
-        let (pitch_sin, pitch_cos) = pitch.sin_cos();
-        let forward = [-yaw_sin * pitch_cos, -pitch_sin, yaw_cos * pitch_cos];
-        let up = [-yaw_sin * pitch_sin, pitch_cos, yaw_cos * pitch_sin];
+        let forward = [
+            -yaw.sin() * pitch.cos(),
+            -pitch.sin(),
+            yaw.cos() * pitch.cos(),
+        ];
+        let up = [
+            -yaw.sin() * pitch.sin(),
+            pitch.cos(),
+            yaw.cos() * pitch.sin(),
+        ];
         let right = [
             forward[1] * up[2] - forward[2] * up[1],
             forward[2] * up[0] - forward[0] * up[2],
@@ -920,7 +896,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
     // Gains and pans per source for this buffer.
     let mut voices = std::mem::take(&mut mixer.voices);
     voices.clear();
-    for (id, c) in &mut mixer.channels {
+    for (id, c) in &mixer.channels {
         let Some((_, source_rate, source_channels)) = &c.samples else {
             continue;
         };
@@ -931,7 +907,6 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         if c.state != State::Playing {
             continue;
         }
-
         let at = [f64::from(c.at[0]), f64::from(c.at[1]), f64::from(c.at[2])];
         let away = |listener: [f64; 3]| {
             [
@@ -940,56 +915,45 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
                 at[2] - listener[2],
             ]
         };
-        let length_sq = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
-        let camera = if !shared {
-            let cam = &mixer.cameras[0];
-            if c.relative || cam.2 == c.world {
-                Some((cam.0, cam.1))
-            } else {
-                None
-            }
-        } else {
-            mixer
-                .cameras
-                .iter()
-                .filter(|camera| c.relative || camera.2 == c.world)
-                .min_by(|a, b| length_sq(away(a.0)).total_cmp(&length_sq(away(b.0))))
-                .map(|camera| (camera.0, camera.1))
-        };
+        let length = |d: [f64; 3]| d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
+        // The nearest camera hears it (one camera but in splitscreen).
+        let camera = mixer
+            .cameras
+            .iter()
+            .filter(|camera| c.relative || camera.2 == c.world)
+            .min_by(|a, b| length(away(a.0)).total_cmp(&length(away(b.0))))
+            .map(|camera| (camera.0, camera.1));
+        // Unheard sources still advance: returning to a world must not resume stale sounds.
         let (listener, (forward, up, right)) = camera.unwrap_or(([0.0; 3], basis(0.0, 0.0)));
         let d = if c.relative { at } else { away(listener) };
-        let d_sqr = length_sq(d);
-
-        let (gain, [left, right]) = if camera.is_none() {
-            (0.0, [0.0, 0.0])
-        } else if direct {
-            let gain = c.gain.clamp(0.0, 1.0);
-            (gain, [gain, gain])
-        } else {
-            let mut zero = false;
-            if let Some(max) = c.linear {
-                let max_d = max as f64;
-                if max <= 0.0 || (!c.relative && d_sqr >= max_d * max_d) {
-                    zero = true;
-                }
-            }
-            if zero {
-                (0.0, [0.0, 0.0])
-            } else {
-                let distance = d_sqr.sqrt() as f32;
-                let gain = c.gain.clamp(0.0, 1.0) * distance_gain(c.linear, distance);
-                let [mut left, mut right] = if c.relative {
-                    stereo_gains_with_length(d[0] as f32, d[1] as f32, -d[2] as f32, distance)
+        let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt() as f32;
+        let gain = if camera.is_some() {
+            c.gain.clamp(0.0, 1.0)
+                * if direct {
+                    1.0
                 } else {
-                    stereo_gains_with_length(dot(d, right), dot(d, up), dot(d, forward), distance)
-                };
-                if shared {
-                    let middle = (left + right) * 0.5;
-                    left = middle + (left - middle) * 0.5;
-                    right = middle + (right - middle) * 0.5;
+                    distance_gain(c.linear, distance)
                 }
-                (gain, [left * gain, right * gain])
+        } else {
+            0.0
+        };
+        let [left, right] = if direct {
+            [gain, gain]
+        } else {
+            // Relative sources are already in OpenAL's listener space (-Z ahead).
+            let [mut left, mut right] = if c.relative {
+                stereo_gains(d[0] as f32, d[1] as f32, -d[2] as f32)
+            } else {
+                stereo_gains(dot(d, right), dot(d, up), dot(d, forward))
+            };
+            if shared {
+                // Several players on the speakers: half the stereo width, as left and right are
+                // nobody's in particular.
+                let middle = (left + right) / 2.0;
+                left = middle + (left - middle) / 2.0;
+                right = middle + (right - middle) / 2.0;
             }
+            [left * gain, right * gain]
         };
         let step = f64::from(*source_rate) / f64::from(rate) * f64::from(c.pitch.max(0.0));
         voices.push((*id, [left, right, gain], step));
@@ -1010,40 +974,6 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
         };
         let source_channels = source_channels as usize;
         let frames = samples.len() / source_channels;
-        let inaudible = if channels >= 2 {
-            left == 0.0 && right == 0.0
-        } else {
-            gain == 0.0
-        };
-        if inaudible {
-            let buffer_frames = data.len() / channels;
-            // As the loop below: a sound of one frame or none stops, looping or not.
-            if !c.looping || frames <= 1 {
-                // `frames` may be 0: no `frames - 1` in usize. A step of 0 never
-                // reaches the end, as in the loop below.
-                let needed = frames as f64 - 1.0 - c.position;
-                if needed <= 0.0 {
-                    c.state = State::Stopped;
-                } else if step > 0.0 {
-                    let steps_to_stop = needed / step;
-                    if (buffer_frames as f64) >= steps_to_stop {
-                        c.state = State::Stopped;
-                    } else {
-                        c.position += step * (buffer_frames as f64);
-                    }
-                }
-            } else {
-                for _ in 0..buffer_frames {
-                    let i = c.position as usize;
-                    if i + 1 >= frames {
-                        c.position = 0.0;
-                    }
-                    c.position += step;
-                }
-            }
-            continue;
-        }
-
         let out: &mut [f32] = if muffling && !c.unmuffled {
             &mut bus
         } else {
@@ -1062,8 +992,8 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
             }
             let t = (c.position - i as f64) as f32;
             if source_channels > 1 {
-                let l = samples[i * 2] + (samples[(i + 1) * 2] - samples[i * 2]) * t;
-                let r = samples[i * 2 + 1] + (samples[(i + 1) * 2 + 1] - samples[i * 2 + 1]) * t;
+                let l = samples[i * 2] * (1.0 - t) + samples[(i + 1) * 2] * t;
+                let r = samples[i * 2 + 1] * (1.0 - t) + samples[(i + 1) * 2 + 1] * t;
                 if channels >= 2 {
                     frame[0] += l * left;
                     frame[1] += r * right;
@@ -1071,7 +1001,7 @@ fn mix(mixer: &mut Mixer, data: &mut [f32], channels: usize, rate: u32) {
                     frame[0] += (l + r) * 0.5 * gain;
                 }
             } else {
-                let s = samples[i] + (samples[i + 1] - samples[i]) * t;
+                let s = samples[i] * (1.0 - t) + samples[i + 1] * t;
                 if channels >= 2 {
                     frame[0] += s * left;
                     frame[1] += s * right;
@@ -1482,7 +1412,6 @@ impl Audio {
             record_heard: false,
             listener: [0.0; 3],
             listener_yaw: 0.0,
-            listener_pitch: 0.0,
             master: 1.0,
             random: crate::random_source::create(),
             source_override: None,
@@ -1606,12 +1535,8 @@ impl Audio {
     /// `SoundManager.updateSource`: the camera position and rotation
     /// (`Listener.setTransform` takes its forward and up vectors).
     pub fn set_listener(&mut self, position: [f64; 3], yaw: f32, pitch: f32) {
-        if self.listener == position && self.listener_yaw == yaw && self.listener_pitch == pitch {
-            return;
-        }
         self.listener = position;
         self.listener_yaw = yaw;
-        self.listener_pitch = pitch;
         if let Ok(mut m) = self.backend.mixer.lock() {
             if self.backend.owner == 0 {
                 m.listener = position;
@@ -1651,7 +1576,6 @@ impl Audio {
             record_heard: false,
             listener: [0.0; 3],
             listener_yaw: 0.0,
-            listener_pitch: 0.0,
             master: self.master,
             random: crate::random_source::create(),
             source_override: None,
@@ -2185,25 +2109,6 @@ impl Audio {
             })
             .collect()
     }
-    /// Mixes one buffer of audio into `data` (channels: 1 or 2, rate in Hz).
-    pub fn mix_buffer(&mut self, data: &mut [f32], channels: usize, rate: u32) {
-        if let Ok(mut m) = self.backend.mixer.lock() {
-            mix(&mut m, data, channels, rate);
-        }
-    }
-    #[doc(hidden)]
-    pub fn insert_cached_sound(&mut self, key: &str, samples: Vec<f32>, rate: u32, channels: u16) {
-        if let Ok(mut c) = self.backend.cache.lock() {
-            c.insert(
-                key.to_owned(),
-                Some((std::sync::Arc::new(samples), rate, channels)),
-            );
-        }
-    }
-    #[doc(hidden)]
-    pub fn backend_live_for_bench(&mut self) {
-        self.backend.live = true;
-    }
 }
 impl Sounds for Audio {
     fn engine(&mut self) -> &mut SoundEngine {
@@ -2708,25 +2613,6 @@ mod tests {
         assert_eq!(data, [0.0; 4], "returning must not resume the old one-shot");
     }
 
-    /// A sound of one frame or none, heard or not, looping or not, stops at its first
-    /// buffer as the mixing loop stops it: none stays playing (and holds its channel).
-    #[test]
-    fn sounds_too_short_to_mix_stop_even_unheard() {
-        for (samples, looping) in [(vec![], false), (vec![1.0], false), (vec![1.0], true)] {
-            let mut mixer = Mixer::default();
-            let mut source = channel(samples.clone(), None, [0.0; 3], looping);
-            source.gain = 0.0;
-            mixer.channels.insert(1, source);
-            let mut data = [0.0; 4];
-            mix(&mut mixer, &mut data, 2, 48_000);
-            assert_eq!(
-                mixer.channels[&1].state,
-                State::Stopped,
-                "{samples:?} {looping}"
-            );
-        }
-    }
-
     #[test]
     fn variants_of_one_sound_are_the_same_sound() {
         assert_eq!(

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

@@ -569,25 +569,6 @@ pub(crate) fn polytone_noise() -> &'static horizon_core::noise::SimplexNoise {
 }
 
 impl horizon_polytone::expr::Host for BlockHost<'_> {
-    fn field(
-        &mut self,
-        root: horizon_polytone::expr::Root,
-        field: horizon_polytone::expr::Field,
-    ) -> Option<horizon_polytone::expr::Value> {
-        use horizon_polytone::expr::Field as F;
-        if root != horizon_polytone::expr::Root::Object {
-            return None;
-        }
-        Some(horizon_polytone::expr::Value::Num(match field {
-            F::X => f64::from(self.at[0]),
-            F::Y => f64::from(self.at[1]),
-            F::Z => f64::from(self.at[2]),
-            F::Temperature => f64::from(self.biome.temperature),
-            F::Downfall => f64::from(self.biome.downfall),
-            _ => return None,
-        }))
-    }
-
     fn root(&mut self, root: horizon_polytone::expr::Root) -> horizon_polytone::expr::Value {
         use horizon_polytone::expr::Root;
         horizon_polytone::expr::Value::Object(match root {

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

@@ -231,10 +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' `environment` fog settings (Polytone's).
-    pub environment: crate::pack_palette::Environment,
-    /// The packs' fluid modifiers' fog.
-    pub fluid_fog: crate::pack_palette::FluidFogs,
+    /// The packs' Polytone `environment` fog settings.
+    pub environment: horizon_polytone::colors::Environment,
 }
 
 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -399,24 +397,6 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
             }
         }
     }
-    // A pack's fluid modifier over its fluid's fog, after everything else (wiki "Custom Colors").
-    let fluid = match input.fog_type {
-        FogType::Lava => input.fluid_fog.lava,
-        FogType::Water if input.blindness.is_none() && input.darkness.is_none() => {
-            input.fluid_fog.water
-        }
-        _ => None,
-    };
-    if let Some(f) = fluid {
-        if let Some(rgb) = f.color {
-            let [r, g, b] = self::rgb(rgb);
-            fog.color = [r, g, b, 1.0];
-        }
-        let end = fog.environmental_end * f.radius;
-        let start = end - (end - fog.environmental_start * f.radius) * f.fade;
-        (fog.environmental_start, fog.environmental_end) = (start, end);
-        (fog.sky_end, fog.cloud_end) = (end, end);
-    }
     let span = (rd / 10.0).clamp(4.0, 64.0);
     fog.render_distance_start = rd - span;
     fog.render_distance_end = rd;
@@ -515,7 +495,6 @@ mod tests {
             full_water_vision: false,
             night_vision: 0.0,
             environment: Default::default(),
-            fluid_fog: Default::default(),
         }
     }
     #[test]
@@ -602,7 +581,7 @@ mod tests {
         let tables = FogTables {
             water_fog_end: vec![1.0],
         };
-        let environment = crate::pack_palette::Environment {
+        let environment = horizon_polytone::colors::Environment {
             powder_snow_fog: Some(0xFF0000),
             blindness_fog_distance: 40.0,
             water_fog_brightening: 0.0,
@@ -632,41 +611,9 @@ mod tests {
         let kept = setup_fog(&tables, &state, &input).color;
         assert_eq!(&kept[..3], &[0.1, 0.2, 0.4]);
     }
-    #[test]
-    fn a_fluid_modifier_scales_and_colours_its_fog_last() {
-        let sky = Sky {
-            fog_start: 10.0,
-            fog_end: 96.0,
-            ..Sky::default()
-        };
-        let tables = FogTables {
-            water_fog_end: vec![1.0],
-        };
-        let mut input = inputs(&sky);
-        input.fog_type = FogType::Lava;
-        input.fire_resistance = true;
-        let vanilla = setup_fog(&tables, &FogState::default(), &input);
-        assert_eq!(
-            (vanilla.environmental_start, vanilla.environmental_end),
-            (0.0, 5.0)
-        );
-        input.fluid_fog.lava = Some(crate::pack_palette::FluidFog {
-            color: Some(0x00FF00),
-            radius: 2.0,
-            fade: 0.5,
-        });
-        let fog = setup_fog(&tables, &FogState::default(), &input);
-        assert_eq!(fog.color, [0.0, 1.0, 0.0, 1.0]);
-        // The end doubles; half the fade from 0 to 10 starts it at 5.
-        assert_eq!(
-            (fog.environmental_start, fog.environmental_end),
-            (5.0, 10.0)
-        );
-        assert_eq!((fog.sky_end, fog.cloud_end), (10.0, 10.0));
-    }
     fn inputs_with<'a>(
         input: &FogInputs<'a>,
-        environment: crate::pack_palette::Environment,
+        environment: horizon_polytone::colors::Environment,
     ) -> FogInputs<'a> {
         FogInputs {
             environment,

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

@@ -239,7 +239,6 @@ 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;
@@ -251,7 +250,6 @@ 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`).
@@ -728,6 +726,62 @@ 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
@@ -7041,10 +7095,8 @@ impl Renderer {
         }
     }
     /// This renderer's output as applied, with what its destination offers and reports.
-    pub fn output(&self) -> output::EffectiveOutput {
-        let native = self.native.as_ref().map(|n| n.frame.api);
-        self.output
-            .with_pack(self.shader_pack_kind() == Some("iris"), native)
+    pub fn output(&self) -> &output::EffectiveOutput {
+        &self.output
     }
     /// What this renderer's display last reported: a renderer made again for the window
     /// starts from it (`Renderer::new`'s `display`).
@@ -8321,7 +8373,9 @@ impl Renderer {
         let taa = !frame.title
             && self.pack_post.as_ref().is_none_or(|p| p.1.is_none())
             && self.native.as_ref().is_none_or(|n| n.post.is_none());
-        let hdr_lighting = self.shader_pack_kind().is_none();
+        let hdr_lighting = self.native.is_none()
+            && self.pack_post.as_ref().is_none_or(|p| p.1.is_none())
+            && std::env::var_os("HORIZON_HDR_LIGHTING").is_none_or(|v| v != "0");
         if let Some(hdr) = &mut self.hdr {
             hdr.lighting = hdr_lighting && hdr.look;
         }
@@ -10062,11 +10116,7 @@ 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
@@ -13664,7 +13714,6 @@ mod tests {
             Some(Reported {
                 paper_white: 240,
                 peak: 998,
-                peak_guessed: true,
             })
         );
         assert_eq!(
@@ -13672,7 +13721,6 @@ 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).
@@ -13681,7 +13729,6 @@ mod tests {
             Some(Reported {
                 paper_white: 456,
                 peak: 456,
-                peak_guessed: true,
             })
         );
         assert_eq!(os_reported(&info(Some(1000.0), None)), None);
@@ -15372,9 +15419,11 @@ 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, 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.
+/// 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.
 fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
     let luminance = info.luminance?;
     let usable = |n: f32| n.is_finite() && n > 0.0;
@@ -15386,7 +15435,6 @@ 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,
     })
 }
 
@@ -15422,7 +15470,6 @@ 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,
     }
 }
 

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

@@ -191,7 +191,7 @@ pub struct Hdr {
     pub masks: Masks,
     /// HDR lighting, whether Horizon lifts this frame's world: off under a Horizon shader pack
     /// that draws, while a `shaders/` pack's post or material stage runs (the pack's own),
-    /// and with HDR Lighting (`look`) off.
+    /// with HDR Lighting (`look`) off, and with `HORIZON_HDR_LIGHTING=0`, to compare.
     pub lighting: bool,
     /// The HDR Lighting setting: off, nothing in the world is lifted, light sources and the
     /// sun included, so the picture is SDR's on the HDR canvas.

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

@@ -1,59 +0,0 @@
-//! `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

@@ -144,9 +144,6 @@ pub struct EffectiveOutput {
     pub(crate) nits: [f32; 3],
     /// The HUD and menus' brightness, as a share of paper white: their nits over its.
     pub(crate) ui_brightness: f32,
-    /// The running shader pack lights the world itself: Horizon lifts none of it, so HDR
-    /// Lighting has nothing to switch (`with_pack`).
-    pub(crate) pack_lights: bool,
 }
 impl Default for EffectiveOutput {
     fn default() -> Self {
@@ -169,22 +166,7 @@ impl EffectiveOutput {
         },
         nits: [203.0, 1000.0, 0.0],
         ui_brightness: 1.0,
-        pack_lights: false,
     };
-    /// This output under the running shader pack: a `shaders/` one (`shaders`), or one of
-    /// Horizon's own of API `native`. Under a 0.1 pack on the 8- or 16-bit frame the last pass
-    /// still lifts the light sources and the sun its marks hold (`lifts_world` in
-    /// `Renderer::render`); under the rest Horizon lifts nothing.
-    pub(crate) fn with_pack(self, shaders: bool, native: Option<horizon_shader_api::Api>) -> Self {
-        let pack_lights = shaders
-            || native.is_some_and(|api| {
-                api != horizon_shader_api::Api::V0_1 || self.frame.format == super::LINEAR_FRAME
-            });
-        Self {
-            pack_lights,
-            ..self
-        }
-    }
     /// Whether the destination offers HDR output.
     pub fn hdr_offered(&self) -> bool {
         self.offered.is_some()
@@ -291,7 +273,6 @@ pub(crate) fn resolve_output(
         ],
         ui_brightness: settings.ui_nits(reading.luminance) as f32
             / settings.paper_white_nits(reading.luminance) as f32,
-        pack_lights: false,
     }
 }
 
@@ -319,7 +300,6 @@ pub(crate) mod tests {
                 luminance: Some(Reported {
                     paper_white: 400,
                     peak: 1000,
-                    peak_guessed: false,
                 }),
                 hdr: system,
             },
@@ -670,7 +650,6 @@ 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,7 +549,6 @@ 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;
@@ -585,7 +584,6 @@ 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);
@@ -731,7 +729,6 @@ mod tests {
                 luminance: (hdr == Some(true)).then_some(Reported {
                     paper_white: 300,
                     peak: 800,
-                    peak_guessed: false,
                 }),
                 hdr,
             };

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

@@ -1,79 +0,0 @@
-//! 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,9 +5,6 @@ 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;
 
@@ -137,7 +134,6 @@ 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
@@ -170,7 +166,6 @@ 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,22 +30,6 @@ 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.
@@ -1223,15 +1207,6 @@ 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 {
@@ -1345,7 +1320,6 @@ 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;
@@ -1354,33 +1328,6 @@ 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,8 +8,7 @@ use crate::{
     gfx::EffectiveOutput,
     graphics::{
         EntityCullingMode, FarDetail, FrameGeneration, GpuCullingMode, GraphicsApi, HdrMode,
-        HdrSetup as Setup, LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode,
-        Preset, Upscaling,
+        LeafCullingMode, Overlay, Pacing, ParticleCullingMode, PresentMode, Preset, Upscaling,
     },
     graphics_style::Cost,
     lang,
@@ -676,9 +675,28 @@ 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 {
-    s.horizon.hdr_setup(out.reported)
+    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
+    }
 }
 /// 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`).
@@ -696,19 +714,13 @@ 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."
         }
-        // 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) =>
-        {
+        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
             "Set up for your display. Leave on Auto unless it looks wrong."
         }
         (Item::Horizon(H::GpuCulling), _) if s.horizon.gpu_culling == GpuCullingMode::Auto => {
@@ -932,7 +944,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 | Setup::Guessed => "Calibrate...",
+                Setup::Unknown => "Calibrate...",
                 Setup::Automatic => "Calibrate Anyway...",
                 Setup::Changed => "Use Automatic Setup",
             })),
@@ -1110,8 +1122,7 @@ impl Item {
     /// active; saved values wait for it. Translucent Batching switches where the device can batch
     /// (`graphics::translucent_batching_offered`), its saved value waiting for one that can,
     /// Smooth Gradients only where it can draw the 16-bit frame, the same way, and GPU Culling
-    /// only where it is offered (`graphics::gpu_culling_offer`), with the reason it isn't. HDR
-    /// Lighting has nothing to switch where the running shader pack lights the world itself.
+    /// only where it is offered (`graphics::gpu_culling_offer`), with the reason it isn't.
     fn blocked(self, s: &Settings, out: &EffectiveOutput) -> Option<&'static str> {
         if !self.available() {
             return Some("This feature is not yet available in Horizon.");
@@ -1142,9 +1153,6 @@ impl Item {
             } else {
                 "Turn HDR on to use it."
             }),
-            Item::Horizon(H::HdrLighting) if out.pack_lights => {
-                Some("The shader pack lights the world itself.")
-            }
             Item::Horizon(H::TranslucentBatching)
                 if !crate::graphics::translucent_batching_offered() =>
             {

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

@@ -31,49 +31,6 @@ fn smooth_gradients_wait_for_a_device_that_draws_the_16_bit_frame() {
     assert_eq!(item.blocked(&s, &out), Some("Turn HDR on to use it."));
 }
 
-#[test]
-fn hdr_lighting_is_greyed_only_where_the_running_pack_lights_the_world() {
-    use horizon_shader_api::Api;
-    let mut s = Settings::default();
-    s.horizon.hdr = HdrMode::On;
-    let item = Item::Horizon(H::HdrLighting);
-    let lights = Some("The shader pack lights the world itself.");
-    let out = offering(true, None);
-    // No pack running, as with one picked but refused, missing or its mod off: live.
-    assert_eq!(item.blocked(&s, &out.with_pack(false, None)), None);
-    // A 0.1 pack on the 16-bit frame: the light sources and the sun still shine.
-    assert_eq!(
-        item.blocked(&s, &out.with_pack(false, Some(Api::V0_1))),
-        None
-    );
-    assert_eq!(
-        item.blocked(&s, &out.with_pack(false, Some(Api::V0_2))),
-        lights
-    );
-    assert_eq!(item.blocked(&s, &out.with_pack(true, None)), lights);
-    let float = EffectiveOutput {
-        frame: crate::gfx::FrameConfiguration {
-            format: wgpu::TextureFormat::Rgba16Float,
-            ..out.frame
-        },
-        ..out
-    };
-    assert_eq!(
-        item.blocked(&s, &float.with_pack(false, Some(Api::V0_1))),
-        lights
-    );
-    // HDR's own reasons come first.
-    assert_eq!(
-        item.blocked(&s, &NONE.with_pack(true, None)),
-        Some("Your display or system doesn't offer HDR output.")
-    );
-    s.horizon.hdr = HdrMode::Off;
-    assert_eq!(
-        item.blocked(&s, &out.with_pack(true, None)),
-        Some("Turn HDR on to use it.")
-    );
-}
-
 #[test]
 fn hdr_auto_can_be_selected_before_querying_and_brightness_waits_for_output() {
     let mut s = Settings::default();
@@ -163,86 +120,14 @@ 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 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)]
-    );
+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);
 }
 
 /// 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,6 +67,7 @@ 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;

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

@@ -2593,7 +2593,8 @@ 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 (`finish_sample`).
+        // Queued tiles the view left are not sampled (a running one is
+        // dropped when it finishes, `finish_sample`).
         drop_queued_samples(&self.shared, &mut self.pending, |key| {
             self.plan.nodes.contains(key)
         });
@@ -2679,7 +2680,6 @@ 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,7 +1,6 @@
 //! Optional, texture-matched overlays drawn full bright over their base texture in the same
-//! 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.
+//! 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.
 use crate::sprites::Sprites;
 use std::{collections::BTreeMap, path::Path};
 
@@ -36,12 +35,14 @@ fn tile_file(name: &str) -> Option<&str> {
     name.strip_suffix(".png")
 }
 
-/// 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)> {
+/// 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);
     // 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();
@@ -55,8 +56,8 @@ pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(S
             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();
@@ -109,7 +110,7 @@ pub fn load_overlays(root: &Path, suffix: &str, sprites: &mut Sprites) -> Vec<(S
 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_overlays`] loads),
+/// OptiFine pairs flagged [`CUTOUT`] (at most [`MAX`] - [`NATIVE`], as [`load_optifine`] 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>,
@@ -203,7 +204,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_overlays(&root, "_e", &mut sprites);
+        let pairs = load_optifine(&root, &mut sprites);
         assert_eq!(
             pairs,
             [(
@@ -214,6 +215,9 @@ 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);
@@ -230,7 +234,7 @@ mod tests {
                 .insert_file(&root, &format!("assets/minecraft/optifine/{tile}.png"))
                 .unwrap();
         }
-        let pairs = load_overlays(&root, "_glow", &mut sprites);
+        let pairs = load_optifine(&root, &mut sprites);
         assert_eq!(
             pairs,
             // Blocks first, then tiles.

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

@@ -1,79 +0,0 @@
-//! 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};
-
-fn fluid(fog: horizon_polytone::colors::FluidFog) -> pack_palette::FluidFog {
-    pack_palette::FluidFog {
-        color: fog.color,
-        radius: fog.radius,
-        fade: fog.fade,
-    }
-}
-
-/// 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,
-        },
-        fluid_fog: pack_palette::FluidFogs {
-            water: colors.fluid_fog.water.map(fluid),
-            lava: colors.fluid_fog.lava.map(fluid),
-        },
-    }
-}
-
-#[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/item_bars.rs

@@ -1,146 +0,0 @@
-//! 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

@@ -3,9 +3,7 @@
 //! 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;
@@ -16,22 +14,10 @@ use crate::pack_hooks::PackFormats;
 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.

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

@@ -10,26 +10,10 @@ 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.

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

@@ -1,106 +1,14 @@
-//! 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.
+//! 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.
 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;
-
-/// 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,
-    /// The fog the packs' fluid modifiers give water and lava.
-    pub fluid_fog: FluidFogs,
-}
-
-/// A fluid modifier's fog: a flat colour (RGB), and the fog's radius and fade multipliers (1 is
-/// vanilla's).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct FluidFog {
-    pub color: Option<u32>,
-    pub radius: f32,
-    pub fade: f32,
-}
-
-/// The fog the packs' fluid modifiers give water and lava.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
-pub struct FluidFogs {
-    pub water: Option<FluidFog>,
-    pub lava: Option<FluidFog>,
-}
-
-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(),
-            fluid_fog: FluidFogs::default(),
-        }
-    }
-}
-
-impl PackColors {
-    /// Whether entities draw their round shadow, as far as the packs say.
-    pub fn entity_shadows(&self) -> bool {
-        self.entity_shadows
-    }
-}
+use horizon_polytone::colors::PackColors;
 
 /// 0 is unset, else `1 << 32 | rgb`.
 static DIFFUSE: [AtomicU64; 16] = [const { AtomicU64::new(0) }; 16];
@@ -108,30 +16,6 @@ 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>| {
@@ -140,39 +24,129 @@ pub fn set(colors: &PackColors) {
             Relaxed,
         );
     };
-    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]);
+    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));
     }
 }
 
-fn get(table: &[AtomicU64; 16], i: usize) -> Option<u32> {
+/// 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> {
     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 {
-    get(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
+    read(&DIFFUSE, dye).unwrap_or(DYES[dye & 15].1)
 }
 
 /// `DyeColor.getTextColor` (RGB) as the packs draw it.
 pub fn text(dye: usize) -> u32 {
-    get(&TEXT, dye).unwrap_or(DYE_TEXT[dye & 15].1)
+    read(&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> {
-    get(&REDSTONE, usize::from(power))
+    read(&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) = get(&SHEEP, i) {
+    if let Some(color) = read(&SHEEP, i) {
         return color;
     }
     if i == 0 {
@@ -182,3 +156,81 @@ 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/polytone.rs

@@ -801,26 +801,6 @@ impl Host for Ctx<'_, '_> {
             _ => Err(format!("{name} is not available here")),
         }
     }
-
-    /// A particle's own fields, as `particle_method` answers them.
-    fn field(&mut self, root: Root, field: horizon_polytone::expr::Field) -> Option<V> {
-        use horizon_polytone::expr::Field as F;
-        let Subject::Particle(p) = &self.subject else {
-            return None;
-        };
-        if root != Root::Object {
-            return None;
-        }
-        Some(V::Num(match field {
-            F::Age => f64::from(p.age),
-            F::Life => f64::from(p.lifetime),
-            F::Custom => *self.custom,
-            F::X => p.position[0],
-            F::Y => p.position[1],
-            F::Z => p.position[2],
-            F::Temperature | F::Downfall => return None,
-        }))
-    }
 }
 
 fn eval(program: &Program, ctx: &mut Ctx) -> Option<f64> {

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

@@ -913,20 +913,6 @@ pub trait Backend {
     fn unpause(&mut self, channel: ChannelId);
     /// `Channel.stopped`.
     fn stopped(&mut self, channel: ChannelId) -> bool;
-    /// Update volume, pitch, and position in a single backend call.
-    fn update_channel(&mut self, channel: ChannelId, volume: f32, pitch: f32, position: [f64; 3]) {
-        self.set_volume(channel, volume);
-        self.set_pitch(channel, pitch);
-        self.set_position(channel, position);
-    }
-    /// Filter which handles have stopped playing in a single pass.
-    fn filter_stopped(&mut self, live: &[(u64, ChannelId)], stopped: &mut Vec<u64>) {
-        for &(h, c) in live {
-            if self.stopped(c) {
-                stopped.push(h);
-            }
-        }
-    }
     /// Whether the channel plays clearly through a mod's muffle (`Audio::muffle`): its sound
     /// event is one the mod exempted. A backend without a muffle ignores it.
     fn set_unmuffled(&mut self, _channel: ChannelId, _unmuffled: bool) {}
@@ -1508,14 +1494,13 @@ impl SoundEngine {
                 .iter()
                 .filter_map(|(h, handle)| handle.channel.map(|c| (*h, c))),
         );
-        let mut stopped = std::mem::take(&mut self.mapped_scratch);
-        stopped.clear();
-        backend.filter_stopped(&live, &mut stopped);
-        for h in stopped.drain(..) {
-            self.release_handle(h, backend);
+        for (h, c) in live.drain(..) {
+            if backend.stopped(c) {
+                self.release_handle(h, backend);
+            }
         }
         // Released handles nobody maps any more.
-        let mut mapped = stopped;
+        let mut mapped = std::mem::take(&mut self.mapped_scratch);
         mapped.clear();
         mapped.extend(self.instance_to_channel.iter().map(|(_, h)| *h));
         self.handles
@@ -1565,7 +1550,9 @@ impl SoundEngine {
                 h.pitch_edited = pitch_edited;
             }
             if let Some(c) = self.handles.get(&handle).and_then(handle_channel) {
-                backend.update_channel(c, volume, pitch, position);
+                backend.set_volume(c, volume);
+                backend.set_pitch(c, pitch);
+                backend.set_position(c, position);
             }
             let instance = self.instances.get_mut(&id).expect("present");
             if instance.looping

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

@@ -1251,9 +1251,6 @@ pub struct EditBox {
     /// `getMessage`: what the narrator calls the box ("<message> edit box:
     /// <value>").
     pub message: String,
-    /// `EditBox.setInvertHighlightedTextColor`: a selection draws its text
-    /// inverted (the default) or in the box's own colour (`AnvilScreen`).
-    pub invert_highlighted_text_color: bool,
     /// Where a borderless box drawn in a frame of its own focuses: a controller's outline goes
     /// round the frame, not over the text.
     pub frame: Option<[f32; 4]>,
@@ -1546,7 +1543,6 @@ impl EditBox {
             text_color_uneditable: rgba(112, 112, 112, 255),
             editable: true,
             message: String::new(),
-            invert_highlighted_text_color: true,
             frame: None,
         }
     }
@@ -1922,11 +1918,7 @@ impl EditBox {
             let right = self.x + self.width;
             let (x0, x1) = (cursor_x.min(right), (hx - 1.0).min(right));
             let (a, b) = (x0.min(x1), x0.max(x1));
-            batch.text_highlight(
-                atlas,
-                (a, ty - 1.0, b - a, 11.0),
-                self.invert_highlighted_text_color,
-            );
+            batch.text_highlight(atlas, (a, ty - 1.0, b - a, 11.0), true);
         }
         if show_cursor {
             if insert {
@@ -2636,20 +2628,6 @@ mod tests {
         );
     }
 
-    /// `EditBox.setInvertHighlightedTextColor`: a selection inverts its text
-    /// unless the box asks it not to (the anvil's rename box).
-    #[test]
-    fn a_selection_inverts_its_text_unless_the_box_says_not_to() {
-        let mut edit = EditBox::new(0.0, 0.0, 100.0, 20.0);
-        assert!(edit.invert_highlighted_text_color);
-        edit.invert_highlighted_text_color = false;
-        edit.set_value("name");
-        edit.set_cursor(0, false);
-        edit.set_cursor(4, true);
-        assert_eq!(edit.selected_text(), "name");
-        assert!(!edit.invert_highlighted_text_color);
-    }
-
     /// `EditBox.setEditable(false)`: the box keeps the focus, the caret keys
     /// and copy, but `charTyped`/paste/Backspace/Delete do nothing, and Cut
     /// copies without taking the text out. A value and the caret still show,

crates/horizon-client/Cargo.toml

@@ -119,11 +119,10 @@ 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, and ray
-# tracing on request (`HORIZON_RAY_TRACING=1`). 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. 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 = ["horizon-client-lib/horizon-extras", "horizon-client-render/horizon-extras", "discord", "friends"]
+horizon-extras = ["horizon-client-lib/horizon-extras", "discord", "friends"]
 # 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"]

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

@@ -287,7 +287,6 @@
   "This feature is not yet available in Horizon.": "This feature is not yet available in Horizon.",
   "Your display or system doesn't offer HDR output.": "Your display or system doesn't offer HDR output.",
   "Turn HDR on to use it.": "Turn HDR on to use it.",
-  "The shader pack lights the world itself.": "The shader pack lights the world itself.",
   "Your GPU or graphics API doesn't support it.": "Your GPU or graphics API doesn't support it.",
   "Not with software rendering, which runs it on the CPU.": "Not with software rendering, which runs it on the CPU.",
   "Out of video memory: off until the next start.": "Out of video memory: off until the next start.",
@@ -442,7 +441,6 @@
   "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.",

crates/horizon-client/src/client_lib.rs

@@ -21,11 +21,11 @@ pub use horizon_client_render::{
     mipmap, mod_browser, mod_list, model_library, models, multiline_edit, native_emissive,
     options_file, options_fixes, options_ui, overlay, pack_browser, pack_formats, pack_hooks,
     pack_palette, pack_screen, packs, pad_cursor, pad_glyph, par, particles, poi_sections,
-    polytone_creative_tabs, polytone_post, post_chain, potent_sulfur, preedit, providers, pvp,
-    pvp_hud, random_source, screen_draw, screen_effects, sculk, section_mask, server_terrain,
-    settings, shader_options, shader_pack_list, signs, skins, social, sound_engine, sound_events,
-    sound_preview, spans, split_layout, split_map, split_profiles, sprites, streaming,
-    structure_block, tab_list, terrain_model, test_block, test_instance_block, testgen,
+    polytone_colors, polytone_creative_tabs, polytone_post, post_chain, potent_sulfur, preedit,
+    providers, pvp, pvp_hud, random_source, screen_draw, screen_effects, sculk, section_mask,
+    server_terrain, settings, shader_options, shader_pack_list, signs, skins, social, sound_engine,
+    sound_events, sound_preview, spans, split_layout, split_map, split_profiles, sprites,
+    streaming, structure_block, tab_list, terrain_model, test_block, test_instance_block, testgen,
     title_edition, trims, ui, vault, weather, widgets, world, worldborder, zip,
 };
 pub mod attack_strength;
@@ -171,7 +171,6 @@ pub use horizon_client_input::gamepad;
 pub use horizon_client_input::gameplay_guide;
 pub use horizon_client_input::held;
 pub use horizon_client_input::input;
-pub use horizon_client_input::input_source;
 pub use horizon_client_input::interaction_input;
 pub use horizon_client_input::key_names;
 pub use horizon_client_input::keybinds;

crates/horizon-client/src/entity_nbt.rs

@@ -2666,9 +2666,9 @@ pub fn mob_from_nbt_with_random(
         m.extra.counter = number(tag.get("still_timeout")).unwrap_or(0) as i32;
     }
     if m.species() == crate::mobs::Species::Shulker {
-        m.extra.variant3 = (number(tag.get("AttachFace")).unwrap_or(0) % 6).unsigned_abs() as u8;
-        m.extra.counter = number(tag.get("Peek")).map_or(0, |v| v as i8 as i32);
-        m.extra.color = number(tag.get("Color")).map_or(16, |v| v as i8 as u8);
+        m.extra.variant3 = number(tag.get("AttachFace")).unwrap_or(0).clamp(0, 5) as u8;
+        m.extra.counter = number(tag.get("Peek")).unwrap_or(0).clamp(0, 100) as i32;
+        m.extra.color = number(tag.get("Color")).map_or(16, |c| c.clamp(0, 16) as u8);
         m.anim.v[0] = m.extra.counter as f32 * 0.01;
         m.anim.vo[0] = m.anim.v[0];
         // Shulker.setPos: square on its block.

crates/horizon-client/src/entry.rs

@@ -23,8 +23,9 @@ pub fn main_with(mods: crate::mod_api::Mods) {
     horizon_client::telemetry::mark_start();
     // Opt-in telemetry keeps each crash report (docs/telemetry.md), whatever the mode.
     crash::on_report(horizon_client::telemetry::keep_crash);
-    // Crates above the engine registered their hooks before this (horizon-official's `main`);
-    // none registers after this point.
+    // Crates above the engine registered their hooks before this (horizon-official's `main`),
+    // then the Horizon parts still in this crate; none registers after this point.
+    game::player_hooks::register();
     horizon_hooks::engine::seal();
     horizon_client::spans::startup::init(std::time::Instant::now());
     horizon_client::spans::trace::start_from_env();

crates/horizon-client/src/game.rs

@@ -373,6 +373,7 @@ mod place_feature_tests;
 mod play_input;
 mod play_keys;
 mod player_equip;
+pub(crate) mod player_hooks;
 mod player_spawn;
 mod pointer_capture;
 #[cfg(test)]
@@ -2028,7 +2029,7 @@ pub struct PackResources {
     /// The packs' Polytone post chains (#11486), when a pack has some.
     polytone_post: Option<Arc<horizon_client::polytone_post::PolytonePost>>,
     /// The packs' Polytone custom colours (`polytone/colors.json`).
-    polytone_colors: Arc<horizon_client::pack_palette::PackColors>,
+    polytone_colors: Arc<horizon_client::polytone_colors::PackColors>,
 }
 /// A quick craft drag as the screen draws it: each dragged slot's count and
 /// whether the slot caps it (None: hidden), and what stays in hand.
@@ -2882,8 +2883,19 @@ struct Game<'a> {
     /// The open connection joined from Realms: `ServerData.isRealm` for the friends
     /// service's presence status.
     realm_session: bool,
-    /// Horizon Studio: replay playback, its free camera, timeline and top bar (game/studio.rs).
-    pub(super) studio: studio::Studio,
+    /// Active packet replay session (game/studio.rs).
+    pub(super) studio_replay: Option<horizon_client::studio::ReplayDriver>,
+    pub(super) studio_freecam: horizon_client::studio::StudioFreecam,
+    pub(super) studio_timeline: horizon_client::studio::TimelineUi,
+    pub(super) studio_topbar: horizon_client::studio::TopBarUi,
+    pub(super) studio_rmb_down: bool,
+    studio_camera_track_dirty: bool,
+    /// Camera perspective to restore after leaving replay playback.
+    studio_replay_previous_camera_type: Option<perspective::CameraType>,
+    /// Replay opened from the title screen owns the synthetic remote session.
+    studio_replay_standalone: bool,
+    last_replay_tick: Option<Instant>,
+    pub(super) studio_virtual_tick_ms: f32,
     /// This world is open to the network (game/lan.rs).
     lan: Option<lan::LanHost>,
     /// Single player's server thread, which `remote` is connected to.
@@ -5015,7 +5027,7 @@ impl Game<'_> {
         if canceled {
             return Ok(false);
         }
-        self.input_feedback(horizon_client::input_source::Feedback::BlockBroken);
+        self.pad_rumble(horizon_client::gamepad::Rumble::BlockBroken);
         let broken = state;
         let facts = self.res.facts().get(state).clone();
         let state = self.crack_mined_pot(pos, state);
@@ -5834,7 +5846,7 @@ impl Game<'_> {
         batch
     }
     fn hud_layers(&mut self, size: [u32; 2]) -> HudBatch {
-        self.input_hud_begin();
+        self.pad.guide_shown.clear();
         let mut batch = HudBatch::new(size);
         batch.glint_colour = self.settings.extras.pvp.tweaks.glint_texel();
         // GlobalSettingsUniform's GameTime, for a resource pack's text shader.
@@ -5931,7 +5943,7 @@ impl Game<'_> {
         // the sleep overlay, debug screen and open screens still draw.
         let spectator = self.spectator();
         let (wi, hi) = (w as i32, h as i32);
-        let in_studio = self.studio.replay.is_some();
+        let in_studio = self.studio_replay.is_some();
         let show_hud = !self.ui.hide_gui && !in_studio;
         // Hud.extractRenderState asks `Screen.isInGameUi` twice: such a screen
         // defers the subtitles over itself, and keeps them while F1 hides the
@@ -6131,7 +6143,7 @@ impl Game<'_> {
                     let atlas = &g.gui.atlas;
                     let width = |s: &str| HudBatch::text_width(atlas, s) as i32;
                     let draws = hud_layout::experience_colored(
-                        g.pack.polytone_colors.xp_bar,
+                        g.pack.polytone_colors.xp_bar(),
                         wi,
                         hi,
                         g.experience.progress,
@@ -6273,19 +6285,19 @@ impl Game<'_> {
         }
         if !self.ui.hide_gui
             && self.screen == Screen::Playing
-            && (self.studio.replay.is_some() || self.studio.freecam.active)
+            && (self.studio_replay.is_some() || self.studio_freecam.active)
         {
-            self.studio.topbar.render(
+            self.studio_topbar.render(
                 &mut batch,
                 &self.gui.atlas,
                 self.cursor,
-                self.studio.freecam.locked_to_path,
+                self.studio_freecam.locked_to_path,
             );
-            self.studio.timeline.render(
+            self.studio_timeline.render(
                 &mut batch,
                 &self.gui.atlas,
                 self.cursor,
-                &self.studio.freecam,
+                &self.studio_freecam,
             );
         }
         if show_hud {
@@ -6464,6 +6476,18 @@ impl Game<'_> {
             self.draw_tooltip_lines(batch, &lines, self.cursor.0, self.cursor.1);
         }
     }
+    /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
+    /// belongs to on the screen. Horizon keeps both on `Game` (`inv_clicks`,
+    /// `inv_drag`, `last_inv_click`), so they are dropped when the pointer
+    /// changes hands: a screen that opens or closes starts with its own
+    /// state, and a press whose release never reached the screen -- the
+    /// pointer left the window, or the screen closed first -- would
+    /// otherwise leave every later press on every later screen swallowed.
+    pub(super) fn reset_inventory_clicks(&mut self) {
+        self.inv_clicks.cancel_drag();
+        self.inv_drag = None;
+        self.last_inv_click = None;
+    }
     pub(super) fn close_container(&mut self) {
         // `Gui.setScreen` clears the old screen's focus before it goes: the
         // key that closed the container (Tab bound to the inventory) has
@@ -6507,15 +6531,29 @@ impl Game<'_> {
         }
         self.close_ender_chest();
     }
+    /// A sound a menu click made the player play (a bundle's insert or
+    /// remove): `Entity.playSound` at the player.
+    pub(super) fn player_menu_sound(&mut self, sound: &str) {
+        let Some(p) = self.player.as_ref() else {
+            return;
+        };
+        let at = [p.position.x, p.position.y, p.position.z];
+        let (volume, pitch) = if sound == horizon_client::bundle::INSERT_FAIL {
+            (1.0, 1.0)
+        } else {
+            (0.8, 0.8 + self.world.random.next_float() * 0.4)
+        };
+        self.audio.play(sound, Some(at), volume, pitch);
+    }
     /// `Camera.setRotation`: the camera's orientation, turned round in
     /// third-person front view.
     pub(super) fn camera_orientation(&self) -> glam::Quat {
-        if self.studio.freecam.active {
+        if self.studio_freecam.active {
             return camera_rotation(
                 perspective::CameraType::FirstPerson,
-                self.studio.freecam.yaw,
-                self.studio.freecam.pitch,
-            ) * glam::Quat::from_rotation_z(self.studio.freecam.roll.to_radians());
+                self.studio_freecam.yaw,
+                self.studio_freecam.pitch,
+            ) * glam::Quat::from_rotation_z(self.studio_freecam.roll.to_radians());
         }
         match self.posed_rotation {
             // The frame's camera, already turned round in front view.
@@ -6722,8 +6760,8 @@ impl Game<'_> {
         self.mark_player(out.len(), !self.own_body_in_view());
         let player_start = out.len();
         self.mark_motion(player_start, Self::MOTION_OWN_PLAYER);
-        let player_alpha = if self.studio.replay.is_some() {
-            (self.studio.virtual_tick_ms as f64 / 50.0).clamp(0.0, 1.0)
+        let player_alpha = if self.studio_replay.is_some() {
+            (self.studio_virtual_tick_ms as f64 / 50.0).clamp(0.0, 1.0)
         } else {
             self.clock.camera_fraction()
         };
@@ -6735,8 +6773,8 @@ impl Game<'_> {
                 .extend(out.drain(player_start..));
         }
         self.mark_motion(out.len(), 0);
-        // Companions in first person, trails and auras (game/cosmetics/fx.rs).
-        self.cosmetics_fx_geometry(camera, alpha, &mut out);
+        // What crates draw around players: first person, see-through (game/player_hooks.rs).
+        self.players_after_geometry(camera, alpha, &mut out);
         self.mark_entity(out.len(), "minecraft:evoker_fangs");
         self.fangs_geometry(camera, alpha, &mut out);
         self.block_item_display_geometry(camera, alpha, &mut out);
@@ -7455,7 +7493,6 @@ impl Game<'_> {
         self.spawn_phantoms();
         self.tick_advancements();
         self.tick_player_model();
-        self.tick_emotes();
         Ok(())
     }
 
@@ -9225,7 +9262,7 @@ impl Game<'_> {
         let camera_alpha = self.clock.camera_fraction();
         let vanilla = self.camera_view(camera_alpha as f32);
         let view = vanilla.map(|view| {
-            if self.shows_panorama() || self.studio.freecam.active {
+            if self.shows_panorama() || self.studio_freecam.active {
                 view
             } else {
                 self.native_camera_pose_now(camera_alpha as f32, view)
@@ -9403,9 +9440,9 @@ impl Game<'_> {
         // hitboxes (F3+G, F3+B).
         let mut lines = self.fishing_line(alpha, size);
         let mut g = self.debug_gizmos(alpha as f32, camera.to_array());
-        if self.studio.freecam.active || self.studio.replay.is_some() {
+        if self.studio_freecam.active || self.studio_replay.is_some() {
             horizon_client::studio::render_camera_path(
-                &self.studio.freecam.track,
+                &self.studio_freecam.track,
                 &mut g,
                 None,
                 100,
@@ -9432,7 +9469,7 @@ impl Game<'_> {
             Vec::new()
         };
         pr.lap("pr_native_visuals");
-        let view = if self.studio.freecam.active {
+        let view = if self.studio_freecam.active {
             glam::Mat4::from_quat(self.camera_orientation().conjugate())
         } else {
             horizon_client::camera::view_matrix(view_yaw, view_pitch)
@@ -9558,7 +9595,7 @@ impl Game<'_> {
         } else {
             self.fov_degrees(camera_alpha as f32, camera.to_array())
         };
-        let camera_effects = fov::camera_effects_enabled(title, self.studio.freecam.active);
+        let camera_effects = fov::camera_effects_enabled(title, self.studio_freecam.active);
         let bob = if !camera_effects {
             glam::Mat4::IDENTITY
         } else {
@@ -10063,7 +10100,7 @@ impl Game<'_> {
                 )
             )
         {
-            self.input_keyboard_used();
+            self.pad.keyboard_took_over = true;
         }
         if let WindowEvent::KeyboardInput { event, .. } = &event
             && event.state == ElementState::Pressed
@@ -10452,19 +10489,19 @@ impl Game<'_> {
                         let previous = self.cursor;
                         self.cursor = (position.x as f32 / b.scale, position.y as f32 / b.scale);
                         if self.screen == Screen::Playing
-                            && (self.studio.timeline.dragging_playhead
-                                || self.studio.timeline.dragging_keyframe.is_some())
+                            && (self.studio_timeline.dragging_playhead
+                                || self.studio_timeline.dragging_keyframe.is_some())
                         {
-                            let action = self.studio.timeline.handle_mouse_drag(
+                            let action = self.studio_timeline.handle_mouse_drag(
                                 self.cursor,
                                 b.width,
-                                &mut self.studio.freecam,
+                                &mut self.studio_freecam,
                             );
                             if matches!(
                                 action,
                                 horizon_client::studio::TimelineAction::KeyframeMoved
                             ) {
-                                self.studio.camera_track_dirty = true;
+                                self.studio_camera_track_dirty = true;
                             }
                             return Ok(());
                         }
@@ -10516,7 +10553,7 @@ impl Game<'_> {
                     }
                 }
                 WindowEvent::MouseWheel { .. }
-                    if self.screen == Screen::Playing && self.studio.replay.is_some() => {}
+                    if self.screen == Screen::Playing && self.studio_replay.is_some() => {}
                 WindowEvent::MouseWheel { delta, .. } => {
                     let (raw_x, raw_y) = match delta {
                         MouseScrollDelta::LineDelta(x, y) => (f64::from(x), f64::from(y)),
@@ -10794,44 +10831,44 @@ impl Game<'_> {
                 WindowEvent::MouseInput { state, button, .. } => {
                     let pressed = state == ElementState::Pressed;
                     if !pressed && button == MouseButton::Left {
-                        let action = self.studio.timeline.handle_mouse_up();
+                        let action = self.studio_timeline.handle_mouse_up();
                         if !matches!(action, horizon_client::studio::TimelineAction::None) {
                             self.handle_studio_timeline_action(action);
                         }
                     }
-                    if (self.studio.freecam.active || self.studio.replay.is_some())
+                    if (self.studio_freecam.active || self.studio_replay.is_some())
                         && button == MouseButton::Right
                     {
                         if let Some(renderer) = &self.renderer {
                             let batch =
                                 HudBatch::new([renderer.config.width, renderer.config.height]);
-                            if self.studio.timeline.visible
-                                && self.cursor.1 >= batch.height - self.studio.timeline.height()
+                            if self.studio_timeline.visible
+                                && self.cursor.1 >= batch.height - self.studio_timeline.height()
                             {
                                 if pressed
-                                    && let Some(index) = self.studio.timeline.keyframe_at_cursor(
+                                    && let Some(index) = self.studio_timeline.keyframe_at_cursor(
                                         self.cursor,
                                         batch.width,
                                         batch.height,
-                                        &self.studio.freecam,
+                                        &self.studio_freecam,
                                     )
                                 {
-                                    if index < self.studio.freecam.track.keyframes.len() {
-                                        self.studio.freecam.track.keyframes.remove(index);
-                                        self.studio.camera_track_dirty = true;
+                                    if index < self.studio_freecam.track.keyframes.len() {
+                                        self.studio_freecam.track.keyframes.remove(index);
+                                        self.studio_camera_track_dirty = true;
                                     }
-                                    self.studio.timeline.selected_keyframe = None;
+                                    self.studio_timeline.selected_keyframe = None;
                                 }
                                 return Ok(());
                             }
                         }
                         if pressed {
-                            self.studio.topbar.close_dropdown();
-                            self.studio.rmb_down = true;
+                            self.studio_topbar.close_dropdown();
+                            self.studio_rmb_down = true;
                             self.capture(true);
                             return Ok(());
-                        } else if self.studio.rmb_down {
-                            self.studio.rmb_down = false;
+                        } else if self.studio_rmb_down {
+                            self.studio_rmb_down = false;
                             self.capture(false);
                             return Ok(());
                         }
@@ -10839,7 +10876,7 @@ impl Game<'_> {
                     if pressed
                         && button == MouseButton::Left
                         && self.screen == Screen::Playing
-                        && (self.studio.replay.is_some() || self.studio.freecam.active)
+                        && (self.studio_replay.is_some() || self.studio_freecam.active)
                     {
                         let size = self
                             .renderer
@@ -10847,8 +10884,8 @@ impl Game<'_> {
                             .map(|renderer| [renderer.config.width, renderer.config.height])
                             .unwrap_or([1, 1]);
                         let batch = HudBatch::new(size);
-                        let had_open_menu = self.studio.topbar.open_menu.is_some();
-                        let topbar_action = self.studio.topbar.handle_mouse_click(
+                        let had_open_menu = self.studio_topbar.open_menu.is_some();
+                        let topbar_action = self.studio_topbar.handle_mouse_click(
                             self.cursor,
                             batch.width,
                             batch.height,
@@ -10857,26 +10894,26 @@ impl Game<'_> {
                             self.handle_studio_topbar_action(topbar_action);
                             return Ok(());
                         }
-                        if had_open_menu || self.cursor.1 <= self.studio.topbar.height {
+                        if had_open_menu || self.cursor.1 <= self.studio_topbar.height {
                             return Ok(());
                         }
-                        if self.studio.timeline.visible {
-                            let action = self.studio.timeline.handle_mouse_down(
+                        if self.studio_timeline.visible {
+                            let action = self.studio_timeline.handle_mouse_down(
                                 self.cursor,
                                 batch.width,
                                 batch.height,
-                                &self.studio.freecam,
+                                &self.studio_freecam,
                             );
                             if !matches!(action, horizon_client::studio::TimelineAction::None) {
                                 self.handle_studio_timeline_action(action);
                                 return Ok(());
                             }
-                            if self.cursor.1 >= batch.height - self.studio.timeline.height() {
+                            if self.cursor.1 >= batch.height - self.studio_timeline.height() {
                                 return Ok(());
                             }
                         }
                     }
-                    if self.screen == Screen::Playing && self.studio.replay.is_some() {
+                    if self.screen == Screen::Playing && self.studio_replay.is_some() {
                         return Ok(());
                     }
                     if matches!(self.screen, Screen::Inventory | Screen::Creative)
@@ -11346,7 +11383,7 @@ impl Game<'_> {
                     let between = now.saturating_duration_since(self.frame_end);
                     self.frame_ticks = elapsed.as_secs_f32() * 20.0;
                     self.previous = now;
-                    if self.studio.freecam.active
+                    if self.studio_freecam.active
                         && self.screen == Screen::Playing
                         && !self.dialog_open()
                     {
@@ -11356,7 +11393,7 @@ impl Game<'_> {
                         let vertical =
                             held(KeyCode::KeyE) - held(KeyCode::KeyQ) + held(KeyCode::Space);
                         let fast = self.keys.raw(&KeyCode::ControlRight);
-                        self.studio.freecam.update_flight_motion(
+                        self.studio_freecam.update_flight_motion(
                             forward,
                             strafe,
                             vertical,
@@ -11436,7 +11473,7 @@ impl Game<'_> {
                     self.extras_frame(elapsed);
                     self.extras_retry()?;
                     self.apply_mouse_look();
-                    self.input_look(elapsed.as_secs_f32());
+                    self.pad_look(elapsed.as_secs_f32());
                     self.advance_flight();
                     self.tick_world_icon();
                     let ticked = Instant::now();
@@ -12146,7 +12183,16 @@ impl<'a> Game<'a> {
             entity_attachments: Default::default(),
             remote: None,
             realm_session: false,
-            studio: Default::default(),
+            studio_replay: None,
+            studio_freecam: Default::default(),
+            studio_timeline: Default::default(),
+            studio_topbar: Default::default(),
+            studio_rmb_down: false,
+            studio_camera_track_dirty: false,
+            studio_replay_previous_camera_type: None,
+            studio_replay_standalone: false,
+            last_replay_tick: None,
+            studio_virtual_tick_ms: 0.0,
             lan: None,
             integrated: None,
             level_shapes: Default::default(),

crates/horizon-client/src/game/block_entity_ticks.rs

@@ -42,25 +42,12 @@ impl Game<'_> {
         self.trial_spawner_tick_positions.clear();
         self.item_columns = Some(Default::default());
         self.pass_mobs = Some(Default::default());
-        let tickers = self.world.block_entity_tickers();
-        let mut last_chunk = (i32::MIN, i32::MIN);
-        let mut last_chunk_ticking = false;
-        for slot in tickers.iter().copied() {
+        for slot in self.world.block_entity_tickers().iter().copied() {
             let pos = slot.0;
-            let chunk = (pos.0 >> 4, pos.2 >> 4);
-            let chunk_ticking = if chunk == last_chunk {
-                last_chunk_ticking
-            } else {
-                last_chunk = chunk;
-                last_chunk_ticking = ticking(pos.0, pos.2);
-                last_chunk_ticking
-            };
-            if !chunk_ticking {
-                continue;
-            }
             // Ticks before this one can remove it (`TickingBlockEntity.isRemoved`).
             if self.world.block_entities.is_asleep(&pos)
                 || !self.world.block_entities.is_live(slot)
+                || !ticking(pos.0, pos.2)
                 || !self.border.contains(f64::from(pos.0), f64::from(pos.2))
             {
                 continue;
@@ -223,14 +210,8 @@ impl Game<'_> {
     /// (`ServerLevel.areEntitiesLoaded`).
     pub(super) fn block_ticking_area(&self) -> impl Fn(i32, i32) -> bool + use<> {
         let levels = self.tickets.levels();
-        let has_pending = !self.world.entities_pending.is_empty();
-        let pending = has_pending.then(|| self.world.entities_pending.clone());
-        move |x, z| {
-            levels.block_ticking_at(x, z)
-                && pending
-                    .as_ref()
-                    .is_none_or(|p| !p.contains(&(x >> 4, z >> 4)))
-        }
+        let pending = self.world.entities_pending.clone();
+        move |x, z| levels.block_ticking_at(x, z) && !pending.contains(&(x >> 4, z >> 4))
     }
     /// `DaylightDetectorBlock.tickEntity` of the detector at `pos`.
     fn tick_daylight_detector(&mut self, pos: Pos) {

crates/horizon-client/src/game/commands.rs

@@ -3831,9 +3831,12 @@ impl Game<'_> {
                     return;
                 }
                 g.spawn = None;
-                g.respawn_config = Some(super::respawn_anchor::RespawnConfig::forced(
-                    level, pos, yaw, pitch,
-                ));
+                g.respawn_config = Some(super::respawn_anchor::RespawnConfig {
+                    dim: level,
+                    pos,
+                    yaw,
+                    forced: true,
+                });
             });
         }
         let dim = Text::literal(self.dim.id());

crates/horizon-client/src/game/control.rs

@@ -644,7 +644,7 @@ impl Game<'_> {
                     .into());
                 }
                 if arg(2)? != "up" {
-                    self.input_keyboard_used();
+                    self.pad.keyboard_took_over = true;
                 }
                 // The command confirmation takes the keys; none go past it.
                 if self.command_prompt.is_some() {
@@ -800,7 +800,7 @@ impl Game<'_> {
                 // controller still holding one keeps it.
                 let options = [self.settings.toggle_crouch, self.settings.toggle_sprint];
                 for (slot, name) in [(0, "key.sneak"), (1, "key.sprint")] {
-                    if !self.input_holds(name) {
+                    if !self.pad.holds_action(&self.settings.controller, name) {
                         self.toggles.key(
                             slot,
                             horizon_client::keymapping::KeyAction::Release,

crates/horizon-client/src/game/cosmetics/emotes.rs

@@ -10,6 +10,7 @@ use horizon_client::mobs::Mob;
 use horizon_client::mobs::anim::BodyPose;
 use horizon_cosmetics::account::OwnedEmote;
 use horizon_cosmetics::{Item, Playing, Slot};
+use horizon_hooks::players::PlayerModels;
 use std::sync::Arc;
 
 /// How far the player may drift (blocks) before the emote stops: a nudge, not a step.
@@ -37,10 +38,15 @@ pub(in crate::game) struct Emotes {
 
 impl Emotes {
     /// The emote to tell the service about, while it plays: its id and whether it loops.
-    pub(in crate::game) fn sending(&self) -> Option<(String, bool)> {
+    pub(in crate::game) fn sending(&self) -> Option<(&str, bool)> {
         let p = self.playing.as_ref().filter(|p| p.stop.is_none())?;
         let looping = p.item.emote.as_ref().is_some_and(|e| e.looping);
-        Some((p.item.id.clone(), looping))
+        Some((&p.item.id, looping))
+    }
+
+    /// When the emote that pulled the camera back started (the own model's age), while it plays.
+    pub(in crate::game) fn pull(&self) -> Option<f32> {
+        self.camera_from.and(self.playing.as_ref()).map(|p| p.start)
     }
 }
 
@@ -59,23 +65,43 @@ impl BodyPose for EmotePose {
     }
 }
 
-/// The emote `m` plays, if any.
-pub(in crate::game) fn playing(m: &Mob) -> Option<&Playing> {
-    let any: &dyn std::any::Any = &**m.emote.as_ref()?;
+/// The emote a model's pose plays, if it is one.
+pub(in crate::game) fn pose_playing(pose: Option<&Arc<dyn BodyPose>>) -> Option<&Playing> {
+    let any: &dyn std::any::Any = &**pose?;
     any.downcast_ref::<EmotePose>().map(|e| &e.0)
 }
 
-/// Makes `m` play `next`, unless it plays that already (a new one allocates).
-pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
-    let same = match (playing(m), &next) {
+/// The pose that plays `next` where `now` is laid, unless it plays that already (None: keep
+/// it; a new one allocates).
+fn replaced(
+    now: Option<&Arc<dyn BodyPose>>,
+    next: Option<Playing>,
+) -> Option<Option<Arc<dyn BodyPose>>> {
+    let same = match (pose_playing(now), &next) {
         (None, None) => true,
         (Some(a), Some(b)) => {
             Arc::ptr_eq(&a.item, &b.item) && a.start == b.start && a.stop == b.stop
         }
         _ => false,
     };
-    if !same {
-        m.emote = next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>);
+    (!same).then(|| next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>))
+}
+
+/// Makes `m` play `next`, unless it plays that already.
+pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
+    if let Some(pose) = replaced(m.emote.as_ref(), next) {
+        m.emote = pose;
+    }
+}
+
+/// Makes model `id` play `next`, unless it plays that already.
+pub(in crate::game) fn set_model_playing(
+    models: &mut dyn PlayerModels,
+    id: u32,
+    next: Option<Playing>,
+) {
+    if let Some(pose) = replaced(models.body_pose(id), next) {
+        models.set_body_pose(id, pose);
     }
 }
 
@@ -229,7 +255,7 @@ impl Game<'_> {
         }
     }
 
-    /// Once a tick: my emote, then the other players'.
+    /// Once a tick: my emote (the others' are `cosmetics::Seat::tick`'s, a hook's).
     pub(in crate::game) fn tick_emotes(&mut self) {
         if let Some(done) = self
             .cosmetics
@@ -250,20 +276,6 @@ impl Game<'_> {
             }
         }
         self.tick_emote();
-        self.tick_others_emotes();
-    }
-
-    /// How far the camera stands back while an emote pulls it (1: the usual distance): it eases
-    /// out over the emote's first quarter second.
-    pub(in crate::game) fn emote_camera_pull(&self, partial: f32) -> f32 {
-        let (Some(p), Some(m)) = (&self.cosmetics.emotes.playing, &self.player_model) else {
-            return 1.0;
-        };
-        if self.cosmetics.emotes.camera_from.is_none() {
-            return 1.0;
-        }
-        let t = ((m.age as f32 + partial - p.start) / 5.0).clamp(0.0, 1.0);
-        0.35 + 0.65 * t * t * (3.0 - 2.0 * t)
     }
 }
 

crates/horizon-client/src/game/cosmetics/fx.rs

@@ -1,47 +1,78 @@
 //! Companions, trails and auras ([docs/cosmetics.md](../../../../../docs/cosmetics.md)): worn
 //! like the other cosmetics but on no bone. A companion floats beside its wearer and follows with
 //! a lag (`horizon_cosmetics::follow`), drawn with the wearer; a trail's particles
-//! (`horizon_cosmetics::trail`) and an aura blend, so they go after every player in one
-//! see-through span (`cosmetics_fx_geometry`). Nothing of them is an entity, collides or is sent
-//! to a server.
+//! (`horizon_cosmetics::trail`) and an aura blend, so they are drawn see-through after every
+//! player (`PlayerDraw::particles`, `Look::see_through`). Nothing of them is an entity, collides
+//! or is sent to a server.
 
-use super::{FULL_LIGHT, OWN};
-use crate::game::Game;
+use super::Seat;
 use glam::{DVec3, Mat4, Vec3};
-use horizon_client::mesher::Vertex;
-use horizon_client::mobs::anim::Poses;
-use horizon_client::mobs::{Mob, Part};
+use horizon_client::fast_hash::FxHashMap;
 use horizon_cosmetics::follow::{self, Follow};
-use horizon_cosmetics::trail::Emitter;
+use horizon_cosmetics::trail::{Budget, Emitter};
 use horizon_cosmetics::{Item, Slot};
+use horizon_hooks::players::{Kind, Light, Look, Particle, Pass, PlayerDraw, PlayerModel};
 use std::sync::Arc;
+use std::time::Instant;
 
 /// How far from the camera (blocks) a wearer's companion, trail and aura are drawn.
 const FAR: f32 = 48.0;
 
-/// Who wears it, as drawn this frame.
-pub(super) struct Wearer<'a> {
-    pub m: &'a Mob,
-    /// The player's own model.
-    pub own: bool,
-    /// `OWN`, or the entity id.
-    pub key: u32,
-    /// The wearer's model matrix (`render::base_transform`), relative to `camera`.
-    pub base: Mat4,
-    pub camera: DVec3,
-    pub alpha: f32,
-    pub light: u32,
+/// The key of the player's own model in `Fx`'s maps (others go by entity id).
+const OWN: u32 = u32::MAX;
+
+/// What companions and trails keep between frames, per wearer (marked with the frame they were
+/// last drawn in; the others are dropped).
+#[derive(Default)]
+pub(super) struct Fx {
+    companions: FxHashMap<u32, (Follow, u32)>,
+    trails: FxHashMap<u32, (Emitter, u32)>,
+    budget: Budget,
+    clock: Option<(Instant, Instant)>,
+    /// Ticks since the first frame, and the last frame's length in seconds.
+    now: f64,
+    dt: f32,
+    frame: u32,
+    /// Kept so a frame of trails allocates none.
+    particles: Vec<Particle>,
 }
 
-/// `m`'s head yaw this frame (degrees).
-fn head_yaw(m: &Mob, alpha: f32) -> f32 {
-    let turn = horizon_client::mobs::living::wrap(m.head_yaw - m.previous_head_yaw);
-    m.previous_head_yaw + turn * alpha
-}
+impl Fx {
+    /// A new frame: the clock moves on and what no frame drew since the last one goes.
+    pub(super) fn frame(&mut self) {
+        self.frame = self.frame.wrapping_add(1);
+        let frame = self.frame;
+        let now = Instant::now();
+        let (start, last) = self.clock.get_or_insert((now, now));
+        self.dt = now.duration_since(*last).as_secs_f32().min(0.25);
+        self.now = now.duration_since(*start).as_secs_f64() * 20.0;
+        *last = now;
+        let seen = |mark: u32| frame.wrapping_sub(mark) <= 1;
+        self.companions.retain(|_, (_, mark)| seen(*mark));
+        let budget = &mut self.budget;
+        self.trails.retain(|_, (e, mark)| {
+            let keep = seen(*mark);
+            if !keep {
+                e.clear(budget);
+            }
+            keep
+        });
+    }
 
-/// Whether `m` lies in a bed.
-fn asleep(m: &Mob) -> bool {
-    m.extra.avatar_pose == horizon_client::pose::Pose::Sleeping
+    /// The companion of wearer `key` moved toward `target` (once a frame, however many times it
+    /// is drawn).
+    fn follow(&mut self, key: u32, target: DVec3, yaw: f32, lag: f32) -> Follow {
+        let (frame, dt) = (self.frame, self.dt);
+        let (f, mark) = self
+            .companions
+            .entry(key)
+            .or_insert((Follow::at(target, yaw), frame));
+        if *mark != frame {
+            f.step(target, yaw, lag, dt);
+            *mark = frame;
+        }
+        *f
+    }
 }
 
 /// Where a companion floats: `at` (relative to the camera) facing `yaw`, at the wearer's scale,
@@ -52,270 +83,144 @@ fn companion_matrix(at: Vec3, yaw: f32, scale: f32) -> Mat4 {
         * Mat4::from_scale(Vec3::new(-scale, -scale, scale))
 }
 
-impl Game<'_> {
-    /// A companion, trail or aura `at` wears: a companion goes where the wearer's other items go
-    /// (`gpu` and `out`, `bounds` grown), trails and auras to the frame's see-through vertices.
-    /// Other players' trails and auras stay hidden with "Hide other players' trails and auras".
-    pub(super) fn cosmetics_fx(
-        &self,
-        at: &Wearer,
-        item: &Arc<Item>,
-        gpu: bool,
-        bounds: Option<(Vec3, Vec3)>,
-        poses: &mut Poses,
-        out: &mut Vec<Vertex>,
-    ) -> Option<(Vec3, Vec3)> {
-        if !at.own && item.slot.is_effect() && self.settings.extras.cosmetics_hide_fx {
-            return bounds;
+/// Full light for what glows, else `otherwise`.
+fn glowing(glow: bool, otherwise: Light) -> Light {
+    if glow { Light::Full } else { otherwise }
+}
+
+impl Seat {
+    /// A companion, trail or aura `m` wears, around its model as `draw` draws it. Other players'
+    /// trails and auras stay hidden with "Hide other players' trails and auras".
+    pub(super) fn fx(&mut self, m: &PlayerModel, item: &Arc<Item>, draw: &mut dyn PlayerDraw) {
+        let own = m.kind == Kind::Own;
+        if !own && item.slot.is_effect() && self.said.hide_fx {
+            return;
         }
         // Past `FAR` a companion, trail or aura is a few pixels across for the cost of a model:
         // not drawn, and a trail that isn't drawn doesn't spawn (its particles go back to the
         // budget).
-        if at.base.w_axis.truncate().length_squared() > FAR * FAR {
-            return bounds;
+        let base = Mat4::from_cols_array_2d(&draw.base());
+        if base.w_axis.truncate().length_squared() > FAR * FAR {
+            return;
         }
+        let Some(uv) = self.uv(item, |id| draw.sprite(id)) else {
+            return;
+        };
+        let key = if own { OWN } else { m.id };
         match item.slot {
-            Slot::Companion => {
-                let Some((model, uv, matrix)) = self.companion_at(at, item, None) else {
-                    return bounds;
-                };
-                self.pose_companion(item, at.m, at.alpha, poses, &model);
-                let glow = item.companion.as_ref().is_some_and(|c| c.glow);
-                let light = if glow { FULL_LIGHT } else { at.light };
-                self.cosmetics_model(&model, matrix, poses, uv, light, gpu, bounds, out)
-            }
-            Slot::Trail => {
-                self.trail(at, item);
-                bounds
-            }
-            Slot::Aura => {
-                self.aura(at, item, poses);
-                bounds
-            }
-            _ => bounds,
+            Slot::Companion => self.companion(key, item, uv, base, draw),
+            Slot::Trail => self.trail(key, item, uv, draw),
+            Slot::Aura => self.aura(item, uv, base, draw),
+            _ => {}
         }
     }
 
-    /// The companion's model, texture and matrix this frame, its follow moved on once a frame.
-    /// `first_person`: the camera's forward and left, for the player's own in first person: the
-    /// companion keeps out of the middle of the view.
-    fn companion_at(
-        &self,
-        at: &Wearer,
+    /// The companion where it floats, its follow moved on once a frame. In first person it keeps
+    /// out of the middle of the view, lit where it floats.
+    fn companion(
+        &mut self,
+        key: u32,
         item: &Arc<Item>,
-        first_person: Option<(Vec3, Vec3)>,
-    ) -> Option<(Arc<Part>, [f32; 4], Mat4)> {
-        let c = item.companion.as_ref()?;
-        let (models, uv) = self.cosmetics_baked(item)?;
-        let model = models.first()?.1.clone();
-        let scale = at.base.x_axis.truncate().length();
-        let target = at.base.transform_point3(Vec3::from(c.anchor) / 16.0);
-        let head = at
-            .base
-            .transform_point3(Vec3::from(horizon_cosmetics::HEAD) / 16.0);
-        let yaw = head_yaw(at.m, at.alpha);
-        let follow = self.companion_follow(at.key, at.camera + target.as_dvec3(), yaw, c.lag);
+        uv: [f32; 4],
+        base: Mat4,
+        draw: &mut dyn PlayerDraw,
+    ) {
+        let Some(c) = item.companion.as_ref() else {
+            return;
+        };
+        let Some((_, mesh)) = self.kept(item).meshes.first().cloned() else {
+            return;
+        };
+        let first_person = draw.pass() == Pass::FirstPerson;
+        let (motion, view) = (draw.motion(), draw.view());
+        let camera = DVec3::from(view.camera);
+        let scale = base.x_axis.truncate().length();
+        let target = base.transform_point3(Vec3::from(c.anchor) / 16.0);
+        let head = base.transform_point3(Vec3::from(horizon_cosmetics::HEAD) / 16.0);
+        let follow = self
+            .fx
+            .follow(key, camera + target.as_dvec3(), motion.head_yaw, c.lag);
         let clearance = (horizon_cosmetics::HEAD_CLEARANCE + c.reach) / 16.0 * scale;
-        let mut rel = (follow.pos - at.camera).as_vec3();
-        if let Some((forward, left)) = first_person {
-            rel = follow::out_of_view(rel, forward, left);
+        let mut rel = (follow.pos - camera).as_vec3();
+        if first_person {
+            rel = follow::out_of_view(rel, Vec3::from(view.forward), Vec3::from(view.left));
         }
         rel = follow::clear_of(rel, head, clearance);
-        Some((model, uv, companion_matrix(rel, follow.yaw, scale)))
-    }
-
-    /// The companion of wearer `key` moved toward `target` (once a frame, however many times it
-    /// is drawn).
-    fn companion_follow(&self, key: u32, target: DVec3, yaw: f32, lag: f32) -> Follow {
-        let frame = self.cosmetics.frame.get();
-        let mut fx = self.cosmetics.fx.borrow_mut();
-        let dt = fx.dt;
-        let (f, mark) = fx
-            .companions
-            .entry(key)
-            .or_insert((Follow::at(target, yaw), frame));
-        if *mark != frame {
-            f.step(target, yaw, lag, dt);
-            *mark = frame;
-        }
-        *f
-    }
-
-    /// The companion's animations, and its `look` part turned with the wearer's pitch.
-    fn pose_companion(&self, item: &Item, m: &Mob, alpha: f32, poses: &mut Poses, model: &Part) {
-        poses.reset(model);
-        item.animate(m.age as f32 + alpha, |name, pose| *poses.get(name) = pose);
-        if let Some(look) = item.companion.as_ref().and_then(|c| c.look.as_deref()) {
-            let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * alpha;
-            poses.get(look)[3] += (pitch * 0.6).clamp(-30.0, 30.0).to_radians();
-        }
+        let matrix = companion_matrix(rel, follow.yaw, scale).to_cols_array_2d();
+        let near = if first_person {
+            Light::AtPlace
+        } else {
+            Light::Model
+        };
+        let look = Look::new(uv).lit(glowing(c.glow, near));
+        let ticks = draw.ticks();
+        // Its animations, and its `look` part turned with the wearer's pitch.
+        let pitch = (motion.head_pitch * 0.6).clamp(-30.0, 30.0).to_radians();
+        draw.draw(&mesh, matrix, look, &mut |p| {
+            item.animate(ticks, |name, pose| *p.pose(name) = pose);
+            if let Some(part) = c.look.as_deref() {
+                p.pose(part)[3] += pitch;
+            }
+        });
     }
 
     /// The trail's particles: spawned once a frame by the distance walked (not while sneaking or
     /// asleep), facing the camera.
-    fn trail(&self, at: &Wearer, item: &Arc<Item>) {
+    fn trail(&mut self, key: u32, item: &Arc<Item>, uv: [f32; 4], draw: &mut dyn PlayerDraw) {
         let Some(t) = &item.trail else {
             return;
         };
-        let Some((_, uv)) = self.cosmetics_baked(item) else {
-            return;
-        };
-        let m = at.m;
-        let a = f64::from(at.alpha);
-        let feet = DVec3::new(
-            m.previous.x + (m.position.x - m.previous.x) * a,
-            m.previous.y + (m.position.y - m.previous.y) * a,
-            m.previous.z + (m.position.z - m.previous.z) * a,
-        );
-        let moves = !m.extra.crouching && !asleep(m);
-        let q = self.camera_orientation();
-        let (right, up) = (q * Vec3::X, q * Vec3::Y);
-        let light = if t.glow { FULL_LIGHT } else { at.light };
-        let frame = self.cosmetics.frame.get();
-        let mut fx = self.cosmetics.fx.borrow_mut();
-        let super::Fx {
+        let (motion, view) = (draw.motion(), draw.view());
+        let moves = !motion.crouching && !motion.asleep;
+        let Fx {
             trails,
             budget,
             now,
-            clear,
+            frame,
+            particles,
             ..
-        } = &mut *fx;
+        } = &mut self.fx;
         let (e, mark) = trails
-            .entry(at.key)
+            .entry(key)
             .or_insert_with(|| (Emitter::default(), frame.wrapping_sub(1)));
-        if *mark != frame {
-            e.step(t, feet, moves, *now, budget);
-            *mark = frame;
-        }
-        for quad in e.quads(t, *now, at.camera, right, up) {
-            let color = ((quad.alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
-            for (corner, [u, v]) in quad.corners.iter().zip(quad.uv) {
-                clear.push(Vertex {
-                    pos: corner.to_array(),
-                    uv: [uv[0] + (uv[2] - uv[0]) * u, uv[1] + (uv[3] - uv[1]) * v],
-                    layer: 0,
-                    color,
-                    light,
-                    // Unlit: a particle keeps its colour whichever way it faces.
-                    normal: [0, 0, 0, 0],
-                    glint_uv: [0.0, 0.0],
-                });
-            }
+        if *mark != *frame {
+            e.step(t, DVec3::from(motion.feet), moves, *now, budget);
+            *mark = *frame;
         }
+        let (camera, right, up) = (
+            DVec3::from(view.camera),
+            Vec3::from(view.right),
+            Vec3::from(view.up),
+        );
+        particles.clear();
+        particles.extend(
+            e.quads(t, *now, camera, right, up)
+                .map(|q| Particle::new(q.corners.map(|c| c.to_array()), q.uv, q.alpha)),
+        );
+        draw.particles(uv, particles, glowing(t.glow, Light::Model));
     }
 
     /// The aura at the wearer's feet, see-through. None while they fly, swim or sleep: it would
     /// tip over with the body.
-    fn aura(&self, at: &Wearer, item: &Arc<Item>, poses: &mut Poses) {
-        let (m, Some(a)) = (at.m, &item.aura) else {
+    fn aura(&mut self, item: &Arc<Item>, uv: [f32; 4], base: Mat4, draw: &mut dyn PlayerDraw) {
+        let Some(a) = &item.aura else {
             return;
         };
-        if m.extra.fall_flying || asleep(m) || m.extra.swim.amount(at.alpha) > 0.0 {
+        let motion = draw.motion();
+        if motion.flying || motion.asleep || motion.swimming {
             return;
         }
-        let Some((models, uv)) = self.cosmetics_baked(item) else {
-            return;
-        };
-        let Some((_, model)) = models.first() else {
+        let Some((_, mesh)) = self.kept(item).meshes.first().cloned() else {
             return;
         };
         // The model's origin is the middle of the feet: 24 pixels under the neck.
-        let matrix = at.base * Mat4::from_translation(Vec3::new(0.0, 24.0 / 16.0, 0.0));
-        poses.reset(model);
-        item.animate(m.age as f32 + at.alpha, |name, pose| {
-            *poses.get(name) = pose
+        let matrix = base * Mat4::from_translation(Vec3::new(0.0, 24.0 / 16.0, 0.0));
+        let look = Look::new(uv)
+            .lit(glowing(a.glow, Light::Model))
+            .see_through(a.alpha);
+        let ticks = draw.ticks();
+        draw.draw(&mesh, matrix.to_cols_array_2d(), look, &mut |p| {
+            item.animate(ticks, |name, pose| *p.pose(name) = pose)
         });
-        let light = if a.glow { FULL_LIGHT } else { at.light };
-        let mut fx = self.cosmetics.fx.borrow_mut();
-        let start = fx.clear.len();
-        horizon_client::mobs::render_model(
-            model,
-            matrix,
-            &|p: &Part| poses.pose(p),
-            uv,
-            light,
-            0,
-            &mut fx.clear,
-        );
-        let color = ((a.alpha * 255.0) as u32) << 24 | 0x00FF_FFFF;
-        for v in &mut fx.clear[start..] {
-            v.color = color;
-            // Seen through, a face turned away would add to the near one (and a card's two
-            // faces would double it): `entity.wgsl` drops back faces, so it is `alpha` at most.
-            v.normal[3] = horizon_client::mesher::SHADED_CULL_W;
-        }
-    }
-
-    /// After every player: the player's own companion in first person (out of the middle of the
-    /// view, after the first-person model went to the shadow pass only), then the frame's trails
-    /// and auras in one see-through span.
-    pub(in crate::game) fn cosmetics_fx_geometry(
-        &self,
-        camera: DVec3,
-        alpha: f64,
-        out: &mut Vec<Vertex>,
-    ) {
-        if !super::enabled() {
-            return;
-        }
-        if !self.own_body_in_view()
-            && let Some(m) = self.player_model.as_ref()
-        {
-            self.mark_entity(out.len(), "minecraft:player");
-            self.own_companion_first_person(m, camera, alpha as f32, out);
-        }
-        let fx = self.cosmetics.fx.borrow();
-        if !fx.clear.is_empty() {
-            self.mark_translucent_entity(out.len(), "minecraft:player");
-            out.extend_from_slice(&fx.clear);
-        }
-    }
-
-    fn own_companion_first_person(
-        &self,
-        m: &Mob,
-        camera: DVec3,
-        alpha: f32,
-        out: &mut Vec<Vertex>,
-    ) {
-        if horizon_client::mobs::trader::is_invisible(m) || self.own_invisible() {
-            return;
-        }
-        let Some(worn) = self.worn(m, true) else {
-            return;
-        };
-        let Some(item) = worn.iter().find(|i| i.slot == Slot::Companion) else {
-            return;
-        };
-        let at = Wearer {
-            m,
-            own: true,
-            key: OWN,
-            base: horizon_client::mobs::render::base_transform(m, alpha, camera),
-            camera,
-            alpha,
-            light: FULL_LIGHT,
-        };
-        let (yaw, pitch) = (self.yaw.to_radians(), self.pitch.to_radians());
-        let forward = Vec3::new(
-            -yaw.sin() * pitch.cos(),
-            -pitch.sin(),
-            yaw.cos() * pitch.cos(),
-        );
-        let left = Vec3::new(yaw.cos(), 0.0, yaw.sin());
-        let Some((model, uv, matrix)) = self.companion_at(&at, item, Some((forward, left))) else {
-            return;
-        };
-        // Lit where it floats.
-        let p = (camera + matrix.w_axis.truncate().as_dvec3()).floor();
-        let light = self.world.light(p.x as i32, p.y as i32, p.z as i32);
-        let mut light = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
-        if item.companion.as_ref().is_some_and(|c| c.glow) {
-            light = FULL_LIGHT;
-        }
-        let mut poses = self.cosmetics.poses.borrow_mut();
-        let poses = &mut poses.1;
-        self.pose_companion(item, m, alpha, poses, &model);
-        self.cosmetics_model(&model, matrix, poses, uv, light, false, None, out);
     }
 }

crates/horizon-client/src/game/creative_hotbar.rs

@@ -9,7 +9,7 @@ impl Game<'_> {
     pub(super) fn mapped_key_down(&self, mapping: &str) -> bool {
         keybinds::key_code(self.settings.keys.get(mapping))
             .is_some_and(|k| self.physical_keys.contains(&k))
-            || self.input_holds(mapping)
+            || self.pad.holds_action(&self.settings.controller, mapping)
     }
 
     /// `CreativeModeInventoryScreen.selectTab` on the HOTBAR tab: each saved

crates/horizon-client/src/game/creatures.rs

@@ -2317,7 +2317,7 @@ impl Game<'_> {
             a.spawn_velocity = Some(p.velocity);
             a.spawn_rot = Some((p.pitch, p.yaw));
         }
-        self.creatures.projectiles.put_back(p);
+        self.creatures.projectiles.push(p);
         self.native_projectile_launch(player, &name, id, kind);
     }
     /// `MushroomCow.shear`'s `sendParticles(EXPLOSION, x, getY(0.5), z, 1, 0, 0, 0, 0)`:
@@ -6949,7 +6949,7 @@ impl Game<'_> {
             {
                 m.heal(25.0);
                 consume = true;
-                eat = Some(("entity.iron_golem.repair", 1.0, m.golem_repair_pitch()));
+                sound = Some("entity.iron_golem.repair");
             }
             Species::Creeper if creeper_igniter => {
                 m.extra.flag = true;

crates/horizon-client/src/game/creatures/mob_geometry.rs

@@ -280,25 +280,18 @@ impl Game<'_> {
                 self.spin_attack_geometry(mob, camera, alpha as f32, packed, out);
                 self.stuck_in_body_geometry(mob, mob.id as i32, camera, alpha as f32, packed, out);
             }
-            // Cosmetics (game/cosmetics.rs), posed on the GPU with the mob's own jobs: culled
-            // with it.
+            // What crates draw on players and mannequins (`game/player_hooks.rs`: cosmetics),
+            // posed on the GPU with the mob's own jobs: culled with it.
             if !layers_only
-                && super::super::cosmetics::enabled()
+                && horizon_hooks::engine::any()
                 && (is_player || &*mob.kind.id == "minecraft:mannequin")
             {
                 let mark = self.skin_frame.borrow().mark();
                 let base = horizon_client::mobs::render::base_transform(mob, alpha as f32, camera);
                 let gpu = skinning;
-                if let Some((lo, hi)) = self.cosmetics_geometry(
-                    mob,
-                    false,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    gpu,
-                    out,
-                ) {
+                if let Some((lo, hi)) =
+                    self.player_layers_geometry(mob, base, camera, alpha as f32, packed, gpu, out)
+                {
                     skinned = Some(match skinned {
                         Some((first, Some((l, h)))) => (first, Some((l.min(lo), h.max(hi)))),
                         Some((first, None)) => (first, Some((lo, hi))),

crates/horizon-client/src/game/dispense_fixture.rs

@@ -353,7 +353,7 @@ impl Game<'_> {
             let found =
                 self.find_respawn_and_use(config, op["consume"].as_bool().unwrap_or(true))?;
             used.push(match found {
-                Some((p, yaw, _pitch)) => format!(
+                Some((p, yaw)) => format!(
                     "respawn {} {} {} {}",
                     num(p.x),
                     num(p.y),
@@ -579,7 +579,6 @@ impl Game<'_> {
                 dim: self.dim,
                 pos: [p(0), p(1), p(2)],
                 yaw: 0.0,
-                pitch: 0.0,
                 forced: false,
             });
         }

crates/horizon-client/src/game/end.rs

@@ -739,8 +739,7 @@ impl Game<'_> {
         // anchor puts the player, facing it; else onto the spawn column.
         let mut target = target;
         if let Some(c) = self.respawn_config.filter(|c| c.dim == self.dim) {
-            // This existing owner transition adapter carries yaw only; its pitch path remains open.
-            if let Some((at, yaw, _pitch)) = self.find_respawn_and_use(c, false)? {
+            if let Some((at, yaw)) = self.find_respawn_and_use(c, false)? {
                 return Ok(Some((at, Some(yaw))));
             }
             target = fallback_spawn(self.spawn, self.level.world_spawn);

crates/horizon-client/src/game/explosion.rs

@@ -1008,10 +1008,7 @@ impl Game<'_> {
                 p.position.z - center[2],
             ];
             let distance = (d[0] * d[0] + d[1] * d[1] + d[2] * d[2]).sqrt();
-            self.input_feedback(horizon_client::input_source::Feedback::Explosion {
-                distance,
-                radius,
-            });
+            self.pad_rumble(horizon_client::gamepad::Rumble::Explosion { distance, radius });
         }
         // Explosion.explode: the blast is heard.
         let ctx = horizon_client::sculk::Context::default();

crates/horizon-client/src/game/forced_respawn_tests.rs

@@ -70,10 +70,9 @@ fn overworld_spawnpoint_is_validated_at_both_player_blocks() {
             assert_eq!(actual.is_some(), allowed, "{block} at height {height}");
             assert_eq!(game.respawn_config.is_some(), allowed);
             assert_eq!(game.level.world_spawn, Some([0, 80, 0]));
-            if let Some((at, yaw, pitch)) = actual {
+            if let Some((at, yaw)) = actual {
                 assert_eq!(at, Vec3::new(5.5, 64.1, 5.5));
                 assert_eq!(yaw, 0.0);
-                assert_eq!(pitch.to_bits(), 0.0f32.to_bits());
             }
         }
     }

crates/horizon-client/src/game/fov.rs

@@ -135,8 +135,8 @@ impl Game<'_> {
     }
     /// `Camera.calculateFov` with `modifyFovBasedOnDeathOrFluid`.
     pub(super) fn fov_degrees(&self, partial: f32, camera: [f64; 3]) -> f32 {
-        if self.studio.freecam.active {
-            return self.studio.freecam.fov.clamp(1.0, 179.0);
+        if self.studio_freecam.active {
+            return self.studio_freecam.fov.clamp(1.0, 179.0);
         }
         let fov = self.view.calculate_fov(
             partial,

crates/horizon-client/src/game/frame_geometry.rs

@@ -193,7 +193,7 @@ impl Game<'_> {
         // replay player's hands remain visible in first person; freecam has
         // no player-view hand.
         if !fov::studio_draws_hand(
-            self.studio.freecam.active,
+            self.studio_freecam.active,
             self.ui.hands_drawn(
                 self.spectator(),
                 self.sleeping.is_some(),

crates/horizon-client/src/game/lan.rs

@@ -1820,7 +1820,7 @@ impl Game<'_> {
             // from carries those, as `save_guest` gives them on leaving. The map
             // stays their one owner.
             let live = self.guest_attachments.get(&uuid).cloned();
-            let g = playerdata::with_warden(&mut host.hub.guests[i], self.warden_tracker_tag());
+            let g = &mut host.hub.guests[i];
             let held = live.map(|a| std::mem::replace(&mut g.attachments, a));
             playerdata::store(g, &mut self.level, vehicle);
             if let Some(held) = held {

crates/horizon-client/src/game/lan_actions.rs

@@ -4190,8 +4190,8 @@ impl Game<'_> {
                 .map_or([0.5, 80.0, 0.5], |[x, y, z]| {
                     [f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5]
                 });
-            let at = found.map_or(world, |(at, yaw, pitch)| {
-                (host.hub.guests[i].yaw, host.hub.guests[i].pitch) = (yaw, pitch);
+            let at = found.map_or(world, |(at, yaw)| {
+                host.hub.guests[i].yaw = yaw;
                 [at.x, at.y, at.z]
             });
             if found.is_none() {

crates/horizon-client/src/game/machines.rs

@@ -118,78 +118,34 @@ impl View {
         }
         None
     }
-    /// `WorldlyContainer.getSlotsForFace` or every slot, zero-allocation iterator.
-    pub(super) fn slots_for_face_iter(&self, face: Option<Direction>) -> Slots<'_> {
+    /// `WorldlyContainer.getSlotsForFace` or every slot.
+    fn slots_for_face(&self, face: Option<Direction>) -> Vec<usize> {
         match (self.kind, face) {
-            (Kind::Furnace, Some(Direction::Down)) => Slots::Slice(&[2, 1]),
-            (Kind::Furnace, Some(Direction::Up)) => Slots::Slice(&[0]),
-            (Kind::Furnace, Some(_)) => Slots::Slice(&[1]),
-            (Kind::Brewing, Some(Direction::Up)) => Slots::Slice(&[3]),
-            (Kind::Brewing, Some(Direction::Down)) => Slots::Slice(&[0, 1, 2, 3]),
-            (Kind::Brewing, Some(_)) => Slots::Slice(&[0, 1, 2, 4]),
-            (Kind::Composter(8), Some(Direction::Down)) => Slots::Slice(&[0]),
-            (Kind::Composter(level), Some(Direction::Up)) if level < 7 => Slots::Slice(&[0]),
-            (Kind::Composter(_), _) => Slots::Slice(&[]),
+            (Kind::Furnace, Some(Direction::Down)) => vec![2, 1],
+            (Kind::Furnace, Some(Direction::Up)) => vec![0],
+            (Kind::Furnace, Some(_)) => vec![1],
+            (Kind::Brewing, Some(Direction::Up)) => vec![3],
+            (Kind::Brewing, Some(Direction::Down)) => vec![0, 1, 2, 3],
+            (Kind::Brewing, Some(_)) => vec![0, 1, 2, 4],
+            (Kind::Composter(8), Some(Direction::Down)) => vec![0],
+            (Kind::Composter(level), Some(Direction::Up)) if level < 7 => vec![0],
+            (Kind::Composter(_), _) => vec![],
             (Kind::Mod, Some(face)) => self
                 .container
                 .as_ref()
-                .map_or(Slots::Slice(&[]), |c| Slots::Mod(&c.faces[face as usize])),
-            _ => Slots::Range(0..self.len()),
+                .map_or_else(Vec::new, |c| c.faces[face as usize].clone()),
+            _ => (0..self.len()).collect(),
         }
     }
-    /// The slots `HopperBlockEntity.addItem` tries through `face`, zero-allocation iterator.
-    pub(super) fn slots_to_add_iter(&self, face: Option<Direction>) -> Slots<'_> {
-        if matches!(self.kind, Kind::Furnace | Kind::Brewing | Kind::Mod) && face.is_some() {
-            self.slots_for_face_iter(face)
-        } else {
-            Slots::Range(0..self.len())
-        }
-    }
-    /// `WorldlyContainer.getSlotsForFace` or every slot.
-    fn slots_for_face(&self, face: Option<Direction>) -> Vec<usize> {
-        self.slots_for_face_iter(face).collect()
-    }
     /// The slots `HopperBlockEntity.addItem` tries through `face`.
     fn slots_to_add(&self, face: Option<Direction>) -> Vec<usize> {
-        self.slots_to_add_iter(face).collect()
-    }
-}
-
-pub(super) enum Slots<'a> {
-    Range(std::ops::Range<usize>),
-    Slice(&'static [usize]),
-    Mod(&'a [usize]),
-}
-
-impl Iterator for Slots<'_> {
-    type Item = usize;
-    #[inline]
-    fn next(&mut self) -> Option<usize> {
-        match self {
-            Slots::Range(r) => r.next(),
-            Slots::Slice(s) => {
-                let (&first, rest) = s.split_first()?;
-                *s = rest;
-                Some(first)
-            }
-            Slots::Mod(s) => {
-                let (&first, rest) = s.split_first()?;
-                *s = rest;
-                Some(first)
-            }
+        if matches!(self.kind, Kind::Furnace | Kind::Brewing | Kind::Mod) && face.is_some() {
+            self.slots_for_face(face)
+        } else {
+            (0..self.len()).collect()
         }
     }
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = match self {
-            Slots::Range(r) => r.len(),
-            Slots::Slice(s) => s.len(),
-            Slots::Mod(s) => s.len(),
-        };
-        (len, Some(len))
-    }
 }
-impl ExactSizeIterator for Slots<'_> {}
 
 pub(super) fn dir_from_name(name: &str) -> Option<Direction> {
     Some(match name {
@@ -224,6 +180,8 @@ struct Containers<'a> {
     registry: &'static horizon_world::registry::BlockRegistry,
     /// Brewing recipes, for what a brewing stand accepts (not needed for signals).
     brewing: Option<&'a horizon_client::brewing::Brewing>,
+    /// The stack of a full composter's `OutputContainer`.
+    bone_meal: ItemStack,
 }
 impl Containers<'_> {
     fn prop(&self, state: BlockStateId, key: &str) -> Option<&str> {
@@ -388,7 +346,7 @@ impl Containers<'_> {
     fn get(&self, view: &View, slot: usize) -> Option<&ItemStack> {
         if let Kind::Composter(level) = view.kind {
             // OutputContainer holds one bone meal; InputContainer composts at once.
-            return (level == 8 && slot == 0).then_some(bone_meal_stack());
+            return (level == 8 && slot == 0).then_some(&self.bone_meal);
         }
         let (pos, i) = view.locate(slot)?;
         self.world
@@ -494,7 +452,7 @@ impl Containers<'_> {
     }
     /// `HopperBlockEntity.isFullContainer`.
     fn is_full(&self, view: &View, face: Direction) -> bool {
-        view.slots_for_face_iter(Some(face)).all(|i| {
+        view.slots_for_face(Some(face)).into_iter().all(|i| {
             self.insertion_item(view, i)
                 .is_some_and(|s| s.count >= self.max_stack(&s))
         })
@@ -540,9 +498,6 @@ impl ItemColumns {
         x: i32,
         z: i32,
     ) -> bool {
-        if items.is_empty() {
-            return false;
-        }
         let (len, last) = (items.len(), items.last().map(|i| i.id));
         let stale = self
             .seen
@@ -601,14 +556,13 @@ impl StampedItemColumns {
     }
 }
 
-fn bone_meal_stack() -> &'static ItemStack {
-    static STACK: std::sync::LazyLock<ItemStack> = std::sync::LazyLock::new(|| ItemStack {
+fn bone_meal() -> ItemStack {
+    ItemStack {
         item: "minecraft:bone_meal".into(),
         count: 1,
         damage: 0,
         extra: None,
-    });
-    &STACK
+    }
 }
 
 /// Comparator input from a container block entity (0 when there is none).
@@ -625,6 +579,7 @@ pub(super) fn container_signal(
         items,
         registry,
         brewing: None,
+        bone_meal: bone_meal(),
     };
     c.view((pos.x, pos.y, pos.z), true)
         .filter(|v| !matches!(v.kind, Kind::Composter(_)))
@@ -680,6 +635,7 @@ impl Game<'_> {
             items: self.items(),
             registry: self.pack.assets.registry,
             brewing: Some(&self.stations().brewing),
+            bone_meal: bone_meal(),
         }
     }
     pub(super) fn block_can_place(&self, pos: [i32; 3], slot: usize, stack: &ItemStack) -> bool {
@@ -891,7 +847,7 @@ impl Game<'_> {
             return self.composter_container_insert([x, y, z], stack, face == Some(Direction::Up));
         }
         let mut rest = Some(stack);
-        for slot in view.slots_to_add_iter(face) {
+        for slot in view.slots_to_add(face) {
             let Some(stack) = rest.take() else { break };
             rest = self.try_move_in_item(from_hopper, view, stack, slot, face);
         }
@@ -924,31 +880,32 @@ impl Game<'_> {
     /// is still a hopper (`BlockEntityType.isValid`).
     pub(super) fn tick_hopper(&mut self, pos: Pos) {
         let time = self.world.game_time;
-        // Every hopper keeps its cooldown and the tick it last ticked
-        // (`HopperBlockEntity.tickedGameTime`), idle ones too: a hopper that
-        // receives an item reads it for its cooldown (8, or 7 once it ticked).
-        let state = self.hoppers.entry(pos).or_default();
-        state.cooldown = state.cooldown.wrapping_sub(1);
-        state.ticked = time;
-        if state.cooldown > 0 {
+        let waiting = {
+            let state = self.hoppers.entry(pos).or_default();
+            state.cooldown = state.cooldown.wrapping_sub(1);
+            state.ticked = time;
+            state.cooldown > 0
+        };
+        if waiting {
             return;
         }
-        state.cooldown = 0;
         // Most ticks only advance the cooldown: the block is checked when the
         // hopper is about to move, not on every tick it waits.
-        let state = self.world.block(pos.0, pos.1, pos.2);
-        let Some(info) = self.pack.assets.registry.state(state) else {
-            self.hoppers.remove(&pos);
-            return;
-        };
-        if info.name != "minecraft:hopper" {
+        let hopper = self
+            .res
+            .facts()
+            .get(self.world.block(pos.0, pos.1, pos.2))
+            .name
+            .as_ref()
+            == "minecraft:hopper";
+        if !hopper {
             self.hoppers.remove(&pos);
             return;
         }
-        if info.properties.get("enabled").is_some_and(|v| v == "false") {
-            return;
+        if let Some(state) = self.hoppers.get_mut(&pos) {
+            state.cooldown = 0;
         }
-        self.hopper_try_move_items_with_state(pos, state);
+        self.hopper_try_move_items(pos);
     }
     /// Drops the cooldowns of hoppers whose block entity is gone.
     pub(super) fn forget_gone_hoppers(&mut self) {
@@ -960,69 +917,23 @@ impl Game<'_> {
     /// `HopperBlockEntity.tryMoveItems` with `suckInItems`.
     pub(super) fn hopper_try_move_items(&mut self, pos: Pos) {
         let state = self.world.block(pos.0, pos.1, pos.2);
-        self.hopper_try_move_items_with_state(pos, state);
-    }
-    fn hopper_try_move_items_with_state(&mut self, pos: Pos, state: BlockStateId) {
-        let Some(info) = self.pack.assets.registry.state(state) else {
+        let c = self.containers();
+        let enabled = c.prop(state, "enabled") != Some("false");
+        let Some(view) = c.view(pos, false) else {
             return;
         };
-        if info.properties.get("enabled").is_some_and(|v| v == "false") {
+        if self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0) || !enabled {
             return;
         }
-        if self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0) {
-            return;
-        }
-        let Some(BlockEntity::Chest(items)) = self.world.block_entities.get(&pos) else {
-            return;
-        };
-        if items.len() != HOPPER_SLOTS {
-            return;
-        }
-        let is_empty = items
-            .iter()
-            .all(|s| s.as_ref().is_none_or(|s| s.count == 0));
-        let has_empty_slot = items
-            .iter()
-            .any(|s| s.as_ref().is_none_or(|s| s.count == 0));
-
-        let above = (pos.0, pos.1 + 1, pos.2);
-        // Fast path for empty hopper with no source container and no item entities:
-        // if empty, cannot eject; if no container above, cannot suck container;
-        // if no dropped items nearby, cannot suck entities -> nothing can happen!
-        if is_empty
-            && self.world.block_entities.get(&above).is_none()
-            && self.carts.is_empty()
-            && self.boats.is_empty()
-            && (self.dropped.is_empty()
-                || self
-                    .item_columns
-                    .as_mut()
-                    .is_some_and(|c| !c.may_reach(&self.dropped, pos.0, pos.2)))
-            && self
-                .pack
-                .assets
-                .registry
-                .state(self.world.block(above.0, above.1, above.2))
-                .is_none_or(|s| s.name != "minecraft:composter")
-        {
-            return;
-        }
-
         self.native_prepare_hopper_transfer([pos.0, pos.1, pos.2]);
-        let view = View {
-            parts: vec![(pos, HOPPER_SLOTS)],
-            kind: Kind::Hopper,
-            container: None,
-        };
         let mut changed = false;
-        if !is_empty {
-            changed = self.hopper_eject_with_state(pos, state, &view);
+        if !c.is_empty(&view) {
+            changed = self.hopper_eject(pos, &view);
         }
-        let is_full = !changed && !has_empty_slot && {
-            let c = self.containers();
-            (0..HOPPER_SLOTS).all(|i| c.get(&view, i).is_some_and(|s| s.count >= c.max_stack(s)))
-        };
-        if !is_full {
+        let c = self.containers();
+        let full =
+            (0..view.len()).all(|i| c.get(&view, i).is_some_and(|s| s.count == c.max_stack(s)));
+        if !full {
             changed |= self.hopper_suck(pos, &view);
         }
         if changed {
@@ -1084,20 +995,19 @@ impl Game<'_> {
     /// `tryMoveItems(…, () -> addItem(hopper, itemEntity))`; true when the
     /// item entity was taken whole.
     fn hopper_take_item(&mut self, pos: Pos, i: usize) -> bool {
-        if self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0) {
-            return false;
-        }
         let state = self.world.block(pos.0, pos.1, pos.2);
         let c = self.containers();
-        if c.prop(state, "enabled") == Some("false") {
-            return false;
-        }
         let Some(view) = c.view(pos, false) else {
             return false;
         };
+        if c.prop(state, "enabled") == Some("false")
+            || self.hoppers.get(&pos).is_some_and(|h| h.cooldown > 0)
+        {
+            return false;
+        }
         let mut changed = false;
         if !c.is_empty(&view) {
-            changed = self.hopper_eject_with_state(pos, state, &view);
+            changed = self.hopper_eject(pos, &view);
         }
         let c = self.containers();
         let full =
@@ -1133,7 +1043,8 @@ impl Game<'_> {
     }
     /// `HopperBlockEntity.ejectItems`: into the block container in front, else
     /// a container entity there (`getContainerAt`).
-    fn hopper_eject_with_state(&mut self, pos: Pos, state: BlockStateId, hopper: &View) -> bool {
+    fn hopper_eject(&mut self, pos: Pos, hopper: &View) -> bool {
+        let state = self.world.block(pos.0, pos.1, pos.2);
         let c = self.containers();
         let Some(facing) = c.prop(state, "facing").and_then(dir_from_name) else {
             return false;
@@ -1245,9 +1156,6 @@ impl Game<'_> {
         if blocked {
             return false;
         }
-        if self.dropped.is_empty() {
-            return false;
-        }
         // Hopper.SUCK_AABB: the hopper bowl and the block above.
         let (min, max) = (
             [
@@ -1306,7 +1214,7 @@ impl Game<'_> {
             // second setChanged after the move or, when the hopper has no
             // room, the setItem putting the bone meal back into the detached
             // container (whose bone meal is lost with it).
-            let bone_meal = bone_meal_stack().clone();
+            let bone_meal = c.bone_meal.clone();
             if !horizon_client::mod_api::mods().is_empty() {
                 let mut cancel = false;
                 self.native_inventory_move_item(
@@ -1336,15 +1244,13 @@ impl Game<'_> {
         source: &View,
         hopper: &View,
     ) -> bool {
-        for slot in source.slots_for_face_iter(Some(Direction::Down)) {
-            {
-                let c = self.containers();
-                let Some(stack) = c.get(source, slot) else {
-                    continue;
-                };
-                if !c.can_take(source, slot, stack, Direction::Down) {
-                    continue;
-                }
+        for slot in source.slots_for_face(Some(Direction::Down)) {
+            let c = self.containers();
+            let Some(stack) = c.get(source, slot) else {
+                continue;
+            };
+            if !c.can_take(source, slot, stack, Direction::Down) {
+                continue;
             }
             if self.hopper_move_canceled(source, slot, source, hopper) {
                 continue;
@@ -1363,9 +1269,7 @@ impl Game<'_> {
                     }
                     return true;
                 }
-                Some(rest) => {
-                    self.put_back(source, slot, rest);
-                }
+                Some(rest) => self.put_back(source, slot, rest),
             }
         }
         false
@@ -1375,9 +1279,6 @@ impl Game<'_> {
     /// minecarts, chest boats) whose box meets the 1x1x1 box around `at`,
     /// picked at random.
     fn entity_container_at(&mut self, at: [f64; 3]) -> Option<u32> {
-        if self.carts.is_empty() && self.boats.is_empty() {
-            return None;
-        }
         let meets = |b: horizon_core::geometry::Aabb| {
             let (lo, hi) = (b.min_position(), b.max_position());
             lo.x < at[0] + 0.5

crates/horizon-client/src/game/menu_clicks.rs

@@ -899,32 +899,4 @@ impl Game<'_> {
             f.input_clicked(world_recipes!(self), before);
         }
     }
-
-    /// `AbstractContainerScreen` keeps `isQuickCrafting` and the drag it
-    /// belongs to on the screen. Horizon keeps both on `Game` (`inv_clicks`,
-    /// `inv_drag`, `last_inv_click`), so they are dropped when the pointer
-    /// changes hands: a screen that opens or closes starts with its own
-    /// state, and a press whose release never reached the screen -- the
-    /// pointer left the window, or the screen closed first -- would
-    /// otherwise leave every later press on every later screen swallowed.
-    pub(super) fn reset_inventory_clicks(&mut self) {
-        self.inv_clicks.cancel_drag();
-        self.inv_drag = None;
-        self.last_inv_click = None;
-    }
-
-    /// A sound a menu click made the player play (a bundle's insert or
-    /// remove): `Entity.playSound` at the player.
-    pub(super) fn player_menu_sound(&mut self, sound: &str) {
-        let Some(p) = self.player.as_ref() else {
-            return;
-        };
-        let at = [p.position.x, p.position.y, p.position.z];
-        let (volume, pitch) = if sound == horizon_client::bundle::INSERT_FAIL {
-            (1.0, 1.0)
-        } else {
-            (0.8, 0.8 + self.world.random.next_float() * 0.4)
-        };
-        self.audio.play(sound, Some(at), volume, pitch);
-    }
 }

crates/horizon-client/src/game/minecarts.rs

@@ -28,10 +28,6 @@ use horizon_core::{
 };
 use horizon_world::registry::BlockStateId;
 use std::{collections::HashMap, sync::Arc};
-mod index;
-mod nbt;
-pub(super) use index::CartIndex;
-use index::cart_at;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(super) enum CartKind {
@@ -191,6 +187,102 @@ pub(super) const TNT_PRIME_EVENT: i8 = 70;
 mod display;
 use display::{cart_render_bounds, display_offset, shown_unless_air};
 pub(super) use display::{default_display_offset, forget_unreadable_display};
+/// The carts' and mobs' boxes for one tick's cart pushes (`push_from_cart`,
+/// `pickup_from_cart`), so a cart reads its neighbours instead of every cart and
+/// every mob of the level. Both answer in slot order, as the scans did.
+///
+/// The cart grid follows each ticked cart ([`CartIndex::moved`]); it is
+/// rebuilt once the list's length changed (a cart gone or added), and dropped
+/// after a command, which can move or replace any cart
+/// ([`CartIndex::forget_carts`]). The mob grid holds until the mob
+/// list's next write ([`ListStamp`]). A native mod's hook can move either kind
+/// unseen, so with mods loaded both scans stay.
+#[derive(Default)]
+pub(super) struct CartIndex {
+    carts: Option<(SeenGrid, Vec<u32>)>,
+    /// The grid, and the carts a mob rides.
+    mobs: Option<(ListStamp, SeenGrid, FxHashSet<u32>)>,
+    near: Vec<u32>,
+}
+impl CartIndex {
+    fn usable() -> bool {
+        horizon_client::mod_api::mods().is_empty()
+    }
+    /// The cart in slot `i` has these bounds now.
+    fn moved(&mut self, i: usize, bounds: Aabb) {
+        if let Some((grid, ids)) = &mut self.carts
+            && i < ids.len()
+        {
+            grid.update(i, bounds);
+        }
+    }
+    fn forget_carts(&mut self) {
+        self.carts = None;
+    }
+    /// The slots of the carts whose box may meet `area`, for the cart in slot
+    /// `i` (just moved); false: scan them all.
+    fn carts_near(&mut self, carts: &[Minecart], i: usize, area: Aabb, out: &mut Vec<u32>) -> bool {
+        if !Self::usable() {
+            return false;
+        }
+        let fresh = |ids: &[u32]| ids.len() == carts.len() && ids[i] == carts[i].id;
+        if !self.carts.as_ref().is_some_and(|(_, ids)| fresh(ids)) {
+            self.carts = Some((
+                SeenGrid::new(carts.iter().map(Minecart::bounds)),
+                carts.iter().map(|c| c.id).collect(),
+            ));
+        }
+        let Some((grid, ids)) = &mut self.carts else {
+            return false;
+        };
+        grid.update(i, carts[i].bounds());
+        if !grid.candidates(area, out) {
+            return false;
+        }
+        if out.iter().any(|&j| ids[j as usize] != carts[j as usize].id) {
+            // A cart was replaced in place: start over next time.
+            self.carts = None;
+            return false;
+        }
+        true
+    }
+    /// The slots of the mobs whose box may meet `area` into `out`, and
+    /// whether a mob rides cart `cart`; None: scan them all.
+    fn mobs_near(
+        &mut self,
+        mobs: &JoinList<Mob>,
+        cart: u32,
+        area: Aabb,
+        out: &mut Vec<u32>,
+    ) -> Option<bool> {
+        if !Self::usable() {
+            return None;
+        }
+        if !self
+            .mobs
+            .as_ref()
+            .is_some_and(|(stamp, ..)| *stamp == mobs.stamp())
+        {
+            self.mobs = Some((
+                mobs.stamp(),
+                SeenGrid::new(mobs.iter().map(Mob::bounds)),
+                mobs.iter().filter_map(|m| m.extra.mount).collect(),
+            ));
+        }
+        let (_, grid, mounted) = self.mobs.as_ref()?;
+        grid.candidates(area, out).then(|| mounted.contains(&cart))
+    }
+}
+/// Where the cart `id` is in `carts`: at `hint` (where it was a moment ago,
+/// the usual case while carts tick in order) or found by a scan. A world
+/// with hundreds of mineshaft chest carts asked this of every cart several
+/// times a tick.
+fn cart_at(carts: &[Minecart], id: u32, hint: usize) -> Option<usize> {
+    if carts.get(hint).is_some_and(|c| c.id == id) {
+        return Some(hint);
+    }
+    carts.iter().position(|c| c.id == id)
+}
 /// `AbstractMinecart.push(entity)` for a non-cart `entity` at `feet`:
 /// the push the cart loses (the entity gets a quarter of it back).
 pub(super) fn cart_push_from(feet: Vec3, cart: Vec3) -> Option<(f64, f64)> {
@@ -2892,6 +2984,177 @@ impl Game<'_> {
             .render_state(&scene, state.0, m, light, out);
     }
 }
+/// Saving and loading.
+impl Minecart {
+    pub fn to_nbt(
+        &self,
+        uuid: [i32; 4],
+        raw: Option<&horizon_world::nbt::Tag>,
+    ) -> horizon_world::nbt::Tag {
+        use horizon_world::nbt::{JavaString, Tag};
+        let mut tag = horizon_client::entity_nbt::vehicle_to_nbt(
+            self.kind.id(),
+            self.position,
+            self.velocity,
+            [self.yaw, self.pitch],
+            (self.on_ground, self.fall_distance),
+            uuid,
+            raw,
+        );
+        horizon_client::entity_nbt::write_saved_flags(&mut tag, self.on_ground, self.no_gravity);
+        if let Tag::Compound(map) = &mut tag {
+            // ContainerEntity.addChestVehicleSaveData belongs only to the
+            // container subclasses, never to a plain or specialized cart.
+            if self.kind.slots() == 0 {
+                map.remove(&JavaString::from("Items"));
+            }
+            if self.kind == CartKind::CommandBlock {
+                for key in ["LastOutput", "LastExecution"] {
+                    map.remove(&JavaString::from(key));
+                }
+            }
+            map.remove(&JavaString::from("DisplayOffset"));
+            map.remove(&JavaString::from("DisplayState"));
+            let mut put = |k: &str, v: Tag| {
+                map.insert(JavaString::from(k), v);
+            };
+            put("FlippedRotation", Tag::Byte(i8::from(self.flipped)));
+            // AbstractMinecart saves firstTick as HasTicked. A cart never burns:
+            // Entity.move sets -getFireImmuneTicks(), 0 for all but players.
+            put("HasTicked", Tag::Byte(i8::from(self.first_tick)));
+            put("Fire", Tag::Short(0));
+            // addAdditionalSaveData: the offset only off its default, the state only when set.
+            if let Some(offset) = self.custom_offset
+                && f64::from(offset) != default_display_offset(self.kind)
+            {
+                put("DisplayOffset", Tag::Int(offset));
+            }
+            if let Some(state) = &self.custom_display {
+                put("DisplayState", state.clone());
+            }
+            match self.kind {
+                CartKind::Chest | CartKind::Hopper => {
+                    put("Items", horizon_client::save::encode_items(&self.items));
+                    if self.kind == CartKind::Hopper {
+                        put("Enabled", Tag::Byte(i8::from(self.enabled)));
+                    }
+                }
+                CartKind::Furnace => {
+                    put("PushX", Tag::Double(self.push.x.to_bits()));
+                    put("PushZ", Tag::Double(self.push.z.to_bits()));
+                    put("Fuel", Tag::Short(self.fuel as i16));
+                }
+                CartKind::Tnt => put("fuse", Tag::Int(self.fuse)),
+                // BaseCommandBlock.save (its CustomName shares the entity's key).
+                CartKind::CommandBlock => {
+                    for (key, value) in self.command.save() {
+                        if !matches!(key, "CustomName" | "powered" | "conditionMet" | "auto") {
+                            put(key, value);
+                        }
+                    }
+                }
+                // BaseSpawner.save: the delays, ranges, SpawnData and SpawnPotentials.
+                CartKind::Spawner => {
+                    if let Some(spawner) = &self.spawner {
+                        for (key, value) in
+                            horizon_client::mobs::spawner::SpawnerExt::save(&**spawner)
+                        {
+                            put(key, value);
+                        }
+                    }
+                }
+                CartKind::Rideable => {}
+            }
+            // A loaded loot table goes back while the items are still its roll;
+            // otherwise the items replace it, as vanilla's unpackLootTable does.
+            if self.loot.as_ref().is_some_and(|l| l.restore(map)) {
+                if let Some(table) = horizon_client::save::text(map.get(&"LootTable".into()))
+                    .and_then(|id| horizon_client_core::identifier::normalize_id(&id))
+                {
+                    map.insert("LootTable".into(), Tag::String(table.as_str().into()));
+                }
+            } else {
+                map.remove(&JavaString::from("LootTable"));
+                map.remove(&JavaString::from("LootTableSeed"));
+            }
+        }
+        tag
+    }
+    pub fn from_nbt(tag: &horizon_world::nbt::Tag, id: u32, kind: CartKind) -> Option<Self> {
+        let (position, _, _) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
+        let mut c = Self::new(id, kind, position);
+        c.load(tag)?;
+        Some(c)
+    }
+    /// `Entity.load` on this cart: the saved fields are read over the live
+    /// ones, the rest (riders, lerp, hurt state) stays; its kind never changes.
+    /// `None`, with nothing changed, when the compound has no position.
+    pub fn load(&mut self, tag: &horizon_world::nbt::Tag) -> Option<()> {
+        use horizon_world::nbt::Tag;
+        let (position, velocity, yaw) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
+        let kind = self.kind;
+        let c = self;
+        c.position = position;
+        c.previous = position;
+        c.velocity = velocity;
+        c.yaw = yaw;
+        c.previous_yaw = yaw;
+        c.no_gravity = horizon_client::entity_nbt::flag(tag, "NoGravity");
+        c.on_ground = horizon_client::entity_nbt::flag(tag, "OnGround");
+        c.pitch = horizon_client::entity_nbt::rotation(tag)[1];
+        c.previous_pitch = c.pitch;
+        // ValueInput's numeric getters take any NumericTag: getIntOr is its
+        // intValue, getShortOr the low 16 bits of it, getBooleanOr
+        // `byteValue() != 0` (the low 8), getDoubleOr its doubleValue.
+        let int = |k: &str| {
+            tag.get(k)
+                .and_then(horizon_client_core::nbt_path::int_value)
+        };
+        let flag = |k: &str, default: bool| int(k).map_or(default, |v| v as i8 != 0);
+        let double = |k: &str| match tag.get(k) {
+            Some(Tag::Byte(v)) => f64::from(*v),
+            Some(Tag::Short(v)) => f64::from(*v),
+            Some(Tag::Int(v)) => f64::from(*v),
+            Some(Tag::Long(v)) => *v as f64,
+            Some(Tag::Float(v)) => f64::from(f32::from_bits(*v)),
+            Some(Tag::Double(v)) => f64::from_bits(*v),
+            _ => 0.0,
+        };
+        // Entity.load: OnGround and fall_distance, as saved.
+        (c.on_ground, c.fall_distance) = horizon_client::entity_nbt::ground_from_nbt(tag);
+        c.flipped = flag("FlippedRotation", false);
+        c.first_tick = flag("HasTicked", false);
+        if kind.slots() > 0 {
+            c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
+        }
+        c.enabled = flag("Enabled", true);
+        c.fuel = int("Fuel").map_or(0, |v| i32::from(v as i16));
+        // readAdditionalSaveData: the saved push has no y.
+        c.push = Vec3::new(double("PushX"), 0.0, double("PushZ"));
+        c.fuse = int("fuse").unwrap_or(-1);
+        // readAdditionalSaveData: DisplayState, DisplayOffset (default offset when absent).
+        c.custom_display = tag.get("DisplayState").cloned();
+        c.custom_offset = int("DisplayOffset");
+        if kind == CartKind::CommandBlock {
+            c.command = horizon_client::command_block::CommandBlock::load(tag);
+            // MinecartCommandBlock.readAdditionalSaveData sets the synched command.
+            // A changed value invokes onSyncedDataUpdated -> setCommand, resetting successes.
+            if c.synced_command != c.command.command {
+                c.synced_command.clone_from(&c.command.command);
+                c.command.set_command(&c.synced_command);
+            }
+            c.synced_output = c.command.last_output_string();
+        }
+        // MinecartSpawner.readAdditionalSaveData: BaseSpawner.load.
+        if kind == CartKind::Spawner {
+            c.spawner = Some(Box::new(horizon_client::mobs::spawner::SpawnerExt::load(
+                tag,
+            )));
+        }
+        Some(())
+    }
+}
+
 /// `VehicleEntity.hurtServer`'s destroy test: a creative player, damage past
 /// 40, or (`MinecartTNT.shouldSourceDestroy`) fire or an explosion hitting a
 /// TNT cart.

crates/horizon-client/src/game/minecarts/index.rs

@@ -1,105 +0,0 @@
-//! The carts' and mobs' boxes for a tick's cart pushes ([`CartIndex`]).
-use super::*;
-
-/// The carts' and mobs' boxes for one tick's cart pushes (`push_from_cart`,
-/// `pickup_from_cart`), so a cart reads its neighbours instead of every cart and
-/// every mob of the level. Both answer in slot order, as the scans did.
-///
-/// The cart grid follows each ticked cart ([`CartIndex::moved`]); it is
-/// rebuilt once the list's length changed (a cart gone or added), and dropped
-/// after a command, which can move or replace any cart
-/// ([`CartIndex::forget_carts`]). The mob grid holds until the mob
-/// list's next write ([`ListStamp`]). A native mod's hook can move either kind
-/// unseen, so with mods loaded both scans stay.
-#[derive(Default)]
-pub(in crate::game) struct CartIndex {
-    pub(super) carts: Option<(SeenGrid, Vec<u32>)>,
-    /// The grid, and the carts a mob rides.
-    pub(super) mobs: Option<(ListStamp, SeenGrid, FxHashSet<u32>)>,
-    pub(super) near: Vec<u32>,
-}
-impl CartIndex {
-    pub(super) fn usable() -> bool {
-        horizon_client::mod_api::mods().is_empty()
-    }
-    /// The cart in slot `i` has these bounds now.
-    pub(super) fn moved(&mut self, i: usize, bounds: Aabb) {
-        if let Some((grid, ids)) = &mut self.carts
-            && i < ids.len()
-        {
-            grid.update(i, bounds);
-        }
-    }
-    pub(super) fn forget_carts(&mut self) {
-        self.carts = None;
-    }
-    /// The slots of the carts whose box may meet `area`, for the cart in slot
-    /// `i` (just moved); false: scan them all.
-    pub(super) fn carts_near(
-        &mut self,
-        carts: &[Minecart],
-        i: usize,
-        area: Aabb,
-        out: &mut Vec<u32>,
-    ) -> bool {
-        if !Self::usable() {
-            return false;
-        }
-        let fresh = |ids: &[u32]| ids.len() == carts.len() && ids[i] == carts[i].id;
-        if !self.carts.as_ref().is_some_and(|(_, ids)| fresh(ids)) {
-            self.carts = Some((
-                SeenGrid::new(carts.iter().map(Minecart::bounds)),
-                carts.iter().map(|c| c.id).collect(),
-            ));
-        }
-        let Some((grid, ids)) = &mut self.carts else {
-            return false;
-        };
-        grid.update(i, carts[i].bounds());
-        if !grid.candidates(area, out) {
-            return false;
-        }
-        if out.iter().any(|&j| ids[j as usize] != carts[j as usize].id) {
-            // A cart was replaced in place: start over next time.
-            self.carts = None;
-            return false;
-        }
-        true
-    }
-    /// The slots of the mobs whose box may meet `area` into `out`, and
-    /// whether a mob rides cart `cart`; None: scan them all.
-    pub(super) fn mobs_near(
-        &mut self,
-        mobs: &JoinList<Mob>,
-        cart: u32,
-        area: Aabb,
-        out: &mut Vec<u32>,
-    ) -> Option<bool> {
-        if !Self::usable() {
-            return None;
-        }
-        if !self
-            .mobs
-            .as_ref()
-            .is_some_and(|(stamp, ..)| *stamp == mobs.stamp())
-        {
-            self.mobs = Some((
-                mobs.stamp(),
-                SeenGrid::new(mobs.iter().map(Mob::bounds)),
-                mobs.iter().filter_map(|m| m.extra.mount).collect(),
-            ));
-        }
-        let (_, grid, mounted) = self.mobs.as_ref()?;
-        grid.candidates(area, out).then(|| mounted.contains(&cart))
-    }
-}
-/// Where the cart `id` is in `carts`: at `hint` (where it was a moment ago,
-/// the usual case while carts tick in order) or found by a scan. A world
-/// with hundreds of mineshaft chest carts asked this of every cart several
-/// times a tick.
-pub(super) fn cart_at(carts: &[Minecart], id: u32, hint: usize) -> Option<usize> {
-    if carts.get(hint).is_some_and(|c| c.id == id) {
-        return Some(hint);
-    }
-    carts.iter().position(|c| c.id == id)
-}

crates/horizon-client/src/game/minecarts/nbt.rs

@@ -1,173 +0,0 @@
-//! Saving and loading a minecart.
-use super::*;
-
-/// Saving and loading.
-impl Minecart {
-    pub fn to_nbt(
-        &self,
-        uuid: [i32; 4],
-        raw: Option<&horizon_world::nbt::Tag>,
-    ) -> horizon_world::nbt::Tag {
-        use horizon_world::nbt::{JavaString, Tag};
-        let mut tag = horizon_client::entity_nbt::vehicle_to_nbt(
-            self.kind.id(),
-            self.position,
-            self.velocity,
-            [self.yaw, self.pitch],
-            (self.on_ground, self.fall_distance),
-            uuid,
-            raw,
-        );
-        horizon_client::entity_nbt::write_saved_flags(&mut tag, self.on_ground, self.no_gravity);
-        if let Tag::Compound(map) = &mut tag {
-            // ContainerEntity.addChestVehicleSaveData belongs only to the
-            // container subclasses, never to a plain or specialized cart.
-            if self.kind.slots() == 0 {
-                map.remove(&JavaString::from("Items"));
-            }
-            if self.kind == CartKind::CommandBlock {
-                for key in ["LastOutput", "LastExecution"] {
-                    map.remove(&JavaString::from(key));
-                }
-            }
-            map.remove(&JavaString::from("DisplayOffset"));
-            map.remove(&JavaString::from("DisplayState"));
-            let mut put = |k: &str, v: Tag| {
-                map.insert(JavaString::from(k), v);
-            };
-            put("FlippedRotation", Tag::Byte(i8::from(self.flipped)));
-            // AbstractMinecart saves firstTick as HasTicked. A cart never burns:
-            // Entity.move sets -getFireImmuneTicks(), 0 for all but players.
-            put("HasTicked", Tag::Byte(i8::from(self.first_tick)));
-            put("Fire", Tag::Short(0));
-            // addAdditionalSaveData: the offset only off its default, the state only when set.
-            if let Some(offset) = self.custom_offset
-                && f64::from(offset) != default_display_offset(self.kind)
-            {
-                put("DisplayOffset", Tag::Int(offset));
-            }
-            if let Some(state) = &self.custom_display {
-                put("DisplayState", state.clone());
-            }
-            match self.kind {
-                CartKind::Chest | CartKind::Hopper => {
-                    put("Items", horizon_client::save::encode_items(&self.items));
-                    if self.kind == CartKind::Hopper {
-                        put("Enabled", Tag::Byte(i8::from(self.enabled)));
-                    }
-                }
-                CartKind::Furnace => {
-                    put("PushX", Tag::Double(self.push.x.to_bits()));
-                    put("PushZ", Tag::Double(self.push.z.to_bits()));
-                    put("Fuel", Tag::Short(self.fuel as i16));
-                }
-                CartKind::Tnt => put("fuse", Tag::Int(self.fuse)),
-                // BaseCommandBlock.save (its CustomName shares the entity's key).
-                CartKind::CommandBlock => {
-                    for (key, value) in self.command.save() {
-                        if !matches!(key, "CustomName" | "powered" | "conditionMet" | "auto") {
-                            put(key, value);
-                        }
-                    }
-                }
-                // BaseSpawner.save: the delays, ranges, SpawnData and SpawnPotentials.
-                CartKind::Spawner => {
-                    if let Some(spawner) = &self.spawner {
-                        for (key, value) in
-                            horizon_client::mobs::spawner::SpawnerExt::save(&**spawner)
-                        {
-                            put(key, value);
-                        }
-                    }
-                }
-                CartKind::Rideable => {}
-            }
-            // A loaded loot table goes back while the items are still its roll;
-            // otherwise the items replace it, as vanilla's unpackLootTable does.
-            if self.loot.as_ref().is_some_and(|l| l.restore(map)) {
-                if let Some(table) = horizon_client::save::text(map.get(&"LootTable".into()))
-                    .and_then(|id| horizon_client_core::identifier::normalize_id(&id))
-                {
-                    map.insert("LootTable".into(), Tag::String(table.as_str().into()));
-                }
-            } else {
-                map.remove(&JavaString::from("LootTable"));
-                map.remove(&JavaString::from("LootTableSeed"));
-            }
-        }
-        tag
-    }
-    pub fn from_nbt(tag: &horizon_world::nbt::Tag, id: u32, kind: CartKind) -> Option<Self> {
-        let (position, _, _) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
-        let mut c = Self::new(id, kind, position);
-        c.load(tag)?;
-        Some(c)
-    }
-    /// `Entity.load` on this cart: the saved fields are read over the live
-    /// ones, the rest (riders, lerp, hurt state) stays; its kind never changes.
-    /// `None`, with nothing changed, when the compound has no position.
-    pub fn load(&mut self, tag: &horizon_world::nbt::Tag) -> Option<()> {
-        use horizon_world::nbt::Tag;
-        let (position, velocity, yaw) = horizon_client::entity_nbt::boat_from_nbt(tag)?;
-        let kind = self.kind;
-        let c = self;
-        c.position = position;
-        c.previous = position;
-        c.velocity = velocity;
-        c.yaw = yaw;
-        c.previous_yaw = yaw;
-        c.no_gravity = horizon_client::entity_nbt::flag(tag, "NoGravity");
-        c.on_ground = horizon_client::entity_nbt::flag(tag, "OnGround");
-        c.pitch = horizon_client::entity_nbt::rotation(tag)[1];
-        c.previous_pitch = c.pitch;
-        // ValueInput's numeric getters take any NumericTag: getIntOr is its
-        // intValue, getShortOr the low 16 bits of it, getBooleanOr
-        // `byteValue() != 0` (the low 8), getDoubleOr its doubleValue.
-        let int = |k: &str| {
-            tag.get(k)
-                .and_then(horizon_client_core::nbt_path::int_value)
-        };
-        let flag = |k: &str, default: bool| int(k).map_or(default, |v| v as i8 != 0);
-        let double = |k: &str| match tag.get(k) {
-            Some(Tag::Byte(v)) => f64::from(*v),
-            Some(Tag::Short(v)) => f64::from(*v),
-            Some(Tag::Int(v)) => f64::from(*v),
-            Some(Tag::Long(v)) => *v as f64,
-            Some(Tag::Float(v)) => f64::from(f32::from_bits(*v)),
-            Some(Tag::Double(v)) => f64::from_bits(*v),
-            _ => 0.0,
-        };
-        // Entity.load: OnGround and fall_distance, as saved.
-        (c.on_ground, c.fall_distance) = horizon_client::entity_nbt::ground_from_nbt(tag);
-        c.flipped = flag("FlippedRotation", false);
-        c.first_tick = flag("HasTicked", false);
-        if kind.slots() > 0 {
-            c.items = horizon_client::save::decode_items(tag.get("Items"), kind.slots());
-        }
-        c.enabled = flag("Enabled", true);
-        c.fuel = int("Fuel").map_or(0, |v| i32::from(v as i16));
-        // readAdditionalSaveData: the saved push has no y.
-        c.push = Vec3::new(double("PushX"), 0.0, double("PushZ"));
-        c.fuse = int("fuse").unwrap_or(-1);
-        // readAdditionalSaveData: DisplayState, DisplayOffset (default offset when absent).
-        c.custom_display = tag.get("DisplayState").cloned();
-        c.custom_offset = int("DisplayOffset");
-        if kind == CartKind::CommandBlock {
-            c.command = horizon_client::command_block::CommandBlock::load(tag);
-            // MinecartCommandBlock.readAdditionalSaveData sets the synched command.
-            // A changed value invokes onSyncedDataUpdated -> setCommand, resetting successes.
-            if c.synced_command != c.command.command {
-                c.synced_command.clone_from(&c.command.command);
-                c.command.set_command(&c.synced_command);
-            }
-            c.synced_output = c.command.last_output_string();
-        }
-        // MinecartSpawner.readAdditionalSaveData: BaseSpawner.load.
-        if kind == CartKind::Spawner {
-            c.spawner = Some(Box::new(horizon_client::mobs::spawner::SpawnerExt::load(
-                tag,
-            )));
-        }
-        Some(())
-    }
-}

crates/horizon-client/src/game/mob_sounds.rs

@@ -61,49 +61,46 @@ impl Game<'_> {
     /// that are gone, and read what the instances follow.
     pub(super) fn start_mob_sounds(&mut self) -> Vec<MobSound> {
         let game_time = self.world.game_time;
-        let mut mobs = Vec::new();
-        let mut bee_indices = Vec::new();
-
-        for m in &self.mobs {
-            if m.removed {
-                continue;
-            }
-            let species = m.species();
-            if !matches!(
-                species,
-                Species::Bee | Species::Guardian | Species::ElderGuardian | Species::Sniffer
-            ) {
-                continue;
-            }
-            let is_bee = species == Species::Bee;
-            let sound = MobSound {
+        let mobs: Vec<MobSound> = self
+            .mobs
+            .iter()
+            .filter(|m| {
+                !m.removed
+                    && matches!(
+                        m.species(),
+                        Species::Bee
+                            | Species::Guardian
+                            | Species::ElderGuardian
+                            | Species::Sniffer
+                    )
+            })
+            .map(|m| MobSound {
                 id: m.id,
                 position: [m.position.x, m.position.y, m.position.z],
                 // Vec3.horizontalDistance.
                 speed: m.velocity.x.hypot(m.velocity.z),
                 baby: m.is_baby(),
                 // NeutralMob.isAngry: the anger end time is ahead.
-                angry: is_bee
+                angry: m.species() == Species::Bee
                     && bee::get(m).is_some_and(|b| b.anger_end > 0 && b.anger_end - game_time > 0),
                 silent: m.silent,
                 attack_scale: guardian::attack_scale(m),
                 // SnifferSoundInstance.tick.
-                sniffer_digging: species == Species::Sniffer
+                sniffer_digging: m.species() == Species::Sniffer
                     && m.ai.target.is_none()
                     && sniffer::can_play_digging_sound(m),
-            };
-            if is_bee {
-                bee_indices.push(mobs.len());
-            }
-            mobs.push(sound);
-        }
+            })
+            .collect();
         self.guardian_sounds
             .retain(|id| mobs.iter().any(|m| m.id == *id));
         self.bee_sounds
             .retain(|id, _| mobs.iter().any(|m| m.id == *id));
-        for &idx in &bee_indices {
-            let sound = &mobs[idx];
-            if self.bee_sounds.get(&sound.id) != Some(&sound.angry) {
+        for sound in &mobs {
+            let is_bee = self
+                .mobs
+                .iter()
+                .any(|m| m.id == sound.id && m.species() == Species::Bee);
+            if is_bee && self.bee_sounds.get(&sound.id) != Some(&sound.angry) {
                 self.bee_sounds.insert(sound.id, sound.angry);
                 let instance = SoundInstance::bee(sound, sound.angry, random_source::create());
                 self.audio.play_instance(instance, false);

crates/horizon-client/src/game/names.rs

@@ -300,11 +300,7 @@ impl Game<'_> {
             ) {
                 continue;
             }
-            let marks = if player || self.cosmetics_local() {
-                self.cosmetics_marks(m, Some(m.id) == own)
-            } else {
-                Marks::default()
-            };
+            let marks = self.hooks_name_marks(m, Some(m.id) == own);
             let at = match marks.top {
                 Some(top) => p + glam::DVec3::Y * cosmetic_lift(top, m.model_scale()),
                 None => p,
@@ -770,10 +766,10 @@ impl Game<'_> {
                     if background { BACKGROUND } else { 0 },
                 ),
             };
-            if n == last && marks.horizon {
+            if let Some(mark) = marks.mark.filter(|_| n == last) {
                 let x = -self.gui.atlas.font.width_text(text) / 2.0 - 10.0;
                 // 8 text pixels square, a pixel left of the background.
-                for &(mx, my, w, h, argb) in super::cosmetics::MARK {
+                for &(mx, my, w, h, argb) in mark {
                     let a = text_alpha * (argb >> 24) / 255;
                     batch.fill(
                         &self.gui.atlas,
@@ -937,10 +933,11 @@ struct NameTag {
     marks: Marks,
 }
 
-/// What Horizon draws by a player's name: its mark (they play Horizon) and their name tag style.
+/// What a hook draws by a player's name (`horizon_hooks::players::NameDecoration`): a mark
+/// before it (Horizon's: they play Horizon) and a name tag style.
 #[derive(Clone, Copy, Default)]
 pub(super) struct Marks {
-    pub horizon: bool,
+    pub mark: Option<horizon_hooks::players::Mark>,
     pub style: Option<TagStyle>,
     /// How high the cosmetics drawn on their body get above the neck, in model pixels: the tag
     /// goes up over a tall one (`cosmetic_lift`).

crates/horizon-client/src/game/native_machines.rs

@@ -471,7 +471,6 @@ pub(crate) mod tests {
             dim: game.dim,
             pos: [1, 2, 3],
             yaw: 0.0,
-            pitch: 0.0,
             forced: false,
         };
         let spawn = Vec3::new(1.0, 2.0, 3.0);

crates/horizon-client/src/game/natural_spawning.rs

@@ -46,8 +46,6 @@ pub(super) struct SpawnScratch {
     /// dx/dz order, that no earlier player's square holds.
     segments: Vec<Vec<(i32, i32)>>,
     stale: Vec<bool>,
-    /// Reusable buffer for spawn players across ticks to avoid heap allocation.
-    pub(super) spawn_players: Vec<SpawnPlayer>,
 }
 impl SpawnScratch {
     fn chunk(p: &LevelPlayer) -> (i32, i32) {
@@ -130,20 +128,6 @@ impl SpawnScratch {
         self.prepare(players);
         self.candidates.clear();
         let mut count = 0;
-        if players.len() == 1 {
-            let p = &players[0];
-            count = self.segments.first().map_or(0, |s| s.len());
-            if !p.spectator
-                && let Some(segment) = self.segments.first()
-            {
-                for &c in segment {
-                    if close_enough_for_spawning(p, c) && keep(c) {
-                        self.candidates.push(c);
-                    }
-                }
-            }
-            return count as i32;
-        }
         for (i, segment) in self.segments.iter().enumerate() {
             count += segment.len();
             let near = &self.neighbours[i];
@@ -666,10 +650,8 @@ fn spawn_cost_types(biomes: &horizon_client::biome::Biomes) -> Vec<&str> {
     types
 }
 impl<'a> Game<'a> {
-    pub(super) fn natural_level_with_players(
-        &self,
-        players: Vec<LevelPlayer>,
-    ) -> GameLevel<'_, 'a> {
+    pub(super) fn natural_level(&self) -> GameLevel<'_, 'a> {
+        let players = self.level_players();
         let nearest = players
             .iter()
             .filter(|p| !p.spectator)
@@ -688,9 +670,6 @@ impl<'a> Game<'a> {
             costed: spawn_cost_types(world_biomes!(self)),
         }
     }
-    pub(super) fn natural_level(&self) -> GameLevel<'_, 'a> {
-        self.natural_level_with_players(self.level_players())
-    }
     /// Creates a mob the spawner accepted, finalized the game's way; the
     /// caller adds it with [`Game::add_spawned`].
     fn finalize_spawned(&self, r: &SpawnRequest, pending: &mut Vec<Mob>) -> Option<Spawned> {
@@ -794,8 +773,6 @@ impl<'a> Game<'a> {
         scratch: &mut SpawnScratch,
     ) -> i32 {
         let levels = self.tickets.levels();
-        // Recomputed each pass: a chunk's ticket level and entity loading change without the
-        // players moving or the chunk count changing.
         scratch.collect(players, |(cx, cz)| {
             levels.loaded_ticking(cx, cz) && super::ticking_chunk(&self.world, cx, cz)
         })
@@ -842,28 +819,31 @@ impl<'a> Game<'a> {
         {
             let level = self.natural_level();
             laps.lap("sn_level");
-            let counted = self.mobs.iter().map(|m| Counted {
-                entity: &m.kind.id,
-                category: Category::from_name(&m.kind.category),
-                block: [
-                    m.position.x.floor() as i32,
-                    m.position.y.floor() as i32,
-                    m.position.z.floor() as i32,
-                ],
-                is_mob: true,
-                persistent: m.persistent
-                    || horizon_client::mobs::ai::requires_custom_persistence(m),
-            });
-            scratch.spawn_players.clear();
-            scratch
-                .spawn_players
-                .extend(players.iter().map(|p| SpawnPlayer {
+            let counted: Vec<Counted> = self
+                .mobs
+                .iter()
+                .map(|m| Counted {
+                    entity: &m.kind.id,
+                    category: Category::from_name(&m.kind.category),
+                    block: [
+                        m.position.x.floor() as i32,
+                        m.position.y.floor() as i32,
+                        m.position.z.floor() as i32,
+                    ],
+                    is_mob: true,
+                    persistent: m.persistent
+                        || horizon_client::mobs::ai::requires_custom_persistence(m),
+                })
+                .collect();
+            let players = players
+                .iter()
+                .map(|p| SpawnPlayer {
                     position: [p.position.x, p.position.y, p.position.z],
                     spectator: p.spectator,
-                }));
-            let spawn_players = std::mem::take(&mut scratch.spawn_players);
+                })
+                .collect();
             laps.lap("sn_materialize");
-            let mut state = SpawnState::new(&level, spawnable, spawn_players, counted, |cx, cz| {
+            let mut state = SpawnState::new(&level, spawnable, players, &counted, |cx, cz| {
                 self.world.chunks.contains_key(&(cx, cz))
             });
             laps.lap("sn_state");
@@ -874,8 +854,7 @@ impl<'a> Game<'a> {
                 Vec::new()
             };
             laps.lap("sn_categories");
-            // Util.shuffle, every pass: it draws from the level's random even when no
-            // category may spawn.
+            // Util.shuffle.
             for i in (1..scratch.candidates.len()).rev() {
                 let j = random.next_int_bound(i as i32 + 1).unwrap_or(0) as usize;
                 scratch.candidates.swap(i, j);
@@ -906,7 +885,6 @@ impl<'a> Game<'a> {
                     );
                 }
             }
-            scratch.spawn_players = state.into_players();
         }
         spawn_selection::attempt_counters(true);
         laps.lap("sn_attempts");

crates/horizon-client/src/game/options.rs

@@ -185,7 +185,7 @@ impl Game<'_> {
         let output = self
             .renderer
             .as_ref()
-            .map_or(Default::default(), |r| r.output());
+            .map_or(Default::default(), |r| *r.output());
         ui.draw(&self.settings, output, batch, &self.gui.atlas, self.cursor);
         self.ui.options = ui;
         self.show_calibration((batch.width, batch.height));

crates/horizon-client/src/game/pad.rs

@@ -679,6 +679,26 @@ impl Game<'_> {
         gamepad::move_vector(self.pad.state.left, settings.move_deadzone)
     }
 
+    /// Whether `key` is held, a movement key by the left stick too: as the keys the stick holds
+    /// (`eight_direction_keys`), whatever moves the player. For readers of the keys that aren't
+    /// the movement itself.
+    pub(super) fn movement_key_held(&self, key: KeyCode) -> bool {
+        if self.keys.raw(&key) {
+            return true;
+        }
+        let Some(stick) = self.pad_move() else {
+            return false;
+        };
+        let [forward, backward, left, right] = gamepad::eight_direction_keys(stick);
+        match key {
+            KeyCode::KeyW => forward,
+            KeyCode::KeyS => backward,
+            KeyCode::KeyA => left,
+            KeyCode::KeyD => right,
+            _ => false,
+        }
+    }
+
     /// The right stick turns the view, once per frame (`Entity.turn`).
     pub(super) fn pad_look(&mut self, seconds: f32) {
         let settings = &self.settings.controller;

crates/horizon-client/src/game/perspective.rs

@@ -280,11 +280,11 @@ impl Game<'_> {
     /// front of) it, pulled in where visual shapes are in the way. Returns the
     /// position, yaw and pitch to render from.
     pub(super) fn camera_view(&mut self, partial: f32) -> Option<(glam::DVec3, f32, f32)> {
-        if self.studio.freecam.active {
+        if self.studio_freecam.active {
             return Some((
-                self.studio.freecam.position,
-                self.studio.freecam.yaw,
-                self.studio.freecam.pitch,
+                self.studio_freecam.position,
+                self.studio_freecam.yaw,
+                self.studio_freecam.pitch,
             ));
         }
         // Minecraft.cameraEntity: a server's spectator camera on a mob or
@@ -311,8 +311,8 @@ impl Game<'_> {
             }
         };
         let mut view = self.view;
-        // An emote pulls the camera back from the player's face (`game/cosmetics/emotes.rs`).
-        let pull = self.emote_camera_pull(partial);
+        // A hook may pull the camera back (an emote, from the player's face).
+        let pull = self.hooks_camera_distance(partial);
         let kind = match self.camera_type {
             CameraType::FirstPerson => horizon_client::camera::CameraType::FirstPerson,
             CameraType::ThirdPersonBack => horizon_client::camera::CameraType::ThirdPersonBack,
@@ -643,9 +643,8 @@ impl Game<'_> {
     /// The model's old pitch is the player's `xRotO`, which the turn moves
     /// with `xRot` (`turn_rotation`).
     pub(super) fn turn_player(&mut self, xo: f64, yo: f64) {
-        if self.studio.freecam.active {
-            self.studio
-                .freecam
+        if self.studio_freecam.active {
+            self.studio_freecam
                 .turn((xo * 0.15) as f32, (yo * 0.15) as f32);
             return;
         }
@@ -698,7 +697,7 @@ impl Game<'_> {
     /// `LevelExtractor`'s skip of the camera entity: the player's own body
     /// is drawn unless the camera is in first person, or while it sleeps.
     pub(super) fn own_body_in_view(&self) -> bool {
-        !self.camera_type.first_person() || self.sleeping.is_some() || self.studio.freecam.active
+        !self.camera_type.first_person() || self.sleeping.is_some() || self.studio_freecam.active
     }
     /// Whether the player's own model shows in the world view (its body or,
     /// while invisible, only its armour and held items).
@@ -801,19 +800,8 @@ impl Game<'_> {
                 packed,
                 out,
             );
-            if super::cosmetics::enabled() {
-                let base = horizon_client::mobs::render::base_transform(m, alpha as f32, camera);
-                self.cosmetics_geometry(
-                    m,
-                    true,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    false,
-                    out,
-                );
-            }
+            let world = horizon_hooks::players::Pass::World;
+            self.own_layers_geometry(m, world, camera, alpha as f32, packed, out);
             self.player_elytra_geometry(m, chest, camera, alpha as f32, packed, out);
             self.spin_attack_geometry(m, camera, alpha as f32, packed, out);
             self.shoulder_parrots_geometry(m, camera, alpha as f32, packed, out);
@@ -927,10 +915,8 @@ impl Game<'_> {
             240 | 240 << 8,
             &mut verts,
         );
-        if super::cosmetics::enabled() {
-            let base = horizon_client::mobs::render::base_transform(&m, 1.0, camera);
-            self.cosmetics_geometry(&m, true, base, None, 1.0, 240 | 240 << 8, false, &mut verts);
-        }
+        let picture = horizon_hooks::players::Pass::Picture;
+        self.own_layers_geometry(&m, picture, camera, 1.0, 240 | 240 << 8, &mut verts);
         // `WingsLayer` draws through `RenderTypes.armorCutoutNoCull`: the
         // wings' faces show from both sides (the elytra texture is empty on
         // the face that looks at the body).

crates/horizon-client/src/game/play_input.rs

@@ -101,7 +101,7 @@ impl Game<'_> {
             };
             // A controller's stick click acts as the key without setting the modifier: it is held
             // while the pad holds it (or its release waits for a tick), not when the keyboard says.
-            let pad = self.input_holds(mapping);
+            let pad = self.pad.holds_action(&self.settings.controller, mapping);
             if !held && !pad {
                 self.toggles.0[slot].set_down(false, needs_toggle);
                 self.sync_toggle(slot);
@@ -180,7 +180,7 @@ impl Game<'_> {
         raw: KeyCode,
         source: Source,
     ) -> Result<()> {
-        if self.screen == Screen::Playing && self.studio.replay.is_some() {
+        if self.screen == Screen::Playing && self.studio_replay.is_some() {
             if !pressed {
                 self.keys.release(&key, source);
                 return Ok(());
@@ -191,7 +191,7 @@ impl Game<'_> {
                 }
                 return Ok(());
             }
-            if !studio_freecam_movement_key(key) || !self.studio.freecam.active {
+            if !studio_freecam_movement_key(key) || !self.studio_freecam.active {
                 return Ok(());
             }
         }
@@ -352,7 +352,9 @@ impl Game<'_> {
             _ => return false,
         };
         match source {
-            Source::Keyboard | Source::Agent => self.input_holds(mapping),
+            Source::Keyboard | Source::Agent => {
+                self.pad.holds_action(&self.settings.controller, mapping)
+            }
             Source::Pad => {
                 let keys = &self.settings.keys;
                 self.physical_buttons
@@ -448,79 +450,6 @@ impl Game<'_> {
     }
 }
 
-/// The input source (docs/layers.md, "Controllers, splitscreen, replays and UI pages"): what
-/// gameplay asks of a device beyond the keyboard and mouse, and tells it. Gameplay calls these,
-/// never the controller modules; today `pad` answers.
-impl Game<'_> {
-    /// The analog move vector (`[left, forward]`, -1..1) while a device moves the player.
-    pub(super) fn input_move(&self) -> Option<[f32; 2]> {
-        self.pad_move()
-    }
-
-    /// Whether a device holds the key mapping named `mapping` (`key.use`).
-    pub(super) fn input_holds(&self, mapping: &str) -> bool {
-        self.pad.holds_action(&self.settings.controller, mapping)
-    }
-
-    /// Turns the view by what the devices give this frame (`Entity.turn`).
-    pub(super) fn input_look(&mut self, seconds: f32) {
-        self.pad_look(seconds);
-    }
-
-    /// The keyboard or mouse acted in play (a key or button pressed): it has control again, though
-    /// only moving the mouse takes a pad out of use.
-    pub(super) fn input_keyboard_used(&mut self) {
-        self.pad.keyboard_took_over = true;
-    }
-
-    /// Whether the pointer event being handled is one a device made (a pad's menu cursor
-    /// clicking), not the mouse's.
-    pub(super) fn input_made_pointer_event(&self) -> bool {
-        self.pad.menu.synthetic
-    }
-
-    /// A new player entity took over (spawn, respawn, a server joined, a dimension change).
-    pub(super) fn input_player_replaced(&mut self) {
-        self.pad.player_replaced();
-    }
-
-    /// Whether the drop about to happen is a device's whole-stack drop (it has no Control key to
-    /// hold). Asking answers once.
-    pub(super) fn input_takes_stack_drop(&mut self) -> bool {
-        std::mem::take(&mut self.pad.drop_stack)
-    }
-
-    /// The HUD starts a frame: what a device drew on the last one is gone.
-    pub(super) fn input_hud_begin(&mut self) {
-        self.pad.guide_shown.clear();
-    }
-
-    /// Something happened to the player that a device may let them feel.
-    pub(super) fn input_feedback(&mut self, event: horizon_client::input_source::Feedback) {
-        self.pad_rumble(event.into());
-    }
-
-    /// Whether `key` is held, a movement key by the analog move vector too: as the keys it holds
-    /// (`eight_direction_keys`), whatever moves the player. For readers of the keys that aren't
-    /// the movement itself.
-    pub(super) fn movement_key_held(&self, key: KeyCode) -> bool {
-        if self.keys.raw(&key) {
-            return true;
-        }
-        let Some(stick) = self.input_move() else {
-            return false;
-        };
-        let [forward, backward, left, right] = horizon_client::gamepad::eight_direction_keys(stick);
-        match key {
-            KeyCode::KeyW => forward,
-            KeyCode::KeyS => backward,
-            KeyCode::KeyA => left,
-            KeyCode::KeyD => right,
-            _ => false,
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::{studio_freecam_movement_key, studio_replay_shortcut};

crates/horizon-client/src/game/play_keys.rs

@@ -10,7 +10,7 @@ impl Game<'_> {
     /// the container's hotbar keys are now (`checkHotbarKeyPressed`).
     pub(super) fn key_pressed(&mut self, key: KeyCode, raw: KeyCode) -> Result<()> {
         self.direct_craft_stop();
-        if self.screen == Screen::Playing && self.studio.replay.is_some() {
+        if self.screen == Screen::Playing && self.studio_replay.is_some() {
             match key {
                 KeyCode::Escape => {
                     self.close_studio_replay();
@@ -25,19 +25,19 @@ impl Game<'_> {
                 KeyCode::KeyF => self.handle_studio_timeline_action(
                     horizon_client::studio::TimelineAction::ToggleFreecam,
                 ),
-                KeyCode::KeyT => self.studio.timeline.visible = !self.studio.timeline.visible,
+                KeyCode::KeyT => self.studio_timeline.visible = !self.studio_timeline.visible,
                 KeyCode::KeyM => self.add_studio_marker(),
                 KeyCode::Home => self.handle_studio_topbar_action(
                     horizon_client::studio::TopBarAction::ResetCameraToPlayer,
                 ),
                 KeyCode::KeyL => {
-                    self.studio.freecam.locked_to_path = !self.studio.freecam.locked_to_path;
+                    self.studio_freecam.locked_to_path = !self.studio_freecam.locked_to_path;
                 }
                 KeyCode::KeyK => self.handle_studio_timeline_action(
                     horizon_client::studio::TimelineAction::AddCameraKeyframe,
                 ),
                 KeyCode::Delete => {
-                    if let Some(index) = self.studio.timeline.selected_keyframe {
+                    if let Some(index) = self.studio_timeline.selected_keyframe {
                         self.handle_studio_timeline_action(
                             horizon_client::studio::TimelineAction::RemoveCameraKeyframe(index),
                         );
@@ -78,7 +78,7 @@ impl Game<'_> {
             KeyCode::Escape => match self.screen {
                 Screen::Options => self.options_key(KeyCode::Escape, None)?,
                 Screen::Playing => {
-                    if self.studio.replay.is_some() && self.captured {
+                    if self.studio_replay.is_some() && self.captured {
                         self.capture(false);
                         return Ok(());
                     }
@@ -213,7 +213,7 @@ impl Game<'_> {
             // key.toggleGui is a KeyMapping: it clicks only with no screen open.
             KeyCode::F1 if self.screen == Screen::Playing => self.toggle_hide_gui(),
             KeyCode::F11 => self.toggle_fullscreen(),
-            KeyCode::F5 if self.screen == Screen::Playing && self.studio.replay.is_none() => {
+            KeyCode::F5 if self.screen == Screen::Playing && self.studio_replay.is_none() => {
                 self.cycle_camera()
             }
             KeyCode::KeyE
@@ -279,7 +279,8 @@ impl Game<'_> {
             KeyCode::KeyQ if self.screen == Screen::Playing => {
                 // handleKeybinds: the number keys select before key.drop.
                 self.select_queued_hotbar();
-                let all = drop_whole_stack(self.modifiers) || self.input_takes_stack_drop();
+                let all =
+                    drop_whole_stack(self.modifiers) || std::mem::take(&mut self.pad.drop_stack);
                 self.drop_held(all);
             }
             KeyCode::Digit1

crates/horizon-client/src/game/player_hooks.rs

@@ -0,0 +1,615 @@
+//! Where the game hands the player models to crates above the engine (`horizon_hooks::Hooks`'s
+//! `frame`, `tick`, `name_decoration`, `player_mark`, `camera`; spec #14091): only a window's
+//! game calls them, never the integrated server's thread or a dedicated server. With no hook
+//! registered nothing is built.
+
+use super::Game;
+use horizon_client::fast_hash::FxHashMap;
+use horizon_client::join_seq::JoinList;
+use horizon_client::mesher::Vertex;
+use horizon_client::mobs::anim::{self, BodyPose, PooledPoses, Poses};
+use horizon_client::mobs::{Mob, Part, Polygon, render};
+use horizon_hooks::engine;
+use horizon_hooks::players::{
+    Bone, CameraView, Frame, Gear, Kind, Light, Look, Mesh, Motion, PartPoses, Particle, Pass,
+    PlayerDraw, PlayerModel, PlayerModels, SpriteStore, Sprites, View,
+};
+use std::sync::Arc;
+
+/// Registers the hooks of the Horizon parts still in this crate (cosmetics: spec #14091 step 5
+/// moves them out). Before the hooks are sealed.
+pub(crate) fn register() {
+    if super::cosmetics::enabled()
+        && let Err(e) = horizon_hooks::register(&super::cosmetics::HOOKS)
+    {
+        log::error!("Cosmetics: their hooks came too late: {e}");
+    }
+}
+
+/// The models of the world a window shows: its own first, then the other players and mannequins.
+struct Models<'a> {
+    own: Option<&'a mut Mob>,
+    mobs: &'a mut JoinList<Mob>,
+    remote: &'a super::remote::Remote,
+}
+
+impl Models<'_> {
+    fn find(&mut self, id: u32) -> Option<&mut Mob> {
+        match self.own.as_deref_mut() {
+            Some(m) if m.id == id => Some(m),
+            _ => self
+                .mobs
+                .iter_mut()
+                .find(|m| m.id == id && kind(m).is_some()),
+        }
+    }
+}
+
+/// What kind of player model `m` is, if it is one (the window's own model aside).
+fn kind(m: &Mob) -> Option<Kind> {
+    match &*m.kind.id {
+        "minecraft:player" => Some(Kind::Player),
+        "minecraft:mannequin" => Some(Kind::Mannequin),
+        _ => None,
+    }
+}
+
+/// What `m` wears where a crate may draw: a helmet or head item, a chestplate, a cape or elytra.
+pub(super) fn gear(m: &Mob) -> Gear {
+    let elytra = m.extra.chest.as_deref() == Some("minecraft:elytra");
+    Gear::new(
+        m.extra.head.is_some(),
+        m.extra.chest.is_some() && !elytra,
+        m.cape.is_some() || elytra,
+    )
+}
+
+fn model(m: &Mob, kind: Kind, uuid: Option<u128>) -> PlayerModel {
+    let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
+    PlayerModel::new(m.id, kind, uuid, m.age, dx * dx + dz * dz > 1e-4)
+        .looks(gear(m), horizon_client::mobs::trader::is_invisible(m))
+}
+
+impl PlayerModels for Models<'_> {
+    fn connection(&self) -> u64 {
+        self.remote.session.serial()
+    }
+
+    fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
+        if let Some(m) = self.own.as_deref() {
+            f(model(m, Kind::Own, Some(self.remote.profile())));
+        }
+        for m in self.mobs.iter() {
+            if let Some(kind) = kind(m) {
+                let uuid = (kind == Kind::Player)
+                    .then(|| self.remote.player_uuid(m.id))
+                    .flatten();
+                f(model(m, kind, uuid));
+            }
+        }
+    }
+
+    fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>> {
+        match self.own.as_deref() {
+            Some(m) if m.id == id => m.emote.as_ref(),
+            _ => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && kind(m).is_some())?
+                .emote
+                .as_ref(),
+        }
+    }
+
+    fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>) {
+        if let Some(m) = self.find(id) {
+            m.emote = pose;
+        }
+    }
+}
+
+/// Sprite `id`'s place in the atlas's names (`hooks/<hex>`), written into `buf`: no allocation.
+fn location(id: u64, buf: &mut [u8; 22]) -> &str {
+    use std::io::Write;
+    let mut out = std::io::Cursor::new(&mut buf[..]);
+    let _ = write!(out, "hooks/{id:x}");
+    let len = out.position() as usize;
+    std::str::from_utf8(&buf[..len]).unwrap_or_default()
+}
+
+/// The crates' sprites in the GUI atlas, in the skin slots: read while drawing.
+struct HookSprites<'a, 'g>(&'a Game<'g>);
+
+impl Sprites for HookSprites<'_, '_> {
+    fn get(&self, id: u64) -> Option<[f32; 4]> {
+        let mut buf = [0; 22];
+        let at = location(id, &mut buf);
+        let r = self.0.gui.atlas.sprites.get(at)?;
+        // Kept this frame (`skin_slots.next_frame`).
+        self.0.skin_downloads.borrow_mut().drawn(at);
+        Some([r.u0, r.v0, r.u1, r.v1])
+    }
+}
+
+/// Where a crate's frame hook puts its sprites.
+struct HookStore<'a, 'g>(&'a mut Game<'g>);
+
+impl SpriteStore for HookStore<'_, '_> {
+    fn has(&self, id: u64) -> bool {
+        self.0
+            .gui
+            .atlas
+            .sprites
+            .contains_key(location(id, &mut [0; 22]))
+    }
+
+    fn put(&mut self, id: u64, rgba: Vec<u8>) {
+        let at = location(id, &mut [0; 22]).to_owned();
+        self.0.store_skin(at, rgba);
+    }
+}
+
+thread_local! {
+    /// The crates' meshes as the renderer takes them, by the mesh's address (each entry holds its
+    /// mesh, so the address isn't reused); render thread only.
+    static MESHES: std::cell::RefCell<FxHashMap<usize, (Arc<Mesh>, Arc<Part>)>> =
+        Default::default();
+}
+
+/// The game's model of `mesh`, made once.
+fn part_of(mesh: &Arc<Mesh>) -> Arc<Part> {
+    fn part(m: &Mesh) -> Part {
+        Part {
+            name: m.name.clone(),
+            pose: m.pose,
+            polygons: m
+                .quads
+                .iter()
+                .map(|q| Polygon {
+                    normal: q.normal,
+                    vertices: q.vertices,
+                    cull_back: false,
+                })
+                .collect(),
+            children: m.children.iter().map(part).collect(),
+        }
+    }
+    MESHES.with_borrow_mut(|meshes| {
+        let (_, part_of) = meshes
+            .entry(Arc::as_ptr(mesh) as usize)
+            .or_insert_with(|| (mesh.clone(), Arc::new(part(mesh))));
+        part_of.clone()
+    })
+}
+
+/// Full light, packed as the vertices carry it.
+const FULL: u32 = 240 | 240 << 8;
+
+thread_local! {
+    /// What crates draw see-through this frame, added after every player.
+    static SEE_THROUGH: std::cell::RefCell<Vec<Vertex>> = const { std::cell::RefCell::new(Vec::new()) };
+}
+
+/// Forgets the meshes no crate holds any more (once a frame).
+fn forget_meshes() {
+    let _ = MESHES.try_with(|m| {
+        m.borrow_mut()
+            .retain(|_, (mesh, _)| Arc::strong_count(mesh) > 1)
+    });
+}
+
+/// `Poses` as a crate poses a mesh's parts.
+struct PosesOf<'a>(&'a mut Poses);
+
+impl PartPoses for PosesOf<'_> {
+    fn pose(&mut self, name: &str) -> &mut [f32; 9] {
+        self.0.get(name)
+    }
+}
+
+/// A player model drawn, as a crate draws on it: posed on the GPU's skin path
+/// when `gpu` (the mob pass's skin frame, begun; the bounds of what went there grow, for
+/// culling), else its vertices go to `out`.
+struct DrawPlayer<'a, 'g> {
+    game: &'a Game<'g>,
+    m: &'a Mob,
+    pass: Pass,
+    /// The model's matrix (`render::base_transform`).
+    base: glam::Mat4,
+    camera: glam::DVec3,
+    alpha: f32,
+    light: u32,
+    gpu: bool,
+    out: &'a mut Vec<Vertex>,
+    bounds: Option<(glam::Vec3, glam::Vec3)>,
+    /// The body as it is drawn, posed on the first `bone`.
+    body: Option<PooledPoses>,
+    poses: PooledPoses,
+}
+
+impl DrawPlayer<'_, '_> {
+    fn body(&self) -> &Part {
+        let (key, _) = render::body(self.m);
+        self.m.kind.layer(&key).unwrap_or(&self.m.kind.model)
+    }
+
+    /// `light` packed; `at`: the place `Light::AtPlace` reads, relative to the camera.
+    fn packed(&self, light: Light, at: glam::Vec3) -> u32 {
+        match light {
+            Light::Full => FULL,
+            Light::AtPlace => {
+                let p = (self.camera + at.as_dvec3()).floor();
+                let l = self.game.world.light(p.x as i32, p.y as i32, p.z as i32);
+                (u32::from(l >> 4) * 16) | ((u32::from(l & 15) * 16) << 8)
+            }
+            _ => self.light,
+        }
+    }
+}
+
+impl PlayerDraw for DrawPlayer<'_, '_> {
+    fn pass(&self) -> Pass {
+        self.pass
+    }
+
+    fn ticks(&self) -> f32 {
+        self.m.age as f32 + self.alpha
+    }
+
+    fn base(&self) -> [[f32; 4]; 4] {
+        self.base.to_cols_array_2d()
+    }
+
+    fn motion(&self) -> Motion {
+        let (m, a) = (self.m, self.alpha);
+        let t = f64::from(a);
+        let (p, n) = (m.previous, m.position);
+        let feet = [
+            p.x + (n.x - p.x) * t,
+            p.y + (n.y - p.y) * t,
+            p.z + (n.z - p.z) * t,
+        ];
+        let turn = horizon_client::mobs::living::wrap(m.head_yaw - m.previous_head_yaw);
+        let yaw = m.previous_head_yaw + turn * a;
+        let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * a;
+        let asleep = m.extra.avatar_pose == horizon_client::pose::Pose::Sleeping;
+        let swimming = m.extra.swim.amount(a) > 0.0;
+        Motion::new(feet, yaw, pitch).poses(
+            m.extra.crouching,
+            asleep,
+            m.extra.fall_flying,
+            swimming,
+        )
+    }
+
+    fn view(&self) -> View {
+        let q = self.game.camera_orientation();
+        let (right, up) = (
+            (q * glam::Vec3::X).to_array(),
+            (q * glam::Vec3::Y).to_array(),
+        );
+        let (yaw, pitch) = (self.game.yaw.to_radians(), self.game.pitch.to_radians());
+        let forward = [
+            -yaw.sin() * pitch.cos(),
+            -pitch.sin(),
+            yaw.cos() * pitch.cos(),
+        ];
+        let left = [yaw.cos(), 0.0, yaw.sin()];
+        View::new(self.camera.to_array(), right, up).looking(forward, left)
+    }
+
+    fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]> {
+        if self.pass == Pass::FirstPerson {
+            return None;
+        }
+        if self.body.is_none() {
+            let mut poses = Poses::pooled();
+            poses.reset(self.body());
+            let data = self.game.res.mob_data();
+            let state = anim::state(self.m, self.alpha);
+            anim::setup(self.m, &state, &mut poses, &data.animations);
+            self.body = Some(poses);
+        }
+        let poses = self.body.as_ref()?;
+        let at = render::part_matrix(self.body(), self.base, poses, bone.part(), 0.0)?;
+        Some(at.to_cols_array_2d())
+    }
+
+    fn body_pose(&self) -> Option<&Arc<dyn BodyPose>> {
+        self.m.emote.as_ref()
+    }
+
+    fn sprite(&self, id: u64) -> Option<[f32; 4]> {
+        HookSprites(self.game).get(id)
+    }
+
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 4],
+        look: Look,
+        pose: &mut dyn FnMut(&mut dyn PartPoses),
+    ) {
+        let model = part_of(mesh);
+        let matrix = glam::Mat4::from_cols_array_2d(&matrix);
+        let (uv, light) = (look.uv, self.packed(look.light, matrix.w_axis.truncate()));
+        self.poses.reset(&model);
+        pose(&mut PosesOf(&mut self.poses));
+        let poses = &self.poses;
+        if let Some(alpha) = look.see_through {
+            let color = ((alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
+            let pose_of = |p: &Part| poses.pose(p);
+            SEE_THROUGH.with_borrow_mut(|out| {
+                let start = out.len();
+                horizon_client::mobs::render_model(&model, matrix, &pose_of, uv, light, 0, out);
+                for v in &mut out[start..] {
+                    v.color = color;
+                    // Seen through, a face turned away would add to the near one: `entity.wgsl`
+                    // drops back faces, so it is `alpha` at most.
+                    v.normal[3] = horizon_client::mesher::SHADED_CULL_W;
+                }
+            });
+            return;
+        }
+        if self.gpu {
+            let mut models = self.game.skin_models.borrow_mut();
+            let mut frame = self.game.skin_frame.borrow_mut();
+            let mut skin = horizon_client::mobs::skin::Skin::new(&mut models, &mut frame);
+            skin.bounds = self.bounds;
+            let paint = horizon_client::mobs::skin::Paint {
+                uv,
+                scroll: 0.0,
+                color: 0xFFFF_FFFF,
+                light,
+                overlay: 0,
+            };
+            if skin.draw(&model, matrix, poses, paint) {
+                self.bounds = skin.bounds;
+                return;
+            }
+        }
+        let pose_of = |p: &Part| poses.pose(p);
+        horizon_client::mobs::render_model(&model, matrix, &pose_of, uv, light, 0, self.out);
+    }
+
+    fn particles(&mut self, uv: [f32; 4], particles: &[Particle], light: Light) {
+        let light = self.packed(light, glam::Vec3::ZERO);
+        SEE_THROUGH.with_borrow_mut(|out| {
+            for q in particles {
+                let color = ((q.alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
+                for (corner, [u, v]) in q.corners.iter().zip(q.uv) {
+                    out.push(Vertex {
+                        pos: *corner,
+                        uv: [uv[0] + (uv[2] - uv[0]) * u, uv[1] + (uv[3] - uv[1]) * v],
+                        layer: 0,
+                        color,
+                        light,
+                        // Unlit: a particle keeps its colour whichever way it faces.
+                        normal: [0, 0, 0, 0],
+                        glint_uv: [0.0, 0.0],
+                    });
+                }
+            }
+        });
+    }
+}
+
+impl Game<'_> {
+    /// What crates draw on player model `m` in the world pass (`creatures.rs`): see
+    /// [`DrawPlayer`]. The bounds of what went to the GPU.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn player_layers_geometry(
+        &self,
+        m: &Mob,
+        base: glam::Mat4,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        gpu: bool,
+        out: &mut Vec<Vertex>,
+    ) -> Option<(glam::Vec3, glam::Vec3)> {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let kind = kind(m).filter(|_| engine::any())?;
+        let model = model(m, kind, self.remote_player_uuid(m.id));
+        let mut draw = DrawPlayer {
+            game: self,
+            m,
+            pass: Pass::World,
+            base,
+            camera,
+            alpha,
+            light,
+            gpu,
+            out,
+            bounds: None,
+            body: None,
+            poses: Poses::pooled(),
+        };
+        engine::player_layers(&model, &mut draw);
+        draw.bounds
+    }
+
+    /// What crates draw on the window's own model `m` (its vertices to `out`): in the world in
+    /// third person (`Pass::World`), or in the inventory's picture of it (`Pass::Picture`).
+    /// `camera`: the world view's camera, or the picture's.
+    pub(super) fn own_layers_geometry(
+        &self,
+        m: &Mob,
+        pass: Pass,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        out: &mut Vec<Vertex>,
+    ) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        if !engine::any() {
+            return;
+        }
+        let model = model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile()));
+        let mut draw = DrawPlayer {
+            game: self,
+            m,
+            pass,
+            base: render::base_transform(m, alpha, camera),
+            camera,
+            alpha,
+            light,
+            gpu: false,
+            out,
+            bounds: None,
+            body: None,
+            poses: Poses::pooled(),
+        };
+        engine::player_layers(&model, &mut draw);
+    }
+
+    /// After every player (`game.rs`): what crates draw around the window's own model in first
+    /// person, then what was drawn see-through, in one span.
+    pub(super) fn players_after_geometry(
+        &self,
+        camera: glam::DVec3,
+        alpha: f64,
+        out: &mut Vec<Vertex>,
+    ) {
+        if engine::any()
+            && !self.own_body_in_view()
+            && let Some(m) = self.player_model.as_ref()
+        {
+            let own = model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile()));
+            let own = own.looks(own.gear, own.invisible || self.own_invisible());
+            self.mark_entity(out.len(), "minecraft:player");
+            let mut draw = DrawPlayer {
+                game: self,
+                m,
+                pass: Pass::FirstPerson,
+                base: render::base_transform(m, alpha as f32, camera),
+                camera,
+                alpha: alpha as f32,
+                light: FULL,
+                gpu: false,
+                out: &mut *out,
+                bounds: None,
+                body: None,
+                poses: Poses::pooled(),
+            };
+            engine::first_person(&own, &mut draw);
+        }
+        let _ = SEE_THROUGH.try_with(|v| {
+            let mut v = v.borrow_mut();
+            if !v.is_empty() {
+                self.mark_translucent_entity(out.len(), "minecraft:player");
+                out.extend_from_slice(&v);
+                v.clear();
+            }
+        });
+    }
+
+    /// Once a frame, before drawing.
+    pub(super) fn client_hooks_frame(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let connection = self.remote.as_ref().map_or(0, |r| r.session.serial());
+        let frame = Frame::new(connection, self.integrated.is_some());
+        engine::frame(&frame, &mut HookStore(self));
+        forget_meshes();
+        let _ = SEE_THROUGH.try_with(|v| v.borrow_mut().clear());
+        self.cosmetics_frame();
+    }
+
+    /// Once a client tick in a world: the player's own emote, then the hooks.
+    pub(super) fn client_hooks_tick(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        self.tick_emotes();
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let Some(remote) = self.remote.as_ref() else {
+            return;
+        };
+        engine::tick(&mut Models {
+            own: self.player_model.as_mut(),
+            mobs: &mut self.mobs,
+            remote,
+        });
+    }
+
+    /// What goes by `m`'s name (`own`: the window's own player), from the hooks.
+    pub(super) fn hooks_name_marks(&self, m: &Mob, own: bool) -> super::names::Marks {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let mut marks = super::names::Marks::default();
+        if !engine::any() {
+            return marks;
+        }
+        let model = match (own, kind(m)) {
+            (true, _) => model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile())),
+            (false, Some(kind)) => model(m, kind, self.remote_player_uuid(m.id)),
+            (false, None) => return marks,
+        };
+        if let Some(d) = engine::name_decoration(&model, &HookSprites(self)) {
+            marks.mark = d.mark;
+            marks.top = d.top;
+            marks.style = d.badge.map(|b| {
+                let [u0, v0, u1, v1] = b.uv;
+                super::names::TagStyle {
+                    mark: horizon_client::hud::Rect {
+                        u0,
+                        v0,
+                        u1,
+                        v1,
+                        w: 8,
+                        h: 8,
+                    },
+                    line: b.line,
+                }
+            });
+        }
+        marks
+    }
+
+    /// How far the third-person camera stands back, as a share of the usual distance: a hook's
+    /// (an emote pulls it back), else 1.
+    pub(super) fn hooks_camera_distance(&self, partial: f32) -> f32 {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        match &self.player_model {
+            Some(m) if engine::any() => {
+                engine::camera(&CameraView::new(m.age as f32 + partial)).map_or(1.0, |c| c.distance)
+            }
+            _ => 1.0,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sprite_locations_fit_the_buffer_and_differ_by_id() {
+        let mut a = [0; 22];
+        let mut b = [0; 22];
+        assert_eq!(location(u64::MAX, &mut a), "hooks/ffffffffffffffff");
+        assert_eq!(location(10, &mut b), "hooks/a");
+    }
+}

crates/horizon-client/src/game/player_spawn.rs

@@ -111,7 +111,7 @@ impl Game<'_> {
             self.stop_sounds_for_new_level();
         }
         self.player = Some(player);
-        self.input_player_replaced();
+        self.pad.player_replaced();
         self.sway = Default::default();
         self.apply_equipment();
         self.eye = 1.62;

crates/horizon-client/src/game/pointer_capture.rs

@@ -26,7 +26,7 @@ impl Game<'_> {
         let pointer = self.captured || self.agent_pointer;
         let grabbed = pointer
             && self.screen == Screen::Playing
-            && (self.player.is_some() || self.studio.freecam.active);
+            && (self.player.is_some() || self.studio_freecam.active);
         let active = self.focused || self.agent_pointer;
         if let Some((xo, yo)) = self
             .mouse
@@ -76,8 +76,8 @@ impl Game<'_> {
             && self.control.is_none()
             && self.screen == Screen::Playing
             && !studio_suppresses_focus_pause(
-                self.studio.replay.is_some(),
-                self.studio.freecam.active,
+                self.studio_replay.is_some(),
+                self.studio_freecam.active,
             )
             && self.player.is_some()
             && !self.options.no_pause
@@ -149,7 +149,7 @@ impl Game<'_> {
         self.reset_inventory_clicks();
         if !capture {
             self.stop_mining();
-            self.studio.rmb_down = false;
+            self.studio_rmb_down = false;
         }
         // The real pointer takes over from an agent's.
         self.agent_pointer = false;
@@ -353,9 +353,9 @@ impl Game<'_> {
     /// click. A screen that is open keeps it free, as releasing the pointer
     /// for that screen did: it is the screen, not the focus, that shows it.
     pub(super) fn regrab_on_refocus(&mut self) {
-        if self.studio.replay.is_some() || self.studio.freecam.active {
+        if self.studio_replay.is_some() || self.studio_freecam.active {
             self.regrab_on_refocus = false;
-            self.studio.rmb_down = false;
+            self.studio_rmb_down = false;
             self.capture(false);
             return;
         }

crates/horizon-client/src/game/remote.rs

@@ -2433,7 +2433,7 @@ impl Game<'_> {
     /// view centre, `calculateStorageRange` (the server's radius, at least
     /// two, plus three) chunks each way.
     pub(super) fn remote_chunk_in_range(&self, x: i32, z: i32) -> bool {
-        if self.studio.replay.is_some() {
+        if self.studio_replay.is_some() {
             return true;
         }
         self.remote
@@ -3110,6 +3110,33 @@ impl Game<'_> {
                 index.get(mobs, id as u32).map(mob_tracking_body)
             });
     }
+    fn remove_entity(&mut self, id: i32) {
+        self.detach_remote_tracking_entity(id);
+        self.audio.remove_sound_entity(id as u32);
+        // Entity.setRemoved detaches every passenger, even when no empty
+        // SetPassengers packet preceded the vehicle's removal. Otherwise
+        // mobs and other players keep their passenger pose after it is gone.
+        self.remote_set_passengers(id, &[]);
+        self.mobs.retain(|m| m.id != id as u32);
+        self.orbs.retain(|o| o.id != id as u32);
+        self.dropped.retain(|d| d.id != id as u32);
+        // Before the crystals go: the dragon's beam index follows them.
+        self.remove_remote_dragon(id);
+        self.remove_remote_object(id as u32);
+        self.remove_remote_projectile(id as u32);
+        self.persist.uuids.remove(&(id as u32));
+        if let Some(r) = self.remote.as_mut() {
+            r.glowing.remove(&id);
+            r.entities.remove(&id);
+            r.passenger_vehicles.remove(&(id as u32));
+            r.passenger_vehicles.retain(|_, v| *v != id as u32);
+            r.lerps.remove(&id);
+            r.cart_lerps.remove(&id);
+            r.stepped.remove(&id);
+            r.head_lerps.remove(&id);
+            r.pending_items.remove(&id);
+        }
+    }
     /// Map a menu slot to Horizon's inventory screen slot ids.
     pub(super) fn menu_slot(menu: &str, slot: i32) -> Option<usize> {
         let s = usize::try_from(slot).ok()?;
@@ -3680,7 +3707,7 @@ impl Game<'_> {
                 self.move_remote_interaction(p.id, p.position);
             }
             C::RemoveEntities(p) => {
-                for &id in &p.ids {
+                for id in p.ids {
                     if let Some(r) = self.remote.as_mut() {
                         if let Some(uuid) = r.level_players.remove(&id) {
                             r.attachments.remove(&Holder::Player(uuid));
@@ -3689,8 +3716,8 @@ impl Game<'_> {
                         r.level_player_textures.remove(&id);
                         r.attachments.remove(&Holder::Entity(id as u32));
                     }
+                    self.remove_entity(id);
                 }
-                self.remove_entities(&p.ids);
             }
             C::MoveEntityPos(play::MoveEntityPos(m))
             | C::MoveEntityPosRot(play::MoveEntityPosRot(m))
@@ -6149,7 +6176,7 @@ impl Game<'_> {
                 player.spectator = self.spectator();
                 player.velocity = delta;
                 self.player = Some(player);
-                self.input_player_replaced();
+                self.pad.player_replaced();
                 self.sway = Default::default();
                 self.eye = 1.62;
                 self.previous_eye = 1.62;
@@ -6158,7 +6185,7 @@ impl Game<'_> {
                 self.apply_remote_abilities();
             }
         }
-        if self.studio.replay.is_none() {
+        if self.studio_replay.is_none() {
             self.previous_position = position;
         }
         self.yaw = yaw;
@@ -6414,7 +6441,7 @@ impl Game<'_> {
             }
             return Ok(());
         }
-        let stick = self.input_move();
+        let stick = self.pad_move();
         if self.player.is_none() {
             return Ok(());
         }
@@ -6494,7 +6521,7 @@ impl Game<'_> {
             return Ok(());
         };
         player.fluids.boat = boat;
-        if !riding && self.studio.replay.is_none() {
+        if !riding && self.studio_replay.is_none() {
             self.previous_position = player.position;
         }
         let before = (
@@ -6701,10 +6728,10 @@ impl Game<'_> {
             self.snap_player_model_pitch();
         }
         // The player's own model (third person, the inventory's preview).
-        if self.studio.replay.is_none() {
+        if self.studio_replay.is_none() {
             self.tick_player_model();
         }
-        self.tick_emotes();
+        self.client_hooks_tick();
         if !dead {
             self.remote_tick_using();
         }
@@ -9498,7 +9525,7 @@ impl Game<'_> {
                 KeyCode::KeyQ if !self.spectator() => {
                     // Minecraft.hasControlDown: the physical keys, so a toggled
                     // sprint on Left Control does not make Q drop the stack.
-                    let all = self.has_control_down() || self.input_takes_stack_drop();
+                    let all = self.has_control_down() || std::mem::take(&mut self.pad.drop_stack);
                     self.remote_drop(all);
                 }
                 KeyCode::KeyE
@@ -10501,7 +10528,7 @@ impl Game<'_> {
     /// A connection's screen is over the world: connecting, reconfiguring, or
     /// the level loading screen, a portal's included (`remote_overlay`).
     pub(super) fn remote_screen_up(&self) -> bool {
-        self.studio.replay.is_none()
+        self.studio_replay.is_none()
             && self
                 .remote
                 .as_ref()
@@ -10585,7 +10612,7 @@ impl Game<'_> {
     /// Connected or connecting with no player yet: `ConnectScreen`, then
     /// `LevelLoadingScreen`, over the panorama with its blur.
     pub(super) fn remote_loading(&self) -> bool {
-        if self.studio.replay.is_some() {
+        if self.studio_replay.is_some() {
             return false;
         }
         use horizon_client::level_loading::Reason;
@@ -10687,17 +10714,11 @@ impl Game<'_> {
     /// The profile name of another player the server sent, by entity id.
     /// The UUID of another player's entity in the level.
     pub(super) fn remote_player_uuid(&self, id: u32) -> Option<u128> {
-        let r = self.remote.as_ref()?;
-        let uuid = *r.level_players.get(&(id as i32))?;
-        (uuid != r.profile).then_some(uuid)
+        self.remote.as_ref()?.player_uuid(id)
     }
     pub(super) fn remote_player_name(&self, id: u32) -> Option<&str> {
         let r = self.remote.as_ref()?;
-        let uuid = r.level_players.get(&(id as i32))?;
-        if *uuid == r.profile {
-            return None;
-        }
-        r.level_player_name(id as i32, uuid)
+        r.level_player_name(id as i32, &r.player_uuid(id)?)
     }
     /// Status for `horizon-ctl status`.
     /// The other players' entities in the level and their names (their
@@ -11478,6 +11499,11 @@ impl Remote {
     pub(super) fn profile(&self) -> u128 {
         self.profile
     }
+    /// Another player's profile UUID, by their entity id (None for the local player).
+    pub(super) fn player_uuid(&self, id: u32) -> Option<u128> {
+        let uuid = *self.level_players.get(&(id as i32))?;
+        (uuid != self.profile).then_some(uuid)
+    }
     /// The entity id of a player in the level, by profile UUID.
     pub(super) fn player_entity(&self, uuid: u128) -> Option<u32> {
         self.level_players
@@ -11615,9 +11641,6 @@ fn in_storage_range(view_distance: i32, center: (i32, i32), x: i32, z: i32) -> b
     x.abs_diff(center.0) <= range && z.abs_diff(center.1) <= range
 }
 
-// A packet's removals (`RemoveEntities`), apart: this file may not grow.
-#[path = "remote_removal.rs"]
-mod removal;
 #[cfg(test)]
 mod tests {
     #[test]

crates/horizon-client/src/game/remote_projectiles.rs

@@ -793,17 +793,13 @@ impl Game<'_> {
     }
 
     pub(super) fn remove_remote_projectile(&mut self, id: u32) {
+        self.fangs.list.retain(|f| f.id != id);
         self.tnts.retain(|t| t.id != id);
         self.falling.retain(|f| f.id != id);
-        self.crystals.retain(|c| c.id != id);
-        self.remove_remote_small_projectiles(id);
-    }
-
-    pub(super) fn remove_remote_small_projectiles(&mut self, id: u32) {
-        self.fangs.list.retain(|f| f.id != id);
         self.creatures.projectiles.retain(|p| p.id != id);
         self.tridents.retain(|t| t.id != id);
         self.rockets.retain(|r| r.id != id);
+        self.crystals.retain(|c| c.id != id);
         self.potions.remove_remote_thrown(id);
         self.potions.clouds.retain(|c| c.id != id);
         self.end.remove_remote_eye(id);

crates/horizon-client/src/game/remote_removal.rs

@@ -1,142 +0,0 @@
-//! Removing entities a server dropped (`RemoveEntities`), out of remote.rs,
-//! which may not grow.
-use super::super::Game;
-
-impl Game<'_> {
-    pub(super) fn remove_entity(&mut self, id: i32) {
-        self.remove_entities(&[id]);
-    }
-
-    /// `ClientboundRemoveEntitiesPacket`: a packet's ids go together, the big
-    /// entity lists filtered once (#13007), each id's own cleanup in order.
-    pub(super) fn remove_entities(&mut self, ids: &[i32]) {
-        for &id in ids {
-            self.detach_remote_tracking_entity(id);
-            self.audio.remove_sound_entity(id as u32);
-            // Entity.setRemoved detaches every passenger, even when no empty
-            // SetPassengers packet preceded the vehicle's removal. Otherwise
-            // mobs and other players keep their passenger pose after it is gone.
-            self.remote_set_passengers(id, &[]);
-            // Before the crystals go: the dragon's beam index follows them.
-            self.remove_remote_dragon(id);
-            self.crystals.retain(|c| c.id != id as u32);
-            self.remove_remote_object(id as u32);
-            self.remove_remote_small_projectiles(id as u32);
-            self.persist.uuids.remove(&(id as u32));
-            if let Some(r) = self.remote.as_mut() {
-                r.glowing.remove(&id);
-                r.entities.remove(&id);
-                r.passenger_vehicles.remove(&(id as u32));
-                r.lerps.remove(&id);
-                r.cart_lerps.remove(&id);
-                r.stepped.remove(&id);
-                r.head_lerps.remove(&id);
-                r.pending_items.remove(&id);
-            }
-        }
-        let removed: horizon_client::fast_hash::FxHashSet<u32> = if ids.len() > 1 {
-            ids.iter().map(|&id| id as u32).collect()
-        } else {
-            Default::default()
-        };
-        let keep = |id: u32| {
-            if ids.len() > 1 {
-                !removed.contains(&id)
-            } else {
-                ids.first().is_none_or(|&removed| id != removed as u32)
-            }
-        };
-        self.mobs.retain(|m| keep(m.id));
-        self.orbs.retain(|o| keep(o.id));
-        self.dropped.retain(|d| keep(d.id));
-        self.falling.retain(|f| keep(f.id));
-        self.tnts.retain(|t| keep(t.id));
-        if let Some(r) = self.remote.as_mut() {
-            r.passenger_vehicles.retain(|_, v| keep(*v));
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    #[ignore = "needs prepared resources in HORIZON_TEST_RESOURCES and scratch homes/cwd"]
-    fn remove_entities_filters_mixed_entity_lists() {
-        use crate::game::{
-            Audio, Game, Options, Progress, Settings, execution_role::ExecutionRole, load_resources,
-        };
-        use horizon_protocol::packets::play::{self, Clientbound as C};
-
-        let root = std::path::PathBuf::from(std::env::var_os("HORIZON_TEST_RESOURCES").unwrap());
-        let settings = Settings::default();
-        let loaded = load_resources(
-            root.clone(),
-            None,
-            &root,
-            &settings,
-            std::time::Instant::now(),
-            false,
-            true,
-            &Progress::new(),
-            &mut |_, _| unreachable!(),
-        )
-        .unwrap();
-        let mut options = Options::parse(std::iter::empty()).unwrap().unwrap();
-        options.resources = root.clone();
-        options.execution_role = ExecutionRole::Client;
-        let mut game = Game::new(
-            &loaded.resources,
-            loaded.pack,
-            loaded.gui.unwrap(),
-            options,
-            settings,
-            Audio::silent(&root),
-            None,
-        )
-        .unwrap();
-        let (client, _server) = horizon_protocol::connection::Pipe::pair();
-        game.connect_local(client, "RemovalTest").unwrap();
-        for (id, kind) in [
-            (40, "minecraft:falling_block"),
-            (41, "minecraft:falling_block"),
-            (42, "minecraft:falling_block"),
-            (43, "minecraft:tnt"),
-            (44, "minecraft:tnt"),
-            (45, "minecraft:experience_orb"),
-            (46, "minecraft:experience_orb"),
-            (47, "minecraft:zombie"),
-            (48, "minecraft:zombie"),
-        ] {
-            if matches!(kind, "minecraft:falling_block" | "minecraft:tnt") {
-                assert!(game.spawn_remote_projectile(
-                    id,
-                    kind,
-                    [0.0, 64.0, 0.0],
-                    (0.0, 0.0),
-                    [0.0; 3],
-                    0
-                ));
-            } else {
-                game.spawn_entity(id, kind, [0.0, 64.0, 0.0], [0.0; 3]);
-            }
-        }
-        for id in [49, 50] {
-            game.dropped.push(horizon_client::entities::ItemEntity::new(
-                id,
-                horizon_client::items::ItemStack::new("minecraft:sand", 1),
-                horizon_core::geometry::Vec3::new(0.0, 64.0, 0.0),
-                horizon_core::geometry::Vec3::ZERO,
-                0.0,
-            ));
-        }
-        game.handle_packet(C::RemoveEntities(play::RemoveEntities {
-            ids: vec![40, 42, 43, 45, 47, 49],
-        }))
-        .unwrap();
-        assert_eq!(game.falling.iter().map(|e| e.id).collect::<Vec<_>>(), [41]);
-        assert_eq!(game.tnts.iter().map(|e| e.id).collect::<Vec<_>>(), [44]);
-        assert_eq!(game.orbs.iter().map(|e| e.id).collect::<Vec<_>>(), [46]);
-        assert_eq!(game.mobs.iter().map(|e| e.id).collect::<Vec<_>>(), [48]);
-        assert_eq!(game.dropped.iter().map(|e| e.id).collect::<Vec<_>>(), [50]);
-    }
-}

crates/horizon-client/src/game/render_tick.rs

@@ -168,7 +168,6 @@ impl Game<'_> {
             full_water_vision: self.settings.extras.pvp.tweaks.clear_water,
             night_vision: self.fog_night_vision(),
             environment: self.pack.polytone_colors.env,
-            fluid_fog: self.pack.polytone_colors.fluid_fog,
         };
         let mut fog = horizon_client::fog::setup_fog(tables, &self.fog, &input);
         if !self.settings.horizon.fog {

crates/horizon-client/src/game/resource_tables.rs

@@ -292,8 +292,10 @@ fn pack_particles(
 }
 
 /// The packs' custom colours; their dye and sheep colours go to the draw paths' table.
-fn read_colors(root: &std::path::Path) -> horizon_client::pack_palette::PackColors {
-    let colors = horizon_client::pack_palette::read(root);
-    horizon_client::brewing::set_pack_colors(colors.effects.clone());
+fn read_colors(root: &std::path::Path) -> horizon_client::polytone_colors::PackColors {
+    let colors = horizon_client::polytone_colors::PackColors::read(root);
+    horizon_client::pack_palette::set(&colors);
+    horizon_client::pack_palette::set_item_bars(root);
+    horizon_client::brewing::set_pack_colors(colors.effects());
     colors
 }

crates/horizon-client/src/game/respawn_anchor.rs

@@ -29,13 +29,12 @@ pub(super) struct RespawnConfig {
     pub dim: Dim,
     pub pos: [i32; 3],
     pub yaw: f32,
-    pub pitch: f32,
     pub forced: bool,
 }
 
 /// A respawn point as a player's save keeps it (`respawn`): dimension,
-/// block, yaw, pitch and whether it is forced.
-pub(super) type SavedRespawn = (String, [i32; 3], f32, f32, bool);
+/// block, yaw and whether it is forced.
+pub(super) type SavedRespawn = (String, [i32; 3], f32, bool);
 
 impl RespawnConfig {
     /// `RespawnData.of`: the yaw wrapped to [-180, 180).
@@ -44,37 +43,19 @@ impl RespawnConfig {
             dim,
             pos,
             yaw: wrap_degrees(f64::from(yaw)) as f32,
-            pitch: 0.0,
             forced,
         }
     }
-    /// `SetSpawnCommand`: the forced literal, with its already parsed angles.
-    pub(super) fn forced(dim: Dim, pos: [i32; 3], yaw: f32, pitch: f32) -> Self {
-        Self {
-            dim,
-            pos,
-            yaw,
-            pitch,
-            forced: true,
-        }
-    }
-    pub(super) fn from_saved((dim, pos, yaw, pitch, forced): &SavedRespawn) -> Self {
+    pub(super) fn from_saved((dim, pos, yaw, forced): &SavedRespawn) -> Self {
         Self {
             dim: Dim::from_id(dim),
             pos: *pos,
             yaw: *yaw,
-            pitch: *pitch,
             forced: *forced,
         }
     }
     pub(super) fn saved(&self) -> SavedRespawn {
-        (
-            self.dim.id().to_owned(),
-            self.pos,
-            self.yaw,
-            self.pitch,
-            self.forced,
-        )
+        (self.dim.id().to_owned(), self.pos, self.yaw, self.forced)
     }
 }
 
@@ -199,7 +180,6 @@ impl Game<'_> {
             dim: self.dim,
             pos,
             yaw: 0.0,
-            pitch: 0.0,
             forced: false,
         };
         // RespawnConfig.isSamePosition: dimension and block.
@@ -498,14 +478,14 @@ impl Game<'_> {
         rule.can_set_spawn.test(self.dark_outside())
     }
     /// `ServerPlayer.findRespawnAndUseSpawnBlock` for a config in the loaded
-    /// dimension: position and angles, using an anchor's charge; a bed's
+    /// dimension: the position and yaw, using an anchor's charge; a bed's
     /// stand-up spot. A forced point (`spawnpoint`) that is no anchor or bed
     /// holds if a player fits in it; anything else is gone.
     pub(super) fn find_respawn_and_use(
         &mut self,
         c: RespawnConfig,
         consume: bool,
-    ) -> Result<Option<(Vec3, f32, f32)>> {
+    ) -> Result<Option<(Vec3, f32)>> {
         let state = self.world.block(c.pos[0], c.pos[1], c.pos[2]);
         if !(self.is_anchor(state)
             && (c.forced || self.anchor_charges(state) > 0)
@@ -515,7 +495,7 @@ impl Game<'_> {
             if self.is_bed(state) && self.bed_sets_spawn(state) {
                 let facing = self.bed_forward(state);
                 let stand = self.bed_stand_up(c.pos, facing, c.yaw);
-                return Ok(stand.map(|p| (p, look_at_yaw(p, c.pos), 0.0)));
+                return Ok(stand.map(|p| (p, look_at_yaw(p, c.pos))));
             }
             let [x, y, z] = c.pos;
             let free = c.forced
@@ -523,7 +503,7 @@ impl Game<'_> {
                 && self.possible_to_respawn_in(state)
                 && self.possible_to_respawn_in(self.world.block(x, y + 1, z));
             let at = Vec3::new(f64::from(x) + 0.5, f64::from(y) + 0.1, f64::from(z) + 0.5);
-            return Ok(free.then_some((at, c.yaw, c.pitch)));
+            return Ok(free.then_some((at, c.yaw)));
         }
         let stand = self.anchor_stand_up(c.pos);
         if !c.forced
@@ -533,7 +513,7 @@ impl Game<'_> {
         {
             self.level_set(c.pos, next)?;
         }
-        Ok(stand.map(|p| (p, look_at_yaw(p, c.pos), 0.0)))
+        Ok(stand.map(|p| (p, look_at_yaw(p, c.pos))))
     }
 }
 
@@ -580,354 +560,3 @@ mod tests {
         assert!((look_at_yaw(east, head) - 90.0).abs() < 1.0e-4);
     }
 }
-
-#[cfg(test)]
-mod connected_spawnpoint_rotation_tests {
-    use crate::game::{Game, lan::LanSettings};
-    use horizon_client::{
-        chunk::Chunk,
-        lan::{Joined, NetConfig, Out, PlayerSender, guest::Guest, hub::HubConfig, playerdata},
-    };
-    use horizon_protocol::packets::{
-        configuration::ClientInformation,
-        play::{self, Clientbound as C, Serverbound as S},
-    };
-    use std::sync::{Arc, atomic::AtomicI32, mpsc};
-
-    fn command(game: &mut Game<'_>, text: &str) {
-        game.chat_capture = Some(Vec::new());
-        game.ui.registries.permission = 4;
-        let dispatcher = horizon_client::command::vanilla::build_for(false, true);
-        let parsed = dispatcher.parse(text, &game.ui.registries);
-        let (ctx, _) = parsed
-            .executable()
-            .expect("actual registered dedicated command");
-        let (root, ctx) = (parsed.context.clone(), ctx.clone());
-        assert_eq!(game.run_chain(&root, &ctx).unwrap(), 1, "{text}");
-        assert!(
-            !game.chat_capture.take().unwrap().is_empty(),
-            "actual command feedback {text}"
-        );
-    }
-
-    #[test]
-    #[ignore = "prepared resources and isolated scratch homes/cwd"]
-    fn command_forced_free_point_survives_real_guest_death_and_respawn_packet() {
-        let mut game = crate::game::native_machines::tests::server_game();
-        game.set_allow_commands(true);
-        let scratch = std::env::temp_dir().join(format!(
-            "horizon-forced-spawn-{}-{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        std::fs::create_dir_all(&scratch).unwrap();
-        game.world_root = scratch.clone();
-        // Fixture setup through the existing column insertion API; admit every lit column below.
-        for x in -2..=2 {
-            for z in -2..=2 {
-                game.streaming
-                    .insert_remote(&mut game.world, Chunk::empty(x, z));
-                assert!(game.streaming.is_lit(x, z));
-            }
-        }
-        let stone = game
-            .pack
-            .assets
-            .registry
-            .default_state("minecraft:stone")
-            .unwrap();
-        let air = game
-            .pack
-            .assets
-            .registry
-            .default_state("minecraft:air")
-            .unwrap();
-        game.world.set(12, 99, 12, stone).unwrap();
-        for y in [100, 101] {
-            game.world.set(12, y, 12, air).unwrap();
-        }
-        assert_eq!(game.world.block(12, 99, 12), stone);
-        assert!(game.world.loaded(12, 12));
-        game.level.world_spawn = Some([4, 100, 4]);
-        game.level.world_spawn_angle = [-30.0, -5.0];
-        game.lan_host(
-            LanSettings {
-                port: 0,
-                guest_commands: true,
-                force_game_mode: false,
-            },
-            NetConfig {
-                listen: false,
-                announce: false,
-                ..NetConfig::loopback(0, String::new(), 2)
-            },
-            HubConfig {
-                default_game_mode: 0,
-                guest_commands: true,
-                force_game_mode: false,
-                hardcore: false,
-                view_distance: 2,
-                simulation_distance: 2,
-                dimension: "minecraft:overworld".into(),
-                allow_flight: false,
-                seed: 0,
-                max_players: 2,
-                integrated: false,
-                levels: Default::default(),
-            },
-        )
-        .unwrap();
-        let (tx, rx) = mpsc::channel();
-        let mut guest = Guest::new(
-            Joined {
-                conn: 7,
-                uuid: 77,
-                name: "Alice".into(),
-                properties: Vec::new(),
-                info: ClientInformation::new(2),
-                brand: "test".into(),
-                sender: PlayerSender::new(tx, Arc::default()),
-                latency: Arc::new(AtomicI32::new(0)),
-                address: "127.0.0.1:7".parse().unwrap(),
-                expected: false,
-                configured: Default::default(),
-            },
-            7,
-            [4.5, 100.0, 4.5],
-            2,
-        );
-        guest.dimension = "minecraft:overworld".into();
-        guest.placed = true;
-        guest.loaded = true;
-        guest.health = 20.0;
-        guest.game_mode = 0;
-        guest.yaw = 0.0;
-        guest.pitch = 0.0;
-        game.lan.as_mut().unwrap().hub.guests.push(guest);
-        let clock = game.world.game_time;
-        command(&mut game, "spawnpoint Alice 12 100 12 45 10");
-        let host = game.lan.as_ref().unwrap();
-        assert!(host.owner.is_none());
-        let guest = &host.hub.guests[0];
-        assert_eq!(
-            (guest.uuid, guest.health, guest.game_mode, guest.position),
-            (77, 20.0, 0, [4.5, 100.0, 4.5])
-        );
-        let tag = playerdata::player_tag(guest);
-        let respawn = tag
-            .get("respawn")
-            .expect("actual serialized personal configuration")
-            .clone();
-        assert_eq!(
-            respawn.get("yaw"),
-            Some(&horizon_world::nbt::Tag::Float(45f32.to_bits()))
-        );
-        assert_eq!(
-            respawn.get("pos"),
-            Some(&horizon_world::nbt::Tag::IntArray(vec![12, 100, 12]))
-        );
-        command(&mut game, "kill Alice");
-        game.tick_lan(false);
-        let mut host = game.lan.take().unwrap();
-        assert_eq!(host.hub.guests[0].uuid, 77);
-        assert_eq!(host.hub.guests[0].health, 0.0);
-        assert!(
-            host.hub.guests[0].dead,
-            "actual command death before request"
-        );
-        for _ in rx.try_iter() {}
-        game.lan_guest_packet(
-            &mut host,
-            7,
-            S::ClientCommand(play::ClientCommand { action: 0 }),
-        );
-        game.tick_server_travel(&mut host);
-        assert!(
-            !game.on_server_trip(7),
-            "admitted lit columns permit actual arrival"
-        );
-        let guest = &host.hub.guests[0];
-        assert_eq!(guest.uuid, 77);
-        assert_eq!(guest.health, 20.0);
-        assert!(!guest.dead);
-        assert_eq!(guest.position, [12.5, 100.1, 12.5]);
-        assert_eq!(game.level.world_spawn, Some([4, 100, 4]));
-        assert_eq!(game.level.world_spawn_angle, [-30.0, -5.0]);
-        assert_eq!(game.world.game_time, clock);
-        let physical = [guest.yaw.to_bits(), guest.pitch.to_bits()];
-        let awaiting_id = guest
-            .awaiting_teleport
-            .expect("actual final arrival awaits its acknowledgement")
-            .0;
-        let mut packets = Vec::new();
-        for out in rx.try_iter() {
-            match out {
-                Out::Packet(p) => packets.push(p),
-                Out::Packets(p) => packets.extend(p),
-                Out::Disconnect(_) => panic!("unexpected disconnect"),
-            }
-        }
-        let mut positions = Vec::new();
-        let mut respawns = 0;
-        for p in packets {
-            println!("complete actual Hub frame {p:?}");
-            let mut r = horizon_protocol::buf::Reader::new(&p);
-            let id = r.varint().unwrap();
-            match C::decode(id, r.rest()).unwrap() {
-                C::PlayerPosition(p) => positions.push(p),
-                C::Respawn(_) => respawns += 1,
-                _ => {}
-            }
-        }
-        assert_eq!(respawns, 1);
-        assert!(!positions.is_empty());
-        println!("all actual arrival positions {positions:?}");
-        let selected: Vec<_> = positions
-            .iter()
-            .filter(|p| p.teleport == awaiting_id)
-            .collect();
-        assert_eq!(
-            selected.len(),
-            1,
-            "select by actual authoritative pending id, never expected position/pitch"
-        );
-        let p = selected[0];
-        assert_eq!(p.position, [12.5, 100.1, 12.5]);
-        // All successful command/death/arrival/identity/world controls precede the intended regression.
-        assert_eq!(
-            (
-                respawn.get("pitch"),
-                physical,
-                [p.yaw.to_bits(), p.pitch.to_bits()]
-            ),
-            (
-                Some(&horizon_world::nbt::Tag::Float(10f32.to_bits())),
-                [45f32.to_bits(), 10f32.to_bits()],
-                [45f32.to_bits(), 10f32.to_bits()]
-            )
-        );
-        drop(host);
-        drop(game);
-        std::fs::remove_dir_all(scratch).unwrap();
-    }
-}
-
-#[cfg(test)]
-mod pitch_preservation_controls {
-    use super::*;
-
-    #[test]
-    fn wrapped_existing_callers_default_to_positive_zero_pitch() {
-        let c = RespawnConfig::wrapped(Dim::Overworld, [5, 100, 5], 45.0, false);
-        assert_eq!(c.yaw.to_bits(), 45f32.to_bits());
-        assert_eq!(c.pitch.to_bits(), 0.0f32.to_bits());
-        assert!(!c.forced);
-    }
-
-    /// Added source/model controls; these do not add a connected bed/anchor runtime claim.
-    #[test]
-    #[ignore = "prepared resources and isolated scratch homes/cwd"]
-    fn bed_anchor_facing_and_invalid_personal_fallback_ignore_stored_pitch() {
-        let mut game = crate::game::native_machines::tests::server_game();
-        let stone = game
-            .pack
-            .assets
-            .registry
-            .default_state("minecraft:stone")
-            .unwrap();
-        for x in 0..16 {
-            for z in 0..16 {
-                game.world.set(x, 99, z, stone).unwrap();
-            }
-        }
-        let state = |game: &Game<'_>, name: &str, properties: &[(&str, &str)]| {
-            let registry = game.pack.assets.registry;
-            let id = registry.default_state(name).unwrap();
-            let mut value = registry.state(id).unwrap().clone();
-            for (key, value_) in properties {
-                value.properties.insert((*key).into(), (*value_).into());
-            }
-            registry.resolve(&value).unwrap()
-        };
-        let head = state(
-            &game,
-            "minecraft:red_bed",
-            &[("facing", "north"), ("part", "head")],
-        );
-        let foot = state(
-            &game,
-            "minecraft:red_bed",
-            &[("facing", "north"), ("part", "foot")],
-        );
-        game.world.set(5, 100, 5, head).unwrap();
-        game.world.set(5, 100, 6, foot).unwrap();
-        assert!(game.is_bed(head) && game.bed_sets_spawn(head));
-        let bed = RespawnConfig {
-            dim: Dim::Overworld,
-            pos: [5, 100, 5],
-            yaw: 45.0,
-            pitch: 0.0,
-            forced: true,
-        };
-        let zero = game
-            .find_respawn_and_use(bed, false)
-            .unwrap()
-            .expect("valid bed geometry");
-        let stored = game
-            .find_respawn_and_use(RespawnConfig { pitch: 75.0, ..bed }, false)
-            .unwrap()
-            .unwrap();
-        assert_eq!(stored, zero);
-        assert_eq!(stored.2.to_bits(), 0.0f32.to_bits());
-        assert_eq!(stored.1.to_bits(), look_at_yaw(stored.0, bed.pos).to_bits());
-
-        // Existing built-in dimension facts select the anchor rule; no new world or actor API.
-        game.dim = Dim::Nether;
-        let anchor = state(&game, "minecraft:respawn_anchor", &[("charges", "2")]);
-        game.world.set(10, 100, 10, anchor).unwrap();
-        assert!(game.anchor_works() && game.is_anchor(anchor));
-        let c = RespawnConfig {
-            dim: Dim::Nether,
-            pos: [10, 100, 10],
-            yaw: 45.0,
-            pitch: 0.0,
-            forced: true,
-        };
-        let zero = game
-            .find_respawn_and_use(c, false)
-            .unwrap()
-            .expect("valid anchor geometry");
-        let stored = game
-            .find_respawn_and_use(RespawnConfig { pitch: 75.0, ..c }, true)
-            .unwrap()
-            .unwrap();
-        assert_eq!(stored, zero);
-        assert_eq!(stored.2.to_bits(), 0.0f32.to_bits());
-        assert_eq!(stored.1.to_bits(), look_at_yaw(stored.0, c.pos).to_bits());
-        assert_eq!(
-            game.world.block(10, 100, 10),
-            anchor,
-            "existing forced-charge behavior"
-        );
-
-        game.dim = Dim::Overworld;
-        game.level.world_spawn = Some([4, 100, 4]);
-        game.level.world_spawn_angle = [-30.0, -5.0];
-        game.world.set(12, 100, 12, stone).unwrap();
-        let invalid = RespawnConfig {
-            dim: Dim::Overworld,
-            pos: [12, 100, 12],
-            yaw: 45.0,
-            pitch: 10.0,
-            forced: true,
-        };
-        game.respawn_config = Some(invalid);
-        assert!(game.resolve_server_respawn(invalid).is_none());
-        assert!(game.respawn_config.is_none());
-        assert_eq!(game.level.world_spawn, Some([4, 100, 4]));
-        assert_eq!(game.level.world_spawn_angle, [-30.0, -5.0]);
-    }
-}

crates/horizon-client/src/game/scoreboard.rs

@@ -823,7 +823,7 @@ impl Game<'_> {
         for (location, rgba) in ready {
             self.store_skin(location, rgba);
         }
-        self.cosmetics_frame();
+        self.client_hooks_frame();
     }
     /// `Hud.extractTabList`: the player list while the player-list key is
     /// held. A local world shows it with a joined LAN guest or a `list`
@@ -900,10 +900,12 @@ impl Game<'_> {
         let board = &self.score.board;
         let objective = board.display_objective(sb::SLOT_LIST);
         let up = |id: u128| upside_down.contains(&id);
-        // Horizon's mark before the names of Horizon players (the cosmetics service's cache).
-        let horizon = self.horizon_players(players.iter().map(|p| p.uuid));
-        let horizon_mark = super::cosmetics::MARK;
-        let marked = |id: u128| horizon.contains(&id).then_some(horizon_mark);
+        // A hook's mark before a name (Horizon's: they play Horizon).
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let marked = horizon_hooks::engine::player_mark;
         let inputs = TabInputs {
             players: &players,
             board,

crates/horizon-client/src/game/sculk.rs

@@ -359,19 +359,12 @@ impl Game<'_> {
             self.sculk.tracker = WardenSpawnTracker::from_nbt(tag);
         }
     }
-    /// The tracker as saved, once it has been loaded.
-    pub(super) fn warden_tracker_tag(&self) -> Option<horizon_world::nbt::Tag> {
-        self.sculk
-            .tracker_loaded
-            .then(|| self.sculk.tracker.to_nbt())
-    }
-    /// Write the tracker into the player data being saved. With a LAN owner,
-    /// `store_owner` rewrites that from the owner's guest, so it puts the
-    /// tracker there as well (`playerdata::with_warden`).
+    /// Write the tracker into the player data being saved.
     pub(super) fn save_warden_tracker(&mut self) {
-        let Some(tag) = self.warden_tracker_tag() else {
+        if !self.sculk.tracker_loaded {
             return;
-        };
+        }
+        let tag = self.sculk.tracker.to_nbt();
         let extra = self
             .level
             .player_extra

crates/horizon-client/src/game/server_travel.rs

@@ -644,14 +644,11 @@ impl Game<'_> {
     /// in the level in place: where it stands up, facing the anchor (with
     /// the deplete sound) or the bed; else the point is forgotten, and the
     /// caller tells the player (`Hub::missing_respawn_block`).
-    pub(super) fn resolve_server_respawn(
-        &mut self,
-        config: RespawnConfig,
-    ) -> Option<(Vec3, f32, f32)> {
+    pub(super) fn resolve_server_respawn(&mut self, config: RespawnConfig) -> Option<(Vec3, f32)> {
         let [x, y, z] = config.pos;
         let anchor = self.is_anchor(self.world.block(x, y, z));
         match self.find_respawn_and_use(config, true) {
-            Ok(Some((at, yaw, pitch))) => {
+            Ok(Some((at, yaw))) => {
                 if !config.forced && anchor {
                     let [x, y, z] = config.pos.map(f64::from);
                     self.audio.play(
@@ -661,7 +658,7 @@ impl Game<'_> {
                         1.0,
                     );
                 }
-                Some((at, yaw, pitch))
+                Some((at, yaw))
             }
             Ok(None) | Err(_) => {
                 let mut cancel = false;
@@ -799,10 +796,7 @@ impl Game<'_> {
             let yaw = host.hub.guests[i].yaw;
             let (position, yaw) = if let Some(config) = trip.respawn {
                 match self.as_guest(host, trip.conn, |g| g.resolve_server_respawn(config)) {
-                    Some(Some((at, yaw, pitch))) => {
-                        host.hub.guests[i].pitch = pitch;
-                        (at, yaw)
-                    }
+                    Some(Some(found)) => found,
                     _ => {
                         host.hub.missing_respawn_block(trip.conn);
                         self.respawn_at_world_spawn(host, trip.conn);

crates/horizon-client/src/game/startup_menu.rs

@@ -1268,7 +1268,7 @@ impl Loading {
             let output = self
                 .renderer
                 .as_ref()
-                .map_or(Default::default(), |r| r.output());
+                .map_or(Default::default(), |r| *r.output());
             self.menu
                 .options
                 .draw(&self.settings, output, batch, &gui.atlas, self.menu.cursor);

crates/horizon-client/src/game/stations/anvil.rs

@@ -15,8 +15,6 @@ pub(super) fn rename_box() -> horizon_client::ui::EditBox {
     edit.text_color = u32::MAX;
     // AnvilScreen also sets `setTextColorUneditable(-1)`: white either way.
     edit.text_color_uneditable = u32::MAX;
-    // AnvilScreen sets `setInvertHighlightedTextColor(false)`.
-    edit.invert_highlighted_text_color = false;
     edit.focused = true;
     edit.editable = false;
     edit
@@ -42,7 +40,6 @@ mod tests {
         // AnvilScreen.init: no input yet, so the box is read-only but focused.
         let station_box = rename_box();
         assert!(station_box.focused && !station_box.editable);
-        assert!(!station_box.invert_highlighted_text_color);
 
         // slotChanged with an item: editable, and it shows the item's name.
         let mut station = Station::new_kind(Kind::Anvil, [0; 3]);

crates/horizon-client/src/game/studio.rs

@@ -15,26 +15,6 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-/// Studio's state in a `Game`: the replay playing, its free camera, timeline and top bar. Studio is
-/// a Horizon extra (docs/layers.md: the replay editor); the engine only asks it whether a replay
-/// plays or the free camera flies.
-#[derive(Default)]
-pub(super) struct Studio {
-    /// The packet replay playing, if any.
-    pub(super) replay: Option<ReplayDriver>,
-    pub(super) freecam: horizon_client::studio::StudioFreecam,
-    pub(super) timeline: horizon_client::studio::TimelineUi,
-    pub(super) topbar: horizon_client::studio::TopBarUi,
-    pub(super) rmb_down: bool,
-    pub(super) camera_track_dirty: bool,
-    /// Camera perspective to restore after leaving replay playback.
-    pub(super) replay_previous_camera_type: Option<super::perspective::CameraType>,
-    /// Replay opened from the title screen owns the synthetic remote session.
-    pub(super) replay_standalone: bool,
-    pub(super) last_replay_tick: Option<std::time::Instant>,
-    pub(super) virtual_tick_ms: f32,
-}
-
 pub const HELP: &[&str] = &[
     "studio record start [NAME]     start recording clientbound packets into .mcpr archive",
     "studio record stop             stop recording and finalize .mcpr archive",
@@ -129,13 +109,13 @@ impl Game<'_> {
         match words[0] {
             "freecam" => match words.get(1).copied() {
                 Some("on") => {
-                    if self.studio.replay.is_none() {
+                    if self.studio_replay.is_none() {
                         self.system_message(Text::translate(
                             "horizon.studio.freecam.replay_required",
                             &[],
                         ));
                     } else if let Some((position, yaw, pitch)) = self.camera_view(1.0) {
-                        self.studio.freecam.activate(
+                        self.studio_freecam.activate(
                             position,
                             yaw,
                             pitch,
@@ -151,24 +131,24 @@ impl Game<'_> {
                     }
                 }
                 Some("off") => {
-                    self.studio.freecam.deactivate();
+                    self.studio_freecam.deactivate();
                     self.capture(false);
                     self.system_message(Text::translate("horizon.studio.freecam.disabled", &[]));
                 }
                 _ => self.system_message(Text::translate("horizon.studio.freecam.usage", &[])),
             },
             "keyframe" => {
-                let Some(driver) = self.studio.replay.as_ref() else {
+                let Some(driver) = self.studio_replay.as_ref() else {
                     self.system_message(Text::translate("horizon.studio.replay.inactive", &[]));
                     return true;
                 };
                 let time_ms = driver.position_ms();
                 match words.get(1).copied() {
                     Some("add") => {
-                        if !self.studio.freecam.active
+                        if !self.studio_freecam.active
                             && let Some((position, yaw, pitch)) = self.camera_view(1.0)
                         {
-                            self.studio.freecam.activate(
+                            self.studio_freecam.activate(
                                 position,
                                 yaw,
                                 pitch,
@@ -176,16 +156,16 @@ impl Game<'_> {
                             );
                         }
                         self.capture(true);
-                        self.studio.freecam.add_keyframe_at_current(time_ms);
-                        self.studio.camera_track_dirty = true;
+                        self.studio_freecam.add_keyframe_at_current(time_ms);
+                        self.studio_camera_track_dirty = true;
                         self.system_message(Text::tr(
                             "horizon.studio.keyframe.added",
                             &[&time_ms.to_string()],
                         ));
                     }
                     Some("clear") => {
-                        self.studio.freecam.track.clear();
-                        self.studio.camera_track_dirty = true;
+                        self.studio_freecam.track.clear();
+                        self.studio_camera_track_dirty = true;
                         self.system_message(Text::translate(
                             "horizon.studio.keyframe.cleared",
                             &[],
@@ -201,15 +181,15 @@ impl Game<'_> {
                             ));
                             return true;
                         };
-                        if index >= self.studio.freecam.track.keyframes.len() {
+                        if index >= self.studio_freecam.track.keyframes.len() {
                             self.system_message(Text::translate(
                                 "horizon.studio.keyframe.index_invalid",
                                 &[],
                             ));
                             return true;
                         }
-                        self.studio.freecam.track.keyframes.remove(index);
-                        self.studio.camera_track_dirty = true;
+                        self.studio_freecam.track.keyframes.remove(index);
+                        self.studio_camera_track_dirty = true;
                         self.system_message(Text::tr(
                             "horizon.studio.keyframe.removed",
                             &[&index.to_string()],
@@ -219,14 +199,14 @@ impl Game<'_> {
                 }
             }
             "path" => match words.get(1).copied() {
-                Some("lock") if !self.studio.freecam.track.is_empty() => {
-                    self.studio.freecam.active = true;
-                    self.studio.freecam.locked_to_path = true;
+                Some("lock") if !self.studio_freecam.track.is_empty() => {
+                    self.studio_freecam.active = true;
+                    self.studio_freecam.locked_to_path = true;
                     self.capture(true);
                     self.system_message(Text::translate("horizon.studio.path.locked", &[]));
                 }
                 Some("unlock") => {
-                    self.studio.freecam.locked_to_path = false;
+                    self.studio_freecam.locked_to_path = false;
                     self.system_message(Text::translate("horizon.studio.path.unlocked", &[]));
                 }
                 _ => self.system_message(Text::translate("horizon.studio.path.usage", &[])),
@@ -319,7 +299,7 @@ impl Game<'_> {
                     }
                 }
                 Some("pause") => {
-                    if let Some(r) = self.studio.replay.as_mut() {
+                    if let Some(r) = self.studio_replay.as_mut() {
                         r.set_paused(true);
                         self.system_message(Text::translate("horizon.studio.replay.paused", &[]));
                     } else {
@@ -327,7 +307,7 @@ impl Game<'_> {
                     }
                 }
                 Some("resume") => {
-                    if let Some(r) = self.studio.replay.as_mut() {
+                    if let Some(r) = self.studio_replay.as_mut() {
                         r.set_paused(false);
                         self.system_message(Text::translate("horizon.studio.replay.resumed", &[]));
                     } else {
@@ -343,7 +323,7 @@ impl Game<'_> {
                         return true;
                     };
                     if let Ok(spd) = spd_str.parse::<f64>() {
-                        let new_speed = if let Some(r) = self.studio.replay.as_mut() {
+                        let new_speed = if let Some(r) = self.studio_replay.as_mut() {
                             r.set_speed(spd);
                             Some(r.speed())
                         } else {
@@ -377,12 +357,11 @@ impl Game<'_> {
                         return true;
                     };
                     if let Ok(ms) = ms_str.parse::<u32>() {
-                        if self.studio.replay.is_some() {
+                        if self.studio_replay.is_some() {
                             match self.seek_studio_replay(ms) {
                                 Ok(()) => {
                                     let actual_ms = self
-                                        .studio
-                                        .replay
+                                        .studio_replay
                                         .as_ref()
                                         .map_or(ms, |replay| ms.min(replay.duration_ms()));
                                     let ms_text = actual_ms.to_string();
@@ -421,7 +400,7 @@ impl Game<'_> {
                     }
                 }
                 Some("status") => {
-                    if let Some(r) = self.studio.replay.as_ref() {
+                    if let Some(r) = self.studio_replay.as_ref() {
                         let position = r.position_ms().to_string();
                         let duration = r.duration_ms().to_string();
                         let progress = format!("{:.1}", r.progress() * 100.0);
@@ -456,7 +435,7 @@ impl Game<'_> {
 
     /// Reset playback tick accumulator and align positions on seek.
     pub(super) fn reset_studio_playback_ticks(&mut self) {
-        self.studio.virtual_tick_ms = 0.0;
+        self.studio_virtual_tick_ms = 0.0;
         if let Some(player) = &self.player {
             self.previous_position = player.position;
             if let Some(m) = self.player_model.as_mut() {
@@ -473,14 +452,12 @@ impl Game<'_> {
     /// forward because its pre-replay world must remain intact.
     pub(super) fn seek_studio_replay(&mut self, target_ms: u32) -> std::io::Result<()> {
         let current_ms = self
-            .studio
-            .replay
+            .studio_replay
             .as_ref()
             .map_or(0, ReplayDriver::position_ms);
-        let packets = if self.studio.replay_standalone {
+        let packets = if self.studio_replay_standalone {
             let packets = self
-                .studio
-                .replay
+                .studio_replay
                 .as_mut()
                 .expect("replay checked by caller")
                 .seek_and_collect(target_ms)?;
@@ -494,8 +471,7 @@ impl Game<'_> {
                     "backward seek requires a standalone replay",
                 ));
             }
-            self.studio
-                .replay
+            self.studio_replay
                 .as_mut()
                 .expect("replay checked by caller")
                 .seek_forward(target_ms)?
@@ -503,7 +479,7 @@ impl Game<'_> {
 
         self.dispatch_studio_replay_packets(packets);
         self.reset_studio_playback_ticks();
-        self.studio.last_replay_tick = Some(std::time::Instant::now());
+        self.last_replay_tick = Some(std::time::Instant::now());
         Ok(())
     }
 
@@ -534,19 +510,19 @@ impl Game<'_> {
 
     /// Advance active replay playback by elapsed frame time and dispatch ready packets.
     pub(super) fn advance_studio_replay(&mut self) -> Result<()> {
-        let Some(driver) = self.studio.replay.as_mut() else {
-            self.studio.last_replay_tick = None;
+        let Some(driver) = self.studio_replay.as_mut() else {
+            self.last_replay_tick = None;
             return Ok(());
         };
 
         let now = std::time::Instant::now();
-        let delta = match self.studio.last_replay_tick {
+        let delta = match self.last_replay_tick {
             Some(last) => now
                 .saturating_duration_since(last)
                 .min(Duration::from_millis(250)),
             None => Duration::from_millis(16),
         };
-        self.studio.last_replay_tick = Some(now);
+        self.last_replay_tick = Some(now);
 
         let ready_packets = match driver.advance(delta) {
             Ok(pkts) => pkts,
@@ -557,18 +533,16 @@ impl Game<'_> {
         };
 
         self.dispatch_studio_replay_packets(ready_packets);
-        if self.studio.freecam.locked_to_path
+        if self.studio_freecam.locked_to_path
             && let Some(position) = self
-                .studio
-                .replay
+                .studio_replay
                 .as_ref()
                 .map(|replay| replay.position_ms())
         {
-            self.studio.freecam.update_spline_playback(position);
+            self.studio_freecam.update_spline_playback(position);
         }
         let paused = self
-            .studio
-            .replay
+            .studio_replay
             .as_ref()
             .is_some_and(|replay| replay.is_paused());
         if self.player_model.is_none() {
@@ -576,14 +550,13 @@ impl Game<'_> {
         }
         if !paused {
             let speed = self
-                .studio
-                .replay
+                .studio_replay
                 .as_ref()
                 .map_or(1.0, |r| r.speed() as f32)
                 .max(0.1);
-            self.studio.virtual_tick_ms += delta.as_secs_f32() * 1000.0 * speed;
-            while self.studio.virtual_tick_ms >= 50.0 {
-                self.studio.virtual_tick_ms -= 50.0;
+            self.studio_virtual_tick_ms += delta.as_secs_f32() * 1000.0 * speed;
+            while self.studio_virtual_tick_ms >= 50.0 {
+                self.studio_virtual_tick_ms -= 50.0;
                 if let Some(player) = &self.player {
                     let current_pos = player.position;
                     let (dx, dz) = (
@@ -634,7 +607,7 @@ impl Game<'_> {
             m.previous_limb_speed = m.limb_speed;
         }
         if let Some((position, duration, paused, markers)) =
-            self.studio.replay.as_ref().map(|replay| {
+            self.studio_replay.as_ref().map(|replay| {
                 (
                     replay.position_ms(),
                     replay.duration_ms(),
@@ -643,10 +616,10 @@ impl Game<'_> {
                 )
             })
         {
-            self.studio.timeline.current_time_ms = u64::from(position);
-            self.studio.timeline.duration_ms = u64::from(duration);
-            self.studio.timeline.playing = !paused;
-            self.studio.timeline.markers = markers;
+            self.studio_timeline.current_time_ms = u64::from(position);
+            self.studio_timeline.duration_ms = u64::from(duration);
+            self.studio_timeline.playing = !paused;
+            self.studio_timeline.markers = markers;
         }
         Ok(())
     }
@@ -666,10 +639,10 @@ impl Game<'_> {
                 self.capture(false);
             }
             TopBarAction::ExitStudio => {
-                if self.studio.replay.is_some() {
+                if self.studio_replay.is_some() {
                     self.close_studio_replay();
                 } else {
-                    self.studio.freecam.deactivate();
+                    self.studio_freecam.deactivate();
                     self.capture(false);
                 }
             }
@@ -695,46 +668,42 @@ impl Game<'_> {
                 } else {
                     (glam::DVec3::ZERO, 0.0, 0.0)
                 };
-                self.studio
-                    .freecam
+                self.studio_freecam
                     .activate(position, yaw, pitch, self.settings.fov);
             }
             TopBarAction::ToggleLockToPath => {
-                self.studio.freecam.locked_to_path = !self.studio.freecam.locked_to_path;
+                self.studio_freecam.locked_to_path = !self.studio_freecam.locked_to_path;
             }
             TopBarAction::ToggleFreecam => {
-                if self.studio.freecam.active {
-                    self.studio.freecam.deactivate();
+                if self.studio_freecam.active {
+                    self.studio_freecam.deactivate();
                     self.capture(false);
                 } else {
                     let (position, yaw, pitch) =
                         self.camera_view(0.0)
                             .unwrap_or((glam::DVec3::ZERO, 0.0, 0.0));
-                    self.studio
-                        .freecam
+                    self.studio_freecam
                         .activate(position, yaw, pitch, self.settings.fov);
                     self.capture(true);
                 }
             }
             TopBarAction::AddKeyframe => {
-                self.studio
-                    .freecam
-                    .add_keyframe_at_current(self.studio.timeline.current_time_ms as u32);
-                self.studio.camera_track_dirty = true;
+                self.studio_freecam
+                    .add_keyframe_at_current(self.studio_timeline.current_time_ms as u32);
+                self.studio_camera_track_dirty = true;
             }
             TopBarAction::AddMarker => self.add_studio_marker(),
             TopBarAction::ClearKeyframes => {
-                self.studio.freecam.track.keyframes.clear();
-                self.studio.timeline.selected_keyframe = None;
-                self.studio.camera_track_dirty = true;
+                self.studio_freecam.track.keyframes.clear();
+                self.studio_timeline.selected_keyframe = None;
+                self.studio_camera_track_dirty = true;
             }
             TopBarAction::ToggleTimeline => {
-                self.studio.timeline.visible = !self.studio.timeline.visible;
+                self.studio_timeline.visible = !self.studio_timeline.visible;
             }
             TopBarAction::SplitClip => {
-                self.studio
-                    .timeline
-                    .split_at(self.studio.timeline.current_time_ms);
+                self.studio_timeline
+                    .split_at(self.studio_timeline.current_time_ms);
             }
         }
     }
@@ -747,97 +716,93 @@ impl Game<'_> {
         use horizon_client::studio::TimelineAction;
         match action {
             TimelineAction::PauseForSeek => {
-                self.studio.timeline.playing = false;
-                if let Some(replay) = self.studio.replay.as_mut() {
+                self.studio_timeline.playing = false;
+                if let Some(replay) = self.studio_replay.as_mut() {
                     replay.set_paused(true);
                 }
             }
             TimelineAction::Seek(time_ms) => {
-                let time_ms = if self.studio.replay_standalone {
+                let time_ms = if self.studio_replay_standalone {
                     time_ms
                 } else {
                     let current =
-                        self.studio
-                            .replay
+                        self.studio_replay
                             .as_ref()
                             .map_or(0, ReplayDriver::position_ms) as u64;
                     time_ms.max(current)
                 };
-                self.studio.timeline.current_time_ms = time_ms;
+                self.studio_timeline.current_time_ms = time_ms;
                 if let Err(error) = self.seek_studio_replay(time_ms.min(u32::MAX as u64) as u32) {
                     log::warn!("Studio timeline seek failed: {error}");
                 }
             }
             TimelineAction::TogglePlay => {
-                self.studio.timeline.playing = !self.studio.timeline.playing;
-                if let Some(replay) = self.studio.replay.as_mut() {
-                    replay.set_paused(!self.studio.timeline.playing);
+                self.studio_timeline.playing = !self.studio_timeline.playing;
+                if let Some(replay) = self.studio_replay.as_mut() {
+                    replay.set_paused(!self.studio_timeline.playing);
                 }
             }
             TimelineAction::StepBack => {
-                let time_ms = self.studio.timeline.current_time_ms.saturating_sub(1000);
+                let time_ms = self.studio_timeline.current_time_ms.saturating_sub(1000);
                 self.handle_studio_timeline_action(TimelineAction::Seek(time_ms));
             }
             TimelineAction::StepForward => {
                 let time_ms = self
-                    .studio
-                    .timeline
+                    .studio_timeline
                     .current_time_ms
                     .saturating_add(1000)
-                    .min(self.studio.timeline.duration_ms);
+                    .min(self.studio_timeline.duration_ms);
                 self.handle_studio_timeline_action(TimelineAction::Seek(time_ms));
             }
             TimelineAction::SeekStart => {
                 self.handle_studio_timeline_action(TimelineAction::Seek(0))
             }
             TimelineAction::SeekEnd => self.handle_studio_timeline_action(TimelineAction::Seek(
-                self.studio.timeline.duration_ms,
+                self.studio_timeline.duration_ms,
             )),
             TimelineAction::SetSpeed(speed) => {
-                self.studio.timeline.speed = speed;
-                if let Some(replay) = self.studio.replay.as_mut() {
+                self.studio_timeline.speed = speed;
+                if let Some(replay) = self.studio_replay.as_mut() {
                     replay.set_speed(speed);
                 }
             }
             TimelineAction::ToggleFreecam => {
-                if self.studio.freecam.active {
-                    self.studio.freecam.deactivate();
+                if self.studio_freecam.active {
+                    self.studio_freecam.deactivate();
                 } else {
                     let (position, yaw, pitch) =
                         self.camera_view(0.0)
                             .unwrap_or((glam::DVec3::ZERO, 0.0, 0.0));
-                    self.studio
-                        .freecam
+                    self.studio_freecam
                         .activate(position, yaw, pitch, self.settings.fov);
                 }
             }
             TimelineAction::AddCameraKeyframe => {
-                self.studio
-                    .freecam
-                    .add_keyframe_at_current(self.studio.timeline.current_time_ms as u32);
-                self.studio.camera_track_dirty = true;
+                self.studio_freecam
+                    .add_keyframe_at_current(self.studio_timeline.current_time_ms as u32);
+                self.studio_camera_track_dirty = true;
             }
             TimelineAction::RemoveCameraKeyframe(index) => {
-                if index < self.studio.freecam.track.keyframes.len() {
-                    self.studio.freecam.track.keyframes.remove(index);
-                    self.studio.camera_track_dirty = true;
+                if index < self.studio_freecam.track.keyframes.len() {
+                    self.studio_freecam.track.keyframes.remove(index);
+                    self.studio_camera_track_dirty = true;
                 }
-                self.studio.timeline.selected_keyframe = None;
+                self.studio_timeline.selected_keyframe = None;
             }
             TimelineAction::SelectKeyframe(index) => {
-                self.studio.timeline.selected_keyframe = Some(index);
+                self.studio_timeline.selected_keyframe = Some(index);
             }
             TimelineAction::KeyframeMoved => {
-                self.studio.camera_track_dirty = true;
+                self.studio_camera_track_dirty = true;
             }
-            TimelineAction::SplitClip(time_ms) => self.studio.timeline.split_at(time_ms),
+            TimelineAction::SplitClip(time_ms) => self.studio_timeline.split_at(time_ms),
             TimelineAction::None => {}
         }
     }
 
     /// Add a bookmark at the replay playhead and save it in the `.mcpr` archive.
     pub(super) fn add_studio_marker(&mut self) {
-        let Some(replay) = self.studio.replay.as_mut() else {
+        let Some(replay) = self.studio_replay.as_mut() else {
             return;
         };
         let label = Text::translate(
@@ -846,7 +811,7 @@ impl Game<'_> {
         )
         .plain();
         match replay.add_marker(label) {
-            Ok(_) => self.studio.timeline.markers = replay.markers().to_vec(),
+            Ok(_) => self.studio_timeline.markers = replay.markers().to_vec(),
             Err(error) => log::warn!("Studio: could not save replay marker: {error}"),
         }
     }
@@ -880,7 +845,7 @@ impl Game<'_> {
                     Ok(Some(res))
                 }
                 Some("pause") => {
-                    if let Some(r) = self.studio.replay.as_mut() {
+                    if let Some(r) = self.studio_replay.as_mut() {
                         r.set_paused(true);
                         Ok(Some(json!({ "ok": true, "paused": true })))
                     } else {
@@ -888,7 +853,7 @@ impl Game<'_> {
                     }
                 }
                 Some("resume") => {
-                    if let Some(r) = self.studio.replay.as_mut() {
+                    if let Some(r) = self.studio_replay.as_mut() {
                         r.set_paused(false);
                         Ok(Some(json!({ "ok": true, "paused": false })))
                     } else {
@@ -898,7 +863,7 @@ impl Game<'_> {
                 Some("speed") => {
                     let spd_str = words.get(3).ok_or("missing speed value")?;
                     let spd: f64 = spd_str.parse().map_err(|_| "invalid speed")?;
-                    if let Some(r) = self.studio.replay.as_mut() {
+                    if let Some(r) = self.studio_replay.as_mut() {
                         r.set_speed(spd);
                         Ok(Some(json!({ "ok": true, "speed": r.speed() })))
                     } else {
@@ -908,7 +873,7 @@ impl Game<'_> {
                 Some("seek") => {
                     let ms_str = words.get(3).ok_or("missing seek timestamp")?;
                     let ms: u32 = ms_str.parse().map_err(|_| "invalid timestamp")?;
-                    let pos = if let Some(r) = self.studio.replay.as_mut() {
+                    let pos = if let Some(r) = self.studio_replay.as_mut() {
                         r.seek(ms).map_err(|e| format!("{e}"))?;
                         Some(r.position_ms())
                     } else {
@@ -922,7 +887,7 @@ impl Game<'_> {
                     }
                 }
                 Some("status") => {
-                    if let Some(r) = self.studio.replay.as_ref() {
+                    if let Some(r) = self.studio_replay.as_ref() {
                         Ok(Some(json!({
                             "ok": true,
                             "active": true,
@@ -1034,13 +999,13 @@ impl Game<'_> {
     }
 
     pub(super) fn open_studio_replay(&mut self, path: &str) -> Result<Value> {
-        if self.studio.camera_track_dirty
-            && let Some(active) = self.studio.replay.as_mut()
+        if self.studio_camera_track_dirty
+            && let Some(active) = self.studio_replay.as_mut()
         {
-            if let Err(error) = active.save_camera_track(&self.studio.freecam.track) {
+            if let Err(error) = active.save_camera_track(&self.studio_freecam.track) {
                 return Ok(json!({ "ok": false, "error": error.to_string() }));
             }
-            self.studio.camera_track_dirty = false;
+            self.studio_camera_track_dirty = false;
         }
         // The recordings browser can be opened while the title screen is
         // available but the slower world tables are still loading. Replay
@@ -1063,7 +1028,7 @@ impl Game<'_> {
             }
         };
 
-        let standalone = self.studio.replay.is_none() && self.remote.is_none();
+        let standalone = self.studio_replay.is_none() && self.remote.is_none();
         if self.remote.is_none()
             && let Err(error) = self.init_remote_for_replay()
         {
@@ -1073,17 +1038,17 @@ impl Game<'_> {
 
         let duration_ms = driver.duration_ms();
         let packets = driver.packet_count();
-        self.studio.timeline.duration_ms = u64::from(duration_ms);
-        self.studio.timeline.current_time_ms = 0;
-        self.studio.timeline.playing = !driver.is_paused();
-        self.studio.timeline.markers = driver.markers().to_vec();
-        self.studio.freecam.track = driver.camera_track().cloned().unwrap_or_default();
-        self.studio.camera_track_dirty = false;
-        if self.studio.replay.is_none() {
-            self.studio.replay_previous_camera_type = Some(self.camera_type);
-            self.studio.replay_standalone = standalone;
+        self.studio_timeline.duration_ms = u64::from(duration_ms);
+        self.studio_timeline.current_time_ms = 0;
+        self.studio_timeline.playing = !driver.is_paused();
+        self.studio_timeline.markers = driver.markers().to_vec();
+        self.studio_freecam.track = driver.camera_track().cloned().unwrap_or_default();
+        self.studio_camera_track_dirty = false;
+        if self.studio_replay.is_none() {
+            self.studio_replay_previous_camera_type = Some(self.camera_type);
+            self.studio_replay_standalone = standalone;
         }
-        self.studio.replay = Some(driver);
+        self.studio_replay = Some(driver);
         self.camera_type = super::perspective::CameraType::FirstPerson;
         self.title = None;
         self.screen = Screen::Playing;
@@ -1101,14 +1066,14 @@ impl Game<'_> {
         }))
     }
     pub(super) fn close_studio_replay(&mut self) -> bool {
-        if self.studio.camera_track_dirty
-            && let Some(driver) = self.studio.replay.as_mut()
-            && let Err(error) = driver.save_camera_track(&self.studio.freecam.track)
+        if self.studio_camera_track_dirty
+            && let Some(driver) = self.studio_replay.as_mut()
+            && let Err(error) = driver.save_camera_track(&self.studio_freecam.track)
         {
             log::warn!("Studio: could not save camera path: {error}");
         }
-        self.studio.camera_track_dirty = false;
-        let closed = self.studio.replay.take().is_some();
+        self.studio_camera_track_dirty = false;
+        let closed = self.studio_replay.take().is_some();
         if !closed {
             return false;
         }
@@ -1116,23 +1081,23 @@ impl Game<'_> {
         // A standalone replay owns a synthetic Remote connection. Treat that
         // connection as replay state even if the saved origin flag was lost;
         // sending it through leave_server() opens the Multiplayer screen.
-        let standalone = self.studio.replay_standalone
+        let standalone = self.studio_replay_standalone
             || self
                 .remote
                 .as_ref()
                 .is_some_and(|remote| remote.brand == "horizon-studio");
-        self.studio.replay_standalone = false;
-        if let Some(camera_type) = self.studio.replay_previous_camera_type.take() {
+        self.studio_replay_standalone = false;
+        if let Some(camera_type) = self.studio_replay_previous_camera_type.take() {
             self.camera_type = camera_type;
         }
-        self.studio.last_replay_tick = None;
-        self.studio.timeline.current_time_ms = 0;
-        self.studio.timeline.playing = false;
-        self.studio.timeline.markers.clear();
-        self.studio.timeline.split_points.clear();
-        self.studio.timeline.selected_keyframe = None;
-        self.studio.freecam.deactivate();
-        self.studio.virtual_tick_ms = 0.0;
+        self.last_replay_tick = None;
+        self.studio_timeline.current_time_ms = 0;
+        self.studio_timeline.playing = false;
+        self.studio_timeline.markers.clear();
+        self.studio_timeline.split_points.clear();
+        self.studio_timeline.selected_keyframe = None;
+        self.studio_freecam.deactivate();
+        self.studio_virtual_tick_ms = 0.0;
         self.capture(false);
         if standalone {
             if let Some(mut remote) = self.remote.take() {

crates/horizon-client/src/game/totem.rs

@@ -149,7 +149,7 @@ impl Game<'_> {
         self.audio
             .play_unshared("minecraft:item.totem.use", Some(body.bounds.feet), 1.0, 1.0);
         if target == TrackingTarget::LocalPlayer {
-            self.input_feedback(horizon_client::input_source::Feedback::Totem);
+            self.pad_rumble(horizon_client::gamepad::Rumble::Totem);
             // findTotem, then LocalPlayer.displayItemActivation. The offsets
             // come from the player's own random in vanilla, not the level's:
             // the client-only particle random stands in for it. The server

crates/horizon-client/src/game/tutorial.rs

@@ -298,7 +298,7 @@ impl super::Game<'_> {
             .into_iter()
             .any(|action| self.keys.held(action))
                 || self
-                    .input_move()
+                    .pad_move()
                     .is_some_and(|[left, forward]| left.abs() > 0.3 || forward.abs() > 0.3))
         {
             self.tutorial.input();

crates/horizon-client/src/game/window_handler.rs

@@ -107,9 +107,9 @@ impl Game<'_> {
                 state: ElementState::Pressed,
                 ..
             }
-        ) && !self.input_made_pointer_event()
+        ) && !self.pad.menu.synthetic
         {
-            self.input_keyboard_used();
+            self.pad.keyboard_took_over = true;
         }
         if let WindowEvent::MouseInput { state, button, .. } = &event {
             if *state == ElementState::Pressed {

crates/horizon-client/src/game/world_session.rs

@@ -245,7 +245,7 @@ impl Game<'_> {
         // Pause-menu and death-screen exits use the normal world-close action.
         // A standalone replay owns a synthetic remote session, so it must go
         // through replay cleanup instead of being treated like a server.
-        if self.studio.replay.is_some() {
+        if self.studio_replay.is_some() {
             self.close_studio_replay();
             return Ok(());
         }

crates/horizon-client/src/join_seq.rs

@@ -165,22 +165,6 @@ impl<T: Joined> JoinList<T> {
             self.push(entity);
         }
     }
-    /// An entity that never left its level keeps its place in
-    /// `EntityTickList`: one a pass took out and puts back (an arrow bouncing
-    /// off) goes back before the first entity that joined after it. One that
-    /// has not joined yet is appended and numbered, as by `push`.
-    pub fn put_back(&mut self, entity: T) {
-        let seq = entity.join_seq();
-        let at = if seq.is_joined() {
-            self.list
-                .iter()
-                .position(|q| q.join_seq() > seq)
-                .unwrap_or(self.list.len())
-        } else {
-            self.list.len()
-        };
-        self.insert(at, entity);
-    }
 }
 
 impl<'a, T> IntoIterator for &'a JoinList<T> {
@@ -209,33 +193,6 @@ impl<T> IntoIterator for JoinList<T> {
 mod tests {
     use super::*;
 
-    #[derive(Debug)]
-    struct E {
-        join: JoinSeq,
-    }
-    crate::impl_joined!(E);
-
-    /// A numbered entity put back lands by its join number; a new one goes last.
-    #[test]
-    fn put_back_keeps_the_join_order() {
-        let mut list = JoinList::default();
-        for _ in 0..3 {
-            list.push(E {
-                join: JoinSeq::UNJOINED,
-            });
-        }
-        let first = list.remove(0);
-        let first_seq = first.join;
-        list.put_back(first);
-        assert_eq!(list[0].join, first_seq, "back before the later joins");
-        list.put_back(E {
-            join: JoinSeq::UNJOINED,
-        });
-        let seqs: Vec<_> = list.iter().map(|e| e.join).collect();
-        assert!(seqs.windows(2).all(|w| w[0] < w[1]), "{seqs:?}");
-        assert_eq!(seqs.len(), 4);
-    }
-
     /// Whatever can change a list changes its stamp; only reading leaves it.
     #[test]
     fn a_stamp_holds_until_the_list_can_have_changed() {

crates/horizon-client/src/lan/guest.rs

@@ -173,10 +173,10 @@ pub struct Guest {
     /// Where the player respawns (a bed's spot; `ServerPlayer.respawnConfig`),
     /// None for the world spawn.
     pub spawn: Option<[f64; 3]>,
-    /// A block-resolved personal respawn point: its dimension, block, yaw,
-    /// pitch and whether it is forced, as the player's save keeps it
-    /// (`respawn`).
-    pub respawn_elsewhere: Option<(String, [i32; 3], f32, f32, bool)>,
+    /// A respawn point outside the Overworld (a respawn anchor, or one
+    /// `spawnpoint` set there): its dimension, block, yaw and whether it is
+    /// forced, as the player's save keeps it (`respawn`).
+    pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>,
     /// Pending ClientboundPlayerPositionPacket id; movement is ignored until
     /// the client accepts it (ServerGamePacketListenerImpl.awaitingPositionFromClient).
     pub awaiting_teleport: Option<(i32, [f64; 3])>,

crates/horizon-client/src/lan/import.rs

@@ -343,7 +343,7 @@ struct Kept {
     effects: Option<crate::effects::PlayerEffects>,
     game_mode: Option<(i32, bool, f32)>,
     position: Option<([f64; 3], [f64; 3], f32, f32, f32, bool, Option<[i32; 4]>)>,
-    spawn: Option<(Option<[f64; 3]>, Option<(String, [i32; 3], f32, f32, bool)>)>,
+    spawn: Option<(Option<[f64; 3]>, Option<(String, [i32; 3], f32, bool)>)>,
     recipes: Option<crate::recipe_book::Settings>,
     /// The body's values: its fall goes with the position, its air and fire with the
     /// health.

crates/horizon-client/src/lan/playerdata.rs

@@ -53,27 +53,6 @@ pub fn exists(world: &Path, uuid: u128) -> bool {
     path(world, uuid).is_file()
 }
 
-/// The key `ServerPlayer.addAdditionalSaveData` stores the `WardenSpawnTracker` under.
-pub const WARDEN_TRACKER_KEY: &str = "warden_spawn_tracker";
-
-/// Put a player's `warden_spawn_tracker` into the compound `store` writes from
-/// (`guest.saved`), so a save keeps it rather than the older one loaded with
-/// the file (the LAN owner's tracker lives in `Game`, `save_warden_tracker`).
-/// Other saved keys are left as they are; no tracker (not loaded yet) changes
-/// nothing.
-pub fn with_warden(guest: &mut Guest, tracker: Option<Tag>) -> &mut Guest {
-    let Some(tracker) = tracker else {
-        return guest;
-    };
-    let saved = guest
-        .saved
-        .get_or_insert_with(|| Tag::Compound(Default::default()));
-    if let Tag::Compound(map) = saved {
-        map.insert(WARDEN_TRACKER_KEY.into(), tracker);
-    }
-    guest
-}
-
 /// `PlayerDataStorage.load`: a guest's saved state, if they have been here
 /// before. The player's file, else its `.dat_old` (what a save cut off
 /// between its two renames leaves, `write_dat`).
@@ -672,42 +651,6 @@ mod tests {
         )
     }
 
-    /// #9965: the owner's warden warning level and cooldown reach the file on
-    /// a save, instead of the ones the file was loaded with.
-    #[test]
-    fn a_stored_warden_tracker_replaces_the_loaded_one() {
-        let mut g = guest();
-        g.saved = Some(Tag::compound(vec![
-            (
-                "warden_spawn_tracker",
-                Tag::compound(vec![
-                    ("warning_level", Tag::Int(2)),
-                    ("cooldown_ticks", Tag::Int(77)),
-                    ("ticks_since_last_warning", Tag::Int(5)),
-                ]),
-            ),
-            ("unrelated_key", Tag::Int(9)),
-        ]));
-        let tracker = crate::sculk::WardenSpawnTracker {
-            ticks_since_last_warning: 0,
-            warning_level: 3,
-            cooldown_ticks: 200,
-        };
-        with_warden(&mut g, Some(tracker.to_nbt()));
-        let (tag, _) = round_trip(&g);
-        let mut back = guest();
-        let mut level = Level::default();
-        level.read_player(&tag);
-        level.player_extra = Some(tag);
-        apply(&mut back, &level);
-        let saved = back.saved.as_ref().unwrap();
-        let read =
-            crate::sculk::WardenSpawnTracker::from_nbt(saved.get("warden_spawn_tracker").unwrap());
-        assert_eq!((read.warning_level, read.cooldown_ticks), (3, 200));
-        assert_eq!(read.ticks_since_last_warning, 0);
-        assert!(matches!(saved.get("unrelated_key"), Some(Tag::Int(9))));
-    }
-
     #[test]
     fn a_new_player_faces_the_world_spawn_angle() {
         let mut g = guest();

crates/horizon-client/src/mobs/anim.rs

@@ -771,26 +771,9 @@ fn swim(p: &mut Poses, pos: f32, h: &Hum) {
         lerp(amount, x, 0.3 * (pos * 0.333_333_34).mcos()),
     );
 }
-/// The player model's parts a [`BodyPose`] poses, in its order.
-pub const BODY_PARTS: [&str; 6] = [
-    "head",
-    "body",
-    "right_arm",
-    "left_arm",
-    "right_leg",
-    "left_leg",
-];
-
-/// A pose a higher layer lays over the player model's body after its vanilla animation (Horizon's
-/// emotes, docs/cosmetics.md), handed to the model through [`Mob::emote`]. The engine names no
-/// type of that layer (docs/layers.md); it downcasts its own back through [`std::any::Any`].
-pub trait BodyPose: std::any::Any + std::fmt::Debug + Send + Sync {
-    /// Poses the [`BODY_PARTS`] at `age` (the mob's ticks): `at_rest` holds each part before the
-    /// animation, `poses` as the animation left it; a part the model lacks holds the identity in
-    /// both and is not written back. False when it poses nothing at `age` (`poses` is then
-    /// ignored).
-    fn pose(&self, age: f32, at_rest: &[[f32; 9]; 6], poses: &mut [[f32; 9]; 6]) -> bool;
-}
+/// A pose laid over the player model's body after its vanilla animation, and the parts it poses:
+/// the hook's own types (`horizon_hooks::players`), kept here under their old path.
+pub use horizon_hooks::players::{BODY_PARTS, BodyPose};
 
 /// Apply the mob's model animation to `p` (at rest), then the pose laid over it, if any.
 pub fn setup(

crates/horizon-client/src/mobs/golem.rs

@@ -246,9 +246,7 @@ impl Goal for DefendVillage {
         // wider, as the box test is strict).
         let near = b.inflate(Vec3::new(1.0, 1.0, 1.0));
         // Villager.getPlayerReputation of the player this golem sees: the
-        // villager's gossips about that player's own UUID. The villagers come
-        // through the same `attackTargeting` (`forCombat().range(64)`), so the
-        // golem must see them too.
+        // villager's gossips about that player's own UUID.
         let bad = cx.w.others_near(near).any(|s| {
             s.species == Species::Villager
                 && s.alive
@@ -257,7 +255,6 @@ impl Goal for DefendVillage {
                     .is_some_and(|v| v.gossips.reputation(p.uuid) <= -100)
                 && b.contains(s.position)
                 && s.position.distance_squared(m.position) <= 64.0 * 64.0
-                && m.sees(cx.w, Who::Mob(s.id))
         });
         bad && m.sees(cx.w, Who::Player)
     }
@@ -325,39 +322,6 @@ impl Goal for MoveTowardsTarget {
         m.nav_stop();
     }
 }
-impl Mob {
-    /// `IronGolem.mobInteract`: the repair sound's pitch comes from the
-    /// golem's own random, not the level's.
-    pub fn golem_repair_pitch(&mut self) -> f32 {
-        1.0 + (self.random.next_float() - self.random.next_float()) * 0.2
-    }
-}
-/// `Level.isBrightOutside`: a fixed-time dimension (the End) is never bright.
-fn bright_outside(w: &MobWorld) -> bool {
-    w.daylight && !w.dimension_type.has_fixed_time
-}
-/// `OfferFlowerGoal.getNearestEntity`: the nearest of
-/// #candidate_for_iron_golem_gift (villagers and copper golems) in the golem's
-/// box inflated by (6, 2, 6) that passes `forNonCombat().range(6.0)`: within
-/// six blocks and in sight.
-fn gift_candidate(m: &mut Mob, w: &MobWorld) -> Option<u32> {
-    let area = m.bounds().inflate(Vec3::new(6.0, 2.0, 6.0));
-    let mut best: Option<(f64, u32)> = None;
-    for s in w.others_near(area) {
-        if !matches!(s.species, Species::Villager | Species::CopperGolem)
-            || !s.alive
-            || !area.intersects(s.bounds)
-        {
-            continue;
-        }
-        let d = s.position.distance_squared(m.position);
-        if d > 36.0 || best.is_some_and(|(b, _)| d >= b) || !m.sees(w, Who::Mob(s.id)) {
-            continue;
-        }
-        best = Some((d, s.id));
-    }
-    best.map(|(_, id)| id)
-}
 /// `OfferFlowerGoal`: by day, now and then, hold out a poppy to a villager.
 #[derive(Clone, Debug)]
 struct OfferFlower {
@@ -370,10 +334,16 @@ impl Goal for OfferFlower {
         MOVE | LOOK
     }
     fn can_use(&mut self, m: &mut Mob, cx: &mut Cx) -> bool {
-        if !bright_outside(cx.w) || m.random.next_int_bound(8000).unwrap_or(1) != 0 {
+        if !cx.w.daylight || m.random.next_int_bound(8000).unwrap_or(1) != 0 {
             return false;
         }
-        self.villager = gift_candidate(m, cx.w);
+        // The nearest of #candidate_for_iron_golem_gift: villagers and copper golems.
+        self.villager =
+            cx.w.nearby(m.position, 6.0, |s| {
+                matches!(s.species, Species::Villager | Species::CopperGolem) && s.alive
+            })
+            .map(|s| s.id)
+            .next();
         self.villager.is_some()
     }
     fn can_continue(&mut self, _: &mut Mob, _: &mut Cx) -> bool {
@@ -642,78 +612,6 @@ mod tests {
         Mob::new(id, Arc::new(kind), at, 0.0)
     }
 
-    fn villager_at(id: u32, at: Vec3) -> crate::mobs::Seen {
-        mob(id, Species::Villager, at).seen(None)
-    }
-
-    fn pick(w: &MobWorld) -> Option<u32> {
-        let mut golem = mob(1, Species::IronGolem, Vec3::new(0.5, 64.0, 0.5));
-        gift_candidate(&mut golem, w)
-    }
-
-    fn with_chunks(world: &mut crate::world::World, _: &horizon_world::registry::BlockRegistry) {
-        for cx in -2..2 {
-            for cz in -2..2 {
-                world.chunks.insert(
-                    (cx, cz),
-                    std::sync::Arc::new(crate::chunk::Chunk::empty(cx, cz)),
-                );
-            }
-        }
-    }
-
-    /// `OfferFlowerGoal`: the search box is the golem's box inflated by
-    /// (6, 2, 6) and the candidate must be within six blocks (Euclidean).
-    #[test]
-    fn the_poppy_goes_to_a_villager_in_the_box_within_six_blocks() {
-        let cases = [
-            (Vec3::new(4.5, 64.0, 0.5), true),
-            // 6.5 blocks on one axis: outside the range.
-            (Vec3::new(7.0, 64.0, 0.5), false),
-            // About 8.5 blocks away, inside the per-axis box of six.
-            (Vec3::new(6.0, 64.0, 6.0), false),
-            // Five blocks above: outside the box's two-block rise.
-            (Vec3::new(0.5, 69.0, 0.5), false),
-        ];
-        for (at, offered) in cases {
-            let villager = villager_at(2, at);
-            crate::mobs::world::with_built_test_world(&[villager], with_chunks, |w, _| {
-                assert_eq!(pick(w).is_some(), offered, "villager at {at:?}");
-            });
-        }
-    }
-
-    /// The candidate must also be in sight, and a fixed-time dimension is
-    /// never bright outside.
-    #[test]
-    fn the_poppy_needs_sight_and_a_dimension_with_a_day() {
-        let villager = villager_at(2, Vec3::new(4.5, 64.0, 0.5));
-        let wall = |world: &mut crate::world::World, r: &horizon_world::registry::BlockRegistry| {
-            with_chunks(world, r);
-            let stone = r.default_state("minecraft:stone").unwrap();
-            for y in 62..70 {
-                for z in -6..8 {
-                    world.set(2, y, z, stone).unwrap();
-                }
-            }
-        };
-        crate::mobs::world::with_built_test_world(std::slice::from_ref(&villager), wall, |w, _| {
-            assert_eq!(pick(w), None, "a villager behind a wall");
-        });
-        crate::mobs::world::with_built_test_world(&[villager], with_chunks, |w, _| {
-            assert!(bright_outside(w));
-            assert_eq!(pick(w), Some(2));
-            let mut end = w.clone();
-            end.dimension_type =
-                horizon_world::dimension_type::DimensionFacts::vanilla("minecraft:the_end")
-                    .unwrap();
-            assert!(!bright_outside(&end));
-            let mut night = w.clone();
-            night.daylight = false;
-            assert!(!bright_outside(&night));
-        });
-    }
-
     #[test]
     fn snow_trail_posts_block_place_with_golem_and_snow_state() {
         let ran = crate::mobs::world::with_built_test_world(

crates/horizon-client/src/mobs/shulker.rs

@@ -855,11 +855,9 @@ pub fn texture(m: &Mob) -> String {
         "red",
         "black",
     ];
-    // Shulker.getColor: the saved byte is signed; 16 and above are undyed, and
-    // DyeColor.byId sends a negative id to white (OutOfBoundsStrategy.ZERO).
-    match m.extra.color as i8 {
-        16.. => "entity/shulker/shulker".into(),
-        c => format!("entity/shulker/shulker_{}", COLORS[c.max(0) as usize]),
+    match COLORS.get(m.extra.color as usize) {
+        Some(c) => format!("entity/shulker/shulker_{c}"),
+        None => "entity/shulker/shulker".into(),
     }
 }
 /// `attachFace.getOpposite().getRotation()` by attach face: the open
@@ -1146,46 +1144,3 @@ mod tests {
         assert!((h - 1.0).abs() < 1e-9, "{h}");
     }
 }
-
-#[cfg(test)]
-mod saved_bytes_tests {
-    use super::*;
-
-    /// `Shulker.readAdditionalSaveData`: `AttachFace` is
-    /// `Direction.LEGACY_ID_CODEC` (`from3DDataValue` wraps the id through
-    /// `abs(id % 6)`), while `Peek` and `Color` are raw `getByteOr` bytes. The
-    /// load clamped all three to their setters' ranges instead.
-    #[test]
-    fn a_shulker_reads_its_face_and_lid_bytes_like_vanilla() {
-        use crate::entity_nbt::mob_from_nbt;
-        use horizon_world::nbt::Tag;
-        let mut kind = crate::mobs::sensor_scan_tests::kind();
-        let k = std::sync::Arc::make_mut(&mut kind);
-        k.id = "minecraft:shulker".into();
-        k.species = Species::Shulker;
-        let types = [("minecraft:shulker".into(), kind)].into();
-        let tag = Tag::compound([
-            ("id", Tag::String("minecraft:shulker".into())),
-            (
-                "Pos",
-                Tag::List(vec![
-                    Tag::Double(0.0f64.to_bits()),
-                    Tag::Double(64.0f64.to_bits()),
-                    Tag::Double(0.0f64.to_bits()),
-                ]),
-            ),
-            ("AttachFace", Tag::Byte(7)),
-            ("Peek", Tag::Byte(-1)),
-            ("Color", Tag::Byte(-1)),
-        ]);
-        let m = mob_from_nbt(&tag, &types, 1, None).unwrap();
-        assert_eq!(m.extra.variant3, 1, "abs(7 % 6) is up");
-        assert_eq!(m.extra.counter, -1, "the peek byte is kept");
-        assert_eq!(m.extra.color, 255, "the color byte is kept");
-        assert_eq!(
-            texture(&m),
-            "entity/shulker/shulker_white",
-            "DyeColor.byId(-1)"
-        );
-    }
-}

crates/horizon-client/src/mobs/spawn_selection.rs

@@ -21,12 +21,7 @@ use horizon_core::{
     random::RandomSource,
 };
 use serde_json::Value;
-use std::{
-    borrow::{Borrow, Cow},
-    collections::HashMap,
-    fs,
-    path::Path,
-};
+use std::{borrow::Cow, collections::HashMap, fs, path::Path};
 
 pub use crate::biome::{SpawnCost, parse_costs, parse_entries};
 
@@ -884,17 +879,13 @@ impl SpawnState {
     /// `NaturalSpawner.createState`: every non-persistent entity of a
     /// spawning category in a loaded chunk adds its biome's spawn charge, its
     /// category count and (for mobs) the local caps of the players near it.
-    pub fn new<'a, L: NaturalLevel, I>(
+    pub fn new<L: NaturalLevel>(
         l: &L,
         spawnable_chunks: i32,
         players: Vec<SpawnPlayer>,
-        entities: I,
+        entities: &[Counted],
         chunk_loaded: impl Fn(i32, i32) -> bool,
-    ) -> Self
-    where
-        I: IntoIterator,
-        I::Item: std::borrow::Borrow<Counted<'a>>,
-    {
+    ) -> Self {
         let mut state = Self {
             spawnable_chunks,
             counts: [0; 8],
@@ -907,7 +898,6 @@ impl SpawnState {
             last_checked: None,
         };
         for e in entities {
-            let e = e.borrow();
             if e.is_mob && e.persistent || e.category == Category::Misc {
                 continue;
             }
@@ -925,10 +915,6 @@ impl SpawnState {
         }
         state
     }
-    /// Reclaims the player buffer for reuse across passes.
-    pub fn into_players(self) -> Vec<SpawnPlayer> {
-        self.players
-    }
     fn add_charge(&mut self, pos: [i32; 3], charge: f64) {
         if charge != 0.0 {
             self.charges.push((pos, charge));

crates/horizon-client/src/motion.rs

@@ -2148,16 +2148,18 @@ impl MotionWorld<'_, '_, '_> {
         let gravity = living_motion::effective_gravity(self)?;
         self.player.velocity = fall_flying_movement(v, self.player.pitch, self.player.yaw, gravity);
         let movement = self.player.velocity;
+        let before = self.player.position;
         self.move_self(movement)?;
         // LivingEntity.handleFallFlyingCollisions: the fall-damage sound plays
         // on both sides (a glider's own travel is client-side, and the sound
         // must reach its own ears, #8906), only the server hurts, and it
-        // compares the horizontal speed before `updateFallFlyingMovement`
-        // with the delta `Entity.move` leaves (the collided axes zeroed).
+        // compares the delta before the move with the one after it, which
+        // `Entity.move` leaves as the movement it resolved. `move_entity` does
+        // not write that back, so the distance actually travelled stands in.
         if self.player.collision.horizontal {
-            let v = self.player.velocity;
-            let after_h = (v.x * v.x + v.z * v.z).sqrt();
-            let dmg = fly_into_wall_damage(move_h, after_h);
+            let travelled = self.player.position.subtract(before);
+            let new_h = (travelled.x * travelled.x + travelled.z * travelled.z).sqrt();
+            let dmg = fly_into_wall_damage(move_h, new_h);
             if dmg > 0.0 {
                 let first = self.player.events.len();
                 // getFallDamageSound((int) dmg)
@@ -3146,7 +3148,6 @@ mod tests {
         assert_eq!(fly_into_wall_damage(0.3, 0.0), 0.0);
         assert!((fly_into_wall_damage(0.5, 0.1) - 1.0).abs() < 1e-5);
         assert!((fly_into_wall_damage(1.2, 0.0) - 9.0).abs() < 1e-5);
-        assert!(fly_into_wall_damage(0.01, 0.0) < 0.0);
     }
 
     use super::*;
@@ -4194,16 +4195,17 @@ mod tests {
             health: &resources.health,
         };
         w.travel_fall_flying().unwrap();
-        let is_fall = |e: &_| {
-            matches!(
+        assert!(
+            w.player.events.iter().any(|e| matches!(
                 e,
-                MotionEvent::Fall(crate::landing::FallEvent::Sound { .. })
-            )
-        };
-        assert_eq!(w.player.events.iter().filter(|e| is_fall(e)).count(), 1);
-        // The sound must play only once on impact, not repeat on subsequent ticks (#12304):
-        w.travel_fall_flying().unwrap();
-        assert_eq!(w.player.events.iter().filter(|e| is_fall(e)).count(), 1);
+                MotionEvent::Fall(crate::landing::FallEvent::Sound {
+                    sound: crate::landing::SceneSound::SmallFall,
+                    ..
+                })
+            )),
+            "{:?}",
+            w.player.events
+        );
         assert!(
             !w.player
                 .hurt_log

crates/horizon-client/src/net.rs

@@ -149,8 +149,20 @@ pub struct Session {
     far: Arc<crate::lod_net::Inbox>,
     /// The recording running, if any.
     recorder: RecorderSlot,
+    /// This connection's number, new for each one ([`Session::serial`]).
+    serial: u64,
+}
+/// The next [`Session::serial`].
+static NEXT_SERIAL: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+fn next_serial() -> u64 {
+    NEXT_SERIAL.fetch_add(1, Ordering::Relaxed)
 }
 impl Session {
+    /// A number of its own for each connection, never 0: entity ids are per connection, so what
+    /// is kept by id goes when it changes (`horizon_hooks::players::PlayerModels::connection`).
+    pub fn serial(&self) -> u64 {
+        self.serial
+    }
     /// The negotiated wire release, once the connection has been established.
     pub fn server_version(&self) -> horizon_protocol::adapter::ServerVersion {
         self.writer.lock().unwrap().as_ref().map_or(
@@ -256,6 +268,7 @@ impl Session {
             debug: false,
             far: Arc::new(crate::lod_net::Inbox::default()),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         }
     }
     fn start(
@@ -333,6 +346,7 @@ impl Session {
             debug,
             far,
             recorder,
+            serial: next_serial(),
         }
     }
     /// Everything received since the last poll.
@@ -1829,6 +1843,7 @@ mod tests {
                 debug: false,
                 far: Arc::default(),
                 recorder: Arc::new(Mutex::new(None)),
+                serial: next_serial(),
             };
             let started = std::time::Instant::now();
             if explicit_disconnect {
@@ -1932,6 +1947,7 @@ mod tests {
             debug: false,
             far: Arc::default(),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         };
         let (thread_writer, thread_configuring, thread_recorder) = (
             session.writer.clone(),
@@ -2215,6 +2231,7 @@ mod tests {
             debug: false,
             far: Arc::default(),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         };
         let recorder = TestRecorder::default();
         session.start_recording(recorder.clone(), |_| {});

crates/horizon-client/src/save.rs

@@ -13,8 +13,6 @@
 //! game rules) is kept from the loaded files and written back unchanged.
 //! Worlds saved by older Horizon builds (`region/`, `DIM-1/`, `Player` in
 //! `level.dat`) are migrated on open.
-mod respawn;
-
 use crate::{
     Result,
     beehive::BeehiveExt,
@@ -3947,8 +3945,8 @@ pub struct Level {
     pub spawn: Option<[f64; 3]>,
     /// A respawn point resolved through its block when the player respawns
     /// (a bed, a respawn anchor, a forced point in any dimension):
-    /// dimension, block, yaw, pitch and `forced`.
-    pub respawn_elsewhere: Option<(String, [i32; 3], f32, f32, bool)>,
+    /// dimension, block, yaw and `forced`.
+    pub respawn_elsewhere: Option<(String, [i32; 3], f32, bool)>,
     pub position: Option<[f64; 3]>,
     pub rotation: [f32; 2],
     pub health: f32,
@@ -4294,8 +4292,20 @@ impl Level {
         if let Some(d) = text(p.get("Dimension")) {
             self.dimension = d;
         }
-        if let Some(respawn) = respawn::read(p) {
-            self.respawn_elsewhere = Some(respawn);
+        if let Some(respawn) = p.get("respawn")
+            && let Some(Tag::IntArray(pos)) = respawn.get("pos")
+            && pos.len() == 3
+        {
+            let dimension =
+                text(respawn.get("dimension")).unwrap_or_else(|| "minecraft:overworld".into());
+            let forced = number(respawn.get("forced")).is_some_and(|v| v != 0);
+            // Forced points, including Overworld ones, are validated through
+            // their blocks on death, just like beds and respawn anchors.
+            let yaw = match respawn.get("yaw") {
+                Some(Tag::Float(b)) => f32::from_bits(*b),
+                _ => 0.0,
+            };
+            self.respawn_elsewhere = Some((dimension, [pos[0], pos[1], pos[2]], yaw, forced));
         }
         let mut inventory = Vec::new();
         let mut inventory_components = HashMap::new();
@@ -4526,8 +4536,17 @@ impl Level {
             ));
         }
         // A respawn point other than the world spawn: an anchor elsewhere, or a bed.
-        if let Some(saved) = &self.respawn_elsewhere {
-            entries.push(("respawn", respawn::write(saved)));
+        if let Some((dimension, block, yaw, forced)) = &self.respawn_elsewhere {
+            let mut respawn = vec![
+                ("dimension", string(dimension)),
+                ("pos", Tag::IntArray(block.to_vec())),
+                ("yaw", Tag::Float(yaw.to_bits())),
+                ("pitch", Tag::Float(0f32.to_bits())),
+            ];
+            if *forced {
+                respawn.push(("forced", Tag::Byte(1)));
+            }
+            entries.push(("respawn", Tag::compound(respawn)));
         } else if let Some(s) = self.spawn {
             let block = [
                 s[0].floor() as i32,
@@ -7679,7 +7698,7 @@ mod tests {
         assert_eq!(back.spawn, Some([8.0, 64.0, 8.0]));
         assert_eq!(
             back.respawn_elsewhere,
-            Some(("minecraft:overworld".into(), [20, 70, 20], 0.0, 0.0, true))
+            Some(("minecraft:overworld".into(), [20, 70, 20], 0.0, true))
         );
         assert!(back.difficulty_locked);
         assert!(back.weather.raining);
@@ -7950,7 +7969,7 @@ mod tests {
         // A personal point coinciding with the world spawn must still keep
         // its forced flag and yaw, rather than turning into a world fallback.
         for pos in [[5, 64, 5], [0, 80, 0]] {
-            let point = ("minecraft:overworld".to_owned(), pos, 37.0, 0.0, true);
+            let point = ("minecraft:overworld".to_owned(), pos, 37.0, true);
             let level = Level {
                 respawn_elsewhere: Some(point.clone()),
                 ..Level::default()

crates/horizon-client/src/save/respawn.rs

@@ -1,104 +0,0 @@
-//! Personal respawn record leaves from Level, using its existing typed NBT rules.
-use super::{Tag, number, string, text};
-
-pub(super) fn read(p: &Tag) -> Option<(String, [i32; 3], f32, f32, bool)> {
-    let mut value = None;
-    if let Some(respawn) = p.get("respawn")
-        && let Some(Tag::IntArray(pos)) = respawn.get("pos")
-        && pos.len() == 3
-    {
-        let dimension =
-            text(respawn.get("dimension")).unwrap_or_else(|| "minecraft:overworld".into());
-        let forced = number(respawn.get("forced")).is_some_and(|v| v != 0);
-        // Forced points, including Overworld ones, are validated through
-        // their blocks on death, just like beds and respawn anchors.
-        let yaw = match respawn.get("yaw") {
-            Some(Tag::Float(b)) => f32::from_bits(*b),
-            _ => 0.0,
-        };
-        let pitch = match respawn.get("pitch") {
-            Some(Tag::Float(b)) => f32::from_bits(*b),
-            _ => 0.0,
-        };
-        value = Some((dimension, [pos[0], pos[1], pos[2]], yaw, pitch, forced));
-    }
-    value
-}
-
-pub(super) fn write(
-    (dimension, block, yaw, pitch, forced): &(String, [i32; 3], f32, f32, bool),
-) -> Tag {
-    let mut respawn = vec![
-        ("dimension", string(dimension)),
-        ("pos", Tag::IntArray(block.to_vec())),
-        ("yaw", Tag::Float(yaw.to_bits())),
-        ("pitch", Tag::Float(pitch.to_bits())),
-    ];
-    if *forced {
-        respawn.push(("forced", Tag::Byte(1)));
-    }
-    Tag::compound(respawn)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::{Level, read_dat, write_dat};
-    use super::*;
-
-    /// Added model control: old records without pitch retain the existing positive-zero default.
-    #[test]
-    fn personal_respawn_missing_pitch_loads_positive_zero() {
-        let tag = Tag::compound(vec![(
-            "respawn",
-            Tag::compound(vec![
-                ("dimension", string("minecraft:overworld")),
-                ("pos", Tag::IntArray(vec![12, 100, 12])),
-                ("yaw", Tag::Float(45f32.to_bits())),
-                ("forced", Tag::Byte(1)),
-            ]),
-        )]);
-        let mut level = Level::default();
-        level.read_player(&tag);
-        let (_, pos, yaw, pitch, forced) = level.respawn_elsewhere.unwrap();
-        assert_eq!(pos, [12, 100, 12]);
-        assert_eq!(yaw.to_bits(), 45f32.to_bits());
-        assert_eq!(pitch.to_bits(), 0.0f32.to_bits());
-        assert!(forced);
-    }
-
-    /// Added model/I/O control, separate from the connected runtime proof.
-    #[test]
-    fn personal_respawn_nonzero_pitch_survives_actual_player_file_write_and_read() {
-        let root = std::env::temp_dir().join(format!(
-            "horizon-personal-pitch-{}-{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        std::fs::create_dir_all(&root).unwrap();
-        let file = root.join("player.dat");
-        let original = Level {
-            respawn_elsewhere: Some((
-                "minecraft:overworld".into(),
-                [12, 100, 12],
-                45.0,
-                10.0,
-                true,
-            )),
-            ..Level::default()
-        };
-        write_dat(&file, original.player_tag()).unwrap();
-        let tag = read_dat(&file).expect("actual written NBT player file");
-        assert_eq!(
-            tag.get("respawn").unwrap().get("pitch"),
-            Some(&Tag::Float(10f32.to_bits()))
-        );
-        let mut loaded = Level::default();
-        loaded.read_player(&tag);
-        assert_eq!(loaded.respawn_elsewhere, original.respawn_elsewhere);
-        println!("actual saved personal respawn {:?}", tag.get("respawn"));
-        std::fs::remove_dir_all(root).unwrap();
-    }
-}

crates/horizon-client/src/stations.rs

@@ -852,24 +852,14 @@ fn parse_recipe_sources<'a>(
             "minecraft:stonecutting" => {
                 // A result count outside 1..=99 fails vanilla's codec: no recipe.
                 if let Some(count) = crate::crafting::template_count(&v["result"]) {
-                    let result = if v["result"].get("components").is_some() {
-                        match SmithingResult::parse(&v["result"], defaults)
-                            .and_then(|result| result.create())
-                        {
-                            Some(result) => result,
-                            None => continue,
-                        }
-                    } else {
-                        ItemStack::new(
-                            horizon_world::loot::recipe_result_id(&v["result"])
-                                .unwrap_or("minecraft:air"),
-                            count,
-                        )
-                    };
                     stonecutting.push(Stonecutting {
                         id,
                         input: ingredient(&v["ingredient"], items),
-                        result,
+                        result: ItemStack::new(
+                            horizon_world::loot::recipe_result_id(&v["result"])
+                                .unwrap_or("minecraft:air"),
+                            count,
+                        ),
                     });
                 }
             }
@@ -2226,27 +2216,6 @@ mod tests {
             vec!["minecraft:diamond_sword", "minecraft:diamond_axe"]
         );
     }
-    #[test]
-    fn stonecutter_result_keeps_its_components() {
-        let root = std::env::temp_dir().join(format!(
-            "horizon-stonecutter-components-{}",
-            std::process::id()
-        ));
-        let dir = root.join("data/minecraft/recipe");
-        fs::create_dir_all(&dir).unwrap();
-        fs::write(root.join("items.json"), r#"{"minecraft:stone":{}}"#).unwrap();
-        fs::write(
-            dir.join("cut.json"),
-            r#"{"type":"minecraft:stonecutting","ingredient":"minecraft:stone","result":{"id":"minecraft:stone","components":{"minecraft:custom_name":"Cut Stone"}}}"#,
-        )
-        .unwrap();
-        let recipes = StationRecipes::load(&root, &sample_items(), &PackOverlay::NONE);
-        let _ = fs::remove_dir_all(&root);
-        let listed = recipes.stonecutter(&ItemStack::new("minecraft:stone", 1));
-        assert_eq!(listed.len(), 1);
-        assert_eq!(listed[0].result.custom_name().as_deref(), Some("Cut Stone"));
-    }
-
     /// A world pack's stonecutting recipe takes its place in registration
     /// order (path, then namespace), not a place after the game's own.
     #[test]