From a7606c4ad4a42ff87eaaf53eab5fc04d3aa52b0a Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 13 Oct 2026 06:07:04 +0200 Subject: [PATCH] Compare the resource pack screen's drawing with vanilla horizon_client::pack_screen ports PackSelectionScreen, its two TransferableSelectionLists and the ConfirmScreen of an incompatible pack as vanilla's state machine (clicks, wheel, search typing, focus, selection, scroll) and gives its GUI calls; screen_draw holds the widgets (StringWidget, MultiLineTextWidget, Button, a font-aware EditBox port) and StringSplitter's line splitting with legacy codes. Pack components keep their legacy codes and style fields. tools/test_pack_screen_parity.py runs a real PackSelectionScreen through the same actions: 1500/1500 cases match. Co-Authored-By: Claude Opus 5.5 --- .../examples/pack_screen_fixture.rs | 163 ++++ crates/horizon-client/src/lib.rs | 2 + crates/horizon-client/src/pack_screen.rs | 915 ++++++++++++++++++ crates/horizon-client/src/packs.rs | 94 +- crates/horizon-client/src/screen_draw.rs | 840 ++++++++++++++++ .../parity/VanillaPackScreenOracle.java | 395 ++++++++ tools/test_pack_screen_parity.py | 180 ++++ 7 files changed, 2564 insertions(+), 25 deletions(-) create mode 100644 crates/horizon-client/examples/pack_screen_fixture.rs create mode 100644 crates/horizon-client/src/pack_screen.rs create mode 100644 crates/horizon-client/src/screen_draw.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java create mode 100644 tools/test_pack_screen_parity.py diff --git a/crates/horizon-client/examples/pack_screen_fixture.rs b/crates/horizon-client/examples/pack_screen_fixture.rs new file mode 100644 index 000000000..ca7cba7b8 --- /dev/null +++ b/crates/horizon-client/examples/pack_screen_fixture.rs @@ -0,0 +1,163 @@ +//! The resource pack screen for tools/test_pack_screen_parity.py: reads one +//! JSON case per line (packs, selection, GUI size, actions, mouse), runs +//! `horizon_client::pack_screen` through the actions and writes the shown +//! screen's GUI calls in the oracle's JSON form. +//! +//! usage: pack_screen_fixture RESOURCES CASES OUTPUT +use horizon_client::{ + hud::HudAtlas, + lang, + pack_screen::{Compat, PackInfo, PackScreen, Source}, + packs::{self, Position}, + screen_draw::{Draw, Measure}, + text::Text, +}; +use serde_json::{Value, json}; +use std::{fmt::Write as _, fs, path::PathBuf}; + +/// Styled runs: [text, rgb or null, bold, italic, underlined, strikethrough, obfuscated]. +pub fn runs(t: &Text) -> Value { + let mut out: Vec<(String, Option, [bool; 5])> = Vec::new(); + for (c, s) in t.chars() { + let f = [ + s.bold, + s.italic, + s.underlined, + s.strikethrough, + s.obfuscated, + ] + .map(|b| b == Some(true)); + match out.last_mut() { + Some(last) if last.1 == s.color && last.2 == f => last.0.push(c), + _ => out.push((c.to_string(), s.color, f)), + } + } + Value::Array( + out.into_iter() + .map(|(t, c, f)| json!([t, c, f[0], f[1], f[2], f[3], f[4]])) + .collect(), + ) +} +pub fn encode(draws: &[Draw]) -> Value { + Value::Array( + draws + .iter() + .map(|d| match d { + Draw::Sprite { sprite, x, y, w, h, color } => { + json!({"type": "sprite", "sprite": sprite, "x": x, "y": y, "w": w, "h": h, "color": color}) + } + Draw::Blit { texture, x, y, w, h, u, v, src, tex, color } => json!({"type": "blit", "texture": texture, + "x": x, "y": y, "w": w, "h": h, "u": u, "v": v, "srcW": src[0], "srcH": src[1], "texW": tex[0], + "texH": tex[1], "color": color}), + Draw::Fill { x0, y0, x1, y1, color } => { + json!({"type": "fill", "x0": x0, "y0": y0, "x1": x1, "y1": y1, "color": color}) + } + Draw::Highlight { x0, y0, x1, y1 } => json!({"type": "highlight", "x0": x0, "y0": y0, "x1": x1, "y1": y1}), + Draw::Text { text, x, y, color, shadow } => { + json!({"type": "text", "runs": runs(text), "x": x, "y": y, "color": color, "shadow": shadow}) + } + Draw::Scissor { x0, y0, x1, y1 } => json!({"type": "scissor", "x0": x0, "y0": y0, "x1": x1, "y1": y1}), + Draw::NoScissor => json!({"type": "noscissor"}), + Draw::Tooltip { lines, x, y } => { + json!({"type": "tooltip", "lines": lines.iter().map(runs).collect::>(), "x": x, "y": y}) + } + }) + .collect(), + ) +} + +fn main() -> horizon_client::Result<()> { + let args: Vec = std::env::args_os().skip(1).map(PathBuf::from).collect(); + let [root, inputs, output] = args.as_slice() else { + return Err("usage: pack_screen_fixture RESOURCES CASES OUTPUT".into()); + }; + let atlas = HudAtlas::build(root)?; + lang::set(lang::Language::load(&[root], lang::DEFAULT)); + let m = Measure(&atlas.font); + let mut out = String::new(); + for line in fs::read_to_string(inputs)? + .lines() + .filter(|l| !l.is_empty()) + { + let c: Value = serde_json::from_str(line)?; + let int = |v: &Value| v.as_i64().unwrap_or(0) as i32; + let packs: Vec = c["packs"] + .as_array() + .into_iter() + .flatten() + .map(|p| { + let (description, description_style) = packs::component_root(&p["description"]); + PackInfo { + id: p["id"].as_str().unwrap_or_default().to_owned(), + title: packs::component_root(&p["title"]).0, + description, + description_style, + source: match p["source"].as_str() { + Some("builtin") => Source::BuiltIn, + Some("world") => Source::World, + Some("server") => Source::Server, + Some("feature") => Source::Feature, + _ => Source::Default, + }, + compat: match p["compat"].as_str() { + Some("old") => Compat::TooOld, + Some("new") => Compat::TooNew, + Some("unknown") => Compat::Unknown, + _ => Compat::Compatible, + }, + icon: p["icon"].as_bool().unwrap_or(false), + required: p["required"].as_bool().unwrap_or(false), + position: if p["position"] == "top" { + Position::Top + } else { + Position::Bottom + }, + fixed: p["fixed"].as_bool().unwrap_or(false), + } + }) + .collect(); + let selected: Vec = c["selected"] + .as_array() + .into_iter() + .flatten() + .filter_map(|s| s.as_str().map(str::to_owned)) + .collect(); + let mut screen = PackScreen::new( + &m, + int(&c["width"]), + int(&c["height"]), + c["inWorld"] == true, + packs, + &selected, + ); + for a in c["actions"].as_array().into_iter().flatten() { + let f = |k: &str| a[k].as_f64().unwrap_or(0.0); + match a["type"].as_str().unwrap_or_default() { + "click" => { + screen.click(&m, f("x"), f("y")); + } + "scroll" => screen.scroll(f("x"), f("y"), f("amount")), + "type" => screen.type_text(&m, a["text"].as_str().unwrap_or_default()), + "erase" => screen.erase(&m, f("count") as isize), + _ => {} + } + if std::env::var_os("PACK_DEBUG").is_some() { + eprintln!("{a} -> {}", screen.debug()); + } + } + let mouse = (int(&c["mouse"][0]), int(&c["mouse"][1])); + let draws = screen.draw(&m, mouse, c["blink"].as_u64().unwrap_or(0)); + let screen_name = if screen.confirming() { + "confirm" + } else { + "packs" + }; + writeln!( + out, + "{}", + json!({"screen": screen_name, "draws": encode(&draws)}) + )?; + } + fs::write(output, out)?; + Ok(()) +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 3f390e98b..ba517de0d 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -77,6 +77,7 @@ pub mod net; pub mod options_file; pub mod options_fixes; pub mod options_ui; +pub mod pack_screen; pub mod packs; pub mod particles; pub mod patrol; @@ -89,6 +90,7 @@ pub mod recipe_book_screen; pub mod save; pub mod scoreboard; pub mod scoreboard_cmd; +pub mod screen_draw; pub mod screen_effects; pub mod screen_layout; pub mod sculk; diff --git a/crates/horizon-client/src/pack_screen.rs b/crates/horizon-client/src/pack_screen.rs new file mode 100644 index 000000000..b9c269f9c --- /dev/null +++ b/crates/horizon-client/src/pack_screen.rs @@ -0,0 +1,915 @@ +//! The resource pack screen (`PackSelectionScreen` with its two +//! `TransferableSelectionList`s, search box and buttons) and the +//! `ConfirmScreen` an incompatible pack opens, as vanilla's state machine: +//! clicks, the mouse wheel and typing change the selection model, the lists' +//! entries, scroll, selection and focus as the vanilla widgets do, and +//! [`PackScreen::draw`] gives the screen's GUI calls. The game shows it; +//! tools/test_pack_screen_parity.py compares it with vanilla. +use crate::{ + packs::{Position, Selectable, SelectionModel}, + screen_draw::{self as d, Draw, Measure, TextField}, + text::{Style, Text}, +}; + +/// `PackCompatibility`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Compat { + Compatible, + TooOld, + TooNew, + Unknown, +} +impl Compat { + fn key(self) -> &'static str { + match self { + Compat::TooOld => "old", + Compat::TooNew => "new", + Compat::Unknown => "unknown", + Compat::Compatible => "compatible", + } + } +} +/// `PackSource`: how the description is decorated. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Source { + Default, + BuiltIn, + Feature, + World, + Server, +} + +/// A pack as the screen shows it. +#[derive(Clone, Debug)] +pub struct PackInfo { + pub id: String, + pub title: Text, + pub description: Text, + /// The description component's own (root) style. + pub description_style: Style, + pub source: Source, + pub compat: Compat, + /// Whether the pack has a `pack.png`. + pub icon: bool, + pub required: bool, + pub position: Position, + pub fixed: bool, +} +impl PackInfo { + pub fn selectable(&self) -> Selectable { + Selectable { + id: self.id.clone(), + required: self.required, + position: self.position, + fixed: self.fixed, + compatible: self.compat == Compat::Compatible, + } + } + /// `PackSource.decorate` merged with the entry's grey + /// (`getExtendedDescription`, `ComponentUtils.mergeStyles`), and the style of + /// its root, which the ellipsis of a cut description takes. + fn extended_description(&self) -> (Text, Style) { + let gray = Style::color(0x808080); + let key = match self.source { + Source::Default => { + let mut root = self.description_style.clone(); + root.inherit(&gray); + return (self.description.clone().with_style(&gray), root); + } + Source::BuiltIn => "pack.source.builtin", + Source::Feature => "pack.source.feature", + Source::World => "pack.source.world", + Source::Server => "pack.source.server", + }; + let t = Text::translate( + "pack.nameAndSource", + &[self.description.clone(), Text::translate(key, &[])], + ) + .with_color(d::GRAY); + (t, Style::color(d::GRAY)) + } +} +/// `PackSelectionScreen.loadPackIcon`'s texture for a pack with an icon. +pub fn icon_texture(id: &str) -> String { + let sanitized: String = id + .to_lowercase() + .chars() + .map(|c| { + if c.is_ascii_lowercase() || c.is_ascii_digit() || "_-./".contains(c) { + c + } else { + '_' + } + }) + .collect(); + let bytes: Vec = id.encode_utf16().flat_map(u16::to_le_bytes).collect(); + let hash: String = crate::skins::sha1(&bytes) + .iter() + .map(|b| format!("{b:02x}")) + .collect(); + format!("pack/{sanitized}/{hash}/icon") +} + +#[derive(Clone, Debug, PartialEq)] +enum Row { + Header, + Pack(String), +} +#[derive(Clone, Debug)] +struct Entry { + row: Row, + y: i32, + height: i32, +} +/// A `TransferableSelectionList`. +#[derive(Clone, Debug)] +struct List { + selected_side: bool, + x: i32, + y: i32, + width: i32, + height: i32, + scroll: f64, + entries: Vec, + /// `getSelected`, an index into `entries`. + selected: Option, + /// The list has a focused child (possibly an entry it no longer holds). + focused: bool, +} +impl List { + fn new(selected_side: bool, height: i32) -> Self { + Self { + selected_side, + x: 0, + y: 33, + width: 200, + height, + scroll: 0.0, + entries: Vec::new(), + selected: None, + focused: false, + } + } + fn bottom(&self) -> i32 { + self.y + self.height + } + fn row_left(&self) -> i32 { + self.x + self.width / 2 - self.row_width() / 2 + } + fn row_width(&self) -> i32 { + self.width - 4 + } + fn content_height(&self) -> i32 { + self.entries.iter().map(|e| e.height).sum::() + 4 + } + fn max_scroll(&self) -> i32 { + (self.content_height() - self.height).max(0) + } + fn scrollable(&self) -> bool { + self.max_scroll() > 0 + } + /// `TransferableSelectionList.Entry.getWidth`. + fn entry_width(&self) -> i32 { + self.row_width() - if self.scrollable() { 6 } else { 0 } + } + fn next_y(&self) -> i32 { + self.y + 2 - self.scroll as i32 + self.entries.iter().map(|e| e.height).sum::() + } + fn add(&mut self, row: Row, height: i32) { + let y = self.next_y(); + self.entries.push(Entry { row, y, height }); + } + fn reposition(&mut self) { + let mut y = self.y + 2 - self.scroll as i32; + for e in &mut self.entries { + e.y = y; + y += e.height; + } + } + fn set_scroll(&mut self, v: f64) { + self.scroll = v.clamp(0.0, self.max_scroll() as f64); + self.reposition(); + } + fn scroll_to(&mut self, i: usize) { + let e = &self.entries[i]; + let top = e.y - self.y - 2; + if top < 0 { + self.set_scroll(self.scroll + top as f64); + } + let e = &self.entries[i]; + let bottom = self.bottom() - e.y - e.height - 2; + if bottom < 0 { + self.set_scroll(self.scroll - bottom as f64); + } + } + fn set_selected(&mut self, i: Option) { + self.selected = i; + if let Some(i) = i { + let e = &self.entries[i]; + let top = e.y + 2 < self.y; + let bottom = e.y + 2 + e.height - 4 > self.bottom(); + if top || bottom { + self.scroll_to(i); + } + } + } + fn update_size(&mut self, width: i32, height: i32, x: i32, y: i32) { + self.width = width; + self.height = height; + self.x = x; + self.y = y; + self.reposition(); + if let Some(i) = self.selected { + self.scroll_to(i); + } + self.set_scroll(self.scroll); + } + fn is_over(&self, x: f64, y: f64) -> bool { + x >= self.x as f64 + && y >= self.y as f64 + && x < (self.x + self.width) as f64 + && y < self.bottom() as f64 + } + /// `getEntryAtPosition`. + fn entry_at(&self, x: i32, y: i32) -> Option { + let (left, w) = (self.row_left(), self.entry_width()); + self.entries + .iter() + .position(|e| x >= left && x < left + w && y >= e.y && y < e.y + e.height) + } + fn scroll_bar_x(&self) -> i32 { + self.x + self.width - 6 + } + fn scroller_height(&self) -> i32 { + ((self.height * self.height) as f32 / self.content_height() as f32) as i32 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Focus { + None, + Search, + List(usize), + /// Open Pack Folder (0) or Done (1). + Button(usize), +} + +/// The open `ConfirmScreen` for an incompatible pack. +#[derive(Clone, Debug)] +struct Confirm { + id: String, + title: Text, + message: Text, +} + +/// What a click on the screen asks the game to do. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum Action { + None, + /// The Open Pack Folder button. + OpenFolder, + /// The Done button (`onClose`: commit). + Done, +} + +/// The pack screen and its state. +#[derive(Clone, Debug)] +pub struct PackScreen { + pub width: i32, + pub height: i32, + pub in_world: bool, + pub packs: Vec, + pub model: SelectionModel, + search: TextField, + focus: Focus, + /// 0: available, 1: selected. + lists: [List; 2], + confirm: Option, + /// The selection changed since the screen opened. + pub changed: bool, +} + +fn tr(key: &str) -> Text { + Text::translate(key, &[]) +} + +impl PackScreen { + /// `PackSelectionScreen.init`: the lists filled, the search box focused. + pub fn new( + m: &Measure, + width: i32, + height: i32, + in_world: bool, + packs: Vec, + selected: &[String], + ) -> Self { + let model = SelectionModel::new(packs.iter().map(PackInfo::selectable).collect(), selected); + let mut search = TextField::new(0, 0, 200, 15); + search.hint = Some(tr("gui.packSelection.search").with_style(&Style { + color: Some(d::GRAY), + italic: Some(true), + ..Style::default() + })); + let mut s = Self { + width, + height, + in_world, + packs, + model, + search, + focus: Focus::None, + lists: [List::new(false, height - 66), List::new(true, height - 66)], + confirm: None, + changed: false, + }; + s.reposition(m); + s.populate(None); + s.set_focus(Focus::Search); + s + } + fn info(&self, id: &str) -> Option<&PackInfo> { + self.packs.iter().find(|p| p.id == id) + } + /// The header layout: title, drop info and search box, centred. + fn header(&self, m: &Measure) -> [(i32, i32); 3] { + let tw = m.width(&tr("resourcePack.title")); + let dw = m.width(&tr("pack.dropInfo")); + let col = tw.max(dw).max(200); + let frame = self.width.max(col); + let lx = (0.5 * (frame - col) as f32) as i32; + let cell = |w: i32| lx + (0.5 * (col - w) as f32) as i32; + [(cell(tw), 4), (cell(dw), 17), (cell(200), 30)] + } + /// The footer's two buttons. + fn footer(&self) -> [(i32, i32); 2] { + let frame = self.width.max(308); + let x = (0.5 * (frame - 308) as f32) as i32; + let y = self.height - 33 + (0.5f32 * 13.0).round() as i32; + [(x, y), (x + 158, y)] + } + /// `repositionElements`. + fn reposition(&mut self, m: &Measure) { + let (sx, sy) = self.header(m)[2]; + self.search.x = sx; + self.search.y = sy; + let content = self.height - 49 - 33; + let w = self.width; + self.lists[0].update_size(200, content, w / 2 - 15 - 200, 49); + self.lists[1].update_size(200, content, w / 2 + 15, 49); + } + /// `AbstractContainerEventHandler.setFocused` on the screen. + fn set_focus(&mut self, f: Focus) { + if self.focus == f { + return; + } + match self.focus { + Focus::Search => self.search.focused = false, + Focus::List(i) => self.lists[i].focused = false, + Focus::None | Focus::Button(_) => {} + } + if f == Focus::Search { + self.search.focused = true; + } + self.focus = f; + } + fn shown(&self, side: usize) -> Vec { + let value = self.search.value.to_lowercase(); + let blank = self.search.value.trim().is_empty() + && self.search.value.chars().all(char::is_whitespace); + let list = if side == 1 { + &self.model.selected + } else { + &self.model.unselected + }; + list.iter() + .filter(|p| { + blank + || p.id.to_lowercase().contains(&value) + || self.info(&p.id).is_some_and(|i| { + i.title.plain().to_lowercase().contains(&value) + || i.description.plain().to_lowercase().contains(&value) + }) + }) + .map(|p| p.id.clone()) + .collect() + } + /// `TransferableSelectionList.updateList`. + fn update_list(&mut self, side: usize, ids: Vec, transferred: Option<&str>) { + let l = &mut self.lists[side]; + l.entries.clear(); + l.selected = None; + l.add(Row::Header, 13); + l.set_selected(None); + for id in ids { + let hit = transferred == Some(id.as_str()); + self.lists[side].add(Row::Pack(id), 36); + if hit { + self.set_focus(Focus::List(side)); + let l = &mut self.lists[side]; + l.focused = true; + let i = l.entries.len() - 1; + l.set_selected(Some(i)); + } + } + let l = &mut self.lists[side]; + l.set_scroll(l.scroll); + } + /// `populateLists`: both lists, then again through the search filter. + fn populate(&mut self, transferred: Option<&str>) { + let all = |m: &SelectionModel, side: bool| -> Vec { + (if side { &m.selected } else { &m.unselected }) + .iter() + .map(|p| p.id.clone()) + .collect() + }; + self.update_list(1, all(&self.model, true), transferred); + self.update_list(0, all(&self.model, false), transferred); + self.filter(transferred); + } + /// `updateFilteredEntries`. + fn filter(&mut self, transferred: Option<&str>) { + let (sel, avail) = (self.shown(1), self.shown(0)); + self.update_list(1, sel, transferred); + self.update_list(0, avail, transferred); + } + /// The pack's index in its model list. + fn model_index(&self, side: usize, id: &str) -> Option { + let list = if side == 1 { + &self.model.selected + } else { + &self.model.unselected + }; + list.iter().position(|p| p.id == id) + } + fn flags(&self, side: usize, id: &str) -> (bool, bool, bool, bool) { + let Some(i) = self.model_index(side, id) else { + return (false, false, false, false); + }; + let s = side == 1; + ( + self.model.can_select(s, i), + self.model.can_unselect(s, i), + self.model.can_move_up(s, i), + self.model.can_move_down(s, i), + ) + } + fn overlay(&self, id: &str) -> bool { + self.info(id).is_none_or(|p| !p.fixed || !p.required) + } + + /// A left click (`Screen.mouseClicked`). + pub fn click(&mut self, m: &Measure, x: f64, y: f64) -> Action { + if self.confirm.is_some() { + return self.confirm_click(m, x, y); + } + if self.search.contains(x, y) { + self.search.click(m, x, false); + self.set_focus(Focus::Search); + return Action::None; + } + for side in 0..2 { + if !self.lists[side].is_over(x, y) { + continue; + } + let l = &self.lists[side]; + let scrolling = l.scrollable() + && x >= l.scroll_bar_x() as f64 + && x <= (l.scroll_bar_x() + 6) as f64 + && y >= l.y as f64 + && y < l.bottom() as f64; + let hit = l.entry_at(x as i32, y as i32); + let mut took = false; + if let Some(i) = hit { + took = true; + match l.entries[i].row.clone() { + Row::Header => { + let l = &mut self.lists[side]; + l.focused = true; + l.set_selected(Some(i)); + } + Row::Pack(id) => { + let current = self.entry_click(m, side, i, &id, x as i32, y as i32); + if self.lists[side] + .entries + .iter() + .any(|e| e.row == Row::Pack(id.clone())) + { + let l = &mut self.lists[side]; + l.focused = true; + if current { + l.set_selected(Some(i)); + } + } + } + } + } + if took || scrolling { + self.set_focus(Focus::List(side)); + } + return Action::None; + } + for (i, (bx, by)) in self.footer().into_iter().enumerate() { + if x >= bx as f64 && y >= by as f64 && x < (bx + 150) as f64 && y < (by + 20) as f64 { + self.set_focus(Focus::Button(i)); + return if i == 0 { + Action::OpenFolder + } else { + Action::Done + }; + } + } + Action::None + } + /// `PackEntry.mouseClicked`; true when the entry clicked is still the + /// list's own (nothing was repopulated). + fn entry_click( + &mut self, + m: &Measure, + side: usize, + i: usize, + id: &str, + x: i32, + y: i32, + ) -> bool { + if !self.overlay(id) { + return true; + } + let e = &self.lists[side].entries[i]; + let (cx, cy) = (self.lists[side].row_left() + 2, e.y + 2); + let (rx, ry) = (x - cx, y - cy); + let (sel, unsel, up, down) = self.flags(side, id); + let icon = (0..32).contains(&rx) && (0..32).contains(&ry); + let left = (0..16).contains(&rx) && (0..32).contains(&ry); + let top_right = (16..32).contains(&rx) && (0..16).contains(&ry); + let bottom_right = (16..32).contains(&rx) && (16..32).contains(&ry); + let index = self.model_index(side, id).unwrap_or(0); + let s = side == 1; + if sel && icon { + if self + .info(id) + .is_some_and(|p| p.compat != Compat::Compatible) + { + self.open_confirm(id); + return true; + } + self.model.activate(s, index, true); + } else if unsel && left { + self.model.activate(s, index, false); + } else if up && top_right { + self.model.move_by(s, index, true); + } else if down && bottom_right { + self.model.move_by(s, index, false); + } else { + return true; + } + self.changed = true; + self.populate(Some(id)); + let _ = m; + false + } + /// `handlePackSelection` of an incompatible pack: the ConfirmScreen + /// (the pack screen loses its focus as `Gui.setScreen` clears it). + fn open_confirm(&mut self, id: &str) { + let compat = self.info(id).map_or(Compat::Unknown, |p| p.compat); + self.set_focus(Focus::None); + for l in &mut self.lists { + l.focused = false; + } + self.confirm = Some(Confirm { + id: id.to_owned(), + title: tr("pack.incompatible.confirm.title"), + message: tr(&format!("pack.incompatible.confirm.{}", compat.key())), + }); + } + /// The ConfirmScreen's layout: title, message lines and the two buttons. + fn confirm_layout( + &self, + m: &Measure, + c: &Confirm, + ) -> ((i32, i32), (Vec<(Text, i32)>, i32, i32), [(i32, i32); 2]) { + let max = self.width - 50; + let lines = d::label_lines(m, &c.message, max, 15, &Style::default()); + let mw = d::label_width(&lines, max); + let mh = lines.len() as i32 * 9; + let tw = m.width(&c.title); + let col = tw.max(mw).max(304); + let total = 9 + 8 + mh + 8 + 36; + let lx = (0.5 * (self.width - col) as f32) as i32; + let ly = (0.5 * (self.height - total) as f32) as i32; + let cell = |w: i32| lx + (0.5 * (col - w) as f32) as i32; + let by = ly + 9 + 8 + mh + 8 + 16; + let bx = cell(304); + ( + (cell(tw), ly), + (lines, cell(mw), ly + 17), + [(bx, by), (bx + 154, by)], + ) + } + fn confirm_click(&mut self, m: &Measure, x: f64, y: f64) -> Action { + let Some(c) = self.confirm.clone() else { + return Action::None; + }; + let (_, _, buttons) = self.confirm_layout(m, &c); + for (i, (bx, by)) in buttons.into_iter().enumerate() { + if x >= bx as f64 && y >= by as f64 && x < (bx + 150) as f64 && y < (by + 20) as f64 { + // The callback: back to the pack screen (repositioned), then select. + self.confirm = None; + self.reposition(m); + if i == 0 + && let Some(index) = self.model_index(0, &c.id) + { + self.model.activate(false, index, true); + self.changed = true; + self.populate(Some(&c.id)); + } + return Action::None; + } + } + Action::None + } + /// The focus, the lists' rows, scroll and selection (for debugging). + pub fn debug(&self) -> String { + format!( + "{:?} {:?}", + self.focus, + self.lists + .iter() + .map(|l| ( + l.scroll, + l.selected, + l.focused, + l.entries.iter().map(|e| e.y).collect::>() + )) + .collect::>() + ) + } + /// Whether the confirmation screen is shown. + pub fn confirming(&self) -> bool { + self.confirm.is_some() + } + /// Escape on the confirmation screen answers no. + pub fn cancel_confirm(&mut self, m: &Measure) -> bool { + if self.confirm.take().is_some() { + self.reposition(m); + return true; + } + false + } + /// The mouse wheel (`AbstractScrollArea.mouseScrolled`). + pub fn scroll(&mut self, x: f64, y: f64, amount: f64) { + if self.confirm.is_some() || self.search.contains(x, y) { + return; + } + for l in &mut self.lists { + if l.is_over(x, y) { + l.set_scroll(l.scroll - amount * 18.0); + return; + } + } + } + /// Typed text, when the search box has the focus. + pub fn type_text(&mut self, m: &Measure, s: &str) { + if self.confirm.is_none() && self.focus == Focus::Search && self.search.insert_text(m, s) { + self.filter(None); + } + } + /// Backspace in the search box. + pub fn erase(&mut self, m: &Measure, count: isize) { + if self.confirm.is_none() + && self.focus == Focus::Search + && self.search.delete_chars(m, -count) + { + self.filter(None); + } + } + pub fn search_focused(&self) -> bool { + self.confirm.is_none() && self.focus == Focus::Search + } + /// Resize (`Screen.init` on a new size: `repositionElements`). + pub fn resize(&mut self, m: &Measure, width: i32, height: i32) { + self.width = width; + self.height = height; + self.reposition(m); + } + /// `PackSelectionModel.commit`: the selection as options.txt stores it. + pub fn commit(&self) -> Vec { + self.model.commit() + } + + /// The shown screen's calls (`Screen.extractRenderState`); `blink_ms` + /// is the time since the search box took the focus. + pub fn draw(&self, m: &Measure, mouse: (i32, i32), blink_ms: u64) -> Vec { + let mut out = Vec::new(); + if let Some(c) = &self.confirm { + let ((tx, ty), (lines, mx, my), buttons) = self.confirm_layout(m, c); + d::string_widget(&mut out, m, &c.title, tx, ty, 0); + d::label(&mut out, &lines, mx, my, self.width - 50, true); + for ((bx, by), key) in buttons.into_iter().zip(["gui.yes", "gui.no"]) { + let hover = d::inside(mouse, bx, by, 150, 20); + d::button(&mut out, m, &tr(key), bx, by, 150, 20, true, hover); + } + return out; + } + let [(tx, ty), (dx, dy), _] = self.header(m); + d::string_widget(&mut out, m, &tr("resourcePack.title"), tx, ty, 0); + d::string_widget( + &mut out, + m, + &tr("pack.dropInfo").with_color(d::GRAY), + dx, + dy, + 0, + ); + self.search.draw(&mut out, m, blink_ms, None); + for side in 0..2 { + self.draw_list(&mut out, m, side, mouse); + } + for (i, (bx, by)) in self.footer().into_iter().enumerate() { + let hover = d::inside(mouse, bx, by, 150, 20); + let label = tr(if i == 0 { + "pack.openFolder" + } else { + "gui.done" + }); + d::button( + &mut out, + m, + &label, + bx, + by, + 150, + 20, + true, + hover || self.focus == Focus::Button(i), + ); + if i == 0 && hover { + d::tooltip(&mut out, m, &tr("pack.folderInfo"), mouse); + } + } + out + } + fn draw_list(&self, out: &mut Vec, m: &Measure, side: usize, mouse: (i32, i32)) { + let l = &self.lists[side]; + let hovered = if l.is_over(mouse.0 as f64, mouse.1 as f64) { + l.entry_at(mouse.0, mouse.1) + } else { + None + }; + let prefix = if self.in_world { "inworld_" } else { "" }; + let right = l.x + l.width; + d::blit( + out, + &format!("textures/gui/{prefix}menu_list_background.png"), + l.x, + l.y, + (right as f32, (l.bottom() + l.scroll as i32) as f32), + l.width, + l.height, + [32, 32], + ); + out.push(Draw::Scissor { + x0: l.x.clamp(0, self.width), + y0: l.y.clamp(0, self.height), + x1: right.clamp(0, self.width), + y1: l.bottom().clamp(0, self.height), + }); + let (left, w) = (l.row_left(), l.entry_width()); + let narrow = if l.scrollable() { 6 } else { 0 }; + for (i, e) in l.entries.iter().enumerate() { + if e.y + e.height < l.y || e.y > l.bottom() { + continue; + } + if l.selected == Some(i) { + let color = if l.focused { -1 } else { -8355712 }; + d::fill(out, left, e.y, left + w, e.y + e.height, color); + d::fill( + out, + left + 1, + e.y + 1, + left + w - 1, + e.y + e.height - 1, + -16777216, + ); + } + let (cx, cy) = (left + 2, e.y + 2); + match &e.row { + Row::Header => { + let key = if l.selected_side { + "pack.selected.title" + } else { + "pack.available.title" + }; + let t = tr(key).with_style(&Style { + underlined: Some(true), + bold: Some(true), + ..Style::default() + }); + let tw = m.width(&t); + d::text( + out, + t, + left + w / 2 - tw / 2, + cy + (e.height - 4) / 2 - 4, + -1, + true, + ); + } + Row::Pack(id) => { + let Some(p) = self.info(id) else { continue }; + if p.compat != Compat::Compatible { + d::fill( + out, + cx - 1, + cy - 1, + cx + w - 4 + 1, + cy + e.height - 4 + 1, + -8978432, + ); + } + let icon = if p.icon { + icon_texture(id) + } else { + "textures/misc/unknown_pack.png".into() + }; + d::blit(out, &icon, cx, cy, (0.0, 0.0), 32, 32, [32, 32]); + let (mut name, (mut desc, mut desc_style)) = + (p.title.clone(), p.extended_description()); + let focus_hover = l.selected == Some(i) && l.focused; + if self.overlay(id) && (hovered == Some(i) || focus_hover) { + d::fill(out, cx, cy, cx + 32, cy + 32, -1601138544); + let (rx, ry) = (mouse.0 - cx, mouse.1 - cy); + if p.compat != Compat::Compatible { + name = tr("pack.incompatible"); + desc = tr(&format!("pack.incompatible.{}", p.compat.key())) + .with_color(d::GRAY); + desc_style = Style::color(d::GRAY); + } + let (sel, unsel, up, down) = self.flags(side, id); + let quarter = |x0: i32, x1: i32, y0: i32, y1: i32| { + (x0..x1).contains(&rx) && (y0..y1).contains(&ry) + }; + let mut arrow = |name: &str, on: bool| { + let s = if on { + format!("transferable_list/{name}_highlighted") + } else { + format!("transferable_list/{name}") + }; + d::sprite(out, &s, cx, cy, 32, 32); + }; + if sel { + arrow("select", quarter(0, 32, 0, 32)); + } else { + if unsel { + arrow("unselect", quarter(0, 16, 0, 32)); + } + if up { + arrow("move_up", quarter(16, 32, 0, 16)); + } + if down { + arrow("move_down", quarter(16, 32, 16, 32)); + } + } + } + let max = 157 - narrow; + d::string_widget(out, m, &name, cx + 34, cy + 1, max); + let lines = d::label_lines(m, &desc, max, 2, &desc_style); + d::label(out, &lines, cx + 34, cy + 12, max, false); + } + } + } + out.push(Draw::NoScissor); + d::blit( + out, + &format!("textures/gui/{prefix}header_separator.png"), + l.x, + l.y - 2, + (0.0, 0.0), + l.width, + 2, + [32, 2], + ); + d::blit( + out, + &format!("textures/gui/{prefix}footer_separator.png"), + l.x, + l.bottom(), + (0.0, 0.0), + l.width, + 2, + [32, 2], + ); + if l.scrollable() { + let sh = l.scroller_height().clamp(32, l.height - 8); + let sy = (l.scroll as i32 * (l.height - sh) / l.max_scroll() + l.y).max(l.y); + d::sprite( + out, + "widget/scroller_background", + l.scroll_bar_x(), + l.y, + 6, + l.height, + ); + d::sprite(out, "widget/scroller", l.scroll_bar_x(), sy, 6, sh); + } + } +} diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs index 1e0c35358..eea53777b 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -4,6 +4,7 @@ //! and an overlay resource root that layers the enabled packs over the //! vanilla resources (later packs win), so every loader sees one tree. pub mod pattern; +use crate::text::Style; use crate::{text::Text, zip::Zip}; use pattern::Pattern; use std::{ @@ -53,47 +54,90 @@ impl Filter { && self.path.as_ref().is_none_or(|p| p.is_match(path)) } } -/// A minimal text component from JSON (strings, `text`, `translate`, arrays). +/// A text component from JSON (strings, `text`, `translate`, arrays, `extra` +/// and the style fields), legacy `§` codes resolved as the font does. pub fn component(v: &serde_json::Value) -> Text { + component_root(v).0.resolve_legacy() +} +/// The component, its legacy codes left in place (each span is a +/// component's contents and style), and its root style (`Component.getStyle`). +pub fn component_root(v: &serde_json::Value) -> (Text, Style) { + let mut out = Text::empty(); + let root = build(v, &Style::default(), &mut out); + (out, root) +} +fn style_of(o: &serde_json::Map) -> Style { + let flag = |k: &str| o.get(k).and_then(|b| b.as_bool()); + Style { + color: o.get("color").and_then(|c| c.as_str()).and_then(|c| { + crate::text::named_color(c).or_else(|| { + c.strip_prefix('#') + .and_then(|h| u32::from_str_radix(h, 16).ok()) + }) + }), + bold: flag("bold"), + italic: flag("italic"), + underlined: flag("underlined"), + strikethrough: flag("strikethrough"), + obfuscated: flag("obfuscated"), + ..Style::default() + } +} +/// Appends `v` under `parent`'s style; returns the component's own style. +fn build(v: &serde_json::Value, parent: &Style, out: &mut Text) -> Style { match v { - serde_json::Value::String(s) => Text::legacy(s), serde_json::Value::Array(a) => { - let mut t = Text::empty(); - for e in a { - t.push(component(e)); + let Some(first) = a.first() else { + return Style::default(); + }; + let own = build(first, parent, out); + let mut style = own.clone(); + style.inherit(parent); + for e in &a[1..] { + build(e, &style, out); } - t + own } serde_json::Value::Object(o) => { - let mut t = if let Some(s) = o.get("text").and_then(|s| s.as_str()) { - Text::legacy(s) + let own = style_of(o); + let mut style = own.clone(); + style.inherit(parent); + if let Some(s) = o.get("text").and_then(|s| s.as_str()) { + out.push(Text::styled(s, style.clone())); } else if let Some(k) = o.get("translate").and_then(|s| s.as_str()) { let args: Vec = o .get("with") .and_then(|w| w.as_array()) .map(|a| a.iter().map(component).collect()) .unwrap_or_default(); - Text::translate(k, &args) - } else { - Text::empty() - }; - if let Some(extra) = o.get("extra") { - t.push(component(extra)); + out.push(Text::translate(k, &args).with_style(&style)); } - if let Some(c) = o.get("color").and_then(|c| c.as_str()) { - let rgb = crate::text::named_color(c).or_else(|| { - c.strip_prefix('#') - .and_then(|h| u32::from_str_radix(h, 16).ok()) - }); - if let Some(rgb) = rgb { - t = t.with_color(rgb); + match o.get("extra") { + Some(serde_json::Value::Array(extra)) => { + for e in extra { + build(e, &style, out); + } } + Some(e) => { + build(e, &style, out); + } + None => {} } - t + own } - serde_json::Value::Number(n) => Text::literal(n.to_string()), - serde_json::Value::Bool(b) => Text::literal(b.to_string()), - serde_json::Value::Null => Text::empty(), + serde_json::Value::String(s) => { + out.push(Text::styled(s.as_str(), parent.clone())); + Style::default() + } + serde_json::Value::Number(n) => { + out.push(Text::styled(n.to_string(), parent.clone())); + Style::default() + } + serde_json::Value::Bool(b) => { + out.push(Text::styled(b.to_string(), parent.clone())); + Style::default() + } + serde_json::Value::Null => Style::default(), } } fn format_of(v: &serde_json::Value) -> Option<(i64, i64)> { diff --git a/crates/horizon-client/src/screen_draw.rs b/crates/horizon-client/src/screen_draw.rs new file mode 100644 index 000000000..7d569e658 --- /dev/null +++ b/crates/horizon-client/src/screen_draw.rs @@ -0,0 +1,840 @@ +//! Menu screens as the `GuiGraphicsExtractor` calls vanilla's widgets make +//! (sprites, texture blits, fills, text highlight, text, scissor and the +//! tooltip), with ports of the widgets that make them: `StringWidget`, +//! `MultiLineTextWidget`, `Button`, `EditBox` (a font-aware port, scrolling +//! included) and the label layouts. The screen layouts built on them +//! (`pack_screen`) are compared with vanilla's calls by the parity harnesses; +//! [`paint`] draws them with the HUD batch. +use crate::{ + font::Font, + hud::{HudAtlas, HudBatch}, + text::{Style, Text}, +}; + +/// One GUI call. +#[derive(Clone, Debug, PartialEq)] +pub enum Draw { + /// `blitSprite`, the id without its namespace. + Sprite { + sprite: String, + x: i32, + y: i32, + w: i32, + h: i32, + color: i32, + }, + /// `blit` of a texture region; `texture` is the full path (`textures/…png`). + Blit { + texture: String, + x: i32, + y: i32, + w: i32, + h: i32, + u: f32, + v: f32, + src: [i32; 2], + tex: [i32; 2], + color: i32, + }, + /// `fill`, corners sorted. + Fill { + x0: i32, + y0: i32, + x1: i32, + y1: i32, + color: i32, + }, + /// `textHighlight`. + Highlight { + x0: i32, + y0: i32, + x1: i32, + y1: i32, + }, + Text { + text: Text, + x: i32, + y: i32, + color: i32, + shadow: bool, + }, + /// `enableScissor`, `disableScissor`. + Scissor { + x0: i32, + y0: i32, + x1: i32, + y1: i32, + }, + NoScissor, + /// `setTooltipForNextFrame`: the split lines and the mouse. + Tooltip { + lines: Vec, + x: i32, + y: i32, + }, +} + +pub const WHITE: i32 = -1; +pub const GRAY: u32 = 0xAAAAAA; +pub const DARK_GRAY: u32 = 0x555555; + +pub fn fill(out: &mut Vec, x0: i32, y0: i32, x1: i32, y1: i32, color: i32) { + out.push(Draw::Fill { + x0: x0.min(x1), + y0: y0.min(y1), + x1: x0.max(x1), + y1: y0.max(y1), + color, + }); +} +pub fn sprite(out: &mut Vec, sprite: &str, x: i32, y: i32, w: i32, h: i32) { + out.push(Draw::Sprite { + sprite: sprite.to_owned(), + x, + y, + w, + h, + color: WHITE, + }); +} +/// `blit(pipeline, texture, x, y, u, v, w, h, texW, texH)`. +pub fn blit( + out: &mut Vec, + texture: &str, + x: i32, + y: i32, + uv: (f32, f32), + w: i32, + h: i32, + tex: [i32; 2], +) { + out.push(Draw::Blit { + texture: texture.to_owned(), + x, + y, + w, + h, + u: uv.0, + v: uv.1, + src: [w, h], + tex, + color: WHITE, + }); +} +/// `graphics.text`: dropped when fully transparent; legacy codes resolved. +pub fn text(out: &mut Vec, text: Text, x: i32, y: i32, color: i32, shadow: bool) { + if (color as u32) >> 24 != 0 { + out.push(Draw::Text { + text: text.resolve_legacy(), + x, + y, + color, + shadow, + }); + } +} + +/// `StringDecomposer.iterateFormatted`: the drawn characters of `contents`, +/// with their index in it and their style; legacy `§` codes restyle what +/// follows them, `§r` returns to `reset`. +pub fn formatted(contents: &str, current: &Style, reset: &Style) -> Vec<(usize, char, Style)> { + let chars: Vec = contents.chars().collect(); + let mut style = current.clone(); + let mut out = Vec::new(); + let mut i = 0; + while i < chars.len() { + let c = chars[i]; + if c == '§' { + let Some(code) = chars.get(i + 1) else { break }; + let code = code.to_ascii_lowercase(); + if let Some(c) = crate::text::COLORS.iter().find(|c| c.0 == code) { + style = Style { + color: Some(c.2), + bold: Some(false), + italic: Some(false), + underlined: Some(false), + strikethrough: Some(false), + obfuscated: Some(false), + ..style + }; + } else { + match code { + 'k' => style.obfuscated = Some(true), + 'l' => style.bold = Some(true), + 'm' => style.strikethrough = Some(true), + 'n' => style.underlined = Some(true), + 'o' => style.italic = Some(true), + 'r' => style = reset.clone(), + _ => {} + } + } + i += 2; + continue; + } + out.push((i, c, style.clone())); + i += 1; + } + out +} + +/// Text measurement as vanilla's `Font` and `StringSplitter` do it, on +/// text whose spans may hold legacy `§` codes (each span is a component's +/// contents and style). +pub struct Measure<'a>(pub &'a Font); +impl Measure<'_> { + /// `Font.width`. + pub fn width(&self, t: &Text) -> i32 { + self.0.width_text(&t.resolve_legacy()) as i32 + } + pub fn width_str(&self, s: &str) -> i32 { + self.0.width(s) as i32 + } + /// `StringSplitter.headByWidth`: the leading characters whose widths sum to at most `max`. + pub fn head(&self, t: &Text, max: i32) -> Text { + let mut left = max as f32; + let mut out = Text::empty(); + for span in &t.spans { + let mut end = None; + let mut position = 0; + for (i, c, style) in formatted(&span.text, &span.style, &span.style) { + left -= self.0.advance(c, &style); + if left >= 0.0 { + position = i + 1; + } else { + end = Some(position); + break; + } + } + match end { + Some(p) => { + out.push(Text::styled( + span.text.chars().take(p).collect::(), + span.style.clone(), + )); + return out; + } + None => out.push(Text::styled(span.text.clone(), span.style.clone())), + } + } + t.clone() + } + /// `Font.plainSubstrByWidth`, from the start or (`tail`) the end, in characters. + pub fn plain(&self, s: &str, max: i32, tail: bool) -> usize { + if tail { + self.0.fit_reverse(s, max as f32) + } else { + self.0.fit(s, max as f32) + } + } + /// `StringSplitter.splitLines` (`Font.split`): breaks at a newline, or + /// at the last space (else the character) once the width is exceeded; + /// the rest of a broken part takes the style found at the break, legacy + /// codes counted from the root style. + pub fn split(&self, t: &Text, max: i32) -> Vec { + let max = (max as f32).max(1.0); + let mut parts: Vec<(Vec, Style)> = t + .spans + .iter() + .filter(|s| !s.text.is_empty()) + .map(|s| (s.text.chars().collect(), s.style.clone())) + .collect(); + let mut lines = Vec::new(); + let mut force_new_line = false; + let root = Style::default(); + 'restart: loop { + let (mut width, mut had_visible) = (0.0f32, false); + let (mut last_space, mut last_space_style) = (None::, Style::default()); + let mut offset = 0; + for (pi, (contents, style)) in parts.iter().enumerate() { + let s: String = contents.iter().collect(); + for (i, c, st) in formatted(&s, style, &root) { + let at = i + offset; + let brk = if c == '\n' { + Some((at, st.clone())) + } else { + if c == ' ' { + last_space = Some(at); + last_space_style = st.clone(); + } + let w = self.0.advance(c, &st); + width += w; + if !had_visible || width <= max { + had_visible |= w != 0.0; + None + } else { + Some(match last_space { + Some(p) => (p, last_space_style.clone()), + None => (at, st.clone()), + }) + } + }; + if let Some((at, split_style)) = brk { + let flat: Vec = + parts.iter().flat_map(|p| p.0.iter().copied()).collect(); + let first = flat.get(at).copied().unwrap_or(' '); + let new_line = first == '\n'; + let skip = usize::from(new_line || first == ' '); + force_new_line = new_line; + // FlatComponents.splitAt. + let mut line = Text::empty(); + let mut position = at; + let mut rest = Vec::new(); + let mut in_skip = false; + let mut done = false; + for (contents, style) in parts.drain(..) { + if done { + rest.push((contents, style)); + continue; + } + let size = contents.len(); + if !in_skip { + if position > size { + line.push(Text::styled( + contents.iter().collect::(), + style, + )); + position -= size; + continue; + } + let before: String = contents[..position].iter().collect(); + if !before.is_empty() { + line.push(Text::styled(before, style.clone())); + } + position += skip; + in_skip = true; + } + if position <= size { + if position < size { + rest.push((contents[position..].to_vec(), split_style.clone())); + } + done = true; + continue; + } + position -= size; + } + let _ = pi; + parts = rest; + lines.push(line); + continue 'restart; + } + } + offset += contents.len(); + } + break; + } + if !parts.is_empty() { + let mut line = Text::empty(); + for (contents, style) in parts { + line.push(Text::styled(contents.iter().collect::(), style)); + } + lines.push(line); + } else if force_new_line { + lines.push(Text::empty()); + } + lines + } +} + +/// `TextAlignment.CENTER.calculateLeft`. +pub fn center_left(anchor: i32, width: i32) -> i32 { + anchor - width / 2 +} + +/// `ComponentRenderUtils.clipText`: as much as fits before an unstyled "...". +pub fn clip(m: &Measure, t: &Text, width: i32) -> Text { + m.head(t, width - m.width_str("...")) + .append(Text::literal("...")) +} + +/// `StringWidget` (CLAMPED) at its position: its single line, clipped when wider than `max_width`. +pub fn string_widget( + out: &mut Vec, + m: &Measure, + message: &Text, + x: i32, + y: i32, + max_width: i32, +) { + let w = m.width(message); + let max = if max_width > 0 { max_width } else { w }; + let line = if w > max { + clip(m, message, max) + } else { + message.clone() + }; + text(out, line, x, y, WHITE, true); +} + +/// `MultiLineLabel.create(font, maxWidth, maxRows, message)`: the lines and their widths; +/// the last kept line gets "..." in `ellipsis` (the message's own style) when rows were cut. +pub fn label_lines( + m: &Measure, + message: &Text, + max_width: i32, + max_rows: usize, + ellipsis: &Style, +) -> Vec<(Text, i32)> { + let split = m.split(message, max_width); + let n = split.len().min(max_rows); + let mut out = Vec::new(); + for (i, line) in split.iter().take(n).enumerate() { + if i == n - 1 && n == max_rows && n != split.len() { + let clipped = m.head(line, m.width(line) - m.width_str("...")); + let with = clipped.append(Text::styled("...", ellipsis.clone())); + let w = m.width(&with); + out.push((with, w)); + } else { + out.push((line.clone(), m.width(line))); + } + } + out +} +/// `MultiLineTextWidget.getWidth`. +pub fn label_width(lines: &[(Text, i32)], max_width: i32) -> i32 { + lines.iter().map(|l| l.1).max().unwrap_or(0).min(max_width) +} +/// `MultiLineTextWidget.visitLines`. +pub fn label( + out: &mut Vec, + lines: &[(Text, i32)], + x: i32, + y: i32, + max_width: i32, + centered: bool, +) { + let mid = x + label_width(lines, max_width) / 2; + for (i, (line, w)) in lines.iter().enumerate() { + let left = if centered { center_left(mid, *w) } else { x }; + text(out, line.clone(), left, y + 9 * i as i32, WHITE, true); + } +} + +/// `Button` (`extractDefaultSprite` and the label over its contents, which +/// must fit: scrolling labels depend on the clock). +pub fn button( + out: &mut Vec, + m: &Measure, + label: &Text, + x: i32, + y: i32, + w: i32, + h: i32, + active: bool, + highlighted: bool, +) { + let sprite_id = if !active { + "widget/button_disabled" + } else if highlighted { + "widget/button_highlighted" + } else { + "widget/button" + }; + sprite(out, sprite_id, x, y, w, h); + let (left, right) = (x + 2, x + w - 2); + let lw = m.width(label); + let top = (y + y + h - 9) / 2 + 1; + let cx = ((left + right) / 2).clamp(left + lw / 2, right - lw / 2); + text(out, label.clone(), center_left(cx, lw), top, WHITE, true); +} +/// `Tooltip.splitTooltip` of a widget's tooltip, shown under the mouse. +pub fn tooltip(out: &mut Vec, m: &Measure, message: &Text, mouse: (i32, i32)) { + out.push(Draw::Tooltip { + lines: m.split(message, 170), + x: mouse.0, + y: mouse.1, + }); +} +/// `AbstractWidget.areCoordinatesInRectangle`. +pub fn inside(mouse: (i32, i32), x: i32, y: i32, w: i32, h: i32) -> bool { + mouse.0 >= x && mouse.1 >= y && mouse.0 < x + w && mouse.1 < y + h +} + +/// Vanilla's `EditBox`: value, cursor, selection and the first shown +/// character, which follows the cursor as `scrollTo` moves it. Positions +/// are in characters. +#[derive(Clone, Debug)] +pub struct TextField { + pub value: String, + pub cursor: usize, + pub highlight: usize, + pub display: usize, + pub max_length: usize, + pub bordered: bool, + pub x: i32, + pub y: i32, + pub width: i32, + pub height: i32, + pub focused: bool, + pub text_color: i32, + pub text_shadow: bool, + pub hint: Option, + pub suggestion: Option, +} +fn chars(s: &str) -> usize { + s.chars().count() +} +fn sub(s: &str, from: usize, to: usize) -> String { + s.chars().skip(from).take(to.saturating_sub(from)).collect() +} +impl TextField { + pub fn new(x: i32, y: i32, width: i32, height: i32) -> Self { + Self { + value: String::new(), + cursor: 0, + highlight: 0, + display: 0, + max_length: 32, + bordered: true, + x, + y, + width, + height, + focused: false, + text_color: -2039584, + text_shadow: true, + hint: None, + suggestion: None, + } + } + pub fn inner_width(&self) -> i32 { + if self.bordered { + self.width - 8 + } else { + self.width + } + } + fn text_x(&self) -> i32 { + self.x + if self.bordered { 4 } else { 0 } + } + fn text_y(&self) -> i32 { + if self.bordered { + self.y + (self.height - 8) / 2 + } else { + self.y + } + } + /// `setValue`. + pub fn set_value(&mut self, m: &Measure, value: &str) { + self.value = value.chars().take(self.max_length).collect(); + self.move_cursor_to(m, chars(&self.value), false); + self.set_highlight(m, self.cursor); + } + /// `insertText`: replaces the selection within the maximum length. True + /// when the value changed (its responder runs). + pub fn insert_text(&mut self, m: &Measure, input: &str) -> bool { + let (start, end) = ( + self.cursor.min(self.highlight), + self.cursor.max(self.highlight), + ); + let room = self.max_length as isize - chars(&self.value) as isize + (end - start) as isize; + if room <= 0 { + return false; + } + let filtered: String = input + .chars() + .filter(|c| *c >= ' ' && *c != '\u{7f}' && *c != '§') + .collect(); + let insert: String = filtered.chars().take(room as usize).collect(); + let n = chars(&insert); + self.value = format!( + "{}{}{}", + sub(&self.value, 0, start), + insert, + sub(&self.value, end, chars(&self.value)) + ); + self.set_cursor(m, start + n); + self.set_highlight(m, self.cursor); + true + } + /// `deleteChars(dir)`: the selection, or `dir` characters from the cursor. + pub fn delete_chars(&mut self, m: &Measure, dir: isize) -> bool { + if self.value.is_empty() { + return false; + } + if self.highlight != self.cursor { + return self.insert_text(m, ""); + } + let pos = (self.cursor as isize + dir).clamp(0, chars(&self.value) as isize) as usize; + let (start, end) = (pos.min(self.cursor), pos.max(self.cursor)); + if start == end { + return false; + } + self.value = format!( + "{}{}", + sub(&self.value, 0, start), + sub(&self.value, end, chars(&self.value)) + ); + self.set_cursor(m, start); + self.move_cursor_to(m, start, false); + true + } + pub fn move_cursor_to(&mut self, m: &Measure, pos: usize, extend: bool) { + self.set_cursor(m, pos); + if !extend { + self.set_highlight(m, self.cursor); + } + } + fn set_cursor(&mut self, m: &Measure, pos: usize) { + self.cursor = pos.min(chars(&self.value)); + self.scroll_to(m, self.cursor); + } + fn set_highlight(&mut self, m: &Measure, pos: usize) { + self.highlight = pos.min(chars(&self.value)); + self.scroll_to(m, self.highlight); + } + fn scroll_to(&mut self, m: &Measure, pos: usize) { + let len = chars(&self.value); + self.display = self.display.min(len); + let inner = self.inner_width(); + let rest = sub(&self.value, self.display, len); + let last = m.plain(&rest, inner, false) + self.display; + let mut display = self.display as isize; + if pos == self.display { + display -= m.plain(&self.value, inner, true) as isize; + } + if pos > last { + display += (pos - last) as isize; + } else if pos as isize <= display { + display = pos as isize; + } + self.display = display.clamp(0, len as isize) as usize; + } + /// `onClick`: the cursor where the mouse is (`findClickedPositionInText`). + pub fn click(&mut self, m: &Measure, x: f64, extend: bool) { + let pos = (x.floor() as i32 - self.text_x()).min(self.inner_width()); + let rest = sub(&self.value, self.display, chars(&self.value)); + let at = self.display + m.plain(&rest, pos, false); + self.move_cursor_to(m, at, extend); + } + pub fn contains(&self, x: f64, y: f64) -> bool { + x >= self.x as f64 + && y >= self.y as f64 + && x < (self.x + self.width) as f64 + && y < (self.y + self.height) as f64 + } + /// `extractWidgetRenderState`; `blink_ms` is the time since the field + /// was focused, `format` styles a substring starting at a character index. + pub fn draw( + &self, + out: &mut Vec, + m: &Measure, + blink_ms: u64, + format: Option<&dyn Fn(&str, usize) -> Text>, + ) { + if self.bordered { + let s = if self.focused { + "widget/text_field_highlighted" + } else { + "widget/text_field" + }; + sprite(out, s, self.x, self.y, self.width, self.height); + } + let color = self.text_color; + let len = chars(&self.value); + let rest = sub(&self.value, self.display, len); + let shown_len = m.plain(&rest, self.inner_width(), false); + let displayed = sub(&rest, 0, shown_len); + let rel_cursor = self.cursor as isize - self.display as isize; + let on_screen = rel_cursor >= 0 && rel_cursor <= shown_len as isize; + let show_cursor = self.focused && (blink_ms / 300).is_multiple_of(2) && on_screen; + let (tx, ty) = (self.text_x(), self.text_y()); + let mut draw_x = tx; + let rel_highlight = + (self.highlight as isize - self.display as isize).clamp(0, shown_len as isize) as usize; + let styled = |s: String, offset: usize| match format { + Some(f) => f(&s, offset), + None => Text::literal(s), + }; + if !displayed.is_empty() { + let half = if on_screen { + sub(&displayed, 0, rel_cursor as usize) + } else { + displayed.clone() + }; + let t = styled(half, self.display); + let w = m.width(&t); + text(out, t, draw_x, ty, color, self.text_shadow); + draw_x += w + 1; + } + let insert = self.cursor < len || len >= self.max_length; + let mut cursor_x = draw_x; + if !on_screen { + cursor_x = if rel_cursor > 0 { tx + self.width } else { tx }; + } else if insert { + cursor_x -= 1; + draw_x -= 1; + } + if !displayed.is_empty() && on_screen && (rel_cursor as usize) < shown_len { + let t = styled(sub(&displayed, rel_cursor as usize, shown_len), self.cursor); + text(out, t, draw_x, ty, color, self.text_shadow); + } + if let Some(hint) = &self.hint + && displayed.is_empty() + && !self.focused + { + text(out, hint.clone(), draw_x, ty, color, true); + } + if !insert && let Some(s) = &self.suggestion { + text( + out, + Text::literal(s.clone()), + cursor_x - 1, + ty, + -8355712, + self.text_shadow, + ); + } + if rel_highlight as isize != rel_cursor { + let hx = tx + m.width_str(&sub(&displayed, 0, rel_highlight)); + let right = self.x + self.width; + out.push(Draw::Highlight { + x0: cursor_x.min(right), + y0: ty - 1, + x1: (hx - 1).min(right), + y1: ty + 1 + 9, + }); + } + if show_cursor { + if insert { + fill(out, cursor_x, ty - 1, cursor_x + 1, ty + 10, color); + } else { + text( + out, + Text::literal("_"), + cursor_x, + ty, + color, + self.text_shadow, + ); + } + } + } +} + +/// Draws the calls with the HUD batch: sprites nine-sliced, textures from +/// the atlas (`textures/gui/x.png` is `gui/x`; tiled textures from their +/// corner), scissor clipping, and the tooltip at the mouse. +pub fn paint(batch: &mut HudBatch, atlas: &HudAtlas, draws: &[Draw]) { + let mut clip: Option<(usize, [i32; 4])> = None; + let mut tooltip = None; + for d in draws { + match d { + Draw::Sprite { + sprite, + x, + y, + w, + h, + color, + } => crate::ui::nine_slice( + batch, + atlas, + &format!("gui/sprites/{sprite}"), + *x as f32, + *y as f32, + *w as f32, + *h as f32, + crate::hud_layout::abgr(*color as u32), + ), + Draw::Blit { + texture, + x, + y, + w, + h, + u, + v, + src, + tex, + color, + } => { + let key = texture + .trim_start_matches("textures/") + .trim_end_matches(".png"); + let key = if atlas.sprites.contains_key(key) { + key + } else { + "misc/unknown_pack" + }; + let color = crate::hud_layout::abgr(*color as u32); + if src[0] == tex[0] && src[1] == tex[1] + || (*u == 0.0 && *v == 0.0 && src[0] <= tex[0] && src[1] <= tex[1]) + { + if let Some(mut r) = atlas.sprites.get(key).copied() { + let (du, dv) = (r.u1 - r.u0, r.v1 - r.v0); + r.u1 = r.u0 + du * src[0] as f32 / tex[0] as f32; + r.v1 = r.v0 + dv * src[1] as f32 / tex[1] as f32; + batch.rect_uv(*x as f32, *y as f32, *w as f32, *h as f32, r, color); + } + } else { + crate::ui::tiled( + batch, + atlas, + key, + *x as f32, + *y as f32, + *w as f32, + *h as f32, + tex[0] as f32, + color, + ); + } + } + Draw::Fill { + x0, + y0, + x1, + y1, + color, + } => batch.fill( + atlas, + *x0 as f32, + *y0 as f32, + (x1 - x0) as f32, + (y1 - y0) as f32, + crate::hud_layout::abgr(*color as u32), + ), + Draw::Highlight { x0, y0, x1, y1 } => { + let (a, b) = ((*x0).min(*x1), (*x0).max(*x1)); + batch.fill( + atlas, + a as f32, + *y0 as f32, + (b - a) as f32, + (y1 - y0) as f32, + crate::hud::rgba(0, 0, 255, 128), + ); + } + Draw::Text { + text, + x, + y, + color, + shadow, + } => { + batch.text_styled( + atlas, + text, + *x as f32, + *y as f32, + crate::hud_layout::abgr(*color as u32), + *shadow, + ); + } + Draw::Scissor { x0, y0, x1, y1 } => { + clip = Some((batch.vertices.len(), [*x0, *y0, *x1, *y1])) + } + Draw::NoScissor => { + if let Some((start, [x0, y0, x1, y1])) = clip.take() { + batch.clip_since(start, x0 as f32, y0 as f32, x1 as f32, y1 as f32); + } + } + Draw::Tooltip { lines, x, y } => { + tooltip = Some((lines.clone(), (*x as f32, *y as f32))) + } + } + } + if let Some((lines, at)) = tooltip { + crate::ui::tooltip(batch, atlas, &lines, at); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java new file mode 100644 index 000000000..bd711ba6e --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPackScreenOracle.java @@ -0,0 +1,395 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import com.mojang.renderpearl.api.pipeline.RenderPipeline; +import com.mojang.serialization.JsonOps; +import java.lang.reflect.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.InputType; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.ActiveTextCollector; +import net.minecraft.client.gui.Font; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.GuiGraphicsExtractor; +import net.minecraft.client.gui.TextAlignment; +import net.minecraft.client.gui.components.AbstractWidget; +import net.minecraft.client.gui.components.EditBox; +import net.minecraft.client.gui.components.WidgetTooltipHolder; +import net.minecraft.client.gui.screens.ConfirmScreen; +import net.minecraft.client.gui.screens.Screen; +import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipPositioner; +import net.minecraft.client.gui.screens.packs.PackSelectionScreen; +import net.minecraft.client.input.MouseButtonEvent; +import net.minecraft.client.input.MouseButtonInfo; +import net.minecraft.client.sounds.SoundManager; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.ComponentSerialization; +import net.minecraft.resources.Identifier; +import net.minecraft.server.packs.PackLocationInfo; +import net.minecraft.server.packs.PackSelectionConfig; +import net.minecraft.server.packs.repository.Pack; +import net.minecraft.server.packs.repository.PackCompatibility; +import net.minecraft.server.packs.repository.PackRepository; +import net.minecraft.server.packs.repository.PackSource; +import net.minecraft.util.FormattedCharSequence; +import net.minecraft.util.Util; +import net.minecraft.world.flag.FeatureFlagSet; +import net.minecraft.world.inventory.tooltip.TooltipComponent; +import org.joml.Matrix3x2f; +import org.joml.Matrix3x2fStack; + +/** + * Original oracle for the resource pack screen's drawing: a real + * PackSelectionScreen over a PackRepository of the case's packs (titles, + * descriptions, sources, compatibility, required, positions, icons), driven + * by the case's clicks, typing in the search box and mouse wheel, with the + * ConfirmScreen an incompatible pack opens (a stand-in Gui switches screens + * as Gui.setScreen does: the old screen loses focus, the new one is + * initialised or repositioned). The screen shown at the end is drawn + * (Screen.extractRenderState: its widgets, then the tooltip) and every + * GuiGraphicsExtractor call is recorded. + * + * Input lines: case JSON. Output lines: {screen, draws} or {error}. + */ +public final class VanillaPackScreenOracle { + static Object unsafe; + static Method allocate; + static Font font; + + @SuppressWarnings("unchecked") + static T alloc(Class type) throws Exception { + return (T) allocate.invoke(unsafe, type); + } + + static Field field(Class owner, String name) throws Exception { + Field f = owner.getDeclaredField(name); + f.setAccessible(true); + return f; + } + + static void put(Object target, Class owner, String name, Object value) throws Exception { + Field f = owner.getDeclaredField(name); + long offset = (long) unsafe.getClass().getMethod("objectFieldOffset", Field.class).invoke(unsafe, f); + Class t = f.getType(); + String setter = t == int.class ? "putInt" : t == boolean.class ? "putBoolean" : t == float.class ? "putFloat" : t == long.class ? "putLong" : "putObject"; + Class param = t.isPrimitive() ? t : Object.class; + unsafe.getClass().getMethod(setter, Object.class, long.class, param).invoke(unsafe, target, offset, value); + } + + static Object call(Object target, Class owner, String name) throws Exception { + Method m = owner.getDeclaredMethod(name); + m.setAccessible(true); + return m.invoke(target); + } + + /** Styled runs: [text, rgb or null, bold, italic, underlined, strikethrough, obfuscated]. */ + static JsonArray runs(FormattedCharSequence s) { + var runs = new JsonArray(); + s.accept((index, style, cp) -> { + Integer rgb = style.getColor() == null ? null : style.getColor().getValue(); + boolean[] flags = {style.isBold(), style.isItalic(), style.isUnderlined(), style.isStrikethrough(), style.isObfuscated()}; + JsonArray last = runs.isEmpty() ? null : runs.get(runs.size() - 1).getAsJsonArray(); + boolean same = last != null && Objects.equals(last.get(1).isJsonNull() ? null : last.get(1).getAsInt(), rgb); + for (int i = 0; same && i < 5; i++) same = last.get(2 + i).getAsBoolean() == flags[i]; + if (same) { + 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); + for (boolean f : flags) run.add(f); + runs.add(run); + } + return true; + }); + return runs; + } + + /** Records every GuiGraphicsExtractor call. */ + public static final class Capture extends GuiGraphicsExtractor { + JsonArray draws; + Matrix3x2fStack stack; + int width, height; + private Capture() { super(null, null, 0, 0); } + @Override public int guiWidth() { return width; } + @Override public int guiHeight() { return height; } + @Override public Matrix3x2fStack pose() { return stack; } + @Override public void nextStratum() { add("stratum"); } + @Override public void requestCursor(com.mojang.blaze3d.platform.cursor.CursorType type) { } + @Override public boolean containsPointInScissor(int x, int y) { return true; } + JsonObject add(String type) { + var o = new JsonObject(); + o.addProperty("type", type); + if (!stack.equals(new Matrix3x2f())) { + var a = new JsonArray(); + for (float v : new float[] {stack.m00(), stack.m01(), stack.m10(), stack.m11(), stack.m20(), stack.m21()}) a.add(v); + o.add("matrix", a); + } + draws.add(o); + return o; + } + @Override public void enableScissor(int x0, int y0, int x1, int y1) { + var o = add("scissor"); + o.addProperty("x0", x0); o.addProperty("y0", y0); o.addProperty("x1", x1); o.addProperty("y1", y1); + } + @Override public void disableScissor() { add("noscissor"); } + @Override public void fill(RenderPipeline p, int x0, int y0, int x1, int y1, int color) { + var o = add("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); + } + @Override public void textHighlight(int x0, int y0, int x1, int y1, boolean invert) { + var o = add("highlight"); + o.addProperty("x0", x0); o.addProperty("y0", y0); o.addProperty("x1", x1); o.addProperty("y1", y1); + } + @Override public void blitSprite(RenderPipeline p, Identifier id, int x, int y, int w, int h, int color) { + var o = add("sprite"); + o.addProperty("sprite", id.getPath()); + o.addProperty("x", x); o.addProperty("y", y); o.addProperty("w", w); o.addProperty("h", h); + o.addProperty("color", color); + } + @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 = add("blit"); + o.addProperty("texture", texture.getPath()); + o.addProperty("x", x); o.addProperty("y", y); o.addProperty("w", w); o.addProperty("h", h); + o.addProperty("u", u); o.addProperty("v", v); + o.addProperty("srcW", srcW); o.addProperty("srcH", srcH); o.addProperty("texW", texW); o.addProperty("texH", texH); + o.addProperty("color", color); + } + void text(FormattedCharSequence str, int x, int y, int color, boolean shadow) { + var o = add("text"); + o.add("runs", runs(str)); + o.addProperty("x", x); o.addProperty("y", y); o.addProperty("color", color); o.addProperty("shadow", shadow); + } + @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); + } + ActiveTextCollector collector(float opacity) { + var self = this; + return new ActiveTextCollector() { + Parameters parameters = new Parameters(new Matrix3x2f(stack), opacity, null); + @Override public Parameters defaultParameters() { return parameters; } + @Override public void defaultParameters(Parameters p) { parameters = p; } + @Override public void accept(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); + } + @Override public void acceptScrolling(Component m, int cx, int l, int r, int t, int b, Parameters p) { + defaultScrollingHelper(m, cx, l, r, t, b, font.width(m), 9, p); + } + }; + } + @Override public ActiveTextCollector textRendererForWidget(AbstractWidget owner, GuiGraphicsExtractor.HoveredTextEffects effects) { + return collector(owner.getAlpha()); + } + @Override public ActiveTextCollector textRenderer(GuiGraphicsExtractor.HoveredTextEffects effects, java.util.function.Consumer consumer) { + return collector(1.0F); + } + @Override public void setTooltipForNextFrame(Font font, List lines, Optional image, + ClientTooltipPositioner positioner, int x, int y, boolean replace, Identifier style) { + var o = add("tooltip"); + var a = new JsonArray(); + for (var l : lines) a.add(runs(l)); + o.add("lines", a); + o.addProperty("x", x); o.addProperty("y", y); + } + } + + /** The window's text input area: not tracked. */ + static final class NoTextInput extends com.mojang.blaze3d.platform.TextInputManager { + NoTextInput() { super(null); } + @Override public void setTextInputArea(int x0, int y0, int x1, int y1) { } + @Override public void onTextInputFocusChange(Object owner, boolean focused) { } + @Override public void startTextInput(Object owner) { } + @Override public void stopTextInput(Object owner) { } + @Override public void stopTextInput() { } + } + + /** Sounds are not played. */ + public static final class NoSound extends SoundManager { + private NoSound() { super(null); } + @Override public net.minecraft.client.sounds.SoundEngine.PlayResult play(net.minecraft.client.resources.sounds.SoundInstance instance) { return null; } + } + + /** No input method editor. */ + public static final class NoKeyboard extends net.minecraft.client.KeyboardHandler { + private NoKeyboard() { super(null); } + @Override public void resubmitLastPreeditEvent(net.minecraft.client.gui.components.events.GuiEventListener e) { } + } + + /** Gui.setScreen without the window: the screen shown, focus cleared on the old one. */ + public static final class StubGui extends Gui { + Screen current; + int width, height; + private StubGui() { super(null, null, null); } + @Override public void setScreen(Screen screen) { + try { + if (current != null) { + current.clearFocus(); + current.removed(); + } + current = screen; + screen.added(); + show(screen, width, height); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + @Override public Screen screen() { return current; } + } + + /** Screen.init(width, height) without narration. */ + static void show(Screen screen, int width, int height) throws Exception { + screen.width = width; + screen.height = height; + if (!(boolean) field(Screen.class, "initialized").get(screen)) { + call(screen, Screen.class, "init"); + Method m = Screen.class.getDeclaredMethod("setInitialFocus"); + m.setAccessible(true); + m.invoke(screen); + } else { + Method m = screen.getClass().getDeclaredMethod("repositionElements"); + m.setAccessible(true); + m.invoke(screen); + } + put(screen, Screen.class, "initialized", true); + } + + static Component component(JsonElement e) { + return ComponentSerialization.CODEC.parse(JsonOps.INSTANCE, e).getOrThrow(); + } + + static Pack pack(JsonObject o) { + String id = o.get("id").getAsString(); + PackSource source = switch (o.get("source").getAsString()) { + case "builtin" -> PackSource.BUILT_IN; + case "world" -> PackSource.WORLD; + case "server" -> PackSource.SERVER; + case "feature" -> PackSource.FEATURE; + default -> PackSource.DEFAULT; + }; + var location = new PackLocationInfo(id, component(o.get("title")), source, Optional.empty()); + var compatibility = switch (o.get("compat").getAsString()) { + case "old" -> PackCompatibility.TOO_OLD; + case "new" -> PackCompatibility.TOO_NEW; + case "unknown" -> PackCompatibility.UNKNOWN; + default -> PackCompatibility.COMPATIBLE; + }; + var metadata = new Pack.Metadata(component(o.get("description")), compatibility, FeatureFlagSet.of(), List.of()); + var config = new PackSelectionConfig(o.get("required").getAsBoolean(), + o.get("position").getAsString().equals("top") ? Pack.Position.TOP : Pack.Position.BOTTOM, o.get("fixed").getAsBoolean()); + return new Pack(location, null, metadata, config); + } + + static JsonObject run(JsonObject c, Minecraft mc, StubGui gui) throws Exception { + int width = c.get("width").getAsInt(), height = c.get("height").getAsInt(); + gui.width = width; + gui.height = height; + gui.current = null; + put(mc, Minecraft.class, "level", c.get("inWorld").getAsBoolean() ? alloc(net.minecraft.client.multiplayer.ClientLevel.class) : null); + List packs = new ArrayList<>(); + Map icons = new HashMap<>(); + for (var p : c.getAsJsonArray("packs")) { + packs.add(pack(p.getAsJsonObject())); + icons.put(p.getAsJsonObject().get("id").getAsString(), p.getAsJsonObject().get("icon").getAsBoolean()); + } + var repository = new PackRepository(consumer -> packs.forEach(consumer)); + repository.reload(); + List initial = new ArrayList<>(); + for (var s : c.getAsJsonArray("selected")) initial.add(s.getAsString()); + repository.setSelected(initial); + var screen = new PackSelectionScreen(repository, r -> { }, Path.of(c.get("dir").getAsString()), Component.translatable("resourcePack.title")); + gui.setScreen(screen); + // PackSelectionScreen.loadPackIcon: a pack with a pack.png gets its own texture. + @SuppressWarnings("unchecked") + var iconMap = (Map) field(PackSelectionScreen.class, "packIcons").get(screen); + iconMap.clear(); + for (var e : icons.entrySet()) { + String id = e.getKey(); + iconMap.put(id, e.getValue() + ? Identifier.withDefaultNamespace("pack/" + Util.sanitizeName(id, Identifier::validPathChar) + "/" + com.google.common.hash.Hashing.sha1().hashUnencodedChars(id) + "/icon") + : Identifier.withDefaultNamespace("textures/misc/unknown_pack.png")); + } + var search = (EditBox) field(PackSelectionScreen.class, "search").get(screen); + var info = new MouseButtonInfo(1, 0); + for (var a : c.getAsJsonArray("actions")) { + var o = a.getAsJsonObject(); + Screen s = gui.current; + switch (o.get("type").getAsString()) { + case "click" -> { + var event = new MouseButtonEvent(o.get("x").getAsDouble(), o.get("y").getAsDouble(), info); + // Never press Open Pack Folder: it opens a file manager. + if (s.getChildAt(event.x(), event.y()).orElse(null) instanceof net.minecraft.client.gui.components.Button b + && b.getMessage().getString().equals(Component.translatable("pack.openFolder").getString())) { + throw new IllegalArgumentException("click on Open Pack Folder"); + } + s.mouseClicked(event, false); + if (gui.current == s) s.mouseReleased(event); + } + case "scroll" -> s.mouseScrolled(o.get("x").getAsDouble(), o.get("y").getAsDouble(), 0.0, o.get("amount").getAsDouble()); + case "type" -> { if (s == screen && screen.getFocused() == search) search.insertText(o.get("text").getAsString()); } + case "erase" -> { if (s == screen && screen.getFocused() == search) search.deleteChars(-o.get("count").getAsInt()); } + default -> throw new IllegalArgumentException(o.toString()); + } + } + Screen shown = gui.current; + for (var w : shown.children()) { + if (w instanceof AbstractWidget widget) { + var holder = (WidgetTooltipHolder) field(AbstractWidget.class, "tooltip").get(widget); + put(holder, WidgetTooltipHolder.class, "wasDisplayed", widget.isMouseOver(c.getAsJsonArray("mouse").get(0).getAsInt(), c.getAsJsonArray("mouse").get(1).getAsInt())); + put(holder, WidgetTooltipHolder.class, "displayStartTime", Util.getMillis() - 1000L); + } + } + if (shown == screen) put(search, EditBox.class, "focusedTime", Util.getMillis() - c.get("blink").getAsLong()); + var g = alloc(Capture.class); + g.draws = new JsonArray(); + g.stack = new Matrix3x2fStack(16); + g.width = width; + g.height = height; + shown.extractRenderState(g, c.getAsJsonArray("mouse").get(0).getAsInt(), c.getAsJsonArray("mouse").get(1).getAsInt(), 1.0F); + var result = new JsonObject(); + result.addProperty("screen", shown == screen ? "packs" : shown instanceof ConfirmScreen ? "confirm" : shown.getClass().getSimpleName()); + result.add("draws", g.draws); + return result; + } + + public static void main(String[] args) throws Exception { + ParityData.init(); + var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe"); + unsafeField.setAccessible(true); + unsafe = unsafeField.get(null); + allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); + font = ParityFont.create(ParityFont.resources()); + Minecraft mc = alloc(Minecraft.class); + put(mc, Minecraft.class, "font", font); + put(mc, Minecraft.class, "lastInputType", InputType.MOUSE); + put(mc, Minecraft.class, "textInputManager", new NoTextInput()); + put(mc, Minecraft.class, "soundManager", alloc(NoSound.class)); + put(mc, Minecraft.class, "keyboardHandler", alloc(NoKeyboard.class)); + var gui = alloc(StubGui.class); + put(mc, Minecraft.class, "gui", gui); + field(Minecraft.class, "instance").set(null, mc); + var gson = new Gson(); + var out = new StringBuilder(); + for (String line : Files.readAllLines(Path.of(args[0]))) { + if (line.isBlank()) continue; + var c = JsonParser.parseString(line).getAsJsonObject(); + JsonObject result; + try { + result = run(c, mc, gui); + } catch (Throwable error) { + Throwable cause = error; + while (cause.getCause() != null) cause = cause.getCause(); + var sw = new java.io.StringWriter(); + cause.printStackTrace(new java.io.PrintWriter(sw)); + result = new JsonObject(); + result.addProperty("error", sw.toString().lines().limit(10).reduce("", (a, b) -> a + b + " | ")); + } + out.append(gson.toJson(result)).append('\n'); + } + Files.writeString(Path.of(args[1]), out.toString(), StandardCharsets.UTF_8); + } +} diff --git a/tools/test_pack_screen_parity.py b/tools/test_pack_screen_parity.py new file mode 100644 index 000000000..a73f734fe --- /dev/null +++ b/tools/test_pack_screen_parity.py @@ -0,0 +1,180 @@ +#!/usr/bin/env python3 +"""Compare the resource pack screen's drawing with the vanilla client's. + +Each case is a pack repository (titles and descriptions as text components, +with legacy formatting codes, colours and styles; pack sources; compatible, +too old, too new or unknown packs; required, fixed and positioned packs; +icons), an initial selection, a GUI size, in a world or not, and what the +player does: clicks on the lists (an entry's icon arrows, an entry, a +header, the scroll bar, empty space), on the search box, typing and erasing +in it, the mouse wheel over the lists, and the ConfirmScreen an incompatible +pack opens (yes, no, or left open). The Java oracle +(VanillaPackScreenOracle) runs a real PackSelectionScreen through these and +records every GuiGraphicsExtractor call of the screen shown at the end +(widgets, list backgrounds, scissor, separators, scroll bars, entries with +their incompatibility tint, hover overlay and arrows, the selection +outline, the search box, the buttons and their tooltip); +examples/pack_screen_fixture runs horizon_client::pack_screen, which the +game's pack screen is, through the same actions. The call lists must agree. + + test_pack_screen_parity.py [--count N] [--detail N] +""" +import argparse +import json +import os +import random +import subprocess +import sys + +try: + from . import interaction_lab as lib, lab, test_rust_parity as base, test_model_baking_parity as baking +except ImportError: + import interaction_lab as lib + import lab + import test_rust_parity as base + import test_model_baking_parity as baking + +PARITY = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity' +IDS = ['vanilla', 'programmer_art', 'file/Faithful.zip', 'file/alpha', 'file/Zeta pack', 'file/zeta', 'file/é', 'file/0', + 'server', 'world', 'fabric', 'file/a.zip', 'file/A.zip', 'file/b', 'file/HC', 'file/Stay True 1.21.zip'] +WORDS = ['Faithful', 'pack', 'textures', 'the', 'default', 'look', 'of', 'Minecraft', 'x32', 'by', 'Vattic', + 'Programmer', 'Art', 'resolution', 'a', 'very', 'loooooooooooooooooooooongword', '§4red', '§lbold§r', '1.21', '!', + 'Stay', 'True', 'é', 'Ünïcödé'] +COLORS = ['red', 'gold', 'aqua', 'gray', '#12AB34', 'dark_purple', 'yellow'] + + +def words(rng, lo, hi): + return ' '.join(rng.choice(WORDS) for _ in range(rng.randint(lo, hi))) + + +def component(rng, lo, hi): + kind = rng.random() + if kind < 0.45: + return words(rng, lo, hi) + if kind < 0.6: + return words(rng, lo, hi) + '\n' + words(rng, 1, hi) + if kind < 0.85: + part = {'text': words(rng, lo, hi)} + for key in ('bold', 'italic', 'underlined'): + if rng.random() < 0.2: + part[key] = True + if rng.random() < 0.6: + part['color'] = rng.choice(COLORS) + if rng.random() < 0.4: + part['extra'] = [{'text': ' ' + words(rng, 1, 4), 'color': rng.choice(COLORS)}] + return part + return [words(rng, 1, 3), {'text': ' ' + words(rng, lo, hi), 'color': rng.choice(COLORS)}] + + +def cases(count): + rng = random.Random(0x50534352) + out = [] + for n in range(count): + width, height = rng.choice([(320, 240), (427, 240), (480, 270), (640, 360), (854, 480), (400, 160), (570, 320)]) + ids = rng.sample(IDS, rng.randint(1, 14)) + packs = [] + for i in ids: + packs.append({'id': i, 'title': component(rng, 1, 3) if rng.random() < 0.8 else i, + 'description': component(rng, 0, 14), + 'source': rng.choice(['default'] * 4 + ['builtin', 'world', 'server', 'feature']), + 'compat': rng.choice(['compatible'] * 5 + ['old', 'new', 'unknown']), + 'required': rng.random() < 0.15, 'position': rng.choice(['top', 'top', 'bottom']), + 'fixed': rng.random() < 0.15, 'icon': rng.random() < 0.4}) + selected = rng.sample(ids, rng.randint(0, len(ids))) + cx = width // 2 + left, right = cx - 15 - 200, cx + 15 + top, bottom = 49, height - 33 + + def point(): + r = rng.random() + if r < 0.6: + x0 = rng.choice([left, right]) + row = rng.randint(0, 9) + y = top + 2 + 13 + 36 * row + rng.randint(-2, 35) + x = x0 + rng.choice([rng.randint(0, 40), rng.randint(0, 200), rng.randint(2, 36), rng.randint(194, 199)]) + return x, min(y, bottom - 1) + if r < 0.7: + return rng.randint(cx - 100, cx + 99), rng.randint(30, 44) + if r < 0.8: + return rng.choice([left, right]) + rng.randint(0, 199), rng.randint(top, top + 16) + return rng.randint(0, width - 1), rng.randint(0, bottom - 1) + def safe(x, y): + # Not the Open Pack Folder button: vanilla would open the folder. + return not (cx - 154 <= x < cx - 4 and height - 26 <= y < height - 6) + actions = [] + for _ in range(rng.choice([0, 1, 2, 4, 8, 14])): + r = rng.random() + if r < 0.7: + x, y = point() if r < 0.6 else (rng.randint(cx - 160, cx + 160), rng.randint(height // 2 - 30, height // 2 + 60)) + if safe(x, y): + actions.append({'type': 'click', 'x': x, 'y': y}) + elif r < 0.8: + x, y = point() + actions.append({'type': 'scroll', 'x': x, 'y': y, 'amount': rng.choice([-3, -1, 1, 2, 0.5])}) + elif r < 0.93: + actions.append({'type': 'type', 'text': rng.choice(['a', 'e', 'pack', 'file', 'Faith', 'z', ' ', 'zzz', 'x32 by'])}) + else: + actions.append({'type': 'erase', 'count': rng.randint(1, 4)}) + mouse = rng.choice([point(), point(), point(), (rng.randint(0, width - 1), rng.randint(0, height - 1)), + (rng.randint(cx - 154, cx + 154), height - 26 + rng.randint(0, 19)), + (rng.randint(cx - 160, cx + 160), rng.randint(height // 2 - 30, height // 2 + 60))]) + out.append({'width': width, 'height': height, 'inWorld': rng.random() < 0.3, 'packs': packs, 'selected': selected, + 'actions': actions, 'mouse': list(mouse), 'blink': rng.choice([0, 100, 400, 650])}) + return out + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--count', type=int, default=3000) + parser.add_argument('--detail', type=int, default=3) + args = parser.parse_args() + lock, jars, _ = base.verify_artifacts() + libraries = baking.client_libraries() + build = lab.LOCAL / 'pack-screen-parity'; build.mkdir(parents=True, exist_ok=True) + (build / 'resourcepacks').mkdir(exist_ok=True) + chosen = cases(args.count) + for c in chosen: + c['dir'] = str(build / 'resourcepacks') + 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])) + + def run(command, name): + with (build / (name + '.log')).open('w') as log: + result = subprocess.run(list(map(str, command)), cwd=lab.ROOT, timeout=3600, stdout=log, stderr=subprocess.STDOUT) + if result.returncode: + print((build / (name + '.log')).read_text()[-4000:]); sys.exit(f'{name} failed') + run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-nowarn', '-cp', dependencies, '-d', classes, + *(PARITY / f'{n}.java' for n in ('ParityData', 'ParityFont', 'VanillaPackScreenOracle'))], 'compile-java') + run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaPackScreenOracle', + inputs, build / 'vanilla.jsonl'], 'vanilla') + lib.cargo_example('horizon-client', 'pack_screen_fixture', lib.RESOURCES, inputs, build / 'rust.jsonl') + vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()] + rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()] + assert len(vanilla) == len(rust) == len(chosen), (len(vanilla), len(rust), len(chosen)) + errors = [v['error'] for v in vanilla if 'error' in v] + bad = [] + for c, v, r in zip(chosen, vanilla, rust): + if 'error' in v or v == r: + continue + bad.append((c, v, r)) + for e in sorted(set(errors))[:5]: + print('ORACLE ERROR', e[:1500]) + for c, v, r in bad[:args.detail]: + brief = {k: c[k] for k in ('width', 'height', 'inWorld', 'selected', 'actions', 'mouse', 'blink')} + print('MISMATCH', json.dumps(brief)[:1500]) + if v.get('screen') != r.get('screen'): + print(f' screen: vanilla {v.get("screen")} | horizon {r.get("screen")}') + a, b = v.get('draws', []), r.get('draws', []) + i = next((i for i in range(max(len(a), len(b))) if i >= len(a) or i >= len(b) or a[i] != b[i]), None) + if i is not None: + print(f' call {i}: vanilla {json.dumps(a[i]) if i < len(a) else None}') + print(f' call {i}: horizon {json.dumps(b[i]) if i < len(b) else None}') + print(f'{len(chosen) - len(bad) - len(errors)}/{len(chosen)} pack screens match; {len(errors)} oracle errors') + if bad or errors: + sys.exit(1) + print('pack screen parity ok') + + +if __name__ == '__main__': + main()