From 8bb6ba4b72a2bfd9e5fc7812580651d321a59c19 Mon Sep 17 00:00:00 2001 From: MobiusDevelopment <8391001+MobiusDevelopment@users.noreply.github.com> Date: Thu, 13 Feb 2020 09:36:36 +0000 Subject: [PATCH] Support for AbsorbDamage effect modes. --- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- .../handlers/effecthandlers/AbsorbDamage.java | 60 ++++++++++++++++--- 15 files changed, 780 insertions(+), 120 deletions(-) diff --git a/L2J_Mobius_1.0_Ertheia/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_1.0_Ertheia/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_1.0_Ertheia/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_1.0_Ertheia/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_2.5_Underground/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_2.5_Underground/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_2.5_Underground/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_2.5_Underground/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_3.0_Helios/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_3.0_Helios/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_3.0_Helios/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_3.0_Helios/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_4.0_GrandCrusade/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_4.0_GrandCrusade/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_4.0_GrandCrusade/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_4.0_GrandCrusade/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_5.0_Salvation/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_5.0_Salvation/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_5.0_Salvation/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_5.0_Salvation/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_5.5_EtinasFate/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_5.5_EtinasFate/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_5.5_EtinasFate/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_5.5_EtinasFate/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_6.0_Fafurion/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_6.0_Fafurion/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_6.0_Fafurion/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_6.0_Fafurion/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_7.0_PreludeOfWar/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_7.0_PreludeOfWar/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_7.0_PreludeOfWar/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_7.0_PreludeOfWar/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_2.0_Saviors/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_2.0_Saviors/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_2.0_Saviors/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_2.0_Saviors/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_2.1_Zaken/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_2.1_Zaken/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_2.1_Zaken/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_2.1_Zaken/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_2.2_Antharas/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_2.2_Antharas/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_2.2_Antharas/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_2.2_Antharas/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_2.3_SevenSigns/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_2.3_SevenSigns/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_2.3_SevenSigns/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_2.3_SevenSigns/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_2.4_SecretOfEmpire/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_2.4_SecretOfEmpire/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_2.4_SecretOfEmpire/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_2.4_SecretOfEmpire/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_3.0_TheKamael/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_3.0_TheKamael/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_3.0_TheKamael/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_3.0_TheKamael/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } } diff --git a/L2J_Mobius_Classic_Interlude/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java b/L2J_Mobius_Classic_Interlude/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java index 3f9132b8e3..d52d7a8970 100644 --- a/L2J_Mobius_Classic_Interlude/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java +++ b/L2J_Mobius_Classic_Interlude/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java @@ -19,6 +19,7 @@ package handlers.effecthandlers; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import org.l2jmobius.gameserver.enums.StatModifierType; import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.effects.AbstractEffect; @@ -30,19 +31,23 @@ import org.l2jmobius.gameserver.model.items.instance.ItemInstance; import org.l2jmobius.gameserver.model.skills.Skill; /** - * @author Sdw + * @author Sdw, Mobius */ public class AbsorbDamage extends AbstractEffect { + private static final Map DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private static final Map PER_DAMAGE_HOLDER = new ConcurrentHashMap<>(); + private final double _damage; - private static final Map _damageHolder = new ConcurrentHashMap<>(); + private final StatModifierType _mode; public AbsorbDamage(StatSet params) { _damage = params.getDouble("damage", 0); + _mode = params.getEnum("mode", StatModifierType.class, StatModifierType.DIFF); } - private DamageReturn onDamageReceivedEvent(OnCreatureDamageReceived event) + private DamageReturn onDamageReceivedDiffEvent(OnCreatureDamageReceived event, Creature effected, Skill skill) { // DOT effects are not taken into account. if (event.isDamageOverTime()) @@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect final int objectId = event.getTarget().getObjectId(); - final double damageLeft = _damageHolder.get(objectId) != null ? _damageHolder.get(objectId) : 0; + final double damageLeft = DIFF_DAMAGE_HOLDER.getOrDefault(objectId, 0d); final double newDamageLeft = Math.max(damageLeft - event.getDamage(), 0); final double newDamage = Math.max(event.getDamage() - damageLeft, 0); - _damageHolder.put(objectId, newDamageLeft); + if (newDamageLeft > 0) + { + DIFF_DAMAGE_HOLDER.put(objectId, newDamageLeft); + } + else + { + effected.stopSkillEffects(skill); + } + + return new DamageReturn(false, true, false, newDamage); + } + + private DamageReturn onDamageReceivedPerEvent(OnCreatureDamageReceived event) + { + // DOT effects are not taken into account. + if (event.isDamageOverTime()) + { + return null; + } + + final int objectId = event.getTarget().getObjectId(); + + final double damagePercent = PER_DAMAGE_HOLDER.getOrDefault(objectId, 0d); + final double currentDamage = event.getDamage(); + final double newDamage = currentDamage - ((currentDamage / 100) * damagePercent); return new DamageReturn(false, true, false, newDamage); } @@ -65,13 +94,28 @@ public class AbsorbDamage extends AbstractEffect public void onExit(Creature effector, Creature effected, Skill skill) { effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); - _damageHolder.remove(effected.getObjectId()); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.remove(effected.getObjectId()); + } + else + { + PER_DAMAGE_HOLDER.remove(effected.getObjectId()); + } } @Override public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) { - _damageHolder.put(effected.getObjectId(), _damage); - effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); + if (_mode == StatModifierType.DIFF) + { + DIFF_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedDiffEvent(event, effected, skill), this)); + } + else + { + PER_DAMAGE_HOLDER.put(effected.getObjectId(), _damage); + effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedPerEvent(event), this)); + } } }