public void Trigger(GameObject triggerObject)
{
if (!triggered)
{
CreateAbilityObjectOnDeath caood = gameObject.AddComponent <CreateAbilityObjectOnDeath>();
caood.abilityToInstantiate = ability;
DestroyAfterDuration destroyer = gameObject.AddComponent <DestroyAfterDuration>();
destroyer.duration = castDelay;
}
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// Leech on cast buff
if (statBuffs)
{
statBuffs.addBuff(4f, Tags.Properties.PercentLifeLeech, 0, physLeechOnCast, null, null, physTag, "marrow shards phys leech on cast buff");
if (tracker && tracker.numberOfMinions() == 2)
{
statBuffs.addBuff(2f, Tags.Properties.CriticalChance, 0, critChanceOnCast, null, null, physTag, "marrow shards phys leech on cast buff");
}
}
if (createsSplintersAtEnd)
{
// nova trigger(s)
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.boneNova);
component.failsIfFailedAbility = true;
component.offset = boneNovaOffset;
component.aimingMethod = CreateAbilityObjectOnDeath.AimingMethod.TravelDirection;
// nova mutator
BoneNovaMutator mutator = abilityObject.AddComponent <BoneNovaMutator>();
mutator.increasedSpeed = nova_increasedSpeed;
mutator.pierces = true;
mutator.increasedDamage = nova_increasedDamage;
mutator.increasedStunChance = nova_increasedStunChance;
mutator.bleedChance = nova_bleedChance;
mutator.addedCritChance = nova_addedCritChance;
mutator.addedCritMultiplier = nova_addedCritMultiplier;
mutator.cone = true;
mutator.randomAngles = true;
mutator.noVFX = true;
mutator.dontAttach = true;
mutator.dontMoveToTarget = true;
mutator.moreDamageAgainstBleeding = nova_moreDamageAgainstBleeding;
}
if (returnHealthChance != 0 && returnHealthChance > (Random.Range(0f, 1f)))
{
CreateResourceReturnAbilityObjectOnEnemyHit component = abilityObject.AddComponent <CreateResourceReturnAbilityObjectOnEnemyHit>();
component.abilityObject = Ability.getAbility(AbilityID.bloodReturn);
component.health = healthReturned;
if (manaReturnChance != 0 && manaReturnChance > (Random.Range(0f, 1f)))
{
component.mana = manaReturned;
}
}
if (increasedHealthCost != 0)
{
DamageCreatorOnCreation component = abilityObject.GetComponent <DamageCreatorOnCreation>();
if (component)
{
component.flatDamage *= (1 + increasedHealthCost);
component.percentCurrentHealthTaken *= (1 + increasedHealthCost);
}
}
if (doesntPierce)
{
Comp <Pierce> .GetOrAdd(abilityObject).objectsToPierce = 0;
abilityObject.AddComponent <DestroyOnFailingToPierceEnemy>();
}
if (endsAtTargetPoint)
{
if (!abilityObject.GetComponent <LocationDetector>())
{
abilityObject.AddComponent <LocationDetector>();
}
DestroyAfterDurationAfterReachingTargetLocation component = abilityObject.AddComponent <DestroyAfterDurationAfterReachingTargetLocation>();
component.duration = 0f;
}
if (increasedDuration != 0)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
dad.duration *= 1 + increasedDuration;
}
if (addedCritChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critChance += addedCritChance;
}
}
if (addedCritMultiplier != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critMultiplier += addedCritMultiplier;
}
}
if (moreDamageAgainstBleeding != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Bleed;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstBleeding);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (chanceToBleed > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Bleed);
newComponent.chance = chanceToBleed;
}
if (chanceToShredArmour > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.ArmourShred);
newComponent.chance = chanceToShredArmour;
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
// increase damage based on the number of minions
float realIncreasedDamage = increasedDamage;
if (increasedDamagePerMinion != 0)
{
if (tracker && tracker.summons != null)
{
realIncreasedDamage += increasedDamagePerMinion * tracker.summons.Count;
}
}
// more damage if you only have one minion
if (increasedDamageWithOneMinion != 0)
{
if (tracker && tracker.numberOfMinions() == 1)
{
realIncreasedDamage += increasedDamageWithOneMinion;
}
}
if (increasedDamageFromMinionDrain != 0 && tracker && tracker.summons != null && tracker.summons.Count > 0)
{
// choose a minion to drain
BaseHealth minionHealth = tracker.summons[Random.Range(0, tracker.summons.Count - 1)].GetComponent <BaseHealth>();
if (minionHealth)
{
// gain extra damage
realIncreasedDamage += increasedDamageFromMinionDrain;
// create a death vfx
Instantiate(spiritEscapePrefab).transform.position = minionHealth.transform.position + spiritEscapeOffset;
// kill the minion
minionHealth.HealthDamage(minionHealth.currentHealth + 1);
}
}
// increase damage
if (realIncreasedDamage != 0 || moreDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(realIncreasedDamage);
if (moreDamage != 0)
{
holder.increaseAllDamage(moreDamage);
}
}
}
if (damagesMinions)
{
DamageEnemyOnHit deoh = abilityObject.GetComponent <DamageEnemyOnHit>();
if (deoh)
{
DamageCreatorMinionOnHit component = abilityObject.AddComponent <DamageCreatorMinionOnHit>();
component.baseDamageStats = deoh.baseDamageStats;
if (doesntPierce)
{
abilityObject.GetComponent <DestroyOnFailingToPierceEnemy>().alsoDestroyOnFailingToPierceCreatorMinion();
}
}
}
return(abilityObject);
}
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 override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (splatterChance > 0 && (!mana || mana.currentMana > 0) && (splatterChance >= 1 || splatterChance > (Random.Range(0f, 1f))))
{
// splatter trigger
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.bloodSplatter);
// splatter mutator
BloodSplatterMutator mutator = abilityObject.AddComponent <BloodSplatterMutator>();
mutator.increasedRadius = splatter_increasedRadius;
mutator.increasedDamage = splatter_increasedDamage;
mutator.chanceToPoison = splatter_chanceToPoison;
mutator.armourReductionChance = splatter_armourReductionChance;
mutator.armourReduction = splatter_armourReduction;
mutator.armourReductionStacks = splatter_armourReductionStacks;
mutator.increasedArmourDebuffDuration = splatter_increasedArmourDebuffDuration;
mutator.increasedDamagePerMinion = splatter_increasedDamagePerMinion;
mutator.minionBuffs = splatter_minionBuffs;
mutator.reducesDarkProtectionInstead = splatter_reducesDarkProtectionInstead;
mutator.necrotic = necrotic;
}
if (necrotic)
{
// replace vfx
CreateOnDeath cod = abilityObject.GetComponent <CreateOnDeath>();
if (cod && cod.objectsToCreateOnDeath != null && cod.objectsToCreateOnDeath.Count > 0)
{
cod.objectsToCreateOnDeath[0] = new CreateOnDeath.GameObjectHolder(PrefabList.getPrefab("NecroticRipBloodOnDeathVFX"));
}
// convert damage
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.convertAllDamageOfType(DamageType.PHYSICAL, DamageType.NECROTIC);
}
}
if (targetsAlliesInstead)
{
// change the damage component to hit allies (only hits minions by default)
DamageEnemyOnHit damageComponent = abilityObject.GetComponent <DamageEnemyOnHit>();
DamageAllyOnHit component = abilityObject.AddComponent <DamageAllyOnHit>();
component.baseDamageStats = damageComponent.baseDamageStats;
damageComponent.deactivate();
Destroy(damageComponent);
// make sure it still creates a blood orb
CreateResourceReturnAbilityObjectOnEnemyHit component2 = abilityObject.GetComponent <CreateResourceReturnAbilityObjectOnEnemyHit>();
component2.hitsAlliesInstead = true;
// change the targetting
MoveToNearestEnemyOnCreation moveComponent = abilityObject.GetComponent <MoveToNearestEnemyOnCreation>();
if (moveComponent)
{
moveComponent.moveToAllyInstead = true;
}
}
if (chanceToPoison > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Poison);
newComponent.chance = chanceToPoison;
}
if (chanceToBleed > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Bleed);
newComponent.chance = chanceToBleed;
}
if (addedHealthGained != 0 || increasedHealthGained != 0 || manaGained != 0 || convertHealthToWard || necrotic)
{
CreateResourceReturnAbilityObjectOnEnemyHit component = abilityObject.GetComponent <CreateResourceReturnAbilityObjectOnEnemyHit>();
// check if this behaviour needs to be removed
if (increasedHealthGained < -1 && manaGained <= 0)
{
component.deactivated = true;
}
// if it does not then change its values
else
{
component.health += addedHealthGained;
component.health *= (1 + increasedHealthGained);
if (increasedHealthGainedPerAttunement != 0)
{
component.health *= (1 + baseStats.GetStatValue(Tags.Properties.Attunement) * increasedHealthGainedPerAttunement);
}
component.mana += manaGained;
if (convertHealthToWard)
{
component.ward = component.health;
component.health = 0;
}
if (necrotic)
{
component.abilityObject = Ability.getAbility(AbilityID.necroticReturn);
}
}
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
// increase damage based on the number of minions
float realIncreasedDamage = increasedDamage;
if (increasedDamagePerMinion != 0)
{
if (tracker && tracker.summons != null)
{
realIncreasedDamage += increasedDamagePerMinion * tracker.summons.Count;
}
}
if (realIncreasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(realIncreasedDamage);
}
}
if (moreDamageInstances != null && moreDamageInstances.Count > 0)
{
float moreDamage = 1f;
foreach (float instance in moreDamageInstances)
{
moreDamage *= 1 + instance;
}
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(moreDamage - 1);
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (voidRiftAtStart)
{
CreateAbilityObjectOnStart component = abilityObject.AddComponent <CreateAbilityObjectOnStart>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.voidRift);
component.createAtStartLocation = true;
}
if (voidRiftAtEnd)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.voidRift);
}
if (voidRiftAtStart || voidRiftAtEnd)
{
VoidRiftMutator mut = abilityObject.AddComponent <VoidRiftMutator>();
mut.increasedDamage = increasedDamage;
mut.increasedRadius = increasedRadius;
mut.increasedStunChance = increasedStunChance;
mut.increasesDoTDamageTaken = increasesDoTDamageTaken;
mut.timeRotChance = timeRotChance;
mut.increasesDamageTaken = increasesDamageTaken;
}
// apply stats on cooldown
float cooldown = getCooldown();
StatBuffs buffs = GetComponent <StatBuffs>();
if (!buffs)
{
buffs = gameObject.AddComponent <StatBuffs>();
}
foreach (TaggedStatsHolder.TaggableStat stat in statsWhileOnCooldown)
{
TaggedStatsHolder.TaggableStat newStat = new TaggedStatsHolder.TaggableStat(stat);
buffs.addTaggedBuff(new TaggedBuff(newStat, cooldown));
}
// apply stats on use
float duration = 2 + additionalSecondsBack;
foreach (TaggedStatsHolder.TaggableStat stat in statOnUse)
{
TaggedStatsHolder.TaggableStat newStat = new TaggedStatsHolder.TaggableStat(stat);
buffs.addTaggedBuff(new TaggedBuff(newStat, duration));
}
if (noHealthRestoration || noManaRestoration)
{
ReturnCasterToOlderPosition component = abilityObject.GetComponent <ReturnCasterToOlderPosition>();
if (noHealthRestoration)
{
component.restoreHealth = false;
}
if (noManaRestoration)
{
component.restoreMana = false;
}
}
if (healsOrDamagesAtRandom && health)
{
float rand = Random.Range(0f, 1f);
if (rand < 0.8f)
{
health.Heal((health.maxHealth - health.currentHealth) * healOrDamagePercent);
}
else
{
health.HealthDamage(health.currentHealth * healOrDamagePercent);
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// if this is a meteor shower
if (additionalMeteors > 0)
{
Destroy(abilityObject);
abilityObject = Instantiate(AbilityIDList.getAbility(AbilityID.meteorShower).abilityPrefab);
abilityObject.transform.position = location;
CastAtRandomPointAfterDuration meteorCaster = abilityObject.GetComponent <CastAtRandomPointAfterDuration>();
meteorCaster.duration /= (1 + increasedMeteorFrequency);
meteorCaster.remainingCasts += additionalMeteors;
meteorCaster.radius *= (1 + increasedShowerRadius);
if (line)
{
StartsAtTarget sat = meteorCaster.GetComponent <StartsAtTarget>();
if (sat)
{
sat.active = false;
Destroy(sat);
}
AbilityMover mover = Comp <AbilityMover> .GetOrAdd(abilityObject);
mover.SetDirection(targetLocation - location);
mover.speed = 10 * (1 + increasedShowerRadius);
meteorCaster.radius = 0;
StartsTowardsTarget stt = abilityObject.AddComponent <StartsTowardsTarget>();
stt.distance = 1f;
stt.addWeaponRange = false;
}
// create a mutator on the meteor shower object
MeteorMutator newMutator = abilityObject.AddComponent <MeteorMutator>();
// variables for all damage
newMutator.moreDamageInstances = moreDamageInstances;
// meteor variables (except use all mana)
newMutator.increasedFallSpeed = increasedFallSpeed;
newMutator.increasedCastSpeed = increasedCastSpeed;
newMutator.shrapnelChance = shrapnelChance;
newMutator.increasedShrapnelSpeed = increasedShrapnelSpeed;
newMutator.shrapnelPierces = shrapnelPierces;
newMutator.replaceFireCircle = replaceFireCircle;
// aoe variables
newMutator.moreDamageAgainstFullHealth = moreDamageAgainstFullHealth;
newMutator.increasedShrapnelDamage = increasedShrapnelDamage;
newMutator.increasedStunChance = increasedStunChance;
newMutator.moreDamageInstances = new List <float>();
newMutator.moreDamageInstances.AddRange(moreDamageInstances);
// apply mana variable once for all meteors
if (usesAllMana && myMana)
{
float totalCost = myMana.getManaCost(ability);
totalCost += myMana.currentMana;
float proportion = totalCost / myMana.maxMana;
newMutator.moreDamageInstances.Add(proportion * 2);
myMana.currentMana = 0;
}
return(abilityObject);
}
// if this is a regular meteor
// apply aoe variables
MeteorAoEMutator aoeMutator = abilityObject.AddComponent <MeteorAoEMutator>();
aoeMutator.moreDamageAgainstFullHealth = moreDamageAgainstFullHealth;
aoeMutator.increasedStunChance = increasedStunChance;
aoeMutator.moreDamageInstances = new List <float>();
aoeMutator.moreDamageInstances.AddRange(moreDamageInstances);
// meteor variables
if (increasedFallSpeed != 0)
{
abilityObject.GetComponent <AbilityMover>().speed *= (1 + increasedFallSpeed);
}
MeteorShrapnelMutator shrapnelMutator = null;
if (shrapnelChance > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < shrapnelChance)
{
CreateAbilityObjectOnDeath caood = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
caood.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.meteorShrapnel);
caood.createAtTarget = true;
caood.offset = -caood.GetComponent <LocationDetector>().targetLocationOffset;
shrapnelMutator = abilityObject.AddComponent <MeteorShrapnelMutator>();
shrapnelMutator.increasedDamage = increasedShrapnelDamage;
shrapnelMutator.increasedSpeed = increasedShrapnelSpeed;
shrapnelMutator.pierces = shrapnelPierces;
shrapnelMutator.increasedStunChance = increasedStunChance;
shrapnelMutator.moreDamageInstances = new List <float>();
shrapnelMutator.moreDamageInstances.AddRange(moreDamageInstances);
}
}
if (replaceFireCircle)
{
CreateAtTargetLocationOnCreation component = abilityObject.GetComponent <CreateAtTargetLocationOnCreation>();
if (component)
{
component.objectsToCreate.Clear();
GameObject prefab = PrefabList.getPrefab("EnemyMeteorCircle");
if (prefab)
{
CreateAtTargetLocationOnCreation.GameObjectHolder holder = new CreateAtTargetLocationOnCreation.GameObjectHolder();
holder.gameObject = prefab;
holder.destroyWhenThisDies = true;
component.objectsToCreate.Add((holder));
}
}
}
if (usesAllMana && myMana)
{
float totalCost = myMana.getManaCost(ability);
totalCost += myMana.currentMana;
float proportion = totalCost / myMana.maxMana;
aoeMutator.moreDamageInstances.Add(proportion * 2);
if (shrapnelMutator)
{
shrapnelMutator.moreDamageInstances.Add(proportion * 2);
}
myMana.currentMana = 0;
}
return(abilityObject);
}
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);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (increasedSpeed != 0)
{
AbilityMover component = abilityObject.GetComponent <AbilityMover>();
if (component)
{
component.speed *= 1 + increasedSpeed;
}
}
if (convertToCold)
{
foreach (Transform child in abilityObject.transform)
{
if (child.name == "VolcanicOrbVFX")
{
child.gameObject.SetActive(false);
}
if (child.name == "FrozenOrbVFX")
{
child.gameObject.SetActive(true);
}
}
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.addBaseDamage(DamageType.COLD, holder.getBaseDamage(DamageType.FIRE));
holder.addBaseDamage(DamageType.FIRE, -holder.getBaseDamage(DamageType.FIRE));
}
foreach (CreateOnDeath cod in abilityObject.GetComponents <CreateOnDeath>())
{
cod.objectsToCreateOnDeath.Clear();
//cod.objectsToCreateOnDeath.Add(new CreateOnDeath.GameObjectHolder(PrefabList.getPrefab("QuickIceCircleVFX")));
}
}
ShrapnelMutator shrapMut = abilityObject.AddComponent <ShrapnelMutator>();
shrapMut.increasedDamage = increasedShrapnelDamage;
shrapMut.increasedSpeed = increasedShrapnelSpeed;
shrapMut.increasedStunChance = increasedShrapnelStunChance;
shrapMut.convertToCold = convertToCold;
shrapMut.pierces = shrapnelPierces;
shrapMut.chillChance = chillChance;
shrapMut.moreDamageInstances = moreDamageInstances;
shrapMut.moreDamageAgainstChilled = moreShrapnelDamageAgainstChilled;
shrapMut.addedProjectiles = addedShrapnelProjectiles;
if (chillChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Chill);
newComponent.chance = chillChance;
}
if (increasedDuration != 0 || baseDurationis2)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
if (dad)
{
if (baseDurationis2)
{
dad.duration = 2f + (1f * increasedDuration);
}
else
{
dad.duration *= (1f + increasedDuration);
}
}
}
if (leavesExplosion)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.fireCircle);
component.offset = new Vector3(0f, -1f, 0f);
FireCircleMutator circleMut = abilityObject.AddComponent <FireCircleMutator>();
circleMut.chillChance = chillChance;
circleMut.convertToCold = convertToCold;
circleMut.igniteChance = explosionIgniteChance;
circleMut.increasedDamage = increasedExplosionDamage;
}
if (delayedExpolosionAtStart)
{
CastAfterDuration component = abilityObject.AddComponent <CastAfterDuration>();
component.ability = AbilityIDList.getAbility(AbilityID.delayedFireCircle);
component.limitCasts = true;
component.remainingCasts = 1;
component.age = 10f;
component.interval = 1f;
component.offset = new Vector3(0f, -1.3f, 0f);
DelayedFireCircleMutator circleMut = abilityObject.AddComponent <DelayedFireCircleMutator>();
circleMut.chillChance = chillChance;
circleMut.convertToCold = convertToCold;
circleMut.igniteChance = explosionIgniteChance;
circleMut.increasedDamage = increasedExplosionDamage;
}
if (leavesExplosiveGround)
{
CastAfterDuration cad = abilityObject.AddComponent <CastAfterDuration>();
if (convertToCold)
{
cad.ability = AbilityIDList.getAbility(AbilityID.shatteringGround);
}
else
{
cad.ability = AbilityIDList.getAbility(AbilityID.explosiveGround);
}
cad.limitCasts = false;
cad.interval = 0.79f / (1f + increasedExplosiveGroundFrequency);
cad.age = 0.6f / (1f + increasedExplosiveGroundFrequency);
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
return(abilityObject);
}
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 (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
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);
}
}
if (timeRotChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.TimeRot);
newComponent.chance = timeRotChance;
}
if (increasesDamageTaken > 0 || increasesDoTDamageTaken > 0)
{
DebuffOnEnemyHit doeh = abilityObject.AddComponent <DebuffOnEnemyHit>();
if (increasesDamageTaken > 0)
{
doeh.addDebuffToList(Tags.Properties.DamageTaken, 0f, -increasesDamageTaken, new List <float>(), new List <float>(), 4f);
}
if (increasesDoTDamageTaken > 0)
{
List <Tags.AbilityTags> tagList = new List <Tags.AbilityTags>();
tagList.Add(Tags.AbilityTags.DoT);
doeh.addDebuffToList(Tags.Properties.DamageTaken, 0f, -increasesDoTDamageTaken, new List <float>(), new List <float>(), 4f, tagList);
}
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (addedCritChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critChance += addedCritChance;
}
}
if (addedCritMultiplier != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.critMultiplier += addedCritMultiplier;
}
}
if (leaveDelayed)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.delayedShieldRushEnd);
DelayedShieldRushEndMutator mutator = abilityObject.AddComponent <DelayedShieldRushEndMutator>();
mutator.increasedDamage = increasedDamage + delayIncreasedDamage;
mutator.increasedRadius = increasedRadius + delayIncreasedRadius;
mutator.timeRotChance = timeRotChance + delayTimeRotChance;
mutator.increasesDamageTaken = increasesDamageTaken + delayIncreasesDamageTaken;
mutator.increasesDoTDamageTaken = increasesDoTDamageTaken + delayIncreasesDoTDamageTaken;
mutator.increasedStunChance = increasedStunChance + delayIncreasedStunChance;
mutator.addedCritMultiplier = addedCritMultiplier + delayAddedCritMultiplier;
mutator.addedCritChance = addedCritChance + delayAddedCritChance;
mutator.leaveDelayed = false;
mutator.increasedDelayLength = increasedDelayLength;
mutator.addedVoidDamage = addedVoidDamage;
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// DoT on cast buff
if (statBuffs)
{
statBuffs.addBuff(4f, Tags.Properties.Damage, 0, increasedDotDamageOnCast, null, null, dotTag, "sacrifice dot on cast bug");
}
if (boneNovaChance > 0 && (!mana || mana.currentMana > 0) && (boneNovaChance >= 1 || boneNovaChance > (Random.Range(0f, 1f))))
{
// nova trigger
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.boneNova);
component.failsIfFailedAbility = true;
component.offset = boneNovaOffset;
// nova mutator
BoneNovaMutator mutator = abilityObject.AddComponent <BoneNovaMutator>();
mutator.increasedSpeed = nova_increasedSpeed;
mutator.pierces = nova_pierces;
mutator.increasedDamage = nova_increasedDamage;
mutator.increasedStunChance = nova_increasedStunChance;
mutator.bleedChance = nova_bleedChance;
mutator.addedCritChance = nova_addedCritChance;
mutator.addedCritMultiplier = nova_addedCritMultiplier;
mutator.cone = false;
mutator.dontAttach = true;
mutator.dontMoveToTarget = true;
mutator.randomAngles = false;
mutator.noVFX = true;
mutator.moreDamageAgainstBleeding = nova_moreDamageAgainstBleeding;
}
if (bloodWraithChance > 0 && (bloodWraithChance >= 1 || bloodWraithChance > Random.Range(0f, 1f)))
{
// wraith trigger
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.summonBloodWraith);
component.failsIfFailedAbility = true;
// wraith mutator
BloodWraithMutator mutator = abilityObject.AddComponent <BloodWraithMutator>();
mutator.statList.AddRange(bloodWraithStats);
mutator.increasedSize = increasedBloodWraithSize;
}
if (moreDamageAgainstBleeding != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Bleed;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstBleeding);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
// increase radius
float totalIncreasedArea = increasedArea;
if (increasedArea != 0 || increasedAreaWith3OrMoreMinions != 0)
{
// calculate total increased area
if (increasedAreaWith3OrMoreMinions != 0 && tracker && tracker.summons != null && tracker.summons.Count >= 3)
{
totalIncreasedArea += increasedAreaWith3OrMoreMinions;
}
// calculate increased radius
float increasedRadius = Mathf.Sqrt(totalIncreasedArea + 1) - 1;;
// apply increased radius
if (increasedRadius != 0)
{
foreach (CreateOnDeath cod in abilityObject.GetComponents <CreateOnDeath>())
{
cod.increasedRadius = increasedRadius;
cod.increasedHeight = increasedRadius;
}
foreach (SphereCollider col in abilityObject.GetComponents <SphereCollider>())
{
col.radius *= (1 + increasedRadius);
}
foreach (CapsuleCollider col in abilityObject.GetComponents <CapsuleCollider>())
{
col.radius *= (1 + increasedRadius);
col.height *= (1 + increasedRadius);
}
}
}
if (chanceToIgnite > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite);
newComponent.chance = chanceToIgnite;
}
if (addedFireDamage > 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.addBaseDamage(DamageType.FIRE, addedFireDamage);
}
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
// increase damage based on the number of minions
float realIncreasedDamage = increasedDamage;
if (increasedDamagePerMinion != 0)
{
if (tracker && tracker.summons != null)
{
realIncreasedDamage += increasedDamagePerMinion * tracker.summons.Count;
}
}
// increased damage if the minion has more health
if (increasedDamageIfDetonatedMinionHasMoreHealth != 0 && tracker)
{
// get the likely target
Summoned targetMinion = tracker.getNearestMinion(targetLocation);
if (targetMinion)
{
// check if it has more health
BaseHealth minionHealth = targetMinion.getBaseHealth();
if (minionHealth && baseStats && baseStats.myHealth && minionHealth.currentHealth > baseStats.myHealth.currentHealth)
{
realIncreasedDamage += increasedDamageIfDetonatedMinionHasMoreHealth;
}
}
}
// more damage if you only have one minion
if (increasedDamageWithOneMinion != 0)
{
if (tracker && tracker.numberOfMinions() == 1)
{
realIncreasedDamage += increasedDamageWithOneMinion;
}
}
// increase damage
if (realIncreasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(realIncreasedDamage);
}
}
// chaining (mutator needs to be updated)
if (chainsBetweenMinions)
{
CreateAbilityObjectOnNewAllyHit component = abilityObject.AddComponent <CreateAbilityObjectOnNewAllyHit>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.sacrifice);
component.onlyHitCreatorMinions = true;
component.aimTowardsHit = true;
SacrificeMutator mutator = abilityObject.AddComponent <SacrificeMutator>();
mutator.nova_increasedSpeed = nova_increasedSpeed;
mutator.nova_pierces = nova_pierces;
mutator.nova_increasedDamage = nova_increasedDamage;
mutator.nova_increasedStunChance = nova_increasedStunChance;
mutator.nova_bleedChance = nova_bleedChance;
mutator.nova_addedCritChance = nova_addedCritChance;
mutator.nova_addedCritMultiplier = nova_addedCritMultiplier;
mutator.nova_moreDamageAgainstBleeding = nova_moreDamageAgainstBleeding;
mutator.boneNovaChance = boneNovaChance;
mutator.moreDamageAgainstBleeding = moreDamageAgainstBleeding;
mutator.increasedStunChance = increasedStunChance;
mutator.chanceToIgnite = chanceToIgnite;
mutator.addedFireDamage = addedFireDamage;
mutator.bloodWraithChance = bloodWraithChance;
mutator.bloodWraithStats = new List <TaggedStatsHolder.TaggableStat>();
mutator.bloodWraithStats.AddRange(bloodWraithStats);
mutator.increasedBloodWraithSize = increasedBloodWraithSize;
mutator.chainsBetweenMinions = true;
// snap shot the damage increase and area increase
mutator.increasedDamage = realIncreasedDamage;
mutator.increasedArea = totalIncreasedArea;
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
float newAddedVoidDamage = addedVoidDamage;
if (addedVoidReducedByAttackSpeed != 0)
{
float voidDamageToAdd = addedVoidReducedByAttackSpeed;
if (baseStats)
{
List <Tags.AbilityTags> tagList = new List <Tags.AbilityTags>();
tagList.Add(Tags.AbilityTags.Melee);
float increasedAttackSpeed = baseStats.GetStatValue(Tags.Properties.AttackSpeed, tagList) - 1;
voidDamageToAdd *= (1 - increasedAttackSpeed);
}
if (voidDamageToAdd > 0)
{
newAddedVoidDamage += voidDamageToAdd;
}
}
ShieldRushEndMutator mutator = abilityObject.AddComponent <ShieldRushEndMutator>();
mutator.increasedDamage = increasedDamage;
mutator.increasedRadius = increasedRadius;
mutator.timeRotChance = timeRotChance;
mutator.increasesDamageTaken = increasesDamageTaken;
mutator.increasesDoTDamageTaken = increasesDoTDamageTaken;
mutator.increasedStunChance = increasedStunChance;
mutator.addedCritMultiplier = addedCritMultiplier;
mutator.addedCritChance = addedCritChance;
mutator.leaveDelayed = leaveDelayed;
mutator.increasedDelayLength = increasedDelayLength;
mutator.delayIncreasedDamage = delayIncreasedDamage;
mutator.delayIncreasedRadius = delayIncreasedRadius;
mutator.delayTimeRotChance = delayTimeRotChance;
mutator.delayIncreasesDamageTaken = delayIncreasesDamageTaken;
mutator.delayIncreasesDoTDamageTaken = delayIncreasesDoTDamageTaken;
mutator.delayIncreasedStunChance = delayIncreasedStunChance;
mutator.delayAddedCritMultiplier = delayAddedCritMultiplier;
mutator.delayAddedCritChance = delayAddedCritChance;
mutator.addedVoidDamage = newAddedVoidDamage + additionalAoEAddedVoidDamage;
if (newAddedVoidDamage > 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.addBaseDamage(DamageType.VOID, addedVoidDamage);
}
}
if (moreTravelDamageAgainstFullHealth != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
conditionalEffect.conditional = new FullHealthConditional();
conditionalEffect.effect = new DamageEffectMoreDamage(moreTravelDamageAgainstFullHealth);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (forwardVoidBeam)
{
CreateAbilityObjectOnStart component = abilityObject.AddComponent <CreateAbilityObjectOnStart>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.forwardVoidBeam);
component.aimingMethod = CreateAbilityObjectOnStart.AimingMethod.TargetDirection;
component.createAtStartLocation = true;
}
if (backwardsVoidBeam)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.backwardsVoidBeam);
component.aimingMethod = CreateAbilityObjectOnDeath.AimingMethod.TravelDirection;
}
if (returnToStart)
{
ReturnCasterToOlderPosition component = abilityObject.AddComponent <ReturnCasterToOlderPosition>();
component.increasePositionAgeWithAge = true;
component.positionAge = 0f;
component.restoreMana = restoreMana;
component.additionalAgeForManaRestoration = 0.35f;
component.whenToMoveCaster = ReturnCasterToOlderPosition.StartOrEnd.End;
}
if (percentCurrentHealthLostOnCast != 0 && health)
{
health.HealthDamage(health.currentHealth * percentCurrentHealthLostOnCast);
}
if (increasedTravelDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedTravelDamage);
}
}
if (increasedTravelStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (statsWhileTravelling != null && statsWhileTravelling.Count > 0)
{
BuffParent bp = abilityObject.GetComponent <BuffParent>();
if (!bp)
{
bp = abilityObject.AddComponent <BuffParent>();
}
List <TaggedStatsHolder.TaggableStat> stats = new List <TaggedStatsHolder.TaggableStat>();
foreach (TaggedStatsHolder.TaggableStat stat in statsWhileTravelling)
{
TaggedStatsHolder.TaggableStat newStat = new TaggedStatsHolder.TaggableStat(stat);
stats.Add(newStat);
}
bp.taggedStats.AddRange(stats);
}
if (increasedRadius > 0)
{
foreach (CreateOnDeath cod in abilityObject.GetComponents <CreateOnDeath>())
{
cod.increasedRadius = increasedRadius;
cod.increasedHeight = increasedRadius;
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
VoidRiftMutator voidRiftMutator = Comp <VoidRiftMutator> .GetOrAdd(abilityObject);
voidRiftMutator.increasedDamage = voidRift_increasedDamage;
voidRiftMutator.increasedRadius = voidRift_increasedRadius;
voidRiftMutator.timeRotChance = voidRift_timeRotChance;
voidRiftMutator.increasesDamageTaken = voidRift_increasesDamageTaken;
voidRiftMutator.increasesDoTDamageTaken = voidRift_increasesDoTDamageTaken;
voidRiftMutator.increasedStunChance = voidRift_increasedStunChance;
voidRiftMutator.moreDamageAgainstStunned = voidRift_moreDamageAgainstStunned;
voidRiftMutator.igniteChance = voidRift_igniteChance;
voidRiftMutator.moreDamageAgainstIgnited = voidRift_damageAgainstIgnited;
voidRiftMutator.moreDamageAgainstTimeRotting = voidRift_damageAgainstTimeRotting;
if (voidRift_noGrowth)
{
voidRiftMutator.areaGainOnNearbyDeath = 0f;
voidRiftMutator.damageGainOnNearbyDeath = 0f;
}
else
{
voidRiftMutator.areaGainOnNearbyDeath *= (1 + voidRift_increasedAreaGrowth);
voidRiftMutator.damageGainOnNearbyDeath *= (1 + voidRift_increasedDamageGrowth);
}
if (dealsDamage)
{
SphereCollider col = abilityObject.AddComponent <SphereCollider>();
col.radius = 0.3f;
col.isTrigger = true;
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (movementSpeedOnCast != 0)
{
TaggedStatsHolder.Stat stat = new TaggedStatsHolder.Stat(Tags.Properties.Movespeed);
stat.increasedValue = movementSpeedOnCast;
Buff buff = new Buff(stat, 4f);
statBuffs.addBuff(buff);
}
if (orbitsCaster)
{
SpiralMovement movement = abilityObject.AddComponent <SpiralMovement>();
movement.outwardDistance = 2f + increasedOrbitDistance;
movement.angleChangedPerSecond = 180f;
movement.constantVelocity = SpiralMovement.ConstantType.AngularVelocity;
movement.centreOnCaster = true;
movement.offsetFromTransform = new Vector3(0, 1, 0);
movement.outwardSpeed = 0f;
movement.randomStartAngle = true;
}
if (castsAbyssalOrb)
{
CastAtRandomPointAfterDuration component = abilityObject.AddComponent <CastAtRandomPointAfterDuration>();
component.ability = Ability.getAbility(AbilityID.abyssalOrb);
component.radius = 5f;
component.limitCasts = false;
component.duration = 3f / (1f + increasedAbyssalOrbFrequency);
}
if (voidEruptionOnDeath)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.voidEruption);
component.aimingMethod = CreateAbilityObjectOnDeath.AimingMethod.Random;
}
if (increasedDuration != 0)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
if (dad)
{
dad.duration *= (1 + increasedDuration);
}
}
return(abilityObject);
}
