diff --git a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/exile_effects/adders/ModEffects.java b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/exile_effects/adders/ModEffects.java index 1ab033760..f46d0d29d 100644 --- a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/exile_effects/adders/ModEffects.java +++ b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/exile_effects/adders/ModEffects.java @@ -1,5 +1,6 @@ package com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; import com.robertx22.library_of_exile.registry.ExileRegistryInit; import com.robertx22.mine_and_slash.aoe_data.database.ailments.Ailments; import com.robertx22.mine_and_slash.aoe_data.database.exile_effects.ExileEffectBuilder; @@ -36,8 +37,10 @@ import java.util.ArrayList; import java.util.Arrays; +import java.util.EnumMap; import java.util.List; import java.util.UUID; +import java.util.Map; import static net.minecraft.world.entity.ai.attributes.Attributes.*; @@ -68,6 +71,8 @@ public class ModEffects implements ExileRegistryInit { public static EffectCtx BLIND = new EffectCtx("blind", "Blind", Elements.Shadow, EffectType.negative); public static EffectCtx STUN = new EffectCtx("stun", "Stun", Elements.Physical, EffectType.negative); public static EffectCtx GALE_FORCE = new EffectCtx("gale_force", "Gale Force", Elements.Physical, EffectType.beneficial); + public static EffectCtx WRATH_OF_THE_JUGGERNAUT = new EffectCtx("wrath_of_the_juggernaut", "Wrath of the Juggernaut", Elements.Physical, EffectType.beneficial); + public static EffectCtx BURNOUT = new EffectCtx("burnout", "Burnout", Elements.Physical, EffectType.negative); // these could be used for map affixes public static EffectCtx SLOW = new EffectCtx("slow", "Lethargy", Elements.Physical, EffectType.negative); @@ -100,6 +105,50 @@ public static List getCurses() { public static int ESSENCE_OF_FROST_MAX_STACKS = 5; + // ---------- Helper ---------- + private static EffectCtx state(String id, String name, Elements elem) { + return new EffectCtx(id, name, elem, EffectType.beneficial); + } + private static EffectCtx statePhysical(String id, String name) { + return state(id, name, Elements.Physical); + } + + // Pretty names for resources (UI text) + private static final Map RES_NAME = Map.of( + ResourceType.health, "Health", + ResourceType.mana, "Mana", + ResourceType.energy, "Energy", + ResourceType.magic_shield, "Magic Shield", + ResourceType.blood, "Blood" + ); + + // Suggested elements per resource (only used for coloring/category) + + // ---------- Generic flags ---------- + public static final EffectCtx LEECHING_STATE = state( + "leeching_state", "Leeching (State)", Elements.Physical + ); + public static final EffectCtx REGEN_STATE = state( + "regen_state", "Regenerating (State)", Elements.Physical + ); + + // ---------- Per-resource flags (generated) ---------- + public static final EnumMap LEECHING_STATE_BY_RES = new EnumMap<>(ResourceType.class); + public static final EnumMap REGEN_STATE_BY_RES = new EnumMap<>(ResourceType.class); + + static { + for (var rt : RES_NAME.keySet()) { + var nice = RES_NAME.get(rt); + + LEECHING_STATE_BY_RES.put( + rt, statePhysical("leeching_" + rt.id + "_state", "Leeching " + nice) + ); + REGEN_STATE_BY_RES.put( + rt, statePhysical("regen_" + rt.id + "_state", "Regenerating " + nice) + ); + } + } + public static void init() { } @@ -359,6 +408,22 @@ public void registerAll() { .addTags(EffectTags.song, EffectTags.offensive) .build(); + ExileEffectBuilder.of(WRATH_OF_THE_JUGGERNAUT) + .vanillaStat(VanillaStatData.create(ATTACK_SPEED, 0.30F, ModType.MORE, UUID.fromString("0c7a6e2c-5e5c-4f2f-9e3b-2a8e3c1a1f30"))) + .vanillaStat(VanillaStatData.create(KNOCKBACK_RESISTANCE, 1.0F, ModType.FLAT, UUID.fromString("a9d9c9f2-9f0f-4521-9c3e-9f7a1c2b5e11"))) + .stat(10, 10, DefenseStats.DAMAGE_REDUCTION.get(), ModType.FLAT) + .stat(100, 100, SpellChangeStats.COOLDOWN_REDUCTION_PER_SPELL_TAG.get(SpellTags.weapon_skill), ModType.FLAT) + .spell(SpellBuilder.forEffect() + .buildForEffect()) + .addTags(EffectTags.offensive) + .maxStacks(1) + .build(); + + ExileEffectBuilder.of(BURNOUT) + .maxStacks(1) + .addTags(EffectTags.negative) + .build(); + ExileEffectBuilder.of(REJUVENATE) .maxStacks(5) @@ -385,6 +450,24 @@ public void registerAll() { .tick(20D)) .buildForEffect()) .build(); + + // (NEW) Leeching & Healing + ExileEffectBuilder.of(LEECHING_STATE) + .maxStacks(1) + .build(); + + ExileEffectBuilder.of(REGEN_STATE) + .maxStacks(1) + .build(); + + // Register per-resource flags + for (EffectCtx ctx : LEECHING_STATE_BY_RES.values()) { + ExileEffectBuilder.of(ctx).maxStacks(1).build(); + } + + for (EffectCtx ctx : REGEN_STATE_BY_RES.values()) { + ExileEffectBuilder.of(ctx).maxStacks(1).build(); + } ExileEffectBuilder.of(BLIZZARD_REDUCE_HEAL_STRENGTH) .maxStacks(1) diff --git a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stat_effects/StatEffects.java b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stat_effects/StatEffects.java index c1ca620f8..be6f9fd00 100644 --- a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stat_effects/StatEffects.java +++ b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stat_effects/StatEffects.java @@ -7,7 +7,6 @@ import com.robertx22.mine_and_slash.aoe_data.database.spells.schools.WaterSpells; import com.robertx22.mine_and_slash.aoe_data.database.stats.base.EffectCtx; import com.robertx22.mine_and_slash.database.data.spells.components.actions.PositionSource; -import com.robertx22.mine_and_slash.uncommon.effectdatas.rework.action.MissingResourceScalingEffect; import com.robertx22.mine_and_slash.database.data.stats.layers.StatLayers; import com.robertx22.mine_and_slash.database.data.stats.types.resources.mana.Mana; import com.robertx22.mine_and_slash.mmorpg.MMORPG; @@ -19,6 +18,9 @@ import com.robertx22.mine_and_slash.uncommon.effectdatas.rework.number_provider.NumberProvider; import com.robertx22.mine_and_slash.uncommon.interfaces.EffectSides; import com.robertx22.mine_and_slash.uncommon.utilityclasses.AllyOrEnemy; +// (NEW) Import for new Leeching and Healing Helpers +import com.robertx22.mine_and_slash.uncommon.effectdatas.rework.condition.HasExileEffectCondition; + import java.util.ArrayList; import java.util.Arrays; @@ -202,6 +204,26 @@ public void registerAll() { } } + /** While leeching (any resource) on Source side. */ + public static HasExileEffectCondition whileLeeching() { + return new HasExileEffectCondition(ModEffects.LEECHING_STATE); + } + + /** While regenerating (any resource) on Source side. */ + public static HasExileEffectCondition whileRegen() { + return new HasExileEffectCondition(ModEffects.REGEN_STATE); + } + + /** While leeching a specific resource on Source side. */ + public static HasExileEffectCondition whileLeeching(ResourceType rt) { + return new HasExileEffectCondition(ModEffects.LEECHING_STATE_BY_RES.get(rt)); + } + + /** While regenerating a specific resource on Source side. */ + public static HasExileEffectCondition whileRegen(ResourceType rt) { + return new HasExileEffectCondition(ModEffects.REGEN_STATE_BY_RES.get(rt)); + } + // Resource scaling config for missing resource percentage // This is used to define how much stat to apply based on the percentage of missing resource diff --git a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/OffenseStats.java b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/OffenseStats.java index ef2605dcf..212da9278 100644 --- a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/OffenseStats.java +++ b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/OffenseStats.java @@ -1,10 +1,12 @@ package com.robertx22.mine_and_slash.aoe_data.database.stats; +import com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects; import com.robertx22.mine_and_slash.aoe_data.database.stat_conditions.StatConditions; import com.robertx22.mine_and_slash.aoe_data.database.stat_effects.StatEffects; import com.robertx22.mine_and_slash.aoe_data.database.stats.base.DatapackStatBuilder; import com.robertx22.mine_and_slash.aoe_data.database.stats.base.EmptyAccessor; import com.robertx22.mine_and_slash.database.data.stats.Stat; +import com.robertx22.mine_and_slash.database.data.stats.Stat.StatGroup; import com.robertx22.mine_and_slash.database.data.stats.StatGuiGroup; import com.robertx22.mine_and_slash.database.data.stats.StatScaling; import com.robertx22.mine_and_slash.database.data.stats.datapacks.test.DataPackStatAccessor; @@ -16,6 +18,7 @@ import com.robertx22.mine_and_slash.uncommon.effectdatas.DamageEvent; import com.robertx22.mine_and_slash.uncommon.effectdatas.SpendResourceEvent; import com.robertx22.mine_and_slash.uncommon.effectdatas.rework.EventData; +import com.robertx22.mine_and_slash.uncommon.effectdatas.rework.condition.HasExileEffectCondition; import com.robertx22.mine_and_slash.uncommon.enumclasses.AttackType; import com.robertx22.mine_and_slash.uncommon.enumclasses.Elements; import com.robertx22.mine_and_slash.uncommon.enumclasses.PlayStyle; @@ -580,6 +583,25 @@ public class OffenseStats { .build(); + // While Leeching (any) → contributes to existing Crit Damage bucket + public static final DataPackStatAccessor WHILE_LEECHING_MS_MORE_DAMAGE = DatapackStatBuilder + .ofSingle("while_leeching_ms_more_damage", Elements.Physical) + .worksWithEvent(DamageEvent.ID) + .setPriority(StatPriority.Damage.DAMAGE_LAYERS) + .setSide(EffectSides.Source) + .addCondition(new HasExileEffectCondition(ModEffects.LEECHING_STATE_BY_RES.get(ResourceType.magic_shield))) + .addCondition(StatConditions.IS_NOT_DOT) + .addEffect(StatEffects.Layers.ADDITIVE_DAMAGE_PERCENT) + .setLocName(x -> "More Damage while Leeching Magic Shield") + .setLocDesc(x -> Stat.VAL1 + "% More Damage While Leeching Magic Shield.") + .modifyAfterDone(x -> { + x.is_perc = true; // percent bonus + }) + .build(); + + + + public static void init() { } diff --git a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/ResourceStats.java b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/ResourceStats.java index 0257e4fa4..875bdf031 100644 --- a/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/ResourceStats.java +++ b/src/main/java/com/robertx22/mine_and_slash/aoe_data/database/stats/ResourceStats.java @@ -360,6 +360,21 @@ public class ResourceStats { }) .build(); + // Allows life leech to persist when at full Health (reservoir is NOT discarded). + public static final DataPackStatAccessor LEECH_AT_FULL_HEALTH = DatapackStatBuilder + .ofSingle("leech_at_full_health", Elements.Physical) + .setLocName(x -> "Leech at Full Health") + .setLocDesc(x -> "Allows Leech to Persist When at Full Health") + .modifyAfterDone(x -> { + x.is_perc = false; // treat as boolean (0 = off, >0 = on) + x.base = 0; + x.min = 0; + x.max = 1; + x.format = ChatFormatting.RED.getName(); + x.group = Stat.StatGroup.MAIN; + }) + .build(); + public static void init() { } diff --git a/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityData.java b/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityData.java index 9bfbb9c0c..b11c18b28 100644 --- a/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityData.java +++ b/src/main/java/com/robertx22/mine_and_slash/capability/entity/EntityData.java @@ -27,6 +27,7 @@ import com.robertx22.mine_and_slash.event_hooks.ontick.UnequipGear; import com.robertx22.mine_and_slash.event_hooks.player.OnLogin; import com.robertx22.mine_and_slash.loot.LootModifiersList; +import com.robertx22.mine_and_slash.mechanics.thresholds.SpendThresholdRuntime; import com.robertx22.mine_and_slash.mmorpg.MMORPG; import com.robertx22.mine_and_slash.mmorpg.SlashRef; import com.robertx22.mine_and_slash.saveclasses.CustomExactStatsData; @@ -959,6 +960,14 @@ public void onSpellHitTarget(Entity spellEntity, LivingEntity target) { } + // Tracks LOSS of resources (spend, drains, damage, etc.) + private final ResourceTracker resourceTracker = new ResourceTracker(); + public ResourceTracker getResourceTracker() { return resourceTracker; } + + private final SpendThresholdRuntime spendRuntime = new SpendThresholdRuntime(); + public SpendThresholdRuntime getSpendRuntime() { return spendRuntime; } + + public boolean alreadyHit(Entity spellEntity, LivingEntity target) { // this makes sure piercing projectiles hit target only once and then pass through 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 db7f134d4..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 @@ -4,55 +4,74 @@ import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; import com.robertx22.mine_and_slash.uncommon.MathHelper; -import java.util.HashMap; +import java.util.EnumMap; import java.util.Map; public class EntityLeechData { + private static final float EPS = 0.1f; + private final EnumMap store = new EnumMap<>(ResourceType.class); - private HashMap map = new HashMap<>(); - - public void addLeech(ResourceType type, float num) { - if (!map.containsKey(type)) { - map.put(type, 0f); + public void addLeech(ResourceType type, float amount) { + store.merge(type, amount, Float::sum); + if (store.getOrDefault(type, 0f) <= EPS) { + store.remove(type); } - float fi = num + map.get(type); - - map.put(type, fi); } - // todo implement expiration after 5s public void onSecondUseLeeches(EntityData data) { + for (Map.Entry en : store.entrySet()) { + ResourceType rt = en.getKey(); + float capPercentPerSec = data.getUnit() + .getCalculatedStat(ResourceStats.LEECH_CAP.get(rt)) + .getValue() / 100F; - // don't allow to accumulate more than x depending on total resource - // currently lets try with capping it to 5 seconds of regen. - for (Map.Entry en : map.entrySet()) { - float leechMaxPerSec = 5F * data.getUnit().getCalculatedStat(ResourceStats.LEECH_CAP.get(en.getKey())).getValue() / 100F; - float max = data.getMaximumResource(en.getKey()) * leechMaxPerSec; - float fi = MathHelper.clamp(en.getValue(), 0, max); - map.put(en.getKey(), fi); + float maxRes = data.getResources().getMax(data.entity, rt); + float fiveSecs = 5F * capPercentPerSec * maxRes; // “5 seconds worth” reservoir cap + float clamped = MathHelper.clamp(en.getValue(), 0, fiveSecs); + en.setValue(clamped); } - for (Map.Entry entry : map.entrySet()) { - float leechMaxPerSec = data.getUnit().getCalculatedStat(ResourceStats.LEECH_CAP.get(entry.getKey())).getValue() / 100F; + for (Map.Entry entry : store.entrySet()) { + ResourceType rt = entry.getKey(); + float reservoir = entry.getValue(); + if (reservoir <= EPS) continue; - float num = entry.getValue(); + float capPercentPerSec = data.getUnit() + .getCalculatedStat(ResourceStats.LEECH_CAP.get(rt)) + .getValue() / 100F; - if (num > 1) { - float maxres = data.getResources().getMax(data.entity, entry.getKey()); + float maxRes = data.getResources().getMax(data.entity, rt); + float perSecondCap = capPercentPerSec * maxRes; - float max = leechMaxPerSec * maxres; + float take = Math.min(reservoir, perSecondCap); + if (take <= EPS) continue; - if (num > max) { - num = max; - } + // Hook: a future stat could allow full-health leeching + final boolean allowFullLeech = data.getUnit() + .getCalculatedStat(ResourceStats.LEECH_AT_FULL_HEALTH.get()).getValue() > 0; + + float applied = data.getResources().restoreAndReturnApplied( + data.entity, rt, take, + com.robertx22.mine_and_slash.uncommon.effectdatas.rework.RestoreType.leech + ); + + if (applied <= EPS) { + boolean keepReservoir = + (rt == ResourceType.health) && allowFullLeech; // only health with talent - addLeech(entry.getKey(), -num); - data.getResources().restore(data.entity, entry.getKey(), num); + if (!keepReservoir) { + entry.setValue(0f); // discard reservoir + } + continue; } - } + entry.setValue(reservoir - take); + } + + 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 new file mode 100644 index 000000000..507b45a00 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/capability/entity/ResourceTracker.java @@ -0,0 +1,140 @@ +package com.robertx22.mine_and_slash.capability.entity; + +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. + */ +public class ResourceTracker { + private static final float EPS = 1e-4f; + private static final float DEFAULT_KEY_PROGRESS = 0f; + + private final java.util.EnumMap lost = new java.util.EnumMap<>(ResourceType.class); + + public void addLoss(ResourceType rt, float amount) { + if (amount <= 0f) return; + lost.merge(rt, amount, Float::sum); + } + + public float getLoss(ResourceType rt) { + return lost.getOrDefault(rt, 0f); + } + + public int consumeThresholds(ResourceType type, float threshold) { + if (threshold <= 0f) return 0; + float have = lost.getOrDefault(type, 0f); + if (have + EPS < threshold) return 0; + + int procs = (int) Math.floor((have + EPS) / threshold); + float remainder = have - procs * threshold; + + if (remainder <= EPS) lost.remove(type); + else lost.put(type, remainder); + return procs; + } + + public int consumeThresholdsAcross(java.util.Set types, float threshold) { + if (threshold <= 0f || types == null || types.isEmpty()) return 0; + + int procs = 0; + + while (total(types) + EPS >= threshold) { + float need = threshold; + + for (ResourceType rt : types) { + float have = lost.getOrDefault(rt, 0f); + if (have <= 0f) continue; + + float take = Math.min(have, need); + if (take > 0f) { + float remaining = have - take; + if (remaining <= EPS) lost.remove(rt); + else lost.put(rt, remaining); + need -= take; + } + if (need <= EPS) break; + } + procs++; + } + + for (ResourceType rt : types) { + if (lost.getOrDefault(rt, 0f) <= EPS) lost.remove(rt); + } + return procs; + } + + private float total(java.util.Set types) { + float sum = 0f; + for (ResourceType rt : types) sum += lost.getOrDefault(rt, 0f); + return sum; + } + + private final java.util.EnumMap> keyProgress = + new java.util.EnumMap<>(ResourceType.class); + + private java.util.Map getKeyProgressOrCreate(ResourceType rt) { + return keyProgress.computeIfAbsent(rt, __ -> new java.util.HashMap<>()); + } + + public void clearKey(ResourceType rt, String key) { + if (key == null || key.isEmpty()) return; + var byKey = keyProgress.get(rt); + if (byKey == null) return; + byKey.remove(key); + if (byKey.isEmpty()) { + keyProgress.remove(rt); + } + } + + public int addAndConsumeForKey(String key, ResourceType rt, float add, float threshold) { + if (key == null || key.isEmpty() || add <= 0f || threshold <= 0f) return 0; + + var byKey = getKeyProgressOrCreate(rt); + float cur = byKey.getOrDefault(key, DEFAULT_KEY_PROGRESS) + add; + + int procs = 0; + while (cur + EPS >= threshold) { + cur -= threshold; + procs++; + } + if (cur <= EPS) byKey.remove(key); + else byKey.put(key, cur); + + return procs; + } + + public float getKeyProgress(String key, ResourceType rt) { + var byKey = keyProgress.get(rt); + return byKey == null ? DEFAULT_KEY_PROGRESS : byKey.getOrDefault(key, DEFAULT_KEY_PROGRESS); + } + + + 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); + } + + 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; + } + + public void clear(ResourceType rt) { + lost.remove(rt); + } + + 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 efcde2d0a..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,8 @@ 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; import com.robertx22.mine_and_slash.saveclasses.gearitem.gear_bases.StatRangeInfo; @@ -27,6 +29,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 +255,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 (DebugHud.ON_EXPIRE) { + if (target instanceof ServerPlayer sp) { + 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) { + 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); + 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 (DebugHud.ON_EXPIRE && target instanceof ServerPlayer sp2) { + DebugHud.send(sp2, "expire_dispatched_" + GUID(), "[EFFECT][EXPIRE] Dispatched attached spell for " + GUID(), 400); + } + + 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()); + if (ctx.onExpireApplied != null && ctx.onExpireApplied.contains(effId)) { + continue; + } + var extraEff = ExileDB.ExileEffects().get(effId); + 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(); + 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(); + } + } } } - 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 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..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,9 +4,13 @@ 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; import net.minecraft.world.entity.LivingEntity; +import net.minecraft.server.level.ServerPlayer; import java.util.*; import java.util.stream.Collectors; @@ -131,6 +135,52 @@ 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 == EntityActivation.ON_EXPIRE) { + if (ctx.caster instanceof ServerPlayer spc) { + DebugHud.send(spc, "expire_action_" + part.type, "[EFFECT][EXPIRE] Action=" + part.type + " targets=" + list.size(), 400); + } + } + + if (!ctx.world.isClientSide && ctx.activation == EntityActivation.ON_EXPIRE + && part.type.equals(SpellAction.EXILE_EFFECT.GUID())) { + try { + String actionType = part.get(MapField.POTION_ACTION); + if (actionType == null || !actionType.equals(ExileEffectAction.GiveOrTake.GIVE_STACKS.name())) { + continue; + } + 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 (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 = 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) { + 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..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 @@ -59,6 +59,12 @@ public void tryActivate(Collection targets, SpellCtx ctx, MapHolde targets.forEach(t -> { if (RandomUtils.roll(chance)) { + // 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) .setSpell(ctx.calculatedSpellData.getSpell()) @@ -68,7 +74,11 @@ public void tryActivate(Collection targets, SpellCtx ctx, MapHolde potionEvent.spellid = ctx.calculatedSpellData.getSpell() .GUID(); - potionEvent.Activate(); + 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 onExpireEffectDurationTicks = java.util.Collections.emptyMap(); + public java.util.Set 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/my_events/EffectUtils.java b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java new file mode 100644 index 000000000..9bdaa0750 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/EffectUtils.java @@ -0,0 +1,71 @@ +package com.robertx22.mine_and_slash.event_hooks.my_events; + +import com.robertx22.mine_and_slash.aoe_data.database.stats.base.EffectCtx; +import com.robertx22.mine_and_slash.database.data.exile_effects.ExileEffect; +import com.robertx22.mine_and_slash.database.data.exile_effects.ExileEffectInstanceData; +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. + * + * Semantics: + * - Resolve the effect from {@link EffectCtx}. + * - Ensure a stored runtime instance exists (store.getOrCreate). + * - Refresh by taking MAX of existing vs. new stacks/ticks (never reduces). + * - Call effect.onApply(...) and mark the unit dirty for sync. + * + * Notes: + * - This variant is player-only by design. If you need NPCs/mobs later, + * add an overload for LivingEntity and only sync when the target is a ServerPlayer. + * - If resolve fails (null effect), we silently no-op; OnResourceRestore already + * provides a dev-only registry warning at the call site. + */ +public final class EffectUtils { + 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((LivingEntity) sp, effect, durationTicks, stacks); + } + + public static ExileEffectInstanceData applyEffect(ServerPlayer sp, ExileEffect effect, int durationTicks, int stacks) { + 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(entity); + var store = unit.getStatusEffectsData(); + var inst = store.getOrCreate(effect); + + 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); + + try { effect.onApply(entity); } catch (Exception ignored) {} + if (markDirty) { + unit.equipmentCache.STATUS.setDirty(); + if (entity instanceof ServerPlayer) { + unit.sync.setDirty(); + } + } + return inst; + } + + private static ExileEffect resolveEffect(EffectCtx ctx) { + ExileEffect eff = ExileDB.ExileEffects().get(ctx.resourcePath); + if (eff == null) eff = ExileDB.ExileEffects().get(ctx.id); + return eff; + } +} 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 new file mode 100644 index 000000000..27464f413 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceLost.java @@ -0,0 +1,27 @@ +package com.robertx22.mine_and_slash.event_hooks.my_events; + +import com.robertx22.mine_and_slash.mechanics.thresholds.SpendThresholdManager; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; +import com.robertx22.mine_and_slash.uncommon.datasaving.Load; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.entity.LivingEntity; + +public final class OnResourceLost { + private OnResourceLost() {} + + public enum LossSource { SpendOrDrain, Damage, Other } + + public static boolean DEBUG_ENABLED = false; + + public static void trigger(LivingEntity entity, ResourceType type, float loss, LossSource source) { + if (loss <= 0f) return; + if (!(entity instanceof ServerPlayer sp)) return; + + var unit = Load.Unit(sp); + long now = sp.level().getGameTime(); // ticks + SpendThresholdManager.processSpend(sp, unit, type, loss, now); + } +} + + + 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 new file mode 100644 index 000000000..d782bf693 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/event_hooks/my_events/OnResourceRestore.java @@ -0,0 +1,126 @@ +package com.robertx22.mine_and_slash.event_hooks.my_events; + +import com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects; +import com.robertx22.mine_and_slash.database.registry.ExileDB; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; +import com.robertx22.mine_and_slash.uncommon.effectdatas.rework.RestoreType; +import net.minecraft.network.chat.Component; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.entity.LivingEntity; + +import java.util.EnumSet; +import java.util.Locale; +import java.util.Map; +import java.util.Objects; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + + +public class OnResourceRestore { + + private static final int STATE_TICKS = 20; + + public static boolean DEBUG_ENABLED = false; + + public static float MIN_DEBUG_AMOUNT = 1.0f; + + private static final EnumSet DEBUG_TYPES = EnumSet.of(RestoreType.leech); + + private static final Map nextAllowedTick = new ConcurrentHashMap<>(); + private static final int PRINT_COOLDOWN_TICKS = 5; // 0.25s @20tps + + + public static void trigger(LivingEntity entity, + ResourceType type, + float amount, + RestoreType restoreType) { + if (amount <= 0) return; + + if (entity instanceof ServerPlayer sp) { + onRestore(sp, type, amount, restoreType); + } + + if (entity instanceof ServerPlayer sp) { + maybeDebugRestore(sp, type, amount, restoreType); + } + } + + // ====== RestoreType routing (single-responsibility helpers below) ====== + + private static void onRestore(ServerPlayer sp, + ResourceType type, + float amount, + RestoreType restoreType) { + switch (restoreType) { + case leech -> applyLeechStates(sp, type); + // === Add NEW RestoreType cases here === + // case -> applyNewKindStates(sp, type, amount); + default -> {} + } + } + + private static void applyLeechStates(ServerPlayer sp, ResourceType type) { + if (!ensureLeechEffectsPresent(sp, type)) { + return; + } + + EffectUtils.applyState(sp, ModEffects.LEECHING_STATE, STATE_TICKS, 1); + + var fx = ModEffects.LEECHING_STATE_BY_RES.get(type); + if (fx != null) { + EffectUtils.applyState(sp, fx, STATE_TICKS, 1); + } + } + + 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; + + if (DEBUG_ENABLED) { + sp.sendSystemMessage(Component.literal( + "[RESTORE][WARN] Missing leech effects: any=" + (anyFx != null) + + ", byRes=" + (byResFx != null) + + " id(any)=" + ModEffects.LEECHING_STATE.GUID() + + " id(byRes)=" + ModEffects.LEECHING_STATE_BY_RES.get(type).GUID() + )); + } + return false; + } + + private static void maybeDebugRestore(ServerPlayer sp, + ResourceType type, + float amount, + RestoreType restoreType) { + if (!DEBUG_ENABLED) return; + if (!DEBUG_TYPES.contains(restoreType)) return; + if (amount < MIN_DEBUG_AMOUNT) return; + + long now = sp.level().getGameTime(); + Key key = new Key(sp.getUUID(), type, restoreType); + long allowedAt = nextAllowedTick.getOrDefault(key, 0L); + if (now < allowedAt) return; + + String msg = String.format(Locale.US, + "[RESTORE] +%.1f %s via %s", amount, type.name(), restoreType.name()); + sp.sendSystemMessage(Component.literal(msg)); + nextAllowedTick.put(key, now + PRINT_COOLDOWN_TICKS); + } + + // ====== internals ====== + + private record Key(UUID player, ResourceType type, RestoreType restoreType) { + @Override public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof Key k)) return false; + return Objects.equals(player, k.player) && type == k.type && restoreType == k.restoreType; + } + @Override public int hashCode() { return Objects.hash(player, type, restoreType); } + } +} + + + + + \ No newline at end of file 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..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 @@ -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,38 @@ public static void onEndTick(ServerPlayer player) { playerData.spellCastingData.charges.onTicks(player, 5); } + if (age % 20 == 0) { + long now = player.level().getGameTime(); + var unit = Load.Unit(player); + if (unit != null) { + for (var rt : 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; + unit.getSpendRuntime().markDecay(key, now); + + float thr = spec.thresholdFor(unit); + if (thr <= 0f) continue; + float decayPerSecond = thr * 0.15f; // Decay rate: 15% of Threshold per second + float newVal = unit.getResourceTracker().decayKeyProgress(key, rt, decayPerSecond); + if (unit.getSpendRuntime().progressScaledChanged(key, newVal, 10)) { + 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..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 @@ -34,7 +34,7 @@ public static void render(GuiGraphics gui, boolean horizontal) { // Minecraft mc = Minecraft.getInstance(); for (Map.Entry 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,37 @@ public static void render(GuiGraphics gui, boolean horizontal) { } } + 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; + + 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); + + 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 new file mode 100644 index 000000000..df2de7f0d --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/DataDrivenSpendThresholdSpec.java @@ -0,0 +1,61 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds; + +import com.robertx22.mine_and_slash.capability.entity.EntityData; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; +import net.minecraft.server.level.ServerPlayer; + +import javax.annotation.Nullable; +import java.util.Set; + +public class DataDrivenSpendThresholdSpec extends SpendThresholdSpec { + + public enum ThresholdMode { FLAT, PERCENT_OF_MAX } + + private final ThresholdMode mode; + private final float value; + private final boolean multiplyByLevel; + @Nullable private final ResourceType percentMaxOf; + + public DataDrivenSpendThresholdSpec( + String key, + ResourceType resource, + ThresholdMode mode, + float value, + boolean multiplyByLevel, + @Nullable ResourceType percentMaxOf, + Set lockWhileEffectIds, + int cooldownTicks, + boolean lockWhileCooldown, + boolean dropProgressWhileLocked, + boolean dropProgressOnProc, + boolean showUi + ) { + super(resource, 0f, key, + lockWhileEffectIds, cooldownTicks, lockWhileCooldown, dropProgressWhileLocked, dropProgressOnProc, showUi); + this.mode = mode; + this.value = value; + this.multiplyByLevel = multiplyByLevel; + this.percentMaxOf = percentMaxOf; + } + + + @Override + public float thresholdFor(EntityData unit) { + float base; + switch (mode) { + case PERCENT_OF_MAX -> { + ResourceType tgt = (percentMaxOf != null) ? percentMaxOf : resource(); + float max = unit.getResources().getMax(unit.getEntity(), tgt); + base = (value / 100f) * max; + } + 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) { + } +} 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 new file mode 100644 index 000000000..1eaf4b3e3 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdManager.java @@ -0,0 +1,119 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds; + +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() {} + + public static void registerDefaults() { + } + + // ===== DEBUGGING ===== + public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType type, float loss, long now) { + processSpend(sp, unit, type, loss, now, OnResourceLost.DEBUG_ENABLED); + } + + public static void processSpend(ServerPlayer sp, EntityData unit, ResourceType type, float loss, long now, boolean debug) { + if (loss <= 0f) return; + + var tracker = unit.getResourceTracker(); + tracker.addLoss(type, loss); + + var specs = SpendThresholdRegistry.resolveFor(unit, type); + if (specs.isEmpty()) { + if (debug) { + sp.sendSystemMessage(Component.literal( + "[SPEND] +" + String.format(java.util.Locale.US, "%.1f", loss) + + " " + type.id + " (no specs)" + )); + } + return; + } + + for (SpendThresholdSpec spec : specs) { + final String key = spec.keyFor(unit); + + if (spec.lockWhileCooldown() && unit.getSpendRuntime().isCoolingDown(key, now)) { + if (spec.dropProgressWhileLocked()) { + tracker.clearKey(type, key); + } + 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) ui=" + (spec.showUi() ? "on" : "off") + )); + } + continue; + } + + if (spec.isLockedFor(unit)) { + if (spec.dropProgressWhileLocked()) { + tracker.clearKey(type, key); + } + if (debug) { + 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)); + } + continue; + } + + + float threshold = spec.thresholdFor(unit); + if (threshold <= 0f) continue; + + int procs = tracker.addAndConsumeForKey(key, type, loss, threshold); + 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); + spec.startCooldown(unit, now); + if (spec.dropProgressOnProc()) { + tracker.clearKey(type, key); + } + 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) + ") ui=" + (spec.showUi() ? "on" : "off")); + } + if (spec.showUi()) { + if (unit.getSpendRuntime().progressScaledChanged(key, cur, 10)) { + boolean show = cur > 0f; + Packets.sendToClient(sp, new ThresholdUiPacket(key, type.id, show, cur)); + } + } + if (cur <= 0f) { + unit.getSpendRuntime().removeActive(type, key); + } + } + } + } + + // --- helpers --- + private static void dbg(ServerPlayer sp, String msg) { + if (!OnResourceLost.DEBUG_ENABLED) return; + 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/SpendThresholdRegistry.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRegistry.java new file mode 100644 index 000000000..2305f408c --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRegistry.java @@ -0,0 +1,41 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds; + +import com.robertx22.mine_and_slash.capability.entity.EntityData; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; + +import java.util.*; + +public final class SpendThresholdRegistry { + private SpendThresholdRegistry() {} + + private static final Map> BY_RES = new EnumMap<>(ResourceType.class); + private static boolean FROZEN = false; + private static int COUNT = 0; + + public static void clearAll() { + BY_RES.clear(); + FROZEN = false; + COUNT = 0; + } + + public static void registerGlobal(SpendThresholdSpec spec) { registerGlobal(spec, 0); } + + public static void registerGlobal(SpendThresholdSpec spec, int priority) { + if (spec == null || FROZEN) return; + spec.withPriority(priority); + BY_RES.computeIfAbsent(spec.resource(), __ -> new ArrayList<>()).add(spec); + COUNT++; + } + + /** Returns a copy sorted by priority (low first). */ + public static List resolveFor(EntityData unit, ResourceType rt) { + var list = BY_RES.get(rt); + if (list == null || list.isEmpty()) return List.of(); + var copy = new ArrayList<>(list); + copy.sort(Comparator.comparingInt(SpendThresholdSpec::priority)); + return copy; + } + + public static void freeze() { FROZEN = true; } + public static int size() { return COUNT; } +} 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 new file mode 100644 index 000000000..aa78d39ce --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdRuntime.java @@ -0,0 +1,135 @@ +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 { + + private static final class KeyState { + long cooldownUntil; + long lastActivityTick; + long lastDecayTick; + int lastProgressIntSent = Integer.MIN_VALUE; + SpendThresholdSpec spec; + } + + private final Map states = new HashMap<>(); + + private final java.util.EnumMap> activeByResource = new java.util.EnumMap<>(ResourceType.class); + private final java.util.EnumMap> activeByResourceReadOnly = new java.util.EnumMap<>(ResourceType.class); + + public void startCooldown(String key, long now, int cooldownTicks) { + if (cooldownTicks <= 0) return; + if (key == null || key.isEmpty()) return; + KeyState ks = states.computeIfAbsent(key, __ -> new KeyState()); + ks.cooldownUntil = now + cooldownTicks; + } + + public boolean isCoolingDown(String key, long now) { + 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) { + 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); + } + + // === Activity/Decay tracking === + public void markActivity(String key, long now) { + if (key == null || key.isEmpty()) return; + KeyState ks = states.computeIfAbsent(key, __ -> new KeyState()); + ks.lastActivityTick = now; + ks.lastDecayTick = 0L; + } + + public long getLastActivity(String key) { + if (key == null || key.isEmpty()) return 0L; + KeyState ks = states.get(key); + return ks == null ? 0L : ks.lastActivityTick; + } + + public long getLastDecay(String key) { + 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; + KeyState ks = states.computeIfAbsent(key, __ -> new KeyState()); + ks.lastDecayTick = now; + } + + public boolean progressIntChanged(String key, int 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; + } + + 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; + Set 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) { + 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); + 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; + } + } + + public Set getActiveKeys(ResourceType rt) { + var s = activeByResource.get(rt); + return (s == null || s.isEmpty()) ? java.util.Set.of() : java.util.Set.copyOf(s); + } + + public SpendThresholdSpec getSpec(String 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 new file mode 100644 index 000000000..f4d1b26a0 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/SpendThresholdSpec.java @@ -0,0 +1,98 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds; + +import com.robertx22.mine_and_slash.capability.entity.EntityData; +import com.robertx22.mine_and_slash.database.data.exile_effects.ExileEffect; +import com.robertx22.mine_and_slash.database.registry.ExileDB; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; +import net.minecraft.server.level.ServerPlayer; + +import java.util.Collections; +import java.util.Set; + + +public abstract class SpendThresholdSpec { + private final ResourceType resource; + private final float perLevelFactor; + private final String key; + + private final Set lockWhileEffectIds; + private final int cooldownTicks; + 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 dropProgressOnProc; + private final boolean showUi; + + private int priority = 0; + + public SpendThresholdSpec(ResourceType resource, + float perLevelFactor, + String key, + Set lockWhileEffectIds, + int cooldownTicks, + boolean lockWhileCooldown, + boolean dropProgressWhileLocked, + boolean dropProgressOnProc, + boolean showUi) { + this.resource = resource; + this.perLevelFactor = perLevelFactor; + this.key = key; + this.lockWhileEffectIds = (lockWhileEffectIds == null) ? Collections.emptySet() : Set.copyOf(lockWhileEffectIds); + this.cooldownTicks = Math.max(0, cooldownTicks); + this.lockWhileCooldown = lockWhileCooldown; + this.dropProgressWhileLocked = dropProgressWhileLocked; + this.dropProgressOnProc = dropProgressOnProc; + this.showUi = showUi; + } + + // ===== accessors ===== + public ResourceType resource() { return resource; } + public String key() { return key; } + public String keyFor(EntityData unit) { return key; } + public boolean lockWhileCooldown() { return lockWhileCooldown; } + public boolean dropProgressWhileLocked() { return dropProgressWhileLocked; } + 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) { + this.priority = p; + return this; + } + + public SpendThresholdSpec withShowUi(boolean 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); } + }.withPriority(this.priority); + } + + public float thresholdFor(EntityData unit) { + return Math.max(0f, perLevelFactor * Math.max(1, unit.getLevel())); + } + + public boolean isEffectLocked(EntityData unit) { + if (lockWhileEffectIds.isEmpty()) return false; + var store = unit.getStatusEffectsData(); + for (String id : lockWhileEffectIds) { + ExileEffect effect = ExileDB.ExileEffects().get(id); + if (effect != null && store.has(effect)) return true; + } + return false; + } + + public boolean isLockedFor(EntityData unit) { + return isEffectLocked(unit); + } + + public void startCooldown(EntityData unit, long now) { + if (cooldownTicks > 0) { + unit.getSpendRuntime().startCooldown(keyFor(unit), now, cooldownTicks); + } + } + + public abstract void onProc(ServerPlayer sp, int procs); + +} diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ThresholdsInit.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ThresholdsInit.java new file mode 100644 index 000000000..77aa79389 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ThresholdsInit.java @@ -0,0 +1,17 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds; + +import com.robertx22.mine_and_slash.mmorpg.SlashRef; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; + +@Mod.EventBusSubscriber(modid = SlashRef.MODID, bus = Mod.EventBusSubscriber.Bus.MOD) +public final class ThresholdsInit { + private ThresholdsInit() {} + + @SubscribeEvent + public static void onCommonSetup(final FMLCommonSetupEvent e) { + e.enqueueWork(SpendThresholdManager::registerDefaults); + System.out.println("[SpendThresholds] defaults registered"); + } +} 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 new file mode 100644 index 000000000..aabccd1df --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdDef.java @@ -0,0 +1,146 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds.datapack; + +import com.google.gson.annotations.SerializedName; +import com.robertx22.mine_and_slash.mechanics.thresholds.DataDrivenSpendThresholdSpec; +import com.robertx22.mine_and_slash.mechanics.thresholds.SpendThresholdSpec; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; +import net.minecraft.server.level.ServerPlayer; +import com.robertx22.mine_and_slash.capability.entity.EntityData; +import com.robertx22.mine_and_slash.database.registry.ExileDB; +import com.robertx22.mine_and_slash.event_hooks.my_events.EffectUtils; + +import java.util.*; + +public class SpendThresholdDef { + public String key; + public String resource = ""; + public boolean enabled = true; + public int priority = 0; + @SerializedName("show_ui") + public boolean showUi = false; + + 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; + } + public Threshold threshold = new Threshold(); + + public static class Locks { + public List effects = new ArrayList<>(); + @SerializedName("lock_while_cooldown") public boolean lockWhileCooldown = false; + @SerializedName("drop_progress_while_locked") public boolean dropProgressWhileLocked = true; + @SerializedName("drop_progress_on_proc") public boolean dropProgressOnProc = true; + } + public Locks locks = new Locks(); + + @SerializedName("cooldown_ticks") + public int cooldownTicks = 0; + + @SerializedName("require_stat") + public String requireStatId = ""; + + public static class ProcAction { + public String action; // "apply_effect" + @SerializedName("exile_potion_id") public String effectId; + @SerializedName("duration_ticks") public int durationTicks = 0; + public int stacks = 1; + @SerializedName("on_expire") public java.util.Map onExpire = java.util.Collections.emptyMap(); + } + @SerializedName("on_proc") + public List onProc = new ArrayList<>(); + + public SpendThresholdSpec toSpec() { + ResourceType res = parseResource(resource, ResourceType.energy); + + 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.PERCENT_OF_MAX; + } else { + mode = DataDrivenSpendThresholdSpec.ThresholdMode.FLAT; // default + treats legacy values as FLAT + } + + ResourceType percentOf = null; + 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 + } + + Set lockEff = (locks != null && locks.effects != null) + ? new HashSet<>(locks.effects) : Collections.emptySet(); + + return new DataDrivenSpendThresholdSpec( + key, + res, + mode, + threshold.value, + mult, + percentOf, + lockEff, + cooldownTicks, + locks != null && locks.lockWhileCooldown, + locks != null && locks.dropProgressWhileLocked, + locks != null && locks.dropProgressOnProc, + showUi + ) { + @Override + public void onProc(ServerPlayer sp, int procs) { + if (onProc == null || onProc.isEmpty()) return; + + var unit = com.robertx22.mine_and_slash.uncommon.datasaving.Load.Unit(sp); + var store = unit.getStatusEffectsData(); + + for (ProcAction a : onProc) { + if (!"exile_effect".equalsIgnoreCase(a.action) || a.effectId == null) continue; + var effect = ExileDB.ExileEffects().get(a.effectId); + if (effect == null) continue; + + int durTicks = Math.max(1, a.durationTicks); + int stacks = Math.max(1, a.stacks); + var inst = EffectUtils.applyEffect(sp, effect, durTicks, stacks); + + if (a.onExpire != null && !a.onExpire.isEmpty()) { + if (inst.onExpireEffectDurationTicks == null) { + inst.onExpireEffectDurationTicks = new java.util.HashMap<>(); + } + for (var e : a.onExpire.entrySet()) { + int ticks = Math.max(0, e.getValue()); + if (ticks > 0) { + inst.onExpireEffectDurationTicks.put(e.getKey(), ticks); + } + } + } + } + } + + @Override + public boolean isLockedFor(EntityData unit) { + if (super.isEffectLocked(unit)) return true; + if (requireStatId != null && !requireStatId.isEmpty()) { + var st = ExileDB.Stats().get(requireStatId); + if (st != null) { + return unit.getUnit().getCalculatedStat(st).getValue() <= 0; + } + } + return false; + } + }.withPriority(priority); + } + + // --- helpers --- + private static ResourceType parseResource(String s, ResourceType fallback) { + if (s == null) return fallback; + for (ResourceType rt : ResourceType.values()) { + if (rt.name().equalsIgnoreCase(s)) return rt; + try { + var idField = rt.getClass().getField("id"); + Object idVal = idField.get(rt); + if (idVal instanceof String && ((String) idVal).equalsIgnoreCase(s)) return rt; + } catch (NoSuchFieldException | IllegalAccessException ignored) {} + } + return fallback; + } +} diff --git a/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdsReloadListener.java b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdsReloadListener.java new file mode 100644 index 000000000..1b2ccbac0 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/datapack/SpendThresholdsReloadListener.java @@ -0,0 +1,51 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds.datapack; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonElement; +import com.robertx22.mine_and_slash.mechanics.thresholds.SpendThresholdRegistry; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.server.packs.resources.ResourceManager; +import net.minecraft.util.profiling.ProfilerFiller; +import net.minecraftforge.event.AddReloadListenerEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; +import net.minecraft.server.packs.resources.SimpleJsonResourceReloadListener; + +import java.util.Map; + +@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.FORGE) +public class SpendThresholdsReloadListener extends SimpleJsonResourceReloadListener { + private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create(); + + public SpendThresholdsReloadListener() { + super(GSON, "spend_thresholds"); + } + + @Override + protected void apply(Map map, + ResourceManager rm, ProfilerFiller profiler) { + SpendThresholdRegistry.clearAll(); + + int loaded = 0; + for (var e : map.entrySet()) { + try { + SpendThresholdDef def = GSON.fromJson(e.getValue(), SpendThresholdDef.class); + if (def != null && def.enabled && def.key != null && !def.key.isEmpty()) { + SpendThresholdRegistry.registerGlobal(def.toSpec(), def.priority); + loaded++; + } + } catch (Exception ex) { + System.err.println("[SpendThresholds] Failed " + e.getKey() + ": " + ex.getMessage()); + } + } + + SpendThresholdRegistry.freeze(); + System.out.println("[SpendThresholds] Loaded " + loaded + " datapack specs; total=" + SpendThresholdRegistry.size()); + } + + @SubscribeEvent + public static void onAddReload(AddReloadListenerEvent evt) { + evt.addListener(new SpendThresholdsReloadListener()); + } +} 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..c8226610f --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mechanics/thresholds/ui/ThresholdUiClient.java @@ -0,0 +1,41 @@ +package com.robertx22.mine_and_slash.mechanics.thresholds.ui; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +public final class ThresholdUiClient { + private ThresholdUiClient() {} + + private static final Map keyToResource = new HashMap<>(); + private static final Map 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 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..191a552d2 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/mmorpg/DebugHud.java @@ -0,0 +1,33 @@ +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() {} + + public static volatile boolean ON_EXPIRE = false; + + private static final java.util.concurrent.ConcurrentHashMap 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/event_registers/CommonEvents.java b/src/main/java/com/robertx22/mine_and_slash/mmorpg/event_registers/CommonEvents.java index a30d2cfd6..bb6e7d15c 100644 --- a/src/main/java/com/robertx22/mine_and_slash/mmorpg/event_registers/CommonEvents.java +++ b/src/main/java/com/robertx22/mine_and_slash/mmorpg/event_registers/CommonEvents.java @@ -4,6 +4,7 @@ import com.robertx22.library_of_exile.events.base.ExileEvents; import com.robertx22.mine_and_slash.database.DatabaseCaches; import com.robertx22.mine_and_slash.database.data.spells.summons.entity.SummonEntity; +import com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost; import com.robertx22.mine_and_slash.event_hooks.damage_hooks.LivingHurtUtils; import com.robertx22.mine_and_slash.event_hooks.damage_hooks.reworked.NewDamageMain; import com.robertx22.mine_and_slash.event_hooks.entity.OnMobSpawn; @@ -62,6 +63,14 @@ public static void register() { }); + ForgeEvents.registerForgeEvent(LivingDamageEvent.class, evt -> { + if (!(evt.getEntity() instanceof ServerPlayer sp)) return; + float applied = evt.getAmount(); + if (applied > 0f) { + OnResourceLost.trigger(sp, ResourceType.health, applied, OnResourceLost.LossSource.Damage); + } + }); + OnItemInteract.register(); 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 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/saveclasses/unit/ResourcesData.java b/src/main/java/com/robertx22/mine_and_slash/saveclasses/unit/ResourcesData.java index dd4f5275e..291ad1e20 100644 --- a/src/main/java/com/robertx22/mine_and_slash/saveclasses/unit/ResourcesData.java +++ b/src/main/java/com/robertx22/mine_and_slash/saveclasses/unit/ResourcesData.java @@ -3,6 +3,7 @@ import com.robertx22.mine_and_slash.capability.entity.EntityData; import com.robertx22.mine_and_slash.config.forge.ServerContainer; import com.robertx22.mine_and_slash.database.data.stats.types.resources.energy.Energy; +import com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost; import com.robertx22.mine_and_slash.uncommon.datasaving.Load; import com.robertx22.mine_and_slash.uncommon.effectdatas.SpendResourceEvent; import com.robertx22.mine_and_slash.uncommon.enumclasses.ModType; @@ -114,25 +115,125 @@ public void spend(LivingEntity en, ResourceType type, float amount) { modify(en, Use.SPEND, type, amount); } + // (START NEW) Overload with RestoreType — callers who know the type should use this + public void restore(LivingEntity en, ResourceType type, float amount, + com.robertx22.mine_and_slash.uncommon.effectdatas.rework.RestoreType rtype) { + if (amount <= 0) return; + + float applied = applyRestoreAndReturnApplied(en, type, amount); // NEW + if (applied <= 0) return; // nothing actually restored (e.g., full health) + + // Fire the unified event with the true applied amount + com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceRestore.trigger(en, type, applied, rtype); + } + + // Overload without RestoreType public void restore(LivingEntity en, ResourceType type, float amount) { - modify(en, Use.RESTORE, type, amount); + // Default to regen when no context is provided + restore(en, type, amount, + com.robertx22.mine_and_slash.uncommon.effectdatas.rework.RestoreType.regen); + } + + // Returns the LEECH actual amount that was applied (0 if capped) + public float restoreAndReturnApplied(LivingEntity en, ResourceType type, float amount, + com.robertx22.mine_and_slash.uncommon.effectdatas.rework.RestoreType rtype) { + if (amount <= 0) return 0f; + float applied = applyRestoreAndReturnApplied(en, type, amount); + if (applied > 0f) { + com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceRestore.trigger(en, type, applied, rtype); + } + return applied; + } + + // Returns the REGEN actual amount that was applied (0 if capped) + private float applyRestoreAndReturnApplied(LivingEntity en, ResourceType type, float amount) { + float applied = applyAndReturnAppliedClamped(en, type, amount); // unified path + cap(en, type); // harmless no-op if already clamped + sync(en); + return applied; + } + + // Returns the current value for non-Health resources (Health uses HealthUtils) + private float getCurrent(ResourceType type, LivingEntity en) { + return switch (type) { + case mana -> mana; + case blood -> blood; + case energy -> energy; + case magic_shield -> magic_shield; + case health -> HealthUtils.getCurrentHealth(en); + }; + } + + private void setCurrent(ResourceType type, float value) { + switch (type) { + case mana -> mana = value; + case blood -> blood = value; + case energy -> energy = value; + case magic_shield -> magic_shield = value; + case health -> { /* health is applied via heal() below */ } + } } + /** + * Compute applied AFTER clamping to max, then write the new value. + * Health heals via HealthUtils; others assign the clamped value. + */ + private float applyAndReturnAppliedClamped(LivingEntity en, ResourceType type, float amount) { + if (amount <= 0f) return 0f; + + float before = getCurrent(type, en); + float max = getMax(en, type); // you already have this method + float after = Math.max(0f, Math.min(before + amount, max)); + float applied = Math.max(0f, after - before); + + if (applied <= 0f) return 0f; + + if (type == ResourceType.health) { + HealthUtils.heal(en, applied); // apply only what fits + } else { + setCurrent(type, after); // write clamped value + } + return applied; + } + // ===(END NEW)=== + + public void modify(LivingEntity en, Use use, ResourceType type, float amount) { - if (amount == 0) { - return; + if (amount == 0f) return; + + // Health restore goes through vanilla heal (keeps heart UI etc.) + if (type == ResourceType.health) { + if (use == Use.RESTORE) { + HealthUtils.heal(en, amount); + cap(en, type); + sync(en); + } else { + // Optional: warn if someone tries to "spend" health via this path + // en.sendSystemMessage(Component.literal("[WARN] modify() called with SPEND health")); + } + return; // done with health either way } + + // --- non-health resources (mana, energy, blood, magic_shield) --- + float before = get(en, type); + float newVal = getModifiedValue(en, type, use, amount); + if (type == ResourceType.mana) { - mana = getModifiedValue(en, type, use, amount); + mana = newVal; } else if (type == ResourceType.blood) { - blood = getModifiedValue(en, type, use, amount); + blood = newVal; } else if (type == ResourceType.energy) { - energy = getModifiedValue(en, type, use, amount); + energy = newVal; } else if (type == ResourceType.magic_shield) { - magic_shield = getModifiedValue(en, type, use, amount); - } else if (type == ResourceType.health) { - if (use == Use.RESTORE) { - HealthUtils.heal(en, amount); + magic_shield = newVal; + } // health spend/drain is handled via damage events + + // Notify spend tracker only on SPEND for non-health + if (use == Use.SPEND) { + float spent = Math.max(0f, before - Math.max(newVal, 0f)); + if (spent > 0f) { + OnResourceLost.trigger(en, type, spent, OnResourceLost.LossSource.SpendOrDrain + ); } } cap(en, type); diff --git a/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/DamageEvent.java b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/DamageEvent.java index 827dc6e08..435c562ac 100644 --- a/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/DamageEvent.java +++ b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/DamageEvent.java @@ -627,6 +627,17 @@ protected void activate() { dmg = DamageAbsorbedByMana.modifyEntityDamage(this, dmg); dmg = MagicShield.modifyEntityDamage(this, dmg); } + + // (START NEW) trigger resource lost event for health + if (target instanceof ServerPlayer sp) { + com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost.trigger( + sp, + com.robertx22.mine_and_slash.saveclasses.unit.ResourceType.health, + dmg, + com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceLost.LossSource.Damage + ); + } + // (END NEW) float vanillaDamage = HealthUtils.realToVanilla(target, dmg); 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/uncommon/effectdatas/RestoreResourceEvent.java b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/RestoreResourceEvent.java index 8d294ccbc..c6737d022 100644 --- a/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/RestoreResourceEvent.java +++ b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/RestoreResourceEvent.java @@ -54,7 +54,12 @@ protected void activate() { } } - this.targetData.getResources().restore(target, data.getResourceType(), num); + // Guard against no-op / negative input after scaling + if (num <= 0) { + return; + } + + this.targetData.getResources().restore(target, data.getResourceType(), num,data.getRestoreType()); if (this.data.getResourceType() == ResourceType.health) { if (data.getRestoreType() == RestoreType.heal) { diff --git a/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/rework/condition/HasExileEffectCondition.java b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/rework/condition/HasExileEffectCondition.java new file mode 100644 index 000000000..527be18f3 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/uncommon/effectdatas/rework/condition/HasExileEffectCondition.java @@ -0,0 +1,133 @@ +package com.robertx22.mine_and_slash.uncommon.effectdatas.rework.condition; + +import com.robertx22.mine_and_slash.aoe_data.database.stats.base.EffectCtx; +import com.robertx22.mine_and_slash.database.data.exile_effects.ExileEffect; +import com.robertx22.mine_and_slash.database.registry.ExileDB; +import com.robertx22.mine_and_slash.database.data.stats.Stat; +import com.robertx22.mine_and_slash.saveclasses.unit.StatData; +import com.robertx22.mine_and_slash.uncommon.datasaving.Load; +import com.robertx22.mine_and_slash.uncommon.effectdatas.EffectEvent; +import com.robertx22.mine_and_slash.uncommon.interfaces.EffectSides; +import com.robertx22.mine_and_slash.saveclasses.unit.ResourceType; +import net.minecraft.network.chat.Component; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.entity.LivingEntity; + +/** + * Datapack-serializable condition that returns true iff the chosen side + * (Source/Target) currently has a given {@link ExileEffect} active. + * + * Usage in code: + * .setSide(EffectSides.Source) + * .addCondition(new HasExileEffectCondition(ModEffects.LEECHING_STATE)) // e.g. "while leeching" + * + * Usage in datapack JSON (shape depends on your builder/serializer wiring): + * { + * "type": "has_exile_effect", + * "effectId": "leeching_state" + * } + * + * Notes: + * - We rely on the store's real state via `has(fx)` (correct now that apply uses getOrCreate()). + * - Keep this condition lightweight: just resolve the effect and query the status store. + * - Debug can be toggled globally via OnResourceRestore.DEBUG_ENABLED (no spam by default). + */ +public class HasExileEffectCondition extends StatCondition { + + /** Serialized id of the effect to check (e.g., "leeching_state"). */ + public String effectId = ""; + + /** Stable serializer id (must match your registry/serializer entry). */ + private static final String SER_ID = "has_exile_effect"; + + /** Convenience ctor for code paths (accepts an EffectCtx like ModEffects.LEECHING_STATE). */ + public HasExileEffectCondition(EffectCtx ctx) { + super(SER_ID + "_" + ctx.resourcePath, SER_ID); + this.effectId = ctx.resourcePath; + } + + /** No-arg ctor for (de)serialization. */ + public HasExileEffectCondition() { + super("", SER_ID); + } + + @Override + public boolean can(EffectEvent event, EffectSides statSource, StatData data, Stat stat) { + if (effectId == null || effectId.isEmpty()) return false; + + // Resolve the effect definition + final ExileEffect fx = ExileDB.ExileEffects().get(effectId); + if (fx == null) return false; + + // Pick the entity to check based on the stat's side (match the stat!) + final LivingEntity who = (statSource == EffectSides.Source) ? event.source : event.target; + if (who == null) return false; + + // Read live status (no allocations): true iff stored instance exists AND is not removed + final var effData = Load.Unit(who).getStatusEffectsData(); + final boolean has = (effData != null) && effData.has(fx); + + // Optional lightweight debug (off by default) + if (com.robertx22.mine_and_slash.event_hooks.my_events.OnResourceRestore.DEBUG_ENABLED + && who instanceof ServerPlayer sp) { + final String side = (statSource == EffectSides.Source ? "SRC" : "TGT"); + final String flags = compactLeechFlags(effData); // e.g. "AMH" or "-" + sp.sendSystemMessage(Component.literal( + "[HasExileEffect] " + side + + " id=" + effectId + + " has=" + (has ? "Y" : "X") + + " flags=" + (flags.isEmpty() ? "-" : flags) + )); + } + + return has; + } + + // ----- helpers (class scope) ----- + + private static String compactLeechFlags( + com.robertx22.mine_and_slash.vanilla_mc.potion_effects.EntityStatusEffectsData effData) { + if (effData == null) return ""; + + StringBuilder b = new StringBuilder(); + + if (hasFx(effData, com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects.LEECHING_STATE.GUID())) + b.append('A'); // Any leech + + if (hasFx(effData, com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects + .LEECHING_STATE_BY_RES.get(ResourceType.health).GUID())) + b.append('H'); + + if (hasFx(effData, com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects + .LEECHING_STATE_BY_RES.get(ResourceType.mana).GUID())) + b.append('M'); + + if (hasFx(effData, com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects + .LEECHING_STATE_BY_RES.get(ResourceType.energy).GUID())) + b.append('E'); + + if (hasFx(effData, com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects + .LEECHING_STATE_BY_RES.get(ResourceType.magic_shield).GUID())) + b.append('S'); + + if (hasFx(effData, com.robertx22.mine_and_slash.aoe_data.database.exile_effects.adders.ModEffects + .LEECHING_STATE_BY_RES.get(ResourceType.blood).GUID())) + b.append('B'); + + return b.toString(); + } + + private static boolean hasFx( + com.robertx22.mine_and_slash.vanilla_mc.potion_effects.EntityStatusEffectsData effData, + String effectId) { + var fx = ExileDB.ExileEffects().get(effectId); + return fx != null && effData.has(fx); + } + + @Override + public Class getSerClass() { + return HasExileEffectCondition.class; + } +} + + 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..198e4ca73 --- /dev/null +++ b/src/main/java/com/robertx22/mine_and_slash/vanilla_mc/new_commands/DebugCommands.java @@ -0,0 +1,83 @@ +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 dispatcher) { + + // /mine_and_slash debug + 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); + + 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 ")); + 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 "); + } +} + + 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 { + + 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 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..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; @@ -35,43 +36,74 @@ public void tick(LivingEntity en) { exileMap.entrySet().removeIf(x -> !ExileDB.ExileEffects().isRegistered(x.getKey())); for (Map.Entry 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 removed = new ArrayList<>(); + List toCallOnRemove = new ArrayList<>(); + List 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 entry : exileMap.entrySet()) { + boolean shouldDrop = entry.getValue().shouldRemove() || entry.getValue().isSpellNoLongerAllocated(en); + if (shouldDrop) { + ExileEffect eff = ExileDB.ExileEffects().get(entry.getKey()); + if (eff != null) { + eff.onRemove(en); + ExileEffectInstanceData inst = exileMap.get(entry.getKey()); + if (inst == null || inst.shouldRemove()) { + toDeleteKeys.add(entry.getKey()); + } 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); + } + } } - return false; - }); + } } else { - exileMap.entrySet().removeIf(x -> { - if (x.getValue().shouldRemove()) { - removed.add(ExileDB.ExileEffects().get(x.getKey())); - return true; + for (Map.Entry entry : exileMap.entrySet()) { + if (entry.getValue().shouldRemove()) { + ExileEffect eff = ExileDB.ExileEffects().get(entry.getKey()); + if (eff != null) { + eff.onRemove(en); + ExileEffectInstanceData inst = exileMap.get(entry.getKey()); + if (inst == null || inst.shouldRemove()) { + toDeleteKeys.add(entry.getKey()); + } 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); + } + } } - return false; - }); + } } - for (ExileEffect eff : removed) { - eff.onRemove(en); + + + for (String key : toDeleteKeys) { + ExileEffectInstanceData current = exileMap.remove(key); + if (DebugHud.ON_EXPIRE && en instanceof net.minecraft.server.level.ServerPlayer sp) { + if (current != null) { + DebugHud.send(sp, "expire_removed_" + key, "[EFFECT][EXPIRE] Removed " + key + " (ticks_left=" + current.ticks_left + ", stacks=" + current.stacks + ") [id=" + System.identityHashCode(current) + "]", 200); + } else { + 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/25percent_health.json b/src/main/resources/data/mmorpg/spend_thresholds/25percent_health.json new file mode 100644 index 000000000..f484183b4 --- /dev/null +++ b/src/main/resources/data/mmorpg/spend_thresholds/25percent_health.json @@ -0,0 +1,23 @@ +{ + "key": "25PERCENT_HEALTH", + "resource": "health", + "enabled": true, + "priority": 0, + "threshold": { + "mode": "PERCENT_OF_MAX", + "value": 25, + "multiply_by_level": false, + "percent_of": "health" + }, + "cooldown_ticks": 0, + "locks": { + "effects": [], + "drop_progress_while_locked": true, + "drop_progress_on_proc": true + }, + "on_proc": [ + { + + } + ] + } \ No newline at end of file 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 new file mode 100644 index 000000000..5741c2585 --- /dev/null +++ b/src/main/resources/data/mmorpg/spend_thresholds/energy_xlvl_wotj.json @@ -0,0 +1,31 @@ +{ + "key": "ENERGY_XLVL_WOTJ", + "resource": "energy", + "show_ui": true, + "enabled": true, + "priority": 0, + "threshold": { + "mode": "FLAT", + "value": 10, + "multiply_by_level": true + }, + "cooldown_ticks": 0, + "require_stat": "unlock_wotj", + "locks": { + "effects": ["wrath_of_the_juggernaut", "burnout"], + "lock_while_cooldown": false, + "drop_progress_while_locked": true, + "drop_progress_on_proc": true + }, + "on_proc": [ + { + "action": "exile_effect", + "exile_potion_id": "wrath_of_the_juggernaut", + "duration_ticks": 200, + "stacks": 1, + "on_expire": { + "burnout": 200 + } + } + ] + } \ No newline at end of file