public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.tornado);
}
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.entanglingRootsInitialHit);
base.Awake();
}
public void OnKill(Ability _ability, GameObject target)
{
if (vineOnKillChance > 0 && usingAbility && target)
{
if (_ability == ability || _ability == AbilityIDList.getAbility(AbilityID.entanglingRootsHit) || _ability == AbilityIDList.getAbility(AbilityID.entanglingRootsInitialHit))
{
float rand = Random.Range(0f, 1f);
if (rand < vineOnKillChance)
{
usingAbility.UseAbility(AbilityIDList.getAbility(AbilityID.summonVineAtTarget), target.transform.position, false, false);
}
}
}
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (castsLightning)
{
RepeatedlyCastAtNearestEnemyWithinRadius cast = abilityObject.AddComponent <RepeatedlyCastAtNearestEnemyWithinRadius>();
cast.abilityToCast = AbilityIDList.getAbility(AbilityID.furyLeapLightning);
cast.castInterval = lightningInterval;
cast.radius = 3f;
}
if (movespeedOnLanding != 0)
{
BuffCreatorOnDeath buff = abilityObject.AddComponent <BuffCreatorOnDeath>();
abilityObject.AddComponent <BuffCreatorOnDeath>().addBuffToList(Tags.Properties.Movespeed, 0f, movespeedOnLanding, null, null, 3f, null, "FuryLeapMoveSpeed");
}
if (attackAndCastSpeedOnLanding != 0)
{
BuffCreatorOnDeath buff = abilityObject.AddComponent <BuffCreatorOnDeath>();
buff.addBuffToList(Tags.Properties.AttackSpeed, 0f, attackAndCastSpeedOnLanding, null, null, 3f, null, "FuryLeapAttackSpeed");
buff.addBuffToList(Tags.Properties.CastSpeed, 0f, attackAndCastSpeedOnLanding, null, null, 3f, null, "FuryLeapCastSpeed");
}
if (eligiblePetsJumpToo)
{
SummonTracker summonTracker = GetComponent <SummonTracker>();
if (summonTracker)
{
foreach (Summoned summon in summonTracker.summons)
{
if (summon.GetComponent <CanJump>() && summon.GetComponent <UsingAbility>() && summon.GetComponent <StateController>() &&
summon.GetComponent <StateController>().currentState&& summon.GetComponent <StateController>().currentState.priority < 60)
{
summon.GetComponent <UsingAbility>().UseAbility(AbilityIDList.getAbility(AbilityID.furyLeap), targetLocation, false, false);
}
}
}
}
FuryLeapAoeMutator flam = abilityObject.AddComponent <FuryLeapAoeMutator>();
flam.increasedDamage = increasedDamage;
flam.increasedRadius = increasedRadius;
flam.increasedStunChance = increasedStunChance;
flam.moreDamageAgainstFullHealth = moreDamageAgainstFullHealth;
flam.addedCritMultiplier = addedCritMultiplier;
if (chanceToPull > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceToPull)
{
abilityObject.AddComponent <CreateAbilityObjectOnDeath>().abilityToInstantiate = AbilityIDList.getAbility(AbilityID.bigPull);
}
}
if (chanceToSummonVinesAtStart > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceToSummonVinesAtStart)
{
GetComponent <UsingAbility>().UseAbility(AbilityIDList.getAbility(AbilityID.summonVines), transform.position, false, false);
}
}
if (chanceToSummonVinesAtEnd > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceToSummonVinesAtStart)
{
abilityObject.AddComponent <CreateAbilityObjectOnDeath>().abilityToInstantiate = AbilityIDList.getAbility(AbilityID.summonVines);
}
}
return(abilityObject);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.leafShield);
base.Awake();
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.devouringOrb);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.furyLeapAoe);
base.Awake();
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.meteor);
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.vengeance);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.boneNova);
base.Awake();
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.thornBurst);
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.manaStrike);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.erasingStrikeHit);
base.Awake();
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.furyLeap);
}
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.iceWard);
base.Awake();
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.poisonArrow);
base.Awake();
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
BuffParent buffObject = abilityObject.GetComponent <BuffParent>();
// add additional duration
if (additionalDuration != 0)
{
DestroyAfterDuration durationObject = abilityObject.GetComponent <DestroyAfterDuration>();
if (durationObject != null)
{
durationObject.duration += additionalDuration;
}
}
// add additional block chance
if (additionalBlockChance > 0)
{
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.BlockChance, new List <Tags.AbilityTags>());
stat.addedValue = additionalBlockChance;
buffObject.taggedStats.Add(stat);
}
// add additional block protections
if (additionalBlockElementalProtection != 0)
{
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.BlockFireProtection, new List <Tags.AbilityTags>());
stat.addedValue = additionalBlockElementalProtection;
buffObject.taggedStats.Add(stat);
TaggedStatsHolder.TaggableStat stat2 = new TaggedStatsHolder.TaggableStat(Tags.Properties.BlockColdProtection, new List <Tags.AbilityTags>());
stat2.addedValue = additionalBlockElementalProtection;
buffObject.taggedStats.Add(stat2);
TaggedStatsHolder.TaggableStat stat3 = new TaggedStatsHolder.TaggableStat(Tags.Properties.BlockLightningProtection, new List <Tags.AbilityTags>());
stat3.addedValue = additionalBlockElementalProtection;
buffObject.taggedStats.Add(stat3);
}
// add additional block armour
if (additionalBlockArmour != 0)
{
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.BlockArmor, new List <Tags.AbilityTags>());
stat.addedValue = additionalBlockArmour;
buffObject.taggedStats.Add(stat);
}
// add additional armour
if (additionalArmour != 0)
{
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.Armour, new List <Tags.AbilityTags>());
stat.addedValue = additionalArmour;
buffObject.taggedStats.Add(stat);
}
// allow casting on allies
if (canCastOnAllies)
{
abilityObject.GetComponent <AttachToCreatorOnCreation>().runOnCreation = false;
abilityObject.AddComponent <AttachToNearestAllyOnCreation>();
abilityObject.AddComponent <StartsAtTarget>();
}
//adds ward gain on block
if (wardOnBlock > 0)
{
List <Tags.AbilityTags> onBlock = new List <Tags.AbilityTags> ();
onBlock.Add(Tags.AbilityTags.Block);
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.WardGain, onBlock);
stat.addedValue = wardOnBlock;
buffObject.taggedStats.Add(stat);
}
// ensure that reduced mana penalty is not greater than 1
float newReducedManaPenalty = reducedManaPenalty;
if (newReducedManaPenalty > 1)
{
newReducedManaPenalty = 1;
}
// reduced mana penalties
if (reducedManaPenalty != 0)
{
// reduce the "less" penalty intrinsic to the skill
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.ManaDrain, new List <Tags.AbilityTags>());
// reducing a 20% less penalty by 40% is the same as adding a 10% more multiplier
stat.moreValues.Add(-newReducedManaPenalty);
buffObject.taggedStats.Add(stat);
}
// add reduced mana regen (after being altered by reduced mana penalties)
if (extraManaDrain != 0)
{
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.ManaDrain, new List <Tags.AbilityTags>());
stat.addedValue = extraManaDrain;
buffObject.taggedStats.Add(stat);
}
// add ward retention
if (additionalWardRetention != 0)
{
TaggedStatsHolder.TaggableStat stat = new TaggedStatsHolder.TaggableStat(Tags.Properties.WardRetention, new List <Tags.AbilityTags>());
stat.addedValue = additionalWardRetention;
buffObject.taggedStats.Add(stat);
}
// ice nova
if (castsFrostNova)
{
CastAfterDuration cad = abilityObject.AddComponent <CastAfterDuration>();
cad.limitCasts = false;
cad.interval = 3f / (1 + increasedFrostNovaFrequency);
cad.ability = AbilityIDList.getAbility(AbilityID.frostNova);
FrostNovaMutator novaMutator = abilityObject.AddComponent <FrostNovaMutator>();
novaMutator.increasedDamage = novaDamage;
novaMutator.addedCritChance = novaCritChance;
novaMutator.addedCritMultiplier = novaCritMulti;
}
// add additional ward regen
if (additionalWardRegen > 0)
{
BuffParent protectionObject = abilityObject.GetComponent <BuffParent>();
if (protectionObject != null)
{
protectionObject.wardRegen += additionalWardRegen;
}
}
return(abilityObject);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.tempestHit);
base.Awake();
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.summonSkeletonWarlord);
base.Awake();
}
GameObject instantiateLightningNova(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
Destroy(abilityObject);
return(Instantiate(AbilityIDList.getAbility(AbilityID.lightningNova).abilityPrefab, location, Quaternion.Euler(targetLocation - location)));
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.furyLeap);
base.Awake();
GetComponent <AbilityEventListener>().onKillEvent += ResetCooldown;
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (addedVoidDamage > 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.addBaseDamage(DamageType.VOID, addedVoidDamage);
}
}
if (timeRotChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.TimeRot);
newComponent.chance = timeRotChance;
}
if (igniteChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite);
newComponent.chance = igniteChance;
}
if (addedCritChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critChance += addedCritChance;
}
}
if (chanceToAttachSparkCharge > 0)
{
ChanceToCreateAbilityObjectOnNewEnemyHit newComponent = abilityObject.AddComponent <ChanceToCreateAbilityObjectOnNewEnemyHit>();
newComponent.spawnAtHit = true;
newComponent.chance = chanceToAttachSparkCharge;
newComponent.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.sparkCharge);
}
if (addedCritMultiplier != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critMultiplier += addedCritMultiplier;
}
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (moreDamageAgainstFullHealth != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
conditionalEffect.conditional = new FullHealthConditional();
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstFullHealth);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (moreDamageAgainstTimeRotting != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.TimeRot;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstTimeRotting);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (increasedRadius > 0)
{
foreach (CreateOnDeath cod in abilityObject.GetComponents <CreateOnDeath>())
{
cod.increasedRadius = increasedRadius;
}
foreach (CapsuleCollider col in abilityObject.GetComponents <CapsuleCollider>())
{
col.height *= (1 + increasedRadius);
col.radius *= (1 + increasedRadius);
}
}
return(abilityObject);
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.shieldRush);
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.iceWard);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.meteorShrapnel);
base.Awake();
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.fireShield);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (increasedRadius != 0)
{
foreach (CreateOnDeath cod in abilityObject.GetComponents <CreateOnDeath>())
{
cod.increasedRadius = increasedRadius;
cod.increasedHeight = increasedRadius;
}
foreach (CapsuleCollider col in abilityObject.GetComponents <CapsuleCollider>())
{
col.height *= (1 + increasedRadius);
col.radius *= (1 + increasedRadius);
}
}
if (damageBuff != 0)
{
BuffOnAllyHit boah = abilityObject.AddComponent <BuffOnAllyHit>();
boah.addBuffToList(Tags.Properties.Damage, 0, damageBuff, null, null, 4 * (1 + increasedBuffDuration), null, "Entangling Roots Damage Buff");
}
if (poisonChanceToWolves != 0)
{
BuffOnAllyHit boah = abilityObject.AddComponent <BuffOnAllyHit>();
boah.onlyApplyToMinionFromAbility = true;
boah.requiredAbility = AbilityIDList.getAbility(AbilityID.summonWolf);
boah.addBuffToList(Tags.Properties.PoisonChance, 0, poisonChanceToWolves, null, null, 4 * (1 + increasedBuffDuration), null, "Entangling Roots Poison Buff");
}
if (bleedchanceToBears != 0)
{
BuffOnAllyHit boah = abilityObject.AddComponent <BuffOnAllyHit>();
boah.onlyApplyToMinionFromAbility = true;
boah.requiredAbility = AbilityIDList.getAbility(AbilityID.summonBear);
boah.addBuffToList(Tags.Properties.BleedChance, 0, bleedchanceToBears, null, null, 4 * (1 + increasedBuffDuration), null, "Entangling Roots Bleed Buff");
BuffOnAllyHit boah2 = abilityObject.AddComponent <BuffOnAllyHit>();
boah2.onlyApplyToMinionFromAbility = true;
boah2.requiredAbility = AbilityIDList.getAbility(AbilityID.summonSerpent);
boah2.addBuffToList(Tags.Properties.BleedChance, 0, bleedchanceToBears, null, null, 4 * (1 + increasedBuffDuration), null, "Entangling Roots Bleed Buff");
}
if (castSpeedToSpriggans != 0)
{
BuffOnAllyHit boah = abilityObject.AddComponent <BuffOnAllyHit>();
boah.onlyApplyToMinionFromAbility = true;
boah.requiredAbility = AbilityIDList.getAbility(AbilityID.summonSpriggan);
boah.addBuffToList(Tags.Properties.CastSpeed, 0, castSpeedToSpriggans, null, null, 4 * (1 + increasedBuffDuration), null, "Entangling Roots Cast Buff");
}
if (healSpriggans)
{
HealAlliesOnHit component = abilityObject.AddComponent <HealAlliesOnHit>();
component.onlyApplyToMinionFromAbility = true;
component.requiredAbility = AbilityIDList.getAbility(AbilityID.summonSpriggan);
component.healAmount = 100000;
}
// initial melee hit
if (!meleeScalingInitialHit)
{
foreach (CreateOnDeath cod in abilityObject.GetComponents <CreateOnDeath>())
{
cod.objectsToCreateOnDeath.Clear();
}
foreach (DamageEnemyOnHit damage in abilityObject.GetComponents <DamageEnemyOnHit>())
{
damage.baseDamageStats.damage.Clear();
damage.baseDamageStats.addedDamageScaling = 0;
Destroy(damage);
abilityObject.AddComponent <CannotApplyAdditionalStatuses>();
}
}
else
{
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (chanceToPoison > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Poison);
newComponent.chance = chanceToPoison;
}
if (alwaysStuns)
{
StunEnemyOnHit component = abilityObject.AddComponent <StunEnemyOnHit>();
component.duration = 0.8f;
}
}
return(abilityObject);
}
public override void setAbility()
{
ability = AbilityIDList.getAbility(AbilityID.staticOrb);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// changing the repeated hit mutator
if (increasedDamage != 0 || addedPoisonDamage != 0 || increasedRadius != 0)
{
EntanglingRootsHitMutator hitMutator = abilityObject.AddComponent <EntanglingRootsHitMutator>();
hitMutator.increasedDamage = increasedDamage;
hitMutator.addedPoisonDamage = addedPoisonDamage;
hitMutator.increasedRadius = increasedRadius;
}
// create the initial hit
CastInLine initialiHitCreator = abilityObject.AddComponent <CastInLine>();
initialiHitCreator.ability = AbilityIDList.getAbility(AbilityID.entanglingRootsInitialHit);
initialiHitCreator.casts = 1;
initialiHitCreator.distancePerCast = 0;
initialiHitCreator.targetPoint = targetLocation;
// changing the initial hit mutator
EntanglingRootsInitialHitMutator initialHitMutator = abilityObject.AddComponent <EntanglingRootsInitialHitMutator>();
initialHitMutator.increasedDamage = initialHitIncreasedDamage;
initialHitMutator.chanceToPoison = initialHitChanceToPoison;
initialHitMutator.increasedRadius = increasedRadius;
initialHitMutator.increasedBuffDuration = increasedBuffDuration;
initialHitMutator.damageBuff = damageBuff;
initialHitMutator.poisonChanceToWolves = poisonChanceToWolves;
initialHitMutator.bleedchanceToBears = bleedchanceToBears;
initialHitMutator.castSpeedToSpriggans = castSpeedToSpriggans;
initialHitMutator.healSpriggans = healSpriggans;
initialHitMutator.meleeScalingInitialHit = meleeScalingInitialHit;
initialHitMutator.alwaysStuns = InitialHitAlwaysStuns;
// creating extra patches
if (addedPatches > 0)
{
// add extra casts
if (patchesInLine)
{
CastInLine component = abilityObject.AddComponent <CastInLine>();
component.ability = AbilityIDList.getAbility(AbilityID.entanglingRoots);
component.casts = addedPatches;
component.distancePerCast = 4;
component.targetPoint = targetLocation;
}
else
{
CastAtRandomPointAfterDuration component = abilityObject.AddComponent <CastAtRandomPointAfterDuration>();
component.ability = AbilityIDList.getAbility(AbilityID.entanglingRoots);
component.duration = 0.01f;
component.limitCasts = true;
component.remainingCasts = addedPatches;
component.radius = 5f;
}
// copy mutator
EntanglingRootsMutator mutator = abilityObject.AddComponent <EntanglingRootsMutator>();
mutator.increasedDamage = increasedDamage;
mutator.addedPoisonDamage = addedPoisonDamage;
mutator.increasedRadius = increasedRadius;
mutator.initialHitIncreasedDamage = initialHitIncreasedDamage;
mutator.initialHitChanceToPoison = initialHitChanceToPoison;
mutator.increasedBuffDuration = increasedBuffDuration;
mutator.damageBuff = damageBuff;
mutator.poisonChanceToWolves = poisonChanceToWolves;
mutator.bleedchanceToBears = bleedchanceToBears;
mutator.castSpeedToSpriggans = castSpeedToSpriggans;
mutator.healSpriggans = healSpriggans;
mutator.meleeScalingInitialHit = meleeScalingInitialHit;
mutator.InitialHitAlwaysStuns = InitialHitAlwaysStuns;
mutator.increasedDuration = increasedDuration;
mutator.healingNovaChance = healingNovaChance;
}
if (increasedDuration != 0)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
if (dad)
{
dad.duration *= (1 + increasedDuration);
}
}
if (increasedRadius != 0)
{
foreach (MagicalFX.FX_Tentacle_ultimate vfx in abilityObject.GetComponentsInChildren <MagicalFX.FX_Tentacle_ultimate>())
{
vfx.SpreadMin *= (1 + increasedRadius);
vfx.SpreadMax *= (1 + increasedRadius);
vfx.SpreadSpawn *= (1 + increasedRadius);
vfx.Number = (int)(((float)vfx.Number) * (1 + increasedRadius));
}
}
if (healingNovaChance > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < healingNovaChance)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.healingNova);
}
}
return(abilityObject);
}
// Use this for initialization
protected override void Awake()
{
ability = AbilityIDList.getAbility(AbilityID.bigPull);
base.Awake();
}
