public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
{
if (this.razeOrbwalk && this.abilityHelper != null && target != null && this.Owner.Speed >= 305 &&
(target.IsRanged || target.GetImmobilityDuration() > 1))
{
var distance = this.Owner.Distance(target);
foreach (var raze in this.razes.OrderBy(x => Math.Abs(x.Ability.CastRange - distance)))
{
if (!this.abilityHelper.CanBeCasted(raze, false))
{
continue;
}
var position = target.Position.Extend2D(this.Owner.Position, raze.Ability.CastRange - (raze.Ability.Radius - 100));
var distance2 = this.Owner.Distance(position);
if (target.GetAttackRange(this.Owner) >= distance2 || target.GetImmobilityDuration() > 1)
{
if (distance2 > 50)
{
return(this.Move(position));
}
}
}
}
return(base.Orbwalk(target, attack, move, comboMenu));
}
// Token: 0x060008D7 RID: 2263 RVA: 0x00027C68 File Offset: 0x00025E68
public override bool ShouldCast(Unit9 target)
{
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.HasModifier(this.Debuff.DebuffModifierName) && !(this.Debuff is INuke))
{
return(false);
}
if (base.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Debuff.UnitTargetCast)
{
return(false);
}
float immobilityDuration = target.GetImmobilityDuration();
if (immobilityDuration <= 0f || immobilityDuration + 0.05f > this.Debuff.GetHitTime(target))
{
return(false);
}
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
public override bool ShouldCast(Unit9 target)
{
if (this.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (this.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Disable.UnitTargetCast)
{
return(false);
}
var immobile = target.GetImmobilityDuration();
if (immobile <= 0 || immobile + 0.05f > this.Disable.GetHitTime(target))
{
return(false);
}
}
if (target.IsStunned)
{
return(this.ChainStun(target));
}
if (target.IsHexed)
{
return((this.isAmplifier && !this.Disable.IsHex()) || this.ChainStun(target));
}
if (target.IsSilenced)
{
return(!this.Disable.IsSilence(false) || this.isAmplifier || this.ChainStun(target));
}
if (target.IsRooted && !this.Ability.UnitTargetCast && target.GetImmobilityDuration() <= 0)
{
return(false);
}
return(true);
}
public override bool ShouldCast(Unit9 target)
{
if (this.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.IsReflectingDamage)
{
return(false);
}
if (this.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
var damage = this.Nuke.GetDamage(target);
if (damage <= 0)
{
return(false);
}
if ((target.IsStunned || target.IsHexed) && this.Ability is IDisable && damage < target.Health)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Nuke.UnitTargetCast)
{
return(false);
}
var immobile = target.GetImmobilityDuration();
if (immobile <= 0 || immobile + 0.05f > this.Nuke.GetHitTime(target))
{
return(false);
}
}
if (target.IsRooted && !this.Ability.UnitTargetCast && target.GetImmobilityDuration() <= 0)
{
return(false);
}
return(true);
}
// Token: 0x06000445 RID: 1093 RVA: 0x00017400 File Offset: 0x00015600
public override bool CanHit(TargetManager targetManager, IComboModeMenu comboMenu)
{
Unit9 target = targetManager.Target;
PredictionInput9 predictionInput = base.Ability.GetPredictionInput(target, null);
if (base.Ability.GetPredictionOutput(predictionInput).HitChance <= 0)
{
return(false);
}
if (target.Distance(base.Owner) < 300f || target.GetImmobilityDuration() > 0f)
{
return(true);
}
if (!target.Equals(this.lastTarget))
{
this.lastTarget = target;
this.rotationTime = Game.RawGameTime;
this.rotation = target.BaseUnit.NetworkRotationRad;
return(false);
}
if ((double)Math.Abs(this.rotation - target.BaseUnit.NetworkRotationRad) > 0.1)
{
this.rotationTime = Game.RawGameTime;
this.rotation = target.BaseUnit.NetworkRotationRad;
return(false);
}
MeatHookMenu abilitySettingsMenu = comboMenu.GetAbilitySettingsMenu <MeatHookMenu>(this);
return(this.rotationTime + abilitySettingsMenu.Delay / 1000f <= Game.RawGameTime);
}
// Token: 0x06000A40 RID: 2624 RVA: 0x0002C89C File Offset: 0x0002AA9C
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 target = targetManager.Target;
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.IsReflectingDamage)
{
return(false);
}
if (base.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (base.Ability.GetDamage(target) <= 0 && !target.HasModifier(this.breakShields))
{
return(false);
}
if (target.IsInvulnerable)
{
if (base.Ability.UnitTargetCast)
{
return(false);
}
if (!this.ChainStun(target, true))
{
return(false);
}
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
public override bool ShouldCast(Unit9 target)
{
if (this.isOrb)
{
return(false);
}
if (target.IsInvulnerable)
{
return(false);
}
if (target.IsRooted && !this.Ability.UnitTargetCast && target.GetImmobilityDuration() <= 0)
{
return(false);
}
if (this.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (this.Harass is ToggleAbility toggle && toggle.Enabled)
{
return(false);
}
return(true);
}
// Token: 0x06000A23 RID: 2595 RVA: 0x0002C088 File Offset: 0x0002A288
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 target = targetManager.Target;
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.IsMagicImmune && !base.Ability.PiercesMagicImmunity(target))
{
return(false);
}
if (target.IsInvulnerable)
{
if (base.Ability.UnitTargetCast)
{
return(false);
}
if (!this.ChainStun(target, true))
{
return(false);
}
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
// Token: 0x060003CC RID: 972 RVA: 0x0001554C File Offset: 0x0001374C
public override bool CanBeCasted(TargetManager targetManager, bool channelingCheck, IComboModeMenu comboMenu)
{
if (!base.CanBeCasted(targetManager, channelingCheck, comboMenu))
{
return(false);
}
if (comboMenu.GetAbilitySettingsMenu <TricksOfTheTradeMenu>(this).SmartUsage)
{
Unit9 target = targetManager.Target;
if (base.Owner.HealthPercentage < 25f)
{
return(true);
}
if (target.GetImmobilityDuration() > 1.5f)
{
return(true);
}
if (!target.IsRanged && target.Distance(base.Owner) < 200f && target.HealthPercentage < 40f)
{
return(true);
}
int damage = base.Ability.GetDamage(target);
if (Math.Floor((double)(base.Ability.Radius / target.Speed / this.tricks.AttackRate)) * (double)damage * 0.89999997615814209 < (double)target.Health)
{
return(false);
}
}
return(true);
}
// 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);
}
// Token: 0x06000305 RID: 773 RVA: 0x0001246C File Offset: 0x0001066C
public override bool UseAbility(TargetManager targetManager, Sleeper comboSleeper, bool aoe)
{
Unit9 target = targetManager.Target;
Vector3 position = target.Position;
Vector3 position2 = base.Owner.Position;
float num = base.Owner.Distance(target);
if (num > this.menuMaxCastRange)
{
return(false);
}
Ability9 ability = base.Owner.Abilities.FirstOrDefault((Ability9 x) => x.Id == AbilityId.storm_spirit_static_remnant);
Ability9 ability2 = base.Owner.Abilities.FirstOrDefault((Ability9 x) => x.Id == AbilityId.storm_spirit_electric_vortex);
float attackRange = base.Owner.GetAttackRange(target, 0f);
bool flag = num < attackRange;
float maxCastRange = this.ball.MaxCastRange;
PredictionInput9 predictionInput = base.Ability.GetPredictionInput(targetManager.Target, null);
predictionInput.CastRange = maxCastRange;
predictionInput.Range = maxCastRange;
predictionInput.Radius = 1f;
predictionInput.Delay += 0.3f;
Vector3 castPosition = base.Ability.GetPredictionOutput(predictionInput).CastPosition;
if (ability != null && ability.CanBeCasted(true) && num > 200f)
{
if (((target.GetImmobilityDuration() > 0.5f && !target.HasModifier("modifier_storm_spirit_electric_vortex_pull")) || !base.Owner.IsVisibleToEnemies) && (float)this.ball.GetRemainingMana(castPosition) > ability.ManaCost)
{
return(this.UseAbility(targetManager, comboSleeper, castPosition));
}
if (ability2 != null && ability2.CanBeCasted(true) && (float)this.ball.GetRemainingMana(castPosition) > ability.ManaCost + ability2.ManaCost && target.GetAngle(position2, false) > 1.5f)
{
return(this.UseAbility(targetManager, comboSleeper, castPosition));
}
}
if (!flag)
{
Vector3 toPosition = Vector3Extensions.Extend2D(castPosition, position2, attackRange - 100f);
return(this.UseAbility(targetManager, comboSleeper, toPosition));
}
if (!this.maxDamage || !base.Owner.CanAttack(target, 0f))
{
return(false);
}
if (target.IsRanged || target.GetAngle(base.Owner, false) > 1f)
{
Vector3 vector = Vector3Extensions.Extend2D(castPosition, position2, attackRange - 50f);
Vector3 vector2 = Vector3Extensions.Extend2D(position2, castPosition, 100f);
Vector3 toPosition2 = (castPosition.Distance2D(vector, false) < castPosition.Distance2D(vector2, false)) ? vector : vector2;
return(this.UseAbility(targetManager, comboSleeper, toPosition2));
}
if (!target.IsStunned && !target.IsDisarmed)
{
Vector3 vector3 = Vector3Extensions.Extend2D(position, position2, attackRange - 100f);
Vector3 vector4 = Vector3Extensions.Extend2D(position, position2, 300f);
Vector3 toPosition3 = (position2.Distance2D(vector3, false) < position2.Distance2D(vector4, false)) ? vector3 : vector4;
return(this.UseAbility(targetManager, comboSleeper, toPosition3));
}
return(false);
}
public override bool ShouldCast(Unit9 target)
{
if (this.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.HasModifier(this.Debuff.DebuffModifierName) && !(this.Debuff is INuke))
{
return(false);
}
if (this.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Debuff.UnitTargetCast)
{
return(false);
}
var immobile = target.GetImmobilityDuration();
if (immobile <= 0 || immobile + 0.05f > this.Debuff.GetHitTime(target))
{
return(false);
}
}
if (target.IsRooted && !this.Ability.UnitTargetCast && target.GetImmobilityDuration() <= 0)
{
return(false);
}
return(true);
}
// Token: 0x060003E6 RID: 998 RVA: 0x00015B70 File Offset: 0x00013D70
public override bool ShouldCast(TargetManager targetManager)
{
if (!base.ShouldCast(targetManager))
{
return(false);
}
Unit9 target = targetManager.Target;
return(target.Distance(base.Owner) <= 400f || target.GetImmobilityDuration() >= 2f);
}
// Token: 0x06000A33 RID: 2611 RVA: 0x0002C550 File Offset: 0x0002A750
public override bool ShouldCast(TargetManager targetManager)
{
Unit9 target = targetManager.Target;
bool isVisible = target.IsVisible;
if (base.Ability.UnitTargetCast && !isVisible)
{
return(false);
}
if (isVisible)
{
if (this.visibleSleeper.IsSleeping(target.Handle))
{
return(false);
}
Modifier modifier = target.GetModifier(this.Debuff.DebuffModifierName);
if (modifier != null)
{
float num = modifier.RemainingTime - base.Ability.GetHitTime(target);
if (num > 0f)
{
this.debuffSleeper.Sleep(target.Handle, num);
return(false);
}
}
}
else
{
this.visibleSleeper.Sleep(target.Handle, 0.1f);
if (this.debuffSleeper.IsSleeping(target.Handle))
{
return(false);
}
}
if (base.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
if (target.IsDarkPactProtected)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Debuff.UnitTargetCast)
{
return(false);
}
if (!this.ChainStun(target, true))
{
return(false);
}
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
// Token: 0x06000899 RID: 2201 RVA: 0x00026E64 File Offset: 0x00025064
public override bool ShouldCast(Unit9 target)
{
if (!base.ShouldCast(target))
{
return(false);
}
if (target.IsStunned || target.IsRooted || target.IsHexed)
{
return(target.GetImmobilityDuration() > 0f);
}
return(target.HasModifier("modifier_skywrath_mage_concussive_shot_slow") || target.Speed < 250f);
}
// Token: 0x060008EB RID: 2283 RVA: 0x00028110 File Offset: 0x00026310
protected virtual bool ChainStun(Unit9 target)
{
INuke nuke;
if ((nuke = (this.Disable as INuke)) != null && (float)nuke.GetDamage(target) > target.Health)
{
return(true);
}
float immobilityDuration = target.GetImmobilityDuration();
return(immobilityDuration > 0f && this.Disable.GetHitTime(target) + 0.05f > immobilityDuration);
}
private bool CheckEnemy(Unit9 enemy)
{
if (!this.settings.IsHeroEnabled(enemy.Name))
{
return(false);
}
if (enemy.IsReflectingDamage)
{
return(false);
}
if (this.settings.OnImmobileOnly)
{
var immobileDuration = enemy.GetImmobilityDuration();
if (immobileDuration <= 0)
{
return(false);
}
var time = this.Ability.GetHitTime(enemy.Position);
if (time * 0.8f > immobileDuration)
{
return(false);
}
if (enemy.IsInvulnerable && immobileDuration > time * 0.9f)
{
return(false);
}
}
else if (enemy.IsInvulnerable)
{
return(false);
}
if (!this.Ability.CanHit(enemy))
{
return(false);
}
if (enemy.Health > this.Nuke.GetDamage(enemy))
{
return(false);
}
if (this.Ability.UnitTargetCast && enemy.IsBlockingAbilities)
{
return(false);
}
return(true);
}
// 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);
}
// Token: 0x06000888 RID: 2184 RVA: 0x00026A54 File Offset: 0x00024C54
public override bool ShouldCast(Unit9 target)
{
if (base.Ability.UnitTargetCast && !target.IsVisible)
{
return(false);
}
if (target.IsReflectingDamage)
{
return(false);
}
if (base.Ability.BreaksLinkens && target.IsBlockingAbilities)
{
return(false);
}
int damage = this.Nuke.GetDamage(target);
if (damage <= 0)
{
return(false);
}
if ((target.IsStunned || target.IsHexed) && base.Ability is IDisable && (float)damage < target.Health)
{
return(false);
}
if (target.IsInvulnerable)
{
if (this.Nuke.UnitTargetCast)
{
return(false);
}
float immobilityDuration = target.GetImmobilityDuration();
if (immobilityDuration <= 0f || immobilityDuration + 0.05f > this.Nuke.GetHitTime(target))
{
return(false);
}
}
return(!target.IsRooted || base.Ability.UnitTargetCast || target.GetImmobilityDuration() > 0f);
}
public override bool ShouldCast(Unit9 target)
{
if (!base.ShouldCast(target))
{
return(false);
}
if (target.GetImmobilityDuration() < 1f)
{
return(false);
}
return(true);
}
// 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);
}
protected virtual bool ChainStun(Unit9 target)
{
if (this.Disable is INuke nuke && nuke.GetDamage(target) > target.Health)
{
return(true);
}
var immobile = target.GetImmobilityDuration();
if (immobile <= 0)
{
return(false);
}
return(this.Disable.GetHitTime(target) + 0.05f > immobile);
}
// Token: 0x060009DB RID: 2523 RVA: 0x0002ADA4 File Offset: 0x00028FA4
protected override bool ChainStun(Unit9 target, bool invulnerability)
{
float num = invulnerability ? target.GetInvulnerabilityDuration() : target.GetImmobilityDuration();
if (num <= 0f)
{
return(false);
}
float num2 = base.Ability.GetHitTime(target) + this.iceBlast.GetReleaseFlyTime(target.Position);
if (target.IsInvulnerable)
{
num2 -= 0.1f;
}
return(num2 > num);
}
// Token: 0x06000A60 RID: 2656 RVA: 0x0002CB78 File Offset: 0x0002AD78
protected virtual bool ChainStun(Unit9 target, bool invulnerability)
{
float num = invulnerability ? target.GetInvulnerabilityDuration() : target.GetImmobilityDuration();
if (num <= 0f)
{
return(false);
}
float num2 = this.Ability.GetHitTime(target);
if (target.IsInvulnerable)
{
num2 -= 0.1f;
}
return(num2 > num);
}
protected override bool ChainStun(Unit9 target, bool invulnerability)
{
var immobile = invulnerability ? target.GetInvulnerabilityDuration() : target.GetImmobilityDuration();
if (immobile <= 0)
{
return(false);
}
var hitTime = this.Ability.GetHitTime(target) + 0.5f;
if (target.IsInvulnerable)
{
hitTime -= 0.1f;
}
return(hitTime > immobile);
}
public bool CanHit(Unit9 target, IComboModeMenu comboMenu)
{
if (comboMenu?.IsAbilityEnabled(this.Ability) != false)
{
return(false);
}
if (!this.Ability.CanBeCasted())
{
return(false);
}
if (!this.Ability.CanHit(target))
{
return(false);
}
if (target.IsReflectingDamage)
{
return(false);
}
var damage = this.Ability.GetDamage(target);
if (damage <= 0)
{
return(false);
}
if (target.IsInvulnerable)
{
if (!this.ChainStun(target, true))
{
return(false);
}
}
if (target.IsRooted && !this.Ability.UnitTargetCast && target.GetImmobilityDuration() <= 0)
{
return(false);
}
return(true);
}
// Token: 0x060005BE RID: 1470 RVA: 0x0001CC0C File Offset: 0x0001AE0C
public override bool ShouldConditionCast(TargetManager targetManager, IComboModeMenu menu, List <UsableAbility> usableAbilities)
{
Unit9 target = targetManager.Target;
float immobilityDuration = target.GetImmobilityDuration();
if (immobilityDuration > 0f)
{
UsableAbility usableAbility = usableAbilities.Find((UsableAbility x) => x.Ability.Id == AbilityId.leshrac_split_earth);
if (usableAbility == null)
{
return(true);
}
if (immobilityDuration < usableAbility.Ability.GetHitTime(target) + base.Ability.GetHitTime(target))
{
return(false);
}
}
return(true);
}
// Token: 0x06000656 RID: 1622 RVA: 0x0001ED0C File Offset: 0x0001CF0C
public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
{
AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
if (abilityHelper.UseAbility(this.force, 550f, 400f))
{
return(true);
}
if (abilityHelper.UseAbilityIfAny(this.euls, new UsableAbility[]
{
this.stomp,
this.hammer
}))
{
return(true);
}
if (abilityHelper.UseAbility(this.atos, true))
{
return(true);
}
if (abilityHelper.UseAbility(this.spirit, true))
{
return(true);
}
if (abilityHelper.UseAbilityIfNone(this.stomp, new UsableAbility[]
{
this.euls
}))
{
return(true);
}
if (abilityHelper.CanBeCasted(this.hammer, false, false, true, true))
{
Unit9 target = targetManager.Target;
if (target.GetImmobilityDuration() > this.hammer.Ability.GetHitTime(target) - 0.5f && abilityHelper.UseAbility(this.hammer, true))
{
return(true);
}
}
return(!abilityHelper.CanBeCasted(this.euls, true, true, true, true) && !abilityHelper.CanBeCasted(this.stomp, false, false, true, true) && abilityHelper.UseAbilityIfNone(this.splitter, new UsableAbility[0]));
}
// Token: 0x06000377 RID: 887 RVA: 0x00013C48 File Offset: 0x00011E48
public override bool ShouldCast(TargetManager targetManager)
{
if (!base.ShouldCast(targetManager))
{
return(false);
}
Unit9 target = targetManager.Target;
if (target.Speed <= 200f)
{
return(true);
}
if (target.GetImmobilityDuration() < 0.3f)
{
float num = base.Ability.Radius / target.Speed + 0.3f;
if ((float)base.Ability.GetDamage(target) * num < target.Health)
{
return(false);
}
}
return(true);
}
// Token: 0x06000378 RID: 888 RVA: 0x00013CB8 File Offset: 0x00011EB8
public override bool UseAbility(TargetManager targetManager, Sleeper comboSleeper, bool aoe)
{
Unit9 target = targetManager.Target;
if (base.Owner.HasAghanimsScepter && (target.GetImmobilityDuration() > 0f || !target.IsMoving) && !targetManager.EnemyHeroes.Any((Unit9 x) => !x.Equals(target) && x.Distance(target) < 900f))
{
Vector3 vector = target.InFront(base.Ability.Radius + (float)(target.IsMoving ? 30 : 10), 0f, true);
if (base.Owner.Distance(vector) > base.Ability.CastRange)
{
return(false);
}
if (!base.Ability.UseAbility(vector, false, false))
{
return(false);
}
}
else
{
PredictionInput9 predictionInput = base.Ability.GetPredictionInput(target, null);
predictionInput.Delay += 0.3f;
PredictionOutput9 predictionOutput = base.Ability.GetPredictionOutput(predictionInput);
if (predictionOutput.HitChance < 1)
{
return(false);
}
if (!base.Ability.UseAbility(predictionOutput.CastPosition, false, false))
{
return(false);
}
}
float castDelay = base.Ability.GetCastDelay(targetManager.Target);
comboSleeper.Sleep(castDelay);
base.Sleeper.Sleep(castDelay + 0.5f);
base.OrbwalkSleeper.Sleep(castDelay);
return(true);
}
