From 6e9f218a14ae636856a29784f18ea8abbf7671e5 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 22:24:03 +0200 Subject: [PATCH 1/7] WIP: unfinished rendering-hud parity work, stopped for the night Uncommitted changes the agent had in progress when it was stopped; may not build or pass its harnesses yet. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/examples/hud_fixture.rs | 294 ++++++++------ .../examples/hud_fixture/kinds.rs | 9 + crates/horizon-client/src/attack_strength.rs | 65 +++ crates/horizon-client/src/hud_layout.rs | 373 +++++++++++++++--- .../horizonlab/parity/VanillaHudOracle.java | 87 +++- tools/hud_parity_cases.py | 46 +++ tools/test_hud_parity.py | 120 +++--- 7 files changed, 767 insertions(+), 227 deletions(-) create mode 100644 crates/horizon-client/examples/hud_fixture/kinds.rs create mode 100644 crates/horizon-client/src/attack_strength.rs create mode 100644 tools/hud_parity_cases.py diff --git a/crates/horizon-client/examples/hud_fixture.rs b/crates/horizon-client/examples/hud_fixture.rs index 3b3285baf..f02d7e1ff 100644 --- a/crates/horizon-client/examples/hud_fixture.rs +++ b/crates/horizon-client/examples/hud_fixture.rs @@ -1,11 +1,13 @@ -//! Headless transport for the HUD parity gate: replays each player state -//! through `horizon_client::hud_layout` (crosshair, hotbar, health, mount -//! hearts, experience bar and level) and writes the draw calls in vanilla's -//! GuiGraphicsExtractor terms. +//! Headless transport for the HUD parity gate: replays each case through +//! `horizon_client::hud_layout` and writes the draw calls in vanilla's +//! GuiGraphicsExtractor terms. Case kinds: `decorations` (crosshair, +//! hotbar, health, mount hearts, experience bar and level) and the +//! overlays handled in `kinds`. #![forbid(unsafe_code)] use horizon_client::{ hud::{HudAtlas, HudBatch}, - hud_layout::{self, GuiDraw, HealthHud, HealthInputs, HeartKind, HotbarInputs}, + hud_layout::{self, GuiDraw, HealthHud, HealthInputs, HeartKind, HotbarInputs, IDENTITY, Pose}, + text::Text, }; use serde_json::{Value, json}; use std::{ @@ -14,6 +16,8 @@ use std::{ path::PathBuf, }; type Result = std::result::Result>; +#[path = "hud_fixture/kinds.rs"] +mod kinds; fn main() -> Result<()> { let args: Vec = std::env::args_os().skip(1).map(PathBuf::from).collect(); @@ -27,117 +31,177 @@ fn main() -> Result<()> { .filter(|l| !l.is_empty()) { let c: Value = serde_json::from_str(line)?; - let int = |k: &str, d: i64| c[k].as_i64().unwrap_or(d) as i32; - let float = |k: &str, d: f64| c[k].as_f64().unwrap_or(d) as f32; - let (w, h) = (int("width", 0), int("height", 0)); - let mode = c["gameMode"].as_str().unwrap_or("survival"); - let survival = mode == "survival" || mode == "adventure"; - let indicator = c["attackIndicator"].as_str().unwrap_or("OFF"); - let partial = float("partial", 0.0); - let effects: Vec<&str> = c["effects"] - .as_array() - .into_iter() - .flatten() - .filter_map(Value::as_str) - .collect(); - let has = |e: &str| effects.contains(&e); - let mut draws = Vec::new(); - // Spectators only see it over a spectatable target (none here). - if c["crosshair"].as_bool().unwrap_or(false) && mode != "spectator" { - let attack = (indicator == "CROSSHAIR").then(|| float("attackScale", 1.0)); - draws.extend(hud_layout::crosshair(w, h, attack, false)); - } - if mode != "spectator" { - let pop = |v: &Value| v.as_f64().map(|p| p as f32 - partial); - let slots: [Option; 9] = std::array::from_fn(|i| pop(&c["slots"][i])); - let inputs = HotbarInputs { - selected: int("selected", 0), - right_handed: c["rightHanded"].as_bool().unwrap_or(true), - offhand: !c["offhand"].is_null(), - slots, - offhand_pop: pop(&c["offhand"]).unwrap_or(0.0), - attack: (indicator == "HOTBAR").then(|| float("attackScale", 1.0)), - }; - draws.extend(hud_layout::hotbar(w, h, &inputs)); - } - let vehicle_hearts = if c.get("vehicleMaxHealth").is_some() { - hud_layout::vehicle_max_hearts(float("vehicleMaxHealth", 0.0)) - } else { - 0 + let draws = match c["kind"].as_str().unwrap_or("decorations") { + "decorations" => decorations(&c, &atlas), + kind => kinds::run(kind, &c, &atlas), }; - if survival { - let millis = 1_000_000_000i64; - let mut hud = HealthHud { - last_health: int("lastHealth", 0), - display_health: int("displayHealth", 0), - last_health_time: millis - i64::from(int("lastHealthAgo", 0)), - health_blink_time: i64::from(int("healthBlinkTime", 0)), - }; - let kind = if has("minecraft:poison") { - HeartKind::Poisoned - } else if has("minecraft:wither") { - HeartKind::Withered - } else if c["frozen"].as_bool().unwrap_or(false) { - HeartKind::Frozen - } else { - HeartKind::Normal - }; - let inputs = HealthInputs { - tick: int("tick", 0), - millis, - health: float("health", 20.0), - max_health: float("maxHealth", 20.0), - absorption: float("absorption", 0.0), - armor: int("armor", 0), - food: int("food", 20), - saturation: float("saturation", 5.0), - kind, - regeneration: has("minecraft:regeneration"), - hunger: has("minecraft:hunger"), - hardcore: c["hardcore"].as_bool().unwrap_or(false), - damage_cooldown: int("damageCooldown", 0) > 0, - air: int("air", 300), - max_air: int("maxAir", 300), - under_water: c["underWater"].as_bool().unwrap_or(false), - vehicle_hearts, - }; - draws.extend(hud.layout(&inputs, w, h)); - } - if vehicle_hearts > 0 { - draws.extend(hud_layout::vehicle_health( - w, - h, - vehicle_hearts, - float("vehicleHealth", 0.0), - )); - } - let width = |s: &str| HudBatch::text_width(&atlas, s) as i32; - let level = if survival { int("xpLevel", 0) } else { 0 }; - draws.extend(hud_layout::experience( - w, - h, - float("xpProgress", 0.0), - level, - c["experienceBar"].as_bool().unwrap_or(false), - &width, - )); - let draws: Vec = draws - .iter() - .map(|d| match d { - GuiDraw::Sprite { sprite, x, y, w, h, region } => { - json!({"type": "sprite", "sprite": sprite, "x": x, "y": y, "w": w, "h": h, "region": region}) - } - GuiDraw::Text { text, x, y, color, shadow } => { - json!({"type": "text", "text": text, "x": x, "y": y, "color": *color as i32, "shadow": shadow}) - } - GuiDraw::Item { slot, x, y, seed, scale, pivot } => { - // translate(pivot) * scale * translate(-pivot) as a 3x2 matrix. - let m = [scale[0], 0.0, 0.0, scale[1], pivot[0] - pivot[0] * scale[0], pivot[1] - pivot[1] * scale[1]]; - json!({"type": "item", "slot": slot, "x": x, "y": y, "seed": seed, "matrix": m}) - } - }) - .collect(); - writeln!(out, "{}", json!({ "draws": draws }))?; + writeln!(out, "{}", json!({ "draws": encode(&draws) }))?; } Ok(()) } + +/// Style runs of styled text: `[text, rgb|null, bold, italic]` per run of +/// equally styled characters, or none for plain text. +fn runs(t: &Text) -> Option { + let mut out: Vec<(String, Option, bool, bool)> = Vec::new(); + let mut styled = false; + for (ch, s) in t.chars() { + let key = (s.color, s.is_bold(), s.is_italic()); + styled |= key != (None, false, false); + match out.last_mut() { + Some(last) if (last.1, last.2, last.3) == key => last.0.push(ch), + _ => out.push((ch.to_string(), key.0, key.1, key.2)), + } + } + styled.then(|| json!(out.into_iter().map(|r| json!([r.0, r.1, r.2, r.3])).collect::>())) +} + +fn encode(draws: &[GuiDraw]) -> Vec { + let mut stack: Vec = vec![IDENTITY]; + let mut out = Vec::new(); + for d in draws { + let pose = *stack.last().unwrap(); + let mut v = match d { + GuiDraw::Push(ops) => { + let mut m = pose; + for op in ops { + hud_layout::pose_apply(&mut m, *op); + } + stack.push(m); + continue; + } + GuiDraw::Pop => { + stack.pop(); + continue; + } + GuiDraw::Sprite { sprite, x, y, w, h, region, color } => { + json!({"type": "sprite", "sprite": sprite, "x": x, "y": y, "w": w, "h": h, "region": region, "color": *color as i32}) + } + GuiDraw::AtlasSprite { sprite, x, y, w, h, color } => { + json!({"type": "atlas", "sprite": sprite, "x": x, "y": y, "w": w, "h": h, "color": *color as i32}) + } + GuiDraw::Blit { texture, blend, x, y, w, h, uv, src, tex, color } => json!({ + "type": "blit", "texture": format!("textures/{texture}.png"), "pipeline": blend.pipeline(), + "x": x, "y": y, "w": w, "h": h, "uv": uv, "src": src, "tex": tex, "color": *color as i32}), + GuiDraw::Fill { x0, y0, x1, y1, color } => { + json!({"type": "fill", "x0": x0, "y0": y0, "x1": x1, "y1": y1, "color": *color as i32}) + } + GuiDraw::Text { text, x, y, color, shadow } => { + let mut v = json!({"type": "text", "text": text.plain(), "x": x, "y": y, "color": *color as i32, "shadow": shadow}); + if let Some(r) = runs(text) { + v["runs"] = r; + } + v + } + GuiDraw::Item { slot, x, y, seed, scale, pivot } => { + // translate(pivot) * scale * translate(-pivot) as a 3x2 matrix. + let m = [scale[0], 0.0, 0.0, scale[1], pivot[0] - pivot[0] * scale[0], pivot[1] - pivot[1] * scale[1]]; + out.push(json!({"type": "item", "slot": slot, "x": x, "y": y, "seed": seed, "matrix": m})); + continue; + } + }; + if pose != IDENTITY { + v["matrix"] = json!(pose); + } + out.push(v); + } + out +} + +fn decorations(c: &Value, atlas: &HudAtlas) -> Vec { + let int = |k: &str, d: i64| c[k].as_i64().unwrap_or(d) as i32; + let float = |k: &str, d: f64| c[k].as_f64().unwrap_or(d) as f32; + let (w, h) = (int("width", 0), int("height", 0)); + let mode = c["gameMode"].as_str().unwrap_or("survival"); + let survival = mode == "survival" || mode == "adventure"; + let indicator = c["attackIndicator"].as_str().unwrap_or("OFF"); + let partial = float("partial", 0.0); + let effects: Vec<&str> = c["effects"] + .as_array() + .into_iter() + .flatten() + .filter_map(Value::as_str) + .collect(); + let has = |e: &str| effects.contains(&e); + let mut draws = Vec::new(); + // Spectators only see it over a spectatable target (none here). + if c["crosshair"].as_bool().unwrap_or(false) && mode != "spectator" { + let attack = (indicator == "CROSSHAIR").then(|| float("attackScale", 1.0)); + draws.extend(hud_layout::crosshair(w, h, attack, false)); + } + if mode != "spectator" { + let pop = |v: &Value| v.as_f64().map(|p| p as f32 - partial); + let slots: [Option; 9] = std::array::from_fn(|i| pop(&c["slots"][i])); + let inputs = HotbarInputs { + selected: int("selected", 0), + right_handed: c["rightHanded"].as_bool().unwrap_or(true), + offhand: !c["offhand"].is_null(), + slots, + offhand_pop: pop(&c["offhand"]).unwrap_or(0.0), + attack: (indicator == "HOTBAR").then(|| float("attackScale", 1.0)), + }; + draws.extend(hud_layout::hotbar(w, h, &inputs)); + } + let vehicle_hearts = if c.get("vehicleMaxHealth").is_some() { + hud_layout::vehicle_max_hearts(float("vehicleMaxHealth", 0.0)) + } else { + 0 + }; + if survival { + let millis = 1_000_000_000i64; + let mut hud = HealthHud { + last_health: int("lastHealth", 0), + display_health: int("displayHealth", 0), + last_health_time: millis - i64::from(int("lastHealthAgo", 0)), + health_blink_time: i64::from(int("healthBlinkTime", 0)), + }; + let kind = if has("minecraft:poison") { + HeartKind::Poisoned + } else if has("minecraft:wither") { + HeartKind::Withered + } else if c["frozen"].as_bool().unwrap_or(false) { + HeartKind::Frozen + } else { + HeartKind::Normal + }; + let inputs = HealthInputs { + tick: int("tick", 0), + millis, + health: float("health", 20.0), + max_health: float("maxHealth", 20.0), + absorption: float("absorption", 0.0), + armor: int("armor", 0), + food: int("food", 20), + saturation: float("saturation", 5.0), + kind, + regeneration: has("minecraft:regeneration"), + hunger: has("minecraft:hunger"), + hardcore: c["hardcore"].as_bool().unwrap_or(false), + damage_cooldown: int("damageCooldown", 0) > 0, + air: int("air", 300), + max_air: int("maxAir", 300), + under_water: c["underWater"].as_bool().unwrap_or(false), + vehicle_hearts, + }; + draws.extend(hud.layout(&inputs, w, h)); + } + if vehicle_hearts > 0 { + draws.extend(hud_layout::vehicle_health( + w, + h, + vehicle_hearts, + float("vehicleHealth", 0.0), + )); + } + let width = |s: &str| HudBatch::text_width(atlas, s) as i32; + let level = if survival { int("xpLevel", 0) } else { 0 }; + draws.extend(hud_layout::experience( + w, + h, + float("xpProgress", 0.0), + level, + c["experienceBar"].as_bool().unwrap_or(false), + &width, + )); + draws +} diff --git a/crates/horizon-client/examples/hud_fixture/kinds.rs b/crates/horizon-client/examples/hud_fixture/kinds.rs new file mode 100644 index 000000000..fd8ea6ffe --- /dev/null +++ b/crates/horizon-client/examples/hud_fixture/kinds.rs @@ -0,0 +1,9 @@ +//! The overlay case kinds of the HUD parity fixture. +use horizon_client::{hud::HudAtlas, hud_layout::GuiDraw}; +use serde_json::Value; + +pub fn run(kind: &str, _c: &Value, _atlas: &HudAtlas) -> Vec { + match kind { + _ => Vec::new(), + } +} diff --git a/crates/horizon-client/src/attack_strength.rs b/crates/horizon-client/src/attack_strength.rs new file mode 100644 index 000000000..1862492bb --- /dev/null +++ b/crates/horizon-client/src/attack_strength.rs @@ -0,0 +1,65 @@ +//! The player's attack strength (`Player.attackStrengthTicker`, +//! `itemSwapTicker`, `getAttackStrengthScale`, `getCurrentItemAttackStrengthDelay`): +//! the charge the attack indicator shows and attacks scale their damage by. + +/// `Attributes.ATTACK_SPEED` base value. +pub const BASE_ATTACK_SPEED: f64 = 4.0; + +#[derive(Clone, Debug, Default, PartialEq)] +pub struct AttackStrength { + /// `LivingEntity.attackStrengthTicker`. + pub ticker: i32, + /// `LivingEntity.itemSwapTicker`. + pub swap_ticker: i32, + /// `Player.lastItemInMainHand`: the stack as last compared. + last_item: Option, +} +/// What `ItemStack.matches` / `isSameItem` compare of the main-hand stack: +/// its item id and the rest of the stack (count and components) as a key. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct HeldStack { + pub item: String, + pub rest: String, +} +/// `Player.getCurrentItemAttackStrengthDelay` for an ATTACK_SPEED value. +pub fn delay(attack_speed: f64) -> f32 { + (1.0 / attack_speed * 20.0) as f32 +} +impl AttackStrength { + /// The attack-strength part of `Player.tick`: both tickers advance, and a + /// main-hand change to a different item resets them + /// (`!ItemStack.matches` and `!ItemStack.isSameItem`). + pub fn tick(&mut self, main_hand: Option) { + self.ticker += 1; + self.swap_ticker += 1; + if self.last_item != main_hand { + let same_item = match (&self.last_item, &main_hand) { + (Some(a), Some(b)) => a.item == b.item, + (None, None) => true, + _ => false, + }; + if !same_item { + self.reset(); + } + self.last_item = main_hand; + } + } + /// `resetAttackStrengthTicker`: swinging at nothing, attacking or + /// stopping a block break. + pub fn reset(&mut self) { + self.ticker = 0; + self.swap_ticker = 0; + } + /// `resetOnlyAttackStrengthTicker` (`Player.onAttack`). + pub fn reset_attack(&mut self) { + self.ticker = 0; + } + /// `getAttackStrengthScale(a)` with the ATTACK_SPEED attribute value. + pub fn scale(&self, a: f32, attack_speed: f64) -> f32 { + ((self.ticker as f32 + a) / delay(attack_speed)).clamp(0.0, 1.0) + } + /// `getItemSwapScale(a)`. + pub fn swap_scale(&self, a: f32, attack_speed: f64) -> f32 { + ((self.swap_ticker as f32 + a) / delay(attack_speed)).clamp(0.0, 1.0) + } +} diff --git a/crates/horizon-client/src/hud_layout.rs b/crates/horizon-client/src/hud_layout.rs index 295a1a029..32c2a0e86 100644 --- a/crates/horizon-client/src/hud_layout.rs +++ b/crates/horizon-client/src/hud_layout.rs @@ -1,26 +1,110 @@ -//! Layout of vanilla's `Hud` decorations as draw calls (`GuiGraphicsExtractor` -//! blits and text): the hotbar with its selection, off-hand slot, items and +//! Layout of vanilla's `Hud` as draw calls (`GuiGraphicsExtractor` blits, +//! fills and text): the hotbar with its selection, off-hand slot, items and //! attack indicator, the crosshair, armour, hearts, food, air bubbles, mount -//! hearts and the experience bar and level. Computed without drawing so the -//! parity fixture can compare them with the vanilla client. +//! hearts, the experience and jump bars, status effect icons, camera +//! overlays, titles and the action bar, the selected item name, boss bars, +//! the scoreboard sidebar, chat and item decorations. Computed without +//! drawing so the parity fixture can compare them with the vanilla client. +use crate::{font::Font, text::Text}; use horizon_core::random::{LegacyRandom, RandomSource}; +use std::borrow::Cow; + +/// A `Matrix3x2fStack` operation applied to a copy of the current pose. +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum PoseOp { + Translate(f32, f32), + Scale(f32, f32), +} + +/// A JOML `Matrix3x2f` as `[m00, m01, m10, m11, m20, m21]`. +pub type Pose = [f32; 6]; +pub const IDENTITY: Pose = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]; + +/// Applies `op` like JOML's `translate` / `scale` (same float order). +pub fn pose_apply(m: &mut Pose, op: PoseOp) { + match op { + PoseOp::Translate(x, y) => { + m[4] += m[0] * x + m[2] * y; + m[5] += m[1] * x + m[3] * y; + } + PoseOp::Scale(x, y) => { + m[0] *= x; + m[1] *= x; + m[2] *= y; + m[3] *= y; + } + } +} + +/// The render pipeline of a texture blit. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Blend { + /// `GUI_TEXTURED`. + Textured, + /// `VIGNETTE`: `dst * (1 - src)`. + Vignette, + /// `GUI_NAUSEA_OVERLAY`: additive. + Nausea, +} +impl Blend { + pub fn pipeline(self) -> &'static str { + match self { + Blend::Textured => "pipeline/gui_textured", + Blend::Vignette => "pipeline/vignette", + Blend::Nausea => "pipeline/gui_nausea_overlay", + } + } +} /// One `GuiGraphicsExtractor` call. #[derive(Clone, Debug, PartialEq)] pub enum GuiDraw { - /// `blitSprite(sprite, x, y, w, h)`; `region` = (spriteW, spriteH, u, v) - /// for the partial overload. + /// `blitSprite(sprite, x, y, w, h, color)`; `region` = (spriteW, + /// spriteH, u, v) for the partial overload. Sprite { - sprite: &'static str, + sprite: Cow<'static, str>, x: i32, y: i32, w: i32, h: i32, region: Option<[i32; 4]>, + color: u32, + }, + /// `blitSprite(pipeline, TextureAtlasSprite, ...)` with a block atlas + /// sprite (the nether portal overlay). + AtlasSprite { + sprite: Cow<'static, str>, + x: i32, + y: i32, + w: i32, + h: i32, + color: u32, + }, + /// `blit(pipeline, texture, x, y, u, v, w, h, srcW, srcH, texW, texH, + /// color)`; `texture` is the path under `textures/` without `.png`. + Blit { + texture: Cow<'static, str>, + blend: Blend, + x: i32, + y: i32, + w: i32, + h: i32, + uv: [f32; 2], + src: [i32; 2], + tex: [i32; 2], + color: u32, + }, + /// `fill(x0, y0, x1, y1, color)` with the corners sorted. + Fill { + x0: i32, + y0: i32, + x1: i32, + y1: i32, + color: u32, }, /// `text(font, text, x, y, argb, dropShadow)`. Text { - text: String, + text: Text, x: i32, y: i32, color: u32, @@ -36,17 +120,130 @@ pub enum GuiDraw { scale: [f32; 2], pivot: [f32; 2], }, + /// `pose().pushMatrix()` followed by `ops`. + Push(Vec), + /// `pose().popMatrix()`. + Pop, } + +pub const WHITE: u32 = 0xFFFF_FFFF; + fn sprite(sprite: &'static str, x: i32, y: i32, w: i32, h: i32) -> GuiDraw { GuiDraw::Sprite { - sprite, + sprite: Cow::Borrowed(sprite), x, y, w, h, region: None, + color: WHITE, } } +fn region(sprite: &'static str, size: [i32; 2], uv: [i32; 2], at: [i32; 2], w: i32, h: i32) -> GuiDraw { + GuiDraw::Sprite { + sprite: Cow::Borrowed(sprite), + x: at[0], + y: at[1], + w, + h, + region: Some([size[0], size[1], uv[0], uv[1]]), + color: WHITE, + } +} +/// `graphics.fill`: the corners are sorted. +pub fn fill(x0: i32, y0: i32, x1: i32, y1: i32, color: u32) -> GuiDraw { + GuiDraw::Fill { + x0: x0.min(x1), + y0: y0.min(y1), + x1: x0.max(x1), + y1: y0.max(y1), + color, + } +} +/// `graphics.text`: dropped when fully transparent. +fn text(out: &mut Vec, text: Text, x: i32, y: i32, color: u32, shadow: bool) { + if color >> 24 != 0 { + out.push(GuiDraw::Text { + text, + x, + y, + color, + shadow, + }); + } +} +/// `graphics.textWithBackdrop` under `background` = `Options.getBackgroundColor(0)`. +fn text_with_backdrop(out: &mut Vec, t: Text, x: i32, y: i32, w: i32, color: u32, background: u32) { + if background != 0 { + out.push(fill(x - 2, y - 2, x + w + 2, y + 9 + 2, multiply(background, color))); + } + text(out, t, x, y, color, true); +} + +/// `Options.getBackgroundColor(float)`: `chat_only` = `backgroundForChatOnly`. +pub fn background_color(chat_only: bool, opacity: f64, default: f32) -> u32 { + let a = if chat_only { default } else { opacity as f32 }; + color_from_float(a, 0.0, 0.0, 0.0) +} + +/// `Mth.floor`. +pub fn floor(x: f32) -> i32 { + let i = x as i32; + if x < i as f32 { i - 1 } else { i } +} +/// `ARGB.as8BitChannel`. +pub fn as8(v: f32) -> u32 { + floor(v * 255.0) as u32 +} +/// `ARGB.white(float)`. +pub fn white(alpha: f32) -> u32 { + (as8(alpha) << 24) | 0xFF_FFFF +} +/// `ARGB.colorFromFloat`. +pub fn color_from_float(a: f32, r: f32, g: f32, b: f32) -> u32 { + argb(as8(a), as8(r), as8(g), as8(b)) +} +/// `ARGB.color(a, r, g, b)`. +pub fn argb(a: u32, r: u32, g: u32, b: u32) -> u32 { + (a & 255) << 24 | (r & 255) << 16 | (g & 255) << 8 | (b & 255) +} +/// `ARGB.multiply`. +pub fn multiply(l: u32, r: u32) -> u32 { + if l == WHITE { + return r; + } + if r == WHITE { + return l; + } + let c = |s: u32| ((l >> s) & 255) * ((r >> s) & 255) / 255; + argb(c(24), c(16), c(8), c(0)) +} +/// `Mth.lerpDiscrete`. +pub fn lerp_discrete(alpha: f32, p0: i32, p1: i32) -> i32 { + p0 + floor(alpha * (p1 - p0 - 1) as f32) + i32::from(alpha > 0.0) +} +/// `Mth.hsvToArgb`. +pub fn hsv_to_argb(hue: f32, saturation: f32, value: f32, alpha: u32) -> u32 { + let h = (hue * 6.0) as i32 % 6; + let f = hue * 6.0 - h as f32; + let p = value * (1.0 - saturation); + let q = value * (1.0 - f * saturation); + let t = value * (1.0 - (1.0 - f) * saturation); + let (r, g, b) = match h { + 0 => (value, t, p), + 1 => (q, value, p), + 2 => (p, value, t), + 3 => (p, q, value), + 4 => (t, p, value), + _ => (value, p, q), + }; + let c = |v: f32| ((v * 255.0) as i32).clamp(0, 255) as u32; + argb(alpha, c(r), c(g), c(b)) +} +/// `Font.width` of styled text. +pub fn width(font: &Font, t: &Text) -> i32 { + font.width_text(t) as i32 +} /// `Hud.extractItemHotbar` inputs. pub struct HotbarInputs { @@ -153,14 +350,14 @@ pub fn hotbar(w: i32, h: i32, i: &HotbarInputs) -> Vec { 18, 18, )); - out.push(GuiDraw::Sprite { - sprite: "hud/hotbar_attack_indicator_progress", - x, - y: y + 18 - progress, - w: 18, - h: progress, - region: Some([18, 18, 0, 18 - progress]), - }); + out.push(region( + "hud/hotbar_attack_indicator_progress", + [18, 18], + [0, 18 - progress], + [x, y + 18 - progress], + 18, + progress, + )); } out } @@ -183,14 +380,14 @@ pub fn crosshair(w: i32, h: i32, attack: Option, full: bool) -> Vec 0 { - out.push(GuiDraw::Sprite { - sprite: "hud/experience_bar_progress", - x: left, - y: top, - w: filled, - h: 5, - region: Some([182, 5, 0, 0]), - }); + out.push(region( + "hud/experience_bar_progress", + [182, 5], + [0, 0], + [left, top], + filled, + 5, + )); } } if level > 0 { @@ -227,21 +424,9 @@ pub fn experience( let x = (w - width(&text)) / 2; let y = h - 24 - 9 - 2; for (dx, dy) in [(1, 0), (-1, 0), (0, 1), (0, -1)] { - out.push(GuiDraw::Text { - text: text.clone(), - x: x + dx, - y: y + dy, - color: 0xFF00_0000, - shadow: false, - }); + self::text(&mut out, Text::literal(&text), x + dx, y + dy, 0xFF00_0000, false); } - out.push(GuiDraw::Text { - text, - x, - y, - color: 0xFF80_FF20, - shadow: false, - }); + self::text(&mut out, Text::literal(text), x, y, 0xFF80_FF20, false); } out } @@ -554,10 +739,14 @@ impl HealthHud { } } -/// Draws the sprite and text calls with the HUD batch; items are left to the -/// caller (they need the item renderer). +/// Draws the calls with the HUD batch under their poses; items are left to +/// the caller (they need the item renderer) and so are the vignette and +/// nausea blits (their blending needs the screen-effect pipeline). pub fn paint(batch: &mut crate::hud::HudBatch, atlas: &crate::hud::HudAtlas, draws: &[GuiDraw]) { + let mut stack = vec![IDENTITY]; for d in draws { + let start = batch.vertices.len(); + let pose = *stack.last().unwrap_or(&IDENTITY); match d { GuiDraw::Sprite { sprite, @@ -566,6 +755,7 @@ pub fn paint(batch: &mut crate::hud::HudBatch, atlas: &crate::hud::HudAtlas, dra w, h, region, + color, } => { let Some(mut r) = atlas.sprites.get(&format!("gui/sprites/{sprite}")).copied() else { @@ -580,7 +770,58 @@ pub fn paint(batch: &mut crate::hud::HudBatch, atlas: &crate::hud::HudAtlas, dra r.u0 = u0; r.v0 = v0; } - batch.rect_uv(*x as f32, *y as f32, *w as f32, *h as f32, r, u32::MAX); + batch.rect_uv(*x as f32, *y as f32, *w as f32, *h as f32, r, abgr(*color)); + } + GuiDraw::AtlasSprite { + sprite, + x, + y, + w, + h, + color, + } => { + batch.sprite_scaled(atlas, sprite, *x as f32, *y as f32, *w as f32, *h as f32, abgr(*color)); + } + GuiDraw::Blit { + texture, + blend: Blend::Textured, + x, + y, + w, + h, + uv, + src, + tex, + color, + } => { + let Some(mut r) = atlas.sprites.get(texture.as_ref()).copied() else { + continue; + }; + let (du, dv) = (r.u1 - r.u0, r.v1 - r.v0); + let u0 = r.u0 + du * uv[0] / tex[0] as f32; + let v0 = r.v0 + dv * uv[1] / tex[1] as f32; + r.u1 = r.u0 + du * (uv[0] + src[0] as f32) / tex[0] as f32; + r.v1 = r.v0 + dv * (uv[1] + src[1] as f32) / tex[1] as f32; + r.u0 = u0; + r.v0 = v0; + batch.rect_uv(*x as f32, *y as f32, *w as f32, *h as f32, r, abgr(*color)); + } + GuiDraw::Blit { .. } | GuiDraw::Item { .. } => {} + GuiDraw::Fill { + x0, + y0, + x1, + y1, + color, + } => { + batch.fill( + atlas, + *x0 as f32, + *y0 as f32, + (x1 - x0) as f32, + (y1 - y0) as f32, + abgr(*color), + ); } GuiDraw::Text { text, @@ -589,11 +830,35 @@ pub fn paint(batch: &mut crate::hud::HudBatch, atlas: &crate::hud::HudAtlas, dra color, shadow, } => { - let [a, r, g, b] = color.to_be_bytes(); - let rgba = crate::hud::rgba(r, g, b, a); - batch.text(atlas, text, *x as f32, *y as f32, rgba, *shadow); + batch.text_styled(atlas, text, *x as f32, *y as f32, abgr(*color), *shadow); + } + GuiDraw::Push(ops) => { + let mut m = pose; + for op in ops { + pose_apply(&mut m, *op); + } + stack.push(m); + } + GuiDraw::Pop => { + if stack.len() > 1 { + stack.pop(); + } + } + } + if pose != IDENTITY { + for v in &mut batch.vertices[start..] { + let [x, y] = v.pos; + v.pos = [ + pose[0] * x + pose[2] * y + pose[4], + pose[1] * x + pose[3] * y + pose[5], + ]; } - GuiDraw::Item { .. } => {} } } } + +/// An ARGB colour as the HUD batch's packed RGBA. +pub fn abgr(color: u32) -> u32 { + let [a, r, g, b] = color.to_be_bytes(); + crate::hud::rgba(r, g, b, a) +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java index 249c71f8d..01469ab40 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java @@ -56,6 +56,7 @@ public final class VanillaHudOracle { static Object unsafe; static Method allocate; static JsonObject c; + static Font FONT; static IdentityHashMap slots = new IdentityHashMap<>(); @SuppressWarnings("unchecked") @@ -134,6 +135,16 @@ public final class VanillaHudOracle { @Override public int guiHeight() { return i("height", 0); } @Override public Matrix3x2fStack pose() { return stack; } @Override public void nextStratum() { } + /** Adds the pose when it is not the identity. */ + JsonObject posed(JsonObject o, org.joml.Matrix3x2fc m) { + if (!m.equals(new Matrix3x2f())) { + var a = new JsonArray(); + for (float v : new float[] {m.m00(), m.m01(), m.m10(), m.m11(), m.m20(), m.m21()}) a.add(v); + o.add("matrix", a); + } + draws.add(o); + return o; + } void sprite(Identifier id, int x, int y, int w, int h, int[] region, int color) { var o = new JsonObject(); o.addProperty("type", "sprite"); @@ -145,20 +156,86 @@ public final class VanillaHudOracle { o.add("region", r); } o.addProperty("color", color); - draws.add(o); + posed(o, stack); } @Override public void blitSprite(RenderPipeline p, Identifier id, int x, int y, int w, int h, int color) { sprite(id, x, y, w, h, null, color); } @Override public void blitSprite(RenderPipeline p, Identifier id, int sw, int sh, int u, int v, int x, int y, int w, int h, int color) { sprite(id, x, y, w, h, new int[] {sw, sh, u, v}, color); } - @Override public void text(Font font, FormattedCharSequence str, int x, int y, int color, boolean shadow) { + @Override public void blitSprite(RenderPipeline p, net.minecraft.client.renderer.texture.TextureAtlasSprite s, int x, int y, int w, int h, int color) { + var o = new JsonObject(); + o.addProperty("type", "atlas"); + o.addProperty("sprite", s.contents().name().getPath()); + o.addProperty("x", x); o.addProperty("y", y); o.addProperty("w", w); o.addProperty("h", h); + o.addProperty("color", color); + posed(o, stack); + } + @Override public void blit(RenderPipeline p, Identifier texture, int x, int y, float u, float v, int w, int h, int srcW, int srcH, int texW, int texH, int color) { + var o = new JsonObject(); + o.addProperty("type", "blit"); + o.addProperty("texture", texture.getPath()); + o.addProperty("pipeline", p.getLocation().getPath()); + o.addProperty("x", x); o.addProperty("y", y); o.addProperty("w", w); o.addProperty("h", h); + var uv = new JsonArray(); uv.add(u); uv.add(v); o.add("uv", uv); + var src = new JsonArray(); src.add(srcW); src.add(srcH); o.add("src", src); + var tex = new JsonArray(); tex.add(texW); tex.add(texH); o.add("tex", tex); + o.addProperty("color", color); + posed(o, stack); + } + @Override public void fill(RenderPipeline p, int x0, int y0, int x1, int y1, int color) { + var o = new JsonObject(); + o.addProperty("type", "fill"); + o.addProperty("x0", Math.min(x0, x1)); o.addProperty("y0", Math.min(y0, y1)); + o.addProperty("x1", Math.max(x0, x1)); o.addProperty("y1", Math.max(y0, y1)); + o.addProperty("color", color); + posed(o, stack); + } + void text(FormattedCharSequence str, int x, int y, int color, boolean shadow, org.joml.Matrix3x2fc pose) { var o = new JsonObject(); o.addProperty("type", "text"); var sb = new StringBuilder(); - str.accept((index, style, cp) -> { sb.appendCodePoint(cp); return true; }); + var runs = new JsonArray(); + boolean[] styled = {false}; + str.accept((index, style, cp) -> { + sb.appendCodePoint(cp); + Integer rgb = style.getColor() == null ? null : style.getColor().getValue(); + boolean bold = style.isBold(), italic = style.isItalic(); + styled[0] |= rgb != null || bold || italic; + JsonArray last = runs.isEmpty() ? null : runs.get(runs.size() - 1).getAsJsonArray(); + if (last != null && java.util.Objects.equals(last.get(1).isJsonNull() ? null : last.get(1).getAsInt(), rgb) + && last.get(2).getAsBoolean() == bold && last.get(3).getAsBoolean() == italic) { + last.set(0, new JsonPrimitive(last.get(0).getAsString() + new String(Character.toChars(cp)))); + } else { + var run = new JsonArray(); + run.add(new String(Character.toChars(cp))); + if (rgb == null) run.add(JsonNull.INSTANCE); else run.add(rgb); + run.add(bold); run.add(italic); + runs.add(run); + } + return true; + }); o.addProperty("text", sb.toString()); o.addProperty("x", x); o.addProperty("y", y); o.addProperty("color", color); o.addProperty("shadow", shadow); - draws.add(o); + if (styled[0]) o.add("runs", runs); + posed(o, pose); + } + @Override public void text(Font font, FormattedCharSequence str, int x, int y, int color, boolean shadow) { + if (net.minecraft.util.ARGB.alpha(color) != 0) text(str, x, y, color, shadow, stack); + } + /** The chat's text collector: text at the parameters' pose and opacity. */ + @Override public net.minecraft.client.gui.ActiveTextCollector textRenderer(GuiGraphicsExtractor.HoveredTextEffects effects, java.util.function.Consumer consumer) { + var self = this; + return new net.minecraft.client.gui.ActiveTextCollector() { + Parameters parameters = new Parameters(new Matrix3x2f(stack), 1.0F, null); + @Override public Parameters defaultParameters() { return parameters; } + @Override public void defaultParameters(Parameters p) { parameters = p; } + @Override public void accept(net.minecraft.client.gui.TextAlignment alignment, int anchorX, int y, Parameters p, FormattedCharSequence text) { + int left = alignment.calculateLeft(anchorX, FONT, text); + if (net.minecraft.util.ARGB.as8BitChannel(p.opacity()) != 0) + self.text(text, left, y, net.minecraft.util.ARGB.white(p.opacity()), true, p.pose()); + } + @Override public void acceptScrolling(net.minecraft.network.chat.Component m, int cx, int l, int r, int t, int b, Parameters p) { } + }; } @Override public void item(LivingEntity owner, ItemStack stack, int x, int y, int seed) { var o = new JsonObject(); @@ -180,7 +257,7 @@ public final class VanillaHudOracle { unsafeField.setAccessible(true); unsafe = unsafeField.get(null); allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); - Font font = ParityFont.create(ParityFont.resources()); + Font font = FONT = ParityFont.create(ParityFont.resources()); Method hotbar = Hud.class.getDeclaredMethod("extractItemHotbar", GuiGraphicsExtractor.class, DeltaTracker.class); Method health = Hud.class.getDeclaredMethod("extractPlayerHealth", GuiGraphicsExtractor.class); Method vehicle = Hud.class.getDeclaredMethod("extractVehicleHealth", GuiGraphicsExtractor.class); diff --git a/tools/hud_parity_cases.py b/tools/hud_parity_cases.py new file mode 100644 index 000000000..df70e80e3 --- /dev/null +++ b/tools/hud_parity_cases.py @@ -0,0 +1,46 @@ +"""Random HUD cases for test_hud_parity.py, one generator per case kind.""" + +EFFECTS = ['minecraft:poison', 'minecraft:wither', 'minecraft:regeneration', 'minecraft:hunger', 'minecraft:speed'] + + +def decorations(rng, n): + max_health = rng.choice([20.0, 20.0, 6.0, 40.0, 33.0, 100.0]) + health = rng.choice([max_health, round(rng.uniform(0, max_health), 2), 1.0, 0.5, 3.0]) + air_max = 300 + under = rng.random() < 0.3 + air = rng.choice([air_max, rng.randint(-20, air_max), 0, 1, 29, 30, 31, 299]) if under or rng.random() < 0.2 else air_max + case = { + 'width': rng.choice([427, 320, 480, 640, 961]), 'height': rng.choice([240, 255, 270, 360, 501]), + 'gameMode': rng.choice(['survival'] * 5 + ['adventure', 'creative', 'spectator']), + 'crosshair': rng.random() < 0.7, + 'attackIndicator': rng.choice(['OFF', 'CROSSHAIR', 'HOTBAR']), + 'attackScale': rng.choice([1.0, round(rng.random(), 3), 0.0, 0.999]), + 'selected': rng.randint(0, 8), 'rightHanded': rng.random() < 0.7, + 'slots': [rng.choice([None, 0, 0, 3, 5]) if rng.random() < 0.6 else None for _ in range(9)], + 'offhand': rng.choice([None, None, 0, 4]), 'partial': round(rng.random(), 3), + 'health': health, 'maxHealth': max_health, + 'absorption': rng.choice([0.0, 0.0, 4.0, 3.5, 17.0, 40.0]), + 'armor': rng.choice([0, 0, 1, 7, 20, 13]), 'food': rng.randint(0, 20), + 'saturation': rng.choice([0.0, 5.0, 0.0]), + 'effects': [e for e in EFFECTS if rng.random() < 0.15], 'frozen': rng.random() < 0.08, + 'hardcore': rng.random() < 0.2, 'damageCooldown': rng.choice([0, 0, 10]), + 'air': air, 'maxAir': air_max, 'underWater': under, + 'tick': rng.randint(0, 100000), 'lastHealth': rng.randint(0, 40), 'displayHealth': rng.randint(0, 40), + 'lastHealthAgo': rng.choice([0, 500, 5000]), 'healthBlinkTime': 0, + 'xpProgress': rng.choice([0.0, round(rng.random(), 4), 0.999]), 'xpLevel': rng.choice([0, 1, 7, 30, 123, 4000]), + 'experienceBar': rng.random() < 0.8, + } + if case['damageCooldown'] and rng.random() < 0.5: + case['healthBlinkTime'] = case['tick'] + rng.randint(1, 20) + if rng.random() < 0.15: + case['vehicleMaxHealth'] = rng.choice([15.0, 30.0, 53.0, 100.0]) + case['vehicleHealth'] = round(rng.uniform(0, case['vehicleMaxHealth']), 1) + + + return case + + +# Generators by kind: (rng, index) -> case. Cases are drawn round-robin. +KINDS = { + 'decorations': decorations, +} diff --git a/tools/test_hud_parity.py b/tools/test_hud_parity.py index 2268d3621..d25c5525b 100644 --- a/tools/test_hud_parity.py +++ b/tools/test_hud_parity.py @@ -1,15 +1,23 @@ #!/usr/bin/env python3 -"""Compare the in-game HUD decorations with the vanilla 26.3 client's Hud. +"""Compare the in-game HUD with the vanilla 26.3 client's Hud. -The Java oracle (VanillaHudOracle) runs vanilla's own Hud.extractCrosshair, -extractItemHotbar, extractPlayerHealth, extractVehicleHealth, ExperienceBar -and ContextualBar.extractExperienceLevel on a stand-in client whose player -answers from the case, and records every blit (sprite, position, size, -partial region), text call (string, position, colour, shadow) and hotbar -item (slot, position, seed, pose). `examples/hud_fixture` lays out the same -state with `horizon_client::hud_layout`; the ordered call lists must agree. +The Java oracle (VanillaHudOracle) runs vanilla's own Hud methods +(extractCrosshair, extractItemHotbar, extractPlayerHealth, +extractVehicleHealth, extractEffects, extractCameraOverlays, extractTitle, +extractOverlayMessage, extractSelectedItemName, the scoreboard sidebar and +Hud.tick), BossHealthOverlay, ChatComponent, the contextual bars and +GuiGraphicsExtractor.itemDecorations on a stand-in client whose player +answers from the case, and records every blit (sprite, texture, position, +size, region, colour, pose), fill, text call (string, style runs, position, +colour, shadow, pose) and hotbar item (slot, position, seed, pose). +`examples/hud_fixture` lays out the same state with +`horizon_client::hud_layout`; the ordered call lists must agree. - test_hud_parity.py [--count N] [--detail N] +Each case has a `kind` (decorations, effects, title, selected, boss, +sidebar, jump, decor, overlays, chat); timing kinds replay events tick by +tick (title fades, the action bar, the selected item name, chat fades). + + test_hud_parity.py [--count N] [--detail N] [--kind K] """ import argparse import json @@ -20,62 +28,69 @@ import sys try: from . import lab, test_rust_parity as base, test_model_baking_parity as baking + from .hud_parity_cases import KINDS except ImportError: import lab, test_rust_parity as base, test_model_baking_parity as baking + from hud_parity_cases import KINDS PARITY = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity' -EFFECTS = ['minecraft:poison', 'minecraft:wither', 'minecraft:regeneration', 'minecraft:hunger', 'minecraft:speed'] -def cases(count): +def cases(count, kinds): rng = random.Random(0x485544) out = [] for n in range(count): - max_health = rng.choice([20.0, 20.0, 6.0, 40.0, 33.0, 100.0]) - health = rng.choice([max_health, round(rng.uniform(0, max_health), 2), 1.0, 0.5, 3.0]) - air_max = 300 - under = rng.random() < 0.3 - air = rng.choice([air_max, rng.randint(-20, air_max), 0, 1, 29, 30, 31, 299]) if under or rng.random() < 0.2 else air_max - case = { - 'width': rng.choice([427, 320, 480, 640, 961]), 'height': rng.choice([240, 255, 270, 360, 501]), - 'gameMode': rng.choice(['survival'] * 5 + ['adventure', 'creative', 'spectator']), - 'crosshair': rng.random() < 0.7, - 'attackIndicator': rng.choice(['OFF', 'CROSSHAIR', 'HOTBAR']), - 'attackScale': rng.choice([1.0, round(rng.random(), 3), 0.0, 0.999]), - 'selected': rng.randint(0, 8), 'rightHanded': rng.random() < 0.7, - 'slots': [rng.choice([None, 0, 0, 3, 5]) if rng.random() < 0.6 else None for _ in range(9)], - 'offhand': rng.choice([None, None, 0, 4]), 'partial': round(rng.random(), 3), - 'health': health, 'maxHealth': max_health, - 'absorption': rng.choice([0.0, 0.0, 4.0, 3.5, 17.0, 40.0]), - 'armor': rng.choice([0, 0, 1, 7, 20, 13]), 'food': rng.randint(0, 20), - 'saturation': rng.choice([0.0, 5.0, 0.0]), - 'effects': [e for e in EFFECTS if rng.random() < 0.15], 'frozen': rng.random() < 0.08, - 'hardcore': rng.random() < 0.2, 'damageCooldown': rng.choice([0, 0, 10]), - 'air': air, 'maxAir': air_max, 'underWater': under, - 'tick': rng.randint(0, 100000), 'lastHealth': rng.randint(0, 40), 'displayHealth': rng.randint(0, 40), - 'lastHealthAgo': rng.choice([0, 500, 5000]), 'healthBlinkTime': 0, - 'xpProgress': rng.choice([0.0, round(rng.random(), 4), 0.999]), 'xpLevel': rng.choice([0, 1, 7, 30, 123, 4000]), - 'experienceBar': rng.random() < 0.8, - } - if case['damageCooldown'] and rng.random() < 0.5: - case['healthBlinkTime'] = case['tick'] + rng.randint(1, 20) - if rng.random() < 0.15: - case['vehicleMaxHealth'] = rng.choice([15.0, 30.0, 53.0, 100.0]) - case['vehicleHealth'] = round(rng.uniform(0, case['vehicleMaxHealth']), 1) + kind = kinds[n % len(kinds)] + case = KINDS[kind](rng, n) + case['kind'] = kind out.append(case) return out +def close(p, q): + if (isinstance(p, float) or isinstance(q, float)) and not isinstance(p, bool) and not isinstance(q, bool): + return abs(p - q) <= 1e-4 * (1 + abs(p)) + return p == q + + +IDENTITY = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] + + +def normal(d): + d = dict(d) + d.setdefault('matrix', IDENTITY) + if d['type'] == 'sprite': + d.setdefault('region', None) + if d['type'] == 'text': + d.setdefault('runs', None) + return d + + +def same(x, y): + if x.keys() != y.keys(): + return False + for k in x: + p, q = x[k], y[k] + if isinstance(p, list) and isinstance(q, list): + if len(p) != len(q) or not all(close(a, b) for a, b in zip(p, q)): + return False + elif not close(p, q): + return False + return True + + def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--count', type=int, default=600) parser.add_argument('--detail', type=int, default=3) + parser.add_argument('--kind', action='append', choices=sorted(KINDS), help='only these kinds (repeatable)') args = parser.parse_args() + kinds = args.kind or list(KINDS) lock, jars, _ = base.verify_artifacts() libraries = baking.client_libraries() build = lab.LOCAL / 'rust-hud-parity'; build.mkdir(parents=True, exist_ok=True) resources = lab.LOCAL / 'horizon-client' / '26.3' - chosen = cases(args.count) + chosen = cases(args.count, kinds) inputs = build / 'inputs.jsonl'; inputs.write_text(''.join(json.dumps(c) + '\n' for c in chosen)) classes = build / 'classes'; classes.mkdir(exist_ok=True) dependencies = os.pathsep.join(map(str, [jars['client'], *libraries])) @@ -95,27 +110,26 @@ def main(): rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()] assert len(vanilla) == len(rust) errors, bad = [], [] + totals = {} for v, r in zip(vanilla, rust): + kind = v['case']['kind'] + totals.setdefault(kind, [0, 0])[1] += 1 if 'error' in v: errors.append(v['error']); continue - a = [{k: x for k, x in d.items() if k != 'color' or d['type'] == 'text'} for d in v['draws']] - for d in a: - if d['type'] == 'sprite': - d.setdefault('region', None) - b = r['draws'] - def same(x, y): - if x.keys() != y.keys(): - return False - return all( - (all(abs(p - q) <= 1e-4 * (1 + abs(p)) for p, q in zip(x[k], y[k])) if k == 'matrix' else x[k] == y[k]) for k in x) + a = [normal(d) for d in v['draws']] + b = [normal(d) for d in r['draws']] if len(a) != len(b) or not all(same(x, y) for x, y in zip(a, b)): first = next((i for i, (x, y) in enumerate(zip(a, b)) if not same(x, y)), min(len(a), len(b))) bad.append((v['case'], first, a[first:first + 2], b[first:first + 2], len(a), len(b))) + else: + totals[kind][0] += 1 for e in sorted(set(errors))[:5]: print('ORACLE ERROR', e) for case, i, a, b, la, lb in bad[:args.detail]: print('MISMATCH', json.dumps(case)) print(f' at call {i} ({la} vanilla, {lb} Horizon calls)\n vanilla {a}\n horizon {b}') + for kind, (ok, n) in sorted(totals.items()): + print(f' {kind:12} {ok}/{n}') print(f'{len(vanilla) - len(bad) - len(errors)}/{len(vanilla)} HUD states match; {len(errors)} oracle errors') if bad or errors: sys.exit(1) From b7cfe5578c7bab606b59d1c08d39640eec7e9077 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 13:05:05 +0200 Subject: [PATCH 2/7] Compare effect icons, titles, the action bar and the selected item name with vanilla's Hud The HUD harness now draws cases by kind. The oracle runs Hud.extractEffects, extractTitle, extractOverlayMessage and extractSelectedItemName after replaying setTitle/setTimes/setOverlayMessage and Hud.tick, and hud_overlays lays out the same state: MobEffectInstance ordering through Java's small-array TimSort, the title and action bar fades, the backdrop from the text background options and the tool highlight timer. The game draws its effect icons, titles and action bar through these layouts and now shows the selected item name. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/examples/hud_fixture.rs | 76 ++- .../examples/hud_fixture/kinds.rs | 112 ++++- crates/horizon-client/src/game.rs | 8 +- crates/horizon-client/src/game/commands.rs | 2 +- .../src/game/commands/text_commands.rs | 4 +- crates/horizon-client/src/game/jukebox.rs | 3 +- crates/horizon-client/src/game/potions.rs | 67 +-- crates/horizon-client/src/game/titles.rs | 216 +++------ crates/horizon-client/src/hud_layout.rs | 36 +- crates/horizon-client/src/hud_overlays.rs | 437 ++++++++++++++++++ crates/horizon-client/src/lib.rs | 1 + crates/horizon-client/src/settings.rs | 9 + .../horizonlab/parity/VanillaHudOracle.java | 114 ++++- tools/hud_parity_cases.py | 82 +++- 14 files changed, 916 insertions(+), 251 deletions(-) create mode 100644 crates/horizon-client/src/hud_overlays.rs diff --git a/crates/horizon-client/examples/hud_fixture.rs b/crates/horizon-client/examples/hud_fixture.rs index f02d7e1ff..46da5e0ad 100644 --- a/crates/horizon-client/examples/hud_fixture.rs +++ b/crates/horizon-client/examples/hud_fixture.rs @@ -7,6 +7,7 @@ use horizon_client::{ hud::{HudAtlas, HudBatch}, hud_layout::{self, GuiDraw, HealthHud, HealthInputs, HeartKind, HotbarInputs, IDENTITY, Pose}, + lang, text::Text, }; use serde_json::{Value, json}; @@ -25,6 +26,7 @@ fn main() -> Result<()> { return Err("usage: hud_fixture RESOURCES INPUTS OUTPUT".into()); }; let atlas = HudAtlas::build(root)?; + lang::set(lang::Language::load(&[root], lang::DEFAULT)); let mut out = BufWriter::new(fs::File::create(output)?); for line in fs::read_to_string(inputs)? .lines() @@ -53,7 +55,13 @@ fn runs(t: &Text) -> Option { _ => out.push((ch.to_string(), key.0, key.1, key.2)), } } - styled.then(|| json!(out.into_iter().map(|r| json!([r.0, r.1, r.2, r.3])).collect::>())) + styled.then(|| { + json!( + out.into_iter() + .map(|r| json!([r.0, r.1, r.2, r.3])) + .collect::>() + ) + }) } fn encode(draws: &[GuiDraw]) -> Vec { @@ -74,28 +82,80 @@ fn encode(draws: &[GuiDraw]) -> Vec { stack.pop(); continue; } - GuiDraw::Sprite { sprite, x, y, w, h, region, color } => { + GuiDraw::Sprite { + sprite, + x, + y, + w, + h, + region, + color, + } => { json!({"type": "sprite", "sprite": sprite, "x": x, "y": y, "w": w, "h": h, "region": region, "color": *color as i32}) } - GuiDraw::AtlasSprite { sprite, x, y, w, h, color } => { + GuiDraw::AtlasSprite { + sprite, + x, + y, + w, + h, + color, + } => { json!({"type": "atlas", "sprite": sprite, "x": x, "y": y, "w": w, "h": h, "color": *color as i32}) } - GuiDraw::Blit { texture, blend, x, y, w, h, uv, src, tex, color } => json!({ + GuiDraw::Blit { + texture, + blend, + x, + y, + w, + h, + uv, + src, + tex, + color, + } => json!({ "type": "blit", "texture": format!("textures/{texture}.png"), "pipeline": blend.pipeline(), "x": x, "y": y, "w": w, "h": h, "uv": uv, "src": src, "tex": tex, "color": *color as i32}), - GuiDraw::Fill { x0, y0, x1, y1, color } => { + GuiDraw::Fill { + x0, + y0, + x1, + y1, + color, + } => { json!({"type": "fill", "x0": x0, "y0": y0, "x1": x1, "y1": y1, "color": *color as i32}) } - GuiDraw::Text { text, x, y, color, shadow } => { + GuiDraw::Text { + text, + x, + y, + color, + shadow, + } => { let mut v = json!({"type": "text", "text": text.plain(), "x": x, "y": y, "color": *color as i32, "shadow": shadow}); if let Some(r) = runs(text) { v["runs"] = r; } v } - GuiDraw::Item { slot, x, y, seed, scale, pivot } => { + GuiDraw::Item { + slot, + x, + y, + seed, + scale, + pivot, + } => { // translate(pivot) * scale * translate(-pivot) as a 3x2 matrix. - let m = [scale[0], 0.0, 0.0, scale[1], pivot[0] - pivot[0] * scale[0], pivot[1] - pivot[1] * scale[1]]; + let m = [ + scale[0], + 0.0, + 0.0, + scale[1], + pivot[0] - pivot[0] * scale[0], + pivot[1] - pivot[1] * scale[1], + ]; out.push(json!({"type": "item", "slot": slot, "x": x, "y": y, "seed": seed, "matrix": m})); continue; } diff --git a/crates/horizon-client/examples/hud_fixture/kinds.rs b/crates/horizon-client/examples/hud_fixture/kinds.rs index fd8ea6ffe..52abd73a0 100644 --- a/crates/horizon-client/examples/hud_fixture/kinds.rs +++ b/crates/horizon-client/examples/hud_fixture/kinds.rs @@ -1,9 +1,117 @@ //! The overlay case kinds of the HUD parity fixture. -use horizon_client::{hud::HudAtlas, hud_layout::GuiDraw}; +use horizon_client::{ + brewing, component, + hud::HudAtlas, + hud_layout::{self, GuiDraw}, + hud_overlays::{self, EffectIcon, HeldName, Titles, ToolHighlight}, + text::{self, Text}, +}; use serde_json::Value; -pub fn run(kind: &str, _c: &Value, _atlas: &HudAtlas) -> Vec { +fn int(c: &Value, k: &str, d: i64) -> i32 { + c[k].as_i64().unwrap_or(d) as i32 +} +fn float(c: &Value, k: &str, d: f64) -> f32 { + c[k].as_f64().unwrap_or(d) as f32 +} +/// A text component in its JSON form. +fn comp(v: &Value) -> Text { + component::to_text(v, &mut |s| Text::literal(s)) +} +/// `Options.getBackgroundColor(0.0F)` from the case's text background options. +fn background(c: &Value) -> u32 { + hud_layout::background_color( + c["chatOnly"].as_bool().unwrap_or(true), + c["textOpacity"].as_f64().unwrap_or(0.5), + 0.0, + ) +} + +pub fn run(kind: &str, c: &Value, atlas: &HudAtlas) -> Vec { + let (w, h) = (int(c, "width", 0), int(c, "height", 0)); match kind { + "effects" => effects(c, w), + "title" => title(c, w, h, atlas), + "selected" => selected(c, w, h, atlas), _ => Vec::new(), } } + +fn effects(c: &Value, w: i32) -> Vec { + let icons: Vec = c["active"] + .as_array() + .into_iter() + .flatten() + .map(|e| { + let id = e["id"] + .as_str() + .unwrap_or("") + .trim_start_matches("minecraft:"); + let def = brewing::effect(id).expect("effect"); + EffectIcon { + id: id.to_owned(), + beneficial: def.category == brewing::Category::Beneficial, + color: def.color as i32, + ambient: e["ambient"].as_bool().unwrap_or(false), + duration: e["duration"].as_i64().unwrap_or(0) as i32, + show_icon: e["icon"].as_bool().unwrap_or(true), + } + }) + .collect(); + hud_overlays::effects(w, c["demo"].as_bool().unwrap_or(false), &icons) +} + +/// Replays `Hud.setTitle` / `setSubtitle` / `setTimes` / `clearTitles` / +/// `resetTitleTimes` / `setOverlayMessage` and ticks, then extracts the +/// action bar and the title. +fn title(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { + let mut t = Titles::default(); + for op in c["ops"].as_array().into_iter().flatten() { + let n = |i: usize| op[i].as_i64().unwrap_or(0) as i32; + match op[0].as_str().unwrap_or("") { + "title" => t.set_title(comp(&op[1])), + "subtitle" => t.set_subtitle(comp(&op[1])), + "times" => t.set_times(n(1), n(2), n(3)), + "clear" => t.clear(), + "reset" => t.reset_times(), + "overlay" => t.set_overlay(comp(&op[1]), op[2].as_bool().unwrap_or(false)), + "tick" => { + for _ in 0..n(1) { + t.tick(); + } + } + other => panic!("unknown title op {other}"), + } + } + let partial = float(c, "partial", 0.0); + let bg = background(c); + let mut out = t.overlay_message(w, h, partial, &atlas.font, bg); + out.extend(t.title(w, h, partial, &atlas.font, bg)); + out +} + +/// Ticks `toolHighlightTimer` through the selected stacks, then extracts the name. +fn selected(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { + let mut highlight = ToolHighlight::default(); + let time = c["displayTime"].as_f64().unwrap_or(1.0); + for step in c["steps"].as_array().into_iter().flatten() { + let held = (!step.is_null()).then(|| { + let custom = &step["custom"]; + HeldName { + item: step["item"].as_str().unwrap_or("").to_owned(), + hover_name: if custom.is_null() { + Text::translate(step["key"].as_str().unwrap_or(""), &[]) + } else { + comp(custom) + }, + rarity_color: text::named_color(step["rarity"].as_str().unwrap_or("white")) + .unwrap_or(0xFFFFFF), + custom_name: !custom.is_null(), + } + }); + highlight.tick(held, time); + } + let mode = c["gameMode"].as_str().unwrap_or("survival"); + let can_hurt = mode == "survival" || mode == "adventure"; + highlight.draw(w, h, can_hurt, &atlas.font, background(c)) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 667e7d911..5a1608282 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -634,6 +634,8 @@ struct Game<'a> { /// The source of a command run through /execute (the player otherwise). command_source: Option, titles: titles::Titles, + /// `Hud.toolHighlightTimer`: the selected item name. + tool_highlight: horizon_client::hud_overlays::ToolHighlight, applied_modifiers: Vec<(String, String)>, experience: Experience, orbs: Vec, @@ -2695,7 +2697,7 @@ impl Game<'_> { self.tick_effects(); self.tick_burning(); self.tick_using(); - self.titles.tick(); + self.tick_hud(); if running { self.tick_paintings(); self.tick_item_frames(); @@ -3000,6 +3002,9 @@ impl Game<'_> { let draws = self.health_hud.layout(&inputs, wi, hi); hud_layout::paint(&mut batch, atlas, &draws); } + if !spectator { + self.draw_selected_name(&mut batch, !self.creative); + } let atlas = &self.res.atlas; if self.debug { let p = self @@ -8036,6 +8041,7 @@ pub fn run() -> Result<()> { shield_cooldown: 0, command_source: None, titles: Default::default(), + tool_highlight: Default::default(), applied_modifiers: Vec::new(), experience: Experience::default(), orbs: Vec::new(), diff --git a/crates/horizon-client/src/game/commands.rs b/crates/horizon-client/src/game/commands.rs index 9dfed52ea..2b50bf260 100644 --- a/crates/horizon-client/src/game/commands.rs +++ b/crates/horizon-client/src/game/commands.rs @@ -687,7 +687,7 @@ impl Game<'_> { .append("]") .with_color(color) } - fn item_rarity(&self, item: &str) -> String { + pub(super) fn item_rarity(&self, item: &str) -> String { static RARITY: std::sync::OnceLock> = std::sync::OnceLock::new(); let map = RARITY.get_or_init(|| { diff --git a/crates/horizon-client/src/game/commands/text_commands.rs b/crates/horizon-client/src/game/commands/text_commands.rs index 12cb54603..e99e01e32 100644 --- a/crates/horizon-client/src/game/commands/text_commands.rs +++ b/crates/horizon-client/src/game/commands/text_commands.rs @@ -67,10 +67,10 @@ impl Game<'_> { } else { let text = self.component_arg(ctx, "title")?; if ctx.has("subtitle") { - self.titles.subtitle = Some(text); + self.titles.set_subtitle(text); "show.subtitle" } else if ctx.has("actionbar") { - self.titles.set_overlay(text); + self.titles.set_overlay(text, false); "show.actionbar" } else { self.titles.set_title(text); diff --git a/crates/horizon-client/src/game/jukebox.rs b/crates/horizon-client/src/game/jukebox.rs index f721e2352..c4f595a3a 100644 --- a/crates/horizon-client/src/game/jukebox.rs +++ b/crates/horizon-client/src/game/jukebox.rs @@ -104,8 +104,7 @@ impl Game<'_> { let description = horizon_client::component::to_text(&s.description, &mut |k| Text::literal(k)); self.titles - .set_overlay(Text::translate("record.nowPlaying", &[description])); - self.titles.overlay_animated = true; + .set_overlay(Text::translate("record.nowPlaying", &[description]), true); self.update_song_volumes(); } fn stop_song(&mut self, pos: [i32; 3]) { diff --git a/crates/horizon-client/src/game/potions.rs b/crates/horizon-client/src/game/potions.rs index fd5e30b34..ba7c10846 100644 --- a/crates/horizon-client/src/game/potions.rs +++ b/crates/horizon-client/src/game/potions.rs @@ -6,7 +6,8 @@ use super::{Game, Screen}; use horizon_client::{ brewing, effects::{EffectAction, EffectInstance, PlayerEffects}, - hud::{HudBatch, rgba}, + hud::HudBatch, + hud_layout, hud_overlays, items::ItemStack, }; use horizon_core::{geometry::Vec3, random::RandomSource}; @@ -542,52 +543,26 @@ impl Game<'_> { if self.screen != Screen::Playing || self.potions.effects.list.is_empty() { return; } - let mut list: Vec<&EffectInstance> = self.potions.effects.list.iter().collect(); - let color = |e: &EffectInstance| brewing::effect(e.id).map_or(0, |d| d.color); - list.sort_by(|a, b| { - (a.ambient, a.duration == -1, a.duration, color(a)) - .cmp(&(b.ambient, b.duration == -1, b.duration, color(b))) - .reverse() - }); - let (mut good, mut bad) = (0, 0); - let atlas = &self.res.atlas; - for e in list { - let beneficial = - brewing::effect(e.id).is_some_and(|d| d.category == brewing::Category::Beneficial); - let mut x = batch.width; - let mut y = 1.0; - if beneficial { - good += 1; - x -= 25.0 * good as f32; - } else { - bad += 1; - x -= 25.0 * bad as f32; - y += 26.0; - } - let mut alpha = 1.0f32; - if e.ambient { - batch.sprite(atlas, "gui/sprites/hud/effect_background_ambient", x, y); - } else { - batch.sprite(atlas, "gui/sprites/hud/effect_background", x, y); - if e.duration != -1 && e.duration <= 200 { - let d = e.duration as f32; - let used = 10.0 - (e.duration / 20) as f32; - alpha = ((d / 10.0 / 5.0 * 0.5).clamp(0.0, 0.5) - + (d * std::f32::consts::PI / 5.0).cos() - * (used / 10.0 * 0.25).clamp(0.0, 0.25)) - .clamp(0.0, 1.0); + let icons: Vec = self + .potions + .effects + .list + .iter() + .map(|e| { + let def = brewing::effect(e.id); + hud_overlays::EffectIcon { + id: e.id.to_owned(), + beneficial: def.is_some_and(|d| d.category == brewing::Category::Beneficial), + color: def.map_or(0, |d| d.color as i32), + ambient: e.ambient, + duration: e.duration, + // Horizon keeps no showIcon flag: every effect shows its icon. + show_icon: true, } - } - batch.sprite_scaled( - atlas, - &format!("mob_effect/{}", e.id), - x + 3.0, - y + 3.0, - 18.0, - 18.0, - rgba(255, 255, 255, (alpha * 255.0) as u8), - ); - } + }) + .collect(); + let draws = hud_overlays::effects(batch.width as i32, false, &icons); + hud_layout::paint(batch, &self.res.atlas, &draws); } /// Effects saved in level.dat (`Player.active_effects`). pub(super) fn restore_effects(&mut self) { diff --git a/crates/horizon-client/src/game/titles.rs b/crates/horizon-client/src/game/titles.rs index 57fe9dbd5..89e50c0d0 100644 --- a/crates/horizon-client/src/game/titles.rs +++ b/crates/horizon-client/src/game/titles.rs @@ -1,169 +1,69 @@ -//! Titles, subtitles and the action bar (`Gui.setTitle`, `setSubtitle`, -//! `setTimes`, `setOverlayMessage`, `extractTitle`, `extractOverlayMessage`). +//! Titles, the action bar and the selected item name: the state and layout +//! live in `hud_overlays` (`Titles`, `ToolHighlight`); this feeds and draws them. use super::Game; +pub(super) use horizon_client::hud_overlays::Titles; use horizon_client::{ - hud::{HudBatch, rgba}, - text::Text, + hud::HudBatch, + hud_layout, + hud_overlays::HeldName, + text::{self, Text}, }; -pub(super) struct Titles { - pub title: Option, - pub subtitle: Option, - pub time: i32, - pub fade_in: i32, - pub stay: i32, - pub fade_out: i32, - pub overlay: Option, - pub overlay_time: i32, - /// `animateOverlayMessageColor`: the "Now Playing" rainbow. - pub overlay_animated: bool, -} -impl Default for Titles { - fn default() -> Self { - Self { - title: None, - subtitle: None, - time: 0, - fade_in: 10, - stay: 70, - fade_out: 20, - overlay: None, - overlay_time: 0, - overlay_animated: false, - } - } -} -impl Titles { - pub fn set_title(&mut self, title: Text) { - self.title = Some(title); - self.time = self.fade_in + self.stay + self.fade_out; - } - pub fn set_times(&mut self, fade_in: i32, stay: i32, fade_out: i32) { - if fade_in >= 0 { - self.fade_in = fade_in; - } - if stay >= 0 { - self.stay = stay; - } - if fade_out >= 0 { - self.fade_out = fade_out; - } - if self.time > 0 { - self.time = self.fade_in + self.stay + self.fade_out; - } - } - pub fn clear(&mut self) { - self.title = None; - self.subtitle = None; - self.time = 0; - } - pub fn reset_times(&mut self) { - (self.fade_in, self.stay, self.fade_out) = (10, 70, 20); - } - pub fn set_overlay(&mut self, text: Text) { - self.overlay = Some(text); - self.overlay_time = 60; - self.overlay_animated = false; - } - /// Gui.tick. - pub fn tick(&mut self) { - if self.overlay_time > 0 { - self.overlay_time -= 1; - } - if self.time > 0 { - self.time -= 1; - if self.time <= 0 { - self.title = None; - self.subtitle = None; - } - } - } -} impl Game<'_> { + /// `Hud.extractOverlayMessage` and `extractTitle`. pub(super) fn draw_titles(&self, batch: &mut HudBatch) { - let t = &self.titles; + let (w, h) = (batch.width as i32, batch.height as i32); let partial = self.clock.fraction() as f32; - let atlas = &self.res.atlas; - let (w, h) = (batch.width, batch.height); - if let Some(text) = &t.overlay - && t.overlay_time > 0 - { - let ticks = t.overlay_time as f32 - partial; - let alpha = ((ticks * 255.0 / 20.0) as i32).min(255); - if alpha > 0 { - let width = atlas.font.width_text(text); - let color = if t.overlay_animated { - let [r, g, b] = hsv_to_rgb(ticks / 50.0, 0.7, 0.6); - rgba(r, g, b, alpha as u8) - } else { - rgba(255, 255, 255, alpha as u8) - }; - batch.text_posed( - atlas, - text, - [-(width / 2.0).trunc(), -4.0], - color, - 1.0, - [(w / 2.0).trunc(), (h - 68.0).trunc()], - ); - } + let background = self.settings.text_background(0.0); + let font = &self.res.atlas.font; + let mut draws = self.titles.overlay_message(w, h, partial, font, background); + draws.extend(self.titles.title(w, h, partial, font, background)); + hud_layout::paint(batch, &self.res.atlas, &draws); + } + /// The selected stack as `Hud.tick` compares it for the name highlight. + fn held_name(&self) -> Option { + let stack = self.inventory.get(self.selected)?.as_ref()?; + let custom = stack.custom_name(); + // ItemStack.getRarity: enchanting raises common and uncommon to rare + // and rare to epic. + let mut rarity = self.item_rarity(&stack.item); + if !stack.enchantments().is_empty() { + rarity = match rarity.as_str() { + "common" | "uncommon" => "rare".into(), + "rare" => "epic".into(), + _ => rarity, + }; } - let Some(title) = &t.title else { return }; - if t.time <= 0 { - return; - } - let ticks = t.time as f32 - partial; - let mut alpha = 255; - if t.time > t.fade_out + t.stay { - let time = (t.fade_in + t.stay + t.fade_out) as f32 - ticks; - alpha = (time * 255.0 / t.fade_in.max(1) as f32) as i32; - } - if t.time <= t.fade_out { - alpha = (ticks * 255.0 / t.fade_out.max(1) as f32) as i32; - } - let alpha = alpha.clamp(0, 255); - if alpha == 0 { - return; - } - let color = rgba(255, 255, 255, alpha as u8); - let origin = [(w / 2.0).trunc(), (h / 2.0).trunc()]; - let width = atlas.font.width_text(title); - batch.text_posed( - atlas, - title, - [-(width / 2.0).trunc(), -10.0], - color, - 4.0, - origin, + Some(HeldName { + item: stack.item.to_string(), + hover_name: Text::literal( + custom.map_or_else(|| self.res.names.item(&stack.item), str::to_owned), + ), + rarity_color: match rarity.as_str() { + "uncommon" => text::YELLOW, + "rare" => text::AQUA, + "epic" => text::LIGHT_PURPLE, + _ => text::WHITE, + }, + custom_name: custom.is_some(), + }) + } + /// The title, action bar and selected-item parts of `Hud.tick`. + pub(super) fn tick_hud(&mut self) { + self.titles.tick(); + let held = self.held_name(); + self.tool_highlight + .tick(held, f64::from(self.settings.notification_display_time)); + } + /// `Hud.extractSelectedItemName`. + pub(super) fn draw_selected_name(&self, batch: &mut HudBatch, can_hurt: bool) { + let draws = self.tool_highlight.draw( + batch.width as i32, + batch.height as i32, + can_hurt, + &self.res.atlas.font, + self.settings.text_background(0.0), ); - if let Some(sub) = &t.subtitle { - let width = atlas.font.width_text(sub); - batch.text_posed( - atlas, - sub, - [-(width / 2.0).trunc(), 5.0], - color, - 2.0, - origin, - ); - } + hud_layout::paint(batch, &self.res.atlas, &draws); } } -/// `Mth.hsvToRgb`. -fn hsv_to_rgb(hue: f32, saturation: f32, value: f32) -> [u8; 3] { - let h = (hue * 6.0) as i32 % 6; - let f = hue * 6.0 - (hue * 6.0).floor(); - let p = value * (1.0 - saturation); - let q = value * (1.0 - f * saturation); - let t = value * (1.0 - (1.0 - f) * saturation); - let (r, g, b) = match h { - 0 => (value, t, p), - 1 => (q, value, p), - 2 => (p, value, t), - 3 => (p, q, value), - 4 => (t, p, value), - _ => (value, p, q), - }; - let c = |v: f32| (v * 255.0).clamp(0.0, 255.0) as u8; - [c(r), c(g), c(b)] -} diff --git a/crates/horizon-client/src/hud_layout.rs b/crates/horizon-client/src/hud_layout.rs index 32c2a0e86..8972eaa63 100644 --- a/crates/horizon-client/src/hud_layout.rs +++ b/crates/horizon-client/src/hud_layout.rs @@ -139,7 +139,14 @@ fn sprite(sprite: &'static str, x: i32, y: i32, w: i32, h: i32) -> GuiDraw { color: WHITE, } } -fn region(sprite: &'static str, size: [i32; 2], uv: [i32; 2], at: [i32; 2], w: i32, h: i32) -> GuiDraw { +fn region( + sprite: &'static str, + size: [i32; 2], + uv: [i32; 2], + at: [i32; 2], + w: i32, + h: i32, +) -> GuiDraw { GuiDraw::Sprite { sprite: Cow::Borrowed(sprite), x: at[0], @@ -172,14 +179,6 @@ fn text(out: &mut Vec, text: Text, x: i32, y: i32, color: u32, shadow: }); } } -/// `graphics.textWithBackdrop` under `background` = `Options.getBackgroundColor(0)`. -fn text_with_backdrop(out: &mut Vec, t: Text, x: i32, y: i32, w: i32, color: u32, background: u32) { - if background != 0 { - out.push(fill(x - 2, y - 2, x + w + 2, y + 9 + 2, multiply(background, color))); - } - text(out, t, x, y, color, true); -} - /// `Options.getBackgroundColor(float)`: `chat_only` = `backgroundForChatOnly`. pub fn background_color(chat_only: bool, opacity: f64, default: f32) -> u32 { let a = if chat_only { default } else { opacity as f32 }; @@ -424,7 +423,14 @@ pub fn experience( let x = (w - width(&text)) / 2; let y = h - 24 - 9 - 2; for (dx, dy) in [(1, 0), (-1, 0), (0, 1), (0, -1)] { - self::text(&mut out, Text::literal(&text), x + dx, y + dy, 0xFF00_0000, false); + self::text( + &mut out, + Text::literal(&text), + x + dx, + y + dy, + 0xFF00_0000, + false, + ); } self::text(&mut out, Text::literal(text), x, y, 0xFF80_FF20, false); } @@ -780,7 +786,15 @@ pub fn paint(batch: &mut crate::hud::HudBatch, atlas: &crate::hud::HudAtlas, dra h, color, } => { - batch.sprite_scaled(atlas, sprite, *x as f32, *y as f32, *w as f32, *h as f32, abgr(*color)); + batch.sprite_scaled( + atlas, + sprite, + *x as f32, + *y as f32, + *w as f32, + *h as f32, + abgr(*color), + ); } GuiDraw::Blit { texture, diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs new file mode 100644 index 000000000..ec77a639b --- /dev/null +++ b/crates/horizon-client/src/hud_overlays.rs @@ -0,0 +1,437 @@ +//! The `Hud` overlays above the hotbar and decorations, laid out as +//! [`GuiDraw`] calls like [`crate::hud_layout`]: status effect icons +//! (`extractEffects`), titles and the action bar (`extractTitle`, +//! `extractOverlayMessage` and the title timers of `Hud.tick`), and the +//! selected item name (`extractSelectedItemName` and its `toolHighlightTimer`). +use crate::{ + font::Font, + hud_layout::{GuiDraw, PoseOp, fill, hsv_to_argb, multiply, white, width}, + text::{Style, Text}, +}; +use std::{borrow::Cow, cmp::Ordering}; + +/// `graphics.text`: dropped when fully transparent. +fn text(out: &mut Vec, text: Text, x: i32, y: i32, color: u32, shadow: bool) { + if color >> 24 != 0 { + out.push(GuiDraw::Text { + text, + x, + y, + color, + shadow, + }); + } +} + +/// `graphics.textWithBackdrop`; `background` is `Options.getBackgroundColor(0.0F)`. +pub fn text_with_backdrop( + out: &mut Vec, + t: Text, + x: i32, + y: i32, + w: i32, + color: u32, + background: u32, +) { + if background != 0 { + out.push(fill( + x - 2, + y - 2, + x + w + 2, + y + 9 + 2, + multiply(background, color), + )); + } + text(out, t, x, y, color, true); +} + +/// `Arrays.sort(T[], Comparator)` for the short arrays the HUD sorts: Java's +/// TimSort below `MIN_MERGE` (a natural run, then binary insertion), which +/// matters when the comparator is not a total order. Longer arrays fall back +/// to a stable sort. +pub fn java_sort(a: &mut [T], cmp: impl Fn(&T, &T) -> Ordering) { + let n = a.len(); + if n < 2 { + return; + } + if n >= 32 { + a.sort_by(cmp); + return; + } + // countRunAndMakeAscending. + let mut run = 2; + if cmp(&a[1], &a[0]) == Ordering::Less { + while run < n && cmp(&a[run], &a[run - 1]) == Ordering::Less { + run += 1; + } + a[..run].reverse(); + } else { + while run < n && cmp(&a[run], &a[run - 1]) != Ordering::Less { + run += 1; + } + } + // binarySort. + for start in run..n { + let (mut left, mut right) = (0, start); + while left < right { + let mid = (left + right) / 2; + if cmp(&a[start], &a[mid]) == Ordering::Less { + right = mid; + } else { + left = mid + 1; + } + } + a[left..=start].rotate_right(1); + } +} + +/// A `MobEffectInstance` as `extractEffects` sees it. +#[derive(Clone, Debug, PartialEq)] +pub struct EffectIcon { + /// The effect id without namespace (`speed`): the sprite is `mob_effect/`. + pub id: String, + /// `MobEffect.isBeneficial`. + pub beneficial: bool, + /// `MobEffect.getColor`. + pub color: i32, + pub ambient: bool, + /// Remaining ticks, -1 for infinite. + pub duration: i32, + pub show_icon: bool, +} + +/// `MobEffectInstance.compareTo`. +fn compare_effects(a: &EffectIcon, o: &EffectIcon) -> Ordering { + if (a.duration <= 32147 || o.duration <= 32147) && !(a.ambient && o.ambient) { + a.ambient + .cmp(&o.ambient) + .then((a.duration == -1).cmp(&(o.duration == -1))) + .then(a.duration.cmp(&o.duration)) + .then(a.color.cmp(&o.color)) + } else { + a.ambient.cmp(&o.ambient).then(a.color.cmp(&o.color)) + } +} + +/// `Hud.extractEffects`: `effects` in `getActiveEffects` order; `demo` moves +/// the icons below the demo timer. +pub fn effects(w: i32, demo: bool, effects: &[EffectIcon]) -> Vec { + let mut out = Vec::new(); + let mut sorted: Vec<&EffectIcon> = effects.iter().collect(); + // Ordering.natural().reverse().sortedCopy. + java_sort(&mut sorted, |a, b| compare_effects(b, a)); + let (mut beneficial, mut harmful) = (0, 0); + for e in sorted.into_iter().filter(|e| e.show_icon) { + let mut x = w; + let mut y = 1 + if demo { 15 } else { 0 }; + if e.beneficial { + beneficial += 1; + x -= 25 * beneficial; + } else { + harmful += 1; + x -= 25 * harmful; + y += 26; + } + let mut alpha = 1.0f32; + let background = if e.ambient { + "hud/effect_background_ambient" + } else { + if e.duration != -1 && e.duration <= 200 { + let remaining = e.duration; + let used = 10 - remaining / 20; + alpha = (remaining as f32 / 10.0 / 5.0 * 0.5).clamp(0.0, 0.5) + + horizon_core::geometry::trig::cos(f64::from( + remaining as f32 * std::f32::consts::PI / 5.0, + )) * (used as f32 / 10.0 * 0.25).clamp(0.0, 0.25); + alpha = alpha.clamp(0.0, 1.0); + } + "hud/effect_background" + }; + out.push(GuiDraw::Sprite { + sprite: Cow::Borrowed(background), + x, + y, + w: 24, + h: 24, + region: None, + color: crate::hud_layout::WHITE, + }); + out.push(GuiDraw::Sprite { + sprite: Cow::Owned(format!("mob_effect/{}", e.id)), + x: x + 3, + y: y + 3, + w: 18, + h: 18, + region: None, + color: white(alpha), + }); + } + out +} + +/// Titles and the action bar: `Hud.title`, `subtitle`, `titleTime`, the +/// fade times and `overlayMessageString` / `overlayMessageTime`. +#[derive(Clone, Debug, PartialEq)] +pub struct Titles { + pub title: Option, + pub subtitle: Option, + pub time: i32, + pub fade_in: i32, + pub stay: i32, + pub fade_out: i32, + pub overlay: Option, + pub overlay_time: i32, + /// `animateOverlayMessageColor`: the "Now Playing" rainbow. + pub overlay_animated: bool, +} +impl Default for Titles { + fn default() -> Self { + Self { + title: None, + subtitle: None, + time: 0, + fade_in: 10, + stay: 70, + fade_out: 20, + overlay: None, + overlay_time: 0, + overlay_animated: false, + } + } +} +impl Titles { + /// `setTitle`. + pub fn set_title(&mut self, title: Text) { + self.title = Some(title); + self.time = self.fade_in + self.stay + self.fade_out; + } + /// `setSubtitle`. + pub fn set_subtitle(&mut self, subtitle: Text) { + self.subtitle = Some(subtitle); + } + /// `setTimes`: negative values keep the current time. + pub fn set_times(&mut self, fade_in: i32, stay: i32, fade_out: i32) { + if fade_in >= 0 { + self.fade_in = fade_in; + } + if stay >= 0 { + self.stay = stay; + } + if fade_out >= 0 { + self.fade_out = fade_out; + } + if self.time > 0 { + self.time = self.fade_in + self.stay + self.fade_out; + } + } + /// `clearTitles`. + pub fn clear(&mut self) { + self.title = None; + self.subtitle = None; + self.time = 0; + } + /// `resetTitleTimes`. + pub fn reset_times(&mut self) { + (self.fade_in, self.stay, self.fade_out) = (10, 70, 20); + } + /// `setOverlayMessage`. + pub fn set_overlay(&mut self, text: Text, animate: bool) { + self.overlay = Some(text); + self.overlay_time = 60; + self.overlay_animated = animate; + } + /// The title and action bar part of `Hud.tick`. + pub fn tick(&mut self) { + if self.overlay_time > 0 { + self.overlay_time -= 1; + } + if self.time > 0 { + self.time -= 1; + if self.time <= 0 { + self.title = None; + self.subtitle = None; + } + } + } + /// `Hud.extractOverlayMessage`. + pub fn overlay_message( + &self, + w: i32, + h: i32, + partial: f32, + font: &Font, + background: u32, + ) -> Vec { + let mut out = Vec::new(); + let Some(message) = &self.overlay else { + return out; + }; + if self.overlay_time <= 0 { + return out; + } + let t = self.overlay_time as f32 - partial; + let alpha = ((t * 255.0 / 20.0) as i32).min(255); + if alpha > 0 { + out.push(GuiDraw::Push(vec![PoseOp::Translate( + (w / 2) as f32, + (h - 68) as f32, + )])); + let color = if self.overlay_animated { + hsv_to_argb(t / 50.0, 0.7, 0.6, alpha as u32) + } else { + crate::hud_layout::argb(alpha as u32, 255, 255, 255) + }; + let width = width(font, message); + text_with_backdrop( + &mut out, + message.clone(), + -width / 2, + -4, + width, + color, + background, + ); + out.push(GuiDraw::Pop); + } + out + } + /// `Hud.extractTitle`. + pub fn title( + &self, + w: i32, + h: i32, + partial: f32, + font: &Font, + background: u32, + ) -> Vec { + let mut out = Vec::new(); + let Some(title) = &self.title else { + return out; + }; + if self.time <= 0 { + return out; + } + let t = self.time as f32 - partial; + let mut alpha = 255; + if self.time > self.fade_out + self.stay { + let time = (self.fade_in + self.stay + self.fade_out) as f32 - t; + alpha = (time * 255.0 / self.fade_in as f32) as i32; + } + if self.time <= self.fade_out { + alpha = (t * 255.0 / self.fade_out as f32) as i32; + } + let alpha = alpha.clamp(0, 255); + if alpha > 0 { + out.push(GuiDraw::Push(vec![PoseOp::Translate( + (w / 2) as f32, + (h / 2) as f32, + )])); + out.push(GuiDraw::Push(vec![PoseOp::Scale(4.0, 4.0)])); + let title_width = width(font, title); + let color = crate::hud_layout::argb(alpha as u32, 255, 255, 255); + text_with_backdrop( + &mut out, + title.clone(), + -title_width / 2, + -10, + title_width, + color, + background, + ); + out.push(GuiDraw::Pop); + if let Some(subtitle) = &self.subtitle { + out.push(GuiDraw::Push(vec![PoseOp::Scale(2.0, 2.0)])); + let subtitle_width = width(font, subtitle); + text_with_backdrop( + &mut out, + subtitle.clone(), + -subtitle_width / 2, + 5, + subtitle_width, + color, + background, + ); + out.push(GuiDraw::Pop); + } + out.push(GuiDraw::Pop); + } + out + } +} + +/// The selected item as `Hud.tick` compares it: its item id and hover name. +#[derive(Clone, Debug, PartialEq)] +pub struct HeldName { + pub item: String, + /// `ItemStack.getHoverName`. + pub hover_name: Text, + /// `getRarity().color()`. + pub rarity_color: u32, + /// The stack has `CUSTOM_NAME`. + pub custom_name: bool, +} + +/// `Hud.toolHighlightTimer` and `lastToolHighlight`. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct ToolHighlight { + pub timer: i32, + pub last: Option, +} +impl ToolHighlight { + /// The selected-item part of `Hud.tick`; `display_time` is the + /// `notificationDisplayTime` option. + pub fn tick(&mut self, selected: Option, display_time: f64) { + match &selected { + None => self.timer = 0, + Some(s) => { + let changed = self + .last + .as_ref() + .is_none_or(|l| l.item != s.item || l.hover_name != s.hover_name); + if changed { + self.timer = (40.0 * display_time) as i32; + } else if self.timer > 0 { + self.timer -= 1; + } + } + } + self.last = selected; + } + /// `Hud.extractSelectedItemName`; `can_hurt` is + /// `gameMode.canHurtPlayer()` (survival and adventure). + pub fn draw( + &self, + w: i32, + h: i32, + can_hurt: bool, + font: &Font, + background: u32, + ) -> Vec { + let mut out = Vec::new(); + let Some(last) = &self.last else { + return out; + }; + if self.timer <= 0 { + return out; + } + let mut name = last.hover_name.clone().with_color(last.rarity_color); + if last.custom_name { + name = name.with_style(&Style { + italic: Some(true), + ..Style::default() + }); + } + let str_width = width(font, &name); + let x = (w - str_width) / 2; + let mut y = h - 59; + if !can_hurt { + y += 14; + } + let alpha = ((self.timer as f32 * 256.0 / 10.0) as i32).min(255); + if alpha > 0 { + let color = crate::hud_layout::argb(alpha as u32, 255, 255, 255); + text_with_backdrop(&mut out, name, x, y, str_width, color, background); + } + out + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 53685eeb2..ea6278878 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -45,6 +45,7 @@ pub mod gossip; pub mod health; pub mod hud; pub mod hud_layout; +pub mod hud_overlays; pub mod hunger; pub mod input; pub mod item_data; diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs index 2d49feee4..3db17435a 100644 --- a/crates/horizon-client/src/settings.rs +++ b/crates/horizon-client/src/settings.rs @@ -475,6 +475,15 @@ impl Settings { } }) } + /// `Options.getBackgroundColor(float)`: the text backdrop colour, `default` + /// opacity unless `backgroundForChatOnly` is off. + pub fn text_background(&self, default: f32) -> u32 { + crate::hud_layout::background_color( + self.file.bool("backgroundForChatOnly"), + f64::from(self.text_background_opacity), + default, + ) + } pub fn chat_options(&self) -> crate::chat::ChatOptions { crate::chat::ChatOptions { opacity: self.chat_opacity, diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java index 01469ab40..65cc4cecf 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java @@ -88,6 +88,19 @@ public final class VanillaHudOracle { static float f(String k, float d) { return c.has(k) && !c.get(k).isJsonNull() ? c.get(k).getAsFloat() : d; } static int i(String k, int d) { return c.has(k) && !c.get(k).isJsonNull() ? c.get(k).getAsInt() : d; } static boolean b(String k) { return c.has(k) && c.get(k).getAsBoolean(); } + static net.minecraft.network.chat.Component comp(JsonElement e) { + return net.minecraft.network.chat.ComponentSerialization.CODEC.parse(com.mojang.serialization.JsonOps.INSTANCE, e).getOrThrow(); + } + static OptionInstance option(T value) throws Exception { + @SuppressWarnings("unchecked") OptionInstance o = alloc(OptionInstance.class); + put(o, OptionInstance.class, "value", value); + return o; + } + static Method hudMethod(String name, Class... params) throws Exception { + Method m = Hud.class.getDeclaredMethod(name, params); + m.setAccessible(true); + return m; + } /** A player whose HUD-facing getters answer from the case. */ public static final class Actor extends LocalPlayer { @@ -95,6 +108,7 @@ public final class VanillaHudOracle { Entity vehicle; FoodData food; ItemStack offhand = ItemStack.EMPTY; + List active = new ArrayList<>(); private Actor() { super(null, null, null, null, null, null, false, null, null); } @Override public float getHealth() { return f("health", 20); } @Override public double getAttributeValue(Holder a) { return a == Attributes.MAX_HEALTH ? f("maxHealth", 20) : 0.0; } @@ -102,9 +116,10 @@ public final class VanillaHudOracle { @Override public int getArmorValue() { return i("armor", 0); } @Override public FoodData getFoodData() { return food; } @Override public boolean hasEffect(Holder effect) { - for (var e : c.getAsJsonArray("effects")) if (effect.is(Identifier.parse(e.getAsString()))) return true; + if (c.has("effects")) for (var e : c.getAsJsonArray("effects")) if (effect.is(Identifier.parse(e.getAsString()))) return true; return false; } + @Override public java.util.Collection getActiveEffects() { return active; } @Override public boolean isFullyFrozen() { return b("frozen"); } @Override public int getAirSupply() { return i("air", 300); } @Override public int getMaxAirSupply() { return i("maxAir", 300); } @@ -264,6 +279,11 @@ public final class VanillaHudOracle { Method crosshair = Hud.class.getDeclaredMethod("extractCrosshair", GuiGraphicsExtractor.class, DeltaTracker.class); crosshair.setAccessible(true); for (Method m : new Method[] {hotbar, health, vehicle}) m.setAccessible(true); + Method effects = hudMethod("extractEffects", GuiGraphicsExtractor.class, DeltaTracker.class); + Method title = hudMethod("extractTitle", GuiGraphicsExtractor.class, DeltaTracker.class); + Method overlayMessage = hudMethod("extractOverlayMessage", GuiGraphicsExtractor.class, DeltaTracker.class); + Method selectedName = hudMethod("extractSelectedItemName", GuiGraphicsExtractor.class); + Method tick = hudMethod("tick"); Method level = Class.forName("net.minecraft.client.gui.contextualbar.ContextualBar") .getDeclaredMethod("extractExperienceLevel", GuiGraphicsExtractor.class, Font.class, int.class); level.setAccessible(true); @@ -284,6 +304,7 @@ public final class VanillaHudOracle { put(clientLevel, ClientLevel.class, "clientLevelData", levelData); actor.level = clientLevel; actor.offhand = ItemStack.EMPTY; + actor.active = new ArrayList<>(); actor.food = new FoodData(); actor.food.setFoodLevel(i("food", 20)); actor.food.setSaturation(f("saturation", 5)); @@ -296,7 +317,7 @@ public final class VanillaHudOracle { var stacks = c.getAsJsonArray("slots"); var items = new net.minecraft.world.item.Item[] {Items.STONE, Items.DIAMOND_SWORD, Items.APPLE, Items.TORCH, Items.BOW, Items.OAK_LOG, Items.BREAD, Items.SHIELD, Items.COMPASS}; - for (int n = 0; n < 9; n++) { + for (int n = 0; stacks != null && n < 9; n++) { if (stacks.get(n).isJsonNull()) continue; var stack = new ItemStack(items[n]); stack.setPopTime(stacks.get(n).getAsInt()); @@ -317,17 +338,20 @@ public final class VanillaHudOracle { put(mc, Minecraft.class, "gameRenderer", renderer); put(mc, Minecraft.class, "font", font); var gameMode = alloc(MultiPlayerGameMode.class); - put(gameMode, MultiPlayerGameMode.class, "localPlayerMode", GameType.byName(c.get("gameMode").getAsString())); + put(gameMode, MultiPlayerGameMode.class, "localPlayerMode", GameType.byName(c.has("gameMode") ? c.get("gameMode").getAsString() : "survival")); put(mc, Minecraft.class, "gameMode", gameMode); var options = alloc(Options.class); - var indicator = alloc(OptionInstance.class); - put(indicator, OptionInstance.class, "value", AttackIndicatorStatus.valueOf(c.get("attackIndicator").getAsString())); - put(options, Options.class, "attackIndicator", indicator); + put(options, Options.class, "attackIndicator", option(AttackIndicatorStatus.valueOf(c.has("attackIndicator") ? c.get("attackIndicator").getAsString() : "OFF"))); + put(options, Options.class, "backgroundForChatOnly", option(c.has("chatOnly") ? b("chatOnly") : true)); + put(options, Options.class, "textBackgroundOpacity", option((double) f("textOpacity", 0.5F))); + put(options, Options.class, "notificationDisplayTime", option(c.has("displayTime") ? c.get("displayTime").getAsDouble() : 1.0)); put(mc, Minecraft.class, "options", options); var window = alloc(com.mojang.blaze3d.platform.Window.class); put(window, com.mojang.blaze3d.platform.Window.class, "guiScaledWidth", i("width", 0)); put(window, com.mojang.blaze3d.platform.Window.class, "guiScaledHeight", i("height", 0)); put(mc, Minecraft.class, "window", window); + put(mc, Minecraft.class, "gui", alloc(net.minecraft.client.gui.Gui.class)); + put(mc, Minecraft.class, "demo", b("demo")); var hud = alloc(Hud.class); put(hud, Hud.class, "minecraft", mc); put(hud, Hud.class, "random", net.minecraft.util.RandomSource.create()); @@ -336,25 +360,79 @@ public final class VanillaHudOracle { put(hud, Hud.class, "displayHealth", i("displayHealth", 0)); put(hud, Hud.class, "lastHealthTime", Util.getMillis() - (long) i("lastHealthAgo", 0)); put(hud, Hud.class, "healthBlinkTime", (long) i("healthBlinkTime", 0)); + put(hud, Hud.class, "lastToolHighlight", ItemStack.EMPTY); + var chat = alloc(net.minecraft.client.gui.components.ChatComponent.class); + put(chat, net.minecraft.client.gui.components.ChatComponent.class, "messageDeletionQueue", new ArrayList<>()); + put(hud, Hud.class, "chat", chat); + hud.resetTitleTimes(); var capture = alloc(Capture.class); capture.draws = new JsonArray(); capture.stack = new Matrix3x2fStack(16); + put(capture, GuiGraphicsExtractor.class, "minecraft", mc); float partial = f("partial", 0); DeltaTracker delta = (DeltaTracker) Proxy.newProxyInstance(DeltaTracker.class.getClassLoader(), new Class[] {DeltaTracker.class}, (proxy, method, a) -> method.getReturnType() == float.class ? partial : null); - var mode = GameType.byName(c.get("gameMode").getAsString()); - if (c.has("crosshair") && c.get("crosshair").getAsBoolean()) { - put(options, Options.class, "cameraType", net.minecraft.client.CameraType.FIRST_PERSON); - var debug = alloc(net.minecraft.client.gui.components.debug.DebugScreenEntryList.class); - put(debug, net.minecraft.client.gui.components.debug.DebugScreenEntryList.class, "currentlyEnabled", new ArrayList()); - put(mc, Minecraft.class, "debugEntries", debug); - crosshair.invoke(hud, capture, delta); + var mode = GameType.byName(c.has("gameMode") ? c.get("gameMode").getAsString() : "survival"); + // Hud.tick's vignette brightness reads the camera entity's level: tick without one. + if (Set.of("title", "selected").contains(c.get("kind").getAsString())) + put(camera, net.minecraft.client.Camera.class, "entity", null); + switch (c.get("kind").getAsString()) { + case "decorations" -> { + if (c.has("crosshair") && c.get("crosshair").getAsBoolean()) { + put(options, Options.class, "cameraType", net.minecraft.client.CameraType.FIRST_PERSON); + var debug = alloc(net.minecraft.client.gui.components.debug.DebugScreenEntryList.class); + put(debug, net.minecraft.client.gui.components.debug.DebugScreenEntryList.class, "currentlyEnabled", new ArrayList()); + put(mc, Minecraft.class, "debugEntries", debug); + crosshair.invoke(hud, capture, delta); + } + if (mode != GameType.SPECTATOR) hotbar.invoke(hud, capture, delta); + if (mode.isSurvival()) health.invoke(hud, capture); + vehicle.invoke(hud, capture); + if (c.has("experienceBar") && c.get("experienceBar").getAsBoolean()) new ExperienceBar(mc).extractBackground(capture, delta); + if (mode.isSurvival() && actor.experienceLevel > 0) level.invoke(null, capture, font, actor.experienceLevel); + } + case "effects" -> { + for (var e : c.getAsJsonArray("active")) { + var o = e.getAsJsonObject(); + var effect = BuiltInRegistries.MOB_EFFECT.get(Identifier.parse(o.get("id").getAsString())).orElseThrow(); + actor.active.add(new net.minecraft.world.effect.MobEffectInstance(effect, o.get("duration").getAsInt(), 0, + o.get("ambient").getAsBoolean(), true, o.get("icon").getAsBoolean())); + } + effects.invoke(hud, capture, delta); + } + case "title" -> { + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + switch (op.get(0).getAsString()) { + case "title" -> hud.setTitle(comp(op.get(1))); + case "subtitle" -> hud.setSubtitle(comp(op.get(1))); + case "times" -> hud.setTimes(op.get(1).getAsInt(), op.get(2).getAsInt(), op.get(3).getAsInt()); + case "clear" -> hud.clearTitles(); + case "reset" -> hud.resetTitleTimes(); + case "overlay" -> hud.setOverlayMessage(comp(op.get(1)), op.get(2).getAsBoolean()); + case "tick" -> { for (int n = op.get(1).getAsInt(); n > 0; n--) tick.invoke(hud); } + default -> throw new IllegalArgumentException(op.toString()); + } + } + overlayMessage.invoke(hud, capture, delta); + title.invoke(hud, capture, delta); + } + case "selected" -> { + int slot = i("selected", 0); + for (var e : c.getAsJsonArray("steps")) { + ItemStack stack = ItemStack.EMPTY; + if (!e.isJsonNull()) { + var o = e.getAsJsonObject(); + stack = new ItemStack(BuiltInRegistries.ITEM.getValue(Identifier.withDefaultNamespace(o.get("item").getAsString()))); + if (!o.get("custom").isJsonNull()) stack.set(net.minecraft.core.component.DataComponents.CUSTOM_NAME, comp(o.get("custom"))); + } + inventory.setItem(slot, stack); + tick.invoke(hud); + } + selectedName.invoke(hud, capture); + } + default -> throw new IllegalArgumentException(c.get("kind").getAsString()); } - if (mode != GameType.SPECTATOR) hotbar.invoke(hud, capture, delta); - if (mode.isSurvival()) health.invoke(hud, capture); - vehicle.invoke(hud, capture); - if (c.has("experienceBar") && c.get("experienceBar").getAsBoolean()) new ExperienceBar(mc).extractBackground(capture, delta); - if (mode.isSurvival() && actor.experienceLevel > 0) level.invoke(null, capture, font, actor.experienceLevel); result.add("draws", capture.draws); } catch (Throwable error) { var cause = error instanceof InvocationTargetException && error.getCause() != null ? error.getCause() : error; diff --git a/tools/hud_parity_cases.py b/tools/hud_parity_cases.py index df70e80e3..b3ebebdb7 100644 --- a/tools/hud_parity_cases.py +++ b/tools/hud_parity_cases.py @@ -35,12 +35,90 @@ def decorations(rng, n): if rng.random() < 0.15: case['vehicleMaxHealth'] = rng.choice([15.0, 30.0, 53.0, 100.0]) case['vehicleHealth'] = round(rng.uniform(0, case['vehicleMaxHealth']), 1) - - return case +ALL_EFFECTS = ['speed', 'slowness', 'haste', 'mining_fatigue', 'strength', 'instant_health', 'instant_damage', 'jump_boost', + 'nausea', 'regeneration', 'resistance', 'fire_resistance', 'water_breathing', 'invisibility', 'blindness', + 'night_vision', 'hunger', 'weakness', 'poison', 'wither', 'health_boost', 'absorption', 'saturation', 'glowing', + 'levitation', 'luck', 'unluck', 'slow_falling', 'conduit_power', 'dolphins_grace', 'bad_omen', + 'hero_of_the_village', 'darkness', 'trial_omen', 'raid_omen', 'wind_charged', 'weaving', 'oozing', 'infested', + 'breath_of_the_nautilus'] +SIZES = dict(width=[427, 320, 480, 640, 961], height=[240, 255, 270, 360, 501]) + + +def screen(rng): + return {'width': rng.choice(SIZES['width']), 'height': rng.choice(SIZES['height'])} + + +def backdrop(rng): + """The text background options behind textWithBackdrop.""" + return {'chatOnly': rng.random() < 0.5, 'textOpacity': rng.choice([0.0, 0.5, 0.25, 1.0, round(rng.random(), 3)])} + + +def effects(rng, n): + count = rng.choice([1, 2, 3, 5, 8, 12, 20]) + active = [] + for e in rng.sample(ALL_EFFECTS, count): + duration = rng.choice([-1, 1, 7, 19, 20, 99, 150, 199, 200, 201, 600, 32147, 32148, 40000, rng.randint(0, 220)]) + active.append({'id': 'minecraft:' + e, 'duration': duration, 'ambient': rng.random() < 0.25, 'icon': rng.random() < 0.9}) + return {**screen(rng), 'demo': rng.random() < 0.15, 'active': active} + + +TITLES = [{'text': 'Hello'}, {'text': 'Boss fight!', 'color': 'red', 'bold': True}, {'text': 'Wave 3', 'italic': True}, + {'text': 'A long title over the whole screen'}, {'text': ''}, ['Mixed ', {'text': 'parts', 'color': 'gold'}], + {'text': 'Ünïcödé ★'}] + + +def title(rng, n): + """Title, subtitle and action bar events between ticks (fades, setTimes mid-title, clears).""" + ops = [] + for _ in range(rng.randint(1, 6)): + r = rng.random() + if r < 0.3: + ops.append(['title', rng.choice(TITLES)]) + elif r < 0.45: + ops.append(['subtitle', rng.choice(TITLES)]) + elif r < 0.6: + ops.append(['times', rng.choice([-1, 0, 1, 5, 10, 20]), rng.choice([-1, 0, 3, 40, 70]), rng.choice([-1, 0, 1, 7, 20])]) + elif r < 0.65: + ops.append(['clear']) + elif r < 0.7: + ops.append(['reset']) + elif r < 0.85: + ops.append(['overlay', rng.choice(TITLES), rng.random() < 0.3]) + ops.append(['tick', rng.choice([0, 0, 1, 2, 5, 9, 10, 11, 30, 50, 59, 60, 79, 80, 81, 99, 100, rng.randint(0, 120)])]) + return {**screen(rng), **backdrop(rng), 'partial': round(rng.random(), 3), 'ops': ops} + + +# Items for the selected item name: id, translation key and rarity colour (checked by the oracle's own stacks). +HELD = [('stone', 'block.minecraft.stone', 'white'), ('diamond_sword', 'item.minecraft.diamond_sword', 'white'), + ('totem_of_undying', 'item.minecraft.totem_of_undying', 'yellow'), ('beacon', 'block.minecraft.beacon', 'aqua'), + ('dragon_egg', 'block.minecraft.dragon_egg', 'light_purple'), ('apple', 'item.minecraft.apple', 'white')] +CUSTOM = [None, None, None, {'text': 'Excalibur'}, {'text': 'Red', 'color': 'red'}, {'text': 'Plain', 'italic': False}] + + +def selected(rng, n): + """Selected-slot changes tick by tick, then the name with its fade.""" + def stack(): + item, key, rarity = rng.choice(HELD) + return {'item': item, 'key': key, 'rarity': rarity, 'custom': rng.choice(CUSTOM)} + steps, held = [], stack() + for _ in range(rng.randint(1, 60)): + if rng.random() < 0.1: + if rng.random() < 0.2: + held = None + else: + held = stack() + steps.append(held) + return {**screen(rng), **backdrop(rng), 'gameMode': rng.choice(['survival', 'adventure', 'creative']), + 'displayTime': rng.choice([1.0, 1.0, 0.5, 2.0, 0.123]), 'steps': steps} + + # Generators by kind: (rng, index) -> case. Cases are drawn round-robin. KINDS = { 'decorations': decorations, + 'effects': effects, + 'title': title, + 'selected': selected, } From f55b4281e5da81554dfa0a980a09616aa0133c33 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 13:10:33 +0200 Subject: [PATCH 3/7] Compare boss bars, the jump bar and the scoreboard sidebar with vanilla The oracle fills a BossHealthOverlay with LerpingBossEvents, runs JumpableVehicleBar on a jumpable mount and displayScoreboardSidebar on a real Scoreboard with teams, display names and number formats. The game collects the dragon, wither, raid and custom bars into one BossHealthOverlay layout (the backgrounds and notches now draw in vanilla's order) and draws the sidebar with the text background options and String.CASE_INSENSITIVE_ORDER. Co-Authored-By: Claude Opus 5.5 --- .../examples/hud_fixture/kinds.rs | 74 ++++++- crates/horizon-client/src/game.rs | 3 +- crates/horizon-client/src/game/bossbars.rs | 75 ++----- crates/horizon-client/src/game/dragon.rs | 50 ++--- crates/horizon-client/src/game/mounts.rs | 22 +- crates/horizon-client/src/game/raids.rs | 43 +--- crates/horizon-client/src/game/scoreboard.rs | 91 ++------ crates/horizon-client/src/game/wither.rs | 36 +--- crates/horizon-client/src/hud_overlays.rs | 197 ++++++++++++++++++ .../horizonlab/parity/VanillaHudOracle.java | 56 +++++ tools/hud_parity_cases.py | 41 ++++ 11 files changed, 448 insertions(+), 240 deletions(-) diff --git a/crates/horizon-client/examples/hud_fixture/kinds.rs b/crates/horizon-client/examples/hud_fixture/kinds.rs index 52abd73a0..fef5be327 100644 --- a/crates/horizon-client/examples/hud_fixture/kinds.rs +++ b/crates/horizon-client/examples/hud_fixture/kinds.rs @@ -3,7 +3,8 @@ use horizon_client::{ brewing, component, hud::HudAtlas, hud_layout::{self, GuiDraw}, - hud_overlays::{self, EffectIcon, HeldName, Titles, ToolHighlight}, + hud_overlays::{self, BossBar, EffectIcon, HeldName, Titles, ToolHighlight}, + scoreboard::{NumberFormat, RenderType, Scoreboard}, text::{self, Text}, }; use serde_json::Value; @@ -33,6 +34,9 @@ pub fn run(kind: &str, c: &Value, atlas: &HudAtlas) -> Vec { "effects" => effects(c, w), "title" => title(c, w, h, atlas), "selected" => selected(c, w, h, atlas), + "boss" => boss(c, w, h, atlas), + "jump" => hud_overlays::jump_bar(w, h, int(c, "cooldown", 0), float(c, "jumpScale", 0.0)), + "sidebar" => sidebar(c, w, h, atlas), _ => Vec::new(), } } @@ -115,3 +119,71 @@ fn selected(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { let can_hurt = mode == "survival" || mode == "adventure"; highlight.draw(w, h, can_hurt, &atlas.font, background(c)) } + +fn boss(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { + let bars: Vec = c["bars"] + .as_array() + .into_iter() + .flatten() + .map(|b| BossBar { + name: comp(&b["name"]), + progress: b["progress"].as_f64().unwrap_or(0.0) as f32, + color: b["color"].as_u64().unwrap_or(0) as usize, + overlay: b["overlay"].as_u64().unwrap_or(0) as usize, + }) + .collect(); + hud_overlays::boss_overlay(w, h, &bars, &atlas.font) +} + +/// A `NumberFormat` from the case: null, `{type: blank}`, `{type: fixed, +/// value}` or `{type: styled, style}`. +fn number_format(v: &Value) -> Option { + match v["type"].as_str()? { + "blank" => Some(NumberFormat::Blank), + "fixed" => Some(NumberFormat::Fixed(v["value"].clone())), + "styled" => Some(NumberFormat::Styled(v["style"].clone())), + other => panic!("unknown number format {other}"), + } +} + +fn sidebar(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { + let mut board = Scoreboard::default(); + let o = &c["objective"]; + board.add_objective( + "sidebar", + "dummy", + o["display"].clone(), + RenderType::Integer, + false, + number_format(&o["format"]), + ); + for s in c["scores"].as_array().into_iter().flatten() { + let owner = s["owner"].as_str().unwrap_or(""); + let score = board.score_mut(owner, "sidebar"); + score.value = s["value"].as_i64().unwrap_or(0) as i32; + score.display = (!s["display"].is_null()).then(|| s["display"].clone()); + score.number_format = number_format(&s["format"]); + } + for t in c["teams"].as_array().into_iter().flatten() { + let name = t["name"].as_str().unwrap_or(""); + let team = board.add_team(name); + team.prefix = t["prefix"].clone(); + team.suffix = t["suffix"].clone(); + team.color = t["color"].as_str().map(str::to_owned); + for m in t["members"].as_array().into_iter().flatten() { + board.add_to_team(m.as_str().unwrap_or(""), name); + } + } + let opacity = c["textOpacity"].as_f64().unwrap_or(0.5); + let chat_only = c["chatOnly"].as_bool().unwrap_or(true); + let objective = board.objective("sidebar").expect("objective").clone(); + hud_overlays::sidebar( + w, + h, + &board, + &objective, + &atlas.font, + hud_layout::background_color(chat_only, opacity, 0.3), + hud_layout::background_color(chat_only, opacity, 0.4), + ) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 5a1608282..96e326d3f 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2931,8 +2931,7 @@ impl Game<'_> { } self.draw_effect_icons(&mut batch); // Hud: the action bar and titles draw over the hotbar (nextStratum). - self.draw_boss_bar(&mut batch); - self.draw_custom_bossbars(&mut batch, 12.0 + 19.0 * self.builtin_bar_count() as f32); + self.draw_boss_bars(&mut batch); self.draw_titles(&mut batch); self.draw_scoreboard(&mut batch); self.draw_subtitles(&mut batch); diff --git a/crates/horizon-client/src/game/bossbars.rs b/crates/horizon-client/src/game/bossbars.rs index 2863546ac..ec7b72632 100644 --- a/crates/horizon-client/src/game/bossbars.rs +++ b/crates/horizon-client/src/game/bossbars.rs @@ -4,10 +4,9 @@ use super::{ commands::{R, err}, }; use horizon_client::{ - bossbar::BossBars, + bossbar::{self, BossBars}, command::{Arg, Context}, - hud::{HudBatch, rgba}, - save, + hud_overlays, save, scoreboard::{self as sb, Comp, comp_text}, scoreboard_cmd::format_list, text::Text, @@ -334,26 +333,10 @@ impl Game<'_> { Ok(self.resolve_component(value)) } - /// How many boss bars the dragon and withers already show. - pub(super) fn builtin_bar_count(&self) -> usize { - let dragon = usize::from(self.dragon.is_some() && self.dim == super::Dim::End); - let withers = self.player.as_ref().map_or(0, |p| { - self.mobs - .iter() - .filter(|m| { - m.species() == horizon_client::mobs::Species::Wither - && m.alive() - && m.position.distance_squared(p.position) <= 64.0 * 64.0 - }) - .count() - }); - dragon + withers - } // ---- drawing ------------------------------------------------------------------ - /// `BossHealthOverlay`: the visible custom bars under the built-in ones. - pub(super) fn draw_custom_bossbars(&self, batch: &mut HudBatch, mut y: f32) { - let atlas = &self.res.atlas; + /// The visible custom bars (`/bossbar`), after the built-in ones. + pub(super) fn custom_bossbars(&self, bars: &mut Vec) { for b in self .bosses .bars @@ -361,44 +344,18 @@ impl Game<'_> { .iter() .filter(|b| b.visible && b.player) { - if y >= batch.height / 3.0 { - break; - } - let x = (batch.width / 2.0 - 91.0).floor(); - let sprite = |kind: &str| format!("gui/sprites/boss_bar/{kind}"); - batch.sprite(atlas, &sprite(&format!("{}_background", b.color)), x, y); - if b.progress() > 0.0 { - batch.sprite_part( - atlas, - &sprite(&format!("{}_progress", b.color)), - x, - y, - b.progress(), - ); - } - if b.style != "progress" { - batch.sprite(atlas, &sprite(&format!("{}_background", b.style)), x, y); - if b.progress() > 0.0 { - batch.sprite_part( - atlas, - &sprite(&format!("{}_progress", b.style)), - x, - y, - b.progress(), - ); - } - } - let name = comp_text(&b.name); - let w = atlas.font.width_text(&name); - batch.text_styled( - atlas, - &name, - (batch.width / 2.0 - w / 2.0).floor(), - y - 9.0, - rgba(255, 255, 255, 255), - true, - ); - y += 19.0; + bars.push(hud_overlays::BossBar { + name: comp_text(&b.name), + progress: b.progress(), + color: bossbar::COLORS + .iter() + .position(|c| *c == b.color) + .unwrap_or(0), + overlay: bossbar::STYLES + .iter() + .position(|s| *s == b.style) + .unwrap_or(0), + }); } } } diff --git a/crates/horizon-client/src/game/dragon.rs b/crates/horizon-client/src/game/dragon.rs index be4b4ec1f..063c57d97 100644 --- a/crates/horizon-client/src/game/dragon.rs +++ b/crates/horizon-client/src/game/dragon.rs @@ -8,9 +8,11 @@ //! exit portal, the egg and the next gateway; and its rendering and boss bar. use super::{Dim, Game}; use horizon_client::{ - hud::{HudBatch, rgba}, + hud::HudBatch, + hud_layout, hud_overlays, mesher::Vertex, particles::{ParticleOptions, ParticleType}, + text::Text, }; use horizon_core::{ geometry::{Aabb, Vec3}, @@ -1839,30 +1841,30 @@ impl Game<'_> { }); self.breath_clouds.append(&mut clouds); } - /// The boss bar (`BossHealthOverlay`): name and the pink progress bar. - pub(super) fn draw_boss_bar(&self, batch: &mut HudBatch) { - let dragon = self.dragon.as_ref().filter(|_| self.dim == Dim::End); - let y = self.draw_wither_bars(batch, if dragon.is_some() { 31.0 } else { 12.0 }); - self.draw_raid_bar(batch, y); - let Some(d) = dragon else { - return; - }; - let atlas = &self.res.atlas; - let x = (batch.width / 2.0 - 91.0).floor(); - let y = 12.0; - batch.sprite(atlas, "gui/sprites/boss_bar/pink_background", x, y); - let progress = (d.health / MAX_HEALTH).clamp(0.0, 1.0); - batch.sprite_part(atlas, "gui/sprites/boss_bar/pink_progress", x, y, progress); - let name = self.translate("entity.minecraft.ender_dragon", "Ender Dragon"); - let w = HudBatch::text_width(atlas, &name); - batch.text( - atlas, - &name, - (batch.width / 2.0 - w / 2.0).floor(), - y - 9.0, - rgba(255, 255, 255, 255), - true, + /// `BossHealthOverlay`: the dragon's pink bar, then the withers', the + /// raids' and the custom bars, in that order. + pub(super) fn draw_boss_bars(&self, batch: &mut HudBatch) { + let mut bars = Vec::new(); + if let Some(d) = self.dragon.as_ref().filter(|_| self.dim == Dim::End) { + bars.push(hud_overlays::BossBar { + name: Text::literal( + self.translate("entity.minecraft.ender_dragon", "Ender Dragon"), + ), + progress: (d.health / MAX_HEALTH).clamp(0.0, 1.0), + color: 0, + overlay: 0, + }); + } + self.wither_bars(&mut bars); + self.raid_bars(&mut bars); + self.custom_bossbars(&mut bars); + let draws = hud_overlays::boss_overlay( + batch.width as i32, + batch.height as i32, + &bars, + &self.res.atlas.font, ); + hud_layout::paint(batch, &self.res.atlas, &draws); } /// `music.dragon` while the boss bar plays music. pub(super) fn boss_music(&self) -> bool { diff --git a/crates/horizon-client/src/game/mounts.rs b/crates/horizon-client/src/game/mounts.rs index 9f6ce609b..2d987ea28 100644 --- a/crates/horizon-client/src/game/mounts.rs +++ b/crates/horizon-client/src/game/mounts.rs @@ -466,23 +466,11 @@ impl Game<'_> { let draws = horizon_client::hud_layout::vehicle_health(w, h, hearts, m.health); horizon_client::hud_layout::paint(batch, atlas, &draws); if m.extra.saddled { - let x = (w / 2 - 91) as f32; - let y = (h - 29) as f32; - batch.sprite(atlas, "gui/sprites/hud/jump_bar_background", x, y); - if self.mount.jump_ticks < 0 { - batch.sprite(atlas, "gui/sprites/hud/jump_bar_cooldown", x, y); - } else { - let filled = (self.mount.jump_scale * 183.0).floor(); - if filled > 0.0 { - batch.sprite_part( - atlas, - "gui/sprites/hud/jump_bar_progress", - x, - y, - filled / 182.0, - ); - } - } + // JumpableVehicleBar: the cooldown shows while the jump recharges. + let cooldown = i32::from(self.mount.jump_ticks < 0); + let draws = + horizon_client::hud_overlays::jump_bar(w, h, cooldown, self.mount.jump_scale); + horizon_client::hud_layout::paint(batch, atlas, &draws); } (hearts, m.extra.saddled) } diff --git a/crates/horizon-client/src/game/raids.rs b/crates/horizon-client/src/game/raids.rs index 91c454ce8..d2fbb6566 100644 --- a/crates/horizon-client/src/game/raids.rs +++ b/crates/horizon-client/src/game/raids.rs @@ -4,9 +4,10 @@ use super::{Dim, Game}; use horizon_client::mobs::villager as mobs_villager; use horizon_client::{ effects::EffectInstance, - hud::{HudBatch, rgba}, + hud_overlays, mobs::{Mob, Species, data, raider}, raid::{self, Action, BarName, RaidLevel, RaiderInfo, RaiderType, Raids, Spawn}, + text::Text, }; use horizon_core::{geometry::Vec3, random::RandomSource}; use std::collections::{HashMap, HashSet}; @@ -746,31 +747,12 @@ impl Game<'_> { } } - /// The raid boss bars (`BossHealthOverlay`): a red notched bar with the - /// raid's title. Returns the next free row. - pub(super) fn draw_raid_bar(&self, batch: &mut HudBatch, mut y: f32) -> f32 { - let atlas = &self.res.atlas; + /// The raid boss bars: red and notched in tens, with the raid's title. + pub(super) fn raid_bars(&self, bars: &mut Vec) { for raid in self.raiding.raids.map.values() { if !raid.bar.visible || !raid.bar.player || raid.is_stopped() { continue; } - let x = (batch.width / 2.0 - 91.0).floor(); - batch.sprite(atlas, "gui/sprites/boss_bar/red_background", x, y); - batch.sprite(atlas, "gui/sprites/boss_bar/notched_10_background", x, y); - let p = raid.bar.progress; - // Mth.lerpDiscrete(progress, 0, 182). - let width = (p * 181.0).floor() as i32 + i32::from(p > 0.0); - if width > 0 { - let fraction = width as f32 / 182.0; - batch.sprite_part(atlas, "gui/sprites/boss_bar/red_progress", x, y, fraction); - batch.sprite_part( - atlas, - "gui/sprites/boss_bar/notched_10_progress", - x, - y, - fraction, - ); - } let title = self.translate("event.minecraft.raid", "Raid"); let name = match raid.bar.name { BarName::Raid => title, @@ -789,18 +771,13 @@ impl Game<'_> { self.translate("event.minecraft.raid.defeat.full", "Raid - Defeat") } }; - let w = HudBatch::text_width(atlas, &name); - batch.text( - atlas, - &name, - (batch.width / 2.0 - w / 2.0).floor(), - y - 9.0, - rgba(255, 255, 255, 255), - true, - ); - y += 19.0; + bars.push(hud_overlays::BossBar { + name: Text::literal(name), + progress: raid.bar.progress, + color: 2, + overlay: 2, + }); } - y } /// A firework a villager launches to celebrate (`CelebrateVillagersSurvivedRaid`). pub(super) fn villager_firework(&mut self, at: [f64; 3], color: usize, flight: u8) { diff --git a/crates/horizon-client/src/game/scoreboard.rs b/crates/horizon-client/src/game/scoreboard.rs index d6962d674..987ea7d14 100644 --- a/crates/horizon-client/src/game/scoreboard.rs +++ b/crates/horizon-client/src/game/scoreboard.rs @@ -8,9 +8,10 @@ use horizon_client::{ Context, args::{IntRange, Selector}, }, - hud::{HudBatch, rgba}, + hud::HudBatch, + hud_layout, hud_overlays, save::{self, uuid_from_text, uuid_text}, - scoreboard::{self as sb, Comp, NumberFormat, Scoreboard, literal}, + scoreboard::{self as sb, Comp, Scoreboard, literal}, scoreboard_cmd::{self, Env, Holder}, text::Text, }; @@ -478,84 +479,16 @@ impl Game<'_> { else { return; }; - let atlas = &self.res.atlas; - let default_format = NumberFormat::sidebar_default(); - let format = objective.format_or_default(default_format); - let mut entries: Vec<_> = board - .list_scores(&objective.name) - .into_iter() - .filter(|e| !e.is_hidden()) - .collect(); - // Highest score first, then names case-insensitively. - entries.sort_by(|a, b| { - b.value - .cmp(&a.value) - .then_with(|| a.owner.to_lowercase().cmp(&b.owner.to_lowercase())) - }); - entries.truncate(15); - let rows: Vec<(Text, Text, f32)> = entries - .iter() - .map(|e| { - let name = match board.players_team(&e.owner) { - Some(t) => t.formatted_name(e.owner_name()), - None => e.owner_name(), - }; - let score = e.format_value(&format); - let width = atlas.font.width_text(&score); - (name, score, width) - }) - .collect(); - let title = objective.display_text(); - let title_width = atlas.font.width_text(&title); - let spacer = atlas.font.width(": "); - let mut biggest = title_width; - for (name, _, score_width) in &rows { - let extra = if *score_width > 0.0 { - spacer + score_width - } else { - 0.0 - }; - biggest = biggest.max(atlas.font.width_text(name) + extra); - } - let count = rows.len() as f32; - let height = count * 9.0; - let (w, h) = (batch.width, batch.height); - let bottom = (h / 2.0).trunc() + (height / 3.0).trunc(); - let left = w - biggest - 3.0; - let right = w - 3.0 + 2.0; - let body = rgba(0, 0, 0, (0.3 * 255.0) as u8); - let header = rgba(0, 0, 0, (0.4 * 255.0) as u8); - let top = bottom - count * 9.0; - batch.fill( - atlas, - left - 2.0, - top - 9.0 - 1.0, - right - (left - 2.0), - 9.0, - header, + let draws = hud_overlays::sidebar( + batch.width as i32, + batch.height as i32, + board, + objective, + &self.res.atlas.font, + self.settings.text_background(0.3), + self.settings.text_background(0.4), ); - batch.fill( - atlas, - left - 2.0, - top - 1.0, - right - (left - 2.0), - bottom - (top - 1.0), - body, - ); - let white = rgba(255, 255, 255, 255); - batch.text_styled( - atlas, - &title, - left + (biggest / 2.0).trunc() - (title_width / 2.0).trunc(), - top - 9.0, - white, - false, - ); - for (i, (name, score, score_width)) in rows.iter().enumerate() { - let y = bottom - (count - i as f32) * 9.0; - batch.text_styled(atlas, name, left, y, white, false); - batch.text_styled(atlas, score, right - score_width, y, white, false); - } + hud_layout::paint(batch, &self.res.atlas, &draws); } } diff --git a/crates/horizon-client/src/game/wither.rs b/crates/horizon-client/src/game/wither.rs index 3668e5f9f..09ddc2b5f 100644 --- a/crates/horizon-client/src/game/wither.rs +++ b/crates/horizon-client/src/game/wither.rs @@ -2,9 +2,10 @@ //! its boss bar, and its skulls hitting and exploding. use super::Game; use horizon_client::{ - hud::{HudBatch, rgba}, + hud_overlays, mobs::{Damage, DamageKind, Species, Who}, projectiles::{Projectile, ProjectileKind}, + text::Text, }; impl Game<'_> { @@ -74,12 +75,11 @@ impl Game<'_> { } Ok(()) } - /// The wither boss bars (purple, below the dragon's), within range. - pub(super) fn draw_wither_bars(&self, batch: &mut HudBatch, mut y: f32) -> f32 { + /// The wither boss bars (purple), within range. + pub(super) fn wither_bars(&self, bars: &mut Vec) { let Some(p) = self.player.as_ref() else { - return y; + return; }; - let atlas = &self.res.atlas; for m in self .mobs .iter() @@ -88,36 +88,22 @@ impl Game<'_> { if m.position.distance_squared(p.position) > 64.0 * 64.0 { continue; } - let x = (batch.width / 2.0 - 91.0).floor(); let progress = if m.extra.counter > 0 { 1.0 - m.extra.counter as f32 / horizon_client::mobs::wither::INVULNERABLE as f32 } else { (m.health / m.attrs.max_health).clamp(0.0, 1.0) }; - batch.sprite(atlas, "gui/sprites/boss_bar/purple_background", x, y); - batch.sprite_part( - atlas, - "gui/sprites/boss_bar/purple_progress", - x, - y, - progress, - ); let name = m .custom_name .clone() .unwrap_or_else(|| self.translate("entity.minecraft.wither", "Wither")); - let w = HudBatch::text_width(atlas, &name); - batch.text( - atlas, - &name, - (batch.width / 2.0 - w / 2.0).floor(), - y - 9.0, - rgba(255, 255, 255, 255), - true, - ); - y += 19.0; + bars.push(hud_overlays::BossBar { + name: Text::literal(name), + progress, + color: 5, + overlay: 0, + }); } - y } pub(super) fn wither_near(&self) -> bool { self.player.as_ref().is_some_and(|p| { diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index ec77a639b..8c554898a 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -435,3 +435,200 @@ impl ToolHighlight { out } } + +/// One `LerpingBossEvent` as `BossHealthOverlay` draws it. +#[derive(Clone, Debug, PartialEq)] +pub struct BossBar { + pub name: Text, + /// `getProgress()` (the lerped value). + pub progress: f32, + /// `BossBarColor` ordinal: pink, blue, red, green, yellow, purple, white. + pub color: usize, + /// `BossBarOverlay` ordinal: progress, notched_6, _10, _12, _20. + pub overlay: usize, +} +const BOSS_COLORS: [&str; 7] = ["pink", "blue", "red", "green", "yellow", "purple", "white"]; +const BOSS_OVERLAYS: [&str; 5] = [ + "progress", + "notched_6", + "notched_10", + "notched_12", + "notched_20", +]; + +/// `BossHealthOverlay.extractRenderState`: the bars in event order, 19 pixels +/// apart from y = 12 until a third of the screen height. +pub fn boss_overlay(w: i32, h: i32, bars: &[BossBar], font: &Font) -> Vec { + let mut out = Vec::new(); + let mut y_offset = 12; + for bar in bars { + let x_left = w / 2 - 91; + let part = |out: &mut Vec, width: i32, kind: &str| { + let sprite = |name: String| GuiDraw::Sprite { + sprite: Cow::Owned(format!("boss_bar/{name}_{kind}")), + x: x_left, + y: y_offset, + w: width, + h: 5, + region: Some([182, 5, 0, 0]), + color: crate::hud_layout::WHITE, + }; + out.push(sprite(BOSS_COLORS[bar.color].to_owned())); + if bar.overlay != 0 { + out.push(sprite(BOSS_OVERLAYS[bar.overlay].to_owned())); + } + }; + part(&mut out, 182, "background"); + let progress = crate::hud_layout::lerp_discrete(bar.progress, 0, 182); + if progress > 0 { + part(&mut out, progress, "progress"); + } + let width = width(font, &bar.name); + text( + &mut out, + bar.name.clone(), + w / 2 - width / 2, + y_offset - 9, + crate::hud_layout::WHITE, + true, + ); + y_offset += 10 + 9; + if y_offset >= h / 3 { + break; + } + } + out +} + +/// `JumpableVehicleBar.extractBackground`: `cooldown` is the mount's jump +/// cooldown and `scale` the player's `getJumpRidingScale()`. +pub fn jump_bar(w: i32, h: i32, cooldown: i32, scale: f32) -> Vec { + let (left, top) = ((w - 182) / 2, h - 24 - 5); + let sprite = |name: &'static str, width: i32, region: Option<[i32; 4]>| GuiDraw::Sprite { + sprite: Cow::Borrowed(name), + x: left, + y: top, + w: width, + h: 5, + region, + color: crate::hud_layout::WHITE, + }; + let mut out = vec![sprite("hud/jump_bar_background", 182, None)]; + if cooldown > 0 { + out.push(sprite("hud/jump_bar_cooldown", 182, None)); + } else { + let progress = crate::hud_layout::lerp_discrete(scale, 0, 182); + if progress > 0 { + out.push(sprite( + "hud/jump_bar_progress", + progress, + Some([182, 5, 0, 0]), + )); + } + } + out +} + +/// `String.CASE_INSENSITIVE_ORDER` over UTF-16 code units. +pub fn compare_ignore_case(a: &str, b: &str) -> Ordering { + fn single(mut it: impl Iterator, c: char) -> char { + match (it.next(), it.next()) { + (Some(m), None) => m, + _ => c, + } + } + let unit = |u: u16| char::from_u32(u32::from(u)); + let (x, y): (Vec, Vec) = (a.encode_utf16().collect(), b.encode_utf16().collect()); + for (&p, &q) in x.iter().zip(&y) { + if p == q { + continue; + } + let (Some(c1), Some(c2)) = (unit(p), unit(q)) else { + return p.cmp(&q); + }; + let (u1, u2) = (single(c1.to_uppercase(), c1), single(c2.to_uppercase(), c2)); + if u1 != u2 { + let (l1, l2) = (single(u1.to_lowercase(), u1), single(u2.to_lowercase(), u2)); + if l1 != l2 { + return (l1 as u32).cmp(&(l2 as u32)); + } + } + } + x.len().cmp(&y.len()) +} + +/// `Hud.displayScoreboardSidebar` for `objective`; `background` and +/// `header` are `Options.getBackgroundColor(0.3F)` and `(0.4F)`. +pub fn sidebar( + w: i32, + h: i32, + board: &crate::scoreboard::Scoreboard, + objective: &crate::scoreboard::Objective, + font: &Font, + background: u32, + header: u32, +) -> Vec { + use crate::scoreboard::NumberFormat; + let format = objective.format_or_default(NumberFormat::sidebar_default()); + let mut entries: Vec<_> = board + .list_scores(&objective.name) + .into_iter() + .filter(|e| !e.is_hidden()) + .collect(); + // SCORE_DISPLAY_ORDER: highest value first, then owners case-insensitively. + java_sort(&mut entries, |a, b| { + b.value + .cmp(&a.value) + .then_with(|| compare_ignore_case(&a.owner, &b.owner)) + }); + entries.truncate(15); + let rows: Vec<(Text, Text, i32)> = entries + .iter() + .map(|e| { + let name = match board.players_team(&e.owner) { + Some(team) => team.formatted_name(e.owner_name()), + None => e.owner_name(), + }; + let score = e.format_value(&format); + let score_width = width(font, &score); + (name, score, score_width) + }) + .collect(); + let title = objective.display_text(); + let title_width = width(font, &title); + let spacer = font.width(": ") as i32; + let mut biggest = title_width; + for (name, _, score_width) in &rows { + let extra = if *score_width > 0 { + spacer + score_width + } else { + 0 + }; + biggest = biggest.max(width(font, name) + extra); + } + let count = rows.len() as i32; + let height = count * 9; + let bottom = h / 2 + height / 3; + let left = w - biggest - 3; + let right = w - 3 + 2; + let header_y = bottom - count * 9; + let mut out = vec![ + fill(left - 2, header_y - 9 - 1, right, header_y - 1, header), + fill(left - 2, header_y - 1, right, bottom, background), + ]; + let white = crate::hud_layout::WHITE; + text( + &mut out, + title, + left + biggest / 2 - title_width / 2, + header_y - 9, + white, + false, + ); + for (i, (name, score, score_width)) in rows.into_iter().enumerate() { + let y = bottom - (count - i as i32) * 9; + text(&mut out, name, left, y, white, false); + text(&mut out, score, right - score_width, y, white, false); + } + out +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java index 65cc4cecf..9b22bb327 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java @@ -96,6 +96,17 @@ public final class VanillaHudOracle { put(o, OptionInstance.class, "value", value); return o; } + static net.minecraft.network.chat.numbers.NumberFormat numberFormat(JsonElement e) { + if (e == null || e.isJsonNull()) return null; + var o = e.getAsJsonObject(); + return switch (o.get("type").getAsString()) { + case "blank" -> net.minecraft.network.chat.numbers.BlankFormat.INSTANCE; + case "fixed" -> new net.minecraft.network.chat.numbers.FixedFormat(comp(o.get("value"))); + case "styled" -> new net.minecraft.network.chat.numbers.StyledFormat( + net.minecraft.network.chat.Style.Serializer.MAP_CODEC.codec().parse(com.mojang.serialization.JsonOps.INSTANCE, o.get("style")).getOrThrow()); + default -> throw new IllegalArgumentException(o.toString()); + }; + } static Method hudMethod(String name, Class... params) throws Exception { Method m = Hud.class.getDeclaredMethod(name, params); m.setAccessible(true); @@ -130,6 +141,13 @@ public final class VanillaHudOracle { @Override public float getAttackStrengthScale(float a) { return f("attackScale", 1); } @Override public Level level() { return level; } @Override public boolean isSpectator() { return false; } + @Override public net.minecraft.world.entity.PlayerRideableJumping jumpableVehicle() { + return (net.minecraft.world.entity.PlayerRideableJumping) Proxy.newProxyInstance(Actor.class.getClassLoader(), + new Class[] {net.minecraft.world.entity.PlayerRideableJumping.class}, + (proxy, method, a) -> method.getName().equals("getJumpCooldown") ? i("cooldown", 0) + : method.getReturnType() == boolean.class ? false : method.getReturnType() == float.class ? 0.0F : null); + } + @Override public float getJumpRidingScale() { return f("jumpScale", 0); } @Override public void playSound(net.minecraft.sounds.SoundEvent sound, float volume, float pitch) { } } @@ -284,6 +302,7 @@ public final class VanillaHudOracle { Method overlayMessage = hudMethod("extractOverlayMessage", GuiGraphicsExtractor.class, DeltaTracker.class); Method selectedName = hudMethod("extractSelectedItemName", GuiGraphicsExtractor.class); Method tick = hudMethod("tick"); + Method sidebar = hudMethod("displayScoreboardSidebar", GuiGraphicsExtractor.class, net.minecraft.world.scores.Objective.class); Method level = Class.forName("net.minecraft.client.gui.contextualbar.ContextualBar") .getDeclaredMethod("extractExperienceLevel", GuiGraphicsExtractor.class, Font.class, int.class); level.setAccessible(true); @@ -431,6 +450,43 @@ public final class VanillaHudOracle { } selectedName.invoke(hud, capture); } + case "boss" -> { + var overlay = new net.minecraft.client.gui.components.BossHealthOverlay(mc); + @SuppressWarnings("unchecked") var events = (Map) + field(net.minecraft.client.gui.components.BossHealthOverlay.class, "events").get(overlay); + for (var e : c.getAsJsonArray("bars")) { + var o = e.getAsJsonObject(); + var id = UUID.randomUUID(); + events.put(id, new net.minecraft.client.gui.components.LerpingBossEvent(id, comp(o.get("name")), o.get("progress").getAsFloat(), + net.minecraft.world.BossEvent.BossBarColor.values()[o.get("color").getAsInt()], + net.minecraft.world.BossEvent.BossBarOverlay.values()[o.get("overlay").getAsInt()], false, false, false)); + } + overlay.extractRenderState(capture); + } + case "jump" -> new net.minecraft.client.gui.contextualbar.JumpableVehicleBar(mc).extractBackground(capture, delta); + case "sidebar" -> { + var board = new net.minecraft.world.scores.Scoreboard(); + var o = c.getAsJsonObject("objective"); + var objective = board.addObjective("sidebar", net.minecraft.world.scores.criteria.ObjectiveCriteria.DUMMY, comp(o.get("display")), + net.minecraft.world.scores.criteria.ObjectiveCriteria.RenderType.INTEGER, false, numberFormat(o.get("format"))); + for (var e : c.getAsJsonArray("scores")) { + var sc = e.getAsJsonObject(); + var access = board.getOrCreatePlayerScore(net.minecraft.world.scores.ScoreHolder.forNameOnly(sc.get("owner").getAsString()), objective); + access.set(sc.get("value").getAsInt()); + if (!sc.get("display").isJsonNull()) access.display(comp(sc.get("display"))); + access.numberFormatOverride(numberFormat(sc.get("format"))); + } + for (var e : c.getAsJsonArray("teams")) { + var t = e.getAsJsonObject(); + var team = board.addPlayerTeam(t.get("name").getAsString()); + team.setPlayerPrefix(comp(t.get("prefix"))); + team.setPlayerSuffix(comp(t.get("suffix"))); + team.setColor(t.get("color").isJsonNull() ? Optional.empty() + : Optional.of(net.minecraft.world.scores.TeamColor.byName(t.get("color").getAsString()))); + for (var m : t.getAsJsonArray("members")) board.addPlayerToTeam(m.getAsString(), team); + } + sidebar.invoke(hud, capture, objective); + } default -> throw new IllegalArgumentException(c.get("kind").getAsString()); } result.add("draws", capture.draws); diff --git a/tools/hud_parity_cases.py b/tools/hud_parity_cases.py index b3ebebdb7..98dc7ab21 100644 --- a/tools/hud_parity_cases.py +++ b/tools/hud_parity_cases.py @@ -115,10 +115,51 @@ def selected(rng, n): 'displayTime': rng.choice([1.0, 1.0, 0.5, 2.0, 0.123]), 'steps': steps} + +def boss(rng, n): + bars = [] + for _ in range(rng.choice([1, 1, 2, 3, 5, 9])): + progress = rng.choice([0.0, 1.0, 0.5, 0.001, 0.999, 1 / 182, round(rng.random(), 4)]) + bars.append({'name': rng.choice(TITLES), 'progress': progress, 'color': rng.randrange(7), 'overlay': rng.randrange(5)}) + return {**screen(rng), 'bars': bars} + + +def jump(rng, n): + return {**screen(rng), 'cooldown': rng.choice([0, 0, 0, 1, 10]), + 'jumpScale': rng.choice([0.0, 1.0, 0.4, 0.001, round(rng.random(), 4)])} + + +OWNERS = ['Alex', 'steve', 'Zed', 'bob', 'Bobby', 'ÉLodie', 'élan', '#hidden', 'x', 'LongPlayerName_123', 'Mia', '_under'] +FORMATS = [None, None, None, {'type': 'blank'}, {'type': 'fixed', 'value': {'text': 'FIX', 'color': 'aqua'}}, + {'type': 'styled', 'style': {'color': 'gold', 'bold': True}}, {'type': 'styled', 'style': {}}] + + +def sidebar(rng, n): + """An objective with scores, display names, number formats and teams.""" + owners = rng.sample(OWNERS, rng.randint(0, len(OWNERS))) + if rng.random() < 0.3: # more rows than the 15 shown + owners += [f'p{i}' for i in range(rng.randint(5, 20))] + scores = [{'owner': o, 'value': rng.choice([0, 1, -1, 7, 7, 100, 2147483647, -2147483648, rng.randint(-50, 50)]), + 'display': rng.choice([None, None, None, {'text': 'Shown ' + o, 'color': 'green'}]), + 'format': rng.choice(FORMATS)} for o in owners] + teams = [] + for t in range(rng.choice([0, 0, 1, 2])): + teams.append({'name': f'team{t}', 'prefix': rng.choice([{'text': ''}, {'text': '[A] '}, {'text': '<', 'color': 'red'}]), + 'suffix': rng.choice([{'text': ''}, {'text': ' *'}]), + 'color': rng.choice([None, 'red', 'blue', 'gold', 'white']), + 'members': [o for o in owners if rng.random() < 0.3]}) + return {**screen(rng), **backdrop(rng), + 'objective': {'display': rng.choice(TITLES + [{'text': 'Kills'}]), 'format': rng.choice(FORMATS)}, + 'scores': scores, 'teams': teams} + + # Generators by kind: (rng, index) -> case. Cases are drawn round-robin. KINDS = { 'decorations': decorations, 'effects': effects, 'title': title, 'selected': selected, + 'boss': boss, + 'jump': jump, + 'sidebar': sidebar, } From 5b53d37e308ff08f49c692680fe071901de24e44 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 13:13:12 +0200 Subject: [PATCH 4/7] Compare item decorations with GuiGraphicsExtractor.itemDecorations The decor cases run vanilla's itemDecorations on stacks with counts, durability (Item.getBarWidth/getBarColor), unbreakable stacks and item cooldowns ticked through ItemCooldowns. Horizon's item drawing now uses the same layout: the bar rounds and colours like vanilla's and the count sits at vanilla's offsets. Co-Authored-By: Claude Opus 5.5 --- .../examples/hud_fixture/kinds.rs | 36 ++++++++++- crates/horizon-client/src/game.rs | 46 +++++++------- crates/horizon-client/src/hud_overlays.rs | 60 +++++++++++++++++++ .../horizonlab/parity/VanillaHudOracle.java | 25 +++++++- tools/hud_parity_cases.py | 22 +++++++ 5 files changed, 166 insertions(+), 23 deletions(-) diff --git a/crates/horizon-client/examples/hud_fixture/kinds.rs b/crates/horizon-client/examples/hud_fixture/kinds.rs index fef5be327..912df200c 100644 --- a/crates/horizon-client/examples/hud_fixture/kinds.rs +++ b/crates/horizon-client/examples/hud_fixture/kinds.rs @@ -3,7 +3,7 @@ use horizon_client::{ brewing, component, hud::HudAtlas, hud_layout::{self, GuiDraw}, - hud_overlays::{self, BossBar, EffectIcon, HeldName, Titles, ToolHighlight}, + hud_overlays::{self, BossBar, EffectIcon, HeldName, ItemDecorations, Titles, ToolHighlight}, scoreboard::{NumberFormat, RenderType, Scoreboard}, text::{self, Text}, }; @@ -37,6 +37,7 @@ pub fn run(kind: &str, c: &Value, atlas: &HudAtlas) -> Vec { "boss" => boss(c, w, h, atlas), "jump" => hud_overlays::jump_bar(w, h, int(c, "cooldown", 0), float(c, "jumpScale", 0.0)), "sidebar" => sidebar(c, w, h, atlas), + "decor" => decor(c, atlas), _ => Vec::new(), } } @@ -187,3 +188,36 @@ fn sidebar(c: &Value, w: i32, h: i32, atlas: &HudAtlas) -> Vec { hud_layout::background_color(chat_only, opacity, 0.4), ) } + +/// `itemDecorations` for a stack with a count, damage and an item cooldown +/// `elapsed` ticks into `duration` (ItemCooldowns.getCooldownPercent). +fn decor(c: &Value, atlas: &HudAtlas) -> Vec { + let count = int(c, "count", 1); + if count <= 0 { + return Vec::new(); + } + let cd = &c["cooldown"]; + let cooldown = if cd.is_null() { + 0.0 + } else { + let (duration, elapsed) = (int(cd, "duration", 0), int(cd, "elapsed", 0)); + if duration <= elapsed { + 0.0 // ItemCooldowns.tick dropped it + } else { + let remaining = duration as f32 - (elapsed as f32 + float(c, "partial", 0.0)); + (remaining / duration as f32).clamp(0.0, 1.0) + } + }; + let max_damage = if c["unbreakable"].as_bool().unwrap_or(false) { + 0 + } else { + int(c, "maxDamage", 0) + }; + let d = ItemDecorations { + count: count as u32, + count_text: c["countText"].as_str().map(str::to_owned), + bar: hud_overlays::damage_bar(int(c, "damage", 0), max_damage), + cooldown, + }; + hud_overlays::item_decorations(int(c, "x", 0), int(c, "y", 0), &d, &atlas.font) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 96e326d3f..673f80210 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -108,7 +108,7 @@ use horizon_client::{ environment::Environment, gfx::{Frame, Renderer}, hud::{HudAtlas, HudBatch, rgba}, - hud_layout, + hud_layout, hud_overlays, items::{ItemStack, Items}, keymapping::KeyAction, light::LightTables, @@ -2844,26 +2844,30 @@ impl Game<'_> { // `GuiGraphics.renderItem`: the resolved item model (tints, foil and // special renderers included), then the decorations. self.draw_item_model(batch, stack, x, y); - let atlas = &self.res.atlas; - if stack.count > 1 { - let text = stack.count.to_string(); - let w = HudBatch::text_width(atlas, &text); - batch.text(atlas, &text, x + 17.0 - w, y + 9.0, u32::MAX, true); - } - if let Some(info) = self.res.items.get(&stack.item) - && info.max_damage > 0 - && stack.damage > 0 - { - let f = 1.0 - stack.damage as f32 / info.max_damage as f32; - let width = (13.0 * f).round(); - let hue = f / 3.0; - let (r, g) = ( - (255.0 * (1.0 - hue * 3.0).clamp(0.0, 1.0)) as u8, - (255.0 * (hue * 3.0).clamp(0.0, 1.0)) as u8, - ); - batch.fill(atlas, x + 2.0, y + 13.0, 13.0, 2.0, rgba(0, 0, 0, 255)); - batch.fill(atlas, x + 2.0, y + 13.0, width, 1.0, rgba(r, g, 0, 255)); - } + // GuiGraphicsExtractor.itemDecorations, laid out at the origin and + // moved to (x, y). Horizon tracks no item cooldowns to shade yet. + let max_damage = self + .res + .items + .get(&stack.item) + .map_or(0, |info| info.max_damage as i32); + let decorations = hud_overlays::ItemDecorations { + count: stack.count, + count_text: None, + bar: hud_overlays::damage_bar(stack.damage as i32, max_damage), + cooldown: 0.0, + }; + let mut draws = vec![hud_layout::GuiDraw::Push(vec![ + hud_layout::PoseOp::Translate(x, y), + ])]; + draws.extend(hud_overlays::item_decorations( + 0, + 0, + &decorations, + &self.res.atlas.font, + )); + draws.push(hud_layout::GuiDraw::Pop); + hud_layout::paint(batch, &self.res.atlas, &draws); } fn hud(&mut self, size: [u32; 2]) -> HudBatch { let mut batch = HudBatch::new(size); diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index 8c554898a..ae6ca88e6 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -632,3 +632,63 @@ pub fn sidebar( } out } + +/// `Mth.ceil`. +fn ceil(x: f32) -> i32 { + let i = x as i32; + if x > i as f32 { i + 1 } else { i } +} + +/// What `GuiGraphicsExtractor.itemDecorations` draws over a stack. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct ItemDecorations { + pub count: u32, + /// The text shown instead of the count, if any. + pub count_text: Option, + /// `isBarVisible`: `getBarWidth` and `getBarColor` (RGB). + pub bar: Option<(i32, u32)>, + /// `ItemCooldowns.getCooldownPercent` of the stack. + pub cooldown: f32, +} + +/// `Item.getBarWidth` and `getBarColor` for a damaged stack (`isDamaged`). +pub fn damage_bar(damage: i32, max_damage: i32) -> Option<(i32, u32)> { + if max_damage <= 0 || damage <= 0 { + return None; + } + let width = (13.0 - damage as f32 * 13.0 / max_damage as f32) + .round() + .clamp(0.0, 13.0) as i32; + let health = ((max_damage as f32 - damage as f32) / max_damage as f32).max(0.0); + Some((width, hsv_to_argb(health / 3.0, 1.0, 1.0, 0))) +} + +/// `GuiGraphicsExtractor.itemDecorations` for a non-empty stack at (x, y): +/// the durability bar, the cooldown shade and the count. +pub fn item_decorations(x: i32, y: i32, d: &ItemDecorations, font: &Font) -> Vec { + let mut out = vec![GuiDraw::Push(Vec::new())]; + if let Some((width, color)) = d.bar { + let (left, top) = (x + 2, y + 13); + out.push(fill(left, top, left + 13, top + 2, 0xFF00_0000)); + out.push(fill(left, top, left + width, top + 1, color | 0xFF00_0000)); + } + if d.cooldown > 0.0 { + let top = y + crate::hud_layout::floor(16.0 * (1.0 - d.cooldown)); + let bottom = top + ceil(16.0 * d.cooldown); + out.push(fill(x, top, x + 16, bottom, 0x7FFF_FFFF)); + } + if d.count != 1 || d.count_text.is_some() { + let amount = d.count_text.clone().unwrap_or_else(|| d.count.to_string()); + let w = font.width(&amount) as i32; + text( + &mut out, + Text::literal(amount), + x + 19 - 2 - w, + y + 6 + 3, + crate::hud_layout::WHITE, + true, + ); + } + out.push(GuiDraw::Pop); + out +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java index 9b22bb327..caa521847 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java @@ -281,7 +281,11 @@ public final class VanillaHudOracle { o.add("matrix", a); draws.add(o); } - @Override public void itemDecorations(Font font, ItemStack stack, int x, int y, String count) { } + /** Off for the hotbar cases (Horizon draws the decorations with the item). */ + boolean realDecorations; + @Override public void itemDecorations(Font font, ItemStack stack, int x, int y, String count) { + if (realDecorations) super.itemDecorations(font, stack, x, y, count); + } } public static void main(String[] args) throws Exception { @@ -388,6 +392,7 @@ public final class VanillaHudOracle { capture.draws = new JsonArray(); capture.stack = new Matrix3x2fStack(16); put(capture, GuiGraphicsExtractor.class, "minecraft", mc); + put(capture, GuiGraphicsExtractor.class, "pose", capture.stack); float partial = f("partial", 0); DeltaTracker delta = (DeltaTracker) Proxy.newProxyInstance(DeltaTracker.class.getClassLoader(), new Class[] {DeltaTracker.class}, (proxy, method, a) -> method.getReturnType() == float.class ? partial : null); @@ -487,6 +492,24 @@ public final class VanillaHudOracle { } sidebar.invoke(hud, capture, objective); } + case "decor" -> { + var stack = new ItemStack(BuiltInRegistries.ITEM.getValue(Identifier.withDefaultNamespace(c.get("item").getAsString()))); + stack.setCount(i("count", 1)); + stack.setDamageValue(i("damage", 0)); + if (b("unbreakable")) stack.set(net.minecraft.core.component.DataComponents.UNBREAKABLE, net.minecraft.util.Unit.INSTANCE); + var cooldowns = new net.minecraft.world.item.ItemCooldowns(); + put(actor, net.minecraft.world.entity.player.Player.class, "cooldowns", cooldowns); + if (c.has("cooldown") && !c.get("cooldown").isJsonNull()) { + var cd = c.getAsJsonObject("cooldown"); + cooldowns.addCooldown(stack, cd.get("duration").getAsInt()); + for (int n = cd.get("elapsed").getAsInt(); n > 0; n--) cooldowns.tick(); + } + var timer = alloc(DeltaTracker.Timer.class); + put(timer, DeltaTracker.Timer.class, "deltaTickResidual", partial); + put(mc, Minecraft.class, "deltaTracker", timer); + capture.realDecorations = true; + capture.itemDecorations(font, stack, i("x", 0), i("y", 0), c.has("countText") ? c.get("countText").getAsString() : null); + } default -> throw new IllegalArgumentException(c.get("kind").getAsString()); } result.add("draws", capture.draws); diff --git a/tools/hud_parity_cases.py b/tools/hud_parity_cases.py index 98dc7ab21..ec0e1459a 100644 --- a/tools/hud_parity_cases.py +++ b/tools/hud_parity_cases.py @@ -153,6 +153,27 @@ def sidebar(rng, n): 'scores': scores, 'teams': teams} + +# Items for the decorations: id and max damage (0 = not damageable), checked by the oracle's own stacks. +DECOR_ITEMS = [('diamond_sword', 1561), ('bow', 384), ('shield', 336), ('flint_and_steel', 64), ('elytra', 432), + ('stone', 0), ('ender_pearl', 0), ('apple', 0)] + + +def decor(rng, n): + """GuiGraphicsExtractor.itemDecorations: count, durability bar and cooldown shade.""" + item, max_damage = rng.choice(DECOR_ITEMS) + case = {'x': rng.randint(-20, 400), 'y': rng.randint(-20, 300), 'item': item, 'maxDamage': max_damage, + 'count': rng.choice([1, 1, 2, 16, 64, 99, 0, 10, 127]), + 'damage': rng.choice([0, 0, 1, max_damage // 2, max_damage - 1, max_damage, rng.randint(0, max(max_damage, 1))]) if max_damage else 0, + 'unbreakable': rng.random() < 0.1, 'partial': round(rng.random(), 3)} + if rng.random() < 0.4: + duration = rng.choice([1, 2, 7, 20, 100, 200]) + case['cooldown'] = {'duration': duration, 'elapsed': rng.choice([0, 1, duration - 1, duration, rng.randint(0, duration)])} + if rng.random() < 0.1: + case['countText'] = rng.choice(['', '+', '1/2', 'x9']) + return case + + # Generators by kind: (rng, index) -> case. Cases are drawn round-robin. KINDS = { 'decorations': decorations, @@ -162,4 +183,5 @@ KINDS = { 'boss': boss, 'jump': jump, 'sidebar': sidebar, + 'decor': decor, } From ef0c6604a573e495eb176cfffdf4c65f09017158 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 13:19:38 +0200 Subject: [PATCH 5/7] Compare camera overlays and the sleep overlay with vanilla's Hud The overlays cases run Hud.extractCameraOverlays and extractSleepOverlay: the vignette with its brightness and world border warning, the spyglass scope and its scopeScale easing (read back and compared), equipment camera overlays, powder snow, the nether portal sprite and the nausea swirl. The game feeds its full-screen camera overlays from the same layout (the vignette option and first person now count), draws the spyglass with vanilla's unclamped easing and the sleep fade at vanilla's opacity under the sidebar, titles and chat. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/examples/hud_fixture.rs | 7 +- .../examples/hud_fixture/kinds.rs | 72 +++++- crates/horizon-client/src/game.rs | 11 +- crates/horizon-client/src/game/fov.rs | 29 +-- crates/horizon-client/src/game/render_tick.rs | 41 +++- crates/horizon-client/src/hud_overlays.rs | 210 +++++++++++++++++- crates/horizon-client/src/screen_effects.rs | 89 ++++---- .../horizonlab/parity/VanillaHudOracle.java | 48 ++++ tools/hud_parity_cases.py | 23 ++ tools/test_hud_parity.py | 5 + 10 files changed, 449 insertions(+), 86 deletions(-) diff --git a/crates/horizon-client/examples/hud_fixture.rs b/crates/horizon-client/examples/hud_fixture.rs index 46da5e0ad..dcb594088 100644 --- a/crates/horizon-client/examples/hud_fixture.rs +++ b/crates/horizon-client/examples/hud_fixture.rs @@ -33,11 +33,14 @@ fn main() -> Result<()> { .filter(|l| !l.is_empty()) { let c: Value = serde_json::from_str(line)?; + // State the case reads back besides the draws (e.g. `scopeScale`). + let mut state = serde_json::Map::new(); let draws = match c["kind"].as_str().unwrap_or("decorations") { "decorations" => decorations(&c, &atlas), - kind => kinds::run(kind, &c, &atlas), + kind => kinds::run(kind, &c, &atlas, &mut state), }; - writeln!(out, "{}", json!({ "draws": encode(&draws) }))?; + state.insert("draws".into(), json!(encode(&draws))); + writeln!(out, "{}", Value::Object(state))?; } Ok(()) } diff --git a/crates/horizon-client/examples/hud_fixture/kinds.rs b/crates/horizon-client/examples/hud_fixture/kinds.rs index 912df200c..0c423c76a 100644 --- a/crates/horizon-client/examples/hud_fixture/kinds.rs +++ b/crates/horizon-client/examples/hud_fixture/kinds.rs @@ -3,7 +3,9 @@ use horizon_client::{ brewing, component, hud::HudAtlas, hud_layout::{self, GuiDraw}, - hud_overlays::{self, BossBar, EffectIcon, HeldName, ItemDecorations, Titles, ToolHighlight}, + hud_overlays::{ + self, BossBar, CameraOverlays, EffectIcon, HeldName, ItemDecorations, Titles, ToolHighlight, + }, scoreboard::{NumberFormat, RenderType, Scoreboard}, text::{self, Text}, }; @@ -28,7 +30,12 @@ fn background(c: &Value) -> u32 { ) } -pub fn run(kind: &str, c: &Value, atlas: &HudAtlas) -> Vec { +pub fn run( + kind: &str, + c: &Value, + atlas: &HudAtlas, + state: &mut serde_json::Map, +) -> Vec { let (w, h) = (int(c, "width", 0), int(c, "height", 0)); match kind { "effects" => effects(c, w), @@ -38,6 +45,7 @@ pub fn run(kind: &str, c: &Value, atlas: &HudAtlas) -> Vec { "jump" => hud_overlays::jump_bar(w, h, int(c, "cooldown", 0), float(c, "jumpScale", 0.0)), "sidebar" => sidebar(c, w, h, atlas), "decor" => decor(c, atlas), + "overlays" => overlays(c, w, h, state), _ => Vec::new(), } } @@ -221,3 +229,63 @@ fn decor(c: &Value, atlas: &HudAtlas) -> Vec { }; hud_overlays::item_decorations(int(c, "x", 0), int(c, "y", 0), &d, &atlas.font) } + +/// `Hud.extractCameraOverlays` then `extractSleepOverlay`; the border is +/// static, so only its warning blocks matter. +fn overlays(c: &Value, w: i32, h: i32, state: &mut serde_json::Map) -> Vec { + let partial = float(c, "partial", 0.0); + let warning = match &c["border"] { + Value::Null => 0.0, + b => { + // WorldBorder.getDistanceToBorder with the static extent's clamped box. + let max = 29_999_984.0; + let half = b["size"].as_f64().unwrap_or(0.0) / 2.0; + let (cx, cz) = ( + b["centerX"].as_f64().unwrap_or(0.0), + b["centerZ"].as_f64().unwrap_or(0.0), + ); + let (min_x, max_x) = ((cx - half).clamp(-max, max), (cx + half).clamp(-max, max)); + let (min_z, max_z) = ((cz - half).clamp(-max, max), (cz + half).clamp(-max, max)); + let (x, z) = ( + f64::from(float(c, "camX", 0.0)), + f64::from(float(c, "camZ", 0.0)), + ); + let distance = (x - min_x).min(max_x - x).min(z - min_z).min(max_z - z); + hud_overlays::border_warning( + distance as f32, + int(b, "warningBlocks", 5), + int(b, "warningTime", 15), + 0.0, + 0.0, + ) + } + }; + let ticks_frozen = int(c, "ticksFrozen", 0); + let inputs = CameraOverlays { + vignette: c["vignette"] + .as_bool() + .unwrap_or(false) + .then(|| (float(c, "vignetteBrightness", 1.0), warning)), + first_person: c["firstPerson"].as_bool().unwrap_or(false), + scoping: c["scoping"].as_bool().unwrap_or(false), + game_time_delta: partial, + equipment: match c["head"].as_str() { + Some("carved_pumpkin") => vec!["misc/pumpkinblur".to_owned()], + _ => Vec::new(), + }, + ticks_frozen, + percent_frozen: ticks_frozen.min(140) as f32 / 140.0, + partial, + portal: [ + c["portal"][0].as_f64().unwrap_or(0.0) as f32, + c["portal"][1].as_f64().unwrap_or(0.0) as f32, + ], + nausea: float(c, "nausea", 0.0), + screen_effect_scale: float(c, "screenEffectScale", 1.0), + }; + let mut scope = float(c, "scopeScale", 0.5); + let mut out = hud_overlays::camera_overlays(w, h, &inputs, &mut scope); + out.extend(hud_overlays::sleep_overlay(w, h, int(c, "sleepTimer", 0))); + state.insert("scopeScale".into(), serde_json::json!(scope)); + out +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 673f80210..c44806b4e 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -2936,6 +2936,11 @@ impl Game<'_> { self.draw_effect_icons(&mut batch); // Hud: the action bar and titles draw over the hotbar (nextStratum). self.draw_boss_bars(&mut batch); + // Hud.extractSleepOverlay, under the sidebar, titles and chat. + if let Some((_, ticks)) = self.sleeping { + let draws = hud_overlays::sleep_overlay(wi, hi, ticks as i32); + hud_layout::paint(&mut batch, &self.res.atlas, &draws); + } self.draw_titles(&mut batch); self.draw_scoreboard(&mut batch); self.draw_subtitles(&mut batch); @@ -3109,12 +3114,6 @@ impl Game<'_> { batch.text(atlas, text, (w - tw) / 2.0, h - 59.0, u32::MAX, true); } self.draw_chat(&mut batch); - let atlas = &self.res.atlas; - if let Some((_, ticks)) = self.sleeping { - // Gui sleep overlay fading in over 100 ticks. - let a = ((ticks as f32 / 100.0).min(1.0) * 204.0) as u8; - batch.fill(atlas, 0.0, 0.0, w, h, rgba(16, 16, 32, a)); - } match self.screen { Screen::Paused => self.draw_pause_menu(&mut batch), Screen::Dead => self.draw_death_screen(&mut batch), diff --git a/crates/horizon-client/src/game/fov.rs b/crates/horizon-client/src/game/fov.rs index faf0f0924..d584d6721 100644 --- a/crates/horizon-client/src/game/fov.rs +++ b/crates/horizon-client/src/game/fov.rs @@ -8,7 +8,8 @@ use horizon_client::{ BobState, CameraFluid, FovPlayer, HurtBob, UseItem, bob_matrix, field_of_view_modifier, }, fog::{FogType, fog_type}, - hud::{HudBatch, rgba}, + hud::HudBatch, + hud_layout, hud_overlays, }; /// `Abilities.walkingSpeed`. @@ -145,26 +146,20 @@ impl Game<'_> { self.audio .play("minecraft:item.spyglass.stop_using", at, 1.0, 1.0); } - /// `Hud.extractCameraOverlays`: the scope, its size easing from 0.5 to - /// 1.125 at half a step per tick of frame time. + /// `Hud.extractCameraOverlays`: the spyglass scope, its size easing + /// towards 1.125 by half the frame's game ticks and reset to 0.5 while + /// not scoping in first person. pub(super) fn draw_spyglass(&mut self, batch: &mut HudBatch) { + self.scope_scale += 0.5 * self.frame_ticks * (1.125 - self.scope_scale); + if !self.camera_type.first_person() { + return; + } if !self.scoping() { self.scope_scale = 0.5; return; } - self.scope_scale += (1.125 - self.scope_scale) * (0.5 * self.frame_ticks).min(1.0); - let atlas = &self.res.atlas; - let (w, h) = (batch.width, batch.height); - let src = w.min(h); - let ratio = (w / src).min(h / src) * self.scope_scale; - let (sw, sh) = ((src * ratio).floor(), (src * ratio).floor()); - let (left, top) = (((w - sw) / 2.0).floor(), ((h - sh) / 2.0).floor()); - let (right, bottom) = (left + sw, top + sh); - batch.sprite_scaled(atlas, "misc/spyglass_scope", left, top, sw, sh, u32::MAX); - let black = rgba(0, 0, 0, 255); - batch.fill(atlas, 0.0, bottom, w, h - bottom, black); - batch.fill(atlas, 0.0, 0.0, w, top, black); - batch.fill(atlas, 0.0, top, left, bottom - top, black); - batch.fill(atlas, right, top, w - right, bottom - top, black); + let draws = + hud_overlays::spyglass(batch.width as i32, batch.height as i32, self.scope_scale); + hud_layout::paint(batch, &self.res.atlas, &draws); } } diff --git a/crates/horizon-client/src/game/render_tick.rs b/crates/horizon-client/src/game/render_tick.rs index c7605f257..a915619a1 100644 --- a/crates/horizon-client/src/game/render_tick.rs +++ b/crates/horizon-client/src/game/render_tick.rs @@ -2,7 +2,6 @@ //! campfire smoke and rain splashes (`ClientLevel.tickWeatherEffects`). use super::{Dim, Game}; use horizon_client::fog::{FogData, FogInputs, FogType, fog_type, update_rain_fog}; -use horizon_client::screen_effects::{ScreenInputs, ScreenQuad, lightmap_brightness}; use horizon_client::{ animate_tick::{AnimateContext, animate_tick, campfire_particles}, biome::Biomes, @@ -11,6 +10,10 @@ use horizon_client::{ particles::{ParticleLevel, ParticleOptions, ParticleType}, world::World, }; +use horizon_client::{ + hud_overlays, + screen_effects::{ScreenInputs, ScreenQuad, lightmap_brightness}, +}; use horizon_core::random::{LegacyRandom, RandomSource}; /// The first motion-blocking block at or below `from` (Heightmap MOTION_BLOCKING), plus one. @@ -140,12 +143,33 @@ impl Game<'_> { fog_type(&self.world, &self.res.facts, eye, self.forward()) == FogType::Water; let water = (in_water && !spectator).then(|| (self.eye_brightness(eye), self.yaw, self.pitch)); - let camera_overlays = match &self.armor[0] { - Some(stack) if &*stack.item == "minecraft:carved_pumpkin" => { - vec!["misc/pumpkinblur".to_owned()] - } - _ => Vec::new(), + // Hud.extractCameraOverlays; the spyglass scope (and its easing) is + // drawn on the HUD by draw_spyglass. + let fx = &self.res.screen_fx; + let overlays = hud_overlays::CameraOverlays { + vignette: self + .settings + .vignette + .then_some((fx.vignette_brightness, 0.0)), + first_person: self.camera_type.first_person(), + scoping: self.scoping(), + game_time_delta: 0.0, + equipment: match &self.armor[0] { + Some(stack) if &*stack.item == "minecraft:carved_pumpkin" => { + vec!["misc/pumpkinblur".to_owned()] + } + _ => Vec::new(), + }, + ticks_frozen: 0, + percent_frozen: 0.0, + partial, + portal: [fx.o_portal, fx.portal], + nausea: 0.0, + screen_effect_scale: 1.0, }; + let mut scope = self.scope_scale; + let gui_overlays = + hud_overlays::camera_overlays(size[0] as i32, size[1] as i32, &overlays, &mut scope); self.res.screen_fx.build(&ScreenInputs { sprites: &self.res.atlas.sprites, aspect: size[0] as f32 / size[1].max(1) as f32, @@ -153,10 +177,7 @@ impl Game<'_> { block_overlay, water, on_fire: false, - camera_overlays, - frozen: 0.0, - vignette: true, - border_warning: None, + gui_overlays: &gui_overlays, }) } /// `Lightmap.getBrightness(getMaxLocalRawBrightness(eye))`. diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index ae6ca88e6..7c43c1a43 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -5,7 +5,9 @@ //! selected item name (`extractSelectedItemName` and its `toolHighlightTimer`). use crate::{ font::Font, - hud_layout::{GuiDraw, PoseOp, fill, hsv_to_argb, multiply, white, width}, + hud_layout::{ + Blend, GuiDraw, PoseOp, color_from_float, fill, hsv_to_argb, multiply, white, width, + }, text::{Style, Text}, }; use std::{borrow::Cow, cmp::Ordering}; @@ -692,3 +694,209 @@ pub fn item_decorations(x: i32, y: i32, d: &ItemDecorations, font: &Font) -> Vec out.push(GuiDraw::Pop); out } + +/// A full-screen `graphics.blit` of `textures/.png`. +fn screen_blit( + w: i32, + h: i32, + texture: impl Into>, + blend: Blend, + color: u32, +) -> GuiDraw { + GuiDraw::Blit { + texture: texture.into(), + blend, + x: 0, + y: 0, + w, + h, + uv: [0.0, 0.0], + src: [w, h], + tex: [w, h], + color, + } +} + +/// `Hud.extractVignette`: `brightness` is `vignetteBrightness` and +/// `border_warning` the world border warning strength (0 when far). +pub fn vignette(w: i32, h: i32, brightness: f32, border_warning: f32) -> GuiDraw { + let brightness = brightness.clamp(0.0, 1.0); + let color = if border_warning > 0.0 { + let warning = border_warning.clamp(0.0, 1.0); + let red = brightness * (1.0 - warning); + let green_blue = brightness + (1.0 - brightness) * warning; + color_from_float(1.0, red, green_blue, green_blue) + } else { + color_from_float(1.0, brightness, brightness, brightness) + }; + screen_blit(w, h, "misc/vignette", Blend::Vignette, color) +} + +/// The border warning strength of `extractVignette` for a camera +/// `distance` from a border with `warning_blocks`, `warning_time`, its +/// `lerp_speed` and how far its size still has to move. +pub fn border_warning( + distance: f32, + warning_blocks: i32, + warning_time: i32, + lerp_speed: f64, + size_left: f64, +) -> f32 { + let moving = (lerp_speed * f64::from(warning_time)).min(size_left.abs()); + let warning_distance = f64::from(warning_blocks).max(moving); + if f64::from(distance) < warning_distance { + 1.0 - (f64::from(distance) / warning_distance) as f32 + } else { + 0.0 + } +} + +/// `Hud.extractSpyglassOverlay`. +pub fn spyglass(w: i32, h: i32, scale: f32) -> Vec { + let src = w.min(h) as f32; + let ratio = (w as f32 / src).min(h as f32 / src) * scale; + let width = crate::hud_layout::floor(src * ratio); + let height = crate::hud_layout::floor(src * ratio); + let left = (w - width) / 2; + let top = (h - height) / 2; + let (right, bottom) = (left + width, top + height); + vec![ + GuiDraw::Blit { + texture: Cow::Borrowed("misc/spyglass_scope"), + blend: Blend::Textured, + x: left, + y: top, + w: width, + h: height, + uv: [0.0, 0.0], + src: [width, height], + tex: [width, height], + color: crate::hud_layout::WHITE, + }, + fill(0, bottom, w, h, 0xFF00_0000), + fill(0, 0, w, top, 0xFF00_0000), + fill(0, top, left, bottom, 0xFF00_0000), + fill(right, top, w, bottom, 0xFF00_0000), + ] +} + +/// `Hud.extractPortalOverlay`: the nether portal block sprite over the screen. +pub fn portal_overlay(w: i32, h: i32, mut alpha: f32) -> GuiDraw { + if alpha < 1.0 { + alpha *= alpha; + alpha *= alpha; + alpha = alpha * 0.8 + 0.2; + } + GuiDraw::AtlasSprite { + sprite: Cow::Borrowed("block/nether_portal"), + x: 0, + y: 0, + w, + h, + color: white(alpha), + } +} + +/// `Hud.extractConfusionOverlay`: the nausea swirl scaled about the centre. +pub fn confusion_overlay(w: i32, h: i32, strength: f32) -> Vec { + let size = 2.0 + strength * (1.0 - 2.0); + let (cx, cy) = (w as f32 / 2.0, h as f32 / 2.0); + vec![ + GuiDraw::Push(vec![ + PoseOp::Translate(cx, cy), + PoseOp::Scale(size, size), + PoseOp::Translate(-cx, -cy), + ]), + screen_blit( + w, + h, + "misc/nausea", + Blend::Nausea, + color_from_float(1.0, 0.2 * strength, 0.4 * strength, 0.2 * strength), + ), + GuiDraw::Pop, + ] +} + +/// What `Hud.extractCameraOverlays` reads. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct CameraOverlays { + /// `Options.vignette`: `vignetteBrightness` and the border warning strength. + pub vignette: Option<(f32, f32)>, + pub first_person: bool, + /// `LocalPlayer.isScoping`. + pub scoping: bool, + /// `DeltaTracker.getGameTimeDeltaTicks`. + pub game_time_delta: f32, + /// `Equippable.cameraOverlay` textures (`misc/pumpkinblur`) of the worn + /// items in `EquipmentSlot` order. + pub equipment: Vec, + /// `getTicksFrozen` and `getPercentFrozen`. + pub ticks_frozen: i32, + pub percent_frozen: f32, + /// The partial tick and `oPortalEffectIntensity` / `portalEffectIntensity`. + pub partial: f32, + pub portal: [f32; 2], + /// `getEffectBlendFactor(NAUSEA, partial)` and `Options.screenEffectScale`. + pub nausea: f32, + pub screen_effect_scale: f32, +} + +/// `Hud.extractCameraOverlays`, easing `scope_scale` (`Hud.scopeScale`). +pub fn camera_overlays(w: i32, h: i32, i: &CameraOverlays, scope_scale: &mut f32) -> Vec { + let mut out = Vec::new(); + if let Some((brightness, warning)) = i.vignette { + out.push(vignette(w, h, brightness, warning)); + } + *scope_scale += 0.5 * i.game_time_delta * (1.125 - *scope_scale); + if i.first_person { + if i.scoping { + out.extend(spyglass(w, h, *scope_scale)); + } else { + *scope_scale = 0.5; + for texture in &i.equipment { + out.push(screen_blit( + w, + h, + texture.clone(), + Blend::Textured, + crate::hud_layout::WHITE, + )); + } + } + } + if i.ticks_frozen > 0 { + out.push(screen_blit( + w, + h, + "misc/powder_snow_outline", + Blend::Textured, + white(i.percent_frozen), + )); + } + let portal = i.portal[0] + i.partial * (i.portal[1] - i.portal[0]); + if portal > 0.0 { + out.push(portal_overlay(w, h, portal)); + } else if i.nausea > 0.0 && i.screen_effect_scale < 1.0 { + out.extend(confusion_overlay( + w, + h, + i.nausea * (1.0 - i.screen_effect_scale), + )); + } + out +} + +/// `Hud.extractSleepOverlay`. +pub fn sleep_overlay(w: i32, h: i32, sleep_timer: i32) -> Vec { + if sleep_timer <= 0 { + return Vec::new(); + } + let timer = sleep_timer as f32; + let mut amount = timer / 100.0; + if amount > 1.0 { + amount = 1.0 - (timer - 100.0) / 10.0; + } + let color = (((220.0 * amount) as i32) << 24) as u32 | 0x10_1020; + vec![fill(0, 0, w, h, color)] +} diff --git a/crates/horizon-client/src/screen_effects.rs b/crates/horizon-client/src/screen_effects.rs index ca728779c..bc7756453 100644 --- a/crates/horizon-client/src/screen_effects.rs +++ b/crates/horizon-client/src/screen_effects.rs @@ -1,9 +1,10 @@ //! Full-screen camera effects drawn between the world and the HUD: //! `ScreenEffectRenderer` (in-wall block texture, underwater overlay, fire) -//! and the `Hud` camera overlays (vignette, pumpkin blur, powder-snow +//! and the full-screen `Hud` camera overlays laid out by +//! `hud_overlays::camera_overlays` (vignette, pumpkin blur, powder-snow //! outline, nether portal swirl). Positions are clip-space quads; textures //! come from the shared 2D atlas and may repeat. -use crate::hud::Rect; +use crate::{hud::Rect, hud_layout::GuiDraw}; use std::collections::HashMap; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -40,14 +41,9 @@ pub struct ScreenInputs<'a> { /// Eye in water: (lightmap brightness at the eye, yaw, pitch). pub water: Option<(f32, f32, f32)>, pub on_fire: bool, - /// Equipment camera overlays (`Equippable.cameraOverlay`, e.g. `misc/pumpkinblur`). - pub camera_overlays: Vec, - /// `Player.getPercentFrozen`. - pub frozen: f32, - /// `Options.vignette`. - pub vignette: bool, - /// Distance to the world border and its warning distance, when close. - pub border_warning: Option, + /// `Hud.extractCameraOverlays` draws: the full-screen blits become + /// screen quads (the spyglass, its fills and the nausea swirl do not). + pub gui_overlays: &'a [GuiDraw], } /// Effect state advanced every tick. @@ -170,43 +166,43 @@ impl ScreenEffects { }), blend, }; - if input.vignette - && let Some(rect) = sprite("misc/vignette") - { - let b = self.vignette_brightness.clamp(0.0, 1.0); - let color = match input.border_warning { - Some(w) if w > 0.0 => { - let w = w.clamp(0.0, 1.0); - let red = b * (1.0 - w); - let gb = b + (1.0 - b) * w; - [red, gb, gb, 1.0] + let rgba = |c: u32| { + let [a, r, g, b] = c.to_be_bytes(); + [r, g, b, a].map(|v| f32::from(v) / 255.0) + }; + for d in input.gui_overlays { + match d { + GuiDraw::Blit { + texture, + blend, + x: 0, + y: 0, + color, + .. + } if *blend != crate::hud_layout::Blend::Nausea + && texture != "misc/spyglass_scope" => + { + let blend = if *blend == crate::hud_layout::Blend::Vignette { + Blend::Vignette + } else { + Blend::Alpha + }; + if let Some(rect) = sprite(texture) { + out.push(gui(rect, rgba(*color), blend)); + } } - _ => [b, b, b, 1.0], - }; - out.push(gui(rect, color, Blend::Vignette)); - } - for overlay in &input.camera_overlays { - if let Some(rect) = sprite(overlay) { - out.push(gui(rect, [1.0; 4], Blend::Alpha)); + GuiDraw::AtlasSprite { + sprite: name, + color, + .. + } => { + if let Some(rect) = sprite(name) { + out.push(gui(rect, rgba(*color), Blend::Alpha)); + } + } + _ => {} } } - if input.frozen > 0.0 - && let Some(rect) = sprite("misc/powder_snow_outline") - { - out.push(gui(rect, [1.0, 1.0, 1.0, input.frozen], Blend::Alpha)); - } - let portal = self.o_portal + (self.portal - self.o_portal) * input.partial; - if portal > 0.0 - && let Some(rect) = sprite("block/nether_portal") - { - let mut a = portal; - if a < 1.0 { - a *= a; - a *= a; - a = a * 0.8 + 0.2; - } - out.push(gui(rect, [1.0, 1.0, 1.0, a], Blend::Alpha)); - } out } } @@ -254,10 +250,7 @@ mod tests { block_overlay: None, water: Some((1.0, 0.0, 0.0)), on_fire: false, - camera_overlays: vec![], - frozen: 0.0, - vignette: true, - border_warning: None, + gui_overlays: &[crate::hud_overlays::vignette(320, 240, 1.0, 0.0)], }; let quads = e.build(&input); assert_eq!(quads.len(), 1); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java index caa521847..322087a83 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java @@ -148,6 +148,16 @@ public final class VanillaHudOracle { : method.getReturnType() == boolean.class ? false : method.getReturnType() == float.class ? 0.0F : null); } @Override public float getJumpRidingScale() { return f("jumpScale", 0); } + @Override public ItemStack getItemBySlot(net.minecraft.world.entity.EquipmentSlot slot) { + return slot == net.minecraft.world.entity.EquipmentSlot.HEAD && c.has("head") && !c.get("head").isJsonNull() + ? new ItemStack(BuiltInRegistries.ITEM.getValue(Identifier.withDefaultNamespace(c.get("head").getAsString()))) : ItemStack.EMPTY; + } + @Override public int getTicksFrozen() { return i("ticksFrozen", 0); } + @Override public boolean isScoping() { return b("scoping"); } + @Override public float getEffectBlendFactor(Holder effect, float partial) { + return effect.is(net.minecraft.world.effect.MobEffects.NAUSEA) ? f("nausea", 0) : 0.0F; + } + @Override public int getSleepTimer() { return i("sleepTimer", 0); } @Override public void playSound(net.minecraft.sounds.SoundEvent sound, float volume, float pitch) { } } @@ -306,6 +316,8 @@ public final class VanillaHudOracle { Method overlayMessage = hudMethod("extractOverlayMessage", GuiGraphicsExtractor.class, DeltaTracker.class); Method selectedName = hudMethod("extractSelectedItemName", GuiGraphicsExtractor.class); Method tick = hudMethod("tick"); + Method cameraOverlays = hudMethod("extractCameraOverlays", GuiGraphicsExtractor.class, DeltaTracker.class); + Method sleep = hudMethod("extractSleepOverlay", GuiGraphicsExtractor.class, DeltaTracker.class); Method sidebar = hudMethod("displayScoreboardSidebar", GuiGraphicsExtractor.class, net.minecraft.world.scores.Objective.class); Method level = Class.forName("net.minecraft.client.gui.contextualbar.ContextualBar") .getDeclaredMethod("extractExperienceLevel", GuiGraphicsExtractor.class, Font.class, int.class); @@ -510,6 +522,42 @@ public final class VanillaHudOracle { capture.realDecorations = true; capture.itemDecorations(font, stack, i("x", 0), i("y", 0), c.has("countText") ? c.get("countText").getAsString() : null); } + case "overlays" -> { + put(options, Options.class, "vignette", option(b("vignette"))); + put(options, Options.class, "cameraType", b("firstPerson") ? net.minecraft.client.CameraType.FIRST_PERSON : net.minecraft.client.CameraType.THIRD_PERSON_BACK); + put(options, Options.class, "screenEffectScale", option((double) f("screenEffectScale", 1))); + var border = new net.minecraft.world.level.border.WorldBorder(); + if (c.has("border") && !c.get("border").isJsonNull()) { + var bo = c.getAsJsonObject("border"); + border.setCenter(bo.get("centerX").getAsDouble(), bo.get("centerZ").getAsDouble()); + border.setSize(bo.get("size").getAsDouble()); + border.setWarningBlocks(bo.get("warningBlocks").getAsInt()); + border.setWarningTime(bo.get("warningTime").getAsInt()); + } + put(clientLevel, ClientLevel.class, "worldBorder", border); + put(mc, Minecraft.class, "level", clientLevel); + put(actor, Entity.class, "position", new net.minecraft.world.phys.Vec3(f("camX", 0), 64, f("camZ", 0))); + actor.oPortalEffectIntensity = c.getAsJsonArray("portal").get(0).getAsFloat(); + actor.portalEffectIntensity = c.getAsJsonArray("portal").get(1).getAsFloat(); + put(hud, Hud.class, "vignetteBrightness", f("vignetteBrightness", 1)); + put(hud, Hud.class, "scopeScale", f("scopeScale", 0.5F)); + // The nether portal particle sprite, as the block model set would give it. + var contents = alloc(net.minecraft.client.renderer.texture.SpriteContents.class); + put(contents, net.minecraft.client.renderer.texture.SpriteContents.class, "name", Identifier.withDefaultNamespace("block/nether_portal")); + var sprite = alloc(net.minecraft.client.renderer.texture.TextureAtlasSprite.class); + put(sprite, net.minecraft.client.renderer.texture.TextureAtlasSprite.class, "contents", contents); + var material = new net.minecraft.client.resources.model.sprite.Material.Baked(sprite, false); + var model = (net.minecraft.client.renderer.block.dispatch.BlockStateModel) Proxy.newProxyInstance(Actor.class.getClassLoader(), + new Class[] {net.minecraft.client.renderer.block.dispatch.BlockStateModel.class}, + (proxy, method, a) -> method.getName().equals("particleMaterial") ? material : null); + var models = alloc(net.minecraft.client.resources.model.ModelManager.class); + put(models, net.minecraft.client.resources.model.ModelManager.class, "blockStateModelSet", + new net.minecraft.client.renderer.block.BlockStateModelSet(Map.of(), model)); + put(mc, Minecraft.class, "modelManager", models); + cameraOverlays.invoke(hud, capture, delta); + sleep.invoke(hud, capture, delta); + result.addProperty("scopeScale", (float) field(Hud.class, "scopeScale").get(hud)); + } default -> throw new IllegalArgumentException(c.get("kind").getAsString()); } result.add("draws", capture.draws); diff --git a/tools/hud_parity_cases.py b/tools/hud_parity_cases.py index ec0e1459a..2b04106c5 100644 --- a/tools/hud_parity_cases.py +++ b/tools/hud_parity_cases.py @@ -174,6 +174,28 @@ def decor(rng, n): return case + +def overlays(rng, n): + """Camera overlays (vignette and border warning, spyglass, pumpkin, powder snow, portal, nausea) and sleep.""" + case = {**screen(rng), 'vignette': rng.random() < 0.7, + 'vignetteBrightness': rng.choice([1.0, 0.0, 0.5, round(rng.random(), 4), 1.3, -0.2]), + 'firstPerson': rng.random() < 0.8, 'scoping': rng.random() < 0.2, + 'scopeScale': rng.choice([0.5, 1.125, round(rng.uniform(0.5, 1.125), 4)]), 'partial': round(rng.random(), 3), + 'head': rng.choice([None, None, 'carved_pumpkin', 'diamond_helmet']), + 'ticksFrozen': rng.choice([0, 0, 0, 1, 70, 139, 140, 300]), + 'portal': rng.choice([[0.0, 0.0], [0.0, 0.0], [0.0, 0.0125], [0.5, 0.5125], [1.0, 1.0], [0.05, 0.0], [round(rng.random(), 3)] * 2]), + 'nausea': rng.choice([0.0, 0.0, 1.0, 0.25, round(rng.random(), 3)]), + 'screenEffectScale': rng.choice([1.0, 0.0, 0.5, round(rng.random(), 3)]), + 'sleepTimer': rng.choice([0, 0, 0, 1, 50, 100, 101, 105, 110, 111])} + if rng.random() < 0.4: + size = rng.choice([10.0, 50.0, 200.0, 1000.0]) + case['border'] = {'centerX': rng.choice([0.0, 100.5]), 'centerZ': rng.choice([0.0, -30.25]), 'size': size, + 'warningBlocks': rng.choice([0, 5, 20, 100]), 'warningTime': rng.choice([0, 15])} + case['camX'] = round(rng.uniform(-150, 250), 2) + case['camZ'] = round(rng.uniform(-150, 150), 2) + return case + + # Generators by kind: (rng, index) -> case. Cases are drawn round-robin. KINDS = { 'decorations': decorations, @@ -184,4 +206,5 @@ KINDS = { 'jump': jump, 'sidebar': sidebar, 'decor': decor, + 'overlays': overlays, } diff --git a/tools/test_hud_parity.py b/tools/test_hud_parity.py index d25c5525b..0aceaee10 100644 --- a/tools/test_hud_parity.py +++ b/tools/test_hud_parity.py @@ -118,6 +118,11 @@ def main(): errors.append(v['error']); continue a = [normal(d) for d in v['draws']] b = [normal(d) for d in r['draws']] + # State the case reads back besides the draws. + for key in v.keys() - {'case', 'draws'}: + if key not in r or not close(v[key], r[key]): + a = a + [{'type': 'state', key: v[key]}] + b = b + [{'type': 'state', key: r.get(key)}] if len(a) != len(b) or not all(same(x, y) for x, y in zip(a, b)): first = next((i for i, (x, y) in enumerate(zip(a, b)) if not same(x, y)), min(len(a), len(b))) bad.append((v['case'], first, a[first:first + 2], b[first:first + 2], len(a), len(b))) From 5b201965afbda883f7a330ff2460396e084d4aef Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 13:28:05 +0200 Subject: [PATCH 6/7] Compare the chat with vanilla's ChatComponent The chat cases add messages (with the system and error tags) at given Hud ticks and draw ChatComponent in background mode: wrapping, the 200-tick fade, scale, width, height, spacing and opacity options. Horizon's chat now wraps like StringSplitter.splitLines and ComponentRenderUtils.wrapComponents (the indent on wrapped lines, breaks at the last space, a dropped newline or space), keeps the options as doubles and draws through a layout with vanilla's fills and text offsets. A component list whose first part has empty text now still passes its style to the rest. The harness runs 200 cases per kind. Co-Authored-By: Claude Opus 5.5 --- .../examples/hud_fixture/kinds.rs | 37 ++- crates/horizon-client/src/chat.rs | 234 ++++++++++-------- crates/horizon-client/src/component.rs | 46 ++-- crates/horizon-client/src/font.rs | 66 +++++ crates/horizon-client/src/game/chat.rs | 2 +- crates/horizon-client/src/hud_layout.rs | 16 +- crates/horizon-client/src/hud_overlays.rs | 21 +- crates/horizon-client/src/settings.rs | 14 +- .../horizonlab/parity/VanillaHudOracle.java | 53 +++- tools/hud_parity_cases.py | 33 +++ tools/test_hud_parity.py | 38 +-- 11 files changed, 379 insertions(+), 181 deletions(-) diff --git a/crates/horizon-client/examples/hud_fixture/kinds.rs b/crates/horizon-client/examples/hud_fixture/kinds.rs index 0c423c76a..550da026b 100644 --- a/crates/horizon-client/examples/hud_fixture/kinds.rs +++ b/crates/horizon-client/examples/hud_fixture/kinds.rs @@ -1,6 +1,8 @@ //! The overlay case kinds of the HUD parity fixture. use horizon_client::{ - brewing, component, + brewing, + chat::{Chat, ChatOptions}, + component, hud::HudAtlas, hud_layout::{self, GuiDraw}, hud_overlays::{ @@ -46,6 +48,7 @@ pub fn run( "sidebar" => sidebar(c, w, h, atlas), "decor" => decor(c, atlas), "overlays" => overlays(c, w, h, state), + "chat" => chat(c, h, atlas), _ => Vec::new(), } } @@ -289,3 +292,35 @@ fn overlays(c: &Value, w: i32, h: i32, state: &mut serde_json::Map Vec { + let option = |k: &str| c[k].as_f64().unwrap_or(0.0); + let mut chat = Chat::default(); + chat.options = ChatOptions { + opacity: option("chatOpacity"), + background_opacity: option("textOpacity"), + scale: option("chatScale"), + width: option("chatWidth"), + height_focused: option("chatHeightFocused"), + height_unfocused: option("chatHeightUnfocused"), + line_spacing: option("chatLineSpacing"), + }; + for m in c["messages"].as_array().into_iter().flatten() { + // GuiMessageTag indicator colours: systemSinglePlayer and chatError. + let indicator = match m["tag"].as_str() { + Some("system") => Some(13684944), + Some("error") => Some(16733525), + _ => None, + }; + chat.add( + atlas, + comp(&m["text"]), + indicator, + m["at"].as_u64().unwrap_or(0), + false, + ); + } + chat.layout(h, c["now"].as_u64().unwrap_or(0), false) +} diff --git a/crates/horizon-client/src/chat.rs b/crates/horizon-client/src/chat.rs index 1c5abe777..eccd5b0d3 100644 --- a/crates/horizon-client/src/chat.rs +++ b/crates/horizon-client/src/chat.rs @@ -5,6 +5,7 @@ use crate::{ command::{Dispatcher, ParseResults, Registries, Suggestion}, hud::{HudAtlas, HudBatch, rgba}, + hud_layout::{self, GuiDraw, PoseOp}, text::{self, Style, Text}, ui::{EditBox, char_len}, }; @@ -12,15 +13,16 @@ use crate::{ /// GuiMessageTag.systemSinglePlayer's indicator colour. pub const SYSTEM_INDICATOR: u32 = 0xD0D0D0; +/// The chat options (doubles, as vanilla keeps them). #[derive(Clone, Copy, Debug)] pub struct ChatOptions { - pub opacity: f32, - pub background_opacity: f32, - pub scale: f32, - pub width: f32, - pub height_focused: f32, - pub height_unfocused: f32, - pub line_spacing: f32, + pub opacity: f64, + pub background_opacity: f64, + pub scale: f64, + pub width: f64, + pub height_focused: f64, + pub height_unfocused: f64, + pub line_spacing: f64, } impl Default for ChatOptions { fn default() -> Self { @@ -37,20 +39,21 @@ impl Default for ChatOptions { } impl ChatOptions { /// ChatComponent.getWidth/getHeight. - pub fn width_px(&self) -> f32 { - (self.width * 280.0 + 40.0).floor() + pub fn width_px(&self) -> i32 { + (self.width * 280.0 + 40.0).floor() as i32 } - pub fn height_px(&self, focused: bool) -> f32 { + pub fn height_px(&self, focused: bool) -> i32 { ((if focused { self.height_focused } else { self.height_unfocused }) * 160.0 + 20.0) - .floor() + .floor() as i32 } - pub fn line_height(&self) -> f32 { - (9.0 * (self.line_spacing + 1.0)).floor() + /// `getLineHeight`. + pub fn line_height(&self) -> i32 { + (9.0 * (self.line_spacing + 1.0)) as i32 } } #[derive(Clone, Debug)] @@ -59,12 +62,25 @@ struct Message { content: Text, indicator: Option, } +/// A wrapped line (`GuiMessage.Line`). #[derive(Clone, Debug)] struct Line { added: u64, content: Text, indicator: Option, } + +/// `ChatComponent.AlphaCalculator.timeBased`: opaque for 180 ticks, then +/// fading out quadratically over 20. +fn time_alpha(ticks: u64, added: u64) -> f32 { + let delta = ticks as i64 - added as i64; + let mut t = delta as f64 / 200.0; + t = 1.0 - t; + t *= 10.0; + t = t.clamp(0.0, 1.0); + t *= t; + t as f32 +} #[derive(Default)] pub struct Chat { messages: Vec, @@ -80,10 +96,11 @@ pub struct Chat { } impl Chat { pub fn lines_per_page(&self, focused: bool) -> usize { - (self.options.height_px(focused) / self.options.line_height().max(1.0)) as usize + (self.options.height_px(focused) / self.options.line_height().max(1)) as usize } - fn max_width(&self) -> f32 { - (self.options.width_px() / self.options.scale.max(0.01)).floor() + /// The wrapping width, `Mth.floor(getWidth() / getScale())`. + fn max_width(&self) -> i32 { + (f64::from(self.options.width_px()) / self.options.scale).floor() as i32 } /// ChatComponent.addMessage: wrap, prepend and trim to 100 lines. pub fn add( @@ -108,7 +125,7 @@ impl Chat { } fn add_lines(&mut self, atlas: &HudAtlas, message: &Message, focused: bool) { let width = self.max_width(); - for line in atlas.font.split(&message.content, width) { + for line in atlas.font.wrap_components(&message.content, width) { if focused && self.scroll > 0 { self.new_since_scroll = true; self.scroll_by(1, focused); @@ -164,116 +181,113 @@ impl Chat { self.scroll = pos as usize; } } - /// ChatComponent.extractRenderState. - pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: u64, focused: bool) { - if self.lines.is_empty() { - return; + /// `ChatComponent.extractRenderState` (background mode unless `focused`) + /// on a screen `height` GUI pixels tall at `Hud.tickCount` `ticks`. + pub fn layout(&self, height: i32, ticks: u64, focused: bool) -> Vec { + let total = self.lines.len(); + if total == 0 { + return Vec::new(); } let o = &self.options; - let scale = o.scale; - if scale <= 0.0 { - return; - } - let max_width = (o.width_px() / scale).ceil(); - let chat_bottom = ((batch.height - 40.0) / scale).floor(); - let text_opacity = o.opacity * 0.9 + 0.1; + let scale = o.scale as f32; + let max_width = hud_layout::ceil(o.width_px() as f32 / scale); + let chat_bottom = hud_layout::floor((height - 40) as f32 / scale); + let text_opacity = o.opacity as f32 * 0.9 + 0.1; + let background_opacity = o.background_opacity as f32; let entry_height = o.line_height(); - let bottom_to_text = (8.0 * (o.line_spacing + 1.0) - 4.0 * o.line_spacing).round(); - let per_page = self.lines_per_page(focused); - let alpha_of = |line: &Line| -> f32 { + let bottom_to_text = + (8.0 * (o.line_spacing + 1.0) - 4.0 * o.line_spacing + 0.5).floor() as i32; + let alpha_of = |line: &Line| { if focused { - return 1.0; + 1.0 + } else { + time_alpha(ticks, line.added) } - let t = - ((1.0 - (ticks.saturating_sub(line.added)) as f64 / 200.0) * 10.0).clamp(0.0, 1.0); - (t * t) as f32 }; - let visible = self.lines.len().saturating_sub(self.scroll).min(per_page); - let mut count = 0; - // Pass 1: backgrounds; pass 2: text (same order as vanilla). - let s = |v: f32| v * scale; - for i in (0..visible).rev() { - let line = &self.lines[i + self.scroll]; - let alpha = alpha_of(line); - if alpha <= 1.0e-5 { - continue; - } - count += 1; - let bottom = chat_bottom - i as f32 * entry_height; - let top = bottom - entry_height; - batch.fill( - atlas, - 0.0, - s(top), - s(max_width + 8.0), - s(entry_height), - rgba(0, 0, 0, (alpha * o.background_opacity * 255.0) as u8), - ); + let visible = total + .saturating_sub(self.scroll) + .min(self.lines_per_page(focused)); + let lines: Vec<(usize, &Line, f32)> = (0..visible) + .rev() + .map(|i| (i, &self.lines[i + self.scroll])) + .map(|(i, line)| (i, line, alpha_of(line))) + .filter(|(_, _, alpha)| *alpha > 1.0e-5) + .collect(); + let mut out = vec![GuiDraw::Push(vec![ + PoseOp::Scale(scale, scale), + PoseOp::Translate(4.0, 0.0), + ])]; + for &(i, _, alpha) in &lines { + let bottom = chat_bottom - i as i32 * entry_height; + out.push(hud_layout::fill( + -4, + bottom - entry_height, + max_width + 4 + 4, + bottom, + hud_layout::as8(alpha * background_opacity) << 24, + )); } - for i in (0..visible).rev() { - let line = &self.lines[i + self.scroll]; - let alpha = alpha_of(line); - if alpha <= 1.0e-5 { - continue; + for &(i, line, alpha) in &lines { + let bottom = chat_bottom - i as i32 * entry_height; + let opacity = alpha * text_opacity; + let color = hud_layout::white(opacity); + if color >> 24 != 0 { + out.push(GuiDraw::Text { + text: line.content.clone(), + x: 0, + y: bottom - bottom_to_text, + color, + shadow: true, + }); } - let bottom = chat_bottom - i as f32 * entry_height; - let top = bottom - entry_height; - let text_top = bottom - bottom_to_text; - let a = (alpha * text_opacity * 255.0) as u8; - if let Some(c) = line.indicator { - batch.fill( - atlas, - 0.0, - s(top), - s(2.0), - s(entry_height), - rgba((c >> 16) as u8, (c >> 8) as u8, c as u8, a), - ); - } - if a > 3 { - batch.text_styled( - atlas, - &line.content, - s(4.0), - s(text_top), - rgba(255, 255, 255, a), - true, - ); + if let Some(indicator) = line.indicator { + let color = hud_layout::as8(opacity) << 24 | indicator & 0xFF_FFFF; + out.push(hud_layout::fill( + -4, + bottom - entry_height, + -2, + bottom, + color, + )); } } - // Scroll bar while focused and scrolled content exists. - if focused && count > 0 { - let total = self.lines.len() as f32; - let chat_height = count as f32 * entry_height; - let virtual_height = total * entry_height; + if focused { + let count = lines.len() as i32; + let chat_height = count * entry_height; + let virtual_height = total as i32 * entry_height; + let y = self.scroll as i32 * chat_height / total as i32 - chat_bottom; + let height = chat_height * chat_height / virtual_height; if virtual_height != chat_height { - let y = self.scroll as f32 * chat_height / total - chat_bottom; - let height = chat_height * chat_height / virtual_height; - let alpha = if y > 0.0 { 170 } else { 96 }; - let c = if self.new_since_scroll { + let alpha: u32 = if y > 0 { 170 } else { 96 }; + let color = if self.new_since_scroll { 0xCC3333 } else { 0x3333AA }; - let x = max_width + 4.0 + 4.0; - batch.fill( - atlas, - s(x), - s(-y - height), - s(2.0), - s(height), - rgba((c >> 16) as u8, (c >> 8) as u8, c as u8, alpha), - ); - batch.fill( - atlas, - s(x + 1.0), - s(-y - height), - s(1.0), - s(height), - rgba(0xCC, 0xCC, 0xCC, alpha), - ); + let x = max_width + 4; + out.push(hud_layout::fill( + x, + -y, + x + 2, + -y - height, + alpha << 24 | color, + )); + out.push(hud_layout::fill( + x + 2, + -y, + x + 1, + -y - height, + alpha << 24 | 0xCCCCCC, + )); } } + out.push(GuiDraw::Pop); + out + } + /// Draws [`Chat::layout`] into the HUD batch. + pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: u64, focused: bool) { + let draws = self.layout(batch.height as i32, ticks, focused); + hud_layout::paint(batch, atlas, &draws); } /// Plain text of the newest messages (for tests and the control socket). pub fn recent_lines(&self, n: usize) -> Vec { diff --git a/crates/horizon-client/src/component.rs b/crates/horizon-client/src/component.rs index 2ead4d13a..115bf74af 100644 --- a/crates/horizon-client/src/component.rs +++ b/crates/horizon-client/src/component.rs @@ -152,6 +152,23 @@ impl Parser<'_> { Err("unterminated string".into()) } } +/// The style fields of a component object. +fn object_style(o: &serde_json::Map) -> Style { + let mut style = Style::default(); + if let Some(c) = o.get("color").and_then(Value::as_str) { + style.color = named_color(c).or_else(|| { + c.strip_prefix('#') + .and_then(|h| u32::from_str_radix(h, 16).ok()) + }); + } + let flag = |k: &str| o.get(k).and_then(Value::as_bool); + style.bold = flag("bold"); + style.italic = flag("italic"); + style.underlined = flag("underlined"); + style.strikethrough = flag("strikethrough"); + style.obfuscated = flag("obfuscated"); + style +} /// `ComponentSerialization.CODEC` decoding into text. `selector` components /// are resolved by `resolve` (ComponentUtils.updateForEntity). pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text { @@ -165,30 +182,23 @@ pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text { return Text::empty(); }; let mut base = to_text(first, resolve); - let style = base - .spans - .first() - .map(|s| s.style.clone()) - .unwrap_or_default(); + // The siblings take the first component's own style, even when + // its text is empty. + let style = match first { + Value::Object(o) => object_style(o), + _ => base + .spans + .first() + .map(|s| s.style.clone()) + .unwrap_or_default(), + }; for sibling in rest { base.push(to_text(sibling, resolve).with_style(&style)); } base } Value::Object(o) => { - let mut style = Style::default(); - if let Some(c) = o.get("color").and_then(Value::as_str) { - style.color = named_color(c).or_else(|| { - c.strip_prefix('#') - .and_then(|h| u32::from_str_radix(h, 16).ok()) - }); - } - let flag = |k: &str| o.get(k).and_then(Value::as_bool); - style.bold = flag("bold"); - style.italic = flag("italic"); - style.underlined = flag("underlined"); - style.strikethrough = flag("strikethrough"); - style.obfuscated = flag("obfuscated"); + let style = object_style(o); let content = if let Some(t) = o.get("text") { match t { Value::String(s) => Text::literal(s.clone()), diff --git a/crates/horizon-client/src/font.rs b/crates/horizon-client/src/font.rs index a69e3f030..aba0581c6 100644 --- a/crates/horizon-client/src/font.rs +++ b/crates/horizon-client/src/font.rs @@ -451,6 +451,72 @@ impl Font { .sum::() .ceil() } + /// `StringSplitter.splitLines`: each line and whether it continues a + /// wrapped one. A line breaks at a `\n`, or once a character overflows + /// `max_width` (never the first visible one) at the last space so far, or + /// before that character; the `\n` or space at the break is dropped. + pub fn split_lines(&self, t: &Text, max_width: f32) -> Vec<(Text, bool)> { + let max_width = max_width.max(1.0); + let chars: Vec<(char, &Style)> = t.chars().collect(); + let n = chars.len(); + let mut out = Vec::new(); + let (mut start, mut wrapped, mut force_new_line) = (0, false, false); + loop { + // LineBreakFinder over what is left. + let (mut width, mut had_visible, mut last_space) = (0.0f32, false, None); + let mut split = None; + for (i, &(c, style)) in chars.iter().enumerate().skip(start) { + if c == '\n' { + split = Some(i); + break; + } + if c == ' ' { + last_space = Some(i); + } + let advance = self.advance(c, style); + width += advance; + if !had_visible || width <= max_width { + had_visible |= advance != 0.0; + } else { + split = Some(last_space.unwrap_or(i)); + break; + } + } + let Some(at) = split else { break }; + let new_line = chars[at].0 == '\n'; + let skip = usize::from(new_line || chars[at].0 == ' '); + force_new_line = new_line; + out.push((t.slice(start, at), wrapped)); + wrapped = !new_line; + start = at + skip; + } + if start < n { + out.push((t.slice(start, n), wrapped)); + } else if force_new_line { + out.push((Text::empty(), false)); + } + out + } + /// `ComponentRenderUtils.wrapComponents`: the split lines, wrapped ones + /// indented by an unstyled space; one empty line for empty text. + pub fn wrap_components(&self, t: &Text, max_width: i32) -> Vec { + let lines: Vec = self + .split_lines(t, max_width as f32) + .into_iter() + .map(|(line, wrapped)| { + if wrapped { + Text::literal(" ").append(line) + } else { + line + } + }) + .collect(); + if lines.is_empty() { + vec![Text::empty()] + } else { + lines + } + } /// StringSplitter.splitLines: wrap at the last space that fits (or /// mid-word when none does); `\n` always breaks. Styles are kept. pub fn split(&self, t: &Text, max_width: f32) -> Vec { diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index 812ac6118..579ee99d7 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -511,7 +511,7 @@ impl Game<'_> { return; }; screen.resize(batch.width, batch.height); - let bg = self.ui.chat.options.background_opacity; + let bg = self.ui.chat.options.background_opacity as f32; screen.draw( batch, &self.res.atlas, diff --git a/crates/horizon-client/src/hud_layout.rs b/crates/horizon-client/src/hud_layout.rs index 8972eaa63..ab28ece3e 100644 --- a/crates/horizon-client/src/hud_layout.rs +++ b/crates/horizon-client/src/hud_layout.rs @@ -1,9 +1,8 @@ //! Layout of vanilla's `Hud` as draw calls (`GuiGraphicsExtractor` blits, //! fills and text): the hotbar with its selection, off-hand slot, items and //! attack indicator, the crosshair, armour, hearts, food, air bubbles, mount -//! hearts, the experience and jump bars, status effect icons, camera -//! overlays, titles and the action bar, the selected item name, boss bars, -//! the scoreboard sidebar, chat and item decorations. Computed without +//! hearts and the experience bar, plus the draw-call types and colour +//! helpers the other layouts share (`hud_overlays`, `chat`). Computed without //! drawing so the parity fixture can compare them with the vanilla client. use crate::{font::Font, text::Text}; use horizon_core::random::{LegacyRandom, RandomSource}; @@ -190,6 +189,11 @@ pub fn floor(x: f32) -> i32 { let i = x as i32; if x < i as f32 { i - 1 } else { i } } +/// `Mth.ceil`. +pub fn ceil(x: f32) -> i32 { + let i = x as i32; + if x > i as f32 { i + 1 } else { i } +} /// `ARGB.as8BitChannel`. pub fn as8(v: f32) -> u32 { floor(v * 255.0) as u32 @@ -585,12 +589,6 @@ fn heart( table[usize::from(hardcore) * 4 + usize::from(half) * 2 + usize::from(blink)] } -fn ceil(x: f32) -> i32 { - // Mth.ceil. - let i = x as i32; - if x > i as f32 { i + 1 } else { i } -} - impl HealthHud { /// `Hud.extractPlayerHealth` for a screen of `w` x `h` GUI pixels. pub fn layout(&mut self, i: &HealthInputs, w: i32, h: i32) -> Vec { diff --git a/crates/horizon-client/src/hud_overlays.rs b/crates/horizon-client/src/hud_overlays.rs index 7c43c1a43..5982ea23d 100644 --- a/crates/horizon-client/src/hud_overlays.rs +++ b/crates/horizon-client/src/hud_overlays.rs @@ -1,8 +1,11 @@ -//! The `Hud` overlays above the hotbar and decorations, laid out as -//! [`GuiDraw`] calls like [`crate::hud_layout`]: status effect icons -//! (`extractEffects`), titles and the action bar (`extractTitle`, -//! `extractOverlayMessage` and the title timers of `Hud.tick`), and the -//! selected item name (`extractSelectedItemName` and its `toolHighlightTimer`). +//! The `Hud` overlays laid out as [`GuiDraw`] calls like +//! [`crate::hud_layout`]: status effect icons (`extractEffects`), titles and +//! the action bar (`extractTitle`, `extractOverlayMessage` and the title +//! timers of `Hud.tick`), the selected item name (`extractSelectedItemName` +//! and its `toolHighlightTimer`), boss bars (`BossHealthOverlay`), the jump +//! bar (`JumpableVehicleBar`), the scoreboard sidebar, item decorations +//! (`GuiGraphicsExtractor.itemDecorations`), the camera overlays and the +//! sleep overlay. use crate::{ font::Font, hud_layout::{ @@ -635,12 +638,6 @@ pub fn sidebar( out } -/// `Mth.ceil`. -fn ceil(x: f32) -> i32 { - let i = x as i32; - if x > i as f32 { i + 1 } else { i } -} - /// What `GuiGraphicsExtractor.itemDecorations` draws over a stack. #[derive(Clone, Debug, Default, PartialEq)] pub struct ItemDecorations { @@ -676,7 +673,7 @@ pub fn item_decorations(x: i32, y: i32, d: &ItemDecorations, font: &Font) -> Vec } if d.cooldown > 0.0 { let top = y + crate::hud_layout::floor(16.0 * (1.0 - d.cooldown)); - let bottom = top + ceil(16.0 * d.cooldown); + let bottom = top + crate::hud_layout::ceil(16.0 * d.cooldown); out.push(fill(x, top, x + 16, bottom, 0x7FFF_FFFF)); } if d.count != 1 || d.count_text.is_some() { diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs index 3db17435a..33c91fb0b 100644 --- a/crates/horizon-client/src/settings.rs +++ b/crates/horizon-client/src/settings.rs @@ -486,13 +486,13 @@ impl Settings { } pub fn chat_options(&self) -> crate::chat::ChatOptions { crate::chat::ChatOptions { - opacity: self.chat_opacity, - background_opacity: self.text_background_opacity, - scale: self.chat_scale, - width: self.chat_width, - height_focused: self.chat_height_focused, - height_unfocused: self.chat_height_unfocused, - line_spacing: self.chat_line_spacing, + opacity: f64::from(self.chat_opacity), + background_opacity: f64::from(self.text_background_opacity), + scale: f64::from(self.chat_scale), + width: f64::from(self.chat_width), + height_focused: f64::from(self.chat_height_focused), + height_unfocused: f64::from(self.chat_height_unfocused), + line_spacing: f64::from(self.chat_line_spacing), } } } diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java index 322087a83..dac37a2f7 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHudOracle.java @@ -43,14 +43,16 @@ import org.joml.Matrix3x2f; import org.joml.Matrix3x2fStack; /** - * Original oracle for the in-game HUD decorations: runs vanilla's own Hud - * methods (extractItemHotbar, extractPlayerHealth, extractVehicleHealth, - * extractCrosshair) and ExperienceBar / ContextualBar on a stand-in client - * (Unsafe-allocated Minecraft, options, game mode, window and level) and a - * player whose state getters answer from the case, and records every - * GuiGraphicsExtractor blit, text and item call. + * Oracle for the in-game HUD: runs vanilla's own Hud methods (hotbar, + * crosshair, health, mount, experience, effects, titles and the action bar, + * the selected item name, the sidebar, camera and sleep overlays and + * Hud.tick), BossHealthOverlay, JumpableVehicleBar, ChatComponent and + * GuiGraphicsExtractor.itemDecorations on a stand-in client (Unsafe-allocated + * Minecraft, options, game mode, window and level) and a player whose state + * getters answer from the case, and records every GuiGraphicsExtractor blit, + * fill, text and item call. See tools/test_hud_parity.py for the case kinds. * - * Input lines: case JSON. Output lines: {case, draws:[...]} or {case, error}. + * Input lines: case JSON. Output lines: {case, draws:[...], state...} or {case, error}. */ public final class VanillaHudOracle { static Object unsafe; @@ -85,6 +87,14 @@ public final class VanillaHudOracle { unsafe.getClass().getMethod(setter, Object.class, long.class, param).invoke(unsafe, target, offset, value); } + static void putStatic(Class owner, String name, Object value) throws Exception { + Field f = field(owner, name); + var u = unsafe.getClass(); + Object base = u.getMethod("staticFieldBase", Field.class).invoke(unsafe, f); + long offset = (long) u.getMethod("staticFieldOffset", Field.class).invoke(unsafe, f); + u.getMethod("putObject", Object.class, long.class, Object.class).invoke(unsafe, base, offset, value); + } + static float f(String k, float d) { return c.has(k) && !c.get(k).isJsonNull() ? c.get(k).getAsFloat() : d; } static int i(String k, int d) { return c.has(k) && !c.get(k).isJsonNull() ? c.get(k).getAsInt() : d; } static boolean b(String k) { return c.has(k) && c.get(k).getAsBoolean(); } @@ -385,7 +395,8 @@ public final class VanillaHudOracle { put(window, com.mojang.blaze3d.platform.Window.class, "guiScaledWidth", i("width", 0)); put(window, com.mojang.blaze3d.platform.Window.class, "guiScaledHeight", i("height", 0)); put(mc, Minecraft.class, "window", window); - put(mc, Minecraft.class, "gui", alloc(net.minecraft.client.gui.Gui.class)); + var gui = alloc(net.minecraft.client.gui.Gui.class); + put(mc, Minecraft.class, "gui", gui); put(mc, Minecraft.class, "demo", b("demo")); var hud = alloc(Hud.class); put(hud, Hud.class, "minecraft", mc); @@ -558,6 +569,32 @@ public final class VanillaHudOracle { sleep.invoke(hud, capture, delta); result.addProperty("scopeScale", (float) field(Hud.class, "scopeScale").get(hud)); } + case "chat" -> { + for (String o : new String[] {"chatScale", "chatWidth", "chatOpacity", "chatLineSpacing", "chatHeightUnfocused", "chatHeightFocused"}) + put(options, Options.class, o, option(c.get(o).getAsDouble())); + put(options, Options.class, "chatColors", option(true)); + putStatic(Minecraft.class, "instance", mc); + put(gui, net.minecraft.client.gui.Gui.class, "hud", hud); + var listener = alloc(net.minecraft.client.multiplayer.chat.ChatListener.class); + put(listener, net.minecraft.client.multiplayer.chat.ChatListener.class, "delayedMessageQueue", new ArrayDeque<>()); + put(gui, net.minecraft.client.gui.Gui.class, "chatListener", listener); + var C = net.minecraft.client.gui.components.ChatComponent.class; + put(chat, C, "minecraft", mc); + put(chat, C, "allMessages", new ArrayList<>()); + put(chat, C, "trimmedMessages", new ArrayList<>()); + put(chat, C, "visibleMessageFilter", (java.util.function.Predicate) m -> true); + for (var e : c.getAsJsonArray("messages")) { + var m = e.getAsJsonObject(); + put(hud, Hud.class, "tickCount", m.get("at").getAsInt()); + var text = comp(m.get("text")); + switch (m.get("tag").isJsonNull() ? "" : m.get("tag").getAsString()) { + case "system" -> chat.addClientSystemMessage(text); + case "error" -> chat.addPlayerMessage(text, null, net.minecraft.client.multiplayer.chat.GuiMessageTag.chatError()); + default -> chat.addPlayerMessage(text, null, null); + } + } + chat.extractRenderState(capture, font, i("now", 0), 0, 0, net.minecraft.client.gui.components.ChatComponent.DisplayMode.BACKGROUND, false); + } default -> throw new IllegalArgumentException(c.get("kind").getAsString()); } result.add("draws", capture.draws); diff --git a/tools/hud_parity_cases.py b/tools/hud_parity_cases.py index 2b04106c5..3957dcb70 100644 --- a/tools/hud_parity_cases.py +++ b/tools/hud_parity_cases.py @@ -196,6 +196,38 @@ def overlays(rng, n): return case + +WORDS = ['hello', 'world', 'a', 'Minecraft', 'supercalifragilisticexpialidocious', 'x' * 70, 'ok!', 'Ünïcödé', '★', ''] + + +def chat_text(rng): + words = [rng.choice(WORDS) for _ in range(rng.choice([1, 2, 5, 12, 30]))] + text = rng.choice([' ', ' ', ' ', ' ', '\n']).join(words) + if rng.random() < 0.1: + text = rng.choice([' ', '\n']) + text + rng.choice(['', ' ', '\n']) + if rng.random() < 0.3: + cut = rng.randint(0, len(text)) + return [{'text': text[:cut], 'color': rng.choice(['red', 'gold', 'aqua'])}, + {'text': text[cut:], 'bold': rng.random() < 0.5, 'italic': rng.random() < 0.3}] + return {'text': text} + + +def chat(rng, n): + """Messages wrapped to the chat width and fading 200 ticks after they arrive.""" + count = rng.choice([1, 2, 5, 10, 30, 120]) + now = rng.randint(200, 2000) + messages = [] + for _ in range(count): + at = rng.choice([now, now - 1, now - 179, now - 180, now - 190, now - 199, now - 200, now - 500, rng.randint(now - 260, now + 5)]) + messages.append({'text': chat_text(rng), 'at': at, 'tag': rng.choice([None, None, 'system', 'error'])}) + messages.sort(key=lambda m: m['at']) + return {**screen(rng), 'now': now, 'messages': messages, + 'chatScale': rng.choice([1.0, 1.0, 0.5, 0.0 + 0.75, 0.25]), 'chatWidth': rng.choice([1.0, 1.0, 0.5, 0.0, 0.3]), + 'chatOpacity': rng.choice([1.0, 0.5, 0.0, 0.25]), 'textOpacity': rng.choice([0.5, 0.0, 1.0, 0.25]), + 'chatLineSpacing': rng.choice([0.0, 0.0, 0.5, 1.0, 0.25]), 'chatHeightUnfocused': rng.choice([70 / 160, 1.0, 0.0, 0.5]), + 'chatHeightFocused': 1.0} + + # Generators by kind: (rng, index) -> case. Cases are drawn round-robin. KINDS = { 'decorations': decorations, @@ -207,4 +239,5 @@ KINDS = { 'sidebar': sidebar, 'decor': decor, 'overlays': overlays, + 'chat': chat, } diff --git a/tools/test_hud_parity.py b/tools/test_hud_parity.py index 0aceaee10..afaf7decd 100644 --- a/tools/test_hud_parity.py +++ b/tools/test_hud_parity.py @@ -1,21 +1,29 @@ #!/usr/bin/env python3 """Compare the in-game HUD with the vanilla 26.3 client's Hud. -The Java oracle (VanillaHudOracle) runs vanilla's own Hud methods -(extractCrosshair, extractItemHotbar, extractPlayerHealth, -extractVehicleHealth, extractEffects, extractCameraOverlays, extractTitle, -extractOverlayMessage, extractSelectedItemName, the scoreboard sidebar and -Hud.tick), BossHealthOverlay, ChatComponent, the contextual bars and -GuiGraphicsExtractor.itemDecorations on a stand-in client whose player -answers from the case, and records every blit (sprite, texture, position, -size, region, colour, pose), fill, text call (string, style runs, position, -colour, shadow, pose) and hotbar item (slot, position, seed, pose). -`examples/hud_fixture` lays out the same state with -`horizon_client::hud_layout`; the ordered call lists must agree. +The Java oracle (VanillaHudOracle) runs vanilla's own code on a stand-in +client whose player answers from the case, and records every +GuiGraphicsExtractor blit (sprite, texture, position, size, region, colour, +pose), fill, text call (string, style runs, position, colour, shadow, pose) +and hotbar item (slot, position, seed, pose). `examples/hud_fixture` lays +out the same state with `horizon_client::hud_layout`, `hud_overlays` and +`chat`; the ordered call lists (and any state read back) must agree. -Each case has a `kind` (decorations, effects, title, selected, boss, -sidebar, jump, decor, overlays, chat); timing kinds replay events tick by -tick (title fades, the action bar, the selected item name, chat fades). +Case kinds (`tools/hud_parity_cases.py`), drawn round-robin: + decorations extractCrosshair, extractItemHotbar, extractPlayerHealth, + extractVehicleHealth, ExperienceBar and the level + effects extractEffects (MobEffectInstance order, blinking icons) + title setTitle/setTimes/setOverlayMessage and Hud.tick, then + extractOverlayMessage and extractTitle (fades, backdrops) + selected Hud.tick's tool highlight, then extractSelectedItemName + boss BossHealthOverlay + jump JumpableVehicleBar + sidebar displayScoreboardSidebar (teams, number formats) + decor GuiGraphicsExtractor.itemDecorations (count, bar, cooldown) + overlays extractCameraOverlays (vignette, spyglass and scopeScale, + pumpkin, powder snow, portal, nausea) and extractSleepOverlay + chat ChatComponent: wrapping (StringSplitter, indents), fades, + tags, scale, width, height and spacing options test_hud_parity.py [--count N] [--detail N] [--kind K] """ @@ -81,7 +89,7 @@ def same(x, y): def main(): parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument('--count', type=int, default=600) + parser.add_argument('--count', type=int, default=2200) parser.add_argument('--detail', type=int, default=3) parser.add_argument('--kind', action='append', choices=sorted(KINDS), help='only these kinds (repeatable)') args = parser.parse_args() From d48017ab700147c91226ae14b1f3a0762e350fa4 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 12 Oct 2026 13:29:20 +0200 Subject: [PATCH 7/7] Build the player's attack strength model with its tests Player.attackStrengthTicker and itemSwapTicker: both advance each tick, a different main-hand item resets them, and getAttackStrengthScale divides by the ATTACK_SPEED delay. The game does not drive it yet; the attack indicator still shows full strength until combat uses the cooldown. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/attack_strength.rs | 41 ++++++++++++++++++++ crates/horizon-client/src/lib.rs | 1 + 2 files changed, 42 insertions(+) diff --git a/crates/horizon-client/src/attack_strength.rs b/crates/horizon-client/src/attack_strength.rs index 1862492bb..f8d8d5c34 100644 --- a/crates/horizon-client/src/attack_strength.rs +++ b/crates/horizon-client/src/attack_strength.rs @@ -63,3 +63,44 @@ impl AttackStrength { ((self.swap_ticker as f32 + a) / delay(attack_speed)).clamp(0.0, 1.0) } } + +#[cfg(test)] +mod tests { + use super::*; + fn held(item: &str, rest: &str) -> Option { + Some(HeldStack { + item: item.into(), + rest: rest.into(), + }) + } + #[test] + fn charges_over_the_attack_delay() { + let mut s = AttackStrength::default(); + // A sword's 1.6 attacks per second: 12.5 ticks to full strength. + assert_eq!(delay(1.6), 12.5); + for _ in 0..6 { + s.tick(None); + } + assert_eq!(s.scale(0.25, 1.6), 6.25 / 12.5); + for _ in 0..10 { + s.tick(None); + } + assert_eq!(s.scale(0.0, 1.6), 1.0); + } + #[test] + fn switching_items_resets_but_restacking_does_not() { + let mut s = AttackStrength::default(); + s.tick(held("minecraft:stone", "64")); + assert_eq!(s.ticker, 0, "picking up an item resets"); + s.tick(held("minecraft:stone", "63")); + assert_eq!( + s.ticker, 1, + "the same item with another count keeps charging" + ); + s.tick(held("minecraft:diamond_sword", "")); + assert_eq!((s.ticker, s.swap_ticker), (0, 0)); + s.tick(held("minecraft:diamond_sword", "")); + s.reset_attack(); + assert_eq!((s.ticker, s.swap_ticker), (0, 1)); + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index ea6278878..d80ed6be6 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -6,6 +6,7 @@ pub mod ambience; pub mod animate_tick; pub mod assets; pub mod atlas_sources; +pub mod attack_strength; pub mod attribute_updates; pub mod audio; pub mod auto_jump;