public void OnHit(Ability _ability, GameObject target)
{
if (firstHit)
{
firstHit = false;
// buffs
if (increasedDamageOnFirstHit != 0)
{
statBuffs.addBuff(4f, Tags.Properties.Damage, 0, increasedDamageOnFirstHit, null, null);
}
if (increasedAttackSpeedOnFirstHit != 0)
{
statBuffs.addBuff(4f, Tags.Properties.AttackSpeed, 0, increasedAttackSpeedOnFirstHit, null, null, null, "Swipe attack speed");
statBuffs.addBuff(4f, Tags.Properties.CastSpeed, 0, increasedAttackSpeedOnFirstHit, null, null, null, "Swipe cast speed");
}
if (increasedCritChanceOnFirstHit != 0)
{
statBuffs.addBuff(4f, Tags.Properties.CriticalChance, 0, increasedCritChanceOnFirstHit, null, null, null, "Swipe crit chance");
}
if (addedCritMultiOnFirstHit != 0)
{
statBuffs.addBuff(4f, Tags.Properties.CriticalMultiplier, addedCritMultiOnFirstHit, 0, null, null, null, "Swipe crit multi");
}
// wolf
float random = Random.Range(0f, 1f);
if (!usingAbility)
{
usingAbility = GetComponent <UsingAbility>();
}
if (random < spiritWolvesOnFirstHitChance)
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.spiritWolves), lastTargetPosition, false, false);
}
}
}
public void onKill(Ability _ability, GameObject target)
{
if (snakeOnKillChance > 0 && (_ability == ability))
{
float rand = Random.Range(0f, 1f);
if (rand < snakeOnKillChance)
{
if (!usingAbility)
{
usingAbility = GetComponent <UsingAbility>();
}
if (usingAbility)
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.summonSerpent), target.transform.position, false, false);
}
}
}
if (lifeOnKill != 0 && (_ability == ability))
{
float rand = Random.Range(0f, 1f);
if (rand < lifeOnKill)
{
if (!baseHealth)
{
baseHealth = GetComponent <BaseHealth>();
}
if (baseHealth)
{
baseHealth.Heal(lifeOnKill);
}
}
}
}
// Use this for initialization
void Start()
{
if (transform.parent)
{
usingAbility = transform.parent.GetComponent <UsingAbility>();
if (usingAbility)
{
usingAbility.usedAbilityEvent += die;
}
}
}
public void OnCrit(Ability _ability, GameObject target)
{
if (_ability == Ability.getAbility(AbilityID.erasingStrikeHit) && voidChargeOnCrit)
{
if (!ua)
{
ua = GetComponent <UsingAbility>();
}
ua.UseAbility(Ability.getAbility(AbilityID.voidEssence), transform.position, false, false);
}
}
public void Start()
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
health = references.creator.GetComponent <BaseHealth>();
ua = references.creator.GetComponent <UsingAbility>();
ua.usedAbilityManaEvent += dealDamage;
}
}
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.entanglingRoots);
base.Awake();
AbilityEventListener eventListener = GetComponent <AbilityEventListener>();
if (eventListener)
{
eventListener.onKillEvent += OnKill;
}
usingAbility = GetComponent <UsingAbility>();
}
public void Start()
{
references = GetComponent <CreationReferences>();
if (references && references.creator)
{
usingAbility = references.creator.GetComponent <UsingAbility>();
if (usingAbility)
{
usingAbility.usedAbilityManaEvent += destroyThis;
}
}
}
public void initialise()
{
initialised = true;
usingAbility = usingAbilityGo.GetComponent <UsingAbility>();
if (usingAbility)
{
usingAbility.usedAbilityManaEvent += pause;
}
if (constantRotation)
{
degreesPerSecond = constantRotation.degreesPerSecond;
}
}
// Use this for initialization
void Start()
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
usingAbility = references.creator.GetComponent <UsingAbility>();
if (usingAbility)
{
usingAbility.channelEndEvent += DestroyThis;
}
}
}
public void OnKill(Ability _ability, GameObject target)
{
if (_ability && _ability == Ability.getAbility(AbilityID.erasingStrikeHit))
{
// void beams
killsSinceUse++;
if (killsSinceUse >= 5 && ua && voidBeamsOnkill)
{
killsSinceUse = -10000;
ua.UseAbility(Ability.getAbility(AbilityID.playerVoidBeams), transform.position + transform.forward, false, false);
}
// stationary void beam
if (!ua)
{
ua = GetComponent <UsingAbility>();
}
if (stationaryVoidBeamChance != 0 && ua)
{
if ((Random.Range(0f, 1f) < stationaryVoidBeamChance) && target)
{
ua.UseAbility(Ability.getAbility(AbilityID.stationaryVoidBeam), target.transform.position, false, false);
}
}
// mana and health
if (mana && manaGainedOnKill != 0)
{
mana.currentMana += manaGainedOnKill; if (mana.currentMana > mana.maxMana)
{
mana.currentMana = mana.maxMana;
}
}
if (health && percentLifeGainedOnKill != 0 && target)
{
BaseHealth targetHealth = target.GetComponent <BaseHealth>();
if (targetHealth)
{
health.Heal(targetHealth.maxHealth * percentLifeGainedOnKill);
}
}
// move speed
if (movementSpeedOnKill != 0)
{
TaggedStatsHolder.Stat stat = new TaggedStatsHolder.Stat(Tags.Properties.Movespeed);
stat.increasedValue = movementSpeedOnKill;
Buff buff = new Buff(stat, 4f);
statBuffs.addBuff(buff);
}
}
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.vengeance);
base.Awake();
mana = GetComponent <BaseMana>();
health = GetComponent <BaseHealth>();
AbilityEventListener ael = AbilityEventListener.GetOrAdd(gameObject);
statBuffs = Comp <StatBuffs> .GetOrAdd(gameObject);
ua = GetComponent <UsingAbility>();
ael.onHitEvent += OnHit;
ael.onHitEvent += OnKill;
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.staticOrb);
base.Awake();
AbilityEventListener eventListener = GetComponent <AbilityEventListener>();
if (eventListener)
{
eventListener.onKillEvent += OnKill;
eventListener.onHitEvent += OnHit;
}
protectionClass = GetComponent <ProtectionClass>();
mana = GetComponent <BaseMana>();
usingAbility = GetComponent <UsingAbility>();
}
public void MoveCaster()
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
PositionRecorder recorder = references.creator.GetComponent <PositionRecorder>();
if (recorder)
{
UsingAbility ua = references.creator.GetComponent <UsingAbility>();
if (ua)
{
if (ua.getController().currentState == ua.getController().dying)
{
return;
}
if (ua.movementFromAbility && ua.movementFromAbility.moving)
{
ua.movementFromAbility.onReachingDestination();
}
StateController controller = ua.getController();
if (controller)
{
controller.forceChangeState(controller.waiting);
}
}
Vector3 newPosition = recorder.getPositionFromDuration(positionAge);
references.creator.transform.eulerAngles = recorder.getAngleFromDuration(positionAge);
references.creator.transform.position = newPosition;
if (restoreHealth && recorder.health)
{
recorder.health.currentHealth = Mathf.Clamp(recorder.getHealthFromDuration(positionAge + additionalAgeForHealthRestoration), 1f, recorder.health.maxHealth);
}
if (restoreMana && recorder.mana)
{
recorder.mana.currentMana = Mathf.Min(recorder.getManaFromDuration(positionAge + additionalAgeForManaRestoration), recorder.mana.maxMana);
}
}
}
}
public void SummonOnKill(Ability _ability, GameObject target)
{
if (clawTotemOnKillChance > 0 && (_ability == ability))
{
float rand = Random.Range(0f, 1f);
if (rand < clawTotemOnKillChance)
{
if (!usingAbility)
{
usingAbility = GetComponent <UsingAbility>();
}
if (usingAbility)
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.summonClawTotem), target.transform.position, false, false);
}
}
}
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.thornBurst);
base.Awake();
ProtectionClass protectionClass = GetComponent <ProtectionClass>();
if (protectionClass)
{
GetComponent <ProtectionClass>().detailedDamageEvent += whenHit;
}
ua = GetComponent <UsingAbility>();
if (ua)
{
AbilityEventListener listener = GetComponent <AbilityEventListener>();
if (listener)
{
listener.onKillEvent += OnKill;
listener.onHitEvent += OnHit;
}
}
}
public void parentTookDamage(int damage)
{
damageTakenSinceTrigger += damage;
if (damageTakenSinceTrigger > damageTakenTrigger)
{
damageTakenSinceTrigger = damageTakenSinceTrigger % damageTakenTrigger;
if (damageTakenSinceTrigger >= damageTakenTrigger)
{
damageTakenSinceTrigger = damageTakenTrigger - 1;
}
Transform target = parent.GetComponent <TargetFinder>().updateTarget();
Vector3 targetPosition = transform.forward;
if (target)
{
targetPosition = new Vector3(target.position.x, target.position.y + 1f, target.position.z);
}
else
{
targetPosition = new Vector3(transform.forward.x, transform.forward.y + 1f, transform.forward.z);
}
if (sourceOfAbility == SourceOfAbilityObjectConstructor.This)
{
GetComponent <AbilityObjectConstructor>().constructAbilityObject(ability, new Vector3(transform.position.x, transform.position.y + 1f, transform.position.z),
targetPosition);
}
else
{
UsingAbility usingAbility = GetComponentInParent <UsingAbility>();
if (usingAbility)
{
usingAbility.UseAbility(ability, targetPosition, false, false);
}
}
if (limitRetaliations)
{
retaliationsRemaining--;
}
retaliated = true;
}
}
public void OnKill(Ability _ability, GameObject target)
{
// vengeance
if (_ability && _ability == ability)
{
if (!ua)
{
ua = GetComponent <UsingAbility>();
}
if (darkBladeOnVengeanceKillChance != 0 && ua)
{
if (Random.Range(0f, 1f) < darkBladeOnVengeanceKillChance)
{
ua.UseAbility(Ability.getAbility(AbilityID.darkBlade), target.transform.position + new Vector3(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f)), false, false);
}
}
if (voidEssenceOnVengeanceKillChance != 0 && ua)
{
if (Random.Range(0f, 1f) < voidEssenceOnVengeanceKillChance)
{
ua.UseAbility(Ability.getAbility(AbilityID.voidEssence), transform.position, false, false);
}
}
}
// riposte
if (_ability && _ability == Ability.getAbility(AbilityID.riposteRetaliationHit))
{
if (!ua)
{
ua = GetComponent <UsingAbility>();
}
if (darkBladeOnRiposteKillChance != 0 && ua)
{
if (Random.Range(0f, 1f) < darkBladeOnRiposteKillChance)
{
ua.UseAbility(Ability.getAbility(AbilityID.darkBlade), target.transform.position + new Vector3(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f)), false, false);
}
}
}
}
// Use this for initialization
void Start()
{
abilityObjectConstructor = Comp <AbilityObjectConstructor> .GetOrAdd(gameObject);
// calculate scaling
if (scalingProperty != Tags.Properties.None)
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
BaseStats stats = references.creator.GetComponent <BaseStats>();
if (stats)
{
float scaler = stats.GetStatValue(scalingProperty);
if (scaler != 0)
{
interval /= scaler;
}
}
}
}
// get creator components if necessery
if (castFromCreatorCastPoint || castAtCreatorTargetLocation)
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
if (castFromCreatorCastPoint)
{
creatorSizeManager = references.creator.GetComponent <SizeManager>();
}
if (castAtCreatorTargetLocation)
{
creatorUsingAbility = references.creator.GetComponent <UsingAbility>();
}
}
}
}
public void Start()
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
SummonTracker summonTracker = references.creator.GetComponent <SummonTracker>();
if (summonTracker)
{
List <Summoned> minionsToUse = new List <Summoned>();
List <Summoned> creatorMinions = summonTracker.summons;
if (creatorMinions.Count > 0)
{
// select minions
if (minionsToUseAbility == MinionUseType.Nearest)
{
Summoned selected = creatorMinions[0];
float selectedDistance = Vector3.Distance(transform.position, creatorMinions[0].transform.position);
float distance = 0;
foreach (Summoned minion in creatorMinions)
{
distance = Vector3.Distance(transform.position, minion.transform.position);
if (distance < selectedDistance && (!requiresCanUseMovementAbilities || minion.GetComponent <CanUseMovementAbilities>()))
{
selectedDistance = distance;
selected = minion;
}
}
if (!requiresCanUseMovementAbilities || selected.GetComponent <CanUseMovementAbilities>())
{
minionsToUse.Add(selected);
}
}
else if (minionsToUseAbility == MinionUseType.Random)
{
int attempts = 0;
Summoned selected = null;
while (attempts < 20)
{
selected = creatorMinions[Random.Range(0, creatorMinions.Count)];
if (!requiresCanUseMovementAbilities || selected.GetComponent <CanUseMovementAbilities>())
{
attempts = 100000;
minionsToUse.Add(selected);
}
}
}
else if (minionsToUseAbility == MinionUseType.All)
{
if (!requiresCanUseMovementAbilities)
{
minionsToUse.AddRange(creatorMinions);
}
else
{
foreach (Summoned minion in creatorMinions)
{
if (minion.GetComponent <CanUseMovementAbilities>())
{
minionsToUse.Add(minion);
}
}
}
}
// make the minions use the ability
Vector3 targetPostion = GetComponent <LocationDetector>().targetLocation;
UsingAbility ua = null;
foreach (Summoned minion in minionsToUse)
{
ua = minion.GetComponent <UsingAbility>();
if (ua)
{
ua.UseAbility(ability, targetPostion, false, false);
ua.transform.LookAt(targetPostion);
}
}
}
}
}
}
// Use this for initialization
void Start()
{
usingAbility = GetComponent <UsingAbility>();
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// check if the explosion needs to be removed
if (removeExplosion)
{
CreateAbilityObjectOnDeath[] components = abilityObject.GetComponents <CreateAbilityObjectOnDeath>();
for (int i = 0; i < components.Length; i++)
{
if (components[i].abilityToInstantiate == AbilityIDList.getAbility(AbilityID.lightningExplosion))
{
Destroy(components[i]);
components[i].deactivate();
}
}
}
// explosion only stuff
else
{
if (increasedExplosionDamage != 0 || explosionChanceToShock != 0)
{
LightningExplosionMutator mut = abilityObject.AddComponent <LightningExplosionMutator>();
mut.increasedDamage = increasedExplosionDamage;
mut.chanceToShock = explosionChanceToShock;
}
if (explodesAtTarget)
{
abilityObject.GetComponent <DestroyAfterDuration>().duration = 1.5f;
if (!abilityObject.GetComponent <LocationDetector>())
{
abilityObject.AddComponent <LocationDetector>();
}
DestroyAfterDurationAfterReachingTargetLocation component = abilityObject.AddComponent <DestroyAfterDurationAfterReachingTargetLocation>();
component.duration = 0f;
}
if (chargedGroundAtEndChance > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chargedGroundAtEndChance)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.chargedGround);
}
}
}
if (chanceToAttachSparkCharge > 0)
{
ChanceToCreateAbilityObjectOnNewEnemyHit newComponent = abilityObject.AddComponent <ChanceToCreateAbilityObjectOnNewEnemyHit>();
newComponent.spawnAtHit = true;
newComponent.chance = chanceToAttachSparkCharge;
newComponent.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.sparkCharge);
}
if (increasedProjectileDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedProjectileDamage);
}
}
if (removePull)
{
PullComponent[] pullComponents = abilityObject.GetComponents <PullComponent>();
for (int i = 0; i < pullComponents.Length; i++)
{
Destroy(pullComponents[i]);
}
}
if (shockChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = shockChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Shock);
}
if (increasedSpeed > 0)
{
AbilityMover mover = abilityObject.GetComponent <AbilityMover>();
if (mover)
{
mover.speed *= (1 + increasedSpeed);
}
}
if (!usingAbility)
{
usingAbility = GetComponent <UsingAbility>();
}
// casting stuff
if (lightningAegisChance > 0 && usingAbility)
{
if (lightningAegisChance >= Random.Range(0f, 1f))
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.lightningAegis), transform.position, false, false);
}
}
if (knockBackOnCastChance > 0 && usingAbility)
{
if (knockBackOnCastChance >= Random.Range(0f, 1f))
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.knockBack), transform.position, false, false);
}
}
return(abilityObject);
}
public void OnHit(Ability _ability, GameObject target)
{
// vengeance
if (_ability && _ability == ability)
{
if (reducedDamageTakenOnHit != 0)
{
TaggedStatsHolder.Stat newStat = new TaggedStatsHolder.Stat(Tags.Properties.DamageTaken);
newStat.increasedValue = -reducedDamageTakenOnHit;
Buff buff = new Buff(newStat, 2f);
statBuffs.addBuff(buff);
}
if (darkBladeOnVengeanceHitChance != 0)
{
if (!ua)
{
ua = GetComponent <UsingAbility>();
}
if (Random.Range(0f, 1f) < darkBladeOnVengeanceHitChance && ua)
{
if (target)
{
ua.UseAbility(Ability.getAbility(AbilityID.darkBlade), target.transform.position, false, false);
}
else
{
ua.UseAbility(Ability.getAbility(AbilityID.darkBlade), target.transform.position + new Vector3(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f)), false, false);
}
}
}
}
// riposte
if (_ability && _ability == Ability.getAbility(AbilityID.riposteRetaliationHit))
{
if (!ua)
{
ua = GetComponent <UsingAbility>();
}
if (voidEssenceOnRiposteHitChance != 0 && ua)
{
if (Random.Range(0f, 1f) < voidEssenceOnRiposteHitChance)
{
if (target)
{
ua.UseAbility(Ability.getAbility(AbilityID.voidEssence), target.transform.position, false, false);
}
else
{
ua.UseAbility(Ability.getAbility(AbilityID.voidEssence), transform.position, false, false);
}
}
}
if (darkBladeOnRiposteHitChance != 0)
{
if (Random.Range(0f, 1f) < darkBladeOnRiposteHitChance && ua)
{
if (target)
{
ua.UseAbility(Ability.getAbility(AbilityID.darkBlade), target.transform.position, false, false);
}
else
{
ua.UseAbility(Ability.getAbility(AbilityID.darkBlade), target.transform.position + new Vector3(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f)), false, false);
}
}
}
}
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (chanceToBleed > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = chanceToBleed;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Bleed);
}
if (chanceToPlague > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = chanceToPlague;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Plague);
}
if (chanceToBlindingPoison > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = chanceToBlindingPoison;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.BlindingPoison);
}
if (chanceToShredArmour > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = chanceToShredArmour;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.ArmourShred);
}
if (poisonSpitChance > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < poisonSpitChance)
{
if (!usingAbility)
{
usingAbility = GetComponent <UsingAbility>();
}
if (usingAbility)
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.poisonSpit), targetLocation + new Vector3(0, -1.1f, 0), false, false);
}
}
}
if (increasedHitDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedHitDamage);
//holder.addBaseDamage(DamageType.PHYSICAL, holder.getBaseDamage(DamageType.PHYSICAL) * increasedDamage);
}
}
if (addedCritChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critChance += addedCritChance;
}
}
if (cullPercent > 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.cullPercent += cullPercent;
}
}
if (moreDamageAgainstBlinded != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Blind;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstBlinded);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (moreDamageAgainstPoisonBlinded != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.BlindingPoison;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstPoisonBlinded);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (dodgeRatingOnAttack != 0 || poisonDamageOnAttack != 0 || dotDamageOnAttack != 0)
{
StatBuffs statBuffs = GetComponent <StatBuffs>();
if (statBuffs == null)
{
statBuffs = gameObject.AddComponent <StatBuffs>();
}
if (dodgeRatingOnAttack != 0)
{
statBuffs.addBuff(4f, Tags.Properties.DodgeRating, dodgeRatingOnAttack, 0, null, null);
}
if (poisonDamageOnAttack != 0)
{
List <Tags.AbilityTags> tagList = new List <Tags.AbilityTags>();
tagList.Add(Tags.AbilityTags.Poison);
statBuffs.addBuff(4f, Tags.Properties.Damage, 0, poisonDamageOnAttack, null, null, tagList);
}
if (dotDamageOnAttack != 0)
{
List <Tags.AbilityTags> tagList = new List <Tags.AbilityTags>();
tagList.Add(Tags.AbilityTags.DoT);
statBuffs.addBuff(4f, Tags.Properties.Damage, 0, dotDamageOnAttack, null, null, tagList);
}
}
return(abilityObject);
}
