/// <summary>
/// Razers Extensions
/// </summary>
/// <param name="ability"></param>
/// <param name="target"></param>
/// <param name="usePrediction"></param>
/// <param name="checkForFace"></param>
/// <returns></returns>
public static bool CanHit(this Ability ability, Hero target, bool usePrediction = false, bool checkForFace = true)
{
var aId = ability.GetAbilityId();
if (aId >= AbilityId.nevermore_shadowraze1 && aId <= AbilityId.nevermore_shadowraze3)
{
var radius = ability.GetRadius();
var range = ability.GetCastRange();
if (checkForFace)
{
var predFontPos = Prediction.InFront(Core.Me, range);
var pred = ability.GetPrediction(target);
//var inRange = (usePrediction ? pred.Distance2D(predFontPos) : target.Distance2D(predFontPos)) <= radius + target.HullRadius;
var inRange = target.Distance2D(predFontPos) <= radius + target.HullRadius;
return(inRange);
}
else
{
var dist = target.Distance2D(Core.Me);
var inRange = dist <= range + target.HullRadius + radius &&
dist >= range - target.HullRadius - radius;
return(inRange);
}
}
return(AbilityExtensions.CanHit(ability, target));
}
// Token: 0x06000173 RID: 371 RVA: 0x0000D3A8 File Offset: 0x0000B5A8
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 target = targetManager.Target;
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
return(false);
}
if (target.IsStunned)
{
return(this.ChainStun(target, false));
}
if (target.IsHexed)
{
return(this.ChainStun(target, false));
}
if (target.IsSilenced)
{
return(!AbilityExtensions.IsSilence(base.Disable, false) || this.ChainStun(target, false));
}
if (target.IsRooted)
{
return(!AbilityExtensions.IsRoot(base.Disable) || this.ChainStun(target, false));
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
/// <summary>
/// with custom delay
/// </summary>
/// <param name="ability"></param>
/// <param name="target"></param>
/// <param name="customDelay"></param>
/// <returns></returns>
public static bool CanHit(this Ability ability, Hero target, float customDelay, bool checkForFace = true)
{
var aId = ability.GetAbilityId();
if (aId >= AbilityId.nevermore_shadowraze1 && aId <= AbilityId.nevermore_shadowraze3)
{
if (checkForFace)
{
var radius = ability.GetRadius();
var range = ability.GetCastRange();
var predFontPos = Prediction.InFront(Core.Me, range);
var pred = Prediction.PredictedXYZ(target, customDelay);
//var inRange = (usePrediction ? pred.Distance2D(predFontPos) : Target.Distance2D(predFontPos)) <= radius + Target.HullRadius;
var inRange = pred.Distance2D(predFontPos) <= radius + target.HullRadius;
return(inRange);
}
else
{
var radius = ability.GetRadius();
var range = ability.GetCastRange();
var pred = Prediction.PredictedXYZ(target, customDelay);
var dist = pred.Distance2D(Core.Me);
var inRange = dist <= (range + radius + target.HullRadius) && dist >= (range - radius - target.HullRadius);
return(inRange);
}
}
return(AbilityExtensions.CanHit(ability, target));
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
}
// Token: 0x060008F4 RID: 2292 RVA: 0x000283BC File Offset: 0x000265BC
public bool UseInstantDisable(Unit9 target, ComboModeMenu menu)
{
foreach (OldDisableAbility oldDisableAbility in base.Abilities)
{
if (oldDisableAbility.Ability.IsValid && !AbilityExtensions.IsDisarm(oldDisableAbility.Disable, true) && oldDisableAbility.Ability.CastPoint <= 0.1f && oldDisableAbility.CanBeCasted(target, menu, true) && oldDisableAbility.Use(target))
{
return(true);
}
}
return(false);
}
/// <summary>
/// The load.
/// </summary>
private static void Init()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
Calculations.Init();
EntityExtensions.Init();
Utils.Sleeps = new Dictionary <string, double>();
NotifiedSubscribers.Clear();
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
Calculations.Init();
EntityExtensions.Init();
Orbwalking.Events_OnLoad(null, null);
Utils.Sleeps = new Dictionary <string, double>();
}
// Token: 0x06000A2E RID: 2606 RVA: 0x0002C30C File Offset: 0x0002A50C
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 target = targetManager.Target;
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (base.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Disable.UnitTargetCast)
{
return(false);
}
if (!this.ChainStun(target, true))
{
return(false);
}
}
if ((float)base.Ability.GetDamage(target) < target.Health)
{
if (target.IsStunned)
{
return(this.ChainStun(target, false));
}
if (target.IsHexed)
{
return(this.ChainStun(target, false));
}
if (target.IsSilenced)
{
return(!AbilityExtensions.IsSilence(this.Disable, false) || this.ChainStun(target, false));
}
if (target.IsRooted)
{
return(!AbilityExtensions.IsRoot(this.Disable) || this.ChainStun(target, false));
}
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
/// <summary>
/// with custom delay
/// </summary>
/// <param name="ability"></param>
/// <param name="target"></param>
/// <param name="customDelay"></param>
/// <returns></returns>
public static bool CanHit(this Ability ability, Hero target, float customDelay)
{
var aId = ability.GetAbilityId();
if (aId >= AbilityId.nevermore_shadowraze1 && aId <= AbilityId.nevermore_shadowraze3)
{
var radius = ability.GetRadius();
var range = ability.GetCastRange();
var predFontPos = Prediction.InFront(Core.Me, range);
var pred = Prediction.PredictedXYZ(target, customDelay);
//var inRange = (usePrediction ? pred.Distance2D(predFontPos) : target.Distance2D(predFontPos)) <= radius + target.HullRadius;
var inRange = pred.Distance2D(predFontPos) <= radius + target.HullRadius;
return(inRange);
}
return(AbilityExtensions.CanHit(ability, target));
}
void Start()
{
this.gameData = GameObject.FindGameObjectWithTag("GameData").GetComponent <GameData>();
int i = 0;
foreach (KeyValuePair <Ability, float> entry in gameData.abilityTimers)
{
AbilityButton abilityButton = new AbilityButton();
abilityButton.button = Instantiate(UIButtonPrefab, this.gameObject.transform);
var abilityImage = abilityButton.button.GetComponent <Image>();
abilityImage.color = new Color(255, 255, 255, 0);
abilityImage.sprite = (Sprite)AssetDatabase.LoadAssetAtPath(AbilityExtensions.GetImagePath(entry.Key), typeof(Sprite));
abilityImage.transform.localScale = new Vector3(0f, 0f, 0f);
abilityButton.button.GetComponent <RectTransform>().localPosition = new Vector3(0, TOP_OFFSET, 0);
abilityButton.abilityState = AbilityState.EXITED;
abilityButton.ability = entry.Key;
activeAbilities[i] = abilityButton;
i++;
}
}
// Token: 0x060008E9 RID: 2281 RVA: 0x00028008 File Offset: 0x00026208
public override bool ShouldCast(Unit9 target)
{
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (base.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Disable.UnitTargetCast)
{
return(false);
}
float immobilityDuration = target.GetImmobilityDuration();
if (immobilityDuration <= 0f || immobilityDuration + 0.05f > this.Disable.GetHitTime(target))
{
return(false);
}
}
if (target.IsStunned)
{
return(this.ChainStun(target));
}
if (target.IsHexed)
{
return((this.isAmplifier && !AbilityExtensions.IsHex(this.Disable)) || this.ChainStun(target));
}
if (target.IsSilenced)
{
return(!AbilityExtensions.IsSilence(this.Disable, false) || this.isAmplifier || this.ChainStun(target));
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
private async Task OnUpdate(CancellationToken token)
{
if (Game.IsPaused || !this.Config.General.ComboKey.Value.Active)
{
await Task.Delay(250, token);
return;
}
if (!this.Config.General.Enabled)
{
return;
}
foreach (var unit in this.Updater.AllUnits)
{
if (unit.Unit != BodyBlockerUnit && this.Config.Hero.ControlUnits && unit.Unit.Name != "npc_dota_templar_assassin_psionic_trap")
{
if (this.ComboMode.CurrentTarget == null || UnitExtensions.IsInvul(this.ComboMode.CurrentTarget) ||
this.ComboMode.CurrentTarget.IsAttackImmune())
{
Player.AttackEntity(unit.Unit, (Unit)null);
//unit.UnitMovementManager.Orbwalk(null);
}
else
{
Player.AttackEntity(unit.Unit, this.ComboMode.CurrentTarget);
//unit.UnitMovementManager.Orbwalk(this.ComboMode.CurrentTarget);
}
}
var ability1 = unit.Ability;
var ability2 = unit.Ability2;
var ability3 = unit.Ability3;
var ability4 = unit.Ability4;
if (this.ComboMode.CurrentTarget != null && this.Config.Hero.UseUnitAbilities &&
!UnitExtensions.IsInvul(this.ComboMode.CurrentTarget) && !this.ComboMode.CurrentTarget.IsAttackImmune() && !this.ComboMode.CurrentTarget.IsMagicImmune() &&
(ability1 != null && AbilityExtensions.CanBeCasted(ability1) ||
ability2 != null && AbilityExtensions.CanBeCasted(ability2) ||
ability3 != null && AbilityExtensions.CanBeCasted(ability3) ||
ability4 != null && AbilityExtensions.CanBeCasted(ability4)))
{
if (ability1 != null &&
AbilityExtensions.CanBeCasted(ability1) &&
UnitCastingChecks(ability1.Name, unit.Unit, this.ComboMode.CurrentTarget, ability1) &&
(ability1.TargetTeamType == TargetTeamType.Enemy ||
ability1.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability1) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability1) - 70))
{
if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability1.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability1.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability1.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability1 != null &&
AbilityExtensions.CanBeCasted(ability1) &&
ability1.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability1))
{
if (ability1.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
if (ability2 != null &&
AbilityExtensions.CanBeCasted(ability2) &&
UnitCastingChecks(ability2.Name, unit.Unit, this.ComboMode.CurrentTarget, ability2) &&
AbilityExtensions.CanHit(ability2, this.ComboMode.CurrentTarget) &&
(ability2.TargetTeamType == TargetTeamType.Enemy ||
ability2.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability2) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability2) - 70))
{
if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability2.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability2.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability2.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability2 != null &&
AbilityExtensions.CanBeCasted(ability2) &&
ability2.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability2))
{
if (ability2.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
if (ability3 != null &&
AbilityExtensions.CanBeCasted(ability3) &&
UnitCastingChecks(ability3.Name, unit.Unit, this.ComboMode.CurrentTarget, ability3) &&
AbilityExtensions.CanHit(ability3, this.ComboMode.CurrentTarget) &&
(ability3.TargetTeamType == TargetTeamType.Enemy ||
ability3.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability3) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability3) - 70))
{
if (ability3.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability3.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability3.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability3.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability3.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability3.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability3 != null &&
AbilityExtensions.CanBeCasted(ability3) &&
ability3.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability3))
{
if (ability3.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
if (ability4 != null &&
AbilityExtensions.CanBeCasted(ability4) &&
UnitCastingChecks(ability4.Name, unit.Unit, this.ComboMode.CurrentTarget, ability4) &&
AbilityExtensions.CanHit(ability4, this.ComboMode.CurrentTarget) &&
(ability4.TargetTeamType == TargetTeamType.Enemy ||
ability4.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityCastRange(unit.Unit, ability4) ||
unit.Unit.Distance2D(this.ComboMode.CurrentTarget) <= Extensions.GetAbilityRadius(unit.Unit, ability4) - 70))
{
if (ability4.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
if (ability4.UseAbility())
{
await Task.Delay(180, token);
}
}
else if (ability4.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
if (ability4.UseAbility(this.ComboMode.CurrentTarget))
{
await Task.Delay(180, token);
}
}
else if (ability4.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
if (ability4.UseAbility(this.ComboMode.CurrentTarget.Position))
{
await Task.Delay(180, token);
}
}
}
else if (ability4 != null &&
AbilityExtensions.CanBeCasted(ability4) &&
ability4.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= Extensions.GetAbilityCastRange(unit.Unit, ability4))
{
if (ability4.UseAbility(this.Owner))
{
await Task.Delay(180, token);
}
}
}
}
await Task.Delay(100, token);
}
// Token: 0x06000113 RID: 275 RVA: 0x0000BB14 File Offset: 0x00009D14
private void OnAbilityAdded(Ability9 ability)
{
try
{
if (ability.IsControllable && ability.Owner.CanUseAbilities && ability.Owner.IsAlly(base.Owner))
{
ActiveAbility activeAbility;
if (!this.ignoredAmplifiers.Contains(ability.Id) && (activeAbility = (ability as ActiveAbility)) != null)
{
IHasDamageAmplify hasDamageAmplify;
if ((hasDamageAmplify = (ability as IHasDamageAmplify)) != null && ((AbilityExtensions.IsIncomingDamageAmplifier(hasDamageAmplify) && activeAbility.TargetsEnemy) || (AbilityExtensions.IsOutgoingDamageAmplifier(hasDamageAmplify) && activeAbility.TargetsAlly)))
{
this.AddAbility(activeAbility);
this.KillStealMenu.AddKillStealAbility(activeAbility);
}
else if (ability is INuke)
{
this.AddAbility(activeAbility);
this.KillStealMenu.AddKillStealAbility(activeAbility);
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
// 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: 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: 0x06000885 RID: 2181 RVA: 0x00026A28 File Offset: 0x00024C28
protected override bool IsIgnored(Ability9 ability)
{
IDisable disable;
return(base.IsIgnored(ability) || ((disable = (ability as IDisable)) != null && AbilityExtensions.IsInvulnerability(disable)));
}
