From 6b47ac9324fc7f1f7da42df519ce757ec8fd8af9 Mon Sep 17 00:00:00 2001 From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com> Date: Wed, 18 Nov 2026 22:15:44 +0100 Subject: [PATCH] Mage weapons follow their template's classes and two-handed flag on refresh Co-Authored-By: Claude Opus 5.5 --- .../tfminecraft/magic/gear/GearRefresher.java | 9 +- .../magic/gear/GearTemplateSync.java | 113 ++++++++++ .../magic/GearRefresherCoverageTest.java | 34 +++ .../magic/gear/GearTemplateSyncTest.java | 201 ++++++++++++++++++ 4 files changed, 354 insertions(+), 3 deletions(-) create mode 100644 src/main/java/net/tfminecraft/magic/gear/GearTemplateSync.java create mode 100644 src/test/java/net/tfminecraft/magic/gear/GearTemplateSyncTest.java diff --git a/src/main/java/net/tfminecraft/magic/gear/GearRefresher.java b/src/main/java/net/tfminecraft/magic/gear/GearRefresher.java index b3d5e32..665d1f8 100644 --- a/src/main/java/net/tfminecraft/magic/gear/GearRefresher.java +++ b/src/main/java/net/tfminecraft/magic/gear/GearRefresher.java @@ -22,7 +22,8 @@ /** * Brings a crafted weapon back in line with the live gear config. * - * Socket colours, part stats and the name are rewritten from the stamped parts. Runes already + * Socket colours, part stats and the name are rewritten from the stamped parts, and the class + * list and two-handed flag follow the weapon's MMOItems template. Runes already * in the weapon are merged into the new layout; any that no longer fit are held by * {@link GearBrokenMarker} instead of being dropped. */ @@ -56,7 +57,7 @@ public static ItemStack refresh(ItemStack stack, Player holder, boolean force) { } if (!force && !GearProvenance.isOutdated(stack) && !RuneRefresher.isOutdated(stack) - && !GearName.isOutdated(stack)) { + && !GearName.isOutdated(stack) && !GearTemplateSync.isOutdated(stack)) { int live = MajorityTierResolver.resolve(GearProvenance.resolveParts(stack)); if (live > 0 && GearProvenance.majorityOf(stack) != live) { ItemStack clone = stack.clone(); @@ -113,7 +114,8 @@ public static ItemStack refresh(ItemStack stack, Player holder, boolean force) { private static ItemStack rewrite(ItemStack stack, List colours, String name, List orphaned, Map runeRevisions) { try { - LiveMMOItem mmo = new LiveMMOItem(NBTItem.get(stack)); + NBTItem nbt = NBTItem.get(stack); + LiveMMOItem mmo = new LiveMMOItem(nbt); List existing = new ArrayList<>(); if (mmo.hasData(ItemStats.GEM_SOCKETS)) { StatData data = mmo.getData(ItemStats.GEM_SOCKETS); @@ -131,6 +133,7 @@ private static ItemStack rewrite(ItemStack stack, List colours, String n } mmo.setData(ItemStats.GEM_SOCKETS, next); GearStatApplicator.apply(mmo, GearProvenance.resolveParts(stack)); + GearTemplateSync.apply(mmo, nbt); GearName.write(mmo, name); runeRevisions.putAll(RuneRefresher.refresh(mmo, stack)); ItemStack built = mmo.newBuilder().build(); diff --git a/src/main/java/net/tfminecraft/magic/gear/GearTemplateSync.java b/src/main/java/net/tfminecraft/magic/gear/GearTemplateSync.java new file mode 100644 index 0000000..374ec49 --- /dev/null +++ b/src/main/java/net/tfminecraft/magic/gear/GearTemplateSync.java @@ -0,0 +1,113 @@ +package net.tfminecraft.magic.gear; + +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; +import java.util.Set; + +import org.bukkit.inventory.ItemStack; + +import io.lumine.mythic.lib.api.item.NBTItem; +import net.Indyuce.mmoitems.ItemStats; +import net.Indyuce.mmoitems.MMOItems; +import net.Indyuce.mmoitems.api.item.mmoitem.MMOItem; +import net.Indyuce.mmoitems.api.item.template.MMOItemTemplate; +import net.Indyuce.mmoitems.stat.data.BooleanData; +import net.Indyuce.mmoitems.stat.data.StringListData; +import net.Indyuce.mmoitems.stat.data.random.RandomBooleanData; +import net.Indyuce.mmoitems.stat.type.StatHistory; + +/** + * Keeps a crafted weapon's class list and two-handed flag in line with its MMOItems template. + * A refresh rebuilds the weapon from its own data, so without this a class added to or removed + * from a mage weapon template, or a template made two-handed, never reaches weapons that exist. + * Nothing else on the weapon is taken from the template. + */ +public final class GearTemplateSync { + + static final String CLASS_TAG = "MMOITEMS_REQUIRED_CLASS"; + static final String TWO_HANDED_TAG = "MMOITEMS_TWO_HANDED"; + + private GearTemplateSync() {} + + /** True when the weapon's classes (as a set, ignoring case) or two-handed flag differ from its template's. */ + public static boolean isOutdated(ItemStack stack) { + if (stack == null || stack.getType().isAir()) { + return false; + } + try { + NBTItem nbt = NBTItem.get(stack); + MMOItemTemplate template = template(nbt); + if (template == null) { + return false; + } + String raw = nbt.getString(CLASS_TAG); + Set classes = lowerCase(Arrays.asList((raw == null ? "" : raw).split(","))); + return !classes.equals(lowerCase(classes(template))) || nbt.getBoolean(TWO_HANDED_TAG) != twoHanded(template); + } catch (RuntimeException ex) { + return false; + } + } + + /** + * Gives {@code mmo} its template's classes and two-handed flag. With a class stat history only + * its original layer changes, so gem layers stay. {@code nbt} is the item {@code mmo} was read from. + */ + public static void apply(MMOItem mmo, NBTItem nbt) { + MMOItemTemplate template = template(nbt); + if (template == null) { + return; + } + List classes = classes(template); + if (classes.isEmpty()) { + mmo.removeData(ItemStats.REQUIRED_CLASS); + } else { + StringListData data = new StringListData(classes); + StatHistory history = mmo.getStatHistory(ItemStats.REQUIRED_CLASS); + if (history != null) { + history.setOriginalData(data.clone()); + } + mmo.setData(ItemStats.REQUIRED_CLASS, data); + } + if (twoHanded(template)) { + mmo.setData(ItemStats.TWO_HANDED, new BooleanData(true)); + } else { + mmo.removeData(ItemStats.TWO_HANDED); + } + } + + private static MMOItemTemplate template(NBTItem nbt) { + if (MMOItems.plugin == null || nbt == null || !nbt.hasType()) { + return null; + } + return MMOItems.plugin.getTemplates().getTemplate(nbt); + } + + private static List classes(MMOItemTemplate template) { + return template.getBaseItemData().get(ItemStats.REQUIRED_CLASS) instanceof StringListData list + ? list.getList() + : List.of(); + } + + static boolean twoHanded(MMOItemTemplate template) { + Object data = template.getBaseItemData().get(ItemStats.TWO_HANDED); + if (data instanceof RandomBooleanData random) { + return random.getChance() >= 1; + } + return data instanceof BooleanData flag && flag.isEnabled(); + } + + /** Trimmed, non-blank, lower-case names, as MMOItems compares a player's class. */ + static Set lowerCase(Collection names) { + Set result = new HashSet<>(); + for (String name : names) { + String trimmed = name.trim(); + if (!trimmed.isEmpty()) { + result.add(trimmed.toLowerCase(Locale.ROOT)); + } + } + return result; + } +} diff --git a/src/test/java/net/tfminecraft/magic/GearRefresherCoverageTest.java b/src/test/java/net/tfminecraft/magic/GearRefresherCoverageTest.java index f853f7e..f3925ad 100644 --- a/src/test/java/net/tfminecraft/magic/GearRefresherCoverageTest.java +++ b/src/test/java/net/tfminecraft/magic/GearRefresherCoverageTest.java @@ -169,6 +169,40 @@ void outdatedRunesRebuildCurrentGearAndStampTheirRevisions() { } } + @Test + void templateClassOrHandChangesRebuildAnOtherwiseCurrentWeapon() { + var item = managed(); + MockBukkit.createMockPlugin("MMOItems"); + MockBukkit.createMockPlugin("MythicLib"); + var built = item(); + var nbtItem = mock(NBTItem.class); + try (var nbt = mockStatic(NBTItem.class); + var stats = mockStatic(GearStatApplicator.class); + var model = mockStatic(GearModelResolver.class); + var skin = mockStatic(GearSkin.class, i -> i.getArgument(1)); + var lore = mockStatic(WeaponLore.class); + var sync = mockStatic(GearTemplateSync.class); + var items = + mockConstruction( + LiveMMOItem.class, + (m, c) -> { + var builder = mock(ItemStackBuilder.class); + when(m.newBuilder()).thenReturn(builder); + when(builder.build()).thenReturn(built); + })) { + nbt.when(() -> NBTItem.get(any(ItemStack.class))).thenReturn(nbtItem); + model + .when(() -> GearModelResolver.apply(any(), any(), any())) + .thenAnswer(i -> i.getArgument(0)); + lore.when(() -> WeaponLore.updateItem(any())).thenAnswer(i -> i.getArgument(0)); + sync.when(() -> GearTemplateSync.isOutdated(item)).thenReturn(false); + assertNull(GearRefresher.refreshIfOutdated(item, null)); + sync.when(() -> GearTemplateSync.isOutdated(item)).thenReturn(true); + assertSame(built, GearRefresher.refreshIfOutdated(item, null)); + sync.verify(() -> GearTemplateSync.apply(items.constructed().getFirst(), nbtItem)); + } + } + @Test void incompatibleGemsAreHeldAndFailuresNeverReplaceOriginals() { MockBukkit.createMockPlugin("MMOItems"); diff --git a/src/test/java/net/tfminecraft/magic/gear/GearTemplateSyncTest.java b/src/test/java/net/tfminecraft/magic/gear/GearTemplateSyncTest.java new file mode 100644 index 0000000..92c8097 --- /dev/null +++ b/src/test/java/net/tfminecraft/magic/gear/GearTemplateSyncTest.java @@ -0,0 +1,201 @@ +package net.tfminecraft.magic.gear; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +import io.lumine.mythic.lib.MythicLib; +import io.lumine.mythic.lib.api.item.NBTItem; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import net.Indyuce.mmoitems.ItemStats; +import net.Indyuce.mmoitems.MMOItems; +import net.Indyuce.mmoitems.api.item.mmoitem.MMOItem; +import net.Indyuce.mmoitems.api.item.template.MMOItemTemplate; +import net.Indyuce.mmoitems.stat.data.BooleanData; +import net.Indyuce.mmoitems.stat.data.StringListData; +import net.Indyuce.mmoitems.stat.data.random.RandomBooleanData; +import net.Indyuce.mmoitems.stat.data.random.RandomStatData; +import net.Indyuce.mmoitems.stat.type.ItemStat; +import net.Indyuce.mmoitems.stat.type.StatHistory; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.MockedStatic; +import org.mockbukkit.mockbukkit.MockBukkit; + +class GearTemplateSyncTest { + private MMOItems oldMmo; + private MythicLib oldLib; + private MockedStatic nbtStatic; + private NBTItem nbt; + private final Map base = new HashMap<>(); + + @BeforeEach + void setUp() { + MockBukkit.mock(); + oldMmo = MMOItems.plugin; + oldLib = MythicLib.plugin; + MMOItems.plugin = mock(MMOItems.class, RETURNS_DEEP_STUBS); + when(MMOItems.plugin.namespace()).thenReturn("mmoitems"); + MythicLib.plugin = mock(MythicLib.class, RETURNS_DEEP_STUBS); + when(MythicLib.plugin.namespace()).thenReturn("mythiclib"); + MMOItemTemplate template = mock(MMOItemTemplate.class); + when(template.getBaseItemData()).thenReturn(base); + nbt = mock(NBTItem.class); + when(nbt.hasType()).thenReturn(true); + when(MMOItems.plugin.getTemplates().getTemplate(nbt)).thenReturn(template); + nbtStatic = mockStatic(NBTItem.class); + nbtStatic.when(() -> NBTItem.get(any(ItemStack.class))).thenReturn(nbt); + } + + @AfterEach + void tearDown() { + nbtStatic.close(); + MMOItems.plugin = oldMmo; + MythicLib.plugin = oldLib; + MockBukkit.unmock(); + } + + private static ItemStack stick() { + return new ItemStack(Material.STICK); + } + + private void template(List classes, RandomStatData twoHanded) { + base.clear(); + if (classes != null) { + base.put(ItemStats.REQUIRED_CLASS, new StringListData(classes)); + } + if (twoHanded != null) { + base.put(ItemStats.TWO_HANDED, twoHanded); + } + } + + private void item(String classes, boolean twoHanded) { + when(nbt.getString(GearTemplateSync.CLASS_TAG)).thenReturn(classes); + when(nbt.getBoolean(GearTemplateSync.TWO_HANDED_TAG)).thenReturn(twoHanded); + } + + @Test + void matchingWeaponsAreNotOutdated() { + template(List.of("Arcanist"), new RandomBooleanData(true)); + item(" arcanist ,", true); + assertFalse(GearTemplateSync.isOutdated(stick())); + template(null, null); + item(null, false); + assertFalse(GearTemplateSync.isOutdated(stick())); + } + + @Test + void classOrTwoHandedChangesMakeAWeaponOutdated() { + template(List.of("Arcanist", "Evoker"), new RandomBooleanData(true)); + item("Mage", true); + assertTrue(GearTemplateSync.isOutdated(stick())); + item("Evoker, Arcanist", false); + assertTrue(GearTemplateSync.isOutdated(stick())); + item("Evoker, Arcanist", true); + assertFalse(GearTemplateSync.isOutdated(stick())); + } + + @Test + void weaponsWithoutAReadableTemplateAreLeftAlone() { + assertFalse(GearTemplateSync.isOutdated(null)); + assertFalse(GearTemplateSync.isOutdated(new ItemStack(Material.AIR))); + when(nbt.hasType()).thenReturn(false); + assertFalse(GearTemplateSync.isOutdated(stick())); + when(nbt.hasType()).thenReturn(true); + when(MMOItems.plugin.getTemplates().getTemplate(nbt)).thenReturn(null); + assertFalse(GearTemplateSync.isOutdated(stick())); + nbtStatic.when(() -> NBTItem.get(any(ItemStack.class))).thenReturn(null); + assertFalse(GearTemplateSync.isOutdated(stick())); + nbtStatic.when(() -> NBTItem.get(any(ItemStack.class))).thenThrow(new IllegalStateException()); + assertFalse(GearTemplateSync.isOutdated(stick())); + MMOItems.plugin = null; + nbtStatic.when(() -> NBTItem.get(any(ItemStack.class))).thenReturn(nbt); + assertFalse(GearTemplateSync.isOutdated(stick())); + } + + @Test + void applyCopiesClassesAndTwoHandedIntoTheOriginalLayer() { + template(List.of("Battlemage"), new RandomBooleanData(true)); + MMOItem mmo = mock(MMOItem.class); + StatHistory history = mock(StatHistory.class); + when(mmo.getStatHistory(ItemStats.REQUIRED_CLASS)).thenReturn(history); + GearTemplateSync.apply(mmo, nbt); + var classes = ArgumentCaptor.forClass(StringListData.class); + verify(mmo).setData(eq(ItemStats.REQUIRED_CLASS), classes.capture()); + assertEquals(List.of("Battlemage"), classes.getValue().getList()); + verify(history).setOriginalData(any(StringListData.class)); + var flag = ArgumentCaptor.forClass(BooleanData.class); + verify(mmo).setData(eq(ItemStats.TWO_HANDED), flag.capture()); + assertTrue(flag.getValue().isEnabled()); + + MMOItem plain = mock(MMOItem.class); + GearTemplateSync.apply(plain, nbt); + verify(plain).setData(eq(ItemStats.REQUIRED_CLASS), any()); + } + + @Test + void applyRemovesWhatTheTemplateNoLongerHas() { + template(List.of(), null); + MMOItem mmo = mock(MMOItem.class); + GearTemplateSync.apply(mmo, nbt); + verify(mmo).removeData(ItemStats.REQUIRED_CLASS); + verify(mmo).removeData(ItemStats.TWO_HANDED); + verify(mmo, never()).setData(any(), any()); + } + + @Test + void applySkipsWeaponsWithoutATemplate() { + MMOItem mmo = mock(MMOItem.class); + GearTemplateSync.apply(mmo, null); + when(nbt.hasType()).thenReturn(false); + GearTemplateSync.apply(mmo, nbt); + verifyNoInteractions(mmo); + } + + @Test + void twoHandedReadsEveryTemplateShape() { + MMOItemTemplate template = mock(MMOItemTemplate.class); + when(template.getBaseItemData()).thenReturn(base); + template(null, new RandomBooleanData(1.0)); + assertTrue(GearTemplateSync.twoHanded(template)); + template(null, new RandomBooleanData(0.5)); + assertFalse(GearTemplateSync.twoHanded(template)); + base.put(ItemStats.TWO_HANDED, new BooleanRandom()); + assertTrue(GearTemplateSync.twoHanded(template)); + base.put(ItemStats.TWO_HANDED, new BooleanRandom(false)); + assertFalse(GearTemplateSync.twoHanded(template)); + base.put(ItemStats.TWO_HANDED, mock(RandomStatData.class)); + assertFalse(GearTemplateSync.twoHanded(template)); + base.put(ItemStats.REQUIRED_CLASS, mock(RandomStatData.class)); + item("Mage", false); + assertTrue(GearTemplateSync.isOutdated(stick())); + } + + @Test + void lowerCaseDropsBlanks() { + assertEquals(Set.of("mage", "evoker"), GearTemplateSync.lowerCase(List.of(" Mage", "", "EVOKER ", " "))); + } + + /** A stored boolean that is also template data, as an older MMOItems template could hold. */ + static class BooleanRandom extends BooleanData implements RandomStatData { + BooleanRandom() { + super(true); + } + + BooleanRandom(boolean state) { + super(state); + } + + @Override + public BooleanData randomize(net.Indyuce.mmoitems.api.item.build.MMOItemBuilder builder) { + return this; + } + } +}