//! Item tooltip formatting: equipment modifiers with a player's base values, //! and lines without player context for the recipe book's search tree. use crate::{ hud::rgba, items::{ItemInfo, ItemStack}, }; use horizon_world::nbt::Tag; /// The `minecraft:tooltip_display` component applied by `ItemStack` while it /// builds a hover tooltip. pub struct TooltipDisplay<'a> { component: Option<&'a Tag>, ominous_banner: bool, } impl<'a> TooltipDisplay<'a> { pub fn for_stack(stack: &'a ItemStack) -> Self { Self { component: stack .data() .and_then(|data| data.other("minecraft:tooltip_display")), ominous_banner: stack.data().is_some_and(|data| data.ominous_banner), } } fn hides_tooltip(&self) -> bool { matches!( self.component.and_then(|display| display.get("hide_tooltip")), Some(Tag::Byte(value)) if *value != 0 ) } /// `ItemStack.getTooltipLines`: `hide_tooltip` suppresses the name unless /// the tooltip flag is creative. pub fn name_visible(&self, creative: bool) -> bool { creative || !self.hides_tooltip() } /// `TooltipDisplay.shows`: whether details for a data component are shown. pub fn shows(&self, component: &str) -> bool { if self.hides_tooltip() { return false; } // `item_data::decode_components` models the raid captain banner's // default hidden pattern tooltip as `ominous_banner` instead of // retaining its redundant `tooltip_display` component. if self.ominous_banner && self.component.is_none() && component == "minecraft:banner_patterns" { return false; } let Some(Tag::List(hidden)) = self .component .and_then(|display| display.get("hidden_components")) else { return true; }; !hidden.iter().any(|tag| { matches!(tag, Tag::String(id) if id.0.iter().copied().eq(component.encode_utf16())) }) } } /// `EquipmentSlotGroup` in declaration order, the order tooltips list them in. const SLOT_GROUPS: [&str; 11] = [ "any", "mainhand", "offhand", "hand", "feet", "legs", "chest", "head", "armor", "body", "saddle", ]; /// `ItemAttributeModifiers.ATTRIBUTE_MODIFIER_FORMAT`, `DecimalFormat("#.##")` /// of a positive amount (half-even on the exact value). fn format_amount(value: f64) -> String { let text = format!("{:.2}", value); text.trim_end_matches('0').trim_end_matches('.').to_owned() } /// `ItemAttributeModifiers.Display.Default.apply`: a modifier's line, none /// for a zero amount. `percent` is the modifier's operation id (0: added /// value, 1 and 2: multiplied). fn modifier_line( translate: &dyn Fn(&str) -> Option, attribute: &str, amount: f64, operation: usize, total: bool, ) -> Option { let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); let scale = match operation { 0 if attribute == "knockback_resistance" => 10.0, 0 => 1.0, _ => 100.0, }; let (kind, shown) = if total { ("equals", amount * scale) } else if amount > 0.0 { ("plus", amount * scale) } else if amount < 0.0 { ("take", -amount * scale) } else { return None; }; Some( text(&format!("attribute.modifier.{kind}.{operation}")) .replacen("%s", &format_amount(shown), 1) .replacen("%s", &text(&format!("attribute.name.{attribute}")), 1) .replace("%%", "%"), ) } /// `Attribute.getStyle`: the colour of a line for an attribute whose value /// rises or falls. Gravity, scale and the waypoint ranges are neutral, burning /// time and fall damage are negative, every other attribute is positive. fn attribute_color(attribute: &str, rises: bool) -> u32 { let (blue, red) = (rgba(85, 85, 255, 255), rgba(255, 85, 85, 255)); match attribute { "burning_time" | "fall_damage_multiplier" => { if rises { red } else { blue } } "gravity" | "scale" | "waypoint_transmit_range" | "waypoint_receive_range" => { rgba(170, 170, 170, 255) } _ => { if rises { blue } else { red } } } } /// `ItemStack.addAttributeTooltips`: slot groups, colors and optional player /// attack damage/speed bases. Recipe search has no player context. pub fn attribute_lines( modifiers: &[(String, String, f64, String, String)], player_base: Option<[f64; 2]>, translate: &dyn Fn(&str) -> Option, ) -> Vec<(String, u32)> { let mut lines = Vec::new(); for group in SLOT_GROUPS { let mut first = true; for (attribute, modifier, amount, operation, slot) in modifiers { if slot != group { continue; } if std::mem::take(&mut first) { lines.push((String::new(), u32::MAX)); lines.push(( translate(&format!("item.modifiers.{group}")) .unwrap_or_else(|| format!("item.modifiers.{group}")), rgba(170, 170, 170, 255), )); } let id = match operation.as_str() { "add_multiplied_base" => 1, "add_multiplied_total" => 2, _ => 0, }; let path = attribute.strip_prefix("minecraft:").unwrap_or(attribute); let base = player_base.and_then(|[damage, speed]| match modifier.as_str() { "minecraft:base_attack_damage" => Some(damage), "minecraft:base_attack_speed" => Some(speed), _ => None, }); if let Some(line) = modifier_line( translate, path, amount + base.unwrap_or(0.0), id, base.is_some(), ) { let (line, color) = if base.is_some() { (format!(" {line}"), rgba(0, 170, 0, 255)) } else { (line, attribute_color(path, *amount > 0.0)) }; lines.push((line, color)); } } } lines } /// The attribute modifiers a mob effect adds per amplifier level /// (`MobEffects`): attribute, amount, operation id. fn effect_modifier(effect: &str) -> Option<(&'static str, f64, usize)> { Some(match effect { "speed" => ("movement_speed", 0.2, 2), "slowness" => ("movement_speed", -0.15, 2), "strength" => ("attack_damage", 3.0, 0), "weakness" => ("attack_damage", -4.0, 0), "jump_boost" => ("safe_fall_distance", 1.0, 0), "luck" => ("luck", 1.0, 0), "invisibility" => ("waypoint_transmit_range", -1.0, 2), _ => return None, }) } fn is_potion_item(item: &str) -> bool { item.ends_with("potion") || item == "minecraft:tipped_arrow" } /// The name line of `stack`, as the item's translation or, for potions and /// smithing templates, its name component gives it. pub fn name_line(stack: &ItemStack, translate: &dyn Fn(&str) -> Option) -> String { let path = stack.item.trim_start_matches("minecraft:"); if let Some(name) = stack.custom_name() { return name.to_owned(); } if let Some(name) = stack.item_name() { return name; } if stack.data().is_some_and(|d| d.ominous_banner) { return translate("block.minecraft.ominous_banner") .unwrap_or_else(|| "Ominous Banner".to_owned()); } let key = if is_potion_item(&stack.item) { Some(crate::brewing::potion_name_key(&stack.item, stack.potion())) } else if let Some(pattern) = path.strip_suffix("_armor_trim_smithing_template") { Some(format!("trim_pattern.minecraft.{pattern}")) } else if path == "netherite_upgrade_smithing_template" { Some("upgrade.minecraft.netherite_upgrade".to_owned()) } else if path.ends_with("_banner_pattern") { // The item name component of the pattern items that have one. Some(format!("item.minecraft.{path}.new")) } else { None }; key.and_then(|k| translate(&k)) .or_else(|| translate(&format!("item.minecraft.{path}"))) .or_else(|| translate(&format!("block.minecraft.{path}"))) .unwrap_or_else(|| path.replace('_', " ")) } /// ItemStack.getRarity: the ominous banner override, then the enchantment upgrade. pub fn rarity<'a>(stack: &ItemStack, default: &'a str) -> &'a str { let rarity = if stack.data().is_some_and(|d| d.ominous_banner) { "uncommon" } else { default }; if stack.enchantments().is_empty() { rarity } else { match rarity { "common" | "uncommon" => "rare", "rare" => "epic", r => r, } } } fn is_beehive(path: &str) -> bool { matches!(path, "beehive" | "bee_nest") } /// `InstrumentComponent.addToTooltip`: the instrument's description. A goat /// horn without the component has the item's default, the ponder horn. pub fn instrument_line( stack: &ItemStack, display: &TooltipDisplay, translate: &dyn Fn(&str) -> Option, ) -> Option { if !display.shows("minecraft:instrument") { return None; } let id = match stack.data().and_then(|d| d.other("minecraft:instrument")) { Some(Tag::String(id)) => id.to_string_lossy(), // An inline instrument carries its own description. Some(inline) => { return inline .get("description") .map(|d| crate::entity_nbt::name_text(d).plain()); } None if &*stack.item == "minecraft:goat_horn" => "minecraft:ponder_goat_horn".to_owned(), None => return None, }; let key = format!("instrument.{}", id.replacen(':', ".", 1)); Some(translate(&key).unwrap_or(key)) } /// `Bees.addToTooltip`: how many bees a hive item holds (a hive item without /// the component has the item's default, none). pub fn bees_line( stack: &ItemStack, display: &TooltipDisplay, translate: &dyn Fn(&str) -> Option, ) -> Option { if !display.shows("minecraft:bees") { return None; } let bees = match stack.data().and_then(|d| d.other("minecraft:bees")) { Some(Tag::List(bees)) => bees.len(), Some(_) => return None, None if is_beehive(stack.item.trim_start_matches("minecraft:")) => 0, None => return None, }; let text = translate("container.beehive.bees").unwrap_or_else(|| "container.beehive.bees".into()); Some( text.replacen("%s", &bees.to_string(), 1) .replacen("%s", "3", 1), ) } /// `BlockItemStateProperties.addToTooltip`: a hive item's honey level (a hive /// item without the component has the item's default, 0). pub fn honey_line( stack: &ItemStack, display: &TooltipDisplay, translate: &dyn Fn(&str) -> Option, ) -> Option { if !display.shows("minecraft:block_state") { return None; } let level = match stack.data().and_then(|d| d.other("minecraft:block_state")) { Some(Tag::Compound(state)) => { match state.get(&horizon_world::nbt::JavaString::from("honey_level")) { Some(Tag::String(level)) => level.to_string_lossy().parse::().ok()?, _ => return None, } } Some(_) => return None, None if is_beehive(stack.item.trim_start_matches("minecraft:")) => 0, None => return None, }; let text = translate("container.beehive.honey").unwrap_or_else(|| "container.beehive.honey".into()); Some( text.replacen("%s", &level.to_string(), 1) .replacen("%s", "5", 1), ) } /// `WrittenBookContent.addToTooltip`: "by " and the generation. pub fn written_book_lines( stack: &ItemStack, display: &TooltipDisplay, translate: &dyn Fn(&str) -> Option, ) -> Vec { let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); let Some(book) = stack .data() .and_then(|d| d.written.as_ref()) .filter(|_| display.shows("minecraft:written_book_content")) else { return Vec::new(); }; let mut lines = Vec::new(); if !book.author.trim().is_empty() { lines.push( crate::text::format_translation( &text("book.byAuthor"), &[crate::text::Text::literal(&book.author)], ) .plain(), ); } lines.push(text(&format!("book.generation.{}", book.generation))); lines } /// `JukeboxPlayable.addToTooltip`: the song's description. pub fn jukebox_line( stack: &ItemStack, info: Option<&ItemInfo>, display: &TooltipDisplay, translate: &dyn Fn(&str) -> Option, ) -> Option { if !display.shows("minecraft:jukebox_playable") { return None; } let song = match stack .data() .and_then(|d| d.other("minecraft:jukebox_playable")) { Some(Tag::String(song)) => song.to_string_lossy(), // An inline song carries its own description. Some(inline) => { return inline .get("description") .map(|d| crate::entity_nbt::name_text(d).plain()); } None => info?.jukebox_song.clone()?, }; let key = format!("jukebox_song.{}", song.replacen(':', ".", 1)); Some(translate(&key).unwrap_or(key)) } /// `DyedItemColor.addToTooltip`: "Dyed" (italic, the flag), or with advanced /// tooltips the colour's hex code. pub fn dyed_line( stack: &ItemStack, display: &TooltipDisplay, advanced: bool, translate: &dyn Fn(&str) -> Option, ) -> Option<(String, bool)> { let rgb = stack.data()?.dyed_color?; if !display.shows("minecraft:dyed_color") { return None; } let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); Some(if advanced { let hex = format!("#{:06X}", rgb & 0xFF_FFFF); (text("item.color").replacen("%s", &hex, 1), false) } else { (text("item.dyed"), true) }) } /// `ItemStack.UNBREAKABLE_TOOLTIP`. pub fn unbreakable_line( stack: &ItemStack, display: &TooltipDisplay, translate: &dyn Fn(&str) -> Option, ) -> Option { (stack.data()?.other("minecraft:unbreakable").is_some() && display.shows("minecraft:unbreakable")) .then(|| translate("item.unbreakable").unwrap_or_else(|| "item.unbreakable".into())) } /// `PotionContents.addPotionTooltip`'s attribute block: an empty line, "When /// Applied:" and the modifiers of the potion's effects (blue for a gain, red /// for a loss); nothing for a potion whose effects add none. pub fn potion_modifier_lines( stack: &ItemStack, translate: &dyn Fn(&str) -> Option, ) -> Vec<(String, u32)> { if !is_potion_item(&stack.item) { return Vec::new(); } let applied: Vec<(String, u32)> = stack .potion() .and_then(crate::brewing::potion) .into_iter() .flat_map(|p| p.effects.iter()) .filter_map(|(effect, _, amplifier)| { let (attribute, amount, operation) = effect_modifier(effect)?; let amount = amount * (*amplifier + 1) as f64; let line = modifier_line(translate, attribute, amount, operation, false)?; let color = if amount > 0.0 { rgba(85, 85, 255, 255) } else { rgba(255, 85, 85, 255) }; Some((line, color)) }) .collect(); if applied.is_empty() { return applied; } let mut lines = vec![ (String::new(), u32::MAX), ( translate("potion.whenDrank").unwrap_or_else(|| "potion.whenDrank".into()), rgba(170, 0, 170, 255), ), ]; lines.extend(applied); lines } /// `ItemStack.components.size()`: the item's default components with the /// stack's own changes applied. pub fn component_count(stack: &ItemStack, info: Option<&ItemInfo>) -> usize { let mut keys: std::collections::HashSet = info .map(|i| i.components.iter().cloned().collect()) .unwrap_or_default(); if let Some(Tag::Compound(patch)) = crate::item_data::components_tag(stack.damage, stack.data()) { for key in patch.keys() { let key = key.to_string_lossy(); match key.strip_prefix('!') { Some(removed) => keys.remove(removed), None => keys.insert(key), }; } } keys.len() } /// `SmithingTemplateItem.appendHoverText`: the template's kind, what it applies to /// and its ingredients (gray titles over blue descriptions); none for other items. pub fn smithing_template_lines( stack: &ItemStack, translate: &dyn Fn(&str) -> Option, ) -> Vec<(String, u32)> { let path = stack.item.trim_start_matches("minecraft:"); if !path.ends_with("_smithing_template") { return Vec::new(); } let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); let kind = if path == "netherite_upgrade_smithing_template" { "netherite_upgrade" } else { "armor_trim" }; let (title, description) = (rgba(170, 170, 170, 255), rgba(85, 85, 255, 255)); let described = |what: &str| { let key = format!("item.minecraft.smithing_template.{kind}.{what}"); (format!(" {}", text(&key)), description) }; vec![ (text("item.minecraft.smithing_template"), title), (String::new(), u32::MAX), (text("item.minecraft.smithing_template.applies_to"), title), described("applies_to"), (text("item.minecraft.smithing_template.ingredients"), title), described("ingredients"), ] } /// The lines of `stack` below its name that its components give, in /// `ItemStack.addDetailsToTooltip` order. pub fn detail_lines( stack: &ItemStack, info: Option<&ItemInfo>, translate: &dyn Fn(&str) -> Option, ) -> Vec { let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); let path = stack.item.trim_start_matches("minecraft:"); let mut lines = Vec::new(); lines.extend( smithing_template_lines(stack, translate) .into_iter() .map(|l| l.0), ); let display = TooltipDisplay::for_stack(stack); lines.extend(bees_line(stack, &display, translate)); lines.extend(honey_line(stack, &display, translate)); let data = stack.data(); // PotDecorations.addToTooltip. if let Some(sherds) = data .and_then(|d| d.pot_decorations.as_ref()) .filter(|s| s.iter().any(Option::is_some)) { lines.push(String::new()); for sherd in sherds.iter() { let item = sherd.as_ref().map_or("minecraft:brick", |s| &*s.item); lines.push(name_line(&ItemStack::new(item, 1), translate)); } } lines.extend(firework_lines(stack, translate)); // PotionContents.addToTooltip: the effects, then their attribute modifiers. if is_potion_item(&stack.item) { let scale = match path { "lingering_potion" => 0.25, "tipped_arrow" => 0.125, _ => 1.0, }; lines.extend( crate::brewing::tooltip(stack.potion(), scale, translate) .into_iter() .map(|l| l.0), ); lines.extend( potion_modifier_lines(stack, translate) .into_iter() .map(|l| l.0), ); } lines.extend(jukebox_line(stack, info, &display, translate)); // Trim.addToTooltip. if let Some((material, pattern)) = data.and_then(|d| d.trim.as_ref()) { let short = |s: &str| s.trim_start_matches("minecraft:").to_owned(); lines.push(text("item.minecraft.smithing_template.upgrade")); lines.push(format!( " {}", text(&format!("trim_pattern.minecraft.{}", short(pattern))) )); lines.push(format!( " {}", text(&format!("trim_material.minecraft.{}", short(material))) )); } lines.extend(dyed_line(stack, &display, false, translate).map(|l| l.0)); if let Some(info) = info { lines.extend( attribute_lines(&info.modifiers, None, translate) .into_iter() .map(|(line, _)| line), ); } lines } /// `Fireworks.addToTooltip` (a rocket's flight duration, its explosions with /// runs of equal ones counted) and `FireworkExplosion.addToTooltip` (a /// star's), unless the stack's tooltip display hides them. A rocket without /// the component has the item's default: flight duration 1, no explosions. pub fn firework_lines( stack: &ItemStack, translate: &dyn Fn(&str) -> Option, ) -> Vec { use crate::particles::FireworkExplosion; let text = |key: &str| translate(key).unwrap_or_else(|| key.to_owned()); let shape = |e: &FireworkExplosion| { text(&format!( "item.minecraft.firework_star.shape.{}", e.shape.name() )) }; // FireworkExplosion.appendColors: dye names (getColorName), comma-separated. let colors = |colors: &[u32]| { colors .iter() .map(|c| { match crate::particles::DYE_FIREWORK_COLORS .iter() .find(|(_, firework)| firework == c) { Some((name, _)) => text(&format!("item.minecraft.firework_star.{name}")), None => text("item.minecraft.firework_star.custom_color"), } }) .collect::>() .join(", ") }; // FireworkExplosion.addAdditionalTooltip. let details = |e: &FireworkExplosion, indent: &str, lines: &mut Vec| { if !e.colors.is_empty() { lines.push(format!("{indent}{}", colors(&e.colors))); } if !e.fade.is_empty() { let fade = text("item.minecraft.firework_star.fade_to"); lines.push(format!("{indent}{fade} {}", colors(&e.fade))); } if e.trail { lines.push(format!( "{indent}{}", text("item.minecraft.firework_star.trail") )); } if e.twinkle { lines.push(format!( "{indent}{}", text("item.minecraft.firework_star.flicker") )); } }; let display = TooltipDisplay::for_stack(stack); let data = stack.data(); let mut lines = Vec::new(); let fireworks = match data.and_then(|d| d.fireworks.as_ref()) { Some((flight, explosions)) => Some((*flight, explosions.as_slice())), None => (&*stack.item == "minecraft:firework_rocket").then_some((1, &[][..])), }; if let Some((flight, explosions)) = fireworks && display.shows("minecraft:fireworks") { if flight > 0 { lines.push( text("item.minecraft.firework_rocket.flight_duration").replacen( "%s", &flight.to_string(), 1, ), ); } // Fireworks.addExplosionTooltip for each run of equal explosions. for run in explosions.chunk_by(|a, b| a == b) { let e = &run[0]; lines.push(if run.len() == 1 { text("item.minecraft.firework_rocket.single_star").replacen("%s", &shape(e), 1) } else { text("item.minecraft.firework_rocket.multiple_stars") .replacen("%s", &run.len().to_string(), 1) .replacen("%s", &shape(e), 1) }); details(e, " ", &mut lines); } } if let Some(e) = data.and_then(|d| d.firework_explosion.as_ref()) && display.shows("minecraft:firework_explosion") { lines.push(shape(e)); details(e, "", &mut lines); } lines } /// `ItemContainerContents.addToTooltip`: "count x name" for the first five /// stacks, by slot, then how many more there are (an italic line). pub fn container_lines( stack: &ItemStack, name: &dyn Fn(&ItemStack) -> String, translate: &dyn Fn(&str) -> Option, ) -> Vec { let Some(data) = stack.data() else { return Vec::new(); }; let mut slots: Vec<&(u8, ItemStack)> = data.container.iter().collect(); slots.sort_by_key(|(slot, _)| *slot); let count = translate("item.container.item_count").unwrap_or_else(|| "%s x %s".into()); let mut lines: Vec = slots .iter() .take(5) .map(|(_, s)| { count .replacen("%s", &s.count.to_string(), 1) .replacen("%s", &name(s), 1) }) .collect(); if slots.len() > 5 { let more = translate("item.container.more_items").unwrap_or_else(|| "and %s more...".into()); lines.push(more.replacen("%s", &(slots.len() - 5).to_string(), 1)); } lines } /// Every line of `stack`'s tooltip, name first. pub fn lines( stack: &ItemStack, info: Option<&ItemInfo>, translate: &dyn Fn(&str) -> Option, ) -> Vec { let mut lines = vec![name_line(stack, translate)]; if TooltipDisplay::for_stack(stack).shows("minecraft:lore") { lines.extend(lore_texts(stack).into_iter().map(|t| t.plain())); } lines.extend(detail_lines(stack, info, translate)); lines } /// `ItemLore.addToTooltip`: each lore component under dark purple italic, with /// the component's own styles (including explicit `false`) winning on children. pub fn lore_texts(stack: &ItemStack) -> Vec { let Some(Tag::List(entries)) = stack.data().and_then(|d| d.other("minecraft:lore")) else { return Vec::new(); }; let base = crate::text::Style { color: Some(crate::text::DARK_PURPLE), italic: Some(true), ..Default::default() }; entries .iter() .map(|entry| { let mut text = crate::entity_nbt::name_text(entry).resolve_legacy(); for span in &mut text.spans { span.style.inherit(&base); } text }) .collect() } #[cfg(test)] mod tests { use super::*; #[test] fn lore_keeps_component_colours_under_dark_purple_italic() { let mut stack = ItemStack::new("minecraft:stick", 1); stack.data_mut().set_other( "minecraft:lore", Some(Tag::List(vec![ Tag::compound([ ("text", Tag::String("Gold line".into())), ("color", Tag::String("gold".into())), ("italic", Tag::Byte(0)), ]), Tag::String("Plain lore".into()), ])), ); let lines = lore_texts(&stack); assert_eq!(lines.len(), 2); assert_eq!(lines[0].plain(), "Gold line"); assert_eq!(lines[0].spans[0].style.color, Some(crate::text::GOLD)); assert!(!lines[0].spans[0].style.is_italic()); assert_eq!(lines[1].plain(), "Plain lore"); assert_eq!( lines[1].spans[0].style.color, Some(crate::text::DARK_PURPLE) ); assert!(lines[1].spans[0].style.is_italic()); assert!(TooltipDisplay::for_stack(&stack).shows("minecraft:lore")); stack.data_mut().set_other( "minecraft:tooltip_display", Some(Tag::compound([( "hidden_components", Tag::List(vec![Tag::String("minecraft:lore".into())]), )])), ); assert!(!TooltipDisplay::for_stack(&stack).shows("minecraft:lore")); } #[test] fn tooltip_display_controls_name_and_component_visibility() { let mut stack = ItemStack::new("minecraft:diamond_sword", 1); let display = TooltipDisplay::for_stack(&stack); assert!(display.name_visible(false)); assert!(display.shows("minecraft:attribute_modifiers")); stack.data_mut().set_other( "minecraft:tooltip_display", Some(Tag::compound([( "hidden_components", Tag::List(vec![Tag::String("minecraft:attribute_modifiers".into())]), )])), ); let display = TooltipDisplay::for_stack(&stack); assert!(display.name_visible(false)); assert!(!display.shows("minecraft:attribute_modifiers")); assert!(display.shows("minecraft:enchantments")); stack.data_mut().set_other( "minecraft:tooltip_display", Some(Tag::compound([("hide_tooltip", Tag::Byte(1))])), ); let display = TooltipDisplay::for_stack(&stack); assert!(!display.name_visible(false)); assert!(display.name_visible(true)); assert!(!display.shows("minecraft:attribute_modifiers")); } #[test] fn ominous_banner_keeps_its_default_hidden_pattern_tooltip() { let mut banner = crate::mobs::raider::ominous_banner(); let display = TooltipDisplay::for_stack(&banner); assert!(!display.shows("minecraft:banner_patterns")); banner.data_mut().set_other( "minecraft:tooltip_display", Some(Tag::Compound(Default::default())), ); let display = TooltipDisplay::for_stack(&banner); assert!(display.shows("minecraft:banner_patterns")); } #[test] fn ominous_banner_name_and_rarity_use_the_stack() { let translate = |key: &str| match key { "block.minecraft.ominous_banner" => Some("Ominous Banner".to_owned()), "block.minecraft.white_banner" => Some("White Banner".to_owned()), _ => None, }; let mut banner = crate::mobs::raider::ominous_banner(); assert_eq!(name_line(&banner, &translate), "Ominous Banner"); assert_eq!(name_line(&banner, &|_| None), "Ominous Banner"); assert_eq!(rarity(&banner, "common"), "uncommon"); banner.data_mut().custom_name = Some("Captain's Standard".into()); assert_eq!(name_line(&banner, &translate), "Captain's Standard"); let mut custom_item = ItemStack::new("minecraft:diamond_sword", 1); custom_item.data_mut().other.push(( "minecraft:item_name".into(), Tag::String("Excalibur".into()), )); assert_eq!(name_line(&custom_item, &translate), "Excalibur"); custom_item.data_mut().custom_name = Some("Custom Blade".into()); assert_eq!(name_line(&custom_item, &translate), "Custom Blade"); banner.enchant("minecraft:unbreaking", 1); assert_eq!(rarity(&banner, "common"), "rare"); let plain = ItemStack::new("minecraft:white_banner", 1); assert_eq!(name_line(&plain, &translate), "White Banner"); assert_eq!(rarity(&plain, "common"), "common"); } #[test] fn container_lines_list_five_stacks_then_how_many_more() { let mut chest = ItemStack::new("minecraft:chest", 1); for slot in [9u8, 1, 2, 3, 4, 5, 6] { chest .data_mut() .container .push((slot, ItemStack::new("minecraft:stone", u32::from(slot)))); } let lang = |k: &str| { Some( match k { "item.container.item_count" => "%s x %s", "item.container.more_items" => "and %s more...", _ => return None, } .to_owned(), ) }; let name = |s: &ItemStack| s.item.trim_start_matches("minecraft:").to_owned(); assert_eq!( container_lines(&chest, &name, &lang), [ "1 x stone", "2 x stone", "3 x stone", "4 x stone", "5 x stone", "and 2 more..." ] ); assert!(container_lines(&ItemStack::new("minecraft:chest", 1), &name, &lang).is_empty()); } #[test] fn fireworks_use_loaded_tooltip_translations() { let root = std::env::temp_dir().join(format!( "horizon-firework-tooltip-language-{}-{}", std::process::id(), std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap() .as_nanos(), )); let dir = root.join("assets/minecraft/lang"); std::fs::create_dir_all(&dir).unwrap(); std::fs::write( dir.join("en_us.json"), serde_json::to_vec(&serde_json::json!({ "item.minecraft.firework_rocket.flight_duration": "Flight Duration: %s", "item.minecraft.firework_rocket.multiple_stars": "%s x %s", "item.minecraft.firework_star.shape.small_ball": "Small Ball", "item.minecraft.firework_star.red": "Red", "item.minecraft.firework_star.custom_color": "Custom", "item.minecraft.firework_star.fade_to": "Fade to", "item.minecraft.firework_star.trail": "Trail", "item.minecraft.firework_star.flicker": "Twinkle", })) .unwrap(), ) .unwrap(); let enchantments = crate::enchant::Enchantments::load(&root); std::fs::remove_dir_all(&root).unwrap(); let translate = |key: &str| enchantments.translate(key).map(str::to_owned); let mut rocket = ItemStack::new("minecraft:firework_rocket", 1); assert_eq!(firework_lines(&rocket, &translate), ["Flight Duration: 1"]); let explosion = crate::particles::FireworkExplosion { colors: vec![0xB3312C], fade: vec![0x123456], trail: true, twinkle: true, ..Default::default() }; rocket.data_mut().fireworks = Some((3, vec![explosion.clone(), explosion.clone()])); assert_eq!( firework_lines(&rocket, &translate), [ "Flight Duration: 3", "2 x Small Ball", " Red", " Fade to Custom", " Trail", " Twinkle", ] ); let mut star = ItemStack::new("minecraft:firework_star", 1); star.data_mut().firework_explosion = Some(explosion); assert_eq!( firework_lines(&star, &translate), ["Small Ball", "Red", "Fade to Custom", "Trail", "Twinkle"] ); } #[test] fn amounts_use_two_decimals_at_most() { assert_eq!(format_amount(8.0), "8"); assert_eq!(format_amount(3.2000000953674316), "3.2"); assert_eq!(format_amount(2.8200000524520874), "2.82"); assert_eq!(format_amount(0.125), "0.12"); assert_eq!(format_amount(0.375), "0.38"); } #[test] fn equipment_attributes_use_player_totals_and_slot_group_colors() { let modifiers = [ ("attack_damage", "base_attack_damage", 6.0, "mainhand"), ("attack_speed", "base_attack_speed", -2.4, "mainhand"), ("armor", "armor", 3.0, "head"), ] .map(|(attribute, id, amount, slot)| { ( format!("minecraft:{attribute}"), format!("minecraft:{id}"), amount, "add_value".to_owned(), slot.to_owned(), ) }); let root = std::env::temp_dir().join(format!( "horizon-tooltip-language-{}-{}", std::process::id(), std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap() .as_nanos(), )); let dir = root.join("assets/minecraft/lang"); std::fs::create_dir_all(&dir).unwrap(); std::fs::write( dir.join("en_us.json"), serde_json::to_vec(&serde_json::json!({ "item.modifiers.mainhand": "When in Main Hand:", "item.modifiers.head": "When on Head:", "attribute.modifier.equals.0": "%s %s", "attribute.modifier.plus.0": "+%s %s", "attribute.modifier.take.0": "-%s %s", "attribute.name.attack_damage": "Attack Damage", "attribute.name.attack_speed": "Attack Speed", "attribute.name.armor": "Armor", })) .unwrap(), ) .unwrap(); let enchantments = crate::enchant::Enchantments::load(&root); std::fs::remove_dir_all(&root).unwrap(); let lang = |key: &str| enchantments.translate(key).map(str::to_owned); let green = rgba(0, 170, 0, 255); let gray = rgba(170, 170, 170, 255); let blue = rgba(85, 85, 255, 255); let red = rgba(255, 85, 85, 255); assert_eq!( attribute_lines(&modifiers, Some([1.0, 4.0]), &lang), [ (String::new(), u32::MAX), ("When in Main Hand:".into(), gray), (" 7 Attack Damage".into(), green), (" 1.6 Attack Speed".into(), green), (String::new(), u32::MAX), ("When on Head:".into(), gray), ("+3 Armor".into(), blue), ] ); let recipe = attribute_lines(&modifiers, None, &lang); assert_eq!(recipe[2], ("+6 Attack Damage".into(), blue)); assert_eq!(recipe[3], ("-2.4 Attack Speed".into(), red)); let custom_base = attribute_lines(&modifiers, Some([2.0, 6.0]), &lang); assert_eq!(custom_base[2].0, " 8 Attack Damage"); assert_eq!(custom_base[3].0, " 3.6 Attack Speed"); assert_eq!( modifier_line(&lang, "attack_damage", 0.0, 0, true).as_deref(), Some("0 Attack Damage") ); } #[test] #[ignore = "requires prepared items/language in HORIZON_TEST_RESOURCES"] fn equipment_attributes_with_prepared_items_and_language() { let root = std::path::PathBuf::from( std::env::var_os("HORIZON_TEST_RESOURCES").expect("HORIZON_TEST_RESOURCES"), ); let items = crate::items::Items::catalog(&root).unwrap(); let enchantments = crate::enchant::Enchantments::load(&root); let translate = |key: &str| enchantments.translate(key).map(str::to_owned); for (item, expected) in [ ( "minecraft:diamond_sword", [ "", "When in Main Hand:", " 7 Attack Damage", " 1.6 Attack Speed", ], ), ( "minecraft:diamond_helmet", ["", "When on Head:", "+3 Armor", "+2 Armor Toughness"], ), ] { let info = items.get(item).unwrap(); let lines = attribute_lines(&info.modifiers, Some([1.0, 4.0]), &translate); assert_eq!( lines .iter() .map(|(text, _)| text.as_str()) .collect::>(), expected, "{item}" ); } } #[test] fn modifier_lines_follow_the_sign_and_operation() { let lang = |k: &str| { Some( match k { "attribute.modifier.plus.2" => "+%s%% %s", "attribute.modifier.take.2" => "-%s%% %s", "attribute.name.movement_speed" => "Speed", _ => return None, } .to_owned(), ) }; assert_eq!( modifier_line(&lang, "movement_speed", 0.2, 2, false).as_deref(), Some("+20% Speed") ); assert_eq!( modifier_line(&lang, "movement_speed", -0.6, 2, false).as_deref(), Some("-60% Speed") ); assert_eq!(modifier_line(&lang, "movement_speed", 0.0, 2, false), None); } }