diff --git a/crates/horizon-client/src/game/advancements.rs b/crates/horizon-client/src/game/advancements.rs index 02638f64f..4c5c0fbbe 100644 --- a/crates/horizon-client/src/game/advancements.rs +++ b/crates/horizon-client/src/game/advancements.rs @@ -19,27 +19,99 @@ pub(super) struct Toast { icon: String, frame: Frame, title: Text, - shown: Option, - /// A `RecipeToast`: the icon is a recipe result. - recipe: bool, + slide: Slide, + /// A `RecipeToast`: the crafting station and result of each display + /// unlocked while it lasts (`recipeItems`); empty for an advancement. + recipes: Vec<(String, ItemStack)>, + /// `RecipeToast.changed` and `lastChanged`. + changed: bool, + last_changed: i64, } impl Toast { - pub(super) fn is_recipe(&self) -> bool { - self.recipe - } - pub(super) fn was_shown(&self) -> bool { - self.shown.is_some() - } - /// `RecipeToast`: "New Recipe(s) Unlocked!" with the recipe's result. - pub(super) fn recipe(icon: &str) -> Self { + /// `RecipeToast.addOrUpdate` on a new toast. + pub(super) fn recipe(items: Vec<(String, ItemStack)>) -> Self { Self { - icon: icon.to_owned(), + icon: String::new(), frame: Frame::Task, title: Text::literal(""), - shown: None, - recipe: true, + slide: Slide::default(), + recipes: items, + changed: true, + last_changed: 0, } } + pub(super) fn is_recipe(&self) -> bool { + !self.recipes.is_empty() + } + /// `RecipeToast.addItem`: more displays on a toast still queued or shown. + pub(super) fn add_recipes(&mut self, items: Vec<(String, ItemStack)>) { + self.recipes.extend(items); + self.changed = true; + } + /// `Toast.update` with `fullyVisibleForMs`: whether it wants to be shown. + fn wants_show(&mut self, fully_for: i64, multiplier: f64) -> bool { + let time = 5000.0 * multiplier; + if self.recipes.is_empty() { + // AdvancementToast. + return (fully_for as f64) < time; + } + if self.changed { + self.last_changed = fully_for; + self.changed = false; + } + ((fully_for - self.last_changed) as f64) < time + } + /// `RecipeToast.displayedRecipeIndex`: the displays take turns over the + /// toast's display time. + fn displayed_recipe(&self, fully_for: i64, multiplier: f64) -> usize { + let n = self.recipes.len() as f64; + (fully_for as f64 / (5000.0 * multiplier / n).max(1.0) % n) as usize + } +} +/// `ToastManager.ToastInstance`: slides a toast in and out over 600 ms, +/// eased by the square, and counts how long it has been fully shown. +#[derive(Default)] +struct Slide { + /// When it first updated; the times below are milliseconds since. + origin: Option, + begun: bool, + /// `animationStartTime`. + start: i64, + /// `becameFullyVisibleAt`. + fully_at: i64, + show: bool, + /// `visiblePortion`: 0 off screen, 1 fully in. + portion: f32, + /// `fullyVisibleFor`. + fully_for: i64, +} +impl Slide { + const MS: i64 = 600; + /// `ToastInstance.update` at `now`; `wants_show` is the toast's own + /// update. The visibility it switched to (the sound to play), and whether + /// it has finished sliding out. + fn update(&mut self, now: i64, wants_show: impl FnOnce(i64) -> bool) -> (Option, bool) { + let was = self.show; + if !self.begun { + self.begun = true; + self.start = now; + self.show = true; + } + if self.show && now - self.start <= Self::MS { + self.fully_at = now; + } + self.fully_for = now - self.fully_at; + let progress = ((now - self.start) as f32 / Self::MS as f32).clamp(0.0, 1.0); + let progress = progress * progress; + self.portion = if self.show { progress } else { 1.0 - progress }; + let wanted = wants_show(self.fully_for); + if wanted != self.show { + self.start = now - ((1.0 - self.portion) * Self::MS as f32) as i64; + self.show = wanted; + } + let finished = !self.show && now - self.start > Self::MS; + ((self.show != was).then_some(self.show), finished) + } } #[derive(Default)] pub(super) struct AdvState { @@ -430,8 +502,10 @@ impl Game<'_> { icon: d.icon.clone(), frame: d.frame, title: text_of(&d.title), - shown: None, - recipe: false, + slide: Slide::default(), + recipes: Vec::new(), + changed: false, + last_changed: 0, }); } if d.announce && self.ui.rules.bool("show_advancement_messages") { @@ -679,45 +753,57 @@ impl Game<'_> { c["from"].as_str().is_none_or(|f| f == from) && c["to"].as_str().is_none_or(|t| t == to) }); } - /// `ToastManager` with the `AdvancementToast`. + /// `ToastManager` with the `AdvancementToast` and the `RecipeToast`, + /// one at a time. pub(super) fn draw_toasts(&mut self, batch: &mut HudBatch) { + let multiplier = f64::from(self.settings.notification_display_time); let Some(t) = self.adv.toasts.front_mut() else { return; }; - let shown = *t.shown.get_or_insert_with(Instant::now); - let ms = shown.elapsed().as_millis() as f32; - // AdvancementToast.DISPLAY_TIME: 5 s, sliding 600 ms in and out. - if ms > 5600.0 { + let first = t.slide.origin.is_none(); + let origin = *t.slide.origin.get_or_insert_with(Instant::now); + let now = origin.elapsed().as_millis() as i64; + let mut slide = std::mem::take(&mut t.slide); + let (sound, finished) = slide.update(now, |fully| t.wants_show(fully, multiplier)); + t.slide = slide; + if finished { self.adv.toasts.pop_front(); return; } - let slide = if ms < 600.0 { - ms / 600.0 - } else if ms > 5000.0 { - 1.0 - (ms - 5000.0) / 600.0 - } else { - 1.0 - }; - let (title, frame, icon, recipe) = (t.title.clone(), t.frame, t.icon.clone(), t.recipe); - if recipe { - // RecipeToast: black description under a purple title. + let x = batch.width - 160.0 * t.slide.portion; + let fully_for = t.slide.fully_for; + let (title, frame, icon) = (t.title.clone(), t.frame, t.icon.clone()); + let recipe = t + .is_recipe() + .then(|| t.recipes[t.displayed_recipe(fully_for, multiplier)].clone()); + // ToastManager.update: the sound of the new visibility, and a + // challenge's own sound as it leaves the queue. + if let Some(show) = sound { + let event = if show { "ui.toast.in" } else { "ui.toast.out" }; + self.audio + .play(&format!("minecraft:{event}"), None, 1.0, 1.0); + } + if first && recipe.is_none() && frame == Frame::Challenge { + self.audio + .play("minecraft:ui.toast.challenge_complete", None, 1.0, 1.0); + } + if let Some((station, item)) = recipe { + // RecipeToast: black description under a purple title, the + // station at 0.6 scale in the corner over the cycling result. let atlas = &self.res.atlas; - let x = batch.width - 160.0 * slide; batch.sprite(atlas, "gui/sprites/toast/recipe", x, 0.0); let title = self.translate("recipe.toast.title", "New Recipe(s) Unlocked!"); let description = self.translate("recipe.toast.description", "Check your recipe book"); let atlas = &self.res.atlas; batch.text(atlas, &title, x + 30.0, 7.0, 0xFF50_0050, false); batch.text(atlas, &description, x + 30.0, 18.0, 0xFF00_0000, false); - self.draw_item(batch, &ItemStack::new(&icon, 1), x + 8.0, 8.0); + let start = batch.vertices.len(); + self.draw_item_model(batch, &ItemStack::new(&station, 1), x + 3.0, 3.0); + batch.scale_since(start, x, 0.0, 0.6, 0.6); + self.draw_item_model(batch, &item, x + 8.0, 8.0); return; } - if frame == Frame::Challenge && ms < 50.0 { - self.audio - .play("minecraft:ui.toast.challenge_complete", None, 1.0, 1.0); - } let atlas = &self.res.atlas; - let x = batch.width - 160.0 * slide; batch.sprite(atlas, "gui/sprites/toast/advancement", x, 0.0); let (key, color) = match frame { Frame::Task => ("advancements.toast.task", 0xFF00_FFFF), @@ -813,3 +899,94 @@ pub(super) fn text_of(v: &Value) -> Text { Text::empty() } } + +#[cfg(test)] +mod tests { + use super::*; + + fn recipes(n: usize) -> Toast { + Toast::recipe( + (0..n) + .map(|i| { + let item = ItemStack::new(&format!("minecraft:item_{i}"), 1); + ("minecraft:crafting_table".to_owned(), item) + }) + .collect(), + ) + } + /// Drives a toast frame by frame (every `step` ms) and returns the slide + /// portions at the given times and when it finished. + fn run(toast: &mut Toast, step: i64, until: i64, at: &[i64]) -> (Vec, Option) { + let mut slide = Slide::default(); + let mut seen = Vec::new(); + for now in (0..=until).step_by(step as usize) { + let (_, finished) = slide.update(now, |f| toast.wants_show(f, 1.0)); + if finished { + return (seen, Some(now)); + } + if at.contains(&now) { + seen.push(slide.portion); + } + } + (seen, None) + } + + #[test] + fn toasts_slide_in_squared_and_out_after_five_seconds() { + let mut toast = recipes(1); + let (portions, finished) = run(&mut toast, 10, 10_000, &[0, 300, 600, 3000]); + // (300 / 600)² = 0.25: ToastInstance.calculateVisiblePortion. + assert_eq!(portions, [0.0, 0.25, 1.0, 1.0]); + // Fully in at 600, shown 5000 ms, out over 600 more. + assert!( + finished.is_some_and(|t| (6200..=6220).contains(&t)), + "{finished:?}" + ); + } + + #[test] + fn the_first_update_plays_the_show_sound_and_the_hide_sound_follows() { + let mut toast = recipes(1); + let mut slide = Slide::default(); + assert_eq!(slide.update(0, |f| toast.wants_show(f, 1.0)).0, Some(true)); + assert_eq!(slide.update(100, |f| toast.wants_show(f, 1.0)).0, None); + assert_eq!( + slide.update(5600, |f| toast.wants_show(f, 1.0)).0, + Some(false) + ); + } + + #[test] + fn recipe_toasts_cycle_through_their_displays_over_the_display_time() { + let toast = recipes(4); + let shown: Vec = [0, 1249, 1250, 2500, 3750, 4999, 5000] + .iter() + .map(|&t| toast.displayed_recipe(t, 1.0)) + .collect(); + assert_eq!(shown, [0, 0, 1, 2, 3, 3, 0]); + // notificationDisplayTime doubles each turn. + assert_eq!(toast.displayed_recipe(2500, 2.0), 1); + } + + #[test] + fn unlocking_more_recipes_keeps_the_toast_up_five_more_seconds() { + let mut toast = recipes(1); + let mut slide = Slide::default(); + let mut finished = None; + for now in (0..=20_000).step_by(10) { + if now == 4000 { + toast.add_recipes(recipes(1).recipes); + } + if slide.update(now, |f| toast.wants_show(f, 1.0)).1 { + finished = Some(now); + break; + } + } + assert_eq!(toast.recipes.len(), 2); + // lastChanged moved to 3400 ms fully shown: hidden at 8400 + 600. + assert!( + finished.is_some_and(|t| (9600..=9620).contains(&t)), + "{finished:?}" + ); + } +} diff --git a/crates/horizon-client/src/game/recipe_book.rs b/crates/horizon-client/src/game/recipe_book.rs index 67e79eb6a..ef4caa988 100644 --- a/crates/horizon-client/src/game/recipe_book.rs +++ b/crates/horizon-client/src/game/recipe_book.rs @@ -197,28 +197,59 @@ impl Game<'_> { search.reset_blink(); } - /// The toast for newly unlocked recipes: one for a burst of unlocks. + /// `RecipeToast.addOrUpdate` for each display of the recipes just + /// unlocked: its crafting station and result join the toast still + /// queued or shown, or a new one. pub(super) fn recipe_toast(&mut self, recipes: &[String]) { if recipes.is_empty() || self.adv.quiet { return; } self.ensure_book(); - let icon = self - .recipe_ui - .book - .as_ref() - .and_then(|b| recipes.iter().find_map(|id| b.entry(id))) - .map(|e| e.result.item.to_string()); - let Some(icon) = icon else { return }; - let fresh = self - .adv - .toasts - .back() - .is_some_and(|t| t.is_recipe() && !t.was_shown()); - if !fresh { - self.adv + let index = &self.res.stations.recipe_index; + let book = self.recipe_ui.book.as_ref(); + // SmithingTrimDemoSlotDisplay draws from a random of its own. + let mut random = super::dispenser::entity_random(); + let mut items = Vec::new(); + for id in recipes { + let Some(station) = index.toast_station(id) else { + continue; + }; + for display in index.display_ids(id) { + // The book's displays carry their resolved results; the + // other recipe types name theirs, and trims are demos. + let result = book + .and_then(|b| { + b.entry_of_display(display) + .map(|i| b.entries[i].result.clone()) + }) + .or_else(|| index.result(id).map(|r| ItemStack::new(r, 1))) + .or_else(|| { + self.res.stations.recipes.trim_demo( + &self.res.stations.enchantments, + id, + &mut |n| { + horizon_core::random::RandomSource::next_int_bound( + &mut random, + n as i32, + ) + .unwrap_or(0) as usize + }, + ) + }); + if let Some(result) = result { + items.push((station.to_owned(), result)); + } + } + } + if items.is_empty() { + return; + } + match self.adv.toasts.iter_mut().find(|t| t.is_recipe()) { + Some(toast) => toast.add_recipes(items), + None => self + .adv .toasts - .push_back(super::advancements::Toast::recipe(&icon)); + .push_back(super::advancements::Toast::recipe(items)), } } diff --git a/crates/horizon-client/src/recipe_book.rs b/crates/horizon-client/src/recipe_book.rs index 6de6416c2..2caa68cac 100644 --- a/crates/horizon-client/src/recipe_book.rs +++ b/crates/horizon-client/src/recipe_book.rs @@ -646,8 +646,31 @@ impl ClientBook { /// displays it has (`RecipeManager.listDisplaysForRecipe`). #[derive(Clone, Debug, Default)] pub struct RecipeIndex { - /// Recipe id -> (special, display count, first display id). - recipes: std::collections::BTreeMap, + recipes: std::collections::BTreeMap, +} +#[derive(Clone, Debug)] +struct Known { + special: bool, + displays: usize, + first_display: i32, + /// `RecipeDisplay.craftingStation`: the workstation item of its displays. + station: &'static str, + /// `Recipe.showNotification`: unlocking it shows the `RecipeToast`. + notify: bool, + /// `result.id`, for the recipes the book doesn't list. + result: Option, +} +/// `RecipeDisplay.craftingStation` of a recipe type. +fn crafting_station(kind: &str) -> &'static str { + match kind { + "minecraft:smelting" => "minecraft:furnace", + "minecraft:blasting" => "minecraft:blast_furnace", + "minecraft:smoking" => "minecraft:smoker", + "minecraft:campfire_cooking" => "minecraft:campfire", + "minecraft:stonecutting" => "minecraft:stonecutter", + "minecraft:smithing_transform" | "minecraft:smithing_trim" => "minecraft:smithing_table", + _ => "minecraft:crafting_table", + } } impl RecipeIndex { /// Reads `data/minecraft/recipe/*.json` under `root`. @@ -685,13 +708,23 @@ impl RecipeIndex { } else { 1 }; - recipes.insert(format!("minecraft:{stem}"), (special, displays, 0)); + recipes.insert( + format!("minecraft:{stem}"), + Known { + special, + displays, + first_display: 0, + station: crafting_station(kind), + notify: v["show_notification"].as_bool().unwrap_or(true), + result: v["result"]["id"].as_str().map(str::to_owned), + }, + ); } // RecipeManager keeps its recipes sorted by id and numbers the displays in that order. let mut next = 0; for r in recipes.values_mut() { - r.2 = next; - next += r.1 as i32; + r.first_display = next; + next += r.displays as i32; } Self { recipes } } @@ -699,10 +732,19 @@ impl RecipeIndex { self.recipes.contains_key(id) } pub fn special(&self, id: &str) -> bool { - self.recipes.get(id).is_some_and(|r| r.0) + self.recipes.get(id).is_some_and(|r| r.special) } pub fn displays(&self, id: &str) -> usize { - self.recipes.get(id).map_or(0, |r| r.1) + self.recipes.get(id).map_or(0, |r| r.displays) + } + /// The crafting station shown on its displays' toast, when unlocking it + /// shows one (`Recipe.showNotification`). + pub fn toast_station(&self, id: &str) -> Option<&'static str> { + self.recipes.get(id).filter(|r| r.notify).map(|r| r.station) + } + /// The result item id its file names (none for trims). + pub fn result(&self, id: &str) -> Option<&str> { + self.recipes.get(id).and_then(|r| r.result.as_deref()) } /// Every recipe id, in id order. pub fn ids(&self) -> impl Iterator { @@ -710,10 +752,15 @@ impl RecipeIndex { } /// The display ids of a recipe (none for a special one). pub fn display_ids(&self, id: &str) -> std::ops::Range { - self.recipes.get(id).map_or(0..0, |r| r.2..r.2 + r.1 as i32) + self.recipes.get(id).map_or(0..0, |r| { + r.first_display..r.first_display + r.displays as i32 + }) } pub fn first_display(&self, id: &str) -> Option { - self.recipes.get(id).filter(|r| r.1 > 0).map(|r| r.2) + self.recipes + .get(id) + .filter(|r| r.displays > 0) + .map(|r| r.first_display) } } @@ -836,6 +883,57 @@ mod tests { Ingredient::of(items.iter().map(|s| (*s).to_owned()).collect()) } #[test] + fn the_index_knows_each_recipes_toast_station_and_result() { + let root = std::env::temp_dir().join(format!("horizon-toast-index-{}", std::process::id())); + let dir = root.join("data/minecraft/recipe"); + std::fs::create_dir_all(&dir).unwrap(); + for (name, json) in [ + ( + "stick", + r#"{"type":"minecraft:crafting_shaped","result":{"id":"minecraft:stick"}}"#, + ), + ( + "crafting_table", + r#"{"type":"minecraft:crafting_shaped","show_notification":false,"result":{"id":"minecraft:crafting_table"}}"#, + ), + ( + "cooked_beef_from_campfire_cooking", + r#"{"type":"minecraft:campfire_cooking","result":{"id":"minecraft:cooked_beef"}}"#, + ), + ( + "stone_slab_from_stonecutting", + r#"{"type":"minecraft:stonecutting","result":{"id":"minecraft:stone_slab"}}"#, + ), + ( + "coast_trim", + r#"{"type":"minecraft:smithing_trim","pattern":"minecraft:coast"}"#, + ), + ] { + std::fs::write(dir.join(format!("{name}.json")), json).unwrap(); + } + let index = RecipeIndex::load(&root); + std::fs::remove_dir_all(&root).unwrap(); + let toast = |id: &str| (index.toast_station(id), index.result(id)); + assert_eq!( + toast("minecraft:stick"), + (Some("minecraft:crafting_table"), Some("minecraft:stick")) + ); + // show_notification: false unlocks silently. + assert_eq!(toast("minecraft:crafting_table").0, None); + assert_eq!( + toast("minecraft:cooked_beef_from_campfire_cooking"), + (Some("minecraft:campfire"), Some("minecraft:cooked_beef")) + ); + assert_eq!( + toast("minecraft:stone_slab_from_stonecutting").0, + Some("minecraft:stonecutter") + ); + assert_eq!( + toast("minecraft:coast_trim"), + (Some("minecraft:smithing_table"), None) + ); + } + #[test] fn small_recipes_are_centred_in_the_grid() { // One ingredient in a 3x3 grid goes to the middle cell. assert_eq!(place_cells(3, 3, 1, 1, &['a']), vec![('a', 4)]); diff --git a/crates/horizon-client/src/stations.rs b/crates/horizon-client/src/stations.rs index d1582a6b8..35b02c12e 100644 --- a/crates/horizon-client/src/stations.rs +++ b/crates/horizon-client/src/stations.rs @@ -437,6 +437,7 @@ pub enum Smithing { result: String, }, Trim { + id: String, template: Ingredient, base: Ingredient, addition: Ingredient, @@ -510,6 +511,7 @@ impl StationRecipes { .to_owned(), }), "minecraft:smithing_trim" => smithing.push(Smithing::Trim { + id, template: ingredient(&v["template"], items), base: ingredient(&v["base"], items), addition: ingredient(&v["addition"], items), @@ -614,25 +616,64 @@ impl StationRecipes { base: b, addition: a, pattern, + .. } => { if t.test(template) && b.test(base) && a.test(addition) { - let material = e.props(&addition.item)?.trim_material.clone()?; - let trim = (Arc::from(material.as_str()), Arc::from(pattern.as_str())); - if base.data().and_then(|d| d.trim.as_ref()) == Some(&trim) { - return None; - } - let mut out = ItemStack { - count: 1, - ..base.clone() - }; - out.data_mut().trim = Some(trim); - return Some(out); + return apply_trim(e, base, addition, pattern); } } } } None } + /// `SmithingTrimDemoSlotDisplay.resolveForFirstStack` of a trim recipe: + /// a random base trimmed with a random material (`pick(n)` draws below n). + pub fn trim_demo( + &self, + e: &Enchantments, + id: &str, + pick: &mut dyn FnMut(usize) -> usize, + ) -> Option { + let (base, addition, pattern) = self.smithing.iter().find_map(|r| match r { + Smithing::Trim { + id: i, + base, + addition, + pattern, + .. + } if i == id => Some((&base.1, &addition.1, pattern)), + _ => None, + })?; + if base.is_empty() || addition.is_empty() { + return None; + } + // applyDemoTransformation: up to 256 draws, the first that isn't empty. + (0..256).find_map(|_| { + let base = ItemStack::new(&base[pick(base.len())], 1); + let material = ItemStack::new(&addition[pick(addition.len())], 1); + apply_trim(e, &base, &material, pattern) + }) + } +} +/// `SmithingTrimRecipe.applyTrim`: none when the material provides no trim +/// or the base already has this one. +fn apply_trim( + e: &Enchantments, + base: &ItemStack, + material: &ItemStack, + pattern: &str, +) -> Option { + let material = e.props(&material.item)?.trim_material.clone()?; + let trim = (Arc::from(material.as_str()), Arc::from(pattern)); + if base.data().and_then(|d| d.trim.as_ref()) == Some(&trim) { + return None; + } + let mut out = ItemStack { + count: 1, + ..base.clone() + }; + out.data_mut().trim = Some(trim); + Some(out) } #[cfg(test)]