public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
{
if (target?.HasModifier("modifier_venomancer_poison_sting_ward") != false)
{
var enemy = EntityManager9.EnemyHeroes
.Where(x => this.Owner.CanAttack(x) && !x.HasModifier("modifier_venomancer_poison_sting_ward"))
.OrderBy(x => x.Distance(this.Owner))
.FirstOrDefault();
if (enemy != null)
{
target = enemy;
}
}
return(base.Orbwalk(target, attack, move, comboMenu));
}
private void Kill(Unit9 target, IReadOnlyList <KillStealAbility> abilities)
{
//todo dynamic order
if (this.KillStealSleeper.IsSleeping)
{
return;
}
foreach (var ability in abilities.OrderBy(x => x.Ability.GetDamage(target)))
{
var hitTime = ability.Ability.GetHitTime(target);
if (target.Health + (target.HealthRegeneration * hitTime * 1.5f) > ability.Ability.GetDamage(target))
{
continue;
}
if (!ability.UseAbility(target))
{
continue;
}
var castDelay = ability.Ability.GetCastDelay(target);
this.AbilitySleeper.Sleep(ability.Ability.Handle, hitTime);
this.orbwalkSleeper.Sleep(ability.Ability.Owner.Handle, castDelay);
this.KillStealSleeper.Sleep(hitTime - ability.Ability.ActivationDelay);
return;
}
for (var i = 0; i < abilities.Count; i++)
{
var ability = abilities[i];
if (this.orbwalkSleeper.IsSleeping(ability.Ability.Owner.Handle))
{
return;
}
if (!ability.Ability.CanBeCasted())
{
continue;
}
var amplifier = ability.Ability as IHasDamageAmplify;
var ampsDamage = amplifier?.IsIncomingDamageAmplifier() == true;
var targetAmplified = ampsDamage && target.HasModifier(amplifier.AmplifierModifierNames);
if (targetAmplified && !(ability.Ability is INuke))
{
continue;
}
if (!ability.UseAbility(target))
{
return;
}
float delay;
if (!targetAmplified)
{
var nextAbility = i < abilities.Count - 1 ? abilities[i + 1] : null;
if (nextAbility != null)
{
var nextAbilityDelay = nextAbility.Ability.GetHitTime(target);
var ampDelay = ability.Ability.GetHitTime(target);
delay = ampDelay - nextAbilityDelay;
}
else
{
delay = ability.Ability.GetHitTime(target);
}
}
else
{
delay = ability.Ability.GetCastDelay(target);
}
this.AbilitySleeper.Sleep(ability.Ability.Handle, ability.Ability.GetHitTime(target));
this.orbwalkSleeper.Sleep(ability.Ability.Owner.Handle, ability.Ability.GetCastDelay(target));
this.KillStealSleeper.Sleep(delay - ability.Ability.ActivationDelay);
return;
}
}
private Dictionary <KillStealAbility, int> GetDamage(Unit9 target)
{
var abilities = new List <KillStealAbility>();
var additionalAmplifiers = new DamageAmplifier();
var damageBlockers = target.GetDamageBlockers().ToDictionary(x => x, x => x.BlockValue(target));
foreach (var ability in this.activeAbilities.Where(x => this.KillStealMenu.IsAbilityEnabled(x.Ability.Name)))
{
if (!ability.Ability.IsValid)
{
continue;
}
if (!this.AbilitySleeper.IsSleeping(ability.Ability.Handle) && !ability.Ability.CanBeCasted(false))
{
continue;
}
//todo remove positive amplifiers
if (ability.Ability is IHasDamageAmplify amplifier)
{
if ((amplifier.IsIncomingDamageAmplifier() && !target.HasModifier(amplifier.AmplifierModifierNames)) ||
(amplifier.IsOutgoingDamageAmplifier() && !ability.Ability.Owner.HasModifier(amplifier.AmplifierModifierNames)))
{
if (amplifier.IsPhysicalDamageAmplifier())
{
additionalAmplifiers[DamageType.Physical] *= 1 + amplifier.AmplifierValue(ability.Ability.Owner, target);
}
if (amplifier.IsMagicalDamageAmplifier())
{
additionalAmplifiers[DamageType.Magical] *= 1 + amplifier.AmplifierValue(ability.Ability.Owner, target);
}
if (amplifier.IsPureDamageAmplifier())
{
additionalAmplifiers[DamageType.Pure] *= 1 + amplifier.AmplifierValue(ability.Ability.Owner, target);
}
}
}
abilities.Add(ability);
}
var remainingHealth = target.Health;
var finalDamage = new Dictionary <KillStealAbility, int>();
var remainingMana = new Dictionary <Unit9, float>();
foreach (var ability in abilities)
{
if (!remainingMana.TryGetValue(ability.Ability.Owner, out var mana))
{
remainingMana[ability.Ability.Owner] = mana = ability.Ability.Owner.Mana;
}
if (mana < ability.Ability.ManaCost)
{
continue;
}
foreach (var damagePair in ability.Ability.GetRawDamage(target, remainingHealth))
{
var damageType = damagePair.Key;
var damage = damagePair.Value;
if (damageType == DamageType.None)
{
if (damage > 0)
{
var ex = new BrokenAbilityException("DamageType");
Logger.Error(ex, ability.Ability.Name);
this.activeAbilities.RemoveAll(x => x.Ability.Handle == ability.Ability.Handle);
}
finalDamage.Add(ability, 0);
continue;
}
if (damageType == DamageType.HealthRemoval)
{
finalDamage.TryGetValue(ability, out var hpRemovalDamage);
finalDamage[ability] = hpRemovalDamage + (int)damage;
remainingHealth -= damage;
continue;
}
var amp = target.GetDamageAmplification(ability.Ability.Owner, damageType, ability.Ability.IntelligenceAmplify);
if (amp <= 0)
{
continue;
}
foreach (var damageBlock in damageBlockers.ToList())
{
var blockAbility = damageBlock.Key;
if (!blockAbility.CanBlock(damageType))
{
continue;
}
var blockedDamage = Math.Min(damage, damageBlock.Value);
damageBlockers[blockAbility] -= blockedDamage;
if (blockAbility.BlocksDamageAfterReduction)
{
damage -= Math.Min(damage, blockedDamage * (1 / (amp * additionalAmplifiers[damageType])));
}
else
{
damage -= blockedDamage;
}
}
var amplifiedDamage = (int)(damage * amp * additionalAmplifiers[damageType]);
if (amplifiedDamage <= 0)
{
continue;
}
remainingMana[ability.Ability.Owner] -= ability.Ability.ManaCost;
finalDamage.TryGetValue(ability, out var savedDamage);
finalDamage[ability] = savedDamage + amplifiedDamage;
remainingHealth -= amplifiedDamage;
}
}
return(finalDamage);
}
// Token: 0x0600053A RID: 1338 RVA: 0x0001ADB0 File Offset: 0x00018FB0
public override bool CanHit(TargetManager targetManager, IComboModeMenu comboMenu)
{
if (!comboMenu.GetAbilitySettingsMenu <SpearOfMarsMenu>(this).StunOnly)
{
return(base.CanHit(targetManager, comboMenu));
}
Unit9 target = targetManager.Target;
if (target.IsMagicImmune && !base.Ability.CanHitSpellImmuneEnemy)
{
return(false);
}
if (base.Owner.Distance(target) > base.Ability.CastRange)
{
return(false);
}
if (target.HasModifier("modifier_mars_arena_of_blood_leash"))
{
return(true);
}
PredictionInput9 predictionInput = base.Ability.GetPredictionInput(target, null);
predictionInput.Range = base.Ability.CastRange;
PredictionOutput9 simplePrediction = base.Ability.PredictionManager.GetSimplePrediction(predictionInput);
Vector3 targetPosition = simplePrediction.TargetPosition;
float num = base.Ability.Range - 200f;
float radius = base.Ability.Radius;
Polygon.Rectangle collisionRec = new Polygon.Rectangle(base.Owner.Position, targetPosition, radius);
if (targetManager.AllEnemyHeroes.Any((Unit9 x) => x != target && collisionRec.IsInside(x.Position)))
{
return(false);
}
foreach (Tree tree in from x in this.trees
where x.IsValid && x.IsAlive
select x)
{
if (new Polygon.Rectangle(targetPosition, Vector3Extensions.Extend2D(base.Owner.Position, targetPosition, num), radius - 50f).IsInside(tree.Position))
{
this.castPosition = simplePrediction.CastPosition;
return(true);
}
}
foreach (Building building in from x in this.buildings
where x.IsValid && x.IsAlive
select x)
{
if (new Polygon.Rectangle(targetPosition, Vector3Extensions.Extend2D(base.Owner.Position, targetPosition, num), radius).IsInside(building.Position))
{
this.castPosition = simplePrediction.CastPosition;
return(true);
}
}
for (int i = 0; i < 30; i++)
{
for (int j = 0; j < 30; j++)
{
Vector2 vector;
vector..ctor(this.navMesh.CellSize * (float)(i - 15) + targetPosition.X, this.navMesh.CellSize * (float)(j - 15) + targetPosition.Y);
if ((this.navMesh.GetCellFlags(vector) & NavMeshCellFlags.InteractionBlocker) != NavMeshCellFlags.None && new Polygon.Rectangle(targetPosition, Vector3Extensions.Extend2D(base.Owner.Position, targetPosition, num), radius - 100f).IsInside(vector))
{
this.castPosition = simplePrediction.CastPosition;
return(true);
}
}
}
return(false);
}
// Token: 0x06000A28 RID: 2600 RVA: 0x0002C17C File Offset: 0x0002A37C
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 owner = base.Owner;
if (owner.IsInvulnerable)
{
return(false);
}
if (owner.Equals(this.Buff.Owner))
{
if (!this.Buff.BuffsOwner)
{
return(false);
}
}
else if (!this.Buff.BuffsAlly)
{
return(false);
}
ToggleAbility toggleAbility;
return((!owner.IsMagicImmune || this.Buff.PiercesMagicImmunity(owner)) && !owner.HasModifier(this.Buff.BuffModifierName) && ((toggleAbility = (this.Buff as ToggleAbility)) == null || !toggleAbility.Enabled));
}
// Token: 0x06000A6E RID: 2670 RVA: 0x0002CDD0 File Offset: 0x0002AFD0
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 target = targetManager.Target;
return((target.IsInNormalState || target.IsTeleporting || target.IsChanneling) && !target.HasModifier(new string[]
{
"modifier_lina_laguna_blade",
"modifier_lion_finger_of_death"
}) && this.ShouldForceCast(targetManager));
}
// 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: 0x060007F9 RID: 2041 RVA: 0x00024918 File Offset: 0x00022B18
public void RollSmashCombo(TargetManager targetManager, RollSmashModeMenu menu)
{
if (base.ComboSleeper.IsSleeping)
{
return;
}
Unit9 target = targetManager.Target;
float num = base.Owner.Distance(target.Position);
AbilityHelper abilityHelper = new AbilityHelper(targetManager, null, this);
if (base.Owner.HasModifier("modifier_earth_spirit_rolling_boulder_caster") && abilityHelper.ForceUseAbility(this.stone, true, true))
{
base.ComboSleeper.Sleep(3f);
return;
}
Unit9 unit = (from x in targetManager.AllyHeroes
where !x.Equals(this.Owner) && menu.IsAllyEnabled(x.Name) && x.Distance(target) > 300f && x.Distance(target) < 1500f
orderby x.Distance(target)
select x).FirstOrDefault <Unit9>();
if (unit == null)
{
return;
}
if (target.HasModifier("modifier_earth_spirit_boulder_smash"))
{
if (abilityHelper.CanBeCasted(this.rolling, false, false, true, true) && this.rolling.SimpleUseAbility(target.Position))
{
base.ComboSleeper.Sleep(0.5f);
return;
}
return;
}
else
{
BoulderSmash boulderSmash = this.smash;
if (boulderSmash == null || !boulderSmash.Ability.CanBeCasted(true))
{
return;
}
if (num < this.smash.Ability.CastRange + 100f)
{
if (Vector3Extensions.AngleBetween(base.Owner.Position, target.Position, unit.Position) < 30f)
{
this.smash.Ability.UseAbility(target, false, false);
base.ComboSleeper.Sleep(0.3f);
return;
}
if (target.GetImmobilityDuration() > 0.5f)
{
base.Owner.BaseUnit.Move(Vector3Extensions.Extend2D(target.Position, unit.Position, -100f));
base.OrbwalkSleeper.Sleep(0.1f);
base.ComboSleeper.Sleep(0.1f);
return;
}
}
if (abilityHelper.CanBeCasted(this.blink, true, true, true, true))
{
Vector3 position = Vector3Extensions.Extend2D(target.GetPredictedPosition(base.Owner.GetTurnTime(target.Position) + Game.Ping / 2000f + 0.2f), unit.Position, -125f);
if (abilityHelper.UseAbility(this.blink, position))
{
base.ComboSleeper.ExtendSleep(0.1f);
return;
}
return;
}
else
{
if (!abilityHelper.CanBeCasted(this.rolling, true, true, true, true))
{
return;
}
if (abilityHelper.UseAbility(this.rolling, true))
{
return;
}
if (abilityHelper.CanBeCasted(this.stone, false, true, true, true))
{
abilityHelper.ForceUseAbility(this.stone, true, true);
return;
}
abilityHelper.ForceUseAbility(this.rolling, true, true);
return;
}
}
}
