public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
if (additionalDuration > 0)
{
DestroyAfterDuration durationObject = abilityObject.GetComponent <DestroyAfterDuration>();
if (durationObject != null)
{
durationObject.duration += additionalDuration;
}
}
// increase the strength of the pull
if (pullMultiplier != 1)
{
RepeatedlyPullEnemiesWithinRadius pull = abilityObject.GetComponent <RepeatedlyPullEnemiesWithinRadius>();
if (pull)
{
pull.distanceMultiplier = 1 - (1 - pull.distanceMultiplier) * pullMultiplier;
}
}
if (increasedBasePhysicalDamage > 0)
{
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.addBaseDamage(DamageType.PHYSICAL, damage.getBaseDamage(DamageType.PHYSICAL) * increasedBasePhysicalDamage);
}
}
if (fireTornado)
{
// change the vfx
foreach (Transform t in abilityObject.transform)
{
if (t.name == "TornadoVFX")
{
t.gameObject.SetActive(false);
}
if (t.name == "Tornado_Fire")
{
t.gameObject.SetActive(true);
}
}
// change the damage to fire
foreach (DamageStatsHolder damage in abilityObject.GetComponents <DamageStatsHolder>())
{
damage.addBaseDamage(DamageType.FIRE, damage.getBaseDamage(DamageType.PHYSICAL));
damage.addBaseDamage(DamageType.PHYSICAL, -damage.getBaseDamage(DamageType.PHYSICAL));
}
}
if (castsLightning)
{
RepeatedlyCastAtNearestEnemyWithinRadius cast = abilityObject.AddComponent <RepeatedlyCastAtNearestEnemyWithinRadius>();
cast.abilityToCast = AbilityIDList.getAbility(AbilityID.lesserLightning);
cast.castInterval = lightningInterval;
cast.radius = lightningRange;
}
if (stationary)
{
abilityObject.GetComponent <UnityEngine.AI.NavMeshAgent>().speed = 0f;
Destroy(abilityObject.GetComponent <RandomNavmeshMovement>());
}
if (attaches)
{
Destroy(abilityObject.GetComponent <UnityEngine.AI.NavMeshAgent>());
Destroy(abilityObject.GetComponent <RandomNavmeshMovement>());
AttachToCreatorOnCreation component = abilityObject.AddComponent <AttachToCreatorOnCreation>();
component.replaceExistingBuff = false;
component.displacement = new Vector3(0, 1f, 0);
}
if (leavesStormOrbs)
{
CastAtRandomPointAfterDuration cast = abilityObject.AddComponent <CastAtRandomPointAfterDuration>();
cast.ability = Ability.getAbility(AbilityID.delayedStormOrb);
cast.duration = 1f / (1 + increasedStormOrbFrequency);
cast.radius = 0.5f;
cast.limitCasts = false;
}
if (ignitesInAoe)
{
CastAfterDuration cad = abilityObject.AddComponent <CastAfterDuration>();
cad.ability = Ability.getAbility(AbilityID.invisibleIgniteNova);
cad.interval = 1f / (1 + increasedIgniteFrequency);
cad.limitCasts = false;
}
if (movementSpeedOnCast != 0 || manaRegenOnCast != 0 || attackAndCastSpeedOnCast != 0)
{
float buffDuration = 2f * (1 + increasedBuffDuration);
if (movementSpeedOnCast != 0)
{
statBuffs.addBuff(buffDuration, Tags.Properties.Movespeed, 0, movementSpeedOnCast, null, null, null, "tornadoMovementSpeed");
}
if (manaRegenOnCast != 0)
{
statBuffs.addBuff(buffDuration, Tags.Properties.ManaRegen, 0, manaRegenOnCast, null, null, null, "tornadoManaRegen");
}
if (attackAndCastSpeedOnCast != 0)
{
statBuffs.addBuff(buffDuration, Tags.Properties.AttackSpeed, 0, attackAndCastSpeedOnCast, null, null, null, "tornadoAttackSpeed");
statBuffs.addBuff(buffDuration, Tags.Properties.CastSpeed, 0, attackAndCastSpeedOnCast, null, null, null, "tornadoCastSpeed");
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// if this is a meteor shower
if (additionalMeteors > 0)
{
Destroy(abilityObject);
abilityObject = Instantiate(AbilityIDList.getAbility(AbilityID.meteorShower).abilityPrefab);
abilityObject.transform.position = location;
CastAtRandomPointAfterDuration meteorCaster = abilityObject.GetComponent <CastAtRandomPointAfterDuration>();
meteorCaster.duration /= (1 + increasedMeteorFrequency);
meteorCaster.remainingCasts += additionalMeteors;
meteorCaster.radius *= (1 + increasedShowerRadius);
if (line)
{
StartsAtTarget sat = meteorCaster.GetComponent <StartsAtTarget>();
if (sat)
{
sat.active = false;
Destroy(sat);
}
AbilityMover mover = Comp <AbilityMover> .GetOrAdd(abilityObject);
mover.SetDirection(targetLocation - location);
mover.speed = 10 * (1 + increasedShowerRadius);
meteorCaster.radius = 0;
StartsTowardsTarget stt = abilityObject.AddComponent <StartsTowardsTarget>();
stt.distance = 1f;
stt.addWeaponRange = false;
}
// create a mutator on the meteor shower object
MeteorMutator newMutator = abilityObject.AddComponent <MeteorMutator>();
// variables for all damage
newMutator.moreDamageInstances = moreDamageInstances;
// meteor variables (except use all mana)
newMutator.increasedFallSpeed = increasedFallSpeed;
newMutator.increasedCastSpeed = increasedCastSpeed;
newMutator.shrapnelChance = shrapnelChance;
newMutator.increasedShrapnelSpeed = increasedShrapnelSpeed;
newMutator.shrapnelPierces = shrapnelPierces;
newMutator.replaceFireCircle = replaceFireCircle;
// aoe variables
newMutator.moreDamageAgainstFullHealth = moreDamageAgainstFullHealth;
newMutator.increasedShrapnelDamage = increasedShrapnelDamage;
newMutator.increasedStunChance = increasedStunChance;
newMutator.moreDamageInstances = new List <float>();
newMutator.moreDamageInstances.AddRange(moreDamageInstances);
// apply mana variable once for all meteors
if (usesAllMana && myMana)
{
float totalCost = myMana.getManaCost(ability);
totalCost += myMana.currentMana;
float proportion = totalCost / myMana.maxMana;
newMutator.moreDamageInstances.Add(proportion * 2);
myMana.currentMana = 0;
}
return(abilityObject);
}
// if this is a regular meteor
// apply aoe variables
MeteorAoEMutator aoeMutator = abilityObject.AddComponent <MeteorAoEMutator>();
aoeMutator.moreDamageAgainstFullHealth = moreDamageAgainstFullHealth;
aoeMutator.increasedStunChance = increasedStunChance;
aoeMutator.moreDamageInstances = new List <float>();
aoeMutator.moreDamageInstances.AddRange(moreDamageInstances);
// meteor variables
if (increasedFallSpeed != 0)
{
abilityObject.GetComponent <AbilityMover>().speed *= (1 + increasedFallSpeed);
}
MeteorShrapnelMutator shrapnelMutator = null;
if (shrapnelChance > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < shrapnelChance)
{
CreateAbilityObjectOnDeath caood = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
caood.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.meteorShrapnel);
caood.createAtTarget = true;
caood.offset = -caood.GetComponent <LocationDetector>().targetLocationOffset;
shrapnelMutator = abilityObject.AddComponent <MeteorShrapnelMutator>();
shrapnelMutator.increasedDamage = increasedShrapnelDamage;
shrapnelMutator.increasedSpeed = increasedShrapnelSpeed;
shrapnelMutator.pierces = shrapnelPierces;
shrapnelMutator.increasedStunChance = increasedStunChance;
shrapnelMutator.moreDamageInstances = new List <float>();
shrapnelMutator.moreDamageInstances.AddRange(moreDamageInstances);
}
}
if (replaceFireCircle)
{
CreateAtTargetLocationOnCreation component = abilityObject.GetComponent <CreateAtTargetLocationOnCreation>();
if (component)
{
component.objectsToCreate.Clear();
GameObject prefab = PrefabList.getPrefab("EnemyMeteorCircle");
if (prefab)
{
CreateAtTargetLocationOnCreation.GameObjectHolder holder = new CreateAtTargetLocationOnCreation.GameObjectHolder();
holder.gameObject = prefab;
holder.destroyWhenThisDies = true;
component.objectsToCreate.Add((holder));
}
}
}
if (usesAllMana && myMana)
{
float totalCost = myMana.getManaCost(ability);
totalCost += myMana.currentMana;
float proportion = totalCost / myMana.maxMana;
aoeMutator.moreDamageInstances.Add(proportion * 2);
if (shrapnelMutator)
{
shrapnelMutator.moreDamageInstances.Add(proportion * 2);
}
myMana.currentMana = 0;
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
// changing the repeated hit mutator
if (increasedDamage != 0 || addedPoisonDamage != 0 || increasedRadius != 0)
{
EntanglingRootsHitMutator hitMutator = abilityObject.AddComponent <EntanglingRootsHitMutator>();
hitMutator.increasedDamage = increasedDamage;
hitMutator.addedPoisonDamage = addedPoisonDamage;
hitMutator.increasedRadius = increasedRadius;
}
// create the initial hit
CastInLine initialiHitCreator = abilityObject.AddComponent <CastInLine>();
initialiHitCreator.ability = AbilityIDList.getAbility(AbilityID.entanglingRootsInitialHit);
initialiHitCreator.casts = 1;
initialiHitCreator.distancePerCast = 0;
initialiHitCreator.targetPoint = targetLocation;
// changing the initial hit mutator
EntanglingRootsInitialHitMutator initialHitMutator = abilityObject.AddComponent <EntanglingRootsInitialHitMutator>();
initialHitMutator.increasedDamage = initialHitIncreasedDamage;
initialHitMutator.chanceToPoison = initialHitChanceToPoison;
initialHitMutator.increasedRadius = increasedRadius;
initialHitMutator.increasedBuffDuration = increasedBuffDuration;
initialHitMutator.damageBuff = damageBuff;
initialHitMutator.poisonChanceToWolves = poisonChanceToWolves;
initialHitMutator.bleedchanceToBears = bleedchanceToBears;
initialHitMutator.castSpeedToSpriggans = castSpeedToSpriggans;
initialHitMutator.healSpriggans = healSpriggans;
initialHitMutator.meleeScalingInitialHit = meleeScalingInitialHit;
initialHitMutator.alwaysStuns = InitialHitAlwaysStuns;
// creating extra patches
if (addedPatches > 0)
{
// add extra casts
if (patchesInLine)
{
CastInLine component = abilityObject.AddComponent <CastInLine>();
component.ability = AbilityIDList.getAbility(AbilityID.entanglingRoots);
component.casts = addedPatches;
component.distancePerCast = 4;
component.targetPoint = targetLocation;
}
else
{
CastAtRandomPointAfterDuration component = abilityObject.AddComponent <CastAtRandomPointAfterDuration>();
component.ability = AbilityIDList.getAbility(AbilityID.entanglingRoots);
component.duration = 0.01f;
component.limitCasts = true;
component.remainingCasts = addedPatches;
component.radius = 5f;
}
// copy mutator
EntanglingRootsMutator mutator = abilityObject.AddComponent <EntanglingRootsMutator>();
mutator.increasedDamage = increasedDamage;
mutator.addedPoisonDamage = addedPoisonDamage;
mutator.increasedRadius = increasedRadius;
mutator.initialHitIncreasedDamage = initialHitIncreasedDamage;
mutator.initialHitChanceToPoison = initialHitChanceToPoison;
mutator.increasedBuffDuration = increasedBuffDuration;
mutator.damageBuff = damageBuff;
mutator.poisonChanceToWolves = poisonChanceToWolves;
mutator.bleedchanceToBears = bleedchanceToBears;
mutator.castSpeedToSpriggans = castSpeedToSpriggans;
mutator.healSpriggans = healSpriggans;
mutator.meleeScalingInitialHit = meleeScalingInitialHit;
mutator.InitialHitAlwaysStuns = InitialHitAlwaysStuns;
mutator.increasedDuration = increasedDuration;
mutator.healingNovaChance = healingNovaChance;
}
if (increasedDuration != 0)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
if (dad)
{
dad.duration *= (1 + increasedDuration);
}
}
if (increasedRadius != 0)
{
foreach (MagicalFX.FX_Tentacle_ultimate vfx in abilityObject.GetComponentsInChildren <MagicalFX.FX_Tentacle_ultimate>())
{
vfx.SpreadMin *= (1 + increasedRadius);
vfx.SpreadMax *= (1 + increasedRadius);
vfx.SpreadSpawn *= (1 + increasedRadius);
vfx.Number = (int)(((float)vfx.Number) * (1 + increasedRadius));
}
}
if (healingNovaChance > 0)
{
float rand = Random.Range(0f, 1f);
if (rand < healingNovaChance)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = AbilityIDList.getAbility(AbilityID.healingNova);
}
}
return(abilityObject);
}
public override GameObject Mutate(GameObject abilityObject, Vector3 location, Vector3 targetLocation)
{
VoidRiftMutator voidRiftMutator = Comp <VoidRiftMutator> .GetOrAdd(abilityObject);
voidRiftMutator.increasedDamage = voidRift_increasedDamage;
voidRiftMutator.increasedRadius = voidRift_increasedRadius;
voidRiftMutator.timeRotChance = voidRift_timeRotChance;
voidRiftMutator.increasesDamageTaken = voidRift_increasesDamageTaken;
voidRiftMutator.increasesDoTDamageTaken = voidRift_increasesDoTDamageTaken;
voidRiftMutator.increasedStunChance = voidRift_increasedStunChance;
voidRiftMutator.moreDamageAgainstStunned = voidRift_moreDamageAgainstStunned;
voidRiftMutator.igniteChance = voidRift_igniteChance;
voidRiftMutator.moreDamageAgainstIgnited = voidRift_damageAgainstIgnited;
voidRiftMutator.moreDamageAgainstTimeRotting = voidRift_damageAgainstTimeRotting;
if (voidRift_noGrowth)
{
voidRiftMutator.areaGainOnNearbyDeath = 0f;
voidRiftMutator.damageGainOnNearbyDeath = 0f;
}
else
{
voidRiftMutator.areaGainOnNearbyDeath *= (1 + voidRift_increasedAreaGrowth);
voidRiftMutator.damageGainOnNearbyDeath *= (1 + voidRift_increasedDamageGrowth);
}
if (dealsDamage)
{
SphereCollider col = abilityObject.AddComponent <SphereCollider>();
col.radius = 0.3f;
col.isTrigger = true;
}
if (increasedDamage != 0)
{
foreach (DamageStatsHolder holder in abilityObject.GetComponents <DamageStatsHolder>())
{
holder.increaseAllDamage(increasedDamage);
}
}
if (movementSpeedOnCast != 0)
{
TaggedStatsHolder.Stat stat = new TaggedStatsHolder.Stat(Tags.Properties.Movespeed);
stat.increasedValue = movementSpeedOnCast;
Buff buff = new Buff(stat, 4f);
statBuffs.addBuff(buff);
}
if (orbitsCaster)
{
SpiralMovement movement = abilityObject.AddComponent <SpiralMovement>();
movement.outwardDistance = 2f + increasedOrbitDistance;
movement.angleChangedPerSecond = 180f;
movement.constantVelocity = SpiralMovement.ConstantType.AngularVelocity;
movement.centreOnCaster = true;
movement.offsetFromTransform = new Vector3(0, 1, 0);
movement.outwardSpeed = 0f;
movement.randomStartAngle = true;
}
if (castsAbyssalOrb)
{
CastAtRandomPointAfterDuration component = abilityObject.AddComponent <CastAtRandomPointAfterDuration>();
component.ability = Ability.getAbility(AbilityID.abyssalOrb);
component.radius = 5f;
component.limitCasts = false;
component.duration = 3f / (1f + increasedAbyssalOrbFrequency);
}
if (voidEruptionOnDeath)
{
CreateAbilityObjectOnDeath component = abilityObject.AddComponent <CreateAbilityObjectOnDeath>();
component.abilityToInstantiate = Ability.getAbility(AbilityID.voidEruption);
component.aimingMethod = CreateAbilityObjectOnDeath.AimingMethod.Random;
}
if (increasedDuration != 0)
{
DestroyAfterDuration dad = abilityObject.GetComponent <DestroyAfterDuration>();
if (dad)
{
dad.duration *= (1 + increasedDuration);
}
}
return(abilityObject);
}
