fixed prefix deletion, unified gem category filtering, and removed mojibake

Author: Nightwielder23

README.md

@@ -35,7 +35,7 @@ The "Hold Alt for full details" prompt also appears when other handlers hide con
 
 `affix_sort_order` is one of `default`, `rarity`, `alphabetical`, `type`.
 
-`affix_prefixes_mode` controls the affix type prefixes (While held, On hit, On block, Passive). `show` (default) keeps them, `alt` hides them unless Alt is held, `delete` removes them permanently.
+`affix_prefixes_mode` controls the affix prefix and suffix Apotheosis adds to the item name, like "Strengthened" or "of the Inferno". `show` (default) keeps the full name, `alt` shows the base item name unless Alt is held, `delete` always shows the base item name.
 
 `hidden_affix_ids` is a list of translation key prefixes for affixes you want hidden entirely.
 

src/main/java/com/nightwielder/apothictooltipcleanup/Config.java

@@ -51,10 +51,10 @@ public class Config {
         builder.comment(" Sort order: default, rarity, alphabetical, type.");
         AFFIX_SORT_ORDER = builder.defineInList("affix_sort_order", "default", Arrays.asList("default", "rarity", "alphabetical", "type"));
 
-        builder.comment(" Affix type prefixes (While held, On hit, On block, Passive).",
-                " show = always visible",
-                " alt = hidden unless Alt is held",
-                " delete = always hidden, Alt has no effect");
+        builder.comment(" The affix prefix and suffix Apotheosis adds to the item name (Strengthened, of the Inferno).",
+                " show = full affixed name",
+                " alt = base item name unless Alt is held",
+                " delete = always the base item name");
         AFFIX_PREFIXES_MODE = builder.defineInList("affix_prefixes_mode", HideMode.SHOW, HideMode.OPTIONS);
 
         builder.comment(" Translation key prefixes of affixes to hide.");
@@ -80,7 +80,7 @@ public class Config {
                 " delete = always hidden, Alt has no effect");
         POTION_DESCRIPTIONS_MODE = builder.defineInList("potion_descriptions_mode", HideMode.SHOW, HideMode.OPTIONS);
 
-        builder.comment(" The [⌛ MM:SS] cooldown markers and [Stacking] tags on affix lines.",
+        builder.comment(" The [MM:SS] cooldown markers and [Stacking] tags on affix lines.",
                 " Only the annotations are touched, never the affix text.",
                 " show = always visible",
                 " alt = hidden unless Alt is held",

src/main/java/com/nightwielder/apothictooltipcleanup/handler/AffixMarkerStripper.java

@@ -12,7 +12,7 @@
 
 // Strips the cooldown marker and [Stacking] tag off affix bullets. Apoth attaches them as siblings
 // of the bullet inner component where a string regex never sees them, so the siblings are matched by
-// translation key after a quick English only check for the marker glyphs.
+// translation key.
 public final class AffixMarkerStripper {
     private static final String COOLDOWN_KEY = "affix.apotheosis.cooldown";
     private static final String STACKING_KEY = "affix.apotheosis.stacking";
@@ -32,10 +32,6 @@ public static boolean apply(List<Component> tooltip) {
             if (!TooltipMatcher.isBulletPrefix(line)) {
                 continue;
             }
-            String text = line.getString();
-            if (text.indexOf('⌛') < 0 && !text.contains("[Stacking]")) {
-                continue;
-            }
             if (!(line.getContents() instanceof TranslatableContents tc)) {
                 continue;
             }

src/main/java/com/nightwielder/apothictooltipcleanup/handler/FitsInRemover.java

@@ -21,6 +21,10 @@ public final class FitsInRemover {
     // teal blue Apotheosis uses for the Fits In header and category bullets
     private static final int FITS_IN_COLOR = 720650;
 
+    // A category in a Fits In bullet: its rendered name, its Apoth id from the translation key (null
+    // when the key shape is unexpected), and the original component so a filtered bullet stays translatable.
+    private record Category(String name, String id, Component component) {}
+
     // Output order for ultra mode's category line: weapons, armor, mining tools, then Other. Within a
     // group, input order is kept.
     private static final LinkedHashMap<String, Set<String>> CATEGORY_GROUPS = new LinkedHashMap<>();
@@ -82,7 +86,7 @@ public static void apply(List<Component> tooltip) {
 
             if (isFits) {
                 if (ultra) {
-                    List<String> names = sortByGroup(filterHidden(extractCategoryNames(tooltip, i + 1, afterBullets)));
+                    List<String> names = sortByGroup(namesOf(filterHidden(extractCategoriesRange(tooltip, i + 1, afterBullets))));
                     removeRange(tooltip, i, afterBullets);
                     if (!names.isEmpty()) {
                         tooltip.add(i, joinedCategoryBullet(String.join(", ", names)));
@@ -96,20 +100,19 @@ public static void apply(List<Component> tooltip) {
                 i++;
                 int bulletIndex = i;
                 while (bulletIndex < afterBullets && TooltipMatcher.isBulletPrefix(tooltip.get(bulletIndex))) {
-                    String inner = extractBulletText(tooltip.get(bulletIndex));
-                    if (inner == null || inner.isEmpty()) {
+                    List<Category> cats = extractCategories(tooltip.get(bulletIndex));
+                    if (cats.isEmpty()) {
                         bulletIndex++;
                         continue;
                     }
-                    List<String> names = splitCategories(inner);
-                    List<String> kept = filterHidden(names);
-                    if (kept.size() == names.size()) {
+                    List<Category> kept = filterHidden(cats);
+                    if (kept.size() == cats.size()) {
                         bulletIndex++;
                     } else if (kept.isEmpty()) {
                         tooltip.remove(bulletIndex);
                         afterBullets--;
                     } else {
-                        tooltip.set(bulletIndex, categoryBullet(String.join(", ", kept)));
+                        tooltip.set(bulletIndex, rebuildCategoryBullet(kept));
                         bulletIndex++;
                     }
                 }
@@ -163,8 +166,7 @@ public static void apply(List<Component> tooltip) {
     // full mode keeps Apoth's layout, so walk each Fits In block and drop hidden categories. A bullet
     // with nothing left is removed, and so is a header with no bullets under it.
     private static void filterFullCategories(List<Component> tooltip) {
-        List<? extends String> hiddenCategories = Config.HIDDEN_GEM_CATEGORIES.get();
-        if (hiddenCategories == null || hiddenCategories.isEmpty()) {
+        if (hiddenSet().isEmpty()) {
             return;
         }
 
@@ -186,20 +188,19 @@ private static void filterFullCategories(List<Component> tooltip) {
             }
 
             while (bulletIndex < afterBullets) {
-                String inner = extractBulletText(tooltip.get(bulletIndex));
-                if (inner == null || inner.isEmpty()) {
+                List<Category> cats = extractCategories(tooltip.get(bulletIndex));
+                if (cats.isEmpty()) {
                     bulletIndex++;
                     continue;
                 }
-                List<String> names = splitCategories(inner);
-                List<String> kept = filterHidden(names);
-                if (kept.size() == names.size()) {
+                List<Category> kept = filterHidden(cats);
+                if (kept.size() == cats.size()) {
                     bulletIndex++;
                 } else if (kept.isEmpty()) {
                     tooltip.remove(bulletIndex);
                     afterBullets--;
                 } else {
-                    tooltip.set(bulletIndex, categoryBullet(String.join(", ", kept)));
+                    tooltip.set(bulletIndex, rebuildCategoryBullet(kept));
                     bulletIndex++;
                 }
             }
@@ -233,8 +234,7 @@ private static void filterSocketInByCategory(List<Component> tooltip) {
             int bulletIndex = i + 1;
             int kept = 0;
             while (bulletIndex < tooltip.size() && TooltipMatcher.isBulletPrefix(tooltip.get(bulletIndex))) {
-                String id = socketBonusCategoryId(tooltip.get(bulletIndex));
-                if (id != null && hidden.contains(id)) {
+                if (socketBonusHidden(tooltip.get(bulletIndex), hidden)) {
                     tooltip.remove(bulletIndex);
                 } else {
                     kept++;
@@ -251,35 +251,35 @@ private static void filterSocketInByCategory(List<Component> tooltip) {
         }
     }
 
-    // Returns the gem_class id from a Pattern B socket bonus bullet (dot_prefix to "%s: %s" to arg[0]
-    // keyed gem_class.<id>), or null if the bullet is not that shape.
-    private static String socketBonusCategoryId(Component bullet) {
+    // Returns true when a Pattern B socket bonus bullet (dot_prefix to "%s: %s" to arg[0] keyed
+    // gem_class.<id>) belongs to a hidden category, matching either the gem_class id or its rendered name.
+    private static boolean socketBonusHidden(Component bullet, Set<String> hidden) {
         TranslatableContents outer = TooltipMatcher.translatable(bullet);
         if (outer == null || outer.getArgs().length == 0) {
-            return null;
+            return false;
         }
         if (!(outer.getArgs()[0] instanceof Component join)) {
-            return null;
+            return false;
         }
 
         TranslatableContents joinTc = TooltipMatcher.translatable(join);
         if (joinTc == null || joinTc.getArgs().length == 0) {
-            return null;
+            return false;
         }
         if (!(joinTc.getArgs()[0] instanceof Component gemClass)) {
-            return null;
+            return false;
         }
 
         TranslatableContents gcTc = TooltipMatcher.translatable(gemClass);
         if (gcTc == null) {
-            return null;
+            return false;
         }
         String key = gcTc.getKey();
         int at = key.lastIndexOf("gem_class.");
-        if (at < 0) {
-            return null;
+        if (at >= 0 && hidden.contains(key.substring(at + "gem_class.".length()))) {
+            return true;
         }
-        return key.substring(at + "gem_class.".length());
+        return hidden.contains(gemClass.getString());
     }
 
     // Returns the hidden_gem_categories config as a case insensitive set, empty if unset.
@@ -350,16 +350,65 @@ private static List<String> sortByGroup(List<String> categories) {
         return sorted;
     }
 
-    private static List<String> extractCategoryNames(List<Component> tooltip, int from, int toExclusive) {
-        List<String> names = new ArrayList<>();
-        for (int k = from; k < toExclusive; k++) {
-            String inner = extractBulletText(tooltip.get(k));
-            if (inner == null || inner.isEmpty()) {
-                continue;
+    // Pulls each category out of a Fits In dot_prefix bullet as a name and Apoth id. Apoth holds the
+    // categories as the args of an inner translatable, one component per category keyed
+    // text.apotheosis.category.<id>.plural, falling back to splitting the rendered text when the shape
+    // is unexpected such as the "Anything" line or a plain literal.
+    private static List<Category> extractCategories(Component bullet) {
+        TranslatableContents outer = TooltipMatcher.translatable(bullet);
+        if (outer == null || outer.getArgs().length == 0) {
+            return Collections.emptyList();
+        }
+        if (!(outer.getArgs()[0] instanceof Component inner)) {
+            return Collections.emptyList();
+        }
+
+        TranslatableContents innerTc = TooltipMatcher.translatable(inner);
+        if (innerTc != null && innerTc.getArgs().length > 0) {
+            List<Category> out = new ArrayList<>();
+            for (Object arg : innerTc.getArgs()) {
+                if (arg instanceof Component cat) {
+                    out.add(new Category(cat.getString(), categoryId(cat), cat));
+                } else {
+                    String name = String.valueOf(arg);
+                    out.add(new Category(name, null, Component.literal(name)));
+                }
             }
-            names.addAll(splitCategories(inner));
+            return out;
         }
-        return names;
+
+        List<Category> out = new ArrayList<>();
+        for (String name : splitCategories(inner.getString())) {
+            out.add(new Category(name, null, Component.literal(name)));
+        }
+        return out;
+    }
+
+    private static List<Category> extractCategoriesRange(List<Component> tooltip, int from, int toExclusive) {
+        List<Category> out = new ArrayList<>();
+        for (int k = from; k < toExclusive; k++) {
+            out.addAll(extractCategories(tooltip.get(k)));
+        }
+        return out;
+    }
+
+    // Returns the Apoth category id from a category name component's key (text.apotheosis.category.<id>.plural),
+    // so config values like "chestplate" match regardless of the rendered "Chestplates" text or locale.
+    private static String categoryId(Component cat) {
+        TranslatableContents tc = TooltipMatcher.translatable(cat);
+        if (tc == null) {
+            return null;
+        }
+        String key = tc.getKey();
+        int at = key.lastIndexOf("category.");
+        if (at < 0) {
+            return null;
+        }
+        String id = key.substring(at + "category.".length());
+        if (id.endsWith(".plural")) {
+            id = id.substring(0, id.length() - ".plural".length());
+        }
+        return id;
     }
 
     // Splits "Swords, Bows, ..." into trimmed, non empty names.
@@ -374,27 +423,46 @@ private static List<String> splitCategories(String inner) {
         return names;
     }
 
-    // Drops any names listed in hidden_gem_categories, case insensitive.
-    private static List<String> filterHidden(List<String> categories) {
-        List<? extends String> hidden = Config.HIDDEN_GEM_CATEGORIES.get();
-        if (hidden == null || hidden.isEmpty()) {
+    // Keeps the categories the user has not hidden, matching the Apoth id from the translation key (so
+    // config can use ids like "chestplate") and the rendered name (so "Chestplates" works too).
+    private static List<Category> filterHidden(List<Category> categories) {
+        Set<String> hidden = hiddenSet();
+        if (hidden.isEmpty()) {
             return categories;
         }
-        Set<String> hiddenSet = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
-        hiddenSet.addAll(hidden);
-        List<String> filtered = new ArrayList<>(categories.size());
-        for (String name : categories) {
-            if (!hiddenSet.contains(name)) {
-                filtered.add(name);
+        List<Category> kept = new ArrayList<>(categories.size());
+        for (Category cat : categories) {
+            boolean hide = (cat.id() != null && hidden.contains(cat.id())) || hidden.contains(cat.name());
+            if (!hide) {
+                kept.add(cat);
             }
         }
-        return filtered;
+        return kept;
     }
 
-    // Rebuilds a Fits In category bullet with the teal styling after dropping hidden categories, used
-    // by both compact and full mode.
-    private static Component categoryBullet(String text) {
-        return Component.translatable("text.apotheosis.dot_prefix", Component.literal(text))
+    private static List<String> namesOf(List<Category> categories) {
+        List<String> names = new ArrayList<>(categories.size());
+        for (Category cat : categories) {
+            names.add(cat.name());
+        }
+        return names;
+    }
+
+    // Rebuilds a Fits In category bullet from the kept categories after dropping hidden ones. Apoth
+    // joins the categories through a "%s, %s" translatable, so reconstruct that with one %s per kept
+    // category and the original category components as args, keeping them translatable.
+    private static Component rebuildCategoryBullet(List<Category> kept) {
+        StringBuilder fmt = new StringBuilder();
+        Object[] args = new Object[kept.size()];
+        for (int i = 0; i < kept.size(); i++) {
+            fmt.append("%s");
+            if (i < kept.size() - 1) {
+                fmt.append(", ");
+            }
+            args[i] = kept.get(i).component();
+        }
+        Component join = Component.translatable(fmt.toString(), args);
+        return Component.translatable("text.apotheosis.dot_prefix", join)
                 .withStyle(Style.EMPTY.withColor(FITS_IN_COLOR));
     }
 

src/main/java/com/nightwielder/apothictooltipcleanup/handler/PrefixCleaner.java

@@ -5,24 +5,32 @@
 import com.nightwielder.apothictooltipcleanup.util.TooltipMatcher;
 import net.minecraft.client.gui.screens.Screen;
 import net.minecraft.network.chat.Component;
+import net.minecraft.world.item.ItemStack;
 
 import java.util.List;
 
-// Hides the affix type prefix lines (While held, On hit, On block, Passive).
+// Strips the Apotheosis affix prefix and suffix from the item name, leaving the base item name. Apoth
+// renames affixed items with a misc.apotheosis.affix_name template, so tooltip line 0 carries that key.
 public final class PrefixCleaner {
     private PrefixCleaner() {}
 
-    // Drops the prefix lines when the mode hides them and returns true if a hidden line is alt revealable.
-    public static boolean apply(List<Component> tooltip) {
+    // Replaces the affixed item name with the plain base name when the mode hides it and returns true
+    // if a hidden name is alt revealable.
+    public static boolean apply(ItemStack stack, List<Component> tooltip) {
         String mode = Config.AFFIX_PREFIXES_MODE.get();
         boolean altDown = Screen.hasAltDown();
         if (!HideMode.hides(mode, altDown)) {
             return false;
         }
-        boolean removed = tooltip.removeIf(c -> TooltipMatcher.keyStartsWith(c, "text.apotheosis.affix_type.while_held")
-                || TooltipMatcher.keyStartsWith(c, "text.apotheosis.affix_type.on_hit")
-                || TooltipMatcher.keyStartsWith(c, "text.apotheosis.affix_type.on_block")
-                || TooltipMatcher.keyStartsWith(c, "text.apotheosis.affix_type.passive"));
-        return removed && HideMode.revealable(mode, altDown);
+        if (tooltip.isEmpty()) {
+            return false;
+        }
+        Component name = tooltip.get(0);
+        if (!TooltipMatcher.keyStartsWith(name, "misc.apotheosis.affix_name")) {
+            return false;
+        }
+        Component base = stack.getItem().getName(stack);
+        tooltip.set(0, Component.empty().append(base).withStyle(name.getStyle()));
+        return HideMode.revealable(mode, altDown);
     }
 }

src/main/java/com/nightwielder/apothictooltipcleanup/handler/TooltipHandler.java

@@ -50,7 +50,7 @@ public static void onTooltip(ItemTooltipEvent event) {
         // each handler returns true if it hid something Alt can reveal. OR them together so
         // AltExpandHandler knows whether to add the prompt.
         boolean anyHidden = false;
-        anyHidden |= PrefixCleaner.apply(tooltip);
+        anyHidden |= PrefixCleaner.apply(stack, tooltip);
         anyHidden |= SourceLineRemover.apply(tooltip);
         anyHidden |= SummarizationDisabler.apply(tooltip);
         if (ApotheosisDetector.isApothicAttributesLoaded()) {