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)
{
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)
{
// 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)
{
// 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)
{
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)
{
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)
{
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 (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)
{
// 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)
{
// 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);
}
