From daa6953a41809301181bc8f68e22555811caefc6 Mon Sep 17 00:00:00 2001
From: Dubledice <138730151+Dubledice@users.noreply.github.com>
Date: Wed, 3 Sep 2025 18:13:57 -0400
Subject: [PATCH 1/6] onExpire + Ui Implementation

---
 .../capability/entity/ResourceTracker.java    | 28 +++++-
 .../data/exile_effects/ExileEffect.java       | 56 ++++++++++--
 .../ExileEffectInstanceData.java              |  4 +
 .../data/spells/components/ComponentPart.java | 46 ++++++++++
 .../components/actions/ExileEffectAction.java | 11 ++-
 .../data/spells/spell_classes/SpellCtx.java   | 12 ++-
 .../event_hooks/ontick/OnServerTick.java      | 38 +++++++++
 .../gui/overlays/EffectsOverlay.java          | 37 +++++++-
 .../DataDrivenSpendThresholdSpec.java         | 59 +++++--------
 .../thresholds/SpendThresholdManager.java     | 34 ++++++--
 .../thresholds/SpendThresholdRuntime.java     | 79 +++++++++++++++--
 .../datapack/SpendThresholdDef.java           | 23 ++---
 .../thresholds/ui/ThresholdUiClient.java      | 42 +++++++++
 .../mine_and_slash/mmorpg/DebugHud.java       | 35 ++++++++
 .../registers/client/S2CPacketRegister.java   |  1 +
 .../registers/server/CommandRegister.java     |  2 +
 .../effectdatas/ExilePotionEvent.java         |  4 +
 .../new_commands/DebugCommands.java           | 85 +++++++++++++++++++
 .../vanilla_mc/packets/ThresholdUiPacket.java | 61 +++++++++++++
 .../EntityStatusEffectsData.java              | 71 ++++++++++++----
 .../spend_thresholds/energy_xlvl_wotj.json    |  8 +-
 21 files changed, 647 insertions(+), 89 deletions(-)
 create mode 100644 src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java
 create mode 100644 src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java
 create mode 100644 src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java
 create mode 100644 src/main/java/com/robertx22/mine_and_slash/vanilla_mc/packets/ThresholdUiPacket.java

diff --git a/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
index 5dc7d2a1b..b80800811 100644
--- a/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
+++ b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
@@ -85,7 +85,7 @@ private float total(java.util.Set<ResourceType> types) {
     private final java.util.EnumMap<ResourceType, java.util.Map<String, Float>> keyProgress =
         new java.util.EnumMap<>(ResourceType.class);
 
-        public void clearKey(ResourceType rt, String key) {
+    public void clearKey(ResourceType rt, String key) {
             if (key == null || key.isEmpty()) return;
             var byKey = keyProgress.get(rt);
             if (byKey == null) return;
@@ -119,6 +119,32 @@ public float getKeyProgress(String key, ResourceType rt) {
         return byKey == null ? 0f : byKey.getOrDefault(key, 0f);
     }
 
+    /**
+     * Set the exact cursor value for a specific key/resource.
+     * If value <= EPS the key entry is removed.
+     */
+    public void setKeyProgress(String key, ResourceType rt, float value) {
+        if (key == null || key.isEmpty()) return;
+        var byKey = keyProgress.computeIfAbsent(rt, __ -> new java.util.HashMap<>());
+        float val = Math.max(0f, value);
+        if (val <= EPS) byKey.remove(key); else byKey.put(key, val);
+        if (byKey.isEmpty()) keyProgress.remove(rt);
+    }
+
+    /**
+     * Decrease the cursor by a fixed amount, clamped at zero. Returns the new value.
+     */
+    public float decayKeyProgress(String key, ResourceType rt, float amount) {
+        if (key == null || key.isEmpty() || amount <= 0f) return getKeyProgress(key, rt);
+        var byKey = keyProgress.get(rt);
+        if (byKey == null) return 0f;
+        float cur = byKey.getOrDefault(key, 0f);
+        float next = Math.max(0f, cur - amount);
+        if (next <= EPS) byKey.remove(key); else byKey.put(key, next);
+        if (byKey.isEmpty()) keyProgress.remove(rt);
+        return next;
+    }
+
     /** Optional utility if you want to wipe a resource’s accumulator. */
     public void clear(ResourceType rt) {
         lost.remove(rt);
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
index efcde2d0a..15e9e2ff4 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
@@ -27,6 +27,7 @@
 import com.robertx22.mine_and_slash.uncommon.localization.Words;
 import net.minecraft.ChatFormatting;
 import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.item.Item;
@@ -252,16 +253,61 @@ public void onRemove(LivingEntity target) {
 
             if (data != null) {
                 LivingEntity caster = data.getCaster(target.level());
-                if (caster != null && spell != null) {
+
+                if (caster == null) {
+                    caster = target;
+                }
+                // --- Debug: show expire intent
+                if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE) {
+                    if (target instanceof ServerPlayer sp) {
+                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_onremove_" + GUID(), "[EFFECT][EXPIRE] onRemove(" + GUID() + ") stacks=" + data.stacks + ", ticks_left=" + data.ticks_left + ", infinite=" + data.is_infinite, 200);
+                    }
+                    if (caster instanceof ServerPlayer spc && caster != target) {
+                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spc, "expire_onremove_" + GUID(), "[EFFECT][EXPIRE] Trigger from " + GUID() + " on target " + target.getName().getString(), 200);
+                    }
+                }
+                if (spell != null && caster != null) {
                     SpellCtx ctx = SpellCtx.onExpire(caster, target, data.calcSpell);
+                    // Attach expiring effect id and any per-effect duration overrides carried on the instance
+                    ctx.expiringEffectId = this.GUID();
+                    ctx.onExpireEffectDurationTicks = (data.onExpireEffectDurationTicks == null)
+                            ? java.util.Collections.emptyMap()
+                            : java.util.Collections.unmodifiableMap(data.onExpireEffectDurationTicks);
                     spell.tryActivate(Spell.DEFAULT_EN_NAME, ctx); // source is default name at all times
+                    if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && target instanceof ServerPlayer sp2) {
+                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp2, "expire_dispatched_" + GUID(), "[EFFECT][EXPIRE] Dispatched attached spell for " + GUID(), 400);
+                    }
+
+                    // Apply any leftover datapack-declared on-expire effects that weren't applied by actions (server only)
+                    if (!target.level().isClientSide && data.onExpireEffectDurationTicks != null && !data.onExpireEffectDurationTicks.isEmpty()) {
+                        for (var entry : data.onExpireEffectDurationTicks.entrySet()) {
+                            String effId = entry.getKey();
+                            int durTicks = Math.max(1, entry.getValue());
+                            if (ctx.onExpireApplied != null && ctx.onExpireApplied.contains(effId)) {
+                                continue;
+                            }
+                            var extraEff = com.robertx22.mine_and_slash.database.registry.ExileDB.ExileEffects().get(effId);
+                            if (extraEff != null) {
+                                var unitT = com.robertx22.mine_and_slash.uncommon.datasaving.Load.Unit(target);
+                                var storeT = unitT.getStatusEffectsData();
+                                var instT = storeT.getOrCreate(extraEff);
+                                instT.stacks = Math.max(instT.stacks, 1);
+                                instT.ticks_left = Math.max(instT.ticks_left, durTicks);
+                                instT.is_infinite = false;
+                                instT.caster_uuid = caster.getStringUUID();
+                                try { extraEff.onApply(target); } catch (Exception ignored) {}
+                                unitT.equipmentCache.STATUS.setDirty();
+                                unitT.sync.setDirty();
+                                if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && target instanceof ServerPlayer spx) {
+                                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spx, "expire_extra_" + effId, "[EFFECT][EXPIRE] Extra-applied " + effId + " tl=" + instT.ticks_left, 400);
+                                }
+                            }
+                        }
+                    }
                 }
             }
 
-            EntityData unitdata = Load.Unit(target);
-            unitdata.getStatusEffectsData()
-                    .get(this).stacks = 0;
-            unitdata.equipmentCache.STATUS.setDirty();
+            Load.Unit(target).equipmentCache.STATUS.setDirty();
 
 
         } catch (Exception e) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffectInstanceData.java b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffectInstanceData.java
index 35e1ec449..041b1fb19 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffectInstanceData.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffectInstanceData.java
@@ -9,6 +9,8 @@
 
 import java.text.DecimalFormat;
 import java.util.UUID;
+import java.util.Map;
+import java.util.HashMap;
 
 public class ExileEffectInstanceData {
 
@@ -22,6 +24,8 @@ public class ExileEffectInstanceData {
     public float str_multi = 1;
     public int ticks_left = 0;
 
+    public Map<String, Integer> onExpireEffectDurationTicks = new HashMap<>();
+
     public boolean isSpellNoLongerAllocated(LivingEntity en) {
         if (self_cast) {
             //calcSpell.equals(CalculatedSpellData.NO_SPELL_RELATED) indicate this effect is not related to a spell
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
index a882c79be..d7fa15e83 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
@@ -6,7 +6,9 @@
 import com.robertx22.mine_and_slash.database.data.spells.components.selectors.TargetSelector;
 import com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField;
 import com.robertx22.mine_and_slash.database.data.spells.spell_classes.SpellCtx;
+import com.robertx22.mine_and_slash.mmorpg.DebugHud;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.server.level.ServerPlayer;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -131,6 +133,50 @@ public void tryActivate(SpellCtx ctx) {
                 System.out.print(part.type + " action is null");
             } else {
                 action.tryActivate(list, ctx, part);
+                if (DebugHud.ON_EXPIRE
+                        && ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE) {
+                    if (ctx.caster instanceof ServerPlayer spc) {
+                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spc, "expire_action_" + part.type, "[EFFECT][EXPIRE] Action=" + part.type + " targets=" + list.size(), 400);
+                    }
+                }
+
+                // Fallback: if ON_EXPIRE exile_effects still don't appear, apply directly here
+                if (!ctx.world.isClientSide && ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE
+                        && part.type.equals(SpellAction.EXILE_EFFECT.GUID())) {
+                    try {
+                        String effId = part.get(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.EXILE_POTION_ID);
+                        Double durD = part.getOrDefault(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.POTION_DURATION, 0D);
+                        Double cntD = part.getOrDefault(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.COUNT, 1D);
+                        int duration = Math.max(1, durD.intValue());
+                        // If override present from datapack, prefer it
+                        if (ctx.onExpireEffectDurationTicks != null && ctx.onExpireEffectDurationTicks.containsKey(effId)) {
+                            int override = ctx.onExpireEffectDurationTicks.get(effId);
+                            if (override > 0) {
+                                duration = override;
+                            }
+                        }
+                        int stacks = Math.max(1, cntD.intValue());
+                        var effect = com.robertx22.mine_and_slash.database.registry.ExileDB.ExileEffects().get(effId);
+                        if (effect != null) {
+                            for (LivingEntity tgt : list) {
+                                var unit = com.robertx22.mine_and_slash.uncommon.datasaving.Load.Unit(tgt);
+                                var store = unit.getStatusEffectsData();
+                                var inst = store.getOrCreate(effect);
+                                inst.stacks = Math.max(inst.stacks, stacks);
+                                inst.ticks_left = Math.max(inst.ticks_left, duration);
+                                inst.is_infinite = false;
+                                inst.caster_uuid = ctx.caster.getStringUUID();
+                                try { effect.onApply(tgt); } catch (Exception ignored) {}
+                                unit.equipmentCache.STATUS.setDirty();
+                                unit.sync.setDirty();
+                                if (ctx.caster instanceof ServerPlayer spc) {
+                                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spc, "expire_fallback_direct_" + effId, "[EFFECT][EXPIRE] Direct-applied " + effId + " tl=" + inst.ticks_left + " x" + inst.stacks, 400);
+                                }
+                            }
+                            ctx.onExpireApplied.add(effId);
+                        }
+                    } catch (Exception ignored) {}
+                }
             }
         }
 
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
index ceed92427..c9485d77e 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
@@ -59,6 +59,10 @@ public void tryActivate(Collection<LivingEntity> targets, SpellCtx ctx, MapHolde
             targets.forEach(t -> {
 
                 if (RandomUtils.roll(chance)) {
+                    // If ON_EXPIRE, ComponentPart handles direct application to avoid same-tick races
+                    if (ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE) {
+                        return; // no-op here; handled upstream
+                    }
                     ExilePotionEvent potionEvent = EventBuilder.ofEffect(ctx.calculatedSpellData, ctx.caster, t, Load.Unit(ctx.caster)
                                     .getLevel(), potion, action.getOther(), duration, infinite)
                             .setSpell(ctx.calculatedSpellData.getSpell())
@@ -68,7 +72,12 @@ public void tryActivate(Collection<LivingEntity> targets, SpellCtx ctx, MapHolde
                     potionEvent.spellid = ctx.calculatedSpellData.getSpell()
                             .GUID();
 
-                    potionEvent.Activate();
+                    // Normal path for non-ON_EXPIRE contexts
+                    try {
+                        potionEvent.Activate();
+                    } catch (Exception ex) {
+                        throw ex;
+                    }
                 }
 
             });
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/spell_classes/SpellCtx.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/spell_classes/SpellCtx.java
index 12389ec60..677cab702 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/spell_classes/SpellCtx.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/spell_classes/SpellCtx.java
@@ -29,6 +29,11 @@ public class SpellCtx {
     public CalculatedSpellData calculatedSpellData;
 
 
+    public String expiringEffectId = null;
+    public java.util.Map<String, Integer> onExpireEffectDurationTicks = java.util.Collections.emptyMap();
+    public java.util.Set<String> onExpireApplied = new java.util.HashSet<>();
+
+
     public SpellCtx setSourceEntity(Entity en) {
         this.sourceEntity = en;
         return this;
@@ -103,7 +108,12 @@ public static SpellCtx onExpire(LivingEntity caster, Entity sourceEntity, Calcul
         Objects.requireNonNull(sourceEntity);
         Objects.requireNonNull(data);
         LivingEntity target = sourceEntity instanceof LivingEntity ? (LivingEntity) sourceEntity : null;
-        return new SpellCtx(EntityActivation.ON_EXPIRE, sourceEntity, caster, target, data);
+        SpellCtx ctx = new SpellCtx(EntityActivation.ON_EXPIRE, sourceEntity, caster, target, data);
+        if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE
+                && caster instanceof net.minecraft.server.level.ServerPlayer sp) {
+            sp.sendSystemMessage(net.minecraft.network.chat.Component.literal("[EFFECT][EXPIRE] Ctx built; caster=" + caster.getName().getString() + ", target=" + (target == null ? "null" : target.getName().getString())));
+        }
+        return ctx;
     }
 
     public static SpellCtx onTick(LivingEntity caster, Entity sourceEntity, CalculatedSpellData data) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
index e65b65747..a0de8f541 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
@@ -18,6 +18,7 @@
 import com.robertx22.mine_and_slash.uncommon.utilityclasses.LevelUtils;
 import com.robertx22.mine_and_slash.uncommon.utilityclasses.WorldUtils;
 import com.robertx22.mine_and_slash.vanilla_mc.packets.MapCompletePacket;
+import com.robertx22.mine_and_slash.vanilla_mc.packets.ThresholdUiPacket;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
@@ -128,6 +129,43 @@ public static void onEndTick(ServerPlayer player) {
                     playerData.spellCastingData.charges.onTicks(player, 5);
                 }
 
+                // Every second, apply passive decay to inactive threshold progress
+                if (age % 20 == 0) {
+                    long now = player.level().getGameTime();
+                    var unit = Load.Unit(player);
+                    if (unit != null) {
+                        // Iterate only active keys per resource
+                        for (var rt : com.robertx22.mine_and_slash.saveclasses.unit.ResourceType.values()) {
+                            for (var key : unit.getSpendRuntime().getActiveKeys(rt)) {
+                                var spec = unit.getSpendRuntime().getSpec(key);
+                                if (!spec.showUi()) continue;
+                                long lastAct = unit.getSpendRuntime().getLastActivity(key);
+                                if (lastAct <= 0) continue;
+                                long since = now - lastAct;
+                                if (since < 300) continue; // < 15s
+
+                                long lastDecay = unit.getSpendRuntime().getLastDecay(key);
+                                if (lastDecay == now) continue; // already decayed this second
+                                unit.getSpendRuntime().markDecay(key, now);
+
+                                // Decay rate: 15% of this threshold's breakpoint per second
+                                float thr = spec.thresholdFor(unit);
+                                if (thr <= 0f) continue;
+                                float decayPerSecond = thr * 0.15f;
+                                float newVal = unit.getResourceTracker().decayKeyProgress(key, rt, decayPerSecond);
+                                int cint = (int) newVal;
+                                if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
+                                    com.robertx22.library_of_exile.main.Packets.sendToClient(player,
+                                        new ThresholdUiPacket(key, rt.id, newVal > 0f, newVal));
+                                }
+                                if (newVal <= 0f) {
+                                    unit.getSpendRuntime().removeActive(rt, key);
+                                }
+                            }
+                        }
+                    }
+                }
+
                 if (player.containerMenu instanceof CraftingStationMenu men) {
                     if (player.tickCount % 5 == 0) {
                         men.be.onTickWhenPlayerWatching(player);
diff --git a/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java b/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java
index 9a75266d3..3042e4332 100644
--- a/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java
+++ b/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java
@@ -34,7 +34,7 @@ public static void render(GuiGraphics gui, boolean horizontal) {
         // Minecraft mc = Minecraft.getInstance();
 
         for (Map.Entry<String, ExileEffectInstanceData> en : Load.Unit(p).getStatusEffectsData().exileMap.entrySet()) {
-            if (!en.getValue().shouldRemove()) {
+            if (!en.getValue().shouldRemove() && !shouldHideLeeching(en.getKey())) {
                 var eff = ExileDB.ExileEffects().get(en.getKey());
 
                 gui.blit(SlashRef.guiId("effect/effect_bg"), x, y, bgX, bgY, 0, 0, bgX, bgY, bgX, bgY);
@@ -58,5 +58,40 @@ public static void render(GuiGraphics gui, boolean horizontal) {
             }
         }
 
+        // Render threshold UI items inline with effects (uses same bg/overlay)
+        var thresholdMap = com.robertx22.mine_and_slash.mechanics.thresholds.ui.ThresholdUiClient.visibleEntries();
+        if (!thresholdMap.isEmpty()) {
+            for (var e : thresholdMap.entrySet()) {
+                String key = e.getKey();
+                String resId = e.getValue();
+                var rt = com.robertx22.mine_and_slash.saveclasses.unit.ResourceType.ofId(resId);
+                if (rt == null) continue;
+
+                // draw frame same as effects
+                gui.blit(SlashRef.guiId("effect/effect_bg"), x, y, bgX, bgY, 0, 0, bgX, bgY, bgX, bgY);
+                gui.blit(SlashRef.guiId("effect/effect_overlay"), x, y, bgX, bgY, 0, 0, bgX, bgY, bgX, bgY);
+
+                // show 0..threshold progress, not current resource value
+                float prog = com.robertx22.mine_and_slash.mechanics.thresholds.ui.ThresholdUiClient.getProgress(key);
+                GuiUtils.renderScaledText(gui, (int) x + 10, (int) y + 10, 0.7F, String.valueOf((int) prog), ChatFormatting.YELLOW);
+
+                if (horizontal) {
+                    x += bgX;
+                } else {
+                    y += bgY;
+                }
+            }
+        }
+
+    }
+
+    private static boolean shouldHideLeeching(String effectId) {
+        if (effectId == null) {
+            return false;
+        }
+        if (effectId.equals("leeching_state")) {
+            return true;
+        }
+        return effectId.startsWith("leeching_") && effectId.endsWith("_state");
     }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
index ca498f77e..d35e248a9 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
@@ -9,13 +9,12 @@
 
 public class DataDrivenSpendThresholdSpec extends SpendThresholdSpec {
 
-    public enum ThresholdMode { FLAT, PERCENT_OF_MAX }
+    public enum ThresholdMode { X_PER_LEVEL, FLAT, PCT_OF_MAX }
 
     private final ThresholdMode mode;
     private final float value;
     private final boolean multiplyByLevel;
-    @Nullable private final ResourceType percentMaxOf;
-    private final boolean showUi;
+    @Nullable private final ResourceType pctMaxOf;
 
     public DataDrivenSpendThresholdSpec(
             String key,
@@ -23,54 +22,40 @@ public DataDrivenSpendThresholdSpec(
             ThresholdMode mode,
             float value,
             boolean multiplyByLevel,
-            @Nullable ResourceType percentMaxOf,
+            @Nullable ResourceType pctMaxOf,
             Set<String> lockWhileEffectIds,
             int cooldownTicks,
             boolean lockWhileCooldown,
             boolean dropProgressWhileLocked,
-            boolean resetProgressOnProc,
-            boolean showUi
+            boolean resetProgressOnProc
     ) {
-        super(resource, 0f, key,
-              lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, resetProgressOnProc, showUi);
+        super(resource, /*perLevelFactor (unused)*/ 0f, key,
+              lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, resetProgressOnProc);
         this.mode = mode;
         this.value = value;
         this.multiplyByLevel = multiplyByLevel;
-        this.percentMaxOf = percentMaxOf;
-        this.showUi = showUi;
-    }
-
-    // Backward-compatible ctor (defaults showUi=false)
-    public DataDrivenSpendThresholdSpec(
-            String key,
-            ResourceType resource,
-            ThresholdMode mode,
-            float value,
-            boolean multiplyByLevel,
-            @Nullable ResourceType percentMaxOf,
-            Set<String> lockWhileEffectIds,
-            int cooldownTicks,
-            boolean lockWhileCooldown,
-            boolean dropProgressWhileLocked,
-            boolean resetProgressOnProc
-    ) {
-        this(key, resource, mode, value, multiplyByLevel, percentMaxOf, lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, resetProgressOnProc, false);
+        this.pctMaxOf = pctMaxOf;
     }
 
     @Override
     public float thresholdFor(EntityData unit) {
         float base;
         switch (mode) {
-            case PERCENT_OF_MAX -> {
-                // default to this spec's resource if percentOf is null
-                ResourceType tgt = (percentMaxOf != null) ? percentMaxOf : resource();
-                float max = unit.getResources().getMax(unit.getEntity(), tgt);
+            case X_PER_LEVEL:
+                base = value * Math.max(1, unit.getLevel());
+                break;
+            case FLAT:
+                base = value * (multiplyByLevel ? Math.max(1, unit.getLevel()) : 1f);
+                break;
+            case PCT_OF_MAX:
+                ResourceType rt = (pctMaxOf != null) ? pctMaxOf : resource();
+                float max = unit.getResources().getMax(unit.getEntity(), rt);
                 base = (value / 100f) * max;
-            }
-            case FLAT -> base = value;
-            default -> base = value;
+                if (multiplyByLevel) base *= Math.max(1, unit.getLevel());
+                break;
+            default:
+                base = 0f;
         }
-        if (multiplyByLevel) base *= Math.max(1, unit.getLevel());
         return Math.max(0f, base);
     }
 
@@ -78,8 +63,4 @@ public float thresholdFor(EntityData unit) {
     public void onProc(ServerPlayer sp, int procs) {
         // No default action here; datapack loader wires actions.
     }
-
-    public boolean showUi() { return showUi; }
-
-    // Perk lock is handled by callers (anonymous subclass) when needed.
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
index 39cc5beb2..2888c3032 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
@@ -2,6 +2,7 @@
 
 import com.robertx22.mine_and_slash.capability.entity.EntityData;
 import com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost;
+import com.robertx22.mine_and_slash.vanilla_mc.packets.ThresholdUiPacket;
 import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType;
 import net.minecraft.server.level.ServerPlayer;
 
@@ -44,7 +45,10 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                     tracker.clearKey(type, key);
                 }
                 if (debug) {
-                    sp.sendSystemMessage(net.minecraft.network.chat.Component.literal("[SPEND:" + spec.key() + "] locked by cooldown"));
+                    long rem = unit.getSpendRuntime().cooldownRemainingTicks(key, now);
+                    sp.sendSystemMessage(net.minecraft.network.chat.Component.literal(
+                        "[SPEND:" + spec.key() + "] locked by cooldown (" + rem + "t ~ " + fmtSec((float) rem) + "s)"
+                    ));
                 }
                 continue;
             }
@@ -57,7 +61,10 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 if (debug) {
                     sp.sendSystemMessage(net.minecraft.network.chat.Component.literal("[SPEND:" + spec.key() + "] locked"));
                 }
-                // UI updates omitted (packet not included in this commit)
+                // hide UI while locked
+                if (spec.showUi()) {
+                    com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
+                }
                 continue;
             }
 
@@ -66,7 +73,10 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
             if (threshold <= 0f) continue;
 
             int procs = tracker.addAndConsumeForKey(key, type, loss, threshold);
-            // activity tracking omitted for compatibility
+            if (loss > 0f && procs == 0) {
+                unit.getSpendRuntime().markActivity(key, now);
+                unit.getSpendRuntime().markActive(type, key, spec);
+            }
             if (procs > 0) {
                 spec.onProc(sp, procs);
                 spec.startCooldown(unit, now);
@@ -74,13 +84,26 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                     tracker.clearKey(type, key);
                 }
                 if (debug) dbg(sp, "[SPEND:" + spec.key() + "] " + type.id + " ×" + procs + " (thr=" + fmt(threshold) + ")");
-                // UI/active tracking omitted
+                // hide UI on proc
+                if (spec.showUi()) {
+                    com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
+                }
+                unit.getSpendRuntime().removeActive(type, key);
             } else {
                 float cur = tracker.getKeyProgress(key, type);
                 if (debug) {
                     dbg(sp, "[SPEND:" + spec.key() + "] +" + fmt(loss) + " " + type.id + " (cur=" + fmt(cur) + " / " + fmt(threshold) + ")");
                 }
-                // UI/active tracking omitted
+                if (spec.showUi()) {
+                    int cint = (int) cur;
+                    if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
+                        boolean show = cur > 0f;
+                        com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, show, cur));
+                    }
+                }
+                if (cur <= 0f) {
+                    unit.getSpendRuntime().removeActive(type, key);
+                }
             }
         }
     }
@@ -91,4 +114,5 @@ private static void dbg(ServerPlayer sp, String msg) {
         sp.sendSystemMessage(net.minecraft.network.chat.Component.literal(msg));
     }
     private static String fmt(float v) { return String.format(java.util.Locale.US, "%.1f", v); }
+    private static String fmtSec(float s) { return String.format(java.util.Locale.US, "%.1f", s); }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
index 4273a4a1e..d8d6916a9 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
@@ -1,19 +1,35 @@
 package com.robertx22.mine_and_slash.mechanics.thresholds;
 
+import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType;
+
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
 public class SpendThresholdRuntime {
     // gameTime (ticks) when each key’s cooldown ends
     private final Map<String, Long> cooldownUntil = new HashMap<>();
 
-    /** Start/refresh cooldown for a key. */
+    // last activity tick for each threshold key (progress added)
+    private final Map<String, Long> lastActivityTick = new HashMap<>();
+
+    // last decay tick applied for each key (so we decay at most once per second)
+    private final Map<String, Long> lastDecayTick = new HashMap<>();
+
+    // last integer progress sent to client (to throttle network updates)
+    private final Map<String, Integer> lastProgressIntSent = new HashMap<>();
+
+    // Index of active threshold keys by resource (only keys with progress > 0 or recently updated)
+    private final java.util.EnumMap<ResourceType, Set<String>> activeByResource = new java.util.EnumMap<>(ResourceType.class);
+    // Quick lookup of spec by key (used for decay threshold value)
+    private final Map<String, SpendThresholdSpec> specByKey = new HashMap<>();
+
     public void startCooldown(String key, long now, int cooldownTicks) {
         if (cooldownTicks <= 0) return;
         cooldownUntil.put(key, now + cooldownTicks);
     }
 
-    /** True if now is still before the stored end time. */
     public boolean isCoolingDown(String key, long now) {
         Long until = cooldownUntil.get(key);
         return until != null && now < until;
@@ -27,8 +43,61 @@ public int cooldownRemainingTicks(String key, long now) {
         return (int) Math.max(0, rem);
     }
 
-    /** Clear a key’s cooldown (optional utility). */
-    public void clearCooldown(String key) {
-        cooldownUntil.remove(key);
+    // === Activity/Decay tracking ===
+    public void markActivity(String key, long now) {
+        if (key == null || key.isEmpty()) return;
+        lastActivityTick.put(key, now);
+        lastDecayTick.remove(key);
+    }
+
+    public long getLastActivity(String key) {
+        return lastActivityTick.getOrDefault(key, 0L);
+    }
+
+    public long getLastDecay(String key) {
+        return lastDecayTick.getOrDefault(key, 0L);
+    }
+
+    public void markDecay(String key, long now) {
+        if (key == null || key.isEmpty()) return;
+        lastDecayTick.put(key, now);
+    }
+
+    public boolean progressIntChanged(String key, int intProgress) {
+        Integer prev = lastProgressIntSent.get(key);
+        if (prev == null || prev.intValue() != intProgress) {
+            lastProgressIntSent.put(key, intProgress);
+            return true;
+        }
+        return false;
+    }
+
+    // === Active key index ===
+    public void markActive(ResourceType rt, String key, SpendThresholdSpec spec) {
+        if (rt == null || key == null || key.isEmpty() || spec == null) return;
+        activeByResource.computeIfAbsent(rt, __ -> new HashSet<>()).add(key);
+        specByKey.put(key, spec);
+    }
+
+    public void removeActive(ResourceType rt, String key) {
+        if (rt == null || key == null || key.isEmpty()) return;
+        var set = activeByResource.get(rt);
+        if (set != null) {
+            set.remove(key);
+            if (set.isEmpty()) activeByResource.remove(rt);
+        }
+        specByKey.remove(key);
+        lastActivityTick.remove(key);
+        lastDecayTick.remove(key);
+        lastProgressIntSent.remove(key);
+    }
+
+    public Set<String> getActiveKeys(ResourceType rt) {
+        var s = activeByResource.get(rt);
+        return s == null ? java.util.Set.of() : java.util.Set.copyOf(s);
+    }
+
+    public SpendThresholdSpec getSpec(String key) {
+        return specByKey.get(key);
     }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java
index 7af2dc981..1cd3a7ffb 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java
@@ -57,13 +57,17 @@ public SpendThresholdSpec toSpec() {
         // Modes supported: FLAT (optionally with multiply_by_level) or PERCENT_OF_MAX
         String rawMode = (threshold.mode == null ? "FLAT" : threshold.mode.trim()).toUpperCase(Locale.ROOT);
         boolean mult = threshold.multiplyByLevel;
-        DataDrivenSpendThresholdSpec.ThresholdMode mode =
-                "PERCENT_OF_MAX".equals(rawMode)
-                        ? DataDrivenSpendThresholdSpec.ThresholdMode.PERCENT_OF_MAX
-                        : DataDrivenSpendThresholdSpec.ThresholdMode.FLAT; // default + treats legacy values as FLAT
+        DataDrivenSpendThresholdSpec.ThresholdMode mode;
+        if ("PERCENT_OF_MAX".equals(rawMode)) {
+            mode = DataDrivenSpendThresholdSpec.ThresholdMode.PCT_OF_MAX;
+        } else if ("X_PER_LEVEL".equals(rawMode)) {
+            mode = DataDrivenSpendThresholdSpec.ThresholdMode.X_PER_LEVEL;
+        } else {
+            mode = DataDrivenSpendThresholdSpec.ThresholdMode.FLAT; // default + treats legacy values as FLAT
+        }
 
         ResourceType percentOf = null;
-        if (mode == DataDrivenSpendThresholdSpec.ThresholdMode.PERCENT_OF_MAX
+        if (mode == DataDrivenSpendThresholdSpec.ThresholdMode.PCT_OF_MAX
                 && threshold.percentOf != null && !threshold.percentOf.isEmpty()) {
             percentOf = parseResource(threshold.percentOf, res); // default to this spec’s resource if bad input
         }
@@ -82,8 +86,7 @@ public SpendThresholdSpec toSpec() {
                 cooldownTicks,
                 locks != null && locks.lockWhileCooldown,
                 locks != null && locks.dropProgressWhileLocked,
-                locks != null && locks.resetProgressOnProc,
-                showUi
+                locks != null && locks.resetProgressOnProc
         ) {
             @Override
             public void onProc(ServerPlayer sp, int procs) {
@@ -102,7 +105,7 @@ public void onProc(ServerPlayer sp, int procs) {
                     var inst = EffectUtils.applyEffect(sp, effect, durTicks, stacks);
 
                     // Attach on-expire duration overrides (ticks directly)
-                    /*if (a.onExpire != null && !a.onExpire.isEmpty()) {
+                    if (a.onExpire != null && !a.onExpire.isEmpty()) {
                         if (inst.onExpireEffectDurationTicks == null) {
                             inst.onExpireEffectDurationTicks = new java.util.HashMap<>();
                         }
@@ -112,7 +115,7 @@ public void onProc(ServerPlayer sp, int procs) {
                                 inst.onExpireEffectDurationTicks.put(e.getKey(), ticks);
                             }
                         }
-                    }*/ // TODO: Add back in when onExpire is implemented
+                    }
 
                 }
             }
@@ -128,7 +131,7 @@ public boolean isLockedFor(EntityData unit) {
                 }
                 return false;
             }
-        }.withPriority(priority);
+        }.withPriority(priority).withShowUi(showUi);
     }
 
     // --- helpers ---
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java
new file mode 100644
index 000000000..11c24f0f7
--- /dev/null
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java
@@ -0,0 +1,42 @@
+package com.robertx22.mine_and_slash.mechanics.thresholds.ui;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/** Client-only holder for which threshold keys should currently render, their resource ids, and progress. */
+public final class ThresholdUiClient {
+    private ThresholdUiClient() {}
+
+    private static final Map<String, String> keyToResource = new HashMap<>();
+    private static final Map<String, Float> keyToProgress = new HashMap<>();
+
+    public static void applyUpdate(String key, String resourceId, boolean show) {
+        if (key == null || key.isEmpty()) return;
+        if (show) {
+            keyToResource.put(key, resourceId == null ? "" : resourceId);
+        } else {
+            keyToResource.remove(key);
+            keyToProgress.remove(key);
+        }
+    }
+
+    public static void setProgress(String key, float progress) {
+        if (key == null || key.isEmpty()) return;
+        keyToProgress.put(key, Math.max(0f, progress));
+    }
+
+    public static float getProgress(String key) {
+        return keyToProgress.getOrDefault(key, 0f);
+    }
+
+    public static boolean isVisible(String key) {
+        return keyToResource.containsKey(key);
+    }
+
+    public static Map<String, String> visibleEntries() {
+        return Collections.unmodifiableMap(keyToResource);
+    }
+}
+
+
diff --git a/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java b/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java
new file mode 100644
index 000000000..0fd3e7dbd
--- /dev/null
+++ b/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java
@@ -0,0 +1,35 @@
+package com.robertx22.mine_and_slash.mmorpg;
+
+/**
+ * Central debug HUD/flags. Toggle via commands or config as needed.
+ * Keep flags conservative (default false) unless explicitly enabled.
+ */
+public final class DebugHud {
+
+    private DebugHud() {}
+
+    // Unified flags
+    public static volatile boolean ON_EXPIRE = false;
+
+    // Simple per-player throttling to avoid spammy chat when debugging
+    private static final java.util.concurrent.ConcurrentHashMap<String, Long> LAST_MSG_MS = new java.util.concurrent.ConcurrentHashMap<>();
+
+    public static void send(net.minecraft.server.level.ServerPlayer sp, String key, String msg) {
+        send(sp, key, msg, 500); // default 0.5s throttle per key
+    }
+
+    public static void send(net.minecraft.server.level.ServerPlayer sp, String key, String msg, int minIntervalMs) {
+        if (sp == null) return;
+        long now = System.currentTimeMillis();
+        String k = sp.getUUID().toString() + ":" + key;
+        Long last = LAST_MSG_MS.get(k);
+        if (last != null && (now - last) < Math.max(0, minIntervalMs)) {
+            return;
+        }
+        LAST_MSG_MS.put(k, now);
+        sp.sendSystemMessage(net.minecraft.network.chat.Component.literal(msg));
+    }
+
+}
+
+
diff --git a/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/client/S2CPacketRegister.java b/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/client/S2CPacketRegister.java
index 4da55e2ff..c31b28e26 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/client/S2CPacketRegister.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/client/S2CPacketRegister.java
@@ -33,6 +33,7 @@ public static void register() {
         Packets.registerServerToClient(MMORPG.NETWORK, new MapCompletePacket(), i++);
         Packets.registerServerToClient(MMORPG.NETWORK, new OpenEntityStatsReplyPacket(), i++);
 
+        Packets.registerServerToClient(MMORPG.NETWORK, new ThresholdUiPacket(), i++);
 
     }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/server/CommandRegister.java b/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/server/CommandRegister.java
index 7107e06d6..695cfc572 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/server/CommandRegister.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mmorpg/registers/server/CommandRegister.java
@@ -25,6 +25,7 @@
 import com.robertx22.mine_and_slash.vanilla_mc.commands.stats.GiveStat;
 import com.robertx22.mine_and_slash.vanilla_mc.commands.stats.ListStats;
 import com.robertx22.mine_and_slash.vanilla_mc.commands.stats.RemoveStat;
+import com.robertx22.mine_and_slash.vanilla_mc.new_commands.DebugCommands;
 import com.robertx22.mine_and_slash.vanilla_mc.new_commands.BuilderToolCommands;
 import com.robertx22.mine_and_slash.vanilla_mc.new_commands.DevCommands;
 import com.robertx22.mine_and_slash.vanilla_mc.new_commands.EntityCommands;
@@ -40,6 +41,7 @@ public static void Register(CommandDispatcher<CommandSourceStack> dispatcher) {
         EntityCommands.init(dispatcher);
         PlayerCommands.init(dispatcher);
         DevCommands.init(dispatcher);
+        DebugCommands.init(dispatcher);
         BuilderToolCommands.reg(dispatcher);
 
         GiveExactUnique.register(dispatcher);
diff --git a/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/ExilePotionEvent.java b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/ExilePotionEvent.java
index 768a78341..8e80885aa 100644
--- a/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/ExilePotionEvent.java
+++ b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/ExilePotionEvent.java
@@ -92,6 +92,10 @@ protected void activate() {
         }
 
         Load.Unit(target).equipmentCache.STATUS.setDirty();
+
+        if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && target instanceof net.minecraft.server.level.ServerPlayer sp) {
+            com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_reapplied_" + effect.GUID(), "[EFFECT][EXPIRE] Reapplied " + effect.GUID() + " ticks_left=" + extraData.ticks_left + " stacks=" + extraData.stacks + " [id=" + System.identityHashCode(extraData) + "]", 400);
+        }
     }
 
 
diff --git a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java
new file mode 100644
index 000000000..c0f7c15b2
--- /dev/null
+++ b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java
@@ -0,0 +1,85 @@
+package com.robertx22.mine_and_slash.vanilla_mc.new_commands;
+
+import com.mojang.brigadier.CommandDispatcher;
+import com.robertx22.library_of_exile.command_wrapper.CommandBuilder;
+import com.robertx22.library_of_exile.command_wrapper.PermWrapper;
+import com.robertx22.library_of_exile.command_wrapper.StringWrapper;
+import com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost;
+import com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceRestore;
+import com.robertx22.mine_and_slash.vanilla_mc.commands.CommandRefs;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.player.Player;
+
+import java.util.List;
+
+public class DebugCommands {
+
+    public static void init(CommandDispatcher<CommandSourceStack> dispatcher) {
+
+        // New unified debug toggle:
+        // /mine_and_slash debug <spend_threshold|resource_restore|onexpire> <true|false|toggle|on|off>
+        CommandBuilder.of(CommandRefs.ID, dispatcher, x -> {
+            StringWrapper SUBJECT = new StringWrapper("subject", () -> List.of("spend_threshold", "resource_restore", "onexpire"));
+            StringWrapper STATE = new StringWrapper("state", () -> List.of("true", "false", "toggle", "on", "off"));
+
+            x.addLiteral("debug", PermWrapper.OP);
+            x.addArg(SUBJECT);
+            x.addArg(STATE);
+
+            x.action(e -> {
+                String subject = SUBJECT.get(e);
+                String state = STATE.get(e);
+
+                // Validate inputs (in addition to tab suggestions)
+                String subjLower = subject == null ? "" : subject.toLowerCase(java.util.Locale.ROOT);
+                String stateLower = state == null ? "" : state.toLowerCase(java.util.Locale.ROOT);
+                boolean subjOk = subjLower.equals("spend_threshold") || subjLower.equals("resource_restore") || subjLower.equals("onexpire");
+                boolean stateOk = stateLower.equals("true") || stateLower.equals("false") || stateLower.equals("toggle") || stateLower.equals("on") || stateLower.equals("off");
+
+                if (!subjOk || !stateOk) {
+                    e.getSource().sendFailure(Component.literal("Usage: /" + CommandRefs.ID + " debug <spend_threshold|resource_restore|onexpire> <true|false|toggle|on|off>"));
+                    return;
+                }
+
+                boolean current;
+                if ("resource_restore".equalsIgnoreCase(subject)) {
+                    current = OnResourceRestore.DEBUG_ENABLED;
+                } else if ("spend_threshold".equalsIgnoreCase(subject)) {
+                    current = OnResourceLost.DEBUG_ENABLED; // spend_threshold
+                } else {
+                    current = com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE;
+                }
+
+                boolean newValue = current;
+                if ("true".equalsIgnoreCase(state) || "on".equalsIgnoreCase(state)) {
+                    newValue = true;
+                } else if ("false".equalsIgnoreCase(state) || "off".equalsIgnoreCase(state)) {
+                    newValue = false;
+                } else if ("toggle".equalsIgnoreCase(state)) {
+                    newValue = !current;
+                }
+
+                if ("resource_restore".equalsIgnoreCase(subject)) {
+                    OnResourceRestore.DEBUG_ENABLED = newValue;
+                } else if ("spend_threshold".equalsIgnoreCase(subject)) {
+                    OnResourceLost.DEBUG_ENABLED = newValue;
+                } else {
+                    com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE = newValue;
+                }
+
+                String label = "resource_restore".equalsIgnoreCase(subject) ? "ResourceRestore" : "spend_threshold".equalsIgnoreCase(subject) ? "SpendThresholds" : "OnExpire";
+                Component msg = Component.literal("[" + label + "] Debug: " + (newValue ? "ON" : "OFF"));
+                CommandSourceStack src = e.getSource();
+                if (src.getEntity() instanceof Player p) {
+                    p.sendSystemMessage(msg);
+                } else {
+                    src.sendSuccess(() -> msg, true);
+                }
+            });
+
+        }, "Toggle debug: /" + CommandRefs.ID + " debug <spend_threshold|resource_restore|onexpire> <true|false|toggle|on|off>");
+    }
+}
+
+
diff --git a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/packets/ThresholdUiPacket.java b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/packets/ThresholdUiPacket.java
new file mode 100644
index 000000000..a721865e8
--- /dev/null
+++ b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/packets/ThresholdUiPacket.java
@@ -0,0 +1,61 @@
+package com.robertx22.mine_and_slash.vanilla_mc.packets;
+
+import com.robertx22.library_of_exile.main.MyPacket;
+import com.robertx22.library_of_exile.packets.ExilePacketContext;
+import com.robertx22.mine_and_slash.mechanics.thresholds.ui.ThresholdUiClient;
+import com.robertx22.mine_and_slash.mmorpg.SlashRef;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+
+public class ThresholdUiPacket extends MyPacket<ThresholdUiPacket> {
+
+    public String key = "";
+    public String resourceId = "";
+    public boolean show = false;
+    public float progress = 0f;
+
+    public ThresholdUiPacket() {
+    }
+
+    public ThresholdUiPacket(String key, String resourceId, boolean show, float progress) {
+        this.key = key == null ? "" : key;
+        this.resourceId = resourceId == null ? "" : resourceId;
+        this.show = show;
+        this.progress = progress;
+    }
+
+    @Override
+    public ResourceLocation getIdentifier() {
+        return new ResourceLocation(SlashRef.MODID, "threshold_ui");
+    }
+
+    @Override
+    public void loadFromData(FriendlyByteBuf buf) {
+        this.key = buf.readUtf(256);
+        this.resourceId = buf.readUtf(64);
+        this.show = buf.readBoolean();
+        this.progress = buf.readFloat();
+    }
+
+    @Override
+    public void saveToData(FriendlyByteBuf buf) {
+        buf.writeUtf(key);
+        buf.writeUtf(resourceId);
+        buf.writeBoolean(show);
+        buf.writeFloat(progress);
+    }
+
+    @Override
+    public void onReceived(ExilePacketContext ctx) {
+        ThresholdUiClient.applyUpdate(key, resourceId, show);
+        if (show) {
+            ThresholdUiClient.setProgress(key, progress);
+        }
+    }
+
+    @Override
+    public MyPacket<ThresholdUiPacket> newInstance() {
+        return new ThresholdUiPacket();
+    }
+}
+
diff --git a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java
index 19b9007a6..262e80fb2 100644
--- a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java
+++ b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java
@@ -35,43 +35,80 @@ public void tick(LivingEntity en) {
         exileMap.entrySet().removeIf(x -> !ExileDB.ExileEffects().isRegistered(x.getKey()));
 
         for (Map.Entry<String, ExileEffectInstanceData> e : exileMap.entrySet()) {
-            e.getValue().ticks_left--;
+            ExileEffectInstanceData inst = e.getValue();
+            // Clamp to prevent negative countdowns
+            if (inst.ticks_left > 0) {
+                inst.ticks_left = inst.ticks_left - 1;
+            } else if (inst.ticks_left < 0) {
+                inst.ticks_left = 0;
+            }
             ExileEffect eff = ExileDB.ExileEffects().get(e.getKey());
             if (eff != null) {
-                eff.onTick(en, e.getValue());
+                eff.onTick(en, inst);
             }
         }
 
 
         // todo this is probably bit laggy per tick no?
-        List<ExileEffect> removed = new ArrayList<>();
+        List<ExileEffect> toCallOnRemove = new ArrayList<>();
+        List<String> toDeleteKeys = new ArrayList<>();
 
         if (en.tickCount % 80 == 0) {
             // Prevent keeping e.g. auras and stances after respeccing
             // Has to string compare spell UUIDs to look up the new spell level, so it's done infrequently
-            exileMap.entrySet().removeIf(x -> {
-                if (x.getValue().shouldRemove() || x.getValue().isSpellNoLongerAllocated(en)) {
-                    removed.add(ExileDB.ExileEffects().get(x.getKey()));
-                    return true;
+            for (Map.Entry<String, ExileEffectInstanceData> entry : exileMap.entrySet()) {
+                boolean shouldDrop = entry.getValue().shouldRemove() || entry.getValue().isSpellNoLongerAllocated(en);
+                if (shouldDrop) {
+                    ExileEffect eff = ExileDB.ExileEffects().get(entry.getKey());
+                    if (eff != null) {
+                        // Fire onRemove immediately for this key
+                        eff.onRemove(en);
+                        // Decide deletion based on current state after onRemove
+                        ExileEffectInstanceData inst = exileMap.get(entry.getKey());
+                        if (inst == null || inst.shouldRemove()) {
+                            toDeleteKeys.add(entry.getKey());
+                        } else if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
+                            com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_kept_" + entry.getKey(), "[EFFECT][EXPIRE] Kept " + entry.getKey() + " after onRemove (ticks_left=" + inst.ticks_left + ")", 400);
+                        }
+                    }
                 }
-                return false;
-            });
+            }
         } else {
-            exileMap.entrySet().removeIf(x -> {
-                if (x.getValue().shouldRemove()) {
-                    removed.add(ExileDB.ExileEffects().get(x.getKey()));
-                    return true;
+            for (Map.Entry<String, ExileEffectInstanceData> entry : exileMap.entrySet()) {
+                if (entry.getValue().shouldRemove()) {
+                    ExileEffect eff = ExileDB.ExileEffects().get(entry.getKey());
+                    if (eff != null) {
+                        // Fire onRemove immediately for this key
+                        eff.onRemove(en);
+                        ExileEffectInstanceData inst = exileMap.get(entry.getKey());
+                        if (inst == null || inst.shouldRemove()) {
+                            toDeleteKeys.add(entry.getKey());
+                        } else if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
+                            com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_kept_" + entry.getKey(), "[EFFECT][EXPIRE] Kept " + entry.getKey() + " after onRemove (ticks_left=" + inst.ticks_left + ")", 400);
+                        }
+                    }
                 }
-                return false;
-            });
+            }
         }
 
-        for (ExileEffect eff : removed) {
-            eff.onRemove(en);
+
+
+        // Now delete expired effects (evaluated after onRemove)
+        for (String key : toDeleteKeys) {
+            ExileEffectInstanceData current = exileMap.remove(key);
+            if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
+                if (current != null) {
+                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (ticks_left=" + current.ticks_left + ", stacks=" + current.stacks + ") [id=" + System.identityHashCode(current) + "]", 200);
+                } else {
+                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (no current instance)", 200);
+                }
+            }
         }
 
     }
 
+    // Removed: processDeferredApplies; no deferral now
+
     public boolean has(ExileEffect eff) {
         return this.exileMap.containsKey(eff.GUID()) && !exileMap.get(eff.GUID()).shouldRemove();
     }
diff --git a/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json b/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json
index b58cea578..2ed7dbd4c 100644
--- a/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json
+++ b/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json
@@ -9,11 +9,11 @@
       "value": 10,
       "multiply_by_level": true
     },
-    "cooldown_seconds": 20,
+    "cooldown_ticks": 0,
     "require_stat": "unlock_wotj",
     "locks": {
       "effects": ["wrath_of_the_juggernaut", "burnout"],
-      "lock_while_cooldown": true,
+      "lock_while_cooldown": false,
       "drop_progress_while_locked": true,
       "reset_progress_on_proc": true
     },
@@ -21,10 +21,10 @@
       {
         "action": "exile_effect",
         "exile_potion_id": "wrath_of_the_juggernaut",
-        "duration_seconds": 10,
+        "duration_ticks": 200,
         "stacks": 1,
         "on_expire": {
-          "burnout": 10
+          "burnout": 200
         }
       }
     ]

From 66fedf4aef14438c4be8fa49079d808fead361ae Mon Sep 17 00:00:00 2001
From: Dubledice <138730151+Dubledice@users.noreply.github.com>
Date: Thu, 4 Sep 2025 10:08:04 -0400
Subject: [PATCH 2/6] Fixed Certain onCast = consumeEffect

Fixed effect consumption logic for certain effects like Overheat.
---
 .../database/data/spells/components/ComponentPart.java    | 6 ++++++
 .../data/spells/components/actions/ExileEffectAction.java | 8 +++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
index d7fa15e83..e8a57ee2e 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
@@ -141,9 +141,15 @@ public void tryActivate(SpellCtx ctx) {
                 }
 
                 // Fallback: if ON_EXPIRE exile_effects still don't appear, apply directly here
+                // Only applies to GIVE_STACKS to avoid resurrecting effects when JSON intends REMOVE_STACKS
                 if (!ctx.world.isClientSide && ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE
                         && part.type.equals(SpellAction.EXILE_EFFECT.GUID())) {
                     try {
+                        String actionType = part.get(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.POTION_ACTION);
+                        if (actionType == null || !actionType.equals(com.robertx22.mine_and_slash.database.data.spells.components.actions.ExileEffectAction.GiveOrTake.GIVE_STACKS.name())) {
+                            // Skip fallback for non-GIVE actions (e.g., REMOVE_STACKS)
+                            continue;
+                        }
                         String effId = part.get(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.EXILE_POTION_ID);
                         Double durD = part.getOrDefault(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.POTION_DURATION, 0D);
                         Double cntD = part.getOrDefault(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.COUNT, 1D);
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
index c9485d77e..690151e5a 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
@@ -59,9 +59,11 @@ public void tryActivate(Collection<LivingEntity> targets, SpellCtx ctx, MapHolde
             targets.forEach(t -> {
 
                 if (RandomUtils.roll(chance)) {
-                    // If ON_EXPIRE, ComponentPart handles direct application to avoid same-tick races
-                    if (ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE) {
-                        return; // no-op here; handled upstream
+                    // If ON_EXPIRE, skip only GIVE_STACKS (handled upstream to avoid same-tick races),
+                    // but DO allow REMOVE_STACKS so consumptions like Overheat work on entity-expire.
+                    if (ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE
+                            && action == GiveOrTake.GIVE_STACKS) {
+                        return;
                     }
                     ExilePotionEvent potionEvent = EventBuilder.ofEffect(ctx.calculatedSpellData, ctx.caster, t, Load.Unit(ctx.caster)
                                     .getLevel(), potion, action.getOther(), duration, infinite)

From 589ff6412f5000bdecda0dcb0d0930d8541a34ad Mon Sep 17 00:00:00 2001
From: Dubledice <138730151+Dubledice@users.noreply.github.com>
Date: Thu, 4 Sep 2025 14:09:44 -0400
Subject: [PATCH 3/6] Cleanup + Tidy

---
 .../capability/entity/EntityLeechData.java    | 31 ++------------
 .../capability/entity/ResourceTracker.java    | 29 ++-----------
 .../data/exile_effects/ExileEffect.java       | 19 ++++-----
 .../data/spells/components/ComponentPart.java | 26 ++++++------
 .../components/actions/ExileEffectAction.java |  1 -
 .../event_hooks/my_events/EffectUtils.java    | 16 +-------
 .../event_hooks/my_events/OnResourceLost.java |  9 ----
 .../my_events/OnResourceRestore.java          | 41 ++++---------------
 .../event_hooks/ontick/OnServerTick.java      |  7 +---
 .../gui/overlays/EffectsOverlay.java          |  3 --
 .../DataDrivenSpendThresholdSpec.java         | 41 +++++++++----------
 .../thresholds/SpendThresholdManager.java     |  8 +---
 .../thresholds/SpendThresholdRuntime.java     |  8 +---
 .../thresholds/SpendThresholdSpec.java        | 24 ++---------
 .../datapack/SpendThresholdDef.java           | 16 +++-----
 .../thresholds/ui/ThresholdUiClient.java      |  1 -
 .../mine_and_slash/mmorpg/DebugHud.java       |  2 -
 .../new_commands/DebugCommands.java           |  2 -
 .../EntityStatusEffectsData.java              | 21 ++++------
 .../spend_thresholds/25percent_health.json    |  2 +-
 20 files changed, 78 insertions(+), 229 deletions(-)

diff --git a/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityLeechData.java b/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityLeechData.java
index 50a4e71bd..87d7c0bc7 100644
--- a/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityLeechData.java
+++ b/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityLeechData.java
@@ -7,36 +7,20 @@
 import java.util.EnumMap;
 import java.util.Map;
 
-/**
- * Holds pending leech “reservoirs” per resource and applies them once per second.
- *
- * Design notes:
- * - Clamp each reservoir to “≤ 5 seconds worth of per-second cap”.
- * - Drain by the intended ‘take’ (min(reservoir, perSecondCap)), not by what was actually applied,
- *   so duration semantics remain consistent even if the target is capped/full.
- * - Prune tiny leftovers to keep the map small.
- */
 public class EntityLeechData {
 
-    private static final float EPS = 0.1f; // tiny cutoff to treat as zero
+    private static final float EPS = 0.1f;
     private final EnumMap<ResourceType, Float> store = new EnumMap<>(ResourceType.class);
 
-    /** Adds (or subtracts) pending leech for a resource. */
     public void addLeech(ResourceType type, float amount) {
         store.merge(type, amount, Float::sum);
-        // prune tiny / negative leftovers
         if (store.getOrDefault(type, 0f) <= EPS) {
             store.remove(type);
         }
     }
 
-    /**
-     * Called once per second. Applies up to the per-second cap for each resource,
-     * then drains the reservoir by the amount we *intended* to take.
-     */
     public void onSecondUseLeeches(EntityData data) {
 
-        // 1) Clamp stored leech per resource to ≤ 5s of cap (prevents unbounded queues)
         for (Map.Entry<ResourceType, Float> en : store.entrySet()) {
             ResourceType rt = en.getKey();
             float capPercentPerSec = data.getUnit()
@@ -49,7 +33,6 @@ public void onSecondUseLeeches(EntityData data) {
             en.setValue(clamped);
         }
 
-        // 2) Apply per-resource leech once
         for (Map.Entry<ResourceType, Float> entry : store.entrySet()) {
             ResourceType rt   = entry.getKey();
             float reservoir   = entry.getValue();
@@ -62,7 +45,6 @@ public void onSecondUseLeeches(EntityData data) {
             float maxRes       = data.getResources().getMax(data.entity, rt);
             float perSecondCap = capPercentPerSec * maxRes;
 
-            // Intended drain this second (bounded by per-second cap and reservoir)
             float take = Math.min(reservoir, perSecondCap);
             if (take <= EPS) continue;
 
@@ -70,32 +52,25 @@ public void onSecondUseLeeches(EntityData data) {
             final boolean allowFullLeech = data.getUnit()
                 .getCalculatedStat(ResourceStats.LEECH_AT_FULL_HEALTH.get()).getValue() > 0;
 
-            // Apply and get what actually landed
             float applied = data.getResources().restoreAndReturnApplied(
                     data.entity, rt, take,
                     com.robertx22.mine_and_slash.uncommon.effectdatas.rework.RestoreType.leech
             );
 
-            // Full-resource policy:
-            // - Non-health: never persist at full → discard.
-            // - Health: persist only if 'leech_at_full_health' is enabled.
-            // If nothing landed (resource is full), enforce full-resource policy.
-            if (applied <= EPS) { // use EPS to avoid float noise
+            if (applied <= EPS) {
                 boolean keepReservoir =
                     (rt == ResourceType.health) && allowFullLeech; // only health with talent
 
                 if (!keepReservoir) {
                     entry.setValue(0f); // discard reservoir
                 }
-                continue; // skip draining by 'take'
+                continue;
             }
 
 
-            // Normal path: drain by intended 'take' to preserve ≤5s duration
             entry.setValue(reservoir - take);
         }
 
-        // 3) Prune empty entries to keep the map small
         store.entrySet().removeIf(e -> e.getValue() <= EPS);
     }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
index b80800811..544224596 100644
--- a/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
+++ b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
@@ -2,7 +2,7 @@
 
 import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType;
 
-/**
+/*
  * Accumulates resource LOSS per type (spend, drains, damage, etc).
  * Call addLoss(...) whenever a resource actually decreases.
  * Use consumeThresholds(...) / addAndConsumeForKey(...) to fire effects and keep remainder.
@@ -10,21 +10,17 @@
 public class ResourceTracker {
     private static final float EPS = 1e-4f;
 
-    // Global per-resource accumulators (used for simple thresholds or debug)
     private final java.util.EnumMap<ResourceType, Float> lost = new java.util.EnumMap<>(ResourceType.class);
 
-    /** Record an actual decrease in a resource. */
     public void addLoss(ResourceType rt, float amount) {
         if (amount <= 0f) return;
         lost.merge(rt, amount, Float::sum);
     }
 
-    /** Current accumulated loss for a resource. */
     public float getLoss(ResourceType rt) {
         return lost.getOrDefault(rt, 0f);
     }
 
-    /** Consume thresholds for a single resource; keep remainder. */
     public int consumeThresholds(ResourceType type, float threshold) {
         if (threshold <= 0f) return 0;
         float have = lost.getOrDefault(type, 0f);
@@ -38,16 +34,11 @@ public int consumeThresholds(ResourceType type, float threshold) {
         return procs;
     }
 
-    /**
-     * Consume as many full thresholds as available across a set of resources (combined bucket).
-     * Drain is deterministic: the iteration order of the set decides which resource is consumed first.
-     * <p><b>Note:</b> Pass an {@link java.util.EnumSet} to guarantee stable drain order.</p>
-     */
     public int consumeThresholdsAcross(java.util.Set<ResourceType> types, float threshold) {
         if (threshold <= 0f || types == null || types.isEmpty()) return 0;
 
         int procs = 0;
-        // Loop while the combined total can pay for at least one threshold
+
         while (total(types) + EPS >= threshold) {
             float need = threshold;
 
@@ -62,26 +53,23 @@ public int consumeThresholdsAcross(java.util.Set<ResourceType> types, float thre
                     else lost.put(rt, remaining);
                     need -= take;
                 }
-                if (need <= EPS) break; // satisfied this proc
+                if (need <= EPS) break;
             }
             procs++;
         }
 
-        // Prune tiny leftovers just in case
         for (ResourceType rt : types) {
             if (lost.getOrDefault(rt, 0f) <= EPS) lost.remove(rt);
         }
         return procs;
     }
 
-    /** Sum of accumulated losses for the given set. */
     private float total(java.util.Set<ResourceType> types) {
         float sum = 0f;
         for (ResourceType rt : types) sum += lost.getOrDefault(rt, 0f);
         return sum;
     }
 
-    // Per-key cursors so multiple specs on the same resource don't interfere
     private final java.util.EnumMap<ResourceType, java.util.Map<String, Float>> keyProgress =
         new java.util.EnumMap<>(ResourceType.class);
 
@@ -95,7 +83,6 @@ public void clearKey(ResourceType rt, String key) {
             }
         }
 
-    /** Add loss to a specific key’s cursor for this resource and consume thresholds. */
     public int addAndConsumeForKey(String key, ResourceType rt, float add, float threshold) {
         if (key == null || key.isEmpty() || add <= 0f || threshold <= 0f) return 0;
 
@@ -113,16 +100,11 @@ public int addAndConsumeForKey(String key, ResourceType rt, float add, float thr
         return procs;
     }
 
-    /** Read current cursor for debug/UI. */
     public float getKeyProgress(String key, ResourceType rt) {
         var byKey = keyProgress.get(rt);
         return byKey == null ? 0f : byKey.getOrDefault(key, 0f);
     }
 
-    /**
-     * Set the exact cursor value for a specific key/resource.
-     * If value <= EPS the key entry is removed.
-     */
     public void setKeyProgress(String key, ResourceType rt, float value) {
         if (key == null || key.isEmpty()) return;
         var byKey = keyProgress.computeIfAbsent(rt, __ -> new java.util.HashMap<>());
@@ -131,9 +113,6 @@ public void setKeyProgress(String key, ResourceType rt, float value) {
         if (byKey.isEmpty()) keyProgress.remove(rt);
     }
 
-    /**
-     * Decrease the cursor by a fixed amount, clamped at zero. Returns the new value.
-     */
     public float decayKeyProgress(String key, ResourceType rt, float amount) {
         if (key == null || key.isEmpty() || amount <= 0f) return getKeyProgress(key, rt);
         var byKey = keyProgress.get(rt);
@@ -145,12 +124,10 @@ public float decayKeyProgress(String key, ResourceType rt, float amount) {
         return next;
     }
 
-    /** Optional utility if you want to wipe a resource’s accumulator. */
     public void clear(ResourceType rt) {
         lost.remove(rt);
     }
 
-    /** Optional: wipe all. */
     public void clearAll() {
         lost.clear();
     }
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
index 15e9e2ff4..57f4d4306 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
@@ -13,6 +13,7 @@
 import com.robertx22.mine_and_slash.database.data.value_calc.LeveledValue;
 import com.robertx22.mine_and_slash.database.registry.ExileDB;
 import com.robertx22.mine_and_slash.database.registry.ExileRegistryTypes;
+import com.robertx22.mine_and_slash.mmorpg.DebugHud;
 import com.robertx22.mine_and_slash.mmorpg.SlashRef;
 import com.robertx22.mine_and_slash.saveclasses.ExactStatData;
 import com.robertx22.mine_and_slash.saveclasses.gearitem.gear_bases.StatRangeInfo;
@@ -258,27 +259,25 @@ public void onRemove(LivingEntity target) {
                     caster = target;
                 }
                 // --- Debug: show expire intent
-                if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE) {
+                if (DebugHud.ON_EXPIRE) {
                     if (target instanceof ServerPlayer sp) {
-                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_onremove_" + GUID(), "[EFFECT][EXPIRE] onRemove(" + GUID() + ") stacks=" + data.stacks + ", ticks_left=" + data.ticks_left + ", infinite=" + data.is_infinite, 200);
+                        DebugHud.send(sp, "expire_onremove_" + GUID(), "[EFFECT][EXPIRE] onRemove(" + GUID() + ") stacks=" + data.stacks + ", ticks_left=" + data.ticks_left + ", infinite=" + data.is_infinite, 200);
                     }
                     if (caster instanceof ServerPlayer spc && caster != target) {
-                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spc, "expire_onremove_" + GUID(), "[EFFECT][EXPIRE] Trigger from " + GUID() + " on target " + target.getName().getString(), 200);
+                        DebugHud.send(spc, "expire_onremove_" + GUID(), "[EFFECT][EXPIRE] Trigger from " + GUID() + " on target " + target.getName().getString(), 200);
                     }
                 }
                 if (spell != null && caster != null) {
                     SpellCtx ctx = SpellCtx.onExpire(caster, target, data.calcSpell);
-                    // Attach expiring effect id and any per-effect duration overrides carried on the instance
                     ctx.expiringEffectId = this.GUID();
                     ctx.onExpireEffectDurationTicks = (data.onExpireEffectDurationTicks == null)
                             ? java.util.Collections.emptyMap()
                             : java.util.Collections.unmodifiableMap(data.onExpireEffectDurationTicks);
                     spell.tryActivate(Spell.DEFAULT_EN_NAME, ctx); // source is default name at all times
-                    if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && target instanceof ServerPlayer sp2) {
-                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp2, "expire_dispatched_" + GUID(), "[EFFECT][EXPIRE] Dispatched attached spell for " + GUID(), 400);
+                    if (DebugHud.ON_EXPIRE && target instanceof ServerPlayer sp2) {
+                        DebugHud.send(sp2, "expire_dispatched_" + GUID(), "[EFFECT][EXPIRE] Dispatched attached spell for " + GUID(), 400);
                     }
 
-                    // Apply any leftover datapack-declared on-expire effects that weren't applied by actions (server only)
                     if (!target.level().isClientSide && data.onExpireEffectDurationTicks != null && !data.onExpireEffectDurationTicks.isEmpty()) {
                         for (var entry : data.onExpireEffectDurationTicks.entrySet()) {
                             String effId = entry.getKey();
@@ -286,7 +285,7 @@ public void onRemove(LivingEntity target) {
                             if (ctx.onExpireApplied != null && ctx.onExpireApplied.contains(effId)) {
                                 continue;
                             }
-                            var extraEff = com.robertx22.mine_and_slash.database.registry.ExileDB.ExileEffects().get(effId);
+                            var extraEff = ExileDB.ExileEffects().get(effId);
                             if (extraEff != null) {
                                 var unitT = com.robertx22.mine_and_slash.uncommon.datasaving.Load.Unit(target);
                                 var storeT = unitT.getStatusEffectsData();
@@ -298,8 +297,8 @@ public void onRemove(LivingEntity target) {
                                 try { extraEff.onApply(target); } catch (Exception ignored) {}
                                 unitT.equipmentCache.STATUS.setDirty();
                                 unitT.sync.setDirty();
-                                if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && target instanceof ServerPlayer spx) {
-                                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spx, "expire_extra_" + effId, "[EFFECT][EXPIRE] Extra-applied " + effId + " tl=" + instT.ticks_left, 400);
+                                if (DebugHud.ON_EXPIRE && target instanceof ServerPlayer spx) {
+                                    DebugHud.send(spx, "expire_extra_" + effId, "[EFFECT][EXPIRE] Extra-applied " + effId + " tl=" + instT.ticks_left, 400);
                                 }
                             }
                         }
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
index e8a57ee2e..7dbc8b7e0 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/ComponentPart.java
@@ -4,6 +4,8 @@
 import com.robertx22.mine_and_slash.database.data.spells.components.conditions.EffectCondition;
 import com.robertx22.mine_and_slash.database.data.spells.components.selectors.BaseTargetSelector;
 import com.robertx22.mine_and_slash.database.data.spells.components.selectors.TargetSelector;
+import com.robertx22.mine_and_slash.database.registry.ExileDB;
+import com.robertx22.mine_and_slash.database.data.spells.components.actions.ExileEffectAction;
 import com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField;
 import com.robertx22.mine_and_slash.database.data.spells.spell_classes.SpellCtx;
 import com.robertx22.mine_and_slash.mmorpg.DebugHud;
@@ -134,27 +136,23 @@ public void tryActivate(SpellCtx ctx) {
             } else {
                 action.tryActivate(list, ctx, part);
                 if (DebugHud.ON_EXPIRE
-                        && ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE) {
+                        && ctx.activation == EntityActivation.ON_EXPIRE) {
                     if (ctx.caster instanceof ServerPlayer spc) {
-                        com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spc, "expire_action_" + part.type, "[EFFECT][EXPIRE] Action=" + part.type + " targets=" + list.size(), 400);
+                        DebugHud.send(spc, "expire_action_" + part.type, "[EFFECT][EXPIRE] Action=" + part.type + " targets=" + list.size(), 400);
                     }
                 }
 
-                // Fallback: if ON_EXPIRE exile_effects still don't appear, apply directly here
-                // Only applies to GIVE_STACKS to avoid resurrecting effects when JSON intends REMOVE_STACKS
-                if (!ctx.world.isClientSide && ctx.activation == com.robertx22.mine_and_slash.database.data.spells.components.EntityActivation.ON_EXPIRE
+                if (!ctx.world.isClientSide && ctx.activation == EntityActivation.ON_EXPIRE
                         && part.type.equals(SpellAction.EXILE_EFFECT.GUID())) {
                     try {
-                        String actionType = part.get(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.POTION_ACTION);
-                        if (actionType == null || !actionType.equals(com.robertx22.mine_and_slash.database.data.spells.components.actions.ExileEffectAction.GiveOrTake.GIVE_STACKS.name())) {
-                            // Skip fallback for non-GIVE actions (e.g., REMOVE_STACKS)
+                        String actionType = part.get(MapField.POTION_ACTION);
+                        if (actionType == null || !actionType.equals(ExileEffectAction.GiveOrTake.GIVE_STACKS.name())) {
                             continue;
                         }
-                        String effId = part.get(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.EXILE_POTION_ID);
-                        Double durD = part.getOrDefault(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.POTION_DURATION, 0D);
-                        Double cntD = part.getOrDefault(com.robertx22.mine_and_slash.database.data.spells.map_fields.MapField.COUNT, 1D);
+                        String effId = part.get(MapField.EXILE_POTION_ID);
+                        Double durD = part.getOrDefault(MapField.POTION_DURATION, 0D);
+                        Double cntD = part.getOrDefault(MapField.COUNT, 1D);
                         int duration = Math.max(1, durD.intValue());
-                        // If override present from datapack, prefer it
                         if (ctx.onExpireEffectDurationTicks != null && ctx.onExpireEffectDurationTicks.containsKey(effId)) {
                             int override = ctx.onExpireEffectDurationTicks.get(effId);
                             if (override > 0) {
@@ -162,7 +160,7 @@ public void tryActivate(SpellCtx ctx) {
                             }
                         }
                         int stacks = Math.max(1, cntD.intValue());
-                        var effect = com.robertx22.mine_and_slash.database.registry.ExileDB.ExileEffects().get(effId);
+                        var effect = ExileDB.ExileEffects().get(effId);
                         if (effect != null) {
                             for (LivingEntity tgt : list) {
                                 var unit = com.robertx22.mine_and_slash.uncommon.datasaving.Load.Unit(tgt);
@@ -176,7 +174,7 @@ public void tryActivate(SpellCtx ctx) {
                                 unit.equipmentCache.STATUS.setDirty();
                                 unit.sync.setDirty();
                                 if (ctx.caster instanceof ServerPlayer spc) {
-                                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(spc, "expire_fallback_direct_" + effId, "[EFFECT][EXPIRE] Direct-applied " + effId + " tl=" + inst.ticks_left + " x" + inst.stacks, 400);
+                                    DebugHud.send(spc, "expire_fallback_direct_" + effId, "[EFFECT][EXPIRE] Direct-applied " + effId + " tl=" + inst.ticks_left + " x" + inst.stacks, 400);
                                 }
                             }
                             ctx.onExpireApplied.add(effId);
diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
index 690151e5a..fef387aa7 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/spells/components/actions/ExileEffectAction.java
@@ -74,7 +74,6 @@ public void tryActivate(Collection<LivingEntity> targets, SpellCtx ctx, MapHolde
                     potionEvent.spellid = ctx.calculatedSpellData.getSpell()
                             .GUID();
 
-                    // Normal path for non-ON_EXPIRE contexts
                     try {
                         potionEvent.Activate();
                     } catch (Exception ex) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java
index 6c4f43aee..59a21f708 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java
@@ -25,15 +25,6 @@
 public final class EffectUtils {
     private EffectUtils() {}
 
-    /**
-     * Apply/refresh a state effect on the player.
-     *
-     * @param sp            target player
-     * @param ctx           effect context (ids defined in ModEffects)
-     * @param durationTicks desired remaining lifetime (ticks); merged via MAX
-     * @param stacks        desired stacks; clamped to effect.max_stacks and merged via MAX
-     * @return ExileEffectInstanceData for the applied effect, or null if resolve failed.
-     */
     public static ExileEffectInstanceData applyState(ServerPlayer sp, EffectCtx ctx, int durationTicks, int stacks) {
         final ExileEffect effect = resolveEffect(ctx);
         if (effect == null) return null;
@@ -46,21 +37,18 @@ public static ExileEffectInstanceData applyEffect(ServerPlayer sp, ExileEffect e
 
         var unit  = Load.Unit(sp);
         var store = unit.getStatusEffectsData();
-        var inst  = store.getOrCreate(effect); // persist if missing
+        var inst  = store.getOrCreate(effect);
 
-        // Merge stacks/ticks: refresh semantics (never decrease on re-apply)
         final int wanted = Math.max(1, stacks);
         final int capped = (effect.max_stacks > 0) ? Math.min(wanted, effect.max_stacks) : wanted;
         inst.stacks     = Math.max(inst.stacks, capped);
         inst.ticks_left = Math.max(inst.ticks_left, durationTicks);
 
-        // Keep vanilla stats / one-of-a-kind cleanup in sync
         effect.onApply(sp);
-        unit.sync.setDirty(); // network/state sync
+        unit.sync.setDirty();
         return inst;
     }
 
-    /** Try both resourcePath (preferred) and id; some data uses either. */
     private static ExileEffect resolveEffect(EffectCtx ctx) {
         ExileEffect eff = ExileDB.ExileEffects().get(ctx.resourcePath);
         if (eff == null) eff = ExileDB.ExileEffects().get(ctx.id);
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceLost.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceLost.java
index 3e29a8206..27464f413 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceLost.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceLost.java
@@ -6,22 +6,13 @@
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.LivingEntity;
 
-/**
- * Unified entrypoint for resource LOSS (spend, drains, damage).
- * Health damage integration calls this via the LivingDamageEvent handler below.
- *
- * Debug printing is handled inside SpendThresholdManager and is toggled by
- * OnResourceLost.DEBUG_ENABLED.
- */
 public final class OnResourceLost {
     private OnResourceLost() {}
 
     public enum LossSource { SpendOrDrain, Damage, Other }
 
-    /** Toggle SpendThresholdManager debug logs per player. */
     public static boolean DEBUG_ENABLED = false;
 
-    /** Call this whenever a resource actually goes down. */
     public static void trigger(LivingEntity entity, ResourceType type, float loss, LossSource source) {
         if (loss <= 0f) return;
         if (!(entity instanceof ServerPlayer sp)) return;
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceRestore.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceRestore.java
index e4e6b9fa8..d782bf693 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceRestore.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceRestore.java
@@ -15,48 +15,31 @@
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 
-/**
- * Fires whenever a resource actually restored ("applied > 0").
- * Semantics are *literal*: we refresh short-TTL "state" flags only when ticks land.
- * - First hit does NOT benefit.
- * - Subsequent hits benefit while ticks are flowing (TTL bridges tick gaps).
- *
- * Extension points:
- *  1) Add a new RestoreType branch in {@link #onRestore(ServerPlayer, ResourceType, float, RestoreType)}.
- *  2) Keep any per-type registry sanity checks in a tiny ensure*Present(...) method.
- *  3) Apply/refresh states via EffectUtils.applyState(...) with a conservative TTL.
- */
+
 public class OnResourceRestore {
 
-    // ===== Gameplay tuning =====
-    /** State lifetime in ticks; should exceed your leech cadence + jitter. */
     private static final int STATE_TICKS = 20;
 
-    // ===== Debug controls =====
-    /** Global toggle for chat debug. Safe to leave false in prod. */
     public static boolean DEBUG_ENABLED = false;
-    /** Ignore tiny restores in debug spam. */
+
     public static float MIN_DEBUG_AMOUNT = 1.0f;
-    /** Which restore kinds print debug (default: leech only). */
+
     private static final EnumSet<RestoreType> DEBUG_TYPES = EnumSet.of(RestoreType.leech);
-    /** Per (player, resource, type) cooldown for chat spam. */
+
     private static final Map<Key, Long> nextAllowedTick = new ConcurrentHashMap<>();
     private static final int PRINT_COOLDOWN_TICKS = 5; // 0.25s @20tps
 
-    /** Public entrypoint from restore sites. Pass the entity that RECEIVED the restore (attacker for leech). */
+
     public static void trigger(LivingEntity entity,
                                ResourceType type,
                                float amount,
                                RestoreType restoreType) {
-        // Must only be called when net-applied > 0
         if (amount <= 0) return;
 
-        // 1) Apply/refresh state flags on ServerPlayer only (current design scope).
         if (entity instanceof ServerPlayer sp) {
             onRestore(sp, type, amount, restoreType);
         }
 
-        // 2) Optional debug print (player-only)
         if (entity instanceof ServerPlayer sp) {
             maybeDebugRestore(sp, type, amount, restoreType);
         }
@@ -72,38 +55,29 @@ private static void onRestore(ServerPlayer sp,
             case leech -> applyLeechStates(sp, type);
             // === Add NEW RestoreType cases here ===
             // case <NEW_KIND> -> applyNewKindStates(sp, type, amount);
-            default -> { /* ignore other kinds by default */ }
+            default -> {}
         }
     }
 
-    /** Leech: refresh generic + per-resource flags on the SOURCE player. */
     private static void applyLeechStates(ServerPlayer sp, ResourceType type) {
-        // Optional runtime sanity (helps catch missing datapack JSON in dev)
         if (!ensureLeechEffectsPresent(sp, type)) {
-            return; // don’t pretend we applied anything
+            return;
         }
 
-        // Generic "while leeching"
         EffectUtils.applyState(sp, ModEffects.LEECHING_STATE, STATE_TICKS, 1);
 
-        // Per-resource "while leeching [resource]"
         var fx = ModEffects.LEECHING_STATE_BY_RES.get(type);
         if (fx != null) {
             EffectUtils.applyState(sp, fx, STATE_TICKS, 1);
         }
     }
 
-    /**
-     * Datapack/registry guard. Returns true if both generic and per-resource
-     * leech flags exist in the ExileDB registry.
-     */
     private static boolean ensureLeechEffectsPresent(ServerPlayer sp, ResourceType type) {
         var anyFx   = ExileDB.ExileEffects().get(ModEffects.LEECHING_STATE.GUID());
         var byResFx = ExileDB.ExileEffects().get(ModEffects.LEECHING_STATE_BY_RES.get(type).GUID());
 
         if (anyFx != null && byResFx != null) return true;
 
-        // Only nag in dev when debug is on; silence in prod.
         if (DEBUG_ENABLED) {
             sp.sendSystemMessage(Component.literal(
                 "[RESTORE][WARN] Missing leech effects: any=" + (anyFx != null) +
@@ -115,7 +89,6 @@ private static boolean ensureLeechEffectsPresent(ServerPlayer sp, ResourceType t
         return false;
     }
 
-    /** Centralized debug; respects type filters & cooldown. */
     private static void maybeDebugRestore(ServerPlayer sp,
                                           ResourceType type,
                                           float amount,
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
index a0de8f541..b7759c656 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
@@ -129,12 +129,10 @@ public static void onEndTick(ServerPlayer player) {
                     playerData.spellCastingData.charges.onTicks(player, 5);
                 }
 
-                // Every second, apply passive decay to inactive threshold progress
                 if (age % 20 == 0) {
                     long now = player.level().getGameTime();
                     var unit = Load.Unit(player);
                     if (unit != null) {
-                        // Iterate only active keys per resource
                         for (var rt : com.robertx22.mine_and_slash.saveclasses.unit.ResourceType.values()) {
                             for (var key : unit.getSpendRuntime().getActiveKeys(rt)) {
                                 var spec = unit.getSpendRuntime().getSpec(key);
@@ -145,13 +143,12 @@ public static void onEndTick(ServerPlayer player) {
                                 if (since < 300) continue; // < 15s
 
                                 long lastDecay = unit.getSpendRuntime().getLastDecay(key);
-                                if (lastDecay == now) continue; // already decayed this second
+                                if (lastDecay == now) continue;
                                 unit.getSpendRuntime().markDecay(key, now);
 
-                                // Decay rate: 15% of this threshold's breakpoint per second
                                 float thr = spec.thresholdFor(unit);
                                 if (thr <= 0f) continue;
-                                float decayPerSecond = thr * 0.15f;
+                                float decayPerSecond = thr * 0.15f; // Decay rate: 15% of Threshold per second
                                 float newVal = unit.getResourceTracker().decayKeyProgress(key, rt, decayPerSecond);
                                 int cint = (int) newVal;
                                 if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java b/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java
index 3042e4332..5ee1ec4f6 100644
--- a/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java
+++ b/src/main/java/com/robertx22/mine_and_slash/gui/overlays/EffectsOverlay.java
@@ -58,7 +58,6 @@ public static void render(GuiGraphics gui, boolean horizontal) {
             }
         }
 
-        // Render threshold UI items inline with effects (uses same bg/overlay)
         var thresholdMap = com.robertx22.mine_and_slash.mechanics.thresholds.ui.ThresholdUiClient.visibleEntries();
         if (!thresholdMap.isEmpty()) {
             for (var e : thresholdMap.entrySet()) {
@@ -67,11 +66,9 @@ public static void render(GuiGraphics gui, boolean horizontal) {
                 var rt = com.robertx22.mine_and_slash.saveclasses.unit.ResourceType.ofId(resId);
                 if (rt == null) continue;
 
-                // draw frame same as effects
                 gui.blit(SlashRef.guiId("effect/effect_bg"), x, y, bgX, bgY, 0, 0, bgX, bgY, bgX, bgY);
                 gui.blit(SlashRef.guiId("effect/effect_overlay"), x, y, bgX, bgY, 0, 0, bgX, bgY, bgX, bgY);
 
-                // show 0..threshold progress, not current resource value
                 float prog = com.robertx22.mine_and_slash.mechanics.thresholds.ui.ThresholdUiClient.getProgress(key);
                 GuiUtils.renderScaledText(gui, (int) x + 10, (int) y + 10, 0.7F, String.valueOf((int) prog), ChatFormatting.YELLOW);
 
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
index d35e248a9..26886ac65 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
@@ -9,12 +9,13 @@
 
 public class DataDrivenSpendThresholdSpec extends SpendThresholdSpec {
 
-    public enum ThresholdMode { X_PER_LEVEL, FLAT, PCT_OF_MAX }
+    public enum ThresholdMode { FLAT, PERCENT_OF_MAX }
 
     private final ThresholdMode mode;
     private final float value;
     private final boolean multiplyByLevel;
-    @Nullable private final ResourceType pctMaxOf;
+    @Nullable private final ResourceType percentMaxOf;
+    private final boolean showUi;
 
     public DataDrivenSpendThresholdSpec(
             String key,
@@ -22,45 +23,43 @@ public DataDrivenSpendThresholdSpec(
             ThresholdMode mode,
             float value,
             boolean multiplyByLevel,
-            @Nullable ResourceType pctMaxOf,
+            @Nullable ResourceType percentMaxOf,
             Set<String> lockWhileEffectIds,
             int cooldownTicks,
             boolean lockWhileCooldown,
             boolean dropProgressWhileLocked,
-            boolean resetProgressOnProc
+            boolean resetProgressOnProc,
+            boolean showUi
     ) {
-        super(resource, /*perLevelFactor (unused)*/ 0f, key,
-              lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, resetProgressOnProc);
+        super(resource, 0f, key,
+              lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, resetProgressOnProc, showUi);
         this.mode = mode;
         this.value = value;
         this.multiplyByLevel = multiplyByLevel;
-        this.pctMaxOf = pctMaxOf;
+        this.percentMaxOf = percentMaxOf;
+        this.showUi = showUi;
     }
 
+
     @Override
     public float thresholdFor(EntityData unit) {
         float base;
         switch (mode) {
-            case X_PER_LEVEL:
-                base = value * Math.max(1, unit.getLevel());
-                break;
-            case FLAT:
-                base = value * (multiplyByLevel ? Math.max(1, unit.getLevel()) : 1f);
-                break;
-            case PCT_OF_MAX:
-                ResourceType rt = (pctMaxOf != null) ? pctMaxOf : resource();
-                float max = unit.getResources().getMax(unit.getEntity(), rt);
+            case PERCENT_OF_MAX -> {
+                ResourceType tgt = (percentMaxOf != null) ? percentMaxOf : resource();
+                float max = unit.getResources().getMax(unit.getEntity(), tgt);
                 base = (value / 100f) * max;
-                if (multiplyByLevel) base *= Math.max(1, unit.getLevel());
-                break;
-            default:
-                base = 0f;
+            }
+            case FLAT -> base = value;
+            default -> base = value;
         }
+        if (multiplyByLevel) base *= Math.max(1, unit.getLevel());
         return Math.max(0f, base);
     }
 
     @Override
     public void onProc(ServerPlayer sp, int procs) {
-        // No default action here; datapack loader wires actions.
     }
+
+    public boolean showUi() { return showUi; }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
index 2888c3032..4a481a700 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
@@ -6,12 +6,10 @@
 import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType;
 import net.minecraft.server.level.ServerPlayer;
 
-/** Registers global spend thresholds at startup. */
 public final class SpendThresholdManager {
     private SpendThresholdManager() {}
 
     public static void registerDefaults() {
-        // No-op: thresholds are defined via datapack JSON.
     }
 
     // ===== DEBUGGING =====
@@ -23,7 +21,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
         if (loss <= 0f) return;
 
         var tracker = unit.getResourceTracker();
-        tracker.addLoss(type, loss); // general counter (optional)
+        tracker.addLoss(type, loss);
 
         var specs = SpendThresholdRegistry.resolveFor(unit, type);
         if (specs.isEmpty()) {
@@ -39,7 +37,6 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
         for (SpendThresholdSpec spec : specs) {
             final String key = spec.keyFor(unit);
 
-            // Cooldown-as-lock
             if (spec.lockWhileCooldown() && unit.getSpendRuntime().isCoolingDown(key, now)) {
                 if (spec.dropProgressWhileLocked()) {
                     tracker.clearKey(type, key);
@@ -53,7 +50,6 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 continue;
             }
 
-            // Locks (effects + optional perk requirement)
             if (spec.isLockedFor(unit)) {
                 if (spec.dropProgressWhileLocked()) {
                     tracker.clearKey(type, key);
@@ -61,7 +57,6 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 if (debug) {
                     sp.sendSystemMessage(net.minecraft.network.chat.Component.literal("[SPEND:" + spec.key() + "] locked"));
                 }
-                // hide UI while locked
                 if (spec.showUi()) {
                     com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
                 }
@@ -84,7 +79,6 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                     tracker.clearKey(type, key);
                 }
                 if (debug) dbg(sp, "[SPEND:" + spec.key() + "] " + type.id + " ×" + procs + " (thr=" + fmt(threshold) + ")");
-                // hide UI on proc
                 if (spec.showUi()) {
                     com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
                 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
index d8d6916a9..1a31a898d 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
@@ -8,21 +8,16 @@
 import java.util.Set;
 
 public class SpendThresholdRuntime {
-    // gameTime (ticks) when each key’s cooldown ends
+
     private final Map<String, Long> cooldownUntil = new HashMap<>();
 
-    // last activity tick for each threshold key (progress added)
     private final Map<String, Long> lastActivityTick = new HashMap<>();
 
-    // last decay tick applied for each key (so we decay at most once per second)
     private final Map<String, Long> lastDecayTick = new HashMap<>();
 
-    // last integer progress sent to client (to throttle network updates)
     private final Map<String, Integer> lastProgressIntSent = new HashMap<>();
 
-    // Index of active threshold keys by resource (only keys with progress > 0 or recently updated)
     private final java.util.EnumMap<ResourceType, Set<String>> activeByResource = new java.util.EnumMap<>(ResourceType.class);
-    // Quick lookup of spec by key (used for decay threshold value)
     private final Map<String, SpendThresholdSpec> specByKey = new HashMap<>();
 
     public void startCooldown(String key, long now, int cooldownTicks) {
@@ -35,7 +30,6 @@ public boolean isCoolingDown(String key, long now) {
         return until != null && now < until;
     }
 
-    /** Remaining ticks until ready (0 if no cooldown / already ready). */
     public int cooldownRemainingTicks(String key, long now) {
         Long until = cooldownUntil.get(key);
         if (until == null) return 0;
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
index 6653eadcc..48e7ecc77 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
@@ -12,21 +12,19 @@
 
 public abstract class SpendThresholdSpec {
     private final ResourceType resource;
-    private final float perLevelFactor;  // used by default thresholdFor()
+    private final float perLevelFactor;
     private final String key;
 
     // gating/cooldown controls
     private final Set<String> lockWhileEffectIds;
     private final int cooldownTicks;
-    private final boolean lockWhileCooldown;         // treat cooldown as a lock
+    private final boolean lockWhileCooldown;         // Used to lock the threshold while the cooldown is active. **RECOMMENDED FOR DEBUGGING ONLY**
     private final boolean dropProgressWhileLocked;
     private final boolean resetProgressOnProc;
-    private final boolean showUi; // whether to render progress HUD for this spec
+    private final boolean showUi;
 
-    // registry ordering (lower runs first)
     private int priority = 0;
 
-    // Full ctor used by data-driven impl
     public SpendThresholdSpec(ResourceType resource,
                               float perLevelFactor,
                               String key,
@@ -47,18 +45,6 @@ public SpendThresholdSpec(ResourceType resource,
         this.showUi = showUi;
     }
 
-    // Backward-compatible ctor (defaults showUi=false)
-    public SpendThresholdSpec(ResourceType resource,
-                              float perLevelFactor,
-                              String key,
-                              Set<String> lockWhileEffectIds,
-                              int cooldownTicks,
-                              boolean lockWhileCooldown,
-                              boolean dropProgressWhileLocked,
-                              boolean resetProgressOnProc) {
-        this(resource, perLevelFactor, key, lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, resetProgressOnProc, false);
-    }
-
     // ===== accessors =====
     public ResourceType resource()              { return resource; }
     public String key()                         { return key; }
@@ -85,12 +71,10 @@ public SpendThresholdSpec withShowUi(boolean on) {
         }.withPriority(this.priority);
     }
 
-    /** Default threshold = perLevelFactor × LVL. Subclasses may override. */
     public float thresholdFor(EntityData unit) {
         return Math.max(0f, perLevelFactor * Math.max(1, unit.getLevel()));
     }
 
-    /** True if any gating effect is active. */
     public boolean isEffectLocked(EntityData unit) {
         if (lockWhileEffectIds.isEmpty()) return false;
         var store = unit.getStatusEffectsData();
@@ -105,14 +89,12 @@ public boolean isLockedFor(EntityData unit) {
         return isEffectLocked(unit);
     }
 
-    /** Start cooldown (no-op if cooldownTicks == 0). */
     public void startCooldown(EntityData unit, long now) {
         if (cooldownTicks > 0) {
             unit.getSpendRuntime().startCooldown(keyFor(unit), now, cooldownTicks);
         }
     }
 
-    /** Called when one or more thresholds are consumed. */
     public abstract void onProc(ServerPlayer sp, int procs);
 
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java
index 1cd3a7ffb..f60fbe52e 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java
@@ -23,7 +23,7 @@ public static class Threshold {
         public String mode = "FLAT";
         public float value = 0f;
         @SerializedName("multiply_by_level") public boolean multiplyByLevel = false;
-        @SerializedName("percent_of") public String percentOf; // optional
+        @SerializedName("percent_of") public String percentOf; 
     }
     public Threshold threshold = new Threshold();
 
@@ -54,20 +54,17 @@ public static class ProcAction {
     public SpendThresholdSpec toSpec() {
         ResourceType res = parseResource(resource, ResourceType.energy);
 
-        // Modes supported: FLAT (optionally with multiply_by_level) or PERCENT_OF_MAX
         String rawMode = (threshold.mode == null ? "FLAT" : threshold.mode.trim()).toUpperCase(Locale.ROOT);
         boolean mult = threshold.multiplyByLevel;
         DataDrivenSpendThresholdSpec.ThresholdMode mode;
         if ("PERCENT_OF_MAX".equals(rawMode)) {
-            mode = DataDrivenSpendThresholdSpec.ThresholdMode.PCT_OF_MAX;
-        } else if ("X_PER_LEVEL".equals(rawMode)) {
-            mode = DataDrivenSpendThresholdSpec.ThresholdMode.X_PER_LEVEL;
+            mode = DataDrivenSpendThresholdSpec.ThresholdMode.PERCENT_OF_MAX;
         } else {
             mode = DataDrivenSpendThresholdSpec.ThresholdMode.FLAT; // default + treats legacy values as FLAT
         }
 
         ResourceType percentOf = null;
-        if (mode == DataDrivenSpendThresholdSpec.ThresholdMode.PCT_OF_MAX
+        if (mode == DataDrivenSpendThresholdSpec.ThresholdMode.PERCENT_OF_MAX
                 && threshold.percentOf != null && !threshold.percentOf.isEmpty()) {
             percentOf = parseResource(threshold.percentOf, res); // default to this spec’s resource if bad input
         }
@@ -86,7 +83,8 @@ public SpendThresholdSpec toSpec() {
                 cooldownTicks,
                 locks != null && locks.lockWhileCooldown,
                 locks != null && locks.dropProgressWhileLocked,
-                locks != null && locks.resetProgressOnProc
+                locks != null && locks.resetProgressOnProc,
+                showUi
         ) {
             @Override
             public void onProc(ServerPlayer sp, int procs) {
@@ -104,7 +102,6 @@ public void onProc(ServerPlayer sp, int procs) {
                     int stacks = Math.max(1, a.stacks);
                     var inst = EffectUtils.applyEffect(sp, effect, durTicks, stacks);
 
-                    // Attach on-expire duration overrides (ticks directly)
                     if (a.onExpire != null && !a.onExpire.isEmpty()) {
                         if (inst.onExpireEffectDurationTicks == null) {
                             inst.onExpireEffectDurationTicks = new java.util.HashMap<>();
@@ -131,7 +128,7 @@ public boolean isLockedFor(EntityData unit) {
                 }
                 return false;
             }
-        }.withPriority(priority).withShowUi(showUi);
+        }.withPriority(priority);
     }
 
     // --- helpers ---
@@ -140,7 +137,6 @@ private static ResourceType parseResource(String s, ResourceType fallback) {
         for (ResourceType rt : ResourceType.values()) {
             if (rt.name().equalsIgnoreCase(s)) return rt;
             try {
-                // if your enum exposes an id/string, handle it here:
                 var idField = rt.getClass().getField("id");
                 Object idVal = idField.get(rt);
                 if (idVal instanceof String && ((String) idVal).equalsIgnoreCase(s)) return rt;
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java
index 11c24f0f7..c8226610f 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java
@@ -4,7 +4,6 @@
 import java.util.HashMap;
 import java.util.Map;
 
-/** Client-only holder for which threshold keys should currently render, their resource ids, and progress. */
 public final class ThresholdUiClient {
     private ThresholdUiClient() {}
 
diff --git a/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java b/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java
index 0fd3e7dbd..191a552d2 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java
@@ -8,10 +8,8 @@ public final class DebugHud {
 
     private DebugHud() {}
 
-    // Unified flags
     public static volatile boolean ON_EXPIRE = false;
 
-    // Simple per-player throttling to avoid spammy chat when debugging
     private static final java.util.concurrent.ConcurrentHashMap<String, Long> LAST_MSG_MS = new java.util.concurrent.ConcurrentHashMap<>();
 
     public static void send(net.minecraft.server.level.ServerPlayer sp, String key, String msg) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java
index c0f7c15b2..198e4ca73 100644
--- a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java
+++ b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java
@@ -17,7 +17,6 @@ public class DebugCommands {
 
     public static void init(CommandDispatcher<CommandSourceStack> dispatcher) {
 
-        // New unified debug toggle:
         // /mine_and_slash debug <spend_threshold|resource_restore|onexpire> <true|false|toggle|on|off>
         CommandBuilder.of(CommandRefs.ID, dispatcher, x -> {
             StringWrapper SUBJECT = new StringWrapper("subject", () -> List.of("spend_threshold", "resource_restore", "onexpire"));
@@ -31,7 +30,6 @@ public static void init(CommandDispatcher<CommandSourceStack> dispatcher) {
                 String subject = SUBJECT.get(e);
                 String state = STATE.get(e);
 
-                // Validate inputs (in addition to tab suggestions)
                 String subjLower = subject == null ? "" : subject.toLowerCase(java.util.Locale.ROOT);
                 String stateLower = state == null ? "" : state.toLowerCase(java.util.Locale.ROOT);
                 boolean subjOk = subjLower.equals("spend_threshold") || subjLower.equals("resource_restore") || subjLower.equals("onexpire");
diff --git a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java
index 262e80fb2..794a18298 100644
--- a/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java
+++ b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/potion_effects/EntityStatusEffectsData.java
@@ -6,6 +6,7 @@
 import com.robertx22.mine_and_slash.saveclasses.ExactStatData;
 import com.robertx22.mine_and_slash.saveclasses.unit.stat_ctx.SimpleStatCtx;
 import com.robertx22.mine_and_slash.saveclasses.unit.stat_ctx.StatContext;
+import com.robertx22.mine_and_slash.mmorpg.DebugHud;
 import net.minecraft.world.entity.LivingEntity;
 
 import java.util.ArrayList;
@@ -54,21 +55,17 @@ public void tick(LivingEntity en) {
         List<String> toDeleteKeys = new ArrayList<>();
 
         if (en.tickCount % 80 == 0) {
-            // Prevent keeping e.g. auras and stances after respeccing
-            // Has to string compare spell UUIDs to look up the new spell level, so it's done infrequently
             for (Map.Entry<String, ExileEffectInstanceData> entry : exileMap.entrySet()) {
                 boolean shouldDrop = entry.getValue().shouldRemove() || entry.getValue().isSpellNoLongerAllocated(en);
                 if (shouldDrop) {
                     ExileEffect eff = ExileDB.ExileEffects().get(entry.getKey());
                     if (eff != null) {
-                        // Fire onRemove immediately for this key
                         eff.onRemove(en);
-                        // Decide deletion based on current state after onRemove
                         ExileEffectInstanceData inst = exileMap.get(entry.getKey());
                         if (inst == null || inst.shouldRemove()) {
                             toDeleteKeys.add(entry.getKey());
-                        } else if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
-                            com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_kept_" + entry.getKey(), "[EFFECT][EXPIRE] Kept " + entry.getKey() + " after onRemove (ticks_left=" + inst.ticks_left + ")", 400);
+                        } else if (DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
+                            DebugHud.send(sp, "expire_kept_" + entry.getKey(), "[EFFECT][EXPIRE] Kept " + entry.getKey() + " after onRemove (ticks_left=" + inst.ticks_left + ")", 400);
                         }
                     }
                 }
@@ -78,13 +75,12 @@ public void tick(LivingEntity en) {
                 if (entry.getValue().shouldRemove()) {
                     ExileEffect eff = ExileDB.ExileEffects().get(entry.getKey());
                     if (eff != null) {
-                        // Fire onRemove immediately for this key
                         eff.onRemove(en);
                         ExileEffectInstanceData inst = exileMap.get(entry.getKey());
                         if (inst == null || inst.shouldRemove()) {
                             toDeleteKeys.add(entry.getKey());
-                        } else if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
-                            com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_kept_" + entry.getKey(), "[EFFECT][EXPIRE] Kept " + entry.getKey() + " after onRemove (ticks_left=" + inst.ticks_left + ")", 400);
+                        } else if (DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
+                            DebugHud.send(sp, "expire_kept_" + entry.getKey(), "[EFFECT][EXPIRE] Kept " + entry.getKey() + " after onRemove (ticks_left=" + inst.ticks_left + ")", 400);
                         }
                     }
                 }
@@ -93,14 +89,13 @@ public void tick(LivingEntity en) {
 
 
 
-        // Now delete expired effects (evaluated after onRemove)
         for (String key : toDeleteKeys) {
             ExileEffectInstanceData current = exileMap.remove(key);
-            if (com.robertx22.mine_and_slash.mmorpg.DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
+            if (DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) {
                 if (current != null) {
-                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (ticks_left=" + current.ticks_left + ", stacks=" + current.stacks + ") [id=" + System.identityHashCode(current) + "]", 200);
+                    DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (ticks_left=" + current.ticks_left + ", stacks=" + current.stacks + ") [id=" + System.identityHashCode(current) + "]", 200);
                 } else {
-                    com.robertx22.mine_and_slash.mmorpg.DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (no current instance)", 200);
+                    DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (no current instance)", 200);
                 }
             }
         }
diff --git a/src/main/resources/data/mmorpg/spend_thresholds/25percent_health.json b/src/main/resources/data/mmorpg/spend_thresholds/25percent_health.json
index 84ff2d0fc..1c1bcc45c 100644
--- a/src/main/resources/data/mmorpg/spend_thresholds/25percent_health.json
+++ b/src/main/resources/data/mmorpg/spend_thresholds/25percent_health.json
@@ -9,7 +9,7 @@
       "multiply_by_level": false,
       "percent_of": "health"
     },
-    "cooldown_seconds": 0,
+    "cooldown_ticks": 0,
     "locks": {
       "effects": [],
       "drop_progress_while_locked": true,

From f8ba63fc449b7294839b97fafe05b5c29b5ac1a6 Mon Sep 17 00:00:00 2001
From: Dubledice <138730151+Dubledice@users.noreply.github.com>
Date: Fri, 5 Sep 2025 10:01:49 -0400
Subject: [PATCH 4/6] Suggested Fixes: Cleanup + Tidy

---
 .../data/exile_effects/ExileEffect.java       | 21 +++--
 .../event_hooks/my_events/EffectUtils.java    | 26 +++--
 .../event_hooks/ontick/OnServerTick.java      |  5 +-
 .../thresholds/SpendThresholdManager.java     | 16 ++--
 .../thresholds/SpendThresholdRuntime.java     | 94 +++++++++++++------
 .../thresholds/SpendThresholdSpec.java        |  1 -
 6 files changed, 108 insertions(+), 55 deletions(-)

diff --git a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
index 57f4d4306..40c55eac0 100644
--- a/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
+++ b/src/main/java/com/robertx22/mine_and_slash/database/data/exile_effects/ExileEffect.java
@@ -13,6 +13,7 @@
 import com.robertx22.mine_and_slash.database.data.value_calc.LeveledValue;
 import com.robertx22.mine_and_slash.database.registry.ExileDB;
 import com.robertx22.mine_and_slash.database.registry.ExileRegistryTypes;
+import com.robertx22.mine_and_slash.event_hooks.my_events.EffectUtils;
 import com.robertx22.mine_and_slash.mmorpg.DebugHud;
 import com.robertx22.mine_and_slash.mmorpg.SlashRef;
 import com.robertx22.mine_and_slash.saveclasses.ExactStatData;
@@ -279,6 +280,7 @@ public void onRemove(LivingEntity target) {
                     }
 
                     if (!target.level().isClientSide && data.onExpireEffectDurationTicks != null && !data.onExpireEffectDurationTicks.isEmpty()) {
+                        boolean anyApplied = false;
                         for (var entry : data.onExpireEffectDurationTicks.entrySet()) {
                             String effId = entry.getKey();
                             int durTicks = Math.max(1, entry.getValue());
@@ -286,22 +288,23 @@ public void onRemove(LivingEntity target) {
                                 continue;
                             }
                             var extraEff = ExileDB.ExileEffects().get(effId);
-                            if (extraEff != null) {
-                                var unitT = com.robertx22.mine_and_slash.uncommon.datasaving.Load.Unit(target);
-                                var storeT = unitT.getStatusEffectsData();
-                                var instT = storeT.getOrCreate(extraEff);
-                                instT.stacks = Math.max(instT.stacks, 1);
-                                instT.ticks_left = Math.max(instT.ticks_left, durTicks);
+                            if (extraEff == null) {
+                                continue;
+                            }
+                            var instT = EffectUtils.applyEffect(target, extraEff, durTicks, 1, false);
+                            if (instT != null) {
                                 instT.is_infinite = false;
                                 instT.caster_uuid = caster.getStringUUID();
-                                try { extraEff.onApply(target); } catch (Exception ignored) {}
-                                unitT.equipmentCache.STATUS.setDirty();
-                                unitT.sync.setDirty();
                                 if (DebugHud.ON_EXPIRE && target instanceof ServerPlayer spx) {
                                     DebugHud.send(spx, "expire_extra_" + effId, "[EFFECT][EXPIRE] Extra-applied " + effId + " tl=" + instT.ticks_left, 400);
                                 }
+                                anyApplied = true;
                             }
                         }
+                        if (anyApplied) {
+                            var unitT = Load.Unit(target);
+                            unitT.sync.setDirty();
+                        }
                     }
                 }
             }
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java
index 59a21f708..9bdaa0750 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java
@@ -6,6 +6,7 @@
 import com.robertx22.mine_and_slash.database.registry.ExileDB;
 import com.robertx22.mine_and_slash.uncommon.datasaving.Load;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.LivingEntity;
 
 /**
  * Utility for applying short-TTL "state" effects (e.g., leeching_state) to players.
@@ -28,14 +29,22 @@ private EffectUtils() {}
     public static ExileEffectInstanceData applyState(ServerPlayer sp, EffectCtx ctx, int durationTicks, int stacks) {
         final ExileEffect effect = resolveEffect(ctx);
         if (effect == null) return null;
-
-        return applyEffect(sp, effect, durationTicks, stacks);
+        return applyEffect((LivingEntity) sp, effect, durationTicks, stacks);
     }
 
     public static ExileEffectInstanceData applyEffect(ServerPlayer sp, ExileEffect effect, int durationTicks, int stacks) {
-        if (effect == null) return null;
+        return applyEffect((LivingEntity) sp, effect, durationTicks, stacks, true);
+    }
+
+    public static ExileEffectInstanceData applyEffect(LivingEntity entity, ExileEffect effect, int durationTicks, int stacks) {
+        return applyEffect(entity, effect, durationTicks, stacks, true);
+    }
+
+    public static ExileEffectInstanceData applyEffect(LivingEntity entity, ExileEffect effect, int durationTicks, int stacks, boolean markDirty) {
+        if (effect == null || entity == null) return null;
+        if (durationTicks <= 0 || stacks <= 0) return null;
 
-        var unit  = Load.Unit(sp);
+        var unit  = Load.Unit(entity);
         var store = unit.getStatusEffectsData();
         var inst  = store.getOrCreate(effect);
 
@@ -44,8 +53,13 @@ public static ExileEffectInstanceData applyEffect(ServerPlayer sp, ExileEffect e
         inst.stacks     = Math.max(inst.stacks, capped);
         inst.ticks_left = Math.max(inst.ticks_left, durationTicks);
 
-        effect.onApply(sp);
-        unit.sync.setDirty();
+        try { effect.onApply(entity); } catch (Exception ignored) {}
+        if (markDirty) {
+            unit.equipmentCache.STATUS.setDirty();
+            if (entity instanceof ServerPlayer) {
+                unit.sync.setDirty();
+            }
+        }
         return inst;
     }
 
diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
index b7759c656..dc30ebd38 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
@@ -133,7 +133,7 @@ public static void onEndTick(ServerPlayer player) {
                     long now = player.level().getGameTime();
                     var unit = Load.Unit(player);
                     if (unit != null) {
-                        for (var rt : com.robertx22.mine_and_slash.saveclasses.unit.ResourceType.values()) {
+                        for (var rt : ResourceType.values()) {
                             for (var key : unit.getSpendRuntime().getActiveKeys(rt)) {
                                 var spec = unit.getSpendRuntime().getSpec(key);
                                 if (!spec.showUi()) continue;
@@ -152,8 +152,7 @@ public static void onEndTick(ServerPlayer player) {
                                 float newVal = unit.getResourceTracker().decayKeyProgress(key, rt, decayPerSecond);
                                 int cint = (int) newVal;
                                 if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
-                                    com.robertx22.library_of_exile.main.Packets.sendToClient(player,
-                                        new ThresholdUiPacket(key, rt.id, newVal > 0f, newVal));
+                                    Packets.sendToClient(player, new ThresholdUiPacket(key, rt.id, newVal > 0f, newVal));
                                 }
                                 if (newVal <= 0f) {
                                     unit.getSpendRuntime().removeActive(rt, key);
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
index 4a481a700..2d0d0752c 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
@@ -3,8 +3,10 @@
 import com.robertx22.mine_and_slash.capability.entity.EntityData;
 import com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost;
 import com.robertx22.mine_and_slash.vanilla_mc.packets.ThresholdUiPacket;
+import com.robertx22.library_of_exile.main.Packets;
 import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.network.chat.Component;
 
 public final class SpendThresholdManager {
     private SpendThresholdManager() {}
@@ -26,7 +28,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
         var specs = SpendThresholdRegistry.resolveFor(unit, type);
         if (specs.isEmpty()) {
             if (debug) {
-                sp.sendSystemMessage(net.minecraft.network.chat.Component.literal(
+                sp.sendSystemMessage(Component.literal(
                     "[SPEND] +" + String.format(java.util.Locale.US, "%.1f", loss) +
                     " " + type.id + " (no specs)"
                 ));
@@ -43,7 +45,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 }
                 if (debug) {
                     long rem = unit.getSpendRuntime().cooldownRemainingTicks(key, now);
-                    sp.sendSystemMessage(net.minecraft.network.chat.Component.literal(
+                    sp.sendSystemMessage(Component.literal(
                         "[SPEND:" + spec.key() + "] locked by cooldown (" + rem + "t ~ " + fmtSec((float) rem) + "s)"
                     ));
                 }
@@ -55,10 +57,10 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                     tracker.clearKey(type, key);
                 }
                 if (debug) {
-                    sp.sendSystemMessage(net.minecraft.network.chat.Component.literal("[SPEND:" + spec.key() + "] locked"));
+                    sp.sendSystemMessage(Component.literal("[SPEND:" + spec.key() + "] locked"));
                 }
                 if (spec.showUi()) {
-                    com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
+                    Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
                 }
                 continue;
             }
@@ -80,7 +82,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 }
                 if (debug) dbg(sp, "[SPEND:" + spec.key() + "] " + type.id + " ×" + procs + " (thr=" + fmt(threshold) + ")");
                 if (spec.showUi()) {
-                    com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
+                    Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
                 }
                 unit.getSpendRuntime().removeActive(type, key);
             } else {
@@ -92,7 +94,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                     int cint = (int) cur;
                     if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
                         boolean show = cur > 0f;
-                        com.robertx22.library_of_exile.main.Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, show, cur));
+                        Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, show, cur));
                     }
                 }
                 if (cur <= 0f) {
@@ -105,7 +107,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
     // --- helpers ---
     private static void dbg(ServerPlayer sp, String msg) {
         if (!OnResourceLost.DEBUG_ENABLED) return;
-        sp.sendSystemMessage(net.minecraft.network.chat.Component.literal(msg));
+        sp.sendSystemMessage(Component.literal(msg));
     }
     private static String fmt(float v) { return String.format(java.util.Locale.US, "%.1f", v); }
     private static String fmtSec(float s) { return String.format(java.util.Locale.US, "%.1f", s); }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
index 1a31a898d..0262a01ef 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
@@ -9,30 +9,36 @@
 
 public class SpendThresholdRuntime {
 
-    private final Map<String, Long> cooldownUntil = new HashMap<>();
-
-    private final Map<String, Long> lastActivityTick = new HashMap<>();
-
-    private final Map<String, Long> lastDecayTick = new HashMap<>();
+    private static final class KeyState {
+        long cooldownUntil;
+        long lastActivityTick;
+        long lastDecayTick;
+        int lastProgressIntSent = Integer.MIN_VALUE;
+        SpendThresholdSpec spec;
+    }
 
-    private final Map<String, Integer> lastProgressIntSent = new HashMap<>();
+    private final Map<String, KeyState> states = new HashMap<>();
 
     private final java.util.EnumMap<ResourceType, Set<String>> activeByResource = new java.util.EnumMap<>(ResourceType.class);
-    private final Map<String, SpendThresholdSpec> specByKey = new HashMap<>();
+    private final java.util.EnumMap<ResourceType, Set<String>> activeByResourceReadOnly = new java.util.EnumMap<>(ResourceType.class);
 
     public void startCooldown(String key, long now, int cooldownTicks) {
         if (cooldownTicks <= 0) return;
-        cooldownUntil.put(key, now + cooldownTicks);
+        if (key == null || key.isEmpty()) return;
+        KeyState ks = states.computeIfAbsent(key, __ -> new KeyState());
+        ks.cooldownUntil = now + cooldownTicks;
     }
 
     public boolean isCoolingDown(String key, long now) {
-        Long until = cooldownUntil.get(key);
-        return until != null && now < until;
+        if (key == null || key.isEmpty()) return false;
+        KeyState ks = states.get(key);
+        return ks != null && now < ks.cooldownUntil;
     }
 
     public int cooldownRemainingTicks(String key, long now) {
-        Long until = cooldownUntil.get(key);
-        if (until == null) return 0;
+        if (key == null || key.isEmpty()) return 0;
+        KeyState ks = states.get(key);
+        long until = (ks == null) ? 0L : ks.cooldownUntil;
         long rem = until - now;
         return (int) Math.max(0, rem);
     }
@@ -40,27 +46,36 @@ public int cooldownRemainingTicks(String key, long now) {
     // === Activity/Decay tracking ===
     public void markActivity(String key, long now) {
         if (key == null || key.isEmpty()) return;
-        lastActivityTick.put(key, now);
-        lastDecayTick.remove(key);
+        KeyState ks = states.computeIfAbsent(key, __ -> new KeyState());
+        ks.lastActivityTick = now;
+        ks.lastDecayTick = 0L;
     }
 
     public long getLastActivity(String key) {
-        return lastActivityTick.getOrDefault(key, 0L);
+        if (key == null || key.isEmpty()) return 0L;
+        KeyState ks = states.get(key);
+        return ks == null ? 0L : ks.lastActivityTick;
     }
 
     public long getLastDecay(String key) {
-        return lastDecayTick.getOrDefault(key, 0L);
+        if (key == null || key.isEmpty()) return 0L;
+        KeyState ks = states.get(key);
+        return ks == null ? 0L : ks.lastDecayTick;
     }
 
     public void markDecay(String key, long now) {
         if (key == null || key.isEmpty()) return;
-        lastDecayTick.put(key, now);
+        KeyState ks = states.computeIfAbsent(key, __ -> new KeyState());
+        ks.lastDecayTick = now;
     }
 
     public boolean progressIntChanged(String key, int intProgress) {
-        Integer prev = lastProgressIntSent.get(key);
-        if (prev == null || prev.intValue() != intProgress) {
-            lastProgressIntSent.put(key, intProgress);
+        if (key == null || key.isEmpty()) return false;
+        KeyState ks = states.get(key);
+        int prev = (ks == null) ? Integer.MIN_VALUE : ks.lastProgressIntSent;
+        if (prev != intProgress) {
+            if (ks == null) ks = states.computeIfAbsent(key, __ -> new KeyState());
+            ks.lastProgressIntSent = intProgress;
             return true;
         }
         return false;
@@ -69,8 +84,15 @@ public boolean progressIntChanged(String key, int intProgress) {
     // === Active key index ===
     public void markActive(ResourceType rt, String key, SpendThresholdSpec spec) {
         if (rt == null || key == null || key.isEmpty() || spec == null) return;
-        activeByResource.computeIfAbsent(rt, __ -> new HashSet<>()).add(key);
-        specByKey.put(key, spec);
+        Set<String> set = activeByResource.get(rt);
+        if (set == null) {
+            set = new HashSet<>();
+            activeByResource.put(rt, set);
+            activeByResourceReadOnly.put(rt, java.util.Collections.unmodifiableSet(set));
+        }
+        set.add(key);
+        KeyState ks = states.computeIfAbsent(key, __ -> new KeyState());
+        ks.spec = spec;
     }
 
     public void removeActive(ResourceType rt, String key) {
@@ -78,20 +100,34 @@ public void removeActive(ResourceType rt, String key) {
         var set = activeByResource.get(rt);
         if (set != null) {
             set.remove(key);
-            if (set.isEmpty()) activeByResource.remove(rt);
+            if (set.isEmpty()) {
+                activeByResource.remove(rt);
+                activeByResourceReadOnly.remove(rt);
+            }
+        }
+        KeyState ks = states.get(key);
+        if (ks != null) {
+            ks.spec = null;
+            ks.lastActivityTick = 0L;
+            ks.lastDecayTick = 0L;
+            ks.lastProgressIntSent = Integer.MIN_VALUE;
         }
-        specByKey.remove(key);
-        lastActivityTick.remove(key);
-        lastDecayTick.remove(key);
-        lastProgressIntSent.remove(key);
     }
 
     public Set<String> getActiveKeys(ResourceType rt) {
         var s = activeByResource.get(rt);
-        return s == null ? java.util.Set.of() : java.util.Set.copyOf(s);
+        if (s == null || s.isEmpty()) return java.util.Set.of();
+        var view = activeByResourceReadOnly.get(rt);
+        if (view == null) {
+            view = java.util.Collections.unmodifiableSet(s);
+            activeByResourceReadOnly.put(rt, view);
+        }
+        return view;
     }
 
     public SpendThresholdSpec getSpec(String key) {
-        return specByKey.get(key);
+        if (key == null || key.isEmpty()) return null;
+        KeyState ks = states.get(key);
+        return ks == null ? null : ks.spec;
     }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
index 48e7ecc77..f99388c65 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
@@ -15,7 +15,6 @@ public abstract class SpendThresholdSpec {
     private final float perLevelFactor;
     private final String key;
 
-    // gating/cooldown controls
     private final Set<String> lockWhileEffectIds;
     private final int cooldownTicks;
     private final boolean lockWhileCooldown;         // Used to lock the threshold while the cooldown is active. **RECOMMENDED FOR DEBUGGING ONLY**

From c47e43aacabd83e386033f25dd5a04e119de1851 Mon Sep 17 00:00:00 2001
From: Dubledice <138730151+Dubledice@users.noreply.github.com>
Date: Fri, 5 Sep 2025 10:59:02 -0400
Subject: [PATCH 5/6] Cleanup + Fixes

---
 .../event_hooks/ontick/OnServerTick.java        |  4 +---
 .../DataDrivenSpendThresholdSpec.java           |  3 +--
 .../thresholds/SpendThresholdManager.java       | 17 +++++++++++------
 .../thresholds/SpendThresholdRuntime.java       | 16 +++++++++-------
 .../thresholds/SpendThresholdSpec.java          |  8 +++++---
 .../spend_thresholds/energy_xlvl_wotj.json      |  1 +
 6 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
index 9ddbaceb4..3684b622c 100644
--- a/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
+++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/ontick/OnServerTick.java
@@ -137,7 +137,6 @@ public static void onEndTick(ServerPlayer player) {
                             for (var key : unit.getSpendRuntime().getActiveKeys(rt)) {
                                 var spec = unit.getSpendRuntime().getSpec(key);
                                 if (!spec.showUi()) continue;
-
                                 long lastAct = unit.getSpendRuntime().getLastActivity(key);
                                 if (lastAct <= 0) continue;
                                 long since = now - lastAct;
@@ -151,8 +150,7 @@ public static void onEndTick(ServerPlayer player) {
                                 if (thr <= 0f) continue;
                                 float decayPerSecond = thr * 0.15f; // Decay rate: 15% of Threshold per second
                                 float newVal = unit.getResourceTracker().decayKeyProgress(key, rt, decayPerSecond);
-                                int cint = (int) newVal;
-                                if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
+                                if (unit.getSpendRuntime().progressScaledChanged(key, newVal, 10)) {
                                     Packets.sendToClient(player, new ThresholdUiPacket(key, rt.id, newVal > 0f, newVal));
                                 }
                                 if (newVal <= 0f) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
index b95d2e2a6..df2de7f0d 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java
@@ -31,7 +31,7 @@ public DataDrivenSpendThresholdSpec(
             boolean showUi
     ) {
         super(resource, 0f, key,
-              lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, dropProgressOnProc);
+              lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, dropProgressOnProc, showUi);
         this.mode = mode;
         this.value = value;
         this.multiplyByLevel = multiplyByLevel;
@@ -58,5 +58,4 @@ public float thresholdFor(EntityData unit) {
     @Override
     public void onProc(ServerPlayer sp, int procs) {
     }
-    public boolean showUi() { return showUi; }
 }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
index 2db94e71b..1eaf4b3e3 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java
@@ -46,7 +46,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 if (debug) {
                     long rem = unit.getSpendRuntime().cooldownRemainingTicks(key, now);
                     sp.sendSystemMessage(Component.literal(
-                        "[SPEND:" + spec.key() + "] locked by cooldown (" + rem + "t ~ " + fmtSec((float) rem) + "s)"
+                        "[SPEND:" + spec.key() + "] locked by cooldown (" + rem + "t ~ " + fmtSec((float) rem) + "s) ui=" + (spec.showUi() ? "on" : "off")
                     ));
                 }
                 continue;
@@ -57,7 +57,7 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                     tracker.clearKey(type, key);
                 }
                 if (debug) {
-                    sp.sendSystemMessage(Component.literal("[SPEND:" + spec.key() + "] locked"));
+                    sp.sendSystemMessage(Component.literal("[SPEND:" + spec.key() + "] locked ui=" + (spec.showUi() ? "on" : "off")));
                 }
                 if (spec.showUi()) {
                     Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
@@ -73,6 +73,11 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
             if (loss > 0f && procs == 0) {
                 unit.getSpendRuntime().markActivity(key, now);
                 unit.getSpendRuntime().markActive(type, key, spec);
+                if (spec.showUi()) {
+                    float curInit = tracker.getKeyProgress(key, type);
+                    boolean show = curInit > 0f;
+                    Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, show, curInit));
+                }
             }
             if (procs > 0) {
                 spec.onProc(sp, procs);
@@ -80,19 +85,19 @@ public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType t
                 if (spec.dropProgressOnProc()) {
                     tracker.clearKey(type, key);
                 }
-                if (debug) dbg(sp, "[SPEND:" + spec.key() + "] " + type.id + " ×" + procs + " (thr=" + fmt(threshold) + ")");
+                if (debug) dbg(sp, "[SPEND:" + spec.key() + "] " + type.id + " ×" + procs + " (thr=" + fmt(threshold) + ") ui=" + (spec.showUi() ? "on" : "off"));
                 if (spec.showUi()) {
                     Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, false, 0));
+                    if (debug) dbg(sp, "[UI:" + key + "] close " + type.id);
                 }
                 unit.getSpendRuntime().removeActive(type, key);
             } else {
                 float cur = tracker.getKeyProgress(key, type);
                 if (debug) {
-                    dbg(sp, "[SPEND:" + spec.key() + "] +" + fmt(loss) + " " + type.id + " (cur=" + fmt(cur) + " / " + fmt(threshold) + ")");
+                    dbg(sp, "[SPEND:" + spec.key() + "] +" + fmt(loss) + " " + type.id + " (cur=" + fmt(cur) + " / " + fmt(threshold) + ") ui=" + (spec.showUi() ? "on" : "off"));
                 }
                 if (spec.showUi()) {
-                    int cint = (int) cur;
-                    if (unit.getSpendRuntime().progressIntChanged(key, cint)) {
+                    if (unit.getSpendRuntime().progressScaledChanged(key, cur, 10)) {
                         boolean show = cur > 0f;
                         Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, show, cur));
                     }
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
index 0262a01ef..aa78d39ce 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java
@@ -81,6 +81,14 @@ public boolean progressIntChanged(String key, int intProgress) {
         return false;
     }
 
+    public boolean progressScaledChanged(String key, float progress, int perUnit) {
+        if (perUnit <= 1) {
+            return progressIntChanged(key, (int) progress);
+        }
+        int scaled = Math.round(progress * perUnit);
+        return progressIntChanged(key, scaled);
+    }
+
     // === Active key index ===
     public void markActive(ResourceType rt, String key, SpendThresholdSpec spec) {
         if (rt == null || key == null || key.isEmpty() || spec == null) return;
@@ -116,13 +124,7 @@ public void removeActive(ResourceType rt, String key) {
 
     public Set<String> getActiveKeys(ResourceType rt) {
         var s = activeByResource.get(rt);
-        if (s == null || s.isEmpty()) return java.util.Set.of();
-        var view = activeByResourceReadOnly.get(rt);
-        if (view == null) {
-            view = java.util.Collections.unmodifiableSet(s);
-            activeByResourceReadOnly.put(rt, view);
-        }
-        return view;
+        return (s == null || s.isEmpty()) ? java.util.Set.of() : java.util.Set.copyOf(s);
     }
 
     public SpendThresholdSpec getSpec(String key) {
diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
index c1fc32423..f4d1b26a0 100644
--- a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
+++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java
@@ -31,8 +31,8 @@ public SpendThresholdSpec(ResourceType resource,
                               int cooldownTicks,
                               boolean lockWhileCooldown,
                               boolean dropProgressWhileLocked,
-                              boolean dropProgressOnProc
-                              ) {
+                              boolean dropProgressOnProc,
+                              boolean showUi) {
         this.resource = resource;
         this.perLevelFactor = perLevelFactor;
         this.key = key;
@@ -41,6 +41,7 @@ public SpendThresholdSpec(ResourceType resource,
         this.lockWhileCooldown = lockWhileCooldown;
         this.dropProgressWhileLocked = dropProgressWhileLocked;
         this.dropProgressOnProc = dropProgressOnProc;
+        this.showUi = showUi;
     }
 
     // ===== accessors =====
@@ -52,6 +53,7 @@ public SpendThresholdSpec(ResourceType resource,
     public boolean dropProgressOnProc()         { return dropProgressOnProc; }
     public int cooldownTicks()                  { return cooldownTicks; }
     public int priority()                       { return priority; }
+    public boolean showUi()                     { return showUi; }
 
     
     public SpendThresholdSpec withPriority(int p) {
@@ -60,7 +62,7 @@ public SpendThresholdSpec withPriority(int p) {
     }
 
     public SpendThresholdSpec withShowUi(boolean on) {
-        return new SpendThresholdSpec(this.resource, this.perLevelFactor, this.key, this.lockWhileEffectIds, this.cooldownTicks, this.lockWhileCooldown, this.dropProgressWhileLocked, this.resetProgressOnProc, on) {
+        return new SpendThresholdSpec(this.resource, this.perLevelFactor, this.key, this.lockWhileEffectIds, this.cooldownTicks, this.lockWhileCooldown, this.dropProgressWhileLocked, this.dropProgressOnProc, on) {
             @Override public float thresholdFor(EntityData unit) { return SpendThresholdSpec.this.thresholdFor(unit); }
             @Override public void onProc(ServerPlayer sp, int procs) { SpendThresholdSpec.this.onProc(sp, procs); }
             @Override public boolean isLockedFor(EntityData unit) { return SpendThresholdSpec.this.isLockedFor(unit); }
diff --git a/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json b/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json
index 979ab5407..5741c2585 100644
--- a/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json
+++ b/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json
@@ -1,6 +1,7 @@
 {
     "key": "ENERGY_XLVL_WOTJ",
     "resource": "energy",
+    "show_ui": true,
     "enabled": true,
     "priority": 0,
     "threshold": {

From 53064b17a9be1fd6c481fa8eba3358d7316223b7 Mon Sep 17 00:00:00 2001
From: Dubledice <138730151+Dubledice@users.noreply.github.com>
Date: Fri, 5 Sep 2025 11:04:36 -0400
Subject: [PATCH 6/6] Culled Duplicate

---
 .../capability/entity/ResourceTracker.java         | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
index ada0504f3..507b45a00 100644
--- a/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
+++ b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java
@@ -111,20 +111,6 @@ public float getKeyProgress(String key, ResourceType rt) {
     }
 
 
-    /**
-     * Decrease the cursor by a fixed amount, clamped at zero. Returns the new value.
-     */
-    public float decayKeyProgress(String key, ResourceType rt, float amount) {
-        if (key == null || key.isEmpty() || amount <= 0f) return getKeyProgress(key, rt);
-        var byKey = keyProgress.get(rt);
-        if (byKey == null) return DEFAULT_KEY_PROGRESS;
-        float cur = byKey.getOrDefault(key, DEFAULT_KEY_PROGRESS);
-        float next = Math.max(0f, cur - amount);
-        if (next <= EPS) byKey.remove(key); else byKey.put(key, next);
-        if (byKey.isEmpty()) keyProgress.remove(rt);
-        return next;
-    }
-
     public void setKeyProgress(String key, ResourceType rt, float value) {
         if (key == null || key.isEmpty()) return;
         var byKey = keyProgress.computeIfAbsent(rt, __ -> new java.util.HashMap<>());