From d241c54e059bbb9274f8e2c1b2a1db6e3f62e815 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Mon, 26 Oct 2026 19:58:45 +0100 Subject: [PATCH] Official mod: Recipes, a recipe viewer Every item sits in the item panel beside the inventory and container screens, with a search box (words in the name or id, @namespace, #tag). R or a click shows an item's recipes, U or a right click its uses, with a tab per station; Back returns through the pages. + beside a crafting recipe the player knows fills the grid as the recipe book does. In creative mode, with "Click gives items" on, a click gives one item and a right click a stack. The keys are rebindable in Controls. Written from vanilla 26.3's recipe book and screens and Horizon's design system only. On servers that are not Horizon it shows the game's own 26.3 recipes; known recipes and + follow the server's recipe book. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 7 + Cargo.toml | 2 +- docs/mods.md | 5 +- mods/official/recipes/Cargo.toml | 16 ++ mods/official/recipes/horizon-mod.toml | 9 + mods/official/recipes/src/lib.rs | 364 +++++++++++++++++++++++++ 6 files changed, 400 insertions(+), 3 deletions(-) create mode 100644 mods/official/recipes/Cargo.toml create mode 100644 mods/official/recipes/horizon-mod.toml create mode 100644 mods/official/recipes/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 0e93bba0e..4d48c48cb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2962,6 +2962,13 @@ dependencies = [ "objc2-quartz-core 0.3.2", ] +[[package]] +name = "recipes" +version = "1.0.0" +dependencies = [ + "horizon-mod-sdk", +] + [[package]] name = "redox_syscall" version = "0.4.1" diff --git a/Cargo.toml b/Cargo.toml index e4628f962..f6ff38ad8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace] exclude = ["launcher", "crates/horizon-telemetry-server", "crates/horizon-mod-registry", "third_party/wgpu-hal"] -members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/zoom", "xtask"] +members = ["crates/horizon-core", "crates/horizon-dualsense", "crates/horizon-threads", "crates/horizon-world", "crates/horizon-client", "crates/horizon-server-files", "crates/horizon-server", "crates/horizon-bots", "crates/horizon-assets", "crates/horizon-protocol", "crates/horizon-theme", "crates/horizon-prepare", "crates/horizon-telemetry", "crates/horizon-bench", "crates/horizon-friends", "crates/horizon-relay", "crates/horizon-mod-sdk", "crates/horizon-mods", "crates/horizon-mods/tests/guest", "crates/horizon-mods/tests/ui_guest", "crates/cargo-horizon-mod", "crates/horizon-port-pack", "crates/horizon-shaders", "crates/horizon-shader-api", "crates/horizon-release-sign", "crates/horizon-mod-sdk/examples/coords-hud", "crates/horizon-mod-sdk/examples/predator-missile", "crates/horizon-mod-sdk/examples/welcome", "mods/official/fps-overlay", "mods/official/keystrokes", "mods/official/minimap", "mods/official/recipes", "mods/official/zoom", "xtask"] resolver = "2" [workspace.package] diff --git a/docs/mods.md b/docs/mods.md index 706e48bd6..4c7ba012a 100644 --- a/docs/mods.md +++ b/docs/mods.md @@ -15,7 +15,7 @@ folder, loads no runtime and plays exactly like vanilla 26.3. | The contract (WIT) | `crates/horizon-mod-sdk/wit/horizon.wit` | 0.1: log, game-read, chat, hud, storage, command, ui; tick, frame, chat and command hooks | | SDK for mod authors | `crates/horizon-mod-sdk` | 0.1 | | Example mods | `crates/horizon-mod-sdk/examples/coords-hud`, `examples/predator-missile` | coordinates, facing and time HUD, `/where`, `/coords`; `/missile`, a guided missile from vanilla commands | -| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap | +| Horizon's official mods | `mods/official/` | the extras moving to the registry: FPS Counter (`fps-overlay`), Keystrokes, Zoom, Minimap; and Recipes, a recipe viewer | | Runtime | `crates/horizon-mods` | wasmtime 48 LTS, component model | | Authoring tool | `crates/cargo-horizon-mod` | `cargo horizon-mod new [--template code\|content] / build / run / test / check`, and the registry's CI (`registry build / review / list`) | | In the game | `crates/horizon-client/src/game/mods.rs`, Options > Mods | client mods | @@ -521,7 +521,7 @@ says how). The formats: [api/mod-index.md](api/mod-index.md). ### Horizon's official mods -The Horizon extras that are mods now live in `mods/official//`, one crate each in the game's workspace, so +The Horizon extras that are mods now, and Horizon's own recipe viewer, live in `mods/official//`, one crate each in the game's workspace, so `cargo clippy --workspace` and pr_ready cover them. They use only the public API, like any other mod, with the same options on their settings page as the extra had and the same look. Each is published by a maintainer: build it on `main` with the toolchain CI uses (`cd mods/official/ && cargo horizon-mod build`), then open a pull request in @@ -535,6 +535,7 @@ so the same rustc and `Cargo.lock` give the same file. | Keystrokes | `keystrokes` | Extras > Keystrokes | `corner`: as above, default `top_left`; `cps`: `true` (default), `false` | | Zoom | `zoom` | Extras > Zoom | `level`: `2`, `3`, `4` (default), `6`, `8`, `10`; `smooth`: `true` (default), `false`; `sensitivity` (slower turning): `true` (default), `false`. The key is the game's: `key.zoom.zoom` in `horizon-mods.txt`, default `key.keyboard.z` | | Minimap | `minimap` | Extras > Minimap | `corner`: as above, default `top_right`; `size`: `64`, `96` (default), `128`; `shape`: `square` (default), `round`; `zoom` (blocks per pixel): `0.5`, `1` (default), `2`, `4`; `rotate`: `false` (default), `true`. The game draws the map (`render.set-minimap`) | +| Recipes | `recipes` | nothing (new) | `give` (a click on the item panel gives the item in creative mode: one, a stack with a right click): `false` (default), `true`. The keys are the game's: `key.recipes.recipe` (default `key.keyboard.r`) and `key.recipes.uses` (default `key.keyboard.u`) in `horizon-mods.txt`. Every item sits in the item panel (`browser`) with a search box (words in the name or id, `@namespace`, `#tag`); R or a click shows an item's recipes, U or a right click its uses, a tab per station, and + fills the grid with a recipe the player knows (`recipes.place`). On servers that are not Horizon it shows the game's own 26.3 recipes; known recipes and + follow the server's recipe book | ## Versions and compatibility diff --git a/mods/official/recipes/Cargo.toml b/mods/official/recipes/Cargo.toml new file mode 100644 index 000000000..5bf0f5d9c --- /dev/null +++ b/mods/official/recipes/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "recipes" +version = "1.0.0" +edition.workspace = true +license.workspace = true +publish = false +description = "Horizon's official recipe viewer: every item beside the inventory, its recipes and uses." + +[lib] +crate-type = ["cdylib"] + +[dependencies] +horizon-mod-sdk = { path = "../../../crates/horizon-mod-sdk" } + +[lints] +workspace = true diff --git a/mods/official/recipes/horizon-mod.toml b/mods/official/recipes/horizon-mod.toml new file mode 100644 index 000000000..f4c04af0d --- /dev/null +++ b/mods/official/recipes/horizon-mod.toml @@ -0,0 +1,9 @@ +id = "recipes" +name = "Recipes" +version = "1.0.0" +description = "Every item beside your inventory, with a search box. R over an item shows its recipes, U its uses (both rebindable in Controls), and + fills the crafting grid with a recipe you know. In creative mode a click can give you the item (Mod settings). On servers that are not Horizon, it shows this game's own 26.3 recipes; what you know and what + can fill follow the server's recipe book." +authors = ["Horizon"] +api = "0.1" +side = "client" +capabilities = ["recipes", "ui", "input", "game-read", "chat", "storage"] +experimental = ["recipes", "ui", "input"] diff --git a/mods/official/recipes/src/lib.rs b/mods/official/recipes/src/lib.rs new file mode 100644 index 000000000..42f856016 --- /dev/null +++ b/mods/official/recipes/src/lib.rs @@ -0,0 +1,364 @@ +//! Horizon's official recipe viewer. Every item sits in the item panel the +//! game draws beside the inventory and container screens (`browser`), with +//! a search box. R over an item, the panel's or any slot's, shows its +//! recipes, U its uses (`input.register-key`, so both can be rebound in +//! Controls); a click does the same, left for recipes and right for uses. +//! A recipe page has a tab per station, and + beside a crafting recipe the +//! player knows fills the grid as the recipe book does (`recipes.place`). +//! In creative mode, with "Click gives items" on, a click on a panel item +//! gives one, a right click a stack (`recipes.give`). +//! +//! On a server that is not Horizon the recipes are the game's own 26.3 +//! ones; `known` and `place` follow the server's recipe book. +use horizon_mod_sdk::{ + Mod, Registration, browser, chat, game, input, recipes, + recipes::Kind, + storage, + ui::{self, ButtonWidget, Widget}, +}; + +const RECIPE_KEY: &str = "recipe"; +const USES_KEY: &str = "uses"; +const GIVE_BUTTON: u32 = 1; +/// What `set-recipes` takes at most. +const MAX_RECIPES: usize = 256; +const MAX_STACKS: usize = 64; +/// The stations, in the order of their tabs, with each one's icon. +const STATIONS: [&str; 8] = [ + "minecraft:crafting_table", + "minecraft:furnace", + "minecraft:blast_furnace", + "minecraft:smoker", + "minecraft:campfire", + "minecraft:stonecutter", + "minecraft:smithing_table", + "minecraft:brewing_stand", +]; + +fn station(kind: Kind) -> usize { + match kind { + Kind::CraftingShaped | Kind::CraftingShapeless => 0, + Kind::Smelting => 1, + Kind::Blasting => 2, + Kind::Smoking => 3, + Kind::Campfire => 4, + Kind::Stonecutting => 5, + Kind::Smithing => 6, + Kind::Brewing => 7, + } +} + +fn stack(item: &str) -> browser::Stack { + browser::Stack { + item: item.into(), + count: 1, + components: String::new(), + } +} + +/// A recipe page: an item's recipes or its uses, on one station's tab. +#[derive(Clone)] +struct View { + item: browser::Stack, + uses: bool, + tab: usize, +} + +#[derive(Default)] +struct Recipes { + items: Vec, + all: Vec, + /// The panel's items now: indexes into `items`, after the search. + listed: Vec, + search: String, + /// The page shown, then the ones Back returns to. + history: Vec, + /// The book id behind each recipe the page shows (-1: none). + shown: Vec, + give: bool, +} + +impl Recipes { + fn id(&self, s: &recipes::Stack) -> &str { + self.items + .get(s.item as usize) + .map_or("minecraft:air", |i| &i.id) + } + fn convert(&self, s: &recipes::Stack) -> browser::Stack { + browser::Stack { + item: self.id(s).into(), + count: s.count, + components: s.components.clone(), + } + } + /// The same item, and the same components when `want` names some. + fn matches(&self, s: &recipes::Stack, want: &browser::Stack) -> bool { + self.id(s) == want.item && (want.components.is_empty() || s.components == want.components) + } + fn name<'a>(&'a self, item: &'a str) -> &'a str { + self.items + .iter() + .find(|i| i.id == item) + .map_or(item, |i| &i.name) + } + + /// Loads the tables once a world is open, and drops them when it closes. + fn load(&mut self) { + let in_world = game::get_player().is_some(); + if in_world && self.items.is_empty() { + self.items = recipes::items(); + self.all = recipes::all(); + self.list(); + } else if !in_world && !self.items.is_empty() { + browser::set_recipes("", &[], 0, &[]); + browser::set_items(&[]); + *self = Recipes { + give: self.give, + ..Recipes::default() + }; + } + } + + /// Fills the panel with the items the search keeps: every word must be + /// in the name or the id; `@minecraft` keeps a namespace, `#logs` a tag. + fn list(&mut self) { + let words: Vec = self + .search + .to_lowercase() + .split_whitespace() + .map(String::from) + .collect(); + let keeps = |item: &recipes::Item| { + words.iter().all(|w| { + if let Some(ns) = w.strip_prefix('@') { + item.id.split(':').next().is_some_and(|n| n.starts_with(ns)) + } else if let Some(tag) = w.strip_prefix('#') { + item.tags.iter().any(|t| t.contains(tag)) + } else { + item.name.to_lowercase().contains(w.as_str()) || item.id.contains(w.as_str()) + } + }) + }; + self.listed = (self.items.iter().enumerate()) + .filter(|(_, i)| i.id != "minecraft:air" && keeps(i)) + .map(|(n, _)| n) + .collect(); + let stacks: Vec<_> = self + .listed + .iter() + .map(|&n| stack(&self.items[n].id)) + .collect(); + browser::set_items(&stacks); + } + + /// The recipes a view lists, all stations together. + fn found(&self, view: &View) -> Vec<&recipes::Recipe> { + (self.all.iter()) + .filter(|r| { + if view.uses { + r.slots + .iter() + .flatten() + .any(|s| self.matches(s, &view.item)) + } else { + r.results.iter().any(|s| self.matches(s, &view.item)) + } + }) + .collect() + } + + /// Opens a page, pushing it on the history; nothing when it is empty. + fn open(&mut self, item: browser::Stack, uses: bool) { + let view = View { item, uses, tab: 0 }; + if self.found(&view).is_empty() { + return; + } + self.history.push(view); + self.show(); + } + + /// Sends the page on top of the history, or the items when there is none. + fn show(&mut self) { + let Some(mut view) = self.history.last().cloned() else { + self.shown.clear(); + browser::set_recipes("", &[], 0, &[]); + return; + }; + let found = self.found(&view); + let stations: Vec = (0..STATIONS.len()) + .filter(|&s| found.iter().any(|r| station(r.kind) == s)) + .collect(); + view.tab = view.tab.min(stations.len().saturating_sub(1)); + let on: Vec<&recipes::Recipe> = (found.iter().copied()) + .filter(|r| stations.get(view.tab) == Some(&station(r.kind))) + .take(MAX_RECIPES) + .collect(); + let known = recipes::known(); + let views: Vec = on.iter().map(|r| self.view(r, &known)).collect(); + let mut title = format!( + "{}: {}", + if view.uses { "Uses" } else { "Recipes" }, + self.name(&view.item.item) + ); + let total = found + .iter() + .filter(|r| stations.get(view.tab) == Some(&station(r.kind))) + .count(); + if total > on.len() { + title.push_str(&format!(" ({} of {total})", on.len())); + } + let tabs: Vec<_> = stations.iter().map(|&s| stack(STATIONS[s])).collect(); + browser::set_recipes(&title, &tabs, view.tab as u32, &views); + self.shown = on.iter().map(|r| r.book_id).collect(); + if let Some(top) = self.history.last_mut() { + top.tab = view.tab; + } + } + + fn view(&self, r: &recipes::Recipe, known: &[i32]) -> browser::RecipeView { + let mut slots: Vec> = (r.slots.iter()) + .map(|s| s.iter().take(MAX_STACKS).map(|s| self.convert(s)).collect()) + .collect(); + let results = r + .results + .iter() + .take(MAX_STACKS) + .map(|s| self.convert(s)) + .collect(); + let (layout, width, height, note) = match r.kind { + Kind::CraftingShaped => (browser::Layout::Grid, r.width, r.height, String::new()), + Kind::CraftingShapeless => { + let n = slots.len() as u32; + let width = match n { + 0 | 1 => 1, + 2..=4 => 2, + _ => 3, + }; + let height = n.div_ceil(width).max(1); + slots.resize((width * height) as usize, Vec::new()); + (browser::Layout::Grid, width, height, "Shapeless".into()) + } + Kind::Smelting | Kind::Blasting | Kind::Smoking | Kind::Campfire => { + let seconds = r.cooking_time as f32 / 20.0; + let note = format!("{seconds} s, {} XP", (r.experience * 100.0).round() / 100.0); + (browser::Layout::Cooking, 1, 1, note) + } + Kind::Stonecutting => (browser::Layout::Single, 1, 1, String::new()), + Kind::Smithing => (browser::Layout::Smithing, 3, 1, String::new()), + Kind::Brewing => (browser::Layout::Brewing, 2, 1, String::new()), + }; + // + only for what the recipe book shows; greyed until the book has it. + let action = (r.book_id >= 0).then(|| known.contains(&r.book_id)); + browser::RecipeView { + layout, + width, + height, + slots, + results, + note, + action, + } + } + + fn handle(&mut self, event: browser::Event) { + match event { + browser::Event::Search(text) => { + self.search = text; + self.list(); + } + browser::Event::Clicked(c) => { + let Some(&n) = self.listed.get(c.index as usize) else { + return; + }; + let item = self.items[n].id.clone(); + if self.give { + let count = if c.right { 99 } else { 1 }; + let gift = recipes::Stack { + item: n as u32, + count, + components: String::new(), + }; + if recipes::give(&gift).is_ok() { + return; + } + } + self.open(stack(&item), c.right); + } + browser::Event::Key(k) if k.key == RECIPE_KEY || k.key == USES_KEY => { + let item = browser::Stack { + count: 1, + ..k.stack + }; + self.open(item, k.key == USES_KEY); + } + browser::Event::SlotClicked(c) => { + let item = browser::Stack { + count: 1, + ..c.stack + }; + self.open(item, c.right); + } + browser::Event::Tab(i) => { + if let Some(top) = self.history.last_mut() { + top.tab = i as usize; + } + self.show(); + } + browser::Event::Action(i) => { + let book = self.shown.get(i as usize).copied(); + if let Some(Err(e)) = book.map(|b| recipes::place(b, false)) { + chat::show(&e); + } + } + browser::Event::Back => { + self.history.pop(); + self.show(); + } + _ => {} + } + } + + fn page(&self) { + ui::set_settings(&[Widget::Button(ButtonWidget { + id: GIVE_BUTTON, + label: format!( + "Click gives items (creative): {}", + if self.give { "ON" } else { "OFF" } + ), + })]); + } +} + +impl Mod for Recipes { + fn init() -> Result<(Self, Registration), String> { + input::register_key(RECIPE_KEY, "Show recipes", "key.keyboard.r")?; + input::register_key(USES_KEY, "Show uses", "key.keyboard.u")?; + let give = storage::get("give").is_some_and(|v| v == b"true"); + let me = Recipes { + give, + ..Recipes::default() + }; + me.page(); + Ok((me, Registration::new().on_frame())) + } + fn frame(&mut self, _seconds: f32) { + self.load(); + // The keys matter only over an item, which `browser` reports. + let _ = input::poll(); + for event in browser::poll() { + self.handle(event); + } + } + fn ui_select(&mut self, id: u32, _row: u32) { + if id == GIVE_BUTTON { + self.give = !self.give; + let _ = storage::set("give", if self.give { b"true" } else { b"false" }); + self.page(); + } + } + fn ui_settings_opened(&mut self) { + self.page(); + } +} + +horizon_mod_sdk::export_mod!(Recipes);