internal void Blocker(IHasDamageBlock block, bool added)
{
if (added)
{
this.blockers[block.BlockModifierName] = block;
}
else
{
this.blockers.Remove(block.BlockModifierName);
}
}
// 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;
}
}
// 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 IsPureDamageBlock(this IHasDamageBlock block)
{
return((block.BlockDamageType & DamageType.Pure) != 0);
}
public static bool IsPhysicalDamageBlock(this IHasDamageBlock block)
{
return((block.BlockDamageType & DamageType.Physical) != 0);
}
public static bool CanBlock(this IHasDamageBlock block, DamageType damageType)
{
return((block.BlockDamageType & damageType) != 0);
}
// Token: 0x06000110 RID: 272 RVA: 0x0000B0E0 File Offset: 0x000092E0
private Dictionary <KillStealAbility, int> GetDamage(Unit9 target)
{
List <KillStealAbility> list = new List <KillStealAbility>();
DamageAmplifier damageAmplifier = new DamageAmplifier();
Dictionary <IHasDamageBlock, float> dictionary = target.GetDamageBlockers().ToDictionary((IHasDamageBlock x) => x, (IHasDamageBlock x) => x.BlockValue(target));
IEnumerable <KillStealAbility> source = this.activeAbilities;
Func <KillStealAbility, bool> < > 9__2;
Func <KillStealAbility, bool> predicate;
if ((predicate = < > 9__2) == null)
{
predicate = (< > 9__2 = ((KillStealAbility x) => this.KillStealMenu.IsAbilityEnabled(x.Ability.Name)));
}
foreach (KillStealAbility killStealAbility in source.Where(predicate))
{
if (killStealAbility.Ability.IsValid && (this.AbilitySleeper.IsSleeping(killStealAbility.Ability.Handle) || killStealAbility.Ability.CanBeCasted(false)))
{
IHasDamageAmplify hasDamageAmplify;
if ((hasDamageAmplify = (killStealAbility.Ability as IHasDamageAmplify)) != null && ((AbilityExtensions.IsIncomingDamageAmplifier(hasDamageAmplify) && !target.HasModifier(hasDamageAmplify.AmplifierModifierName)) || (AbilityExtensions.IsOutgoingDamageAmplifier(hasDamageAmplify) && !killStealAbility.Ability.Owner.HasModifier(hasDamageAmplify.AmplifierModifierName))))
{
if (AbilityExtensions.IsPhysicalDamageAmplifier(hasDamageAmplify))
{
DamageAmplifier damageAmplifier2 = damageAmplifier;
damageAmplifier2[DamageType.Physical] = damageAmplifier2[DamageType.Physical] * (1f + hasDamageAmplify.AmplifierValue(killStealAbility.Ability.Owner, target));
}
if (AbilityExtensions.IsMagicalDamageAmplifier(hasDamageAmplify))
{
DamageAmplifier damageAmplifier2 = damageAmplifier;
damageAmplifier2[DamageType.Magical] = damageAmplifier2[DamageType.Magical] * (1f + hasDamageAmplify.AmplifierValue(killStealAbility.Ability.Owner, target));
}
if (AbilityExtensions.IsPureDamageAmplifier(hasDamageAmplify))
{
DamageAmplifier damageAmplifier2 = damageAmplifier;
damageAmplifier2[DamageType.Pure] = damageAmplifier2[DamageType.Pure] * (1f + hasDamageAmplify.AmplifierValue(killStealAbility.Ability.Owner, target));
}
}
list.Add(killStealAbility);
}
}
float num = target.Health;
Dictionary <KillStealAbility, int> dictionary2 = new Dictionary <KillStealAbility, int>();
Dictionary <Unit9, float> dictionary3 = new Dictionary <Unit9, float>();
using (List <KillStealAbility> .Enumerator enumerator2 = list.GetEnumerator())
{
while (enumerator2.MoveNext())
{
KillStealAbility ability = enumerator2.Current;
float num2;
if (!dictionary3.TryGetValue(ability.Ability.Owner, out num2))
{
num2 = (dictionary3[ability.Ability.Owner] = ability.Ability.Owner.Mana);
}
if (num2 >= ability.Ability.ManaCost)
{
Predicate <KillStealAbility> < > 9__3;
foreach (KeyValuePair <DamageType, float> keyValuePair in ability.Ability.GetRawDamage(target, new float?(num)))
{
DamageType key = keyValuePair.Key;
float num3 = keyValuePair.Value;
if (key == DamageType.None)
{
if (num3 > 0f)
{
Logger.Error(new BrokenAbilityException("DamageType"), ability.Ability.Name);
List <KillStealAbility> list2 = this.activeAbilities;
Predicate <KillStealAbility> match;
if ((match = < > 9__3) == null)
{
match = (< > 9__3 = ((KillStealAbility x) => x.Ability.Handle == ability.Ability.Handle));
}
list2.RemoveAll(match);
}
dictionary2.Add(ability, 0);
}
else if (key == DamageType.HealthRemoval)
{
int num4;
dictionary2.TryGetValue(ability, out num4);
dictionary2[ability] = num4 + (int)num3;
num -= num3;
}
else
{
float damageAmplification = target.GetDamageAmplification(ability.Ability.Owner, key, ability.Ability.IntelligenceAmplify);
if (damageAmplification > 0f)
{
foreach (KeyValuePair <IHasDamageBlock, float> keyValuePair2 in dictionary.ToList <KeyValuePair <IHasDamageBlock, float> >())
{
IHasDamageBlock key2 = keyValuePair2.Key;
if (AbilityExtensions.CanBlock(key2, key))
{
float num5 = Math.Min(num3, keyValuePair2.Value);
Dictionary <IHasDamageBlock, float> dictionary4 = dictionary;
IHasDamageBlock key3 = key2;
dictionary4[key3] -= num5;
if (key2.BlocksDamageAfterReduction)
{
num3 -= Math.Min(num3, num5 * (1f / (damageAmplification * damageAmplifier[key])));
}
else
{
num3 -= num5;
}
}
}
int num6 = (int)(num3 * damageAmplification * damageAmplifier[key]);
if (num6 > 6000 || num6 < 0)
{
BrokenAbilityException ex = new BrokenAbilityException("Amplified");
ex.Data["Ability"] = new
{
Ability = ability.Ability.Name,
Target = target.Name,
Damage = num3.ToString(),
AmplifiedDamage = num6.ToString(),
Type = key.ToString(),
Amp = damageAmplification.ToString(),
Amp2 = damageAmplifier[key].ToString(),
TargetAmps = (from x in target.amplifiers
where x.IsValid && AbilityExtensions.IsIncomingDamageAmplifier(x)
select x.AmplifierModifierName).ToArray <string>(),
OwnerAmps = (from x in ability.Ability.Owner.amplifiers
where x.IsValid && AbilityExtensions.IsOutgoingDamageAmplifier(x)
select x.AmplifierModifierName).ToArray <string>()
};
Logger.Error(ex, null);
}
else
{
Dictionary <Unit9, float> dictionary5 = dictionary3;
Unit9 owner = ability.Ability.Owner;
dictionary5[owner] -= ability.Ability.ManaCost;
int num7;
dictionary2.TryGetValue(ability, out num7);
dictionary2[ability] = num7 + num6;
num -= (float)num6;
}
}
}
}
}
}
}
return(dictionary2);
}
// Token: 0x060004A1 RID: 1185 RVA: 0x00004E61 File Offset: 0x00003061
public static bool IsMagicalDamageBlock(this IHasDamageBlock block)
{
return((block.BlockDamageType & DamageType.Magical) > DamageType.None);
}
