lineage2/l2j_mobius
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support for AbsorbDamage effect modes.

Browse Source
This commit is contained in:
MobiusDevelopment
2020-02-13 09:36:36 +00:00
parent 90ab6d4b25
commit 8bb6ba4b72
15 changed files with 780 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
L2J_Mobius_1.0_Ertheia/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_2.5_Underground/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_3.0_Helios/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_4.0_GrandCrusade/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_5.0_Salvation/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_5.5_EtinasFate/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_6.0_Fafurion/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_7.0_PreludeOfWar/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_2.0_Saviors/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_2.1_Zaken/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_2.2_Antharas/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_2.3_SevenSigns/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_2.4_SecretOfEmpire/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_3.0_TheKamael/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }

60
L2J_Mobius_Classic_Interlude/dist/game/data/scripts/handlers/effecthandlers/AbsorbDamage.java vendored
View File

@@ -19,6 +19,7 @@ package handlers.effecthandlers;
import java.util.Map; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentHashMap;
import org.l2jmobius.gameserver.enums.StatModifierType;
import org.l2jmobius.gameserver.model.StatSet; import org.l2jmobius.gameserver.model.StatSet;
import org.l2jmobius.gameserver.model.actor.Creature; import org.l2jmobius.gameserver.model.actor.Creature;
import org.l2jmobius.gameserver.model.effects.AbstractEffect; 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; import org.l2jmobius.gameserver.model.skills.Skill;
/** /**
* @author Sdw * @author Sdw, Mobius
*/ */
public class AbsorbDamage extends AbstractEffect public class AbsorbDamage extends AbstractEffect
{ {
private static final Map<Integer, Double> DIFF_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private static final Map<Integer, Double> PER_DAMAGE_HOLDER = new ConcurrentHashMap<>();
private final double _damage; private final double _damage;
private static final Map<Integer, Double> _damageHolder = new ConcurrentHashMap<>(); private final StatModifierType _mode;
public AbsorbDamage(StatSet params) public AbsorbDamage(StatSet params)
{ {
_damage = params.getDouble("damage", 0); _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. // DOT effects are not taken into account.
if (event.isDamageOverTime()) if (event.isDamageOverTime())
@@ -52,11 +57,35 @@ public class AbsorbDamage extends AbstractEffect
final int objectId = event.getTarget().getObjectId(); 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 newDamageLeft = Math.max(damageLeft - event.getDamage(), 0);
final double newDamage = Math.max(event.getDamage() - damageLeft, 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); 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) public void onExit(Creature effector, Creature effected, Skill skill)
{ {
effected.removeListenerIf(EventType.ON_CREATURE_DAMAGE_RECEIVED, listener -> listener.getOwner() == this); 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 @Override
public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item) public void onStart(Creature effector, Creature effected, Skill skill, ItemInstance item)
{ {
_damageHolder.put(effected.getObjectId(), _damage); if (_mode == StatModifierType.DIFF)
effected.addListener(new FunctionEventListener(effected, EventType.ON_CREATURE_DAMAGE_RECEIVED, (OnCreatureDamageReceived event) -> onDamageReceivedEvent(event), this)); {
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));
}
} }
} }