Show the missing item tooltip lines in vanilla order
Custom names are italic. Unbreakable, dyed, written book author and generation, music disc songs, goat horn instruments, loaded crossbow projectiles, hive bees and honey, the potion "When Applied" block and enchantment attribute modifiers (Efficiency V gives +26 Mining Efficiency) now appear, and advanced tooltips (F3+H) end with the item id and the component count. Attribute lines use the attribute's sentiment colour.
This commit is contained in:
@@ -545,6 +545,32 @@ impl Enchantments {
|
||||
}
|
||||
out
|
||||
}
|
||||
/// `EnchantmentHelper.forEachModifier` as an item's tooltip lists them: the
|
||||
/// `minecraft:attributes` effects of `stack`'s enchantments as rows of
|
||||
/// (attribute, id, amount, operation, slot group), one per slot group the
|
||||
/// enchantment lists.
|
||||
pub fn modifier_rows(&self, stack: &ItemStack) -> Vec<(String, String, f64, String, String)> {
|
||||
let mut rows = Vec::new();
|
||||
for (id, level) in stack.enchantments() {
|
||||
let Some(e) = self.get(id) else { continue };
|
||||
for a in e.effects["minecraft:attributes"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
{
|
||||
for slot in &e.slots {
|
||||
rows.push((
|
||||
a["attribute"].as_str().unwrap_or("").to_owned(),
|
||||
a["id"].as_str().unwrap_or("").to_owned(),
|
||||
f64::from(level_value(&a["amount"], *level)),
|
||||
a["operation"].as_str().unwrap_or("add_value").to_owned(),
|
||||
slot.clone(),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
rows
|
||||
}
|
||||
/// Sum of `add_value` amounts of one attribute from enchantments on `stack`.
|
||||
pub fn attribute_add(&self, stack: Option<&ItemStack>, attribute: &str) -> f64 {
|
||||
stack.map_or(0.0, |s| {
|
||||
|
||||
@@ -277,6 +277,10 @@ fn argb(c: i32) -> u32 {
|
||||
)
|
||||
}
|
||||
|
||||
/// A text style's `0xRRGGBB` colour from a HUD colour (`rgba`).
|
||||
fn rgb_of(rgba: u32) -> u32 {
|
||||
(rgba & 0xFF) << 16 | (rgba >> 8 & 0xFF) << 8 | (rgba >> 16 & 0xFF)
|
||||
}
|
||||
impl Game<'_> {
|
||||
/// `Component.translatable`: the selected language (which `lang` layers
|
||||
/// over `en_us`), the caller's English text last.
|
||||
@@ -1689,20 +1693,34 @@ impl Game<'_> {
|
||||
&self,
|
||||
stack: &ItemStack,
|
||||
) -> Vec<(horizon_client::text::Text, u32)> {
|
||||
let e: &Enchantments = &self.res.stations().enchantments;
|
||||
let props = e.props(&stack.item);
|
||||
self.stack_tooltip_lines(stack, false)
|
||||
}
|
||||
/// `ItemStack.getRarity`'s colour for the name line and a `[name]` link.
|
||||
fn rarity_color(&self, stack: &ItemStack) -> u32 {
|
||||
let props = self.res.stations().enchantments.props(&stack.item);
|
||||
let rarity = horizon_client::item_tooltip::rarity(
|
||||
stack,
|
||||
props.map_or("common", |p| p.rarity.as_str()),
|
||||
);
|
||||
let color = match rarity {
|
||||
match rarity {
|
||||
"uncommon" => rgba(255, 255, 85, 255),
|
||||
"rare" => rgba(85, 255, 255, 255),
|
||||
"epic" => rgba(255, 85, 255, 255),
|
||||
_ => u32::MAX,
|
||||
};
|
||||
let name = if let Some(n) = stack.custom_name() {
|
||||
}
|
||||
}
|
||||
/// `ItemStack.getHoverName`: the custom name, a written book's title, the
|
||||
/// item name component, else the item's or potion's name.
|
||||
fn stack_hover_name(&self, stack: &ItemStack) -> String {
|
||||
if let Some(n) = stack.custom_name() {
|
||||
n.to_owned()
|
||||
} else if let Some(title) = stack
|
||||
.data()
|
||||
.and_then(|d| d.written.as_ref())
|
||||
.map(|w| w.title.as_str())
|
||||
.filter(|t| !t.trim().is_empty())
|
||||
{
|
||||
title.to_owned()
|
||||
} else if let Some(n) = stack.item_name() {
|
||||
n
|
||||
} else if stack.data().is_some_and(|d| d.ominous_banner) {
|
||||
@@ -1718,16 +1736,47 @@ impl Game<'_> {
|
||||
.unwrap_or_else(|| self.pack.names.display_item(&stack.item))
|
||||
} else {
|
||||
self.pack.names.display_item(&stack.item)
|
||||
};
|
||||
}
|
||||
}
|
||||
/// `ItemStack.getTooltipLines`. A `nested` stack is a crossbow's
|
||||
/// projectile: `ChargedProjectiles.addProjectileTooltip` takes its details
|
||||
/// without the name, the player and the advanced flag.
|
||||
fn stack_tooltip_lines(
|
||||
&self,
|
||||
stack: &ItemStack,
|
||||
nested: bool,
|
||||
) -> Vec<(horizon_client::text::Text, u32)> {
|
||||
let e: &Enchantments = &self.res.stations().enchantments;
|
||||
let color = self.rarity_color(stack);
|
||||
let advanced = !nested && self.options_advanced_tooltips();
|
||||
let display = horizon_client::item_tooltip::TooltipDisplay::for_stack(stack);
|
||||
let mut lines = Vec::new();
|
||||
if display.name_visible(self.screen == Screen::Creative) {
|
||||
lines.push((horizon_client::text::Text::legacy(&name), color));
|
||||
if !nested && display.name_visible(self.screen == Screen::Creative) {
|
||||
// `getStyledHoverName`: a custom name is italic.
|
||||
let name = self.stack_hover_name(stack);
|
||||
let name = if stack.custom_name().is_some() {
|
||||
horizon_client::text::Text::literal(name).italic()
|
||||
} else {
|
||||
horizon_client::text::Text::legacy(&name)
|
||||
};
|
||||
lines.push((name, color));
|
||||
}
|
||||
let translate = |k: &str| self.pack.names.display_get(k);
|
||||
let push = |lines: &mut Vec<(horizon_client::text::Text, u32)>, s: String, c: u32| {
|
||||
lines.push((horizon_client::text::Text::legacy(&s), c));
|
||||
};
|
||||
let gray = rgba(170, 170, 170, 255);
|
||||
let item_info = self.res.items().get(&stack.item);
|
||||
// InstrumentComponent.addToTooltip.
|
||||
if let Some(text) =
|
||||
horizon_client::item_tooltip::instrument_line(stack, &display, &translate)
|
||||
{
|
||||
push(&mut lines, text, gray);
|
||||
}
|
||||
// Bees.addToTooltip.
|
||||
if let Some(text) = horizon_client::item_tooltip::bees_line(stack, &display, &translate) {
|
||||
push(&mut lines, text, gray);
|
||||
}
|
||||
// ItemContainerContents.addToTooltip.
|
||||
let hover_name = |s: &ItemStack| {
|
||||
s.custom_name()
|
||||
@@ -1742,6 +1791,70 @@ impl Game<'_> {
|
||||
push(&mut lines, text, u32::MAX);
|
||||
}
|
||||
}
|
||||
// BannerPatternLayers.addToTooltip: up to six layer names.
|
||||
if display.shows("minecraft:banner_patterns") {
|
||||
for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
|
||||
let key = self.res.stations().banners.layer_key(layer);
|
||||
push(
|
||||
&mut lines,
|
||||
self.translate(&key, &key),
|
||||
rgba(170, 170, 170, 255),
|
||||
);
|
||||
}
|
||||
}
|
||||
// WrittenBookContent.addToTooltip.
|
||||
for text in horizon_client::item_tooltip::written_book_lines(stack, &display, &translate) {
|
||||
push(&mut lines, text, gray);
|
||||
}
|
||||
// ChargedProjectiles.addToTooltip: each run of equal projectiles, then
|
||||
// the projectile's own details indented under it.
|
||||
if display.shows("minecraft:charged_projectiles") {
|
||||
let charged = stack.data().map_or(&[][..], |d| &d.charged[..]);
|
||||
for run in charged.chunk_by(|a, b| a.same_item_same_components(b)) {
|
||||
let projectile = &run[0];
|
||||
let name = self.stack_hover_name(projectile);
|
||||
let line = if run.len() == 1 {
|
||||
// `getDisplayName`: `[name]` in the rarity colour.
|
||||
let mut shown = horizon_client::text::Text::literal(format!("[{name}]"))
|
||||
.with_color(rgb_of(self.rarity_color(projectile)));
|
||||
if projectile.custom_name().is_some() {
|
||||
shown = shown.italic();
|
||||
}
|
||||
horizon_client::text::format_translation(
|
||||
&self.translate(
|
||||
"item.minecraft.crossbow.projectile.single",
|
||||
"Projectile: %s",
|
||||
),
|
||||
&[shown],
|
||||
)
|
||||
} else {
|
||||
horizon_client::text::format_translation(
|
||||
&self.translate(
|
||||
"item.minecraft.crossbow.projectile.multiple",
|
||||
"Projectile: %s x %s",
|
||||
),
|
||||
&[
|
||||
horizon_client::text::Text::literal(run.len().to_string()),
|
||||
horizon_client::text::Text::literal(name),
|
||||
],
|
||||
)
|
||||
};
|
||||
lines.push((line, u32::MAX));
|
||||
for (text, c) in self.stack_tooltip_lines(projectile, true) {
|
||||
// `literal(" ").append(line).withStyle(GRAY)`: the line's
|
||||
// own colours win over the gray.
|
||||
let rgb = if c == u32::MAX {
|
||||
horizon_client::text::GRAY
|
||||
} else {
|
||||
rgb_of(c)
|
||||
};
|
||||
let indented = horizon_client::text::Text::literal(" ")
|
||||
.append(text)
|
||||
.with_color(rgb);
|
||||
lines.push((indented, u32::MAX));
|
||||
}
|
||||
}
|
||||
}
|
||||
// Fireworks / FireworkExplosion.addToTooltip.
|
||||
for text in horizon_client::item_tooltip::firework_lines(stack, &translate) {
|
||||
push(&mut lines, text, rgba(170, 170, 170, 255));
|
||||
@@ -1764,6 +1877,17 @@ impl Game<'_> {
|
||||
};
|
||||
push(&mut lines, text, c);
|
||||
}
|
||||
// The attribute modifiers of the effects (`When Applied:`).
|
||||
for (text, c) in horizon_client::item_tooltip::potion_modifier_lines(stack, &translate)
|
||||
{
|
||||
push(&mut lines, text, c);
|
||||
}
|
||||
}
|
||||
// JukeboxPlayable.addToTooltip.
|
||||
if let Some(text) =
|
||||
horizon_client::item_tooltip::jukebox_line(stack, item_info, &display, &translate)
|
||||
{
|
||||
push(&mut lines, text, gray);
|
||||
}
|
||||
if display.shows("minecraft:trim")
|
||||
&& let Some((material, pattern)) = stack.data().and_then(|d| d.trim.clone())
|
||||
@@ -1811,16 +1935,12 @@ impl Game<'_> {
|
||||
);
|
||||
}
|
||||
}
|
||||
// BannerPatternLayers.addToTooltip: up to six layer names.
|
||||
if display.shows("minecraft:banner_patterns") {
|
||||
for layer in horizon_client::banner::tooltip_layers(stack).iter().take(6) {
|
||||
let key = self.res.stations().banners.layer_key(layer);
|
||||
push(
|
||||
&mut lines,
|
||||
self.translate(&key, &key),
|
||||
rgba(170, 170, 170, 255),
|
||||
);
|
||||
}
|
||||
// DyedItemColor.addToTooltip.
|
||||
if let Some((text, italic)) =
|
||||
horizon_client::item_tooltip::dyed_line(stack, &display, advanced, &translate)
|
||||
{
|
||||
let text = horizon_client::text::Text::legacy(&text);
|
||||
lines.push((if italic { text.italic() } else { text }, gray));
|
||||
}
|
||||
// ItemLore.addToTooltip: after the enchantments, before the attributes
|
||||
// (ItemStack.addDetailsToTooltip).
|
||||
@@ -1829,6 +1949,50 @@ impl Game<'_> {
|
||||
lines.push((text, u32::MAX));
|
||||
}
|
||||
}
|
||||
if display.shows("minecraft:attribute_modifiers") {
|
||||
// The item's own modifiers, then its enchantments' for each slot
|
||||
// group (`ItemStack.forEachModifier`).
|
||||
let mut modifiers = item_info.map(|i| i.modifiers.clone()).unwrap_or_default();
|
||||
modifiers.extend(e.modifier_rows(stack));
|
||||
let base = |name: &str, default| {
|
||||
self.player
|
||||
.as_ref()
|
||||
.and_then(|player| {
|
||||
let key = player.attributes.key(name)?;
|
||||
let handle = player.attributes.lookup(Some(&key))?;
|
||||
player
|
||||
.attributes
|
||||
.instance(&handle)
|
||||
.ok()
|
||||
.map(|value| value.base_value())
|
||||
})
|
||||
.unwrap_or(default)
|
||||
};
|
||||
let player_base = (!nested).then(|| {
|
||||
[
|
||||
base("minecraft:attack_damage", 1.0),
|
||||
base(
|
||||
"minecraft:attack_speed",
|
||||
horizon_client::attack_strength::BASE_ATTACK_SPEED,
|
||||
),
|
||||
]
|
||||
});
|
||||
for (text, c) in
|
||||
horizon_client::item_tooltip::attribute_lines(&modifiers, player_base, &translate)
|
||||
{
|
||||
push(&mut lines, text, c);
|
||||
}
|
||||
}
|
||||
// ItemStack.UNBREAKABLE_TOOLTIP.
|
||||
if let Some(text) =
|
||||
horizon_client::item_tooltip::unbreakable_line(stack, &display, &translate)
|
||||
{
|
||||
push(&mut lines, text, rgba(85, 85, 255, 255));
|
||||
}
|
||||
// BlockItemStateProperties.addToTooltip.
|
||||
if let Some(text) = horizon_client::item_tooltip::honey_line(stack, &display, &translate) {
|
||||
push(&mut lines, text, gray);
|
||||
}
|
||||
// Spawner.appendHoverText: what a spawner or trial spawner item spawns.
|
||||
if display.shows("minecraft:block_entity_data")
|
||||
&& matches!(
|
||||
@@ -1852,43 +2016,11 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
}
|
||||
if display.shows("minecraft:attribute_modifiers")
|
||||
&& let Some(info) = self.res.items().get(&stack.item)
|
||||
{
|
||||
let base = |name: &str, default| {
|
||||
self.player
|
||||
.as_ref()
|
||||
.and_then(|player| {
|
||||
let key = player.attributes.key(name)?;
|
||||
let handle = player.attributes.lookup(Some(&key))?;
|
||||
player
|
||||
.attributes
|
||||
.instance(&handle)
|
||||
.ok()
|
||||
.map(|value| value.base_value())
|
||||
})
|
||||
.unwrap_or(default)
|
||||
};
|
||||
let player_base = [
|
||||
base("minecraft:attack_damage", 1.0),
|
||||
base(
|
||||
"minecraft:attack_speed",
|
||||
horizon_client::attack_strength::BASE_ATTACK_SPEED,
|
||||
),
|
||||
];
|
||||
for (text, c) in horizon_client::item_tooltip::attribute_lines(
|
||||
&info.modifiers,
|
||||
Some(player_base),
|
||||
&translate,
|
||||
) {
|
||||
push(&mut lines, text, c);
|
||||
}
|
||||
}
|
||||
if display.shows("minecraft:damage")
|
||||
&& let Some(info) = self.res.items().get(&stack.item)
|
||||
&& let Some(info) = item_info
|
||||
&& info.max_damage > 0
|
||||
&& stack.damage > 0
|
||||
&& self.options_advanced_tooltips()
|
||||
&& advanced
|
||||
{
|
||||
push(
|
||||
&mut lines,
|
||||
@@ -1900,8 +2032,23 @@ impl Game<'_> {
|
||||
u32::MAX,
|
||||
);
|
||||
}
|
||||
// ItemStack.addDetailsToTooltipTail: with advanced tooltips the item id
|
||||
// and how many components the stack has.
|
||||
if advanced {
|
||||
let dark_gray = rgba(85, 85, 85, 255);
|
||||
push(&mut lines, stack.item.to_string(), dark_gray);
|
||||
let count = horizon_client::item_tooltip::component_count(stack, item_info);
|
||||
if count > 0 {
|
||||
let text = self.translate("item.components", "%s component(s)");
|
||||
push(
|
||||
&mut lines,
|
||||
text.replacen("%s", &count.to_string(), 1),
|
||||
dark_gray,
|
||||
);
|
||||
}
|
||||
}
|
||||
// ItemStack.OP_NBT_WARNING, for a player with game master permission.
|
||||
if self.ui.registries.permission >= 2 && block_entity_item::op_warning(stack) {
|
||||
if !nested && self.ui.registries.permission >= 2 && block_entity_item::op_warning(stack) {
|
||||
for (key, fallback) in [
|
||||
("item.op_warning.line1", "Warning:"),
|
||||
(
|
||||
|
||||
@@ -108,6 +108,32 @@ fn modifier_line(
|
||||
)
|
||||
}
|
||||
|
||||
/// `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(
|
||||
@@ -150,10 +176,8 @@ pub fn attribute_lines(
|
||||
) {
|
||||
let (line, color) = if base.is_some() {
|
||||
(format!(" {line}"), rgba(0, 170, 0, 255))
|
||||
} else if *amount > 0.0 {
|
||||
(line, rgba(85, 85, 255, 255))
|
||||
} else {
|
||||
(line, rgba(255, 85, 85, 255))
|
||||
(line, attribute_color(path, *amount > 0.0))
|
||||
};
|
||||
lines.push((line, color));
|
||||
}
|
||||
@@ -231,6 +255,235 @@ pub fn rarity<'a>(stack: &ItemStack, default: &'a str) -> &'a str {
|
||||
}
|
||||
}
|
||||
|
||||
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<String>,
|
||||
) -> Option<String> {
|
||||
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<String>,
|
||||
) -> Option<String> {
|
||||
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<String>,
|
||||
) -> Option<String> {
|
||||
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::<u32>().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 <author>" and the generation.
|
||||
pub fn written_book_lines(
|
||||
stack: &ItemStack,
|
||||
display: &TooltipDisplay,
|
||||
translate: &dyn Fn(&str) -> Option<String>,
|
||||
) -> Vec<String> {
|
||||
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<String>,
|
||||
) -> Option<String> {
|
||||
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<String>,
|
||||
) -> 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<String>,
|
||||
) -> Option<String> {
|
||||
(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<String>,
|
||||
) -> 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<String> = 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()
|
||||
}
|
||||
|
||||
/// The lines of `stack` below its name that its components give, in
|
||||
/// `ItemStack.addDetailsToTooltip` order.
|
||||
pub fn detail_lines(
|
||||
@@ -265,19 +518,9 @@ pub fn detail_lines(
|
||||
))
|
||||
));
|
||||
}
|
||||
// BeehiveBlock: the block state components of the item.
|
||||
if path == "beehive" {
|
||||
lines.push(
|
||||
text("container.beehive.bees")
|
||||
.replacen("%s", "0", 1)
|
||||
.replacen("%s", "3", 1),
|
||||
);
|
||||
lines.push(
|
||||
text("container.beehive.honey")
|
||||
.replacen("%s", "0", 1)
|
||||
.replacen("%s", "5", 1),
|
||||
);
|
||||
}
|
||||
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
|
||||
@@ -303,32 +546,13 @@ pub fn detail_lines(
|
||||
.into_iter()
|
||||
.map(|l| l.0),
|
||||
);
|
||||
let applied: Vec<String> = 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)?;
|
||||
modifier_line(
|
||||
translate,
|
||||
attribute,
|
||||
amount * (*amplifier + 1) as f64,
|
||||
operation,
|
||||
false,
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
if !applied.is_empty() {
|
||||
lines.push(String::new());
|
||||
lines.push(text("potion.whenDrank"));
|
||||
lines.extend(applied);
|
||||
}
|
||||
}
|
||||
// JukeboxPlayable.addToTooltip: the song's description.
|
||||
if path.starts_with("music_disc_") {
|
||||
lines.push(text(&format!("item.minecraft.{path}.desc")));
|
||||
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();
|
||||
@@ -342,10 +566,7 @@ pub fn detail_lines(
|
||||
text(&format!("trim_material.minecraft.{}", short(material)))
|
||||
));
|
||||
}
|
||||
// DyedItemColor.addToTooltip (without advanced tooltips).
|
||||
if data.is_some_and(|d| d.dyed_color.is_some()) {
|
||||
lines.push(text("item.dyed"));
|
||||
}
|
||||
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)
|
||||
|
||||
@@ -128,6 +128,8 @@ pub struct ItemInfo {
|
||||
pub block_transformer: Option<String>,
|
||||
/// Has a default `bundle_contents` (the bundles, `BundleItem`).
|
||||
pub bundle: bool,
|
||||
/// The ids of the item's default components (its prototype's keys).
|
||||
pub components: Vec<String>,
|
||||
}
|
||||
/// `Item.Properties.craftRemainder` (not a data component, so not in the
|
||||
/// default-component report): what an item leaves in the grid when crafted with.
|
||||
@@ -614,6 +616,10 @@ impl Items {
|
||||
cushion_color: c["minecraft:cushion/color"].as_str().map(str::to_owned),
|
||||
block_transformer: c["minecraft:block_transformer"].as_str().map(str::to_owned),
|
||||
bundle: c.get("minecraft:bundle_contents").is_some(),
|
||||
components: c
|
||||
.as_object()
|
||||
.map(|c| c.keys().cloned().collect())
|
||||
.unwrap_or_default(),
|
||||
crafting_remainder: CRAFT_REMAINDERS
|
||||
.iter()
|
||||
.find(|(item, _)| *item == name)
|
||||
|
||||
Reference in New Issue
Block a user