public override float mutateUseSpeed(float useSpeed)
{
if (noAttackSpeedScaling)
{
float divider = baseStats.GetStatValue(Tags.Properties.AttackSpeed, ability.useTags);
if (divider > 0)
{
return(base.mutateUseSpeed(useSpeed) / divider);
}
}
return(base.mutateUseSpeed(useSpeed));
}
// Use this for initialization
void Start()
{
abilityObjectConstructor = Comp <AbilityObjectConstructor> .GetOrAdd(gameObject);
// calculate scaling
if (scalingProperty != Tags.Properties.None)
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
BaseStats stats = references.creator.GetComponent <BaseStats>();
if (stats)
{
float scaler = stats.GetStatValue(scalingProperty);
if (scaler != 0)
{
interval /= scaler;
}
}
}
}
// get creator components if necessery
if (castFromCreatorCastPoint || castAtCreatorTargetLocation)
{
CreationReferences references = GetComponent <CreationReferences>();
if (references && references.creator)
{
if (castFromCreatorCastPoint)
{
creatorSizeManager = references.creator.GetComponent <SizeManager>();
}
if (castAtCreatorTargetLocation)
{
creatorUsingAbility = references.creator.GetComponent <UsingAbility>();
}
}
}
}
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)
{
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);
}
