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