/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
package com.l2jmobius.gameserver.model.skills;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import com.l2jmobius.Config;
import com.l2jmobius.commons.util.Rnd;
import com.l2jmobius.gameserver.data.xml.impl.SkillData;
import com.l2jmobius.gameserver.data.xml.impl.SkillTreesData;
import com.l2jmobius.gameserver.enums.AttributeType;
import com.l2jmobius.gameserver.enums.BasicProperty;
import com.l2jmobius.gameserver.enums.MountType;
import com.l2jmobius.gameserver.enums.ShotType;
import com.l2jmobius.gameserver.handler.AffectScopeHandler;
import com.l2jmobius.gameserver.handler.IAffectScopeHandler;
import com.l2jmobius.gameserver.handler.ITargetTypeHandler;
import com.l2jmobius.gameserver.handler.TargetHandler;
import com.l2jmobius.gameserver.instancemanager.HandysBlockCheckerManager;
import com.l2jmobius.gameserver.model.ArenaParticipantsHolder;
import com.l2jmobius.gameserver.model.L2Object;
import com.l2jmobius.gameserver.model.PcCondOverride;
import com.l2jmobius.gameserver.model.StatsSet;
import com.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.actor.instance.L2BlockInstance;
import com.l2jmobius.gameserver.model.actor.instance.L2PcInstance;
import com.l2jmobius.gameserver.model.cubic.CubicInstance;
import com.l2jmobius.gameserver.model.effects.AbstractEffect;
import com.l2jmobius.gameserver.model.effects.EffectFlag;
import com.l2jmobius.gameserver.model.effects.L2EffectType;
import com.l2jmobius.gameserver.model.holders.AlterSkillHolder;
import com.l2jmobius.gameserver.model.holders.AttachSkillHolder;
import com.l2jmobius.gameserver.model.interfaces.IIdentifiable;
import com.l2jmobius.gameserver.model.items.instance.L2ItemInstance;
import com.l2jmobius.gameserver.model.skills.targets.AffectObject;
import com.l2jmobius.gameserver.model.skills.targets.AffectScope;
import com.l2jmobius.gameserver.model.skills.targets.TargetType;
import com.l2jmobius.gameserver.model.stats.BasicPropertyResist;
import com.l2jmobius.gameserver.model.stats.Formulas;
import com.l2jmobius.gameserver.model.stats.TraitType;
import com.l2jmobius.gameserver.network.SystemMessageId;
import com.l2jmobius.gameserver.network.serverpackets.FlyToLocation.FlyType;
import com.l2jmobius.gameserver.network.serverpackets.SystemMessage;
public final class Skill implements IIdentifiable
{
private static final Logger _log = Logger.getLogger(Skill.class.getName());
/** Skill ID. */
private final int _id;
/** Skill level. */
private final int _level;
/** Custom skill ID displayed by the client. */
private final int _displayId;
/** Custom skill level displayed by the client. */
private final int _displayLevel;
/** Skill client's name. */
private final String _name;
/** Operative type: passive, active, toggle. */
private final SkillOperateType _operateType;
private final int _magic;
private final TraitType _traitType;
private final boolean _staticReuse;
/** MP consumption. */
private final int _mpConsume;
/** Initial MP consumption. */
private final int _mpInitialConsume;
/** MP consumption per channeling. */
private final int _mpPerChanneling;
/** HP consumption. */
private final int _hpConsume;
/** Amount of items consumed by this skill from caster. */
private final int _itemConsumeCount;
/** Id of item consumed by this skill from caster. */
private final int _itemConsumeId;
/** Cast range: how far can be the target. */
private final int _castRange;
/** Effect range: how far the skill affect the target. */
private final int _effectRange;
/** Abnormal instant, used for herbs mostly. */
private final boolean _isAbnormalInstant;
/** Abnormal level, global effect level. */
private final int _abnormalLvl;
/** Abnormal type: global effect "group". */
private final AbnormalType _abnormalType;
/** Abnormal time: global effect duration time. */
private final int _abnormalTime;
/** Abnormal visual effect: the visual effect displayed ingame. */
private Set _abnormalVisualEffects;
/** If {@code true} this skill's effect should stay after death. */
private final boolean _stayAfterDeath;
/** If {@code true} this skill's effect recovery HP/MP or CP from herb. */
private final boolean _isRecoveryHerb;
private final int _refId;
// all times in milliseconds
private final int _hitTime;
// private final int _skillInterruptTime;
private final int _coolTime;
private final int _reuseHashCode;
private final int _reuseDelay;
private final int _reuseDelayGroup;
private final int _magicLevel;
private final int _lvlBonusRate;
private final int _activateRate;
private final int _minChance;
private final int _maxChance;
// Effecting area of the skill, in radius.
// The radius center varies according to the _targetType:
// "caster" if targetType = AURA/PARTY/CLAN or "target" if targetType = AREA
private final TargetType _targetType;
private final AffectScope _affectScope;
private final AffectObject _affectObject;
private final int _affectRange;
private final int[] _fanRange = new int[4]; // unk;startDegree;fanAffectRange;fanAffectAngle
private final int[] _affectLimit = new int[3]; // TODO: Third value is unknown... find it out!
private final int[] _affectHeight = new int[2];
private final boolean _nextActionIsAttack;
private final boolean _removedOnAnyActionExceptMove;
private final boolean _removedOnDamage;
private final boolean _blockedInOlympiad;
private final AttributeType _attributeType;
private final int _attributeValue;
private final BasicProperty _basicProperty;
private final int _minPledgeClass;
private final int _soulMaxConsume;
private final boolean _isTriggeredSkill; // If true the skill will take activation buff slot instead of a normal buff slot
private final int _effectPoint;
private Set _rideState;
private final Map> _conditionLists = new EnumMap<>(SkillConditionScope.class);
private final Map> _effectLists = new EnumMap<>(EffectScope.class);
// Flying support
private final FlyType _flyType;
private final int _flyRadius;
private final boolean _isDebuff;
private final boolean _isSuicideAttack;
private final boolean _canBeDispelled;
private final boolean _excludedFromCheck;
private final boolean _withoutAction;
private final String _icon;
private volatile Byte[] _effectTypes;
// Channeling data
private final int _channelingSkillId;
private final int _channelingTickInitialDelay;
private final int _channelingTickInterval;
// Mentoring
private final boolean _isMentoring;
// Stance skill IDs
private final int _doubleCastSkill;
private final boolean _canDoubleCast;
private final boolean _canCastWhileDisabled;
private final boolean _isSharedWithSummon;
private final boolean _isNecessaryToggle;
private final boolean _deleteAbnormalOnLeave;
private final boolean _irreplacableBuff; // Stays after death, on subclass change, cant be canceled.
private final boolean _blockActionUseSkill; // Blocks the use skill client action and is not showed on skill list.
private final int _toggleGroupId;
private final int _attachToggleGroupId;
private final List _alterSkills;
private final List _attachSkills;
private final Set _abnormalResists;
private final double _magicCriticalRate;
public Skill(StatsSet set)
{
_id = set.getInt(".id");
_level = set.getInt(".level");
_refId = set.getInt(".referenceId", 0);
_displayId = set.getInt(".displayId", _id);
_displayLevel = set.getInt(".displayLevel", _level);
_name = set.getString(".name", "");
_operateType = set.getEnum("operateType", SkillOperateType.class);
_magic = set.getInt("isMagic", 0);
_traitType = set.getEnum("trait", TraitType.class, TraitType.NONE);
_staticReuse = set.getBoolean("staticReuse", false);
_mpConsume = set.getInt("mpConsume", 0);
_mpInitialConsume = set.getInt("mpInitialConsume", 0);
_mpPerChanneling = set.getInt("mpPerChanneling", _mpConsume);
_hpConsume = set.getInt("hpConsume", 0);
_itemConsumeCount = set.getInt("itemConsumeCount", 0);
_itemConsumeId = set.getInt("itemConsumeId", 0);
_castRange = set.getInt("castRange", -1);
_effectRange = set.getInt("effectRange", -1);
_abnormalLvl = set.getInt("abnormalLvl", 0);
_abnormalType = set.getEnum("abnormalType", AbnormalType.class, AbnormalType.NONE);
int abnormalTime = set.getInt("abnormalTime", 0);
if (Config.ENABLE_MODIFY_SKILL_DURATION && Config.SKILL_DURATION_LIST.containsKey(getId()))
{
if ((getLevel() < 100) || (getLevel() > 140))
{
abnormalTime = Config.SKILL_DURATION_LIST.get(getId());
}
else if ((getLevel() >= 100) && (getLevel() < 140))
{
abnormalTime += Config.SKILL_DURATION_LIST.get(getId());
}
}
_abnormalTime = abnormalTime;
_isAbnormalInstant = set.getBoolean("abnormalInstant", false);
parseAbnormalVisualEffect(set.getString("abnormalVisualEffect", null));
_stayAfterDeath = set.getBoolean("stayAfterDeath", false);
_hitTime = set.getInt("hitTime", 0);
_coolTime = set.getInt("coolTime", 0);
_isDebuff = set.getBoolean("isDebuff", false);
_isRecoveryHerb = set.getBoolean("isRecoveryHerb", false);
if (Config.ENABLE_MODIFY_SKILL_REUSE && Config.SKILL_REUSE_LIST.containsKey(_id))
{
if (Config.DEBUG)
{
_log.info("*** Skill " + _name + " (" + _level + ") changed reuse from " + set.getInt("reuseDelay", 0) + " to " + Config.SKILL_REUSE_LIST.get(_id) + " seconds.");
}
_reuseDelay = Config.SKILL_REUSE_LIST.get(_id);
}
else
{
_reuseDelay = set.getInt("reuseDelay", 0);
}
_reuseDelayGroup = set.getInt("reuseDelayGroup", -1);
_reuseHashCode = SkillData.getSkillHashCode(_reuseDelayGroup > 0 ? _reuseDelayGroup : _id, _level);
_targetType = set.getEnum("targetType", TargetType.class, TargetType.SELF);
_affectScope = set.getEnum("affectScope", AffectScope.class, AffectScope.SINGLE);
_affectObject = set.getEnum("affectObject", AffectObject.class, AffectObject.ALL);
_affectRange = set.getInt("affectRange", 0);
final String rideState = set.getString("rideState", null);
if (rideState != null)
{
final String[] state = rideState.split(";");
if (state.length > 0)
{
_rideState = new HashSet<>(state.length);
for (String s : state)
{
try
{
_rideState.add(MountType.valueOf(s));
}
catch (Exception e)
{
_log.log(Level.WARNING, "Bad data in rideState for skill " + this + "!", e);
}
}
}
}
final String fanRange = set.getString("fanRange", null);
if (fanRange != null)
{
try
{
final String[] valuesSplit = fanRange.split(";");
_fanRange[0] = Integer.parseInt(valuesSplit[0]);
_fanRange[1] = Integer.parseInt(valuesSplit[1]);
_fanRange[2] = Integer.parseInt(valuesSplit[2]);
_fanRange[3] = Integer.parseInt(valuesSplit[3]);
}
catch (Exception e)
{
throw new IllegalArgumentException("SkillId: " + _id + " invalid fanRange value: " + fanRange + ", \"unk;startDegree;fanAffectRange;fanAffectAngle\" required");
}
}
final String affectLimit = set.getString("affectLimit", null);
if (affectLimit != null)
{
try
{
final String[] valuesSplit = affectLimit.split("-");
_affectLimit[0] = Integer.parseInt(valuesSplit[0]);
_affectLimit[1] = Integer.parseInt(valuesSplit[1]);
if (valuesSplit.length > 2)
{
_affectLimit[2] = Integer.parseInt(valuesSplit[2]);
}
}
catch (Exception e)
{
throw new IllegalArgumentException("SkillId: " + _id + " invalid affectLimit value: " + affectLimit + ", \"minAffected-additionalRandom\" required");
}
}
final String affectHeight = set.getString("affectHeight", null);
if (affectHeight != null)
{
try
{
final String[] valuesSplit = affectHeight.split(";");
_affectHeight[0] = Integer.parseInt(valuesSplit[0]);
_affectHeight[1] = Integer.parseInt(valuesSplit[1]);
}
catch (Exception e)
{
throw new IllegalArgumentException("SkillId: " + _id + " invalid affectHeight value: " + affectHeight + ", \"minHeight-maxHeight\" required");
}
if (_affectHeight[0] > _affectHeight[1])
{
throw new IllegalArgumentException("SkillId: " + _id + " invalid affectHeight value: " + affectHeight + ", \"minHeight-maxHeight\" required, minHeight is higher than maxHeight!");
}
}
_magicLevel = set.getInt("magicLvl", 0);
_lvlBonusRate = set.getInt("lvlBonusRate", 0);
_activateRate = set.getInt("activateRate", -1);
_minChance = set.getInt("minChance", Config.MIN_ABNORMAL_STATE_SUCCESS_RATE);
_maxChance = set.getInt("maxChance", Config.MAX_ABNORMAL_STATE_SUCCESS_RATE);
_nextActionIsAttack = set.getBoolean("nextActionAttack", false);
_removedOnAnyActionExceptMove = set.getBoolean("removedOnAnyActionExceptMove", false);
_removedOnDamage = set.getBoolean("removedOnDamage", false);
_blockedInOlympiad = set.getBoolean("blockedInOlympiad", false);
_attributeType = set.getEnum("attributeType", AttributeType.class, AttributeType.NONE);
_attributeValue = set.getInt("attributeValue", 0);
_basicProperty = set.getEnum("basicProperty", BasicProperty.class, BasicProperty.NONE);
_isSuicideAttack = set.getBoolean("isSuicideAttack", false);
_minPledgeClass = set.getInt("minPledgeClass", 0);
_soulMaxConsume = set.getInt("soulMaxConsumeCount", 0);
_isTriggeredSkill = set.getBoolean("isTriggeredSkill", false);
_effectPoint = set.getInt("effectPoint", 0);
_flyType = set.getEnum("flyType", FlyType.class, null);
_flyRadius = set.getInt("flyRadius", 0);
_canBeDispelled = set.getBoolean("canBeDispelled", true);
_excludedFromCheck = set.getBoolean("excludedFromCheck", false);
_withoutAction = set.getBoolean("withoutAction", false);
_icon = set.getString("icon", "icon.skill0000");
_channelingSkillId = set.getInt("channelingSkillId", 0);
_channelingTickInterval = set.getInt("channelingTickInterval", 2000);
_channelingTickInitialDelay = set.getInt("channelingTickInitialDelay", _channelingTickInterval);
_isMentoring = set.getBoolean("isMentoring", false);
_doubleCastSkill = set.getInt("doubleCastSkill", 0);
_canDoubleCast = set.getBoolean("canDoubleCast", false);
_canCastWhileDisabled = set.getBoolean("canCastWhileDisabled", false);
_isSharedWithSummon = set.getBoolean("isSharedWithSummon", true);
_isNecessaryToggle = set.getBoolean("isNecessaryToggle", false);
_deleteAbnormalOnLeave = set.getBoolean("deleteAbnormalOnLeave", false);
_irreplacableBuff = set.getBoolean("irreplacableBuff", false);
_blockActionUseSkill = set.getBoolean("blockActionUseSkill", false);
_toggleGroupId = set.getInt("toggleGroupId", -1);
_attachToggleGroupId = set.getInt("attachToggleGroupId", -1);
_alterSkills = set.getList("alterSkill", StatsSet.class, Collections.emptyList()).stream().map(AlterSkillHolder::fromStatsSet).collect(Collectors.toList());
_attachSkills = set.getList("attachSkillList", StatsSet.class, Collections.emptyList()).stream().map(AttachSkillHolder::fromStatsSet).collect(Collectors.toList());
final String abnormalResist = set.getString("abnormalResists", null);
if (abnormalResist != null)
{
final String[] abnormalResistStrings = abnormalResist.split(";");
if (abnormalResistStrings.length > 0)
{
_abnormalResists = new HashSet<>(abnormalResistStrings.length);
for (String s : abnormalResistStrings)
{
try
{
_abnormalResists.add(AbnormalType.valueOf(s));
}
catch (Exception e)
{
_log.log(Level.WARNING, "Skill ID[" + _id + "] Expected AbnormalType for abnormalResists but found " + s, e);
}
}
}
else
{
_abnormalResists = Collections.emptySet();
}
}
else
{
_abnormalResists = Collections.emptySet();
}
_magicCriticalRate = set.getDouble("magicCriticalRate", 0);
}
public TraitType getTraitType()
{
return _traitType;
}
public AttributeType getAttributeType()
{
return _attributeType;
}
public int getAttributeValue()
{
return _attributeValue;
}
public boolean isAOE()
{
switch (_affectScope)
{
case FAN:
case FAN_PB:
case POINT_BLANK:
case RANGE:
case RING_RANGE:
case SQUARE:
case SQUARE_PB:
{
return true;
}
}
return false;
}
public boolean isDamage()
{
return hasEffectType(L2EffectType.MAGICAL_ATTACK, L2EffectType.HP_DRAIN, L2EffectType.PHYSICAL_ATTACK, L2EffectType.PHYSICAL_ATTACK_HP_LINK);
}
public boolean isSuicideAttack()
{
return _isSuicideAttack;
}
public boolean allowOnTransform()
{
return isPassive();
}
/**
* Verify if this skill is abnormal instant.
* Herb buff skills yield {@code true} for this check.
* @return {@code true} if the skill is abnormal instant, {@code false} otherwise
*/
public boolean isAbnormalInstant()
{
return _isAbnormalInstant;
}
/**
* Gets the skill abnormal type.
* @return the abnormal type
*/
public AbnormalType getAbnormalType()
{
return _abnormalType;
}
/**
* Gets the skill abnormal level.
* @return the skill abnormal level
*/
public int getAbnormalLvl()
{
return _abnormalLvl;
}
/**
* Gets the skill abnormal time.
* Is the base to calculate the duration of the continuous effects of this skill.
* @return the abnormal time
*/
public int getAbnormalTime()
{
return _abnormalTime;
}
/**
* Gets the skill abnormal visual effect.
* @return the abnormal visual effect
*/
public Set getAbnormalVisualEffects()
{
return (_abnormalVisualEffects != null) ? _abnormalVisualEffects : Collections.emptySet();
}
/**
* Verify if the skill has abnormal visual effects.
* @return {@code true} if the skill has abnormal visual effects, {@code false} otherwise
*/
public boolean hasAbnormalVisualEffects()
{
return (_abnormalVisualEffects != null) && !_abnormalVisualEffects.isEmpty();
}
/**
* Gets the skill magic level.
* @return the skill magic level
*/
public int getMagicLevel()
{
return _magicLevel;
}
public int getLvlBonusRate()
{
return _lvlBonusRate;
}
public int getActivateRate()
{
return _activateRate;
}
/**
* Return custom minimum skill/effect chance.
* @return
*/
public int getMinChance()
{
return _minChance;
}
/**
* Return custom maximum skill/effect chance.
* @return
*/
public int getMaxChance()
{
return _maxChance;
}
/**
* Return true if skill effects should be removed on any action except movement
* @return
*/
public boolean isRemovedOnAnyActionExceptMove()
{
return _removedOnAnyActionExceptMove;
}
/**
* @return {@code true} if skill effects should be removed on damage
*/
public boolean isRemovedOnDamage()
{
return _removedOnDamage;
}
/**
* @return {@code true} if skill can not be used in olympiad.
*/
public boolean isBlockedInOlympiad()
{
return _blockedInOlympiad;
}
/**
* Return the additional effect Id.
* @return
*/
public int getChannelingSkillId()
{
return _channelingSkillId;
}
/**
* Return true if character should attack target after skill
* @return
*/
public boolean nextActionIsAttack()
{
return _nextActionIsAttack;
}
/**
* @return Returns the castRange.
*/
public int getCastRange()
{
return _castRange;
}
/**
* @return Returns the effectRange.
*/
public int getEffectRange()
{
return _effectRange;
}
/**
* @return Returns the hpConsume.
*/
public int getHpConsume()
{
return _hpConsume;
}
/**
* Gets the skill ID.
* @return the skill ID
*/
@Override
public int getId()
{
return _id;
}
/**
* Verify if this skill is a debuff.
* @return {@code true} if this skill is a debuff, {@code false} otherwise
*/
public boolean isDebuff()
{
return _isDebuff;
}
/**
* Verify if this skill is coming from Recovery Herb.
* @return {@code true} if this skill is a recover herb, {@code false} otherwise
*/
public boolean isRecoveryHerb()
{
return _isRecoveryHerb;
}
public int getDisplayId()
{
return _displayId;
}
public int getDisplayLevel()
{
return _displayLevel;
}
/**
* Return skill basic property type.
* @return
*/
public BasicProperty getBasicProperty()
{
return _basicProperty;
}
/**
* @return Returns the how much items will be consumed.
*/
public int getItemConsumeCount()
{
return _itemConsumeCount;
}
/**
* @return Returns the ID of item for consume.
*/
public int getItemConsumeId()
{
return _itemConsumeId;
}
/**
* @return Returns the level.
*/
public int getLevel()
{
return _level;
}
/**
* @return isMagic integer value from the XML.
*/
public int getMagicType()
{
return _magic;
}
/**
* @return Returns true to set physical skills.
*/
public boolean isPhysical()
{
return _magic == 0;
}
/**
* @return Returns true to set magic skills.
*/
public boolean isMagic()
{
return _magic == 1;
}
/**
* @return Returns true to set static skills.
*/
public boolean isStatic()
{
return _magic == 2;
}
/**
* @return Returns true to set dance skills.
*/
public boolean isDance()
{
return _magic == 3;
}
/**
* @return Returns true to set static reuse.
*/
public boolean isStaticReuse()
{
return _staticReuse;
}
/**
* @return Returns the mpConsume.
*/
public int getMpConsume()
{
return _mpConsume;
}
/**
* @return Returns the mpInitialConsume.
*/
public int getMpInitialConsume()
{
return _mpInitialConsume;
}
/**
* @return Mana consumption per channeling tick.
*/
public int getMpPerChanneling()
{
return _mpPerChanneling;
}
/**
* @return the skill name
*/
public String getName()
{
return _name;
}
/**
* @return the reuse delay
*/
public int getReuseDelay()
{
return _reuseDelay;
}
/**
* @return the skill ID from which the reuse delay should be taken.
*/
public int getReuseDelayGroup()
{
return _reuseDelayGroup;
}
public int getReuseHashCode()
{
return _reuseHashCode;
}
public int getHitTime()
{
return _hitTime;
}
/**
* @return the cool time
*/
public int getCoolTime()
{
return _coolTime;
}
/**
* @return the target type of the skill : SELF, TARGET, SUMMON, GROUND...
*/
public TargetType getTargetType()
{
return _targetType;
}
/**
* @return the affect scope of the skill : SINGLE, FAN, SQUARE, PARTY, PLEDGE...
*/
public AffectScope getAffectScope()
{
return _affectScope;
}
/**
* @return the affect object of the skill : All, Clan, Friend, NotFriend, Invisible...
*/
public AffectObject getAffectObject()
{
return _affectObject;
}
/**
* @return the AOE range of the skill.
*/
public int getAffectRange()
{
return _affectRange;
}
/**
* @return the AOE fan range of the skill.
*/
public int[] getFanRange()
{
return _fanRange;
}
/**
* @return the maximum amount of targets the skill can affect or 0 if unlimited.
*/
public int getAffectLimit()
{
if ((_affectLimit[0] > 0) || (_affectLimit[1] > 0))
{
return (_affectLimit[0] + Rnd.get(_affectLimit[1]));
}
return 0;
}
public int getAffectHeightMin()
{
return _affectHeight[0];
}
public int getAffectHeightMax()
{
return _affectHeight[1];
}
public boolean isActive()
{
return _operateType.isActive();
}
public boolean isPassive()
{
return _operateType.isPassive();
}
public boolean isToggle()
{
return _operateType.isToggle();
}
public boolean isAura()
{
return _operateType.isAura();
}
public boolean isHidingMesseges()
{
return _operateType.isHidingMesseges();
}
public boolean isNotBroadcastable()
{
return _operateType.isNotBroadcastable();
}
public boolean isContinuous()
{
return _operateType.isContinuous() || isSelfContinuous();
}
public boolean isSelfContinuous()
{
return _operateType.isSelfContinuous();
}
public boolean isChanneling()
{
return _operateType.isChanneling();
}
public boolean isTriggeredSkill()
{
return _isTriggeredSkill;
}
public boolean isSynergySkill()
{
return _operateType.isSynergy();
}
/**
* Verify if the skill is a transformation skill.
* @return {@code true} if the skill is a transformation, {@code false} otherwise
*/
public boolean isTransformation()
{
return _abnormalType == AbnormalType.TRANSFORM;
}
public int getEffectPoint()
{
return _effectPoint;
}
public boolean useSoulShot()
{
return hasEffectType(L2EffectType.PHYSICAL_ATTACK, L2EffectType.PHYSICAL_ATTACK_HP_LINK);
}
public boolean useSpiritShot()
{
return _magic == 1;
}
public boolean useFishShot()
{
return hasEffectType(L2EffectType.FISHING);
}
public int getMinPledgeClass()
{
return _minPledgeClass;
}
public boolean isHeroSkill()
{
return SkillTreesData.getInstance().isHeroSkill(_id, _level);
}
public boolean isGMSkill()
{
return SkillTreesData.getInstance().isGMSkill(_id, _level);
}
public boolean is7Signs()
{
return (_id > 4360) && (_id < 4367);
}
/**
* Verify if this is a healing potion skill.
* @return {@code true} if this is a healing potion skill, {@code false} otherwise
*/
public boolean isHealingPotionSkill()
{
return getAbnormalType() == AbnormalType.HP_RECOVER;
}
public int getMaxSoulConsumeCount()
{
return _soulMaxConsume;
}
public FlyType getFlyType()
{
return _flyType;
}
public int getFlyRadius()
{
return _flyRadius;
}
public boolean isStayAfterDeath()
{
return _stayAfterDeath || isIrreplacableBuff() || isNecessaryToggle();
}
public boolean isBad()
{
return _effectPoint < 0;
}
public boolean checkCondition(L2Character activeChar, L2Object object)
{
if (activeChar.canOverrideCond(PcCondOverride.SKILL_CONDITIONS) && !Config.GM_SKILL_RESTRICTION)
{
return true;
}
if (activeChar.isPlayer() && !canBeUseWhileRiding((L2PcInstance) activeChar))
{
final SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED_DUE_TO_UNSUITABLE_TERMS);
sm.addSkillName(_id);
activeChar.sendPacket(sm);
return false;
}
return checkConditions(SkillConditionScope.GENERAL, activeChar, object);
}
/**
* Checks if a player can use this skill while riding.
* @param player the player
* @return {@code true} if the player can use this skill, {@code false} otherwise
*/
public boolean canBeUseWhileRiding(L2PcInstance player)
{
return (_rideState == null) || _rideState.contains(player.getMountType());
}
/**
* @param activeChar the character that requests getting the skill target.
* @param forceUse if character pressed ctrl (force pick target)
* @param dontMove if character pressed shift (dont move and pick target only if in range)
* @param sendMessage send SystemMessageId packet if target is incorrect.
* @return {@code WorldObject} this skill can be used on, or {@code null} if there is no such.
*/
public L2Object getTarget(L2Character activeChar, boolean forceUse, boolean dontMove, boolean sendMessage)
{
return getTarget(activeChar, activeChar.getTarget(), forceUse, dontMove, sendMessage);
}
/**
* @param activeChar the character that requests getting the skill target.
* @param seletedTarget the target that has been selected by this character to be checked.
* @param forceUse if character pressed ctrl (force pick target)
* @param dontMove if character pressed shift (dont move and pick target only if in range)
* @param sendMessage send SystemMessageId packet if target is incorrect.
* @return the selected {@code WorldObject} this skill can be used on, or {@code null} if there is no such.
*/
public L2Object getTarget(L2Character activeChar, L2Object seletedTarget, boolean forceUse, boolean dontMove, boolean sendMessage)
{
final ITargetTypeHandler handler = TargetHandler.getInstance().getHandler(getTargetType());
if (handler != null)
{
try
{
return handler.getTarget(activeChar, seletedTarget, this, forceUse, dontMove, sendMessage);
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception in Skill.getTarget(): " + e.getMessage(), e);
}
}
activeChar.sendMessage("Target type of skill " + this + " is not currently handled.");
return null;
}
/**
* @param activeChar the character that needs to gather targets.
* @param target the initial target activeChar is focusing upon.
* @return list containing objects gathered in a specific geometric way that are valid to be affected by this skill.
*/
public List getTargetsAffected(L2Character activeChar, L2Object target)
{
if (target == null)
{
return null;
}
activeChar.sendDebugMessage("-> " + this + "\n TT: " + getTargetType() + "\n AS: " + getAffectScope() + "\n AO: " + getAffectObject());
final IAffectScopeHandler handler = AffectScopeHandler.getInstance().getHandler(getAffectScope());
if (handler != null)
{
try
{
final List result = new LinkedList<>();
handler.forEachAffected(activeChar, target, this, o -> result.add(o));
return result;
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception in Skill.getTargetsAffected(): " + e.getMessage(), e);
}
}
activeChar.sendMessage("Target affect scope of skill " + this + " is not currently handled.");
return null;
}
/**
* @param activeChar the character that needs to gather targets.
* @param target the initial target activeChar is focusing upon.
* @param action for each affected target.
*/
public void forEachTargetAffected(L2Character activeChar, L2Object target, Consumer action)
{
if (target == null)
{
return;
}
final IAffectScopeHandler handler = AffectScopeHandler.getInstance().getHandler(getAffectScope());
if (handler != null)
{
try
{
handler.forEachAffected(activeChar, target, this, action);
}
catch (Exception e)
{
_log.log(Level.WARNING, "Exception in Skill.forEachTargetAffected(): " + e.getMessage(), e);
}
}
else
{
activeChar.sendMessage("Target affect scope of skill " + this + " is not currently handled.");
}
}
/**
* Adds an effect to the effect list for the given effect scope.
* @param effectScope the effect scope
* @param effect the effect
*/
public void addEffect(EffectScope effectScope, AbstractEffect effect)
{
_effectLists.computeIfAbsent(effectScope, k -> new ArrayList<>()).add(effect);
}
/**
* Gets the skill effects.
* @param effectScope the effect scope
* @return the list of effects for the give scope
*/
public List getEffects(EffectScope effectScope)
{
return _effectLists.get(effectScope);
}
/**
* Verify if this skill has effects for the given scope.
* @param effectScope the effect scope
* @return {@code true} if this skill has effects for the given scope, {@code false} otherwise
*/
public boolean hasEffects(EffectScope effectScope)
{
final List effects = _effectLists.get(effectScope);
return (effects != null) && !effects.isEmpty();
}
/**
* Applies the effects from this skill to the target for the given effect scope.
* @param effectScope the effect scope
* @param info the buff info
* @param applyInstantEffects if {@code true} instant effects will be applied to the effected
* @param addContinuousEffects if {@code true} continuous effects will be applied to the effected
*/
public void applyEffectScope(EffectScope effectScope, BuffInfo info, boolean applyInstantEffects, boolean addContinuousEffects)
{
if ((effectScope != null) && hasEffects(effectScope))
{
for (AbstractEffect effect : getEffects(effectScope))
{
if (effect.isInstant())
{
if (applyInstantEffects && effect.calcSuccess(info.getEffector(), info.getEffected(), info.getSkill()))
{
effect.instant(info.getEffector(), info.getEffected(), info.getSkill(), info.getItem());
}
}
else if (addContinuousEffects)
{
if (applyInstantEffects)
{
effect.continuousInstant(info.getEffector(), info.getEffected(), info.getSkill(), info.getItem());
}
if (effect.canStart(info))
{
info.addEffect(effect);
}
}
}
}
}
/**
* Method overload for {@link Skill#applyEffects(L2Character, L2Character, boolean, boolean, boolean, int, L2ItemInstance)}.
* Simplify the calls.
* @param effector the caster of the skill
* @param effected the target of the effect
*/
public void applyEffects(L2Character effector, L2Character effected)
{
applyEffects(effector, effected, false, false, true, 0, null);
}
/**
* Method overload for {@link Skill#applyEffects(L2Character, L2Character, boolean, boolean, boolean, int, L2ItemInstance)}.
* Simplify the calls.
* @param effector the caster of the skill
* @param effected the target of the effect
* @param item
*/
public void applyEffects(L2Character effector, L2Character effected, L2ItemInstance item)
{
applyEffects(effector, effected, false, false, true, 0, item);
}
/**
* Method overload for {@link Skill#applyEffects(L2Character, L2Character, boolean, boolean, boolean, int, L2ItemInstance)}.
* Simplify the calls, allowing abnormal time time customization.
* @param effector the caster of the skill
* @param effected the target of the effect
* @param instant if {@code true} instant effects will be applied to the effected
* @param abnormalTime custom abnormal time, if equal or lesser than zero will be ignored
*/
public void applyEffects(L2Character effector, L2Character effected, boolean instant, int abnormalTime)
{
applyEffects(effector, effected, false, false, instant, abnormalTime, null);
}
/**
* Applies the effects from this skill to the target.
* @param effector the caster of the skill
* @param effected the target of the effect
* @param self if {@code true} self-effects will be casted on the caster
* @param passive if {@code true} passive effects will be applied to the effector
* @param instant if {@code true} instant effects will be applied to the effected
* @param abnormalTime custom abnormal time, if equal or lesser than zero will be ignored
* @param item
*/
public void applyEffects(L2Character effector, L2Character effected, boolean self, boolean passive, boolean instant, int abnormalTime, L2ItemInstance item)
{
// null targets cannot receive any effects.
if (effected == null)
{
return;
}
if (effected.isIgnoringSkillEffects(getId(), getLevel()))
{
effected.sendDebugMessage("Skill " + toString() + " has been ignored (ignoring skill effects)");
return;
}
boolean addContinuousEffects = !passive && (_operateType.isToggle() || (_operateType.isContinuous() && Formulas.calcEffectSuccess(effector, effected, this)));
if (!self && !passive)
{
final BuffInfo info = new BuffInfo(effector, effected, this, !instant, item, null);
if (addContinuousEffects && (abnormalTime > 0))
{
info.setAbnormalTime(abnormalTime);
}
applyEffectScope(EffectScope.GENERAL, info, instant, addContinuousEffects);
final EffectScope pvpOrPveEffectScope = effector.isPlayable() && effected.isAttackable() ? EffectScope.PVE : effector.isPlayable() && effected.isPlayable() ? EffectScope.PVP : null;
applyEffectScope(pvpOrPveEffectScope, info, instant, addContinuousEffects);
applyEffectScope(EffectScope.CHANNELING, info, instant, addContinuousEffects);
if (addContinuousEffects)
{
effected.getEffectList().add(info);
// Check for mesmerizing debuffs and increase resist level.
if (isDebuff() && (getBasicProperty() != BasicProperty.NONE) && effected.hasBasicPropertyResist())
{
final BasicPropertyResist resist = effected.getBasicPropertyResist(getBasicProperty());
resist.increaseResistLevel();
effected.sendDebugMessage(toString() + " has increased your " + getBasicProperty() + " debuff resistance to " + resist.getResistLevel() + " level for " + resist.getRemainTime().toMillis() + " milliseconds.");
}
}
// Support for buff sharing feature including healing herbs.
if (isSharedWithSummon() && effected.isPlayer() && effected.hasServitors() && !isTransformation())
{
if ((addContinuousEffects && isContinuous() && !isDebuff()) || isRecoveryHerb())
{
effected.getServitors().values().forEach(s -> applyEffects(effector, s, isRecoveryHerb(), 0));
}
}
}
if (self)
{
addContinuousEffects = !passive && (_operateType.isToggle() || (_operateType.isSelfContinuous() && Formulas.calcEffectSuccess(effector, effector, this)));
final BuffInfo info = new BuffInfo(effector, effector, this, !instant, item, null);
if (addContinuousEffects && (abnormalTime > 0))
{
info.setAbnormalTime(abnormalTime);
}
applyEffectScope(EffectScope.SELF, info, instant, addContinuousEffects);
if (addContinuousEffects)
{
info.getEffector().getEffectList().add(info);
}
// Support for buff sharing feature.
// Avoiding Servitor Share since it's implementation already "shares" the effect.
if (addContinuousEffects && isSharedWithSummon() && info.getEffected().isPlayer() && isContinuous() && !isDebuff() && info.getEffected().hasServitors())
{
info.getEffected().getServitors().values().forEach(s -> applyEffects(effector, s, false, 0));
}
}
if (passive)
{
final BuffInfo info = new BuffInfo(effector, effector, this, true, item, null);
applyEffectScope(EffectScope.GENERAL, info, false, true);
effector.getEffectList().add(info);
}
}
/**
* Activates a skill for the given creature and targets.
* @param caster the caster
* @param targets the targets
*/
public void activateSkill(L2Character caster, L2Object... targets)
{
activateSkill(caster, null, targets);
}
/**
* Activates a skill for the given creature and targets.
* @param caster the caster
* @param item
* @param targets the targets
*/
public void activateSkill(L2Character caster, L2ItemInstance item, L2Object... targets)
{
activateSkill(caster, null, item, targets);
}
/**
* Activates a skill for the given cubic and targets.
* @param cubic the cubic
* @param targets the targets
*/
public void activateSkill(CubicInstance cubic, L2Object... targets)
{
activateSkill(cubic.getOwner(), cubic, null, targets);
}
/**
* Activates the skill to the targets.
* @param caster the caster
* @param cubic the cubic that cast the skill, can be {@code null}
* @param item
* @param targets the targets
*/
public final void activateSkill(L2Character caster, CubicInstance cubic, L2ItemInstance item, L2Object... targets)
{
// TODO: replace with AI
switch (getId())
{
case 5852:
case 5853:
{
final L2BlockInstance block = targets[0] instanceof L2BlockInstance ? (L2BlockInstance) targets[0] : null;
final L2PcInstance player = caster.isPlayer() ? (L2PcInstance) caster : null;
if ((block == null) || (player == null))
{
return;
}
final int arena = player.getBlockCheckerArena();
if (arena != -1)
{
final ArenaParticipantsHolder holder = HandysBlockCheckerManager.getInstance().getHolder(arena);
if (holder == null)
{
return;
}
final int team = holder.getPlayerTeam(player);
final int color = block.getColorEffect();
if ((team == 0) && (color == 0x00))
{
block.changeColor(player, holder, team);
}
else if ((team == 1) && (color == 0x53))
{
block.changeColor(player, holder, team);
}
}
break;
}
default:
{
for (L2Object targetObject : targets)
{
if (!targetObject.isCharacter())
{
continue;
}
final L2Character target = (L2Character) targetObject;
if (Formulas.calcBuffDebuffReflection(target, this))
{
// if skill is reflected instant effects should be casted on target
// and continuous effects on caster
applyEffects(target, caster, false, 0);
final BuffInfo info = new BuffInfo(caster, target, this, false, item, null);
applyEffectScope(EffectScope.GENERAL, info, true, false);
final EffectScope pvpOrPveEffectScope = caster.isPlayable() && target.isAttackable() ? EffectScope.PVE : caster.isPlayable() && target.isPlayable() ? EffectScope.PVP : null;
applyEffectScope(pvpOrPveEffectScope, info, true, false);
applyEffectScope(EffectScope.CHANNELING, info, true, false);
}
else
{
applyEffects(caster, target, item);
}
}
break;
}
}
// Self Effect
if (hasEffects(EffectScope.SELF))
{
if (caster.isAffectedBySkill(getId()))
{
caster.stopSkillEffects(true, getId());
}
applyEffects(caster, caster, true, false, true, 0, item);
}
if (cubic == null)
{
if (useSpiritShot())
{
caster.setChargedShot(caster.isChargedShot(ShotType.BLESSED_SPIRITSHOTS) ? ShotType.BLESSED_SPIRITSHOTS : ShotType.SPIRITSHOTS, false);
}
else if (useSoulShot())
{
caster.setChargedShot(ShotType.SOULSHOTS, false);
}
}
if (isSuicideAttack())
{
caster.doDie(caster);
}
}
/**
* Adds a condition to the condition list for the given condition scope.
* @param skillConditionScope the condition scope
* @param skillCondition the condition
*/
public void addCondition(SkillConditionScope skillConditionScope, ISkillCondition skillCondition)
{
_conditionLists.computeIfAbsent(skillConditionScope, k -> new ArrayList<>()).add(skillCondition);
}
/**
* Checks the conditions of this skills for the given condition scope.
* @param skillConditionScope the condition scope
* @param caster the caster
* @param target the target
* @return {@code false} if at least one condition returns false, {@code true} otherwise
*/
public boolean checkConditions(SkillConditionScope skillConditionScope, L2Character caster, L2Object target)
{
return _conditionLists.getOrDefault(skillConditionScope, Collections.emptyList()).stream().allMatch(c -> c.canUse(caster, this, target));
}
@Override
public String toString()
{
return "Skill " + _name + "(" + _id + "," + _level + ")";
}
/**
* used for tracking item id in case that item consume cannot be used
* @return reference item id
*/
public int getReferenceItemId()
{
return _refId;
}
public boolean canBeDispelled()
{
return _canBeDispelled;
}
/**
* Verify if the skill can be stolen.
* @return {@code true} if skill can be stolen, {@code false} otherwise
*/
public boolean canBeStolen()
{
return !isPassive() && !isToggle() && !isDebuff() && !isHeroSkill() && !isGMSkill() && !(isStatic() && (getId() != CommonSkill.CARAVANS_SECRET_MEDICINE.getId())) && canBeDispelled() && (getId() != CommonSkill.SERVITOR_SHARE.getId());
}
public boolean isClanSkill()
{
return SkillTreesData.getInstance().isClanSkill(_id, _level);
}
public boolean isExcludedFromCheck()
{
return _excludedFromCheck;
}
public boolean isWithoutAction()
{
return _withoutAction;
}
/**
* Parses all the abnormal visual effects.
* @param abnormalVisualEffects the abnormal visual effects list
*/
private void parseAbnormalVisualEffect(String abnormalVisualEffects)
{
if (abnormalVisualEffects != null)
{
final String[] data = abnormalVisualEffects.split(";");
final Set aves = new HashSet<>(1);
for (String aveString : data)
{
final AbnormalVisualEffect ave = AbnormalVisualEffect.findByName(aveString);
if (ave != null)
{
aves.add(ave);
}
else
{
_log.warning("Invalid AbnormalVisualEffect(" + this + ") found for Skill(" + aveString + ")");
}
}
if (!aves.isEmpty())
{
_abnormalVisualEffects = aves;
}
}
}
/**
* @param effectType Effect type to check if its present on this skill effects.
* @param effectTypes Effect types to check if are present on this skill effects.
* @return {@code true} if at least one of specified {@link L2EffectType} types is present on this skill effects, {@code false} otherwise.
*/
public boolean hasEffectType(L2EffectType effectType, L2EffectType... effectTypes)
{
if (_effectTypes == null)
{
synchronized (this)
{
if (_effectTypes == null)
{
final Set effectTypesSet = new HashSet<>();
for (List effectList : _effectLists.values())
{
if (effectList != null)
{
for (AbstractEffect effect : effectList)
{
effectTypesSet.add((byte) effect.getEffectType().ordinal());
}
}
}
final Byte[] effectTypesArray = effectTypesSet.toArray(new Byte[effectTypesSet.size()]);
Arrays.sort(effectTypesArray);
_effectTypes = effectTypesArray;
}
}
}
if (Arrays.binarySearch(_effectTypes, (byte) effectType.ordinal()) >= 0)
{
return true;
}
for (L2EffectType type : effectTypes)
{
if (Arrays.binarySearch(_effectTypes, (byte) type.ordinal()) >= 0)
{
return true;
}
}
return false;
}
/**
* @param effectScope Effect Scope to look inside for the specific effect type.
* @param effectType Effect type to check if its present on this skill effects.
* @param effectTypes Effect types to check if are present on this skill effects.
* @return {@code true} if at least one of specified {@link L2EffectType} types is present on this skill effects, {@code false} otherwise.
*/
public boolean hasEffectType(EffectScope effectScope, L2EffectType effectType, L2EffectType... effectTypes)
{
if (hasEffects(effectScope))
{
return false;
}
for (AbstractEffect effect : _effectLists.get(effectScope))
{
if (effectType == effect.getEffectType())
{
return true;
}
for (L2EffectType type : effectTypes)
{
if (type == effect.getEffectType())
{
return true;
}
}
}
return false;
}
/**
* @return icon of the current skill.
*/
public String getIcon()
{
return _icon;
}
public int getChannelingTickInterval()
{
return _channelingTickInterval;
}
public int getChannelingTickInitialDelay()
{
return _channelingTickInitialDelay;
}
public Set getRideState()
{
return _rideState;
}
public boolean isMentoring()
{
return _isMentoring;
}
/**
* @param activeChar
* @return alternative skill that has been attached due to the effect of toggle skills on the player (e.g Fire Stance, Water Stance).
*/
public Skill getAttachedSkill(L2Character activeChar)
{
// If character is double casting, return double cast skill.
if ((getDoubleCastSkill() > 0) && activeChar.isAffected(EffectFlag.DOUBLE_CAST))
{
return SkillData.getInstance().getSkill(getDoubleCastSkill(), getLevel());
}
// Default toggle group ID, assume nothing attached.
if ((getAttachToggleGroupId() <= 0) || (getAttachSkills() == null))
{
return null;
}
//@formatter:off
final int toggleSkillId = activeChar.getEffectList().getToggles().stream()
.filter(info -> info.getSkill().getToggleGroupId() == getAttachToggleGroupId())
.mapToInt(info -> info.getSkill().getId())
.findAny().orElse(0);
//@formatter:on
// No active toggles with this toggle group ID found.
if (toggleSkillId == 0)
{
return null;
}
final AttachSkillHolder attachedSkill = getAttachSkills().stream().filter(ash -> ash.getRequiredSkillId() == toggleSkillId).findAny().orElse(null);
// No attached skills for this toggle found.
if (attachedSkill == null)
{
return null;
}
return SkillData.getInstance().getSkill(attachedSkill.getSkillId(), getLevel());
}
public boolean canDoubleCast()
{
return _canDoubleCast;
}
public int getDoubleCastSkill()
{
return _doubleCastSkill;
}
public boolean canCastWhileDisabled()
{
return _canCastWhileDisabled;
}
public boolean isSharedWithSummon()
{
return _isSharedWithSummon;
}
public boolean isNecessaryToggle()
{
return _isNecessaryToggle;
}
public boolean isDeleteAbnormalOnLeave()
{
return _deleteAbnormalOnLeave;
}
public boolean isIrreplacableBuff()
{
return _irreplacableBuff;
}
/**
* @return if skill could not be requested for use by players.
*/
public boolean isBlockActionUseSkill()
{
return _blockActionUseSkill;
}
public int getToggleGroupId()
{
return _toggleGroupId;
}
public int getAttachToggleGroupId()
{
return _attachToggleGroupId;
}
public List getAlterSkills()
{
return _alterSkills;
}
public List getAttachSkills()
{
return _attachSkills;
}
public Set getAbnormalResists()
{
return _abnormalResists;
}
public double getMagicCriticalRate()
{
return _magicCriticalRate;
}
}