public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
RiposteMutator mut = abilityObject.AddComponent <RiposteMutator>();
mut.increasedDuration = increasedDuration;
mut.additionalRetaliations = additionalRetaliations;
mut.darkBladeRetaliationChance = darkBladeRetaliationChance;
mut.statsWhilePrepped = statsWhilePrepped;
if (increasedDamageWhileBelowHalfHealth != 0)
{
if (health && health.currentHealth < health.maxHealth / 2)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamageWhileBelowHalfHealth);
}
}
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (moreDamageAgaintDamaged != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
DamagedConditional conditional = new DamagedConditional();
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgaintDamaged);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
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 (increasedStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
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 (extraProjectiles > 0 && !spiralMovement)
{
foreach (DamageEnemyOnHit component in abilityObject.GetComponents <DamageEnemyOnHit>())
{
component.canDamageSameEnemyAgain = false;
}
}
if (chains > 0)
{
ChainOnHit chain = abilityObject.AddComponent <ChainOnHit>();
chain.chainsRemaining = chains;
chain.abilityToChain = ability;
chain.range = 8f;
chain.destroyAfterChainAttempt = true;
chain.cannotHitSame = true;
chain.offset = new Vector3(0f, 1.2f, 0f);
}
if (chains > 0 || hasChained)
{
// add a copy of this mutator to the ability object, but remove the chains (because it will chain anyway), the increased damage to first enemy hit, and the on cast stuff
HammerThrowMutator newMutator = Comp <HammerThrowMutator> .GetOrAdd(abilityObject);
newMutator.chains = 0;
newMutator.increasedDamage = increasedDamage;
newMutator.extraProjectiles = 0;
newMutator.armourShredChance = 0f;
newMutator.noPierce = noPierce;
newMutator.chanceForDoubleDamage = chanceForDoubleDamage;
newMutator.increasedDamage = increasedDamage;
newMutator.moreDamageAgainstStunned = moreDamageAgainstStunned;
newMutator.spiralMovement = false;
newMutator.aoeVoidDamage = aoeVoidDamage;
newMutator.increasedAoEBaseDamage = increasedAoEBaseDamage;
newMutator.increasedProjectileSpeed = increasedProjectileSpeed;
newMutator.increasedStunChance = increasedStunChance;
newMutator.moreDamage = moreDamage;
newMutator.noReturn = true;
newMutator.canDamageSameEnemyAgain = false;
newMutator.hasChained = true;
}
if (noReturn)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
ReturnToCasterAfterDuration component = abilityObject.GetComponent <ReturnToCasterAfterDuration>();
component.duration = 10000f;
if (spiralMovement)
{
dad.duration = 6f;
}
else
{
dad.duration = 2.5f;
}
if (!hasChained)
{
abilityObject.AddComponent <DestroyOnInanimateCollison>();
ReturnOnInanimateCollision ret = abilityObject.GetComponent <ReturnOnInanimateCollision>();
if (ret)
{
Destroy(ret);
}
}
}
// aoe void damage
if (aoeVoidDamage)
{
foreach (Transform child in abilityObject.GetComponentsInChildren <Transform>(true))
{
if (child.name == "aura")
{
child.gameObject.SetActive(true);
}
}
RepeatedlyDamageEnemiesWithinRadius repeatDamage = abilityObject.GetComponent <RepeatedlyDamageEnemiesWithinRadius>();
if (repeatDamage == null)
{
repeatDamage = abilityObject.AddComponent <RepeatedlyDamageEnemiesWithinRadius>();
}
if (repeatDamage.baseDamageStats.damage == null)
{
repeatDamage.baseDamageStats.damage = new List <DamageStatsHolder.DamageTypesAndValues>();
}
repeatDamage.addBaseDamage(DamageType.VOID, 6f * (1 + increasedAoEBaseDamage));
repeatDamage.damageInterval = 0.5f;
repeatDamage.radius = 1.5f;
repeatDamage.baseDamageStats.addedDamageScaling = 0.2f;
repeatDamage.tags.Add(Tags.AbilityTags.AoE);
repeatDamage.tags.Add(Tags.AbilityTags.Throwing);
repeatDamage.tags.Add(Tags.AbilityTags.DoT);
}
// add extra projectiles
if (extraProjectiles != 0)
{
ExtraProjectiles extraProjectilesObject = abilityObject.GetComponent <ExtraProjectiles>();
if (extraProjectilesObject == null)
{
extraProjectilesObject = abilityObject.AddComponent <ExtraProjectiles>(); extraProjectilesObject.numberOfExtraProjectiles = 0;
}
extraProjectilesObject.numberOfExtraProjectiles += extraProjectiles;
if (projectileNova)
{
extraProjectilesObject.angle = 144f;
if (extraProjectiles >= 6)
{
extraProjectilesObject.angle = 160;
}
}
}
// remove pierce
if (noPierce && chains <= 0 && !hasChained)
{
Pierce pierce = abilityObject.GetComponent <Pierce>();
if (pierce == null)
{
pierce = abilityObject.AddComponent <Pierce>(); pierce.objectsToPierce = 0;
}
if (chains <= 0 && !hasChained)
{
abilityObject.AddComponent <DestroyOnFailingToPierceEnemy>();
}
}
// add chance to shred armour
if (armourShredChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = armourShredChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.ArmourShred);
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (moreDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(moreDamage);
}
}
if (chanceForDoubleDamage > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceForDoubleDamage)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
for (int i = 0; i < holder.baseDamageStats.damage.Count; i++)
{
holder.addBaseDamage(holder.baseDamageStats.damage[i].damageType, holder.getBaseDamage(holder.baseDamageStats.damage[i].damageType));
}
}
}
}
if (moreDamageAgainstStunned != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
StunnedConditional conditional = new StunnedConditional();
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstStunned);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (increasedProjectileSpeed != 0)
{
AbilityMover mover = abilityObject.GetComponent <AbilityMover>();
mover.speed *= (1 + increasedProjectileSpeed);
}
if (spiralMovement)
{
SpiralMovement spira = abilityObject.AddComponent <SpiralMovement>();
spira.constantVelocity = SpiralMovement.ConstantType.BothAreMaxima;
spira.tangentialVelocity = 5.3f * (1 + increasedProjectileSpeed);
spira.angleChangedPerSecond = 157f * (1 + increasedProjectileSpeed);
spira.outwardSpeed = 1.15f;
spira.outwardDistance = 0.6f;
AbilityMover mover = abilityObject.GetComponent <AbilityMover>();
mover.speed = 0;
if (centreOnCaster)
{
spira.centreOnCaster = true;
spira.offsetFromTransform = new Vector3(0f, 1.2f, 0f);
}
if (extraProjectiles > 0)
{
spira.randomStartAngle = true;
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (cone || randomAngles)
{
ExtraProjectiles component = abilityObject.GetComponent <ExtraProjectiles>();
if (randomAngles)
{
component.randomAngles = true;
}
if (cone)
{
component.angle = 38f;
}
}
if (increasedSpeed != 0)
{
AbilityMover component = abilityObject.GetComponent <AbilityMover>();
if (component)
{
component.speed *= 1 + increasedSpeed;
}
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (bleedChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = bleedChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Bleed);
}
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);
}
}
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 == "SharpnelVFX")
{
child.gameObject.SetActive(false);
}
if (child.name == "IceSharpnelVFX")
{
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 (ConstantRotation rot in abilityObject.GetComponents <ConstantRotation>())
{
rot.degreesPerSecond = 0f;
}
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
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);
}
}
if (chillChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Chill);
newComponent.chance = chillChance;
}
if (moreDamageAgainstChilled != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Chill;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstChilled);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (addedProjectiles != 0)
{
ExtraProjectiles component = abilityObject.GetComponent <ExtraProjectiles>();
if (component)
{
component.numberOfExtraProjectiles += addedProjectiles;
}
}
if (pierces)
{
Pierce pierce = abilityObject.GetComponent <Pierce>();
if (pierce == null)
{
pierce = abilityObject.AddComponent <Pierce>(); pierce.objectsToPierce = 0;
}
pierce.objectsToPierce += 10000;
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// choose the nova type
if (canIceNova || canFireNova || canLightningNova)
{
int randMax = 0;
if (canIceNova)
{
randMax++;
}
if (canFireNova)
{
randMax++;
}
if (canLightningNova)
{
randMax++;
}
float rand = Random.Range(0f, randMax);
if (rand < 1f)
{
if (canIceNova)
{
abilityObject = instantiateIceNova(abilityObject, location, targetLocation);
}
else if (canFireNova)
{
abilityObject = instantiateFireNova(abilityObject, location, targetLocation);
}
else
{
abilityObject = instantiateLightningNova(abilityObject, location, targetLocation);
}
}
else if (rand < 2f)
{
if (canFireNova && canIceNova)
{
abilityObject = instantiateFireNova(abilityObject, location, targetLocation);
}
else
{
abilityObject = instantiateLightningNova(abilityObject, location, targetLocation);
}
}
else
{
abilityObject = instantiateLightningNova(abilityObject, location, targetLocation);
}
}
if (chanceForChainingIceNova > 0)
{
float rand2 = Random.Range(0f, 1f);
if (rand2 < chanceForChainingIceNova)
{
CreateAbilityObjectOnNewEnemtHit newComponent = abilityObject.AddComponent <CreateAbilityObjectOnNewEnemtHit>();
newComponent.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.delayerForChainingIceNova);
}
}
if (chillChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Chill);
newComponent.chance = chillChance;
}
if (shockChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Shock);
newComponent.chance = shockChance;
}
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 (canTarget)
{
abilityObject.AddComponent <StartsAtTarget>();
}
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 (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 GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (chains > 0)
{
ChainOnHit chain = abilityObject.AddComponent <ChainOnHit>();
chain.chainsRemaining = chains;
chain.abilityToChain = ability;
chain.range = 8f;
chain.cannotHitSame = true;
chain.destroyAfterSuccessfulChainAttempt = true;
chain.offset = new Vector3(0f, 1.2f, 0f);
}
if (chains > 0 || hasChained)
{
// add a copy of this mutator to the ability object, but remove the chains (because it will chain anyway), the increased damage to first enemy hit, and the on cast stuff
DarkBladeMutator newMutator = abilityObject.AddComponent <DarkBladeMutator>();
newMutator.chains = 0;
newMutator.increasedDamage = increasedDamage;
newMutator.armourShredChance = 0f;
newMutator.noPierce = noPierce;
newMutator.chanceForDoubleDamage = chanceForDoubleDamage;
newMutator.increasedDamage = increasedDamage;
newMutator.moreDamageAgainstStunned = moreDamageAgainstStunned;
newMutator.increasedProjectileSpeed = increasedProjectileSpeed;
newMutator.increasedStunChance = increasedStunChance;
newMutator.hasChained = true;
}
// remove pierce
if (noPierce && chains <= 0 && !hasChained)
{
Pierce pierce = abilityObject.GetComponent <Pierce>();
if (pierce == null)
{
pierce = abilityObject.AddComponent <Pierce>(); pierce.objectsToPierce = 0;
}
if (chains <= 0 && !hasChained)
{
abilityObject.AddComponent <DestroyOnFailingToPierceEnemy>();
}
}
// add chance to shred armour
if (armourShredChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = armourShredChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.ArmourShred);
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (chanceForDoubleDamage > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceForDoubleDamage)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
for (int i = 0; i < holder.baseDamageStats.damage.Count; i++)
{
holder.addBaseDamage(holder.baseDamageStats.damage[i].damageType, holder.getBaseDamage(holder.baseDamageStats.damage[i].damageType));
}
}
}
}
if (moreDamageAgainstStunned != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
StunnedConditional conditional = new StunnedConditional();
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstStunned);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (increasedProjectileSpeed != 0)
{
AbilityMover mover = abilityObject.GetComponent <AbilityMover>();
mover.speed *= (1 + increasedProjectileSpeed);
}
return(abilityObject);
}
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)
{
// return a channelled fireball object if this is channelled
if (channelled)
{
Destroy(abilityObject);
abilityObject = Instantiate(Ability.getAbility(AbilityID.channelledFireball).abilityPrefab, location, Quaternion.Euler(targetLocation - location));
// change the mutator on the new abilityObject
FireballMutator mut = Comp <FireballMutator> .GetOrAdd(abilityObject);
mut.extraProjectiles = extraProjectiles;
mut.addExplosion = addExplosion;
mut.chanceToCreateExplosionOnHit = chanceToCreateExplosionOnHit;
mut.igniteChance = igniteChance;
mut.targetsToPierce = targetsToPierce;
mut.reduceBaseDamageBy80Percent = reduceBaseDamageBy80Percent;
mut.increasedCastSpeed = increasedCastSpeed;
mut.chanceForDoubleDamage = chanceForDoubleDamage;
mut.fireAddedAsLightning = fireAddedAsLightning;
mut.increasedDamage = increasedDamage;
mut.moreDamageAgainstIgnited = moreDamageAgainstIgnited;
mut.moreDamageAgainstChilled = moreDamageAgainstChilled;
mut.homing = homing;
mut.freeWhenOutOfMana = freeWhenOutOfMana;
mut.alwaysFree = alwaysFree;
mut.increasedSpeed = increasedSpeed;
mut.increasedDuration = increasedDuration;
mut.inaccuracy = inaccuracy;
// some are always false
mut.channelled = false;
mut.fireInSequence = false;
// this will be the channelled fireball object
mut.channelledFireballObject = true;
// return the new ability object and do not change it further
return(abilityObject);
}
// disable shared hit detector for channelling
if (channelledFireballObject)
{
foreach (HitDetector detector in abilityObject.GetComponents <HitDetector>())
{
detector.cannotHaveSharedhitDetector = true;
}
}
// add an explosion
if (addExplosion)
{
abilityObject.AddComponent <CreateAbilityObjectOnDeath>().abilityToInstantiate = AbilityIDList.getAbility(AbilityID.fireballAoe);
}
// increase speed
if (increasedSpeed != 0)
{
abilityObject.GetComponent <AbilityMover>().speed *= (1 + increasedSpeed);
}
// increase duration
if (increasedDuration != 0)
{
abilityObject.GetComponent <DestroyAfterDuration>().duration *= (1 + increasedDuration);
}
// slightly randomise target location
if (inaccuracy)
{
targetLocation += new Vector3(Random.Range(-1f, 1f), 0, Random.Range(-1f, 1f)) * 0.25f * Vector3.Distance(location, targetLocation);
}
// add extra projectiles
if (extraProjectiles != 0 && !fireInSequence)
{
ExtraProjectiles extraProjectilesObject = abilityObject.GetComponent <ExtraProjectiles>();
if (extraProjectilesObject == null)
{
extraProjectilesObject = abilityObject.AddComponent <ExtraProjectiles>(); extraProjectilesObject.numberOfExtraProjectiles = 0;
}
extraProjectilesObject.numberOfExtraProjectiles += extraProjectiles;
}
// add pierce change
if (targetsToPierce > 0)
{
Pierce pierce = abilityObject.GetComponent <Pierce>();
if (pierce == null)
{
pierce = abilityObject.AddComponent <Pierce>(); pierce.objectsToPierce = 0;
}
pierce.objectsToPierce += targetsToPierce;
}
// add chance to create explosion on hit
if (chanceToCreateExplosionOnHit > 0)
{
ChanceToCreateAbilityObjectOnNewEnemyHit ctcaooneh = abilityObject.AddComponent <ChanceToCreateAbilityObjectOnNewEnemyHit>();
ctcaooneh.chance = chanceToCreateExplosionOnHit;
ctcaooneh.spawnAtHit = true;
ctcaooneh.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.fireballAoe);
}
// add chance to ignite
if (igniteChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = igniteChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite);
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
//holder.addBaseDamage(DamageType.FIRE, holder.getBaseDamage(DamageType.FIRE) * increasedDamage);
}
}
// reduce hit damage
if (reduceBaseDamageBy80Percent)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
for (int i = 0; i < holder.baseDamageStats.damage.Count; i++)
{
holder.baseDamageStats.damage[i] = new DamageStatsHolder.DamageTypesAndValues(holder.baseDamageStats.damage[i].damageType, holder.baseDamageStats.damage[i].value * 0.2f);
}
}
}
if (chanceForDoubleDamage > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceForDoubleDamage)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
for (int i = 0; i < holder.baseDamageStats.damage.Count; i++)
{
holder.addBaseDamage(holder.baseDamageStats.damage[i].damageType, holder.getBaseDamage(holder.baseDamageStats.damage[i].damageType));
}
}
}
}
if (fireAddedAsLightning > 0)
{
abilityObject.GetComponentInChildren <DisableOnStart>().active = false;
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.addBaseDamage(DamageType.LIGHTNING, holder.getBaseDamage(DamageType.FIRE) * fireAddedAsLightning);
}
}
if (moreDamageAgainstIgnited != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Ignite;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstIgnited);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (moreDamageAgainstChilled != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Chill;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstChilled);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (homing)
{
abilityObject.AddComponent <HomingMovement>();
}
return(abilityObject);
}
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);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
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 (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 (bleedChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Bleed);
newComponent.chance = bleedChance;
}
if (increasedStunChance != 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.increasedStunChance += increasedStunChance;
}
}
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);
}
}
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 (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 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;
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;
cod.increasedHeight = 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 (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 (moreDamageAgainstFullHealth != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
FullHealthConditional conditional = new FullHealthConditional();
conditionalEffect.conditional = conditional;
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 (moreDamageAgainstDamaged != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
DamagedConditional conditional = new DamagedConditional();
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstDamaged);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (cullPercent > 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.baseDamageStats.cullPercent += cullPercent;
}
}
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)
{
// add an explosion
if (addExplosion)
{
abilityObject.AddComponent <CreateAbilityObjectOnDeath>().abilityToInstantiate = AbilityIDList.getAbility(AbilityID.fireballAoe);
}
// add extra projectiles
if (extraProjectiles != 0 && !fireInSequence)
{
ExtraProjectiles extraProjectilesObject = abilityObject.GetComponent <ExtraProjectiles>();
if (extraProjectilesObject == null)
{
extraProjectilesObject = abilityObject.AddComponent <ExtraProjectiles>(); extraProjectilesObject.numberOfExtraProjectiles = 0;
}
extraProjectilesObject.numberOfExtraProjectiles += extraProjectiles;
}
// add pierce change
if (targetsToPierce > 0)
{
Pierce pierce = abilityObject.GetComponent <Pierce>();
if (pierce == null)
{
pierce = abilityObject.AddComponent <Pierce>(); pierce.objectsToPierce = 0;
}
pierce.objectsToPierce += targetsToPierce;
}
// add chance to create explosion on hit
if (chanceToCreateExplosionOnHit > 0)
{
ChanceToCreateAbilityObjectOnNewEnemyHit ctcaooneh = abilityObject.AddComponent <ChanceToCreateAbilityObjectOnNewEnemyHit>();
ctcaooneh.chance = chanceToCreateExplosionOnHit;
ctcaooneh.spawnAtHit = true;
ctcaooneh.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.fireballAoe);
}
// add chance to ignite
if (igniteChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = igniteChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite);
}
if (additionalIgnite)
{
ApplyStatusOnEnemyHit component = abilityObject.AddComponent <ApplyStatusOnEnemyHit>();
component.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite);
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
//holder.addBaseDamage(DamageType.FIRE, holder.getBaseDamage(DamageType.FIRE) * increasedDamage);
}
}
// reduce hit damage
if (reduceBaseDamageBy80Percent)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
for (int i = 0; i < holder.baseDamageStats.damage.Count; i++)
{
holder.baseDamageStats.damage[i] = new DamageStatsHolder.DamageTypesAndValues(holder.baseDamageStats.damage[i].damageType, holder.baseDamageStats.damage[i].value * 0.2f);
}
}
}
if (chanceForDoubleDamage > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceForDoubleDamage)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
for (int i = 0; i < holder.baseDamageStats.damage.Count; i++)
{
holder.addBaseDamage(holder.baseDamageStats.damage[i].damageType, holder.getBaseDamage(holder.baseDamageStats.damage[i].damageType));
}
}
}
}
if (moreDamageAgainstPoisoned != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Poison;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstPoisoned);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
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 (homing)
{
abilityObject.AddComponent <HomingMovement>();
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
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 (igniteChance > 0)
{
ChanceToApplyStatusOnEnemyHit newComponent = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
newComponent.statusEffect = StatusEffectList.getEffect(StatusEffectID.Ignite);
newComponent.chance = igniteChance;
}
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 (moreDamageAgainstStunned != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
StunnedConditional conditional = new StunnedConditional();
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstStunned);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
if (moreDamageAgainstIgnited != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Ignite;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstIgnited);
// 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);
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// add chance to create ice vortex
if (chanceToCreateIceVortex > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < chanceToCreateIceVortex)
{
float rand2 = Random.Range(0f, 1f);
if (rand2 < chanceForSuperIceVortex)
{
abilityObject.AddComponent <CreateAbilityObjectOnDeath>().abilityToInstantiate = AbilityIDList.getAbility(AbilityID.superIceVortex);
}
else
{
abilityObject.AddComponent <CreateAbilityObjectOnDeath>().abilityToInstantiate = AbilityIDList.getAbility(AbilityID.iceVortex);
}
}
}
// add chance to chill
if (chillChance > 0)
{
ChanceToApplyStatusOnEnemyHit chanceTo = abilityObject.AddComponent <ChanceToApplyStatusOnEnemyHit>();
chanceTo.chance = chillChance;
chanceTo.statusEffect = StatusEffectList.getEffect(StatusEffectID.Chill);
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
//holder.addBaseDamage(DamageType.FIRE, holder.getBaseDamage(DamageType.FIRE) * increasedDamage);
}
}
if (moreDamageAgainstChilled != 0)
{
// create the conditional
DamageConditionalEffect conditionalEffect = new DamageConditionalEffect();
HasStatusEffectConditional conditional = new HasStatusEffectConditional();
conditional.statusEffect = StatusEffectID.Chill;
conditionalEffect.conditional = conditional;
conditionalEffect.effect = new DamageEffectMoreDamage(moreDamageAgainstChilled);
// add the conditional to all damage stats holders
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.baseDamageStats.conditionalEffects.Add(conditionalEffect);
}
}
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;
}
}
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);
}
