internal void Amplifier(IHasDamageAmplify amplify, bool added)
{
if (added)
{
this.amplifiers.Add(amplify);
}
else
{
this.amplifiers.Remove(amplify);
}
}
// Token: 0x060003B6 RID: 950 RVA: 0x0001D02C File Offset: 0x0001B22C
private void CheckModifier(uint senderHandle, Modifier modifier, bool added)
{
string name = modifier.Name;
Unit9 unitFast = EntityManager9.GetUnitFast(senderHandle);
if (unitFast == null)
{
return;
}
Action <Unit9, bool> action;
if (this.specialModifiers.TryGetValue(name, out action))
{
action(unitFast, added);
}
IHasRangeIncrease range = this.rangeFactory.GetRange(name);
if (range != null)
{
unitFast.Range(range, added);
return;
}
if (modifier.IsHidden)
{
return;
}
IAppliesImmobility disable = this.damageFactory.GetDisable(name);
if (disable != null)
{
IDisable disable2;
bool invulnerability = (disable2 = (disable as IDisable)) != null && (disable2.AppliesUnitState & UnitState.Invulnerable) > (UnitState)0UL;
unitFast.Disabler(modifier, added, invulnerability);
return;
}
if (modifier.IsStunDebuff)
{
unitFast.Disabler(modifier, added, false);
return;
}
IHasDamageAmplify amplifier = this.damageFactory.GetAmplifier(name);
if (amplifier != null)
{
unitFast.Amplifier(amplifier, added);
return;
}
IHasPassiveDamageIncrease passive = this.damageFactory.GetPassive(name);
if (passive != null)
{
unitFast.Passive(passive, added);
return;
}
IHasDamageBlock blocker = this.damageFactory.GetBlocker(name);
if (blocker != null)
{
unitFast.Blocker(blocker, added);
return;
}
}
public static bool IsPureDamageAmplifier(this IHasDamageAmplify amplifier)
{
return((amplifier.AmplifierDamageType & DamageType.Pure) != 0);
}
// Token: 0x0600048C RID: 1164 RVA: 0x0001F188 File Offset: 0x0001D388
private void OnAbilityRemoved(Ability9 ability)
{
IHasDamageAmplify amplifier;
if ((amplifier = (ability as IHasDamageAmplify)) != null)
{
if (amplifier.IsAmplifierPermanent)
{
ability.Owner.Amplifier(amplifier, false);
return;
}
if (amplifier.IsAmplifierAddedToStats)
{
return;
}
foreach (Unit9 unit in EntityManager9.Units)
{
unit.Amplifier(amplifier, false);
}
IHasDamageAmplify hasDamageAmplify = EntityManager9.Abilities.OfType <IHasDamageAmplify>().FirstOrDefault((IHasDamageAmplify x) => x.AmplifierModifierName == amplifier.AmplifierModifierName);
if (hasDamageAmplify != null)
{
this.amplifiers[hasDamageAmplify.AmplifierModifierName] = hasDamageAmplify;
IEnumerable <Unit9> units = EntityManager9.Units;
Func <Unit9, bool> < > 9__1;
Func <Unit9, bool> predicate;
if ((predicate = < > 9__1) == null)
{
predicate = (< > 9__1 = ((Unit9 x) => x.HasModifier(amplifier.AmplifierModifierName)));
}
using (IEnumerator <Unit9> enumerator = units.Where(predicate).GetEnumerator())
{
while (enumerator.MoveNext())
{
Unit9 unit2 = enumerator.Current;
unit2.Amplifier(hasDamageAmplify, true);
}
goto IL_117;
}
}
this.amplifiers.Remove(amplifier.AmplifierModifierName);
}
IL_117:
IHasPassiveDamageIncrease passive;
if ((passive = (ability as IHasPassiveDamageIncrease)) != null)
{
if (passive.IsPassiveDamagePermanent)
{
ability.Owner.Passive(passive, false);
return;
}
foreach (Unit9 unit3 in EntityManager9.Units)
{
unit3.Passive(passive, false);
}
IHasPassiveDamageIncrease hasPassiveDamageIncrease = EntityManager9.Abilities.OfType <IHasPassiveDamageIncrease>().FirstOrDefault((IHasPassiveDamageIncrease x) => x.PassiveDamageModifierName == passive.PassiveDamageModifierName);
if (hasPassiveDamageIncrease != null)
{
this.passives[hasPassiveDamageIncrease.PassiveDamageModifierName] = hasPassiveDamageIncrease;
IEnumerable <Unit9> units2 = EntityManager9.Units;
Func <Unit9, bool> < > 9__3;
Func <Unit9, bool> predicate2;
if ((predicate2 = < > 9__3) == null)
{
predicate2 = (< > 9__3 = ((Unit9 x) => x.HasModifier(passive.PassiveDamageModifierName)));
}
using (IEnumerator <Unit9> enumerator = units2.Where(predicate2).GetEnumerator())
{
while (enumerator.MoveNext())
{
Unit9 unit4 = enumerator.Current;
unit4.Passive(hasPassiveDamageIncrease, true);
}
goto IL_221;
}
}
this.passives.Remove(passive.PassiveDamageModifierName);
}
IL_221:
IHasDamageBlock block;
if ((block = (ability as IHasDamageBlock)) != null)
{
if (block.IsDamageBlockPermanent)
{
ability.Owner.Blocker(block, false);
return;
}
foreach (Unit9 unit5 in EntityManager9.Units)
{
unit5.Blocker(block, false);
}
IHasDamageBlock hasDamageBlock = EntityManager9.Abilities.OfType <IHasDamageBlock>().FirstOrDefault((IHasDamageBlock x) => x.BlockModifierName == block.BlockModifierName);
if (hasDamageBlock != null)
{
this.blockers[hasDamageBlock.BlockModifierName] = hasDamageBlock;
IEnumerable <Unit9> units3 = EntityManager9.Units;
Func <Unit9, bool> < > 9__5;
Func <Unit9, bool> predicate3;
if ((predicate3 = < > 9__5) == null)
{
predicate3 = (< > 9__5 = ((Unit9 x) => x.HasModifier(block.BlockModifierName)));
}
using (IEnumerator <Unit9> enumerator = units3.Where(predicate3).GetEnumerator())
{
while (enumerator.MoveNext())
{
Unit9 unit6 = enumerator.Current;
unit6.Blocker(block, true);
}
goto IL_32F;
}
}
this.blockers.Remove(block.BlockModifierName);
}
IL_32F:
IAppliesImmobility disable;
if ((disable = (ability as IAppliesImmobility)) != null)
{
IAppliesImmobility appliesImmobility = EntityManager9.Abilities.OfType <IAppliesImmobility>().FirstOrDefault((IAppliesImmobility x) => x.ImmobilityModifierName == disable.ImmobilityModifierName);
if (appliesImmobility == null)
{
this.disablers.Remove(disable.ImmobilityModifierName);
return;
}
this.disablers[disable.ImmobilityModifierName] = appliesImmobility;
}
}
public static bool IsPhysicalDamageAmplifier(this IHasDamageAmplify amplifier)
{
return((amplifier.AmplifierDamageType & DamageType.Physical) != 0);
}
public static bool IsOutgoingDamageAmplifier(this IHasDamageAmplify amplifier)
{
return((amplifier.AmplifiesDamage & AmplifiesDamage.Outgoing) != 0);
}
// Token: 0x06000111 RID: 273 RVA: 0x0000B7C0 File Offset: 0x000099C0
private void Kill(Unit9 target, IReadOnlyList <KillStealAbility> abilities)
{
if (this.KillStealSleeper.IsSleeping)
{
return;
}
Func <KillStealAbility, int> < > 9__0;
Func <KillStealAbility, int> keySelector;
if ((keySelector = < > 9__0) == null)
{
keySelector = (< > 9__0 = ((KillStealAbility x) => x.Ability.GetDamage(target)));
}
foreach (KillStealAbility killStealAbility in abilities.OrderBy(keySelector))
{
float hitTime = killStealAbility.Ability.GetHitTime(target);
if (target.Health + target.HealthRegeneration * hitTime * 1.5f <= (float)killStealAbility.Ability.GetDamage(target) && killStealAbility.Ability.UseAbility(target, EntityManager9.EnemyHeroes, 2, 0, false, false))
{
float castDelay = killStealAbility.Ability.GetCastDelay(target);
this.AbilitySleeper.Sleep(killStealAbility.Ability.Handle, hitTime);
this.orbwalkSleeper.Sleep(killStealAbility.Ability.Owner.Handle, castDelay);
this.KillStealSleeper.Sleep(hitTime - killStealAbility.Ability.ActivationDelay);
return;
}
}
for (int i = 0; i < abilities.Count; i++)
{
KillStealAbility killStealAbility2 = abilities[i];
if (this.orbwalkSleeper.IsSleeping(killStealAbility2.Ability.Owner.Handle))
{
return;
}
if (killStealAbility2.Ability.CanBeCasted(true))
{
IHasDamageAmplify hasDamageAmplify = killStealAbility2.Ability as IHasDamageAmplify;
bool flag = hasDamageAmplify != null && AbilityExtensions.IsIncomingDamageAmplifier(hasDamageAmplify) && target.HasModifier(hasDamageAmplify.AmplifierModifierName);
if (!flag || killStealAbility2.Ability is INuke)
{
if (!killStealAbility2.Ability.UseAbility(target, EntityManager9.EnemyHeroes, 2, 0, false, false))
{
return;
}
float num;
if (!flag)
{
KillStealAbility killStealAbility3 = (i < abilities.Count - 1) ? abilities[i + 1] : null;
if (killStealAbility3 != null)
{
float hitTime2 = killStealAbility3.Ability.GetHitTime(target);
num = killStealAbility2.Ability.GetHitTime(target) - hitTime2;
}
else
{
num = killStealAbility2.Ability.GetHitTime(target);
}
}
else
{
num = killStealAbility2.Ability.GetCastDelay(target);
}
this.AbilitySleeper.Sleep(killStealAbility2.Ability.Handle, killStealAbility2.Ability.GetHitTime(target));
this.orbwalkSleeper.Sleep(killStealAbility2.Ability.Owner.Handle, killStealAbility2.Ability.GetCastDelay(target));
this.KillStealSleeper.Sleep(num - killStealAbility2.Ability.ActivationDelay);
return;
}
}
}
}
// Token: 0x060004A0 RID: 1184 RVA: 0x00004E54 File Offset: 0x00003054
public static bool IsMagicalDamageAmplifier(this IHasDamageAmplify amplifier)
{
return((amplifier.AmplifierDamageType & DamageType.Magical) > DamageType.None);
}
// Token: 0x0600049E RID: 1182 RVA: 0x00004E34 File Offset: 0x00003034
public static bool IsIncomingDamageAmplifier(this IHasDamageAmplify amplifier)
{
return((amplifier.AmplifiesDamage & AmplifiesDamage.Incoming) > AmplifiesDamage.None);
}
