private async Task Kill(CancellationToken token = new CancellationToken())
{
var enemies = EntityManager <Hero> .Entities
.Where(x => Owner.Team != x.Team && x.IsValid && !x.IsIllusion && x.IsAlive && x.Distance2D(Owner) < 400)
.OrderBy(e => e.Distance2D(Owner))
.ToList();
if (!enemies.Any())
{
return;
}
if (!Owner.CanCast())
{
return;
}
var threshold = R.GetAbilityData("kill_threshold");
foreach (var enemy in enemies)
{
if (enemy.Modifiers.Any(m => m.Name == "modifier_skeleton_king_reincarnation_scepter_active"))
{
continue;
}
if (enemy.Health + (enemy.HealthRegeneration / 2) >= threshold)
{
continue;
}
if (UnitExtensions.IsLinkensProtected(enemy))
{
continue;
}
if (!R.CanBeCasted(enemy))
{
continue;
}
R.UseAbility(enemy);
await Task.Delay((int)(R.FindCastPoint() * 1000 + Game.Ping), token);
}
}
protected override void OnActivate()
{
me = Context.Owner as Hero;
GameDispatcher.OnIngameUpdate += GameDispatcher_OnIngameUpdate;
Q = ExUnit.GetAbilityById(me, AbilityId.storm_spirit_static_remnant);
W = ExUnit.GetAbilityById(me, AbilityId.storm_spirit_electric_vortex);
R = ExUnit.GetAbilityById(me, AbilityId.storm_spirit_ball_lightning);
E = ExUnit.GetAbilityById(me, AbilityId.storm_spirit_overload);
if (Config.DrawingDamageEnabled.Value)
{
Drawing.OnDraw += DrawingDamagePanel;
}
context.Inventory.Attach(this);
base.OnActivate();
}
public virtual async Task KillStealAsync()
{
var damageBlast = Blast.GetAbilityData("blast_damage");
damageBlast *= GetSpellAmp();
bool comboMana = Blast.GetManaCost(Blast.Level - 1) + Decrepify.GetManaCost(Decrepify.Level - 1) <
Owner.Mana;
var decrepifyKillable =
EntityManager <Hero> .Entities.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
x.Health < damageBlast *(1 - x.MagicDamageResist) &&
Decrepify.CanBeCasted(x) && Blast.CanBeCasted() &&
!UnitExtensions.IsMagicImmune(x) && comboMana);
var blastKillable =
EntityManager <Hero> .Entities.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
x.Health < damageBlast *(1 - x.MagicDamageResist) &&
Blast.CanBeCasted() && !UnitExtensions.IsMagicImmune(x) &&
Ensage.SDK.Extensions.EntityExtensions.Distance2D(Owner, x.NetworkPosition) <= 400);
if (decrepifyKillable != null)
{
Decrepify.UseAbility(decrepifyKillable);
await Await.Delay(GetAbilityDelay(decrepifyKillable, Decrepify));
Blast.UseAbility(decrepifyKillable);
await Await.Delay(GetAbilityDelay(decrepifyKillable, Decrepify));
}
if (blastKillable != null)
{
Blast.UseAbility(blastKillable.NetworkPosition);
await Await.Delay(GetAbilityDelay(blastKillable, Blast));
}
}
public Hero GetTarget(bool otherChecks = true)
{
if (_globalTarget != null && _globalTarget.IsAlive)
{
if (otherChecks)
{
if (!Owner.IsValidOrbwalkingTarget(_globalTarget) &&
!UnitExtensions.HasModifier(Owner, "modifier_item_hurricane_pike_range"))
{
return(null);
}
}
return(_globalTarget);
}
_globalTarget = TargetSelector.ClosestToMouse(Owner);
if (_globalTarget != null &&
(!otherChecks || Owner.IsValidOrbwalkingTarget(_globalTarget) ||
UnitExtensions.HasModifier(Owner, "modifier_item_hurricane_pike_range")))
{
return(_globalTarget);
}
return(null);
}
public virtual async Task KillStealAsync(CancellationToken args)
{
float RemnantAutoDamage = this.Remnant.GetAbilityData("static_remnant_damage") + this.Overload.GetDamage(Overload.Level - 1);
RemnantAutoDamage += (Owner.MinimumDamage + Owner.BonusDamage);
RemnantAutoDamage *= GetSpellAmp();
float AutoDamage = this.Overload.GetDamage(Overload.Level - 1);
AutoDamage += (Owner.MinimumDamage + Owner.BonusDamage);
AutoDamage *= GetSpellAmp();
var RemnantAutokillableTar =
ObjectManager.GetEntitiesParallel <Hero>()
.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
this.Remnant.CanBeCasted() && this.Remnant.CanHit(x) &&
x.Health < (RemnantAutoDamage * (1 - x.MagicDamageResist)) &&
!UnitExtensions.IsMagicImmune(x) &&
x.Distance2D(this.Owner) <= 235);
var AutokillableTar =
ObjectManager.GetEntitiesParallel <Hero>()
.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
x.Health < AutoDamage * (1 - x.MagicDamageResist) &&
!UnitExtensions.IsMagicImmune(x) &&
x.Distance2D(this.Owner) <= 480);
if (UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_overload") && AutokillableTar != null)
{
Owner.Attack(AutokillableTar);
await Await.Delay(500);
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
Target = this.TargetSelector.Active.GetTargets().FirstOrDefault(x => !x.IsInvulnerable());
var allTargets = this.TargetSelector.Active.GetTargets().FirstOrDefault();
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
var myHpThreshold = this.Config.SelfHPDrain.Item.GetValue <Slider>().Value;
var postDrainHp = this.Config.PostDrainHP.Item.GetValue <Slider>().Value;
var allyPostDrain = this.Config.HealAllyTo.Item.GetValue <Slider>().Value;
var healThreshold = this.Config.DrainHP.Item.GetValue <Slider>().Value;
var wardTars = this.Config.WardTargets.Item.GetValue <Slider>().Value;
//warnings
if (myHpThreshold < postDrainHp && this.Config.AbilityToggler.Value.IsEnabled(this.Drain.Name))
{
Log.Debug(
"Post drain hp is higher than your hp threshold to begin healing, please change this or the script won't work.");
return;
}
if (healThreshold > allyPostDrain && this.Config.AbilityToggler.Value.IsEnabled(this.Drain.Name))
{
Log.Debug("Your ally's post heal threshold is lower than their heal threshold, please fix this.");
return;
}
if (!silenced)
{
try
{
var tempHealTarget =
EntityManager <Hero> .Entities.FirstOrDefault(
x =>
x.IsAlive && x.Team == this.Owner.Team && x != Owner && !x.IsIllusion &&
((float)x.Health / (float)x.MaximumHealth) * 100 < healThreshold &&
!UnitExtensions.IsMagicImmune(x) && Config.HealTargetHeroes.Value.IsEnabled(x.Name));
var myHealth = (float)Owner.Health / (float)Owner.MaximumHealth * 100;
if (tempHealTarget != null)
{
HealTarget = tempHealTarget;
}
if (HealTarget != null)
{
if (HealTarget != null && this.Config.AbilityToggler.Value.IsEnabled(this.Drain.Name) &&
!UnitExtensions.IsChanneling(Owner) && myHealth >= myHpThreshold &&
HealTarget.Distance2D(this.Owner) <= Drain.CastRange &&
HealTarget.HealthPercent() * 100 < healThreshold)
{
this.Drain.UseAbility(HealTarget);
IsHealing = true;
await Await.Delay(GetAbilityDelay(HealTarget, Drain), token);
}
//Stop Healing; There is no hidden modifier/any way to check if we are healing a target.
if ((UnitExtensions.IsChanneling(Owner) && myHealth <= postDrainHp) && IsHealing)
{
Owner.Stop();
IsHealing = false;
}
if (HealTarget != null && IsHealing &&
(HealTarget.HealthPercent() >= ((float)allyPostDrain / 100)))
{
Owner.Stop();
IsHealing = false;
}
if (HealTarget == null && IsHealing)
{
Owner.Stop();
IsHealing = false;
}
}
}
catch (Exception)
{
// ignore
}
}
if (IsHealing)
{
return;
}
if ((this.BlinkDagger != null) &&
(this.BlinkDagger.Item.IsValid) &&
Target != null && Owner.Distance2D(Target) <= 1200 + sliderValue && !(Owner.Distance2D(Target) <= 400) &&
this.BlinkDagger.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name) &&
!UnitExtensions.IsChanneling(Owner))
{
var l = (this.Owner.Distance2D(Target) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = Target.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
Log.Debug("Using BlinkDagger");
this.BlinkDagger.UseAbility(position);
await Await.Delay(this.GetItemDelay(position) + (int)Game.Ping, token);
}
if (!silenced && Target != null)
{
var targets =
EntityManager <Hero> .Entities.Where(
x =>
x.IsValid && x.Team != this.Owner.Team && !x.IsIllusion &&
!UnitExtensions.IsMagicImmune(x) &&
x.Distance2D(this.Owner) <= Ward.GetAbilityData("radius"))
.ToList();
if (targets.Count >= wardTars && this.Ward.CanBeCasted() && !UnitExtensions.IsChanneling(Owner) &&
this.Config.AbilityToggler.Value.IsEnabled(this.Ward.Name))
{
Log.Debug($"Using Ward");
Ward.UseAbility(Owner.NetworkPosition);
await Await.Delay(GetAbilityDelay(Owner, Ward), token);
}
try
{
// var thresholdTars = this.Config.WardTargets.Item.GetValue<Slider>();
var manaDecrepify = Decrepify.GetManaCost(Decrepify.Level - 1);
var manaBlast = Blast.GetManaCost(Blast.Level - 1);
// var manaDrain = Drain.GetManaCost(Drain.Level - 1);
if (Decrepify.CanBeCasted() && Target != null && Decrepify.CanHit(Target) &&
this.Config.AbilityToggler.Value.IsEnabled(this.Decrepify.Name) &&
this.Owner.Mana >= manaBlast + manaDecrepify &&
!UnitExtensions.IsChanneling(Owner) &&
Target.IsAlive)
{
this.Decrepify.UseAbility(Target);
await Await.Delay(GetAbilityDelay(Target, Decrepify), token);
}
if (this.Blast.CanBeCasted() &&
this.Config.AbilityToggler.Value.IsEnabled(this.Blast.Name) &&
(!this.Decrepify.CanBeCasted() || manaBlast > Owner.Mana - manaDecrepify) &&
!UnitExtensions.IsChanneling(Owner) &&
Target != null && Target.IsAlive)
{
var delay = Blast.GetAbilityData("delay") + Blast.GetCastPoint();
var blastTargets =
EntityManager <Hero> .Entities.OrderBy(x => x == allTargets).Where(
x =>
x.IsValid && x.IsVisible && x.Team != Owner.Team && !x.IsIllusion &&
!UnitExtensions.IsMagicImmune(x)).ToList();
var blastCastRange = Blast.CastRange;
if (blastTargets == null)
{
return;
}
var input =
new PredictionInput(
Owner,
Target,
delay,
float.MaxValue,
blastCastRange,
400,
PredictionSkillshotType.SkillshotCircle,
true,
blastTargets)
{
CollisionTypes = CollisionTypes.None
};
var output = Prediction.GetPrediction(input);
if (output.HitChance >= HitChance.Medium)
{
Log.Debug($"Using Blast");
this.Blast.UseAbility(output.CastPosition);
await Await.Delay(GetAbilityDelay(Target.Position, this.Blast), token);
}
}
}
catch (Exception)
{
// ignored
}
}
if (this.BloodThorn != null &&
this.BloodThorn.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.BloodThorn.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
Log.Debug("Using Bloodthorn");
this.BloodThorn.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if ((this.SheepStick != null) &&
(this.SheepStick.Item.IsValid) &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.SheepStick.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_sheepstick"))
{
Log.Debug("Using Sheepstick");
this.SheepStick.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Dagon != null &&
this.Dagon.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.Dagon.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(Dagon5.Item.Name))
{
Log.Debug("Using Dagon");
this.Dagon.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Orchid != null &&
this.Orchid.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.Orchid.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_orchid"))
{
Log.Debug("Using Orchid");
this.Orchid.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.RodofAtos != null &&
this.RodofAtos.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.RodofAtos.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_rod_of_atos"))
{
Log.Debug("Using RodofAtos");
this.RodofAtos.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.VeilofDiscord != null &&
this.VeilofDiscord.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.VeilofDiscord.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_veil_of_discord"))
{
Log.Debug("Using VeilofDiscord");
this.VeilofDiscord.UseAbility(Target.Position);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.HurricanePike != null &&
this.HurricanePike.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.HurricanePike.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_hurricane_pike"))
{
Log.Debug("Using HurricanePike");
this.HurricanePike.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.ShivasGuard != null &&
this.ShivasGuard.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.ShivasGuard.Item.CanBeCasted() &&
Owner.Distance2D(Target) <= 900 &&
this.Config.ItemToggler.Value.IsEnabled("item_shivas_guard"))
{
Log.Debug("Using Shiva's Guard");
this.ShivasGuard.UseAbility();
await Await.Delay((int)Game.Ping, token);
}
if (this.Mjollnir != null &&
this.Mjollnir.Item.IsValid &&
Target != null && !UnitExtensions.IsChanneling(Owner) &&
this.Mjollnir.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_mjollnir"))
{
Log.Debug("Using Mjollnir");
this.Mjollnir.UseAbility(Owner);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Config.AbilityToggler.Value.IsEnabled(this.Blast.Name) &&
this.Config.AbilityToggler.Value.IsEnabled(this.Decrepify.Name))
{
if (!silenced && this.Drain.CanBeCasted() &&
!this.Blast.CanBeCasted() && !this.Decrepify.CanBeCasted() &&
this.Config.AbilityToggler.Value.IsEnabled(this.Drain.Name) &&
!UnitExtensions.IsChanneling(Owner) &&
Target != null && Target.IsAlive)
{
Log.Debug($"Using Drain 1");
this.Drain.UseAbility(Target);
await Await.Delay(GetAbilityDelay(Target, Drain) + 50, token);
}
}
else
{
if (!silenced && this.Drain.CanBeCasted() &&
this.Config.AbilityToggler.Value.IsEnabled(this.Drain.Name) &&
!UnitExtensions.IsChanneling(Owner) &&
Target != null && Target.IsAlive)
{
Log.Debug($"Using Drain 2");
this.Drain.UseAbility(Target);
await Await.Delay(GetAbilityDelay(Target, Drain) + 50, token);
}
}
if (Target != null && !Owner.IsValidOrbwalkingTarget(Target) && !UnitExtensions.IsChanneling(this.Owner))
{
Orbwalker.Move(Game.MousePosition);
await Await.Delay(50, token);
}
else
{
Orbwalker.OrbwalkTo(Target);
}
await Await.Delay(50, token);
}
public override async Task ExecuteAsync(CancellationToken token)
{
try
{
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
if (Config.TargetItem.Value.SelectedValue.Contains("Lock") && Context.TargetSelector.IsActive &&
(!CanExecute || EnemyHero == null || !EnemyHero.IsValid || !EnemyHero.IsAlive))
{
EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
else if (Config.TargetItem.Value.SelectedValue.Contains("Default") && Context.TargetSelector.IsActive)
{
EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
var Silenced = UnitExtensions.IsSilenced(base.Owner);
if (EnemyHero != null)
{
if (this.BlinkDagger != null &&
(this.BlinkDagger.CanBeCasted &&
base.Owner.Distance2D(EnemyHero) <= 1200 + sliderValue &&
!(base.Owner.Distance2D(EnemyHero) <= 400) &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name)))
{
var l = (this.Owner.Distance2D(EnemyHero) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = EnemyHero.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
this.BlinkDagger.UseAbility(position);
await Await.Delay(BlinkDagger.GetCastDelay(position), token);
}
if (!Silenced)
{
if (this.Config.AbilityToggler.Value.IsEnabled(this.Blast.Name) && this.Blast.CanBeCasted() && this.Blast.CanHit(EnemyHero))
{
this.Blast.UseAbility(EnemyHero);
await Await.Delay(this.GetAbilityDelay(base.Owner, Blast), token);
}
}
if (this.Basher != null &&
base.Owner.IsAttacking() &&
this.Basher.CanBeCasted &&
this.Basher.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled(Basher.ToString()))
{
this.Basher.UseAbility(EnemyHero);
await Await.Delay(Basher.GetCastDelay(EnemyHero), token);
}
if (this.Mjollnir != null &&
base.Owner.IsAttacking() &&
this.Mjollnir.CanBeCasted &&
this.Config.ItemToggler.Value.IsEnabled(Mjollnir.ToString()))
{
this.Mjollnir.UseAbility(base.Owner);
await Await.Delay(Mjollnir.GetCastDelay(Owner), token);
}
if (!UnitExtensions.IsMagicImmune(EnemyHero) &&
!EnemyHero.IsInvulnerable() &&
!UnitExtensions.HasModifier(EnemyHero, "modifier_winter_wyvern_winters_curse"))
{
if (this.BloodThorn != null &&
this.BloodThorn.CanBeCasted &&
this.BloodThorn.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.ToString()))
{
this.BloodThorn.UseAbility(EnemyHero);
await Await.Delay(BloodThorn.GetCastDelay(EnemyHero), token);
}
if (this.Medalion1 != null &&
this.Medalion1.CanBeCasted &&
this.Medalion1.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled(this.Medalion1.ToString()))
{
this.Medalion1.UseAbility(EnemyHero);
await Await.Delay(Medalion1.GetCastDelay(EnemyHero), token);
}
if (this.Medallion2 != null &&
this.Medallion2.CanBeCasted &&
this.Medallion2.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled(this.Medallion2.ToString()))
{
this.Medallion2.UseAbility(EnemyHero);
await Await.Delay(Medallion2.GetCastDelay(EnemyHero), token);
}
if (this.DiffBlade != null &&
this.DiffBlade.CanBeCasted &&
this.DiffBlade.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled("item_diffusal_blade_2"))
{
this.DiffBlade.UseAbility(EnemyHero);
await Await.Delay(DiffBlade.GetCastDelay(EnemyHero), token);
}
if (this.Orchid != null &&
this.Orchid.CanBeCasted &&
this.Orchid.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled(Orchid.ToString()))
{
this.Orchid.UseAbility(EnemyHero);
await Await.Delay(Orchid.GetCastDelay(EnemyHero), token);
}
if (this.Heaven != null &&
base.Owner.IsAttacking() &&
this.Heaven.CanBeCasted &&
this.Heaven.CanHit(EnemyHero) &&
this.Config.ItemToggler.Value.IsEnabled(Heaven.ToString()))
{
this.Heaven.UseAbility(EnemyHero);
await Await.Delay(Heaven.GetCastDelay(EnemyHero), token);
}
}
if (EnemyHero != null && (EnemyHero.IsInvulnerable() || UnitExtensions.IsAttackImmune(EnemyHero)))
{
Orbwalker.Move(Game.MousePosition);
}
else if (EnemyHero != null)
{
Orbwalker.OrbwalkTo(EnemyHero);
}
}
else
{
Orbwalker.Move(Game.MousePosition);
}
}
catch (TaskCanceledException)
{
// canceled
}
catch (Exception e)
{
Log.Error(e);
}
}
public bool CanAttack(Unit target)
{
var rotationTime = Owner.TurnTime(target.NetworkPosition);
return(UnitExtensions.CanAttack(Owner) && Game.RawGameTime + 0.1f + rotationTime + Game.Ping / 2000f - LastAttackTime > 1f / Owner.AttacksPerSecond);
}
public override async Task ExecuteAsync(CancellationToken token)
{
var target = this.TargetSelector.Active.GetTargets().FirstOrDefault(x => !x.IsInvulnerable() && x.Distance2D(this.Owner) <= this.Owner.AttackRange * 2);
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
if ((this.BlinkDagger != null) &&
(this.BlinkDagger.Item.IsValid) &&
target != null && Owner.Distance2D(target) <= 1200 + sliderValue && !(Owner.Distance2D(target) <= 400) &&
this.BlinkDagger.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name))
{
var l = (this.Owner.Distance2D(target) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = target.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
Log.Debug("Using BlinkDagger");
this.BlinkDagger.UseAbility(position);
await Await.Delay(this.GetItemDelay(target), token);
}
if (!silenced)
{
try
{
var targets =
EntityManager <Hero> .Entities.Where(
x => x.IsValid && x.Team != this.Owner.Team && !x.IsIllusion && x.Distance2D(this.Owner) <= 700)
.ToList();
var me = this.Owner as Hero;
foreach (var ultiTarget in targets)
{
if (this.Config.AbilityToggler.Value.IsEnabled(this.Ulti.Name) && this.Ulti.CanBeCasted(ultiTarget))
{
var ultiDamage =
Math.Floor(
this.Ulti.GetAbilitySpecialData("damage_multiplier") *
(me.TotalIntelligence - ultiTarget.TotalIntelligence) *
(1 - ultiTarget.MagicDamageResist));
if (ultiTarget.Health > ultiDamage)
{
continue;
}
var delay = this.GetAbilityDelay(ultiTarget, this.Ulti);
var radius = this.Ulti.GetAbilitySpecialData("radius");
var input =
new PredictionInput(
this.Owner,
ultiTarget,
delay,
float.MaxValue,
700,
radius,
PredictionSkillshotType.SkillshotCircle,
true)
{
CollisionTypes = CollisionTypes.None
};
// Log.Debug($"Owner: {input.Owner.Name}");
// Log.Debug($"Delay: {input.Delay}");
// Log.Debug($"Range: {input.Range}");
// Log.Debug($"Speed: {input.Speed}");
// Log.Debug($"Radius: {input.Radius}");
// Log.Debug($"Type: {input.PredictionSkillshotType}");
var output = this.Prediction.GetPrediction(input);
var amount = output.AoeTargetsHit.Count;
// Log.Debug($"{output.HitChance}");
if (output.HitChance >= HitChance.Medium && this.Config.MinimumTargetToUlti.Item.GetValue <int>() >= amount)
{
Log.Debug(
$"Using Ulti on {amount}!");
this.Ulti.UseAbility(output.CastPosition);
await Await.Delay(delay + (int)Game.Ping, token);
}
}
}
}
catch (Exception e)
{
Log.Debug($"{e}");
}
if (this.Orb != null && this.Orb.IsValid && this.Config.AbilityToggler.Value.IsEnabled(this.Orb.Name) && this.Orb.CanBeCasted(target) && !this.Orb.IsAutoCastEnabled)
{
Log.Debug($"Toggling Arcane Orb on because {target != null}");
this.Orb.ToggleAutocastAbility();
await Await.Delay(100 + (int)Game.Ping, token);
}
// Toggle off if target is null
else if (this.Orb != null && this.Orb.IsValid && this.Config.AbilityToggler.Value.IsEnabled(this.Orb.Name) && target == null && this.Orb.IsAutoCastEnabled)
{
Log.Debug($"Toggling Arcane Orb off because target is null");
this.Orb.ToggleAutocastAbility();
await Await.Delay(100 + (int)Game.Ping, token);
}
}
if ((this.BloodThorn != null) &&
this.BloodThorn.Item.IsValid &&
target != null &&
this.BloodThorn.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
Log.Debug("Using Bloodthorn");
this.BloodThorn.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.SheepStick != null) &&
this.SheepStick.Item.IsValid &&
target != null &&
this.SheepStick.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_sheepstick"))
{
Log.Debug("Using Sheepstick");
this.SheepStick.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.Orchid != null) &&
this.Orchid.Item.IsValid && target != null &&
this.Orchid.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_orchid"))
{
Log.Debug("Using Orchid");
this.Orchid.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.RodofAtos != null) &&
this.RodofAtos.Item.IsValid &&
target != null &&
this.RodofAtos.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_rod_of_atos"))
{
Log.Debug("Using RodofAtos");
this.RodofAtos.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.VeilofDiscord != null) &&
this.VeilofDiscord.Item.IsValid &&
target != null &&
this.VeilofDiscord.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_veil_of_discord"))
{
Log.Debug("Using VeilofDiscord");
this.VeilofDiscord.UseAbility(target.Position);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.HurricanePike != null) && (double)(this.Owner.Health / this.Owner.MaximumHealth) * 100 <=
(double)Config.HurricanePercentage.Item.GetValue <Slider>().Value&&
this.HurricanePike.Item.IsValid &&
target != null &&
this.HurricanePike.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_hurricane_pike"))
{
Log.Debug("Using HurricanePike");
this.HurricanePike.UseAbility(target);
await Await.Delay(this.GetItemDelay(target), token);
}
if ((this.ShivasGuard != null) &&
this.ShivasGuard.Item.IsValid &&
target != null && this.Owner.Distance2D(target) <= 900 &&
this.ShivasGuard.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_shivas_guard"))
{
Log.Debug("Using Shivas");
this.ShivasGuard.UseAbility();
await Await.Delay(20 + (int)Game.Ping, token);
}
if (this.Orbwalker.OrbwalkTo(target))
{
return;
}
await Await.Delay(125, token);
}
public override async Task ExecuteAsync(CancellationToken token)
{
var casted = false;
// checks for items
if (this.manta != null && this.config.UseAbilities.Value.IsEnabled("item_manta") && this.manta.Item.CanBeCasted())
{
Log.Debug("Used manta");
this.manta.Item.UseAbility();
casted = true;
await Await.Delay(250 + (int)Game.Ping, token);
}
if (!casted && this.bottle != null && this.config.UseAbilities.Value.IsEnabled("item_bottle"))
{
var bottleItem = this.bottle.Item as Bottle;
if (bottleItem?.StoredRune == RuneType.Illusion)
{
Log.Debug("Used bottle");
bottleItem.UseAbility();
casted = true;
await Await.Delay(125 + (int)Game.Ping, token);
}
}
// check for spells
if (!casted)
{
if (this.mirrorImage != null && this.config.UseAbilities.Value.IsEnabled("naga_siren_mirror_image") && this.mirrorImage.CanBeCasted())
{
this.mirrorImage.UseAbility();
var delay = (int)((this.mirrorImage.GetCastPoint(0) + this.mirrorImage.AbilitySpecialData.First(x => x.Name == "invuln_duration").Value) * 1000.0f) + 250
+ (int)Game.Ping;
Log.Debug($"using mirror image with delay {delay}");
await Await.Delay(delay, token);
return;
}
if (this.conjureImage != null && this.config.UseAbilities.Value.IsEnabled("terrorblade_conjure_image") && this.conjureImage.CanBeCasted())
{
this.conjureImage.UseAbility();
var delay = (int)((this.conjureImage.GetCastPoint(0) * 1000.0f) + 250.0f) + (int)Game.Ping;
Log.Debug($"using conjure image with delay {delay}");
await Await.Delay(delay, token);
return;
}
if (this.doppelWalk != null && this.config.UseAbilities.Value.IsEnabled("phantom_lancer_doppelwalk") && this.doppelWalk.CanBeCasted())
{
var pos = Game.MousePosition - this.owner.Position;
if (pos.Length() > this.doppelWalk.CastRange)
{
pos.Normalize();
pos *= this.doppelWalk.CastRange;
}
this.doppelWalk.UseAbility(this.owner.Position + pos);
var delay = ((int)(this.doppelWalk.GetCastPoint(0) + this.doppelWalk.AbilitySpecialData.First(x => x.Name == "delay").Value) * 1000) + 250 + (int)Game.Ping;
Log.Debug($"using doppel walk with delay {delay}");
await Await.Delay(delay, token);
}
}
if (this.config.MoveHero)
{
// Log.Debug($"Move hero to position {Game.MousePosition}");
this.owner.Move(Game.MousePosition);
this.heroTargetDirection = Game.MousePosition - this.owner.Position;
}
else
{
this.heroTargetDirection = UnitExtensions.InFront(this.owner, 250) - this.owner.Position;
// Log.Debug($"Hero target dir {heroTargetDirection}");
}
this.illusionHandler.RunAsync();
await Await.Delay(125, token);
}
public override async Task ExecuteAsync(CancellationToken token)
{
try
{
if (Config.Target.Value.SelectedValue.Contains("Lock") && Context.TargetSelector.IsActive &&
(!CanExecute || EnemyHero == null || !EnemyHero.IsValid || !EnemyHero.IsAlive))
{
EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
else if (Config.Target.Value.SelectedValue.Contains("Default") && Context.TargetSelector.IsActive)
{
EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
var Silenced = UnitExtensions.IsSilenced(base.Owner);
var SliderData = this.Config.UseBlink.Item.GetValue <Slider>().Value;
var IsInvis = Ensage.SDK.Extensions.UnitExtensions.IsInvisible(this.Owner);
var WAbiCasted = Ensage.SDK.Extensions.UnitExtensions.HasModifier(Owner, "modifier_dark_willow_shadow_realm_buff");
var QAbiTargets = EntityManager <Hero> .Entities.OrderBy(x => x == EnemyHero).Where(x => x.IsValid && x.IsVisible && x.Team != Owner.Team && !x.IsIllusion && !UnitExtensions.IsMagicImmune(x)).ToList();
if (EnemyHero != null && !EnemyHero.IsInvulnerable() && !UnitExtensions.IsMagicImmune(EnemyHero))
{
if (this.QAbi.CanBeCasted && this.QAbi != null && !Silenced && this.Config.AbilityToggler.Value.IsEnabled(this.QAbi.Ability.Name) && this.QAbi.CanHit(EnemyHero) && !IsInvis)
{
QAbi.UseAbility(EnemyHero.Position);
/// await Await.Delay(QAbi.GetCastDelay(EnemyHero.Position), token);
await Await.Delay(this.GetAbilityDelay(this.Owner, QAbi), token);
}
if (!Silenced && this.EAbi != null && this.Config.AbilityToggler.Value.IsEnabled(this.EAbi.Ability.Name) && this.EAbi.CanBeCasted && !IsInvis && this.EAbi.CanHit(EnemyHero))
{
this.EAbi.Ability.UseAbility(EnemyHero);
await Await.Delay(this.GetAbilityDelay(this.Owner, EAbi), token);
}
if (!Silenced && this.DAbi != null && !IsInvis && this.Owner.IsInRange(EnemyHero, 300) && !IsInvis && this.DAbi.CanBeCasted && this.Config.AbilityToggler.Value.IsEnabled(this.DAbi.Ability.Name))
{
this.DAbi.Ability.UseAbility();
await Await.Delay(this.GetAbilityDelay(this.Owner, DAbi), token);
}
//
//
//
//
//
//
if (this.Blink != null && this.Blink.CanBeCasted && Owner.Distance2D(EnemyHero) <= 1200 + SliderData && !IsInvis && !(this.Owner.Distance2D(EnemyHero) <= 400) && this.Config.ItemToggler2.Value.IsEnabled(this.Blink.Item.Name))
{
var l = (this.Owner.Distance2D(EnemyHero) - SliderData) / SliderData;
var posA = this.Owner.Position;
var posB = EnemyHero.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
this.Blink.UseAbility(position);
await Await.Delay(Blink.GetCastDelay(position), token);
}
if (!UnitExtensions.IsMagicImmune(EnemyHero))
{
if (this.BloodThorn != null && this.BloodThorn.CanBeCasted && !IsInvis && !this.Owner.IsAttacking() && this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
this.BloodThorn.UseAbility(EnemyHero);
await Await.Delay(BloodThorn.GetCastDelay(EnemyHero), token);
}
if (this.Medalion1 != null && this.Medalion1.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && !this.Owner.IsAttacking() && this.Config.ItemToggler.Value.IsEnabled(this.Medalion1.Item.Name))
{
this.Medalion1.UseAbility(EnemyHero);
await Await.Delay(Medalion1.GetCastDelay(EnemyHero), token);
}
if (this.Medallion2 != null && this.Medallion2.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && !this.Owner.IsAttacking() && this.Config.ItemToggler.Value.IsEnabled(this.Medallion2.Item.Name))
{
this.Medallion2.UseAbility(EnemyHero);
await Await.Delay(Medallion2.GetCastDelay(EnemyHero), token);
}
if (this.SheepStick != null && this.SheepStick.CanBeCasted && !IsInvis && this.Config.ItemToggler.Value.IsEnabled(this.SheepStick.Item.Name))
{
this.SheepStick.UseAbility(EnemyHero);
await Await.Delay(SheepStick.GetCastDelay(EnemyHero), token);
}
if (this.Orchid != null && this.Orchid.CanBeCasted && !IsInvis && this.Config.ItemToggler.Value.IsEnabled(Orchid.Item.Name))
{
this.Orchid.UseAbility(EnemyHero);
await Await.Delay(Orchid.GetCastDelay(EnemyHero), token);
}
if (this.Mjollnir != null && this.Mjollnir.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && this.Config.ItemToggler2.Value.IsEnabled(Mjollnir.Item.Name))
{
this.Mjollnir.UseAbility(this.Owner);
await Await.Delay(Mjollnir.GetCastDelay(), token);
}
if (this.Veil_Of_Discord != null && this.Veil_Of_Discord.CanBeCasted && !IsInvis && this.Config.ItemToggler2.Value.IsEnabled(Veil_Of_Discord.Item.Name))
{
this.Veil_Of_Discord.UseAbility(EnemyHero.Position);
await Await.Delay(Veil_Of_Discord.GetCastDelay(), token);
}
if (this.Rod_Of_Atos != null && this.Rod_Of_Atos.CanBeCasted && !IsInvis && this.Config.ItemToggler2.Value.IsEnabled(Rod_Of_Atos.Item.Name))
{
this.Rod_Of_Atos.UseAbility(EnemyHero);
await Await.Delay(Rod_Of_Atos.GetCastDelay(), token);
}
}
if (EnemyHero != null && (EnemyHero.IsInvulnerable() || UnitExtensions.IsAttackImmune(EnemyHero)))
{
Orbwalker.Move(Game.MousePosition);
}
else if (EnemyHero != null)
{
Orbwalker.OrbwalkTo(EnemyHero);
}
}
else
{
Orbwalker.Move(Game.MousePosition);
}
}
catch (TaskCanceledException)
{
// canceled
}
catch (Exception e)
{
Log.Error(e);
}
}
private void OnUpdate()
{
if (RazeShort.Level <= 0)
{
return;
}
Razes = new List <Ability> {
RazeShort, RazeMedium, RazeLong
};
if (DrawRazeRange == true)
{
var raze1 = UnitExtensions.InFront(Owner, this.RazeShort.GetAbilitySpecialData("shadowraze_range"));
var raze2 = UnitExtensions.InFront(Owner, this.RazeMedium.GetAbilitySpecialData("shadowraze_range"));
var raze3 = UnitExtensions.InFront(Owner, this.RazeLong.GetAbilitySpecialData("shadowraze_range"));
var file = "materials/ensage_ui/particles/alert_range.vpcf";
Particle.AddOrUpdate(Owner, $"DrawRange_{1}", file, ParticleAttachment.AbsOrigin, RestartType.None, 0,
raze1,
1, new Vector3(255, 0, 0), 2, new Vector3(200, 255, 40));
Particle.AddOrUpdate(Owner, $"DrawRange_{2}", file, ParticleAttachment.AbsOrigin, RestartType.None, 0,
raze2,
1, new Vector3(255, 0, 0), 2, new Vector3(200, 255, 40));
Particle.AddOrUpdate(Owner, $"DrawRange_{3}", file, ParticleAttachment.AbsOrigin, RestartType.None, 0,
raze3,
1, new Vector3(255, 0, 0), 2, new Vector3(200, 255, 40));
var targets = EntityManager <Hero> .Entities.FirstOrDefault(
x => x.IsAlive && x.Team != this.Owner.Team &&
x.Distance2D(this.Owner) < 1500 && !x.IsIllusion);
if (targets != null && this.RazeShort.CanBeCasted() && !UnitExtensions.IsMagicImmune(targets) && !targets.IsInvulnerable() &&
CanHit(this.RazeShort, targets, GetRazeDelay(targets, RazeShort), true))
{
Particle.AddOrUpdate(Owner, $"DrawRange_{1}", file, ParticleAttachment.AbsOrigin, RestartType.None,
0,
raze1, 1, new Vector3(0, 255, 0), 2, new Vector3(200, 255, 40));
}
if (targets != null && this.RazeMedium.CanBeCasted() && !UnitExtensions.IsMagicImmune(targets) && !targets.IsInvulnerable() &&
CanHit(this.RazeMedium, targets, GetRazeDelay(targets, RazeMedium), true))
{
Particle.AddOrUpdate(Owner, $"DrawRange_{2}", file, ParticleAttachment.AbsOrigin, RestartType.None,
0,
raze2, 1, new Vector3(0, 255, 0), 2, new Vector3(200, 255, 40));
}
if (targets != null && this.RazeLong.CanBeCasted() && !UnitExtensions.IsMagicImmune(targets) && !targets.IsInvulnerable() &&
CanHit(this.RazeLong, targets, GetRazeDelay(targets, RazeLong), true))
{
Particle.AddOrUpdate(Owner, $"DrawRange_{3}", file, ParticleAttachment.AbsOrigin, RestartType.None,
0,
raze3, 1, new Vector3(0, 255, 0), 2, new Vector3(200, 255, 40));
}
}
else
{
Particle.Remove($"DrawRange_{1}");
Particle.Remove($"DrawRange_{2}");
Particle.Remove($"DrawRange_{3}");
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
Target = this.TargetSelector.Active.GetTargets().FirstOrDefault(x => !x.IsInvulnerable());
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
var isChanneling = UnitExtensions.IsChanneling(this.Owner);
if (!silenced)
{
try
{
if ((this.BlinkDagger != null) &&
(this.BlinkDagger.Item.IsValid) &&
Target != null && Owner.Distance2D(Target) <= 1200 + sliderValue &&
!(Owner.Distance2D(Target) <= sliderValue) &&
this.BlinkDagger.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name) && !isChanneling)
{
var l = (this.Owner.Distance2D(Target) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = Target.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
Log.Debug("Using BlinkDagger");
this.BlinkDagger.UseAbility(position);
await Await.Delay(this.GetItemDelay(position), token);
}
if ((this.Euls != null) && this.Euls.Item.IsValid && Target != null &&
this.Owner.Distance2D(Target) <= this.Euls.CastRange && this.Euls.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(this.Euls.Item.Name))
{
Log.Debug($"Using Eul");
this.Euls.UseAbility(this.Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (Hex != null && Hex.IsValid && Hex.CanBeCasted(Target) &&
!isChanneling &&
this.Config.AbilityToggler.Value.IsEnabled(this.Hex.Name))
{
Log.Debug($"Using Hex");
Hex.UseAbility(Target);
await Await.Delay(GetAbilityDelay(this.Owner, Hex), token);
}
if (Ethershock != null && Ethershock.IsValid && Ethershock.CanBeCasted(Target) &&
!isChanneling &&
this.Config.AbilityToggler.Value.IsEnabled(this.Ethershock.Name))
{
Log.Debug($"Using Ethershock!");
Ethershock.UseAbility(Target);
await Await.Delay(GetAbilityDelay(this.Owner, Ethershock), token);
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Error($"{e}");
}
}
if (!silenced)
{
try
{
var invulTargetsToo = this.TargetSelector.Active.GetTargets().FirstOrDefault();
if (Wards != null && Wards.IsValid && Wards.CanBeCasted() &&
!isChanneling && invulTargetsToo != null && invulTargetsToo.IsValid &&
this.Config.AbilityToggler.Value.IsEnabled(this.Wards.Name))
{
var delay = Wards.GetCastPoint();
var wardsCastRange = Wards.CastRange;
var input = new PredictionInput(this.Owner, invulTargetsToo, delay, float.MaxValue,
wardsCastRange, 30,
PredictionSkillshotType.SkillshotCircle)
{
CollisionTypes = CollisionTypes.None
};
output = Prediction.GetPrediction(input);
if (output.HitChance >= HitChance.Medium)
{
Log.Debug($"Casting Wards");
this.Wards.UseAbility(output.CastPosition);
if (this.Config.FailSwitch.Value.Equals(true) && (Target.IsRotating() && Target.MovementSpeed >= 300 || Ensage.SDK.Extensions.EntityExtensions.Distance2D(Target, output.CastPosition) >= 200))
{
Log.Error($"stopping");
this.Owner.Stop();
await Await.Delay(100, token);
}
await Await.Delay(GetAbilityDelay(output.CastPosition, this.Wards), token);
}
}
}
catch (TaskCanceledException)
{
// ignored
}
catch (Exception e)
{
Log.Error($"{e}");
}
}
if (this.BloodThorn != null &&
this.BloodThorn.Item.IsValid &&
Target != null && !isChanneling &&
this.BloodThorn.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
Log.Debug("Using Bloodthorn");
this.BloodThorn.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if ((this.SheepStick != null) &&
(this.SheepStick.Item.IsValid) &&
Target != null && !isChanneling &&
this.SheepStick.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_sheepstick"))
{
Log.Debug("Using Sheepstick");
this.SheepStick.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Dagon != null &&
this.Dagon.Item.IsValid &&
Target != null && !isChanneling &&
this.Dagon.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(Dagon5.Item.Name))
{
Log.Debug("Using Dagon");
this.Dagon.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Orchid != null &&
this.Orchid.Item.IsValid &&
Target != null && !isChanneling &&
this.Orchid.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_orchid"))
{
Log.Debug("Using Orchid");
this.Orchid.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.RodofAtos != null &&
this.RodofAtos.Item.IsValid &&
Target != null && !isChanneling &&
this.RodofAtos.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_rod_of_atos"))
{
Log.Debug("Using RodofAtos");
this.RodofAtos.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.VeilofDiscord != null &&
this.VeilofDiscord.Item.IsValid &&
Target != null && !isChanneling &&
this.VeilofDiscord.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_veil_of_discord"))
{
Log.Debug("Using VeilofDiscord");
this.VeilofDiscord.UseAbility(Target.Position);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.HurricanePike != null &&
this.HurricanePike.Item.IsValid &&
Target != null && !isChanneling &&
this.HurricanePike.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_hurricane_pike"))
{
Log.Debug("Using HurricanePike");
this.HurricanePike.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.ShivasGuard != null &&
this.ShivasGuard.Item.IsValid &&
Target != null && !isChanneling &&
this.ShivasGuard.Item.CanBeCasted() &&
Owner.Distance2D(Target) <= 900 &&
this.Config.ItemToggler.Value.IsEnabled("item_shivas_guard"))
{
Log.Debug("Using Shiva's Guard");
this.ShivasGuard.UseAbility();
await Await.Delay((int)Game.Ping, token);
}
if (this.Mjollnir != null &&
this.Mjollnir.Item.IsValid &&
Target != null && !isChanneling &&
this.Mjollnir.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_mjollnir"))
{
Log.Debug("Using Mjollnir");
this.Mjollnir.UseAbility(Owner);
await Await.Delay(this.GetItemDelay(Target), token);
}
try
{
if (Shackles != null && Shackles.IsValid && Shackles.CanBeCasted(Target) &&
!isChanneling &&
(Wards == null || !Wards.IsValid || !Wards.CanBeCasted() ||
!this.Config.AbilityToggler.Value.IsEnabled(this.Wards.Name)) && HexSync() &&
this.Config.AbilityToggler.Value.IsEnabled(this.Shackles.Name))
{
Log.Debug($"Using Shackles!");
Shackles.UseAbility(Target);
await Await.Delay(GetAbilityDelay(this.Target, Shackles) + 1000, token);
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Error(e);
}
/*if (Refresher != null && Refresher.Item.IsValid && Target != null &&
* !isChanneling && this.Refresher.Item.CanBeCasted() && !this.Wards.CanBeCasted() && !this.Shackles.CanBeCasted() &&
* this.Config.ItemToggler.Value.IsEnabled(Refresher.Item.Name))
* {
* Log.Debug($"Using Refresher Orb");
* Refresher.UseAbility();
* await Await.Delay(100, token);
* }*/
if (Target != null && Owner.IsValidOrbwalkingTarget(Target) && !isChanneling)
{
this.Context.Orbwalker.Active.OrbwalkTo(Target);
Log.Debug($"Orbwalking");
}
await Await.Delay(100, token);
}
public override async Task ExecuteAsync(CancellationToken token)
{
var target = this.TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && !UnitExtensions.IsMagicImmune(x) && x.IsAlive);
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
if (this.BlinkDagger != null &&
this.BlinkDagger.Item.IsValid &&
target != null && Owner.Distance2D(target) <= 1200 + sliderValue &&
!(Owner.Distance2D(target) <= 400) &&
this.BlinkDagger.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name))
{
var l = (this.Owner.Distance2D(target) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = target.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
Log.Debug("Using BlinkDagger");
this.BlinkDagger.UseAbility(position);
await Await.Delay(this.GetItemDelay(target), token);
}
//Are we in an ult phase?
var inUltimate = UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_ball_lightning") ||
Lightning.IsInAbilityPhase;
//Check if we're silenced, our target is alive, and we have a target.
var UltDistance = Config.DistanceForUlt.Item.GetValue <Slider>().Value;
//Check for distance to target and push against slider value
if (target != null && target.IsAlive &&
Owner.Distance2D(target) >= 400 && Owner.Distance2D(target) <= UltDistance &&
Config.AbilityToggler.Value.IsEnabled(Lightning.Name) && !silenced)
{
//Based on whether they are moving or not, predict where they will be.
if (target.IsMoving)
{
var PredictedPosition = Ensage.Common.Extensions.UnitExtensions.InFront(target, 0);
//Check the mana consumed from our prediction.
double TempManaConsumed = (Lightning.GetAbilityData("ball_lightning_initial_mana_base") +
((Lightning.GetAbilityData("ball_lightning_initial_mana_percentage") /
100) * Owner.MaximumMana))
+ ((Ensage.SDK.Extensions.EntityExtensions.Distance2D(Owner,
PredictedPosition) / 100) *
(((Lightning.GetAbilityData("ball_lightning_travel_cost_percent") /
100) * Owner.MaximumMana)));
if (TempManaConsumed <= Owner.Mana && !inUltimate)
{
Lightning.UseAbility(PredictedPosition);
await Await.Delay(
(int)(Lightning.FindCastPoint() + Owner.GetTurnTime(PredictedPosition) * 2250 + Game.Ping),
token);
}
}
else
{
var PredictedPosition = target.NetworkPosition;
double TempManaConsumed = (Lightning.GetAbilityData("ball_lightning_initial_mana_base") +
((Lightning.GetAbilityData("ball_lightning_initial_mana_percentage") /
100) * Owner.MaximumMana))
+ ((Ensage.SDK.Extensions.EntityExtensions.Distance2D(Owner,
PredictedPosition) / 100) *
(((Lightning.GetAbilityData("ball_lightning_travel_cost_percent") /
100) * Owner.MaximumMana)));
if (TempManaConsumed <= Owner.Mana && !inUltimate)
{
Lightning.UseAbility(PredictedPosition);
await Await.Delay(
(int)(Lightning.FindCastPoint() + Owner.GetTurnTime(PredictedPosition) * 2250 + Game.Ping),
token);
}
}
}
//Vars we need before combo.
bool HasAghanims = Owner.HasItem(ItemId.item_ultimate_scepter);
float VortexCost = Vortex.GetManaCost(Vortex.Level - 1);
float RemnantCost = Remnant.GetManaCost(Remnant.Level - 1);
float CurrentMana = Owner.Mana;
float TotalMana = Owner.MaximumMana;
//This is here to stop us from ulting after our target dies.
float RemnantAutoDamage = this.Remnant.GetAbilityData("static_remnant_damage");
if (this.Overload != null)
{
RemnantAutoDamage += this.Overload.GetDamage(Overload.Level - 1);
}
var RemnantAutokillableTar =
ObjectManager.GetEntitiesFast <Hero>()
.FirstOrDefault(
x =>
x.IsAlive && x.Team != this.Owner.Team && !x.IsIllusion &&
this.Remnant.CanBeCasted() && this.Remnant.CanHit(x) &&
x.Health < (RemnantAutoDamage * (1 - x.MagicDamageResist)) &&
!UnitExtensions.IsMagicImmune(x) &&
x.Distance2D(this.Owner) <= 235);
var ActiveRemnant = Remnants.Any(unit => unit.Distance2D(RemnantAutokillableTar) < 240);
if (!silenced && target != null)
{
//there is a reason behind this; the default delay on storm ult is larger than a minimum distance travelled.
var TargetPosition = target.NetworkPosition;
/*TargetPosition *= 100;
* TargetPosition = target.NetworkPosition + TargetPosition;*/
double ManaConsumed = (Lightning.GetAbilityData("ball_lightning_initial_mana_base") + ((Lightning.GetAbilityData("ball_lightning_initial_mana_percentage") / 100) * CurrentMana))
+ ((Ensage.SDK.Extensions.EntityExtensions.Distance2D(Owner, TargetPosition) / 100) * (((Lightning.GetAbilityData("ball_lightning_travel_cost_percent") / 100) * CurrentMana)));
//Always auto attack if we have an overload charge.
if (UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_overload") && target != null)
{
Owner.Attack(target);
await Await.Delay(500);
}
//Vortex prioritization logic [do we have q/w enabled, do we have the mana to cast both, do they have lotus, do we have an overload modifier]
if (!UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_overload") &&
Config.AbilityToggler.Value.IsEnabled(Vortex.Name) && Vortex.CanBeCasted() &&
Config.AbilityToggler.Value.IsEnabled(Remnant.Name) && Remnant.CanBeCasted() &&
(VortexCost + RemnantCost) <= CurrentMana)
{
//Use Vortex
if (!HasAghanims)
{
Vortex.UseAbility(target);
await Await.Delay(GetAbilityDelay(Owner, Vortex), token);
}
//Use Vortex differently for aghanims.
else
{
Vortex.UseAbility();
await Await.Delay(GetAbilityDelay(Owner, Vortex), token);
}
}
//Remnant logic [w is not available, cant ult, close enough for the detonation]
if (!UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_overload") && target.IsAlive &&
Config.AbilityToggler.Value.IsEnabled(Remnant.Name) && Remnant.CanBeCasted() &&
!Vortex.CanBeCasted() && (CurrentMana <= RemnantCost + ManaConsumed || Owner.Distance2D(target) <= Remnant.GetAbilityData("static_remnant_radius")))
{
Remnant.UseAbility();
await Await.Delay(GetAbilityDelay(Owner, Remnant), token);
}
//Ult logic [nothing else is available or we are not in range for a q]
if (!UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_overload") && target.IsAlive &&
Config.AbilityToggler.Value.IsEnabled(Lightning.Name) && Lightning.CanBeCasted() &&
(!Remnant.CanBeCasted() || Owner.Distance2D(target) >= Remnant.GetAbilityData("static_remnant_radius")) &&
(!Vortex.CanBeCasted(target) || Owner.Distance2D(target) <= UltDistance)
//Don't cast ult if theres a remnant that can kill our target.
&& !inUltimate && (RemnantAutokillableTar == null || ActiveRemnant == false))
//todo: alternate check for aghanims
{
Lightning.UseAbility(TargetPosition);
int delay = (int)((Lightning.FindCastPoint() + Owner.GetTurnTime(TargetPosition)) * 1250.0 + Game.Ping);
Log.Debug($"{delay}ms to wait.");
await Task.Delay(delay);
}
}
if ((this.Nullifier != null &&
(this.Nullifier.Item.IsValid &&
target != null &&
this.Nullifier.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_nullifier"))))
{
Log.Debug("Using Nullifier");
this.Nullifier.UseAbility(target);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.BloodThorn != null &&
(this.BloodThorn.Item.IsValid &&
target != null &&
this.BloodThorn.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_bloodthorn"))))
{
Log.Debug("Using Bloodthorn");
this.BloodThorn.UseAbility(target);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.SheepStick != null &&
(this.SheepStick.Item.IsValid &&
target != null &&
this.SheepStick.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_sheepstick"))))
{
Log.Debug("Using Sheepstick");
this.SheepStick.UseAbility(target);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.Orchid != null) && this.Orchid.Item.IsValid && target != null &&
(this.Orchid.Item.CanBeCasted(target) && this.Config.ItemToggler.Value.IsEnabled("item_orchid")))
{
Log.Debug("Using Orchid");
this.Orchid.UseAbility(target);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.RodofAtos != null &&
(this.RodofAtos.Item.IsValid &&
target != null &&
this.RodofAtos.Item.CanBeCasted(target) &&
this.Config.ItemToggler.Value.IsEnabled("item_rod_of_atos"))))
{
Log.Debug("Using RodofAtos");
this.RodofAtos.UseAbility(target);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.VeilofDiscord != null &&
(this.VeilofDiscord.Item.IsValid &&
target != null &&
this.VeilofDiscord.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_veil_of_discord"))))
{
Log.Debug("Using VeilofDiscord");
this.VeilofDiscord.UseAbility(target.Position);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.HurricanePike != null) && (double)(this.Owner.Health / this.Owner.MaximumHealth) * 100 <=
(double)Config.HurricanePercentage.Item.GetValue <Slider>().Value&&
this.HurricanePike.Item.IsValid &&
target != null &&
this.HurricanePike.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_hurricane_pike"))
{
Log.Debug("Using HurricanePike");
this.HurricanePike.UseAbility(target);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.ShivasGuard != null &&
(this.ShivasGuard.Item.IsValid &&
target != null &&
this.ShivasGuard.Item.CanBeCasted() &&
Owner.Distance2D(target) <= 900 &&
this.Config.ItemToggler.Value.IsEnabled("item_shivas_guard"))))
{
Log.Debug("Using Shiva's Guard");
this.ShivasGuard.UseAbility();
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if ((this.Mjollnir != null &&
(this.Mjollnir.Item.IsValid &&
target != null &&
this.Mjollnir.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_mjollnir"))))
{
Log.Debug("Using Mjollnir");
this.Mjollnir.UseAbility(Owner);
await Await.Delay(this.GetItemDelay(target) + (int)Game.Ping, token);
}
if (this.Orbwalker.OrbwalkTo(target))
{
return;
}
await Await.Delay(125, token);
}
private void DrawingDamagePanel(EventArgs args)
{
me = Context.Owner as Hero;
var enemies = ObjectManager.GetEntities <Hero>()
.Where(x => x.IsVisible && x.IsAlive && x.Team != me.Team && !ExUnit.IsMagicImmune(x) && !x.IsIllusion).ToList();
if (!Game.IsInGame || Game.IsPaused || Game.IsWatchingGame || enemies.Count == 0 || !Config.DrawingDamageEnabled.Value)
{
return;
}
foreach (var v in enemies)
{
damage[v.Handle] = (float)CalculateDamage(v);
var useMana = CalculateMana(v);
//Console.WriteLine("useMana" + useMana);
var screenPos = HUDInfo.GetHPbarPosition(v);
if (!OnScreen(v.Position))
{
continue;
}
var travelSpeed = R.GetAbilityData("ball_lightning_move_speed", R.Level);
//var travelTime = me.Distance2D(v) / travelSpeed;
var distance = me.Distance2D(v);
var startManaCost = R.GetAbilityData("ball_lightning_initial_mana_base") +
me.MaximumMana / 100 * R.GetAbilityData("ball_lightning_initial_mana_percentage");
var costPerUnit = (12 + me.MaximumMana * 0.007) / 100.0;
var calcEnemyHealth = v.Health <= 0 ? 0 : v.Health - damage[v.Handle];
var calcMyMana = useMana >= me.Mana ? 0 : me.Mana - useMana;
var rManacost = startManaCost + costPerUnit * Math.Floor(distance / 100) * 100;
var text1 = v.Health <= damage[v.Handle] ? "✔ Damage:" + Math.Floor(damage[v.Handle]) + "(Easy Kill)"
: "✘ Damage:" + (int)Math.Floor(damage[v.Handle]) + "(" + (int)calcEnemyHealth + ")";
var text2 = me.Mana >= useMana ? "✔ Mana:" + (int)Math.Floor(useMana) + "(" + (int)calcMyMana + ")" : "✘ Mana:" + (int)Math.Floor(useMana) + "(" + (int)calcMyMana + ")";
var text3 = me.Mana >= rManacost ? "✔ Distance:" + (int)me.Distance2D(v) : "✘ Distance:" + (int)me.Distance2D(v);
var size = new Vector2(Config.DrawingDamageSize.Item.GetValue <Slider>().Value, Config.DrawingDamageSize.Item.GetValue <Slider>().Value);
var position1 = new Vector2(screenPos.X + 65, screenPos.Y + 12);
var position2 = new Vector2(screenPos.X + 65, screenPos.Y + 24);
var position3 = new Vector2(screenPos.X + 65, screenPos.Y + 36);
var fountCount = Config.WeatherItem.Value.SelectedIndex;
var fountName = Config.WeatherItem.Value.SList;
if (Drawing.Direct3DDevice9 == null)
{
return;
}
Drawing.DrawText(
text1, fountName[fountCount],
new Vector2(screenPos.X + 64, screenPos.Y + 13),
size,
Color.Black,
FontFlags.GaussianBlur);
Drawing.DrawText(
text1, fountName[fountCount],
position1,
size,
v.Health <= damage[v.Handle] ? Color.LawnGreen : Color.OrangeRed,
FontFlags.GaussianBlur);
Drawing.DrawText(
text2, fountName[fountCount],
new Vector2(screenPos.X + 64, screenPos.Y + 25),
size,
Color.Black,
FontFlags.GaussianBlur);
Drawing.DrawText(
text2, fountName[fountCount],
position2,
size,
me.Mana >= useMana ? Color.LawnGreen : Color.OrangeRed,
FontFlags.GaussianBlur);
Drawing.DrawText(
text3, fountName[fountCount],
new Vector2(screenPos.X + 64, screenPos.Y + 37),
size,
Color.Black,
FontFlags.GaussianBlur);
Drawing.DrawText(
text3, fountName[fountCount],
position3,
size,
me.Mana >= rManacost ? Color.LawnGreen : Color.OrangeRed,
FontFlags.GaussianBlur);
}
}
public double CalculateDamage(Hero victim)
{
double dmgResult = 0;
bool vailOn = false;
bool orchidOn = false;
double manacost = 0;
var rLevel = R.Level;
var distance = me.Distance2D(victim);
var dagon = me.Inventory.Items.FirstOrDefault(item => item.Name.Contains("item_dagon"));
var travelSpeed = R.GetAbilityData("ball_lightning_move_speed", rLevel);
var travelTime = distance / travelSpeed;
var startManaCost = R.GetAbilityData("ball_lightning_initial_mana_base") +
me.MaximumMana / 100 * R.GetAbilityData("ball_lightning_initial_mana_percentage");
//Console.WriteLine("startManaCost " + startManaCost);
var costPerUnit = (12 + me.MaximumMana * 0.007) / 100.0;
var rManacost = startManaCost + costPerUnit * Math.Floor(distance / 100) * 100;
var e = TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && x.IsAlive);
var damageR = R.GetAbilityData("#AbilityDamage", rLevel); // / 100f;
rDmg = (distance - 1) * (float)0.01 * damageR;
Q = me.Spellbook.SpellQ;
W = me.Spellbook.SpellW;
E = me.Spellbook.SpellE;
R = me.Spellbook.SpellR;
qDmg = Q.GetAbilityData("static_remnant_damage");
wDmg = (me.AttacksPerSecond * W.GetAbilityData("duration") - 1) * me.GetAttackDamage(victim);
sheepDmg = (me.AttacksPerSecond * (float)3.5 - 1) * me.GetAttackDamage(victim);
eDmg = E.GetAbilityData("#AbilityDamage", E.Level);
var qReady = Q != null && Config.AbilityToggler.Value.IsEnabled(Q.Name) &&
Q.CanBeCasted();
var wReady = W != null && Config.AbilityToggler.Value.IsEnabled(W.Name) &&
W.CanBeCasted();
var rReady = R != null && Config.AbilityToggler.Value.IsEnabled(R.Name) &&
R.CanBeCasted();
var eReady = E != null && Config.AbilityToggler.Value.IsEnabled(E.Name) &&
E.Level > 0;
if (arcane != null &&
arcane.Item.IsValid && arcane.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(arcane.Item.Name))
{
manacost -= 125;
}
if (soul != null &&
soul.Item.IsValid && soul.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(soul.Item.Name))
{
manacost -= 150;
}
if (rReady)
{
if (manacost + rManacost < me.Mana)
{
manacost += rManacost;
dmgResult += rDmg * (1 - victim.MagicDamageResist);
if (eReady)
{
dmgResult += eDmg * (1 - victim.MagicDamageResist);
}
}
else
{
goto gotoDamage;
}
}
if (orchid != null &&
orchid.Item.IsValid && orchid.Item.CanBeCasted() && Config.ItemToggler.Value.IsEnabled("item_bloodthorn") &&
!ExUnit.HasModifier(victim, "modifier_bloodthorn_debuff") &&
!ExUnit.HasModifier(victim, "modifier_orchid_malevolence_debuff"))
{
if (manacost + orchid.Item.ManaCost < me.Mana)
{
manacost += orchid.Item.ManaCost;
orchidOn = true;
}
else
{
goto gotoDamage;
}
}
if (bloodthorn != null &&
bloodthorn.Item.IsValid && bloodthorn.Item.CanBeCasted() && Config.ItemToggler.Value.IsEnabled("item_bloodthorn") &&
!ExUnit.HasModifier(victim, "modifier_bloodthorn_debuff") &&
!ExUnit.HasModifier(victim, "modifier_orchid_malevolence_debuff"))
{
if (manacost + bloodthorn.Item.ManaCost < me.Mana)
{
manacost += bloodthorn.Item.ManaCost;
orchidOn = true;
}
else
{
goto gotoDamage;
}
}
if (vail != null &&
vail.Item.IsValid && vail.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(vail.Item.Name) &&
!ExUnit.HasModifier(victim, "modifier_item_veil_of_discord_debuff"))
{
if (manacost + vail.Item.ManaCost < me.Mana)
{
manacost += vail.Item.ManaCost;
vailOn = true;
}
else
{
goto gotoDamage;
}
}
if (qReady)
{
if (manacost + Q.ManaCost < me.Mana)
{
manacost += Q.ManaCost;
dmgResult += qDmg * (1 - victim.MagicDamageResist);
if (eReady)
{
dmgResult += eDmg * (1 - victim.MagicDamageResist);
}
}
else
{
goto gotoDamage;
}
}
if (wReady && eReady)
{
if (manacost + W.ManaCost < me.Mana)
{
dmgResult += eDmg * (1 - victim.MagicDamageResist);
}
else
{
goto gotoDamage;
}
}
var spellamplymult = 1 + me.TotalIntelligence / 16 / 100;
dmgResult = dmgResult * spellamplymult;
if (dagon != null && dagon.CanBeCasted() && victim.Handle == e?.Handle && Config.ItemToggler.Value.IsEnabled("item_dagon_5"))
{
if (manacost + dagon.ManaCost < me.Mana)
{
manacost += dagon.ManaCost;
dmgResult += dagonDmg[dagon.Level] * (1 - victim.MagicDamageResist);
}
else
{
goto gotoDamage;
}
}
if (shiva != null &&
shiva.Item.IsValid && shiva.Item.CanBeCasted() && Config.ItemToggler.Value.IsEnabled(shiva.Item.Name))
{
if (manacost + shiva.Item.ManaCost < me.Mana)
{
manacost += shiva.Item.ManaCost;
dmgResult += 200 * (1 - victim.MagicDamageResist);
}
else
{
goto gotoDamage;
}
}
int etherealdamage = (int)((me.TotalIntelligence * 2) + 75);
if (ethereal != null &&
ethereal.Item.IsValid && ethereal.Item.CanBeCasted() && victim.Handle == e?.Handle && Config.ItemToggler.Value.IsEnabled(ethereal.Item.Name))
{
if (manacost + ethereal.Item.ManaCost < me.Mana)
{
manacost += ethereal.Item.ManaCost;
dmgResult += 1.4 + etherealdamage;
}
//else goto gotoDamage;
}
gotoDamage:
if (ExUnit.HasModifier(me, "modifier_special_bonus_spell_amplify"))
{
dmgResult *= 1.10;
}
if (ExUnit.HasModifier(victim, "modifier_item_veil_of_discord_debuff"))
{
dmgResult *= 1.25;
}
if (vail != null &&
vail.Item.IsValid && vail.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(vail.Item.Name) &&
!ExUnit.HasModifier(victim, "modifier_item_veil_of_discord_debuff"))
{
if (vailOn)
{
dmgResult *= 1.25;
}
}
if (sheep != null &&
sheep.Item.IsValid && sheep.Item.CanBeCasted() && Config.ItemToggler.Value.IsEnabled(sheep.Item.Name))
{
if (manacost + 100 < me.Mana)
{
dmgResult += sheepDmg;
}
}
if (bloodthorn != null &&
bloodthorn.Item.IsValid && bloodthorn.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled("item_bloodthorn") && orchidOn || ExUnit.HasModifier(victim, "modifier_bloodthorn_debuff"))
{
if (qReady && eReady)
{
dmgResult += me.GetAttackDamage(victim) * 1.4;
}
if (rReady && eReady)
{
dmgResult += me.GetAttackDamage(victim) * 1.4;
}
if (wReady)
{
if (manacost + W.ManaCost < me.Mana)
{
dmgResult += wDmg * 1.4;
}
}
}
else
{
if (qReady && eReady)
{
dmgResult += me.GetAttackDamage(victim);
}
if (rReady && eReady)
{
dmgResult += me.GetAttackDamage(victim);
}
if (wReady)
{
if (manacost + W.ManaCost < me.Mana)
{
dmgResult += wDmg;
}
}
}
if (ExUnit.HasModifier(victim, "modifier_chen_penitence"))
{
var chen =
ObjectManager.GetEntities <Hero>()
.FirstOrDefault(x => x.Team == me.Team && x.ClassId == ClassId.CDOTA_Unit_Hero_Chen);
if (chen != null)
{
dmgResult *= penitence[chen.Spellbook.Spell1.Level];
}
}
if (ExUnit.HasModifier(victim, "modifier_shadow_demon_soul_catcher"))
{
var demon = ObjectManager.GetEntities <Hero>()
.FirstOrDefault(x => x.Team == me.Team && x.ClassId == ClassId.CDOTA_Unit_Hero_Shadow_Demon);
if (demon != null)
{
dmgResult *= souls[demon.Spellbook.Spell2.Level];
}
}
if (orchid != null &&
orchid.Item.IsValid && orchid.Item.CanBeCasted() && Config.ItemToggler.Value.IsEnabled("item_bloodthorn") &&
!ExUnit.HasModifier(victim, "modifier_bloodthorn_debuff") &&
!ExUnit.HasModifier(victim, "modifier_orchid_malevolence_debuff"))
{
if (orchidOn)
{
dmgResult *= 1.3;
}
}
if (bloodthorn != null &&
bloodthorn.Item.IsValid && bloodthorn.Item.CanBeCasted() && Config.ItemToggler.Value.IsEnabled("item_bloodthorn") &&
!ExUnit.HasModifier(victim, "modifier_bloodthorn_debuff") &&
!ExUnit.HasModifier(victim, "modifier_orchid_malevolence_debuff"))
{
if (orchidOn)
{
dmgResult *= 1.3;
}
}
if (ExUnit.HasModifier(victim, "modifier_item_mask_of_madness_berserk"))
{
dmgResult *= 1.3;
}
if (ExUnit.HasModifier(victim, "modifier_orchid_malevolence_debuff") || ExUnit.HasModifier(victim, "modifier_bloodthorn_debuff"))
{
dmgResult *= 1.3;
}
if (ExUnit.HasModifier(victim, "modifier_kunkka_ghost_ship_damage_absorb"))
{
dmgResult *= 0.5;
}
if (ExUnit.HasModifier(victim, "modifier_bloodseeker_bloodrage") || ExUnit.HasModifier(me, "modifier_bloodseeker_bloodrage"))
{
dmgResult *= 1.4;
}
if (victim.NetworkName == "CDOTA_Unit_Hero_SkeletonKing" && victim.Spellbook.SpellR.Cooldown <= 0 && victim.Mana > 140)
{
dmgResult = 0;
}
return(dmgResult);
} // GetDamageTaken::END
} // GetDamageTaken::END
public double CalculateMana(Hero victim)
{
double manacost = 0;
try
{
var distance = me.Distance2D(victim);
var startManaCost = R.GetAbilityData("ball_lightning_initial_mana_base") +
me.MaximumMana / 100 * R.GetAbilityData("ball_lightning_initial_mana_percentage");
var costPerUnit = (12 + me.MaximumMana * 0.007) / 100.0;
var rManacost = startManaCost + costPerUnit * Math.Floor(distance / 100) * 100;
var qReady = Q != null && Config.AbilityToggler.Value.IsEnabled(Q?.Name) &&
Q.Cooldown <= 0;
var wReady = W != null && Config.AbilityToggler.Value.IsEnabled(W?.Name) &&
W.Cooldown <= 0;
var rReady = R != null && Config.AbilityToggler.Value.IsEnabled(R?.Name) &&
R.Cooldown <= 0;
if (arcane != null && arcane.Item.Cooldown <= 0 &&
Config.ItemToggler.Value.IsEnabled(arcane.Item.Name))
{
manacost -= 125;
}
if (soul != null && soul.Item.Cooldown <= 0 &&
Config.ItemToggler.Value.IsEnabled(soul.Item.Name))
{
manacost -= 150;
}
if (rReady)
{
manacost += rManacost;
}
if (qReady)
{
manacost += Q.ManaCost;
}
if (vail != null && vail.Item.Cooldown <= 0 &&
Config.ItemToggler.Value.IsEnabled(vail.Item.Name) &&
!ExUnit.HasModifier(victim, "modifier_item_veil_of_discord_debuff"))
{
manacost += vail.Item.ManaCost;
}
if (wReady)
{
manacost += W.ManaCost;
}
if (orchid != null &&
orchid.Item.IsValid && orchid.Item.Cooldown <= 0 && Config.ItemToggler.Value.IsEnabled("item_bloodthorn"))
{
manacost += orchid.Item.ManaCost;
}
if (bloodthorn != null &&
bloodthorn.Item.IsValid && bloodthorn.Item.Cooldown <= 0 && Config.ItemToggler.Value.IsEnabled("item_bloodthorn"))
{
manacost += bloodthorn.Item.ManaCost;
}
if (lotus != null &&
lotus.Item.IsValid && lotus.Item.Cooldown <= 0 && Config.ItemToggler.Value.IsEnabled(lotus.Item.Name))
{
manacost += lotus.Item.ManaCost;
}
if (sheep != null &&
sheep.Item.IsValid && sheep.Item.Cooldown <= 0 && Config.ItemToggler.Value.IsEnabled(sheep.Item.Name))
{
manacost += sheep.Item.ManaCost;
}
var dagon = me.GetDagon();
if (dagon != null &&
dagon.IsValid && dagon.Cooldown <= 0 && Config.ItemToggler.Value.IsEnabled("item_dagon_5"))
{
manacost += dagon.ManaCost;
}
if (shiva != null &&
shiva.Item.IsValid && shiva.Item.Cooldown <= 0 && Config.ItemToggler.Value.IsEnabled(shiva.Item.Name))
{
manacost += shiva.Item.ManaCost;
}
if (ethereal != null &&
ethereal.Item.IsValid && ethereal.Item.Cooldown <= 0)
{
manacost += ethereal.Item.ManaCost;
}
}
catch (Exception)
{
}
return(manacost);
} // GetDamageTaken::END
private async Task UseItems(Unit target, CancellationToken token)
{
var called = EntityManager <Hero> .Entities
.Where(x => Owner.Team != x.Team && x.IsValid && !x.IsIllusion && x.IsAlive && x.Modifiers.Any(m => m.Name == "modifier_axe_berserkers_call"))
.ToList();
if (called.Any())
{
var bkb = Owner.GetItemById(AbilityId.item_black_king_bar);
if (bkb != null && bkb.CanBeCasted() && config.UseItems.Value.IsEnabled(bkb.Name))
{
bkb.UseAbility();
await Task.Delay(10, token);
}
var bladeMail = Owner.GetItemById(AbilityId.item_blade_mail);
if (bladeMail != null && bladeMail.CanBeCasted() && config.UseItems.Value.IsEnabled(bladeMail.Name))
{
bladeMail.UseAbility();
await Task.Delay(10, token);
}
var lotus = Owner.GetItemById(AbilityId.item_lotus_orb);
if (lotus != null && lotus.CanBeCasted() && config.UseItems.Value.IsEnabled(lotus.Name))
{
lotus.UseAbility(Owner);
await Task.Delay(10, token);
}
var mjollnir = Owner.GetItemById(AbilityId.item_mjollnir);
if (mjollnir != null && mjollnir.CanBeCasted() && config.UseItems.Value.IsEnabled(mjollnir.Name))
{
mjollnir.UseAbility(Owner);
await Task.Delay(10, token);
}
var shiva = Owner.GetItemById(AbilityId.item_shivas_guard);
if (shiva != null && shiva.CanBeCasted() && config.UseItems.Value.IsEnabled(shiva.Name))
{
shiva.UseAbility();
await Task.Delay(10, token);
}
var crimson = Owner.GetItemById(AbilityId.item_crimson_guard);
if (crimson != null && crimson.CanBeCasted() && config.UseItems.Value.IsEnabled(crimson.Name))
{
crimson.UseAbility();
await Task.Delay(10, token);
}
var pipe = Owner.GetItemById(AbilityId.item_pipe);
if (pipe != null && pipe.CanBeCasted() && config.UseItems.Value.IsEnabled(pipe.Name))
{
pipe.UseAbility();
await Task.Delay(10, token);
}
var dagon = Owner.GetDagon();
if (dagon != null && dagon.CanBeCasted() && config.UseItems.Value.IsEnabled("item_dagon") && !UnitExtensions.IsMagicImmune(target) && !UnitExtensions.IsLinkensProtected(target))
{
dagon.UseAbility(target);
await Task.Delay(10, token);
}
if (W != null && W.CanBeCasted() && Owner.CanCast() && !UnitExtensions.IsMagicImmune(target))
{
if (W.ManaCost + R.ManaCost < Owner.Mana)
{
W.UseAbility(target);
await Task.Delay((int)(W.FindCastPoint() * 1000 + Game.Ping), token);
}
}
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (!await this.ShouldExecute(token))
{
return;
}
this.MaxTargetRange = Math.Max(this.MaxTargetRange, 700);
if ((this.CurrentTarget == null) || !this.CurrentTarget.IsVisible)
{
this.Pugna.Context.Orbwalker.Active.OrbwalkTo(null);
return;
}
if (this.CurrentTarget.IsIllusion)
{
this.OrbwalkToTarget();
return;
}
try
{
var linkens = Ensage.SDK.Extensions.UnitExtensions.IsLinkensProtected(this.CurrentTarget);
await BreakLinken(token);
var allTargets = this.Context.TargetSelector.Active.GetTargets().FirstOrDefault();
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Pugna.UseBlinkPrediction.Item.GetValue <Slider>().Value;
var myHpThreshold = this.Pugna.SelfHPDrain.Item.GetValue <Slider>().Value;
var postDrainHp = this.Pugna.PostDrainHP.Item.GetValue <Slider>().Value;
var allyPostDrain = this.Pugna.HealAllyTo.Item.GetValue <Slider>().Value;
var healThreshold = this.Pugna.DrainHP.Item.GetValue <Slider>().Value;
var wardTars = this.Pugna.WardTargets.Item.GetValue <Slider>().Value;
if (!silenced)
{
try
{
this.Pugna.HealTarget =
EntityManager <Hero> .Entities.FirstOrDefault(
x =>
x.IsAlive && x.Team == this.Owner.Team && x != Owner && !x.IsIllusion &&
((float)x.Health / (float)x.MaximumHealth) * 100 < healThreshold &&
!UnitExtensions.IsMagicImmune(x) &&
this.Pugna.HealTargetHeroes.Value.IsEnabled(x.Name));
var myHealth = (float)Owner.Health / (float)Owner.MaximumHealth * 100;
if (this.Pugna.HealTarget != null)
{
this.Pugna.HealTarget = this.Pugna.HealTarget;
}
if (this.Pugna.HealTarget != null)
{
if (this.Pugna.HealTarget != null &&
!UnitExtensions.IsChanneling(Owner) && myHealth >= myHpThreshold &&
this.Pugna.HealTarget.Distance2D(this.Owner) <= this.Pugna.Drain.CastRange &&
this.Pugna.HealTarget.HealthPercent() * 100 < healThreshold)
{
this.Pugna.Drain.UseAbility(this.Pugna.HealTarget);
this.Pugna.IsHealing = true;
await Task.Delay(
(int)this.Pugna.Drain.GetCastDelay(this.Owner, this.Pugna.HealTarget, true),
token);
}
//Stop Healing; There is no hidden modifier/any way to check if we are healing a target.
if ((UnitExtensions.IsChanneling(Owner) && myHealth <= postDrainHp) && this.Pugna.IsHealing)
{
Owner.Stop();
this.Pugna.IsHealing = false;
}
if (this.Pugna.HealTarget != null && this.Pugna.IsHealing &&
(this.Pugna.HealTarget.HealthPercent() >= ((float)allyPostDrain / 100)))
{
Owner.Stop();
this.Pugna.IsHealing = false;
}
if (this.Pugna.HealTarget == null && this.Pugna.IsHealing)
{
Owner.Stop();
this.Pugna.IsHealing = false;
}
}
}
catch (Exception)
{
// ignore
}
}
if (this.Pugna.IsHealing)
{
return;
}
if ((this.Pugna.BlinkDagger != null) &&
(this.Pugna.BlinkDagger.Item.IsValid) &&
this.CurrentTarget != null && Owner.Distance2D(this.CurrentTarget) <= 1200 + sliderValue &&
!(Owner.Distance2D(this.CurrentTarget) <= 400) &&
this.Pugna.BlinkDagger.Item.CanBeCasted(this.CurrentTarget) &&
!UnitExtensions.IsChanneling(Owner))
{
var l = (this.Owner.Distance2D(this.CurrentTarget) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = this.CurrentTarget.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
this.Pugna.BlinkDagger.UseAbility(position);
await Task.Delay((int)this.Pugna.BlinkDagger.GetCastDelay(position), token);
}
if (!silenced && this.CurrentTarget != null)
{
var targets =
EntityManager <Hero> .Entities.Where(
x =>
x.IsValid && x.Team != this.Owner.Team && !x.IsIllusion &&
!UnitExtensions.IsMagicImmune(x) &&
x.Distance2D(this.Owner) <= this.Pugna.Ward.GetAbilityData("radius"))
.ToList();
if (targets.Count >= wardTars && this.Pugna.Ward.CanBeCasted() &&
!UnitExtensions.IsChanneling(Owner))
{
this.Pugna.Ward.UseAbility(Owner.NetworkPosition);
await Task.Delay((int)this.Pugna.Ward.GetCastDelay(this.Owner, this.Owner, true), token);
}
try
{
// var thresholdTars = this.Config.WardTargets.Item.GetValue<Slider>();
var manaDecrepify = this.Pugna.Decrepify.GetManaCost(this.Pugna.Decrepify.Level - 1);
var manaBlast = this.Pugna.Blast.GetManaCost(this.Pugna.Blast.Level - 1);
// var manaDrain = Drain.GetManaCost(Drain.Level - 1);
if (this.Pugna.Decrepify.CanBeCasted() && this.CurrentTarget != null &&
this.Pugna.Decrepify.CanHit(this.CurrentTarget) &&
this.Owner.Mana >= manaBlast + manaDecrepify &&
!UnitExtensions.IsChanneling(Owner) &&
this.CurrentTarget.IsAlive)
{
this.Pugna.Decrepify.UseAbility(this.CurrentTarget);
await Task.Delay(
(int)this.Pugna.Decrepify.GetCastDelay(this.Owner, this.CurrentTarget, true), token);
}
if (this.Pugna.Blast.CanBeCasted() &&
(!this.Pugna.Decrepify.CanBeCasted() || manaBlast > Owner.Mana - manaDecrepify) &&
!UnitExtensions.IsChanneling(Owner) &&
this.CurrentTarget != null && this.CurrentTarget.IsAlive)
{
var delay = this.Pugna.Blast.GetAbilityData("delay") + this.Pugna.Blast.GetCastPoint();
var blastTargets =
EntityManager <Hero> .Entities.OrderBy(x => x == allTargets).Where(
x =>
x.IsValid && x.IsVisible && x.Team != Owner.Team && !x.IsIllusion &&
!UnitExtensions.IsMagicImmune(x)).ToList();
var blastCastRange = this.Pugna.Blast.CastRange;
if (blastTargets == null)
{
return;
}
var input =
new PredictionInput(
Owner,
this.CurrentTarget,
delay,
float.MaxValue,
blastCastRange,
400,
PredictionSkillshotType.SkillshotCircle,
true,
blastTargets)
{
CollisionTypes = CollisionTypes.None
};
var output = this.Context.Prediction.GetPrediction(input);
if (output.HitChance >= HitChance.Medium)
{
this.Pugna.Blast.UseAbility(output.CastPosition);
await Task.Delay(
(int)this.Pugna.Blast.GetCastDelay(this.Owner, this.CurrentTarget, true), token);
}
}
}
catch (Exception)
{
// ignored
}
}
if (this.Pugna.BloodThorn != null &&
this.Pugna.BloodThorn.Item.IsValid &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.BloodThorn.Item.CanBeCasted(this.CurrentTarget))
{
this.Pugna.BloodThorn.UseAbility(this.CurrentTarget);
await Task.Delay(this.Pugna.BloodThorn.GetCastDelay(this.CurrentTarget), token);
}
if ((this.Pugna.Sheepstick != null) &&
(this.Pugna.Sheepstick.Item.IsValid) &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.Sheepstick.Item.CanBeCasted(this.CurrentTarget))
{
this.Pugna.Sheepstick.UseAbility(this.CurrentTarget);
await Await.Delay(this.Pugna.Sheepstick.GetCastDelay(this.CurrentTarget), token);
}
if (this.Pugna.Dagon != null &&
this.Pugna.Dagon.Item.IsValid &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.Dagon.Item.CanBeCasted(this.CurrentTarget))
{
this.Pugna.Dagon.UseAbility(this.CurrentTarget);
await Await.Delay(this.Pugna.Dagon.GetCastDelay(this.CurrentTarget), token);
}
if (this.Pugna.Orchid != null &&
this.Pugna.Orchid.Item.IsValid &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.Orchid.Item.CanBeCasted(this.CurrentTarget))
{
this.Pugna.Orchid.UseAbility(this.CurrentTarget);
await Await.Delay(this.Pugna.Orchid.GetCastDelay(this.CurrentTarget), token);
}
if (this.Pugna.RodOfAtos != null &&
this.Pugna.RodOfAtos.Item.IsValid &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.RodOfAtos.Item.CanBeCasted(this.CurrentTarget))
{
this.Pugna.RodOfAtos.UseAbility(this.CurrentTarget);
await Await.Delay(this.Pugna.RodOfAtos.GetCastDelay(this.CurrentTarget), token);
}
if (this.Pugna.VeilOfDiscord != null &&
this.Pugna.VeilOfDiscord.Item.IsValid &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.VeilOfDiscord.Item.CanBeCasted())
{
this.Pugna.VeilOfDiscord.UseAbility(this.CurrentTarget.Position);
await Await.Delay(this.Pugna.VeilOfDiscord.GetCastDelay(this.CurrentTarget), token);
}
if (this.Pugna.ShivasGuard != null &&
this.Pugna.ShivasGuard.Item.IsValid &&
this.CurrentTarget != null && !UnitExtensions.IsChanneling(Owner) &&
this.Pugna.ShivasGuard.Item.CanBeCasted() &&
Owner.Distance2D(this.CurrentTarget) <= 900)
{
this.Pugna.ShivasGuard.UseAbility();
await Await.Delay((int)Game.Ping, token);
}
if (!silenced && this.Pugna.Drain.CanBeCasted() &&
(!this.Pugna.Blast.CanBeCasted() || this.Owner.Distance2D(this.CurrentTarget) > this.Pugna.Blast.CastRange) &&
(!this.Pugna.Decrepify.CanBeCasted() || this.Owner.Distance2D(this.CurrentTarget) > this.Pugna.Decrepify.CastRange) &&
!UnitExtensions.IsChanneling(Owner) &&
this.CurrentTarget != null && this.CurrentTarget.IsAlive)
{
this.Pugna.Drain.UseAbility(this.CurrentTarget);
await Task.Delay((int)this.Pugna.Drain.GetCastDelay(this.Owner, this.CurrentTarget, true) + 50,
token);
}
else if (!silenced && this.Pugna.Drain.CanBeCasted() &&
(this.Owner.Distance2D(this.CurrentTarget) > this.Pugna.Blast.CastRange ||
this.Owner.Distance2D(this.CurrentTarget) > this.Pugna.Decrepify.CastRange) &&
!UnitExtensions.IsChanneling(Owner) &&
this.CurrentTarget != null && this.CurrentTarget.IsAlive)
{
this.Pugna.Drain.UseAbility(this.CurrentTarget);
await Task.Delay((int)this.Pugna.Drain.GetCastDelay(this.Owner, this.CurrentTarget, true) + 50,
token);
}
if (this.CurrentTarget != null && !Owner.IsValidOrbwalkingTarget(this.CurrentTarget) &&
!UnitExtensions.IsChanneling(this.Owner))
{
Orbwalker.Move(Game.MousePosition);
await Await.Delay(50, token);
}
else
{
Orbwalker.OrbwalkTo(this.CurrentTarget);
}
await Await.Delay(50, token);
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Debug($"{e}");
}
this.OrbwalkToTarget();
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (!config.Enabled)
{
return;
}
var target = targetSelector.Active.GetTargets().FirstOrDefault();
if (target == null)
{
Orbwalker.OrbwalkTo(null);
return;
}
if (!Owner.CanCast())
{
return;
}
var posForHitChance = target.BasePredict(450 + Game.Ping);
var distanceToHitChance = EntityExtensions.Distance2D(Owner, posForHitChance);
var blink = Owner.GetItemById(AbilityId.item_blink);
var force = Owner.GetItemById(AbilityId.item_force_staff);
var blinkReady = blink != null && blink.CanBeCasted() && config.UseItemsInit.Value.IsEnabled(blink.Name);
var forceReady = force != null && force.CanBeCasted() && config.UseItemsInit.Value.IsEnabled(force.Name);
if (config.EnabledForcePlusBlink && forceReady && blinkReady)
{
if (distanceToHitChance < 1900 && distanceToHitChance > 1200 && Q.CanBeCasted())
{
await TurnTo(posForHitChance, token);
if (Vector3Extensions.Distance(UnitExtensions.InFront(Owner, 600), posForHitChance) < 1200)
{
force.UseAbility(Owner);
await Task.Delay(10, token);
}
}
}
if (blinkReady)
{
if (distanceToHitChance < 1200 && !Q.CanHit(target) && Q.CanBeCasted())
{
blink.UseAbility(posForHitChance);
await Task.Delay(10, token);
}
}
if (forceReady)
{
if (distanceToHitChance < 750 && !Q.CanHit(target) && Q.CanBeCasted())
{
await TurnTo(posForHitChance, token);
if (Vector3Extensions.Distance(UnitExtensions.InFront(Owner, 600), posForHitChance) < 260)
{
force.UseAbility(Owner);
await Task.Delay(10, token);
}
}
}
await Kill(token);
if (Q.CanBeCasted())
{
if (Q.CanHit(target) && !target.HasModifiers(cuntCullModifiers, false))
{
Q.UseAbility();
await Task.Delay((int)(Q.FindCastPoint() * 1000 + Game.Ping), token);
}
Orbwalker.Move(posForHitChance);
}
else
{
Orbwalker.OrbwalkTo(target);
}
await UseItems(target, token);
}
public override void Execute()
{
if (Core.TempestHero != null && Core.TempestHero.Hero.IsAlive)
{
if (UnitExtensions.HasModifier(Core.TempestHero.Hero, "modifier_teleporting"))
{
return;
}
if (UnitExtensions.IsChanneling(Core.TempestHero.Hero))
{
return;
}
if (_sleeper.Sleeping)
{
return;
}
_sleeper.Sleep(150);
var currentLane = GetLane(Core.TempestHero.Hero);
CurrentLane = currentLane;
var target = Core.TempestHero.Orbwalker.GetTarget();
if (target == null || target.Position.IsZero || !target.IsAlive)
{
var path = FindOrGetNeededPath(Core.TempestHero.Hero);
var lastPoint = path[path.Count - 1];
var closest = path.Where(
x =>
x.Distance2D(lastPoint) < Core.TempestHero.Hero.Position.Distance2D(lastPoint) - 300)
.OrderBy(pos => CheckForDist(pos, Core.TempestHero.Hero))
.FirstOrDefault();
Core.TempestHero.Hero.Move(closest);
Status = "Moving";
if (MenuManager.UseTravels)
{
var travels = Core.TempestHero.Hero.GetItemById(AbilityId.item_travel_boots) ??
Core.TempestHero.Hero.GetItemById(AbilityId.item_travel_boots_2);
if (travels != null && travels.CanBeCasted())
{
Status = "Moving [?TP]";
var temp = path.ToList();
temp.Reverse();
if (MenuManager.CheckForCreeps)
{
var enemyCreeps =
EntityManager <Creep> .Entities.Where(
x =>
x.IsValid && x.IsVisible && x.IsAlive &&
x.Team != ObjectManager.LocalHero.Team &&
Map.GetLane(x) == currentLane);
Creep creepForTravels = null;
var allyCreeps =
EntityManager <Creep> .Entities.Where(
allyCreep => allyCreep.IsValid && allyCreep.IsAlive &&
allyCreep.Team == ObjectManager.LocalHero.Team &&
Map.GetLane(allyCreep) == currentLane &&
allyCreep.HealthPercent() > 0.75).ToList();
foreach (var point in temp)
{
creepForTravels = allyCreeps.FirstOrDefault(
allyCreep =>
point.IsInRange(allyCreep.Position, 1500) &&
enemyCreeps.Any(z => z.IsInRange(allyCreep, 1500)));
if (creepForTravels != null)
{
break;
}
}
if (creepForTravels != null && creepForTravels.Distance2D(Core.TempestHero.Hero) > 1500)
{
var point = path[path.Count - 1];
var distance1 = point.Distance2D(creepForTravels);
var distance2 = point.Distance2D(Core.TempestHero.Hero);
if (distance1 < distance2 || Map.GetLane(Core.TempestHero.Hero) != currentLane)
{
travels.UseAbility(creepForTravels);
Status = "Doing Tp";
_sleeper.Sleep(1000);
return;
}
}
}
else
{
var finalPos = temp.First();
var ally =
EntityManager <Creep> .Entities.Where(
allyCreep => allyCreep.IsValid && allyCreep.IsAlive &&
allyCreep.Team == ObjectManager.LocalHero.Team &&
Map.GetLane(allyCreep) == currentLane &&
allyCreep.HealthPercent() > 0.75)
.OrderBy(y => EntityExtensions.Distance2D(y, finalPos))
.FirstOrDefault();
var allyTwr =
EntityManager <Tower> .Entities.Where(
allyCreep => allyCreep.IsValid && allyCreep.IsAlive &&
allyCreep.Team == ObjectManager.LocalHero.Team &&
Map.GetLane(allyCreep) == currentLane &&
allyCreep.HealthPercent() > 0.1)
.OrderBy(y => EntityExtensions.Distance2D(y, finalPos))
.FirstOrDefault();
Unit tpTarget = null;
if (ally != null && allyTwr != null)
{
var dist1 = finalPos.Distance2D(ally);
var dist2 = finalPos.Distance2D(allyTwr);
if (dist1 > dist2)
{
tpTarget = allyTwr;
}
else
{
tpTarget = ally;
}
}
if (tpTarget != null && tpTarget.Distance2D(Core.TempestHero.Hero) > 1500)
{
var point = path[path.Count - 1];
var distance1 = point.Distance2D(tpTarget);
var distance2 = point.Distance2D(Core.TempestHero.Hero);
if (distance1 < distance2 || Map.GetLane(Core.TempestHero.Hero) != currentLane)
{
travels.UseAbility(tpTarget.Position);
_sleeper.Sleep(1000);
Status = "Doing Tp";
return;
}
}
}
}
}
try
{
foreach (var illusion in IllusionManager.GetIllusions)
{
illusion.Hero.Move(closest);
}
foreach (var necro in NecronomiconManager.GetNecronomicons)
{
necro.Necr.Move(closest);
}
}
catch (Exception e)
{
Printer.Both("kek " + e.Message);
}
}
else
{
Status = $"Pushing{(target is Tower ? " Tower" : "")}";
if (Core.TempestHero.Spark.CanBeCasted())
{
Printer.Log(
$"[AutoPushing][Spark][{target.Name} ({target.NetworkName})]->{target.Position.PrintVector()}",
true);
if (!target.Position.IsZero)
{
Core.TempestHero.Spark.UseAbility(target.Position);
Status = "Casting spark";
_sleeper.Sleep(500);
return;
}
}
var itemForPushing = Core.TempestHero.Hero.GetItemById(ItemId.item_mjollnir);
if (itemForPushing != null && itemForPushing.CanBeCasted())
{
var allyCreep =
EntityManager <Creep> .Entities
.FirstOrDefault(
x =>
x.IsAlive && x.Team == ObjectManager.LocalHero.Team &&
x.IsInRange(Core.TempestHero.Hero, 500) && x.HealthPercent() <= 0.92 &&
x.IsMelee);
if (allyCreep != null)
{
itemForPushing.UseAbility(allyCreep);
_sleeper.Sleep(500);
}
}
itemForPushing = Core.TempestHero.Hero.GetItemById(ItemId.item_manta);
if (itemForPushing != null && itemForPushing.CanBeCasted())
{
itemForPushing.UseAbility();
_sleeper.Sleep(500);
}
itemForPushing = Core.TempestHero.Hero.GetItemById(ItemId.item_necronomicon) ??
Core.TempestHero.Hero.GetItemById(ItemId.item_necronomicon_2) ??
Core.TempestHero.Hero.GetItemById(ItemId.item_necronomicon_3);
if (itemForPushing != null && itemForPushing.CanBeCasted())
{
itemForPushing.UseAbility();
_sleeper.Sleep(500);
}
if (Core.TempestHero.Orbwalker.GetTarget() is Tower)
{
var field = Core.TempestHero.MagneticField;
if (field.CanBeCasted())
{
var pos =
(Core.TempestHero.Orbwalker.GetTarget().NetworkPosition -
Core.TempestHero.Hero.NetworkPosition).Normalized();
pos *= 280 + 150;
pos = Core.TempestHero.Orbwalker.GetTarget().NetworkPosition - pos;
field.UseAbility(pos);
_sleeper.Sleep(1000);
}
}
}
if (MenuManager.AutoPushingTargetting)
{
var enemyHero =
Heroes.GetByTeam(ObjectManager.LocalHero.GetEnemyTeam())
.FirstOrDefault(
x => x.IsVisible && x.IsAlive && x.IsInRange(Core.TempestHero.Hero,
MenuManager
.AutoPushingTargettingRange) /*Core.TempestHero.Hero.IsValidOrbwalkingTarget(x)*/);
if (enemyHero != null)
{
//OrderManager.ChangeOrder(OrderManager.Orders.SparkSpamTempest);
Core.Target = enemyHero;
MenuManager.TempestCombo.SetValue(new KeyBind(MenuManager.TempestCombo.GetValue <KeyBind>().Key,
KeyBindType.Toggle, true));
Core.Target = enemyHero;
ParticleManager?.Remove("targetting_range");
}
else
{
if (MenuManager.DrawTargettingRange)
{
ParticleManager.DrawRange(Core.TempestHero.Hero, "targetting_range",
MenuManager.AutoPushingTargettingRange, Color.White);
}
}
}
}
else
{
Status = "Tempest is dead";
var illusions = IllusionManager.GetIllusions.Where(x => x.Orbwalker.GetTarget() == null).ToList();
var necros = NecronomiconManager.GetNecronomicons.Where(x => x.Orbwalker.GetTarget() == null).ToList();
var any = illusions.Any() || necros.Any();
if (any)
{
foreach (var illusion in illusions)
{
var path = FindOrGetNeededPath(illusion.Hero);
var lastPoint = path[path.Count - 1];
var closest = path.Where(
x =>
x.Distance2D(lastPoint) <
Core.TempestHero.Hero.Position.Distance2D(lastPoint) - 300)
.OrderBy(pos => CheckForDist(pos, Core.TempestHero.Hero))
.FirstOrDefault();
illusion.Hero.Move(closest);
}
foreach (var necro in necros)
{
var path = FindOrGetNeededPath(necro.Necr);
var lastPoint = path[path.Count - 1];
var closest = path.Where(
x =>
x.Distance2D(lastPoint) <
Core.TempestHero.Hero.Position.Distance2D(lastPoint) - 300)
.OrderBy(pos => CheckForDist(pos, Core.TempestHero.Hero))
.FirstOrDefault();
necro.Necr.Move(closest);
}
_sleeper.Sleep(500);
}
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
var e = TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && x.IsAlive);
if (e == null)
{
return;
}
var debuff = e.FindModifier("modifier_storm_spirit_electric_vortex_pull") ?? e.FindModifier("modifier_sheepstick_debuff") ?? e.FindModifier("modifier_rod_of_atos_debuff");
var buff = e.HasModifiers(new[]
{
"modifier_storm_spirit_electric_vortex_pull",
"modifier_sheepstick_debuff",
"modifier_rod_of_atos_debuff"
}, false) || ExUnit.IsStunned(e) || ExUnit.IsHexed(e) || ExUnit.IsRooted(e);
var checkTimeModif = debuff?.RemainingTime <= 0.3;
var inUltBall = ExUnit.HasModifier(me, "modifier_storm_spirit_ball_lightning") ||
R.IsInAbilityPhase;
var inOverload = ExUnit.HasModifier(me, "modifier_storm_spirit_overload");
var lotusBuff = ExUnit.HasModifier(e, "modifier_item_lotus_orb_active");
var inVortex = ExUnit.HasModifier(e, "modifier_storm_spirit_electric_vortex_pull");
var travelSpeed = R.GetAbilityData("ball_lightning_move_speed", R.Level);
var distance = me.Distance2D(e);
var travelTime = distance / travelSpeed;
var startManaCost = R.GetAbilityData("ball_lightning_initial_mana_base") +
me.MaximumMana / 100 * R.GetAbilityData("ball_lightning_initial_mana_percentage");
var costPerUnit = (12 + me.MaximumMana * 0.007) / 100.0;
var rManacost = startManaCost + costPerUnit * Math.Floor(distance / 100) * 100;
var dagon = me.GetDagon();
var enemies = EntityManager <Hero> .Entities.Count(
x => x.IsValid && x.IsAlive && !x.IsIllusion && x.Team != me.Team && x.Distance2D(me) <= 700) >= Config.Heel.Item.GetValue <Slider>().Value;
if (!lotusBuff)
{
if (
// cheese
cheese != null &&
cheese.Item.IsValid &&
cheese.Item.CanBeCasted() &&
(me.Health <= me.MaximumHealth * 0.3 ||
me.Mana <= me.MaximumMana * 0.2) &&
distance <= 700 &&
Config.ItemToggler.Value.IsEnabled(cheese.Item.Name)
)
{
cheese.UseAbility();
await Await.Delay(GetItemDelay(e), token);
}
if ( // SoulRing Item
soul != null &&
soul.Item.IsValid &&
soul.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(soul.Item.Name) &&
me.CanCast() &&
me.Health >= me.MaximumHealth * 0.4 &&
me.Mana <= me.MaximumMana * 0.4
)
{
soul.UseAbility();
await Await.Delay(GetItemDelay(e), token);
}
if ( // Arcane Boots Item
arcane != null &&
arcane.Item.IsValid &&
arcane.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(arcane.Item.Name) &&
me.CanCast() &&
me.Mana <= me.MaximumMana * 0.4
)
{
arcane.UseAbility();
await Await.Delay(GetItemDelay(e), token);
}
uint elsecount = 0;
elsecount += 1;
if (elsecount == 1 &&
R != null &&
R.CanBeCasted() &&
!me.IsAttacking() &&
!R.IsChanneling &&
!R.IsInAbilityPhase &&
me.Mana >= rManacost &&
!inUltBall &&
distance >= me.GetAttackRange() &&
!ExUnit.IsMagicImmune(e) &&
Config.AbilityToggler.Value.IsEnabled(R.Name)
)
{
if (e.NetworkActivity == NetworkActivity.Move)
{
R.CastSkillShot(e);
}
else
{
R.UseAbility(e.Position);
}
await Await.Delay(GetAbilityDelay(me, R) + (int)Math.Floor(travelTime * 1000), token);
}
else
{
elsecount += 1;
}
if (vail != null &&
vail.Item.IsValid &&
vail.Item.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled(vail.Item.Name) &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e)
)
{
vail.UseAbility(e.Position);
await Await.Delay(GetItemDelay(e), token);
}
if (orchid != null &&
orchid.Item.IsValid &&
orchid.Item.CanBeCasted() &&
(Config.silenceToHex.Value || !ExUnit.IsHexed(e)) &&
(Config.silenceToVortex.Value || !inVortex)
&& me.CanCast() &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled("item_bloodthorn")
)
{
orchid.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
if (nullifier != null &&
nullifier.Item.IsValid &&
nullifier.Item.CanBeCasted() &&
me.CanCast() &&
!ExUnit.IsHexed(e) &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled(nullifier.Item.Name)
)
{
nullifier.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
if (bloodthorn != null &&
bloodthorn.Item.IsValid &&
bloodthorn.Item.CanBeCasted() &&
(Config.silenceToVortex.Value || !inVortex) &&
(Config.silenceToHex.Value || !ExUnit.IsHexed(e)) &&
me.CanCast() &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled("item_bloodthorn")
)
{
bloodthorn.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
if (elsecount == 2 &&
sheep != null &&
sheep.Item.IsValid &&
sheep.Item.CanBeCasted() &&
me.CanCast() &&
(checkTimeModif || !buff) &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e) &&
(Config.hexToSilence.Value || !ExUnit.IsSilenced(e)) &&
e.ClassId != ClassId.CDOTA_Unit_Hero_Tidehunter &&
Config.ItemToggler.Value.IsEnabled(sheep.Item.Name)
)
{
sheep.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
else
{
elsecount += 1;
}
if (elsecount == 3 &&
Q != null &&
Q.CanBeCasted() &&
Config.AbilityToggler.Value.IsEnabled(Q.Name) &&
!ExUnit.IsMagicImmune(e) &&
me.CanCast() &&
!R.IsInAbilityPhase &&
(W == null || !W.CanBeCasted() || !Config.AbilityToggler.Value.IsEnabled(W.Name) || ExUnit.IsSilenced(e) || ExUnit.IsHexed(e)) &&
(!inOverload || inOverload && ExUnit.IsAttackImmune(e)) &&
distance <= Q.GetAbilityData("static_remnant_radius") + me.HullRadius
)
{
Q.UseAbility();
await Await.Delay(GetAbilityDelay(me, Q) + 100, token);
}
else
{
elsecount += 1;
}
if (elsecount == 4 &&
W != null &&
W.CanBeCasted() &&
(Config.fastVortex.Value || !R.IsInAbilityPhase && !inOverload) &&
(checkTimeModif || !buff) &&
(Config.vortexToSilence.Value || !ExUnit.IsSilenced(e)) &&
!me.IsAttacking() &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e) &&
Config.AbilityToggler.Value.IsEnabled(W.Name)
)
{
W.UseAbility(e);
await Await.Delay(GetAbilityDelay(me, W) + 50, token);
}
else
{
elsecount += 1;
}
if (elsecount == 5 &&
ExUnit.CanAttack(me) &&
!me.IsAttacking() &&
!ExUnit.HasModifier(e, "modifier_item_ethereal_blade_slow") &&
inOverload &&
!ExUnit.IsAttackImmune(e) &&
distance <= me.GetAttackRange() &&
!ExUnit.IsAttackImmune(e)
)
{
me.Attack(e);
await Await.Delay(170, token);
}
else
{
elsecount += 1;
}
if (elsecount == 6 &&
W != null &&
W.CanBeCasted() &&
(Config.fastVortex.Value || !inOverload) &&
me.AghanimState() &&
(checkTimeModif || !buff) &&
!me.IsAttacking() &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e) &&
Config.AbilityToggler.Value.IsEnabled(W.Name)
)
{
W.UseAbility();
await Await.Delay(GetAbilityDelay(me, W), token);
}
else
{
elsecount += 1;
}
if (elsecount == 7 &&
atos != null &&
atos.Item.IsValid &&
atos.Item.CanBeCasted() &&
me.CanCast() &&
(checkTimeModif || !buff || !ExUnit.IsHexed(e)) &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled(atos.Item.Name)
)
{
atos.UseAbility(e);
await Await.Delay(GetItemDelay(e) + 100, token);
}
else
{
elsecount += 1;
}
if (elsecount == 8 &&
ethereal != null &&
ethereal.Item.IsValid &&
ethereal.Item.CanBeCasted() &&
me.CanCast() &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled(ethereal.Item.Name)
)
{
if (Config.debuff.Value)
{
var speed = ethereal.Item.GetAbilityData("projectile_speed");
var time = e.Distance2D(me) / speed;
ethereal.UseAbility(e);
await Await.Delay((int)(time * 1000.0f + Game.Ping) + 30, token);
}
else
{
ethereal.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
}
else
{
elsecount += 1;
}
if (elsecount == 9 &&
dagon != null &&
dagon.IsValid &&
dagon.CanBeCasted() &&
Config.ItemToggler.Value.IsEnabled("item_dagon_5") &&
me.CanCast() &&
(ethereal == null ||
ExUnit.HasModifier(e, "modifier_item_ethereal_blade_slow") ||
ethereal.Item.Cooldown < 17) &&
!ExUnit.IsLinkensProtected(e) &&
!ExUnit.IsMagicImmune(e)
)
{
dagon.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
else
{
elsecount += 1;
}
if (elsecount == 10 &&
urn != null &&
urn.Item.IsValid && urn.Item.CanBeCasted() && urn.Item.CurrentCharges > 0 &&
distance <= urn.Item.GetCastRange() &&
Config.ItemToggler.Value.IsEnabled(urn.Item.Name)
)
{
urn.UseAbility(e);
await Await.Delay(GetItemDelay(e), token);
}
else
{
elsecount += 1;
}
if (elsecount == 11 &&
bkb != null &&
bkb.Item.IsValid &&
bkb.Item.CanBeCasted() &&
enemies &&
Config.ItemToggler.Value.IsEnabled(bkb.Item.Name)
)
{
bkb.UseAbility();
await Await.Delay(GetItemDelay(me), token);
}
else
{
elsecount += 1;
}
if (elsecount == 12 &&
lotus != null &&
lotus.Item.IsValid &&
lotus.Item.CanBeCasted() &&
enemies &&
Config.ItemToggler.Value.IsEnabled(lotus.Item.Name)
)
{
lotus.UseAbility(me);
await Await.Delay(GetItemDelay(me), token);
}
else
{
elsecount += 1;
}
if (elsecount == 13 &&
shiva != null &&
shiva.Item.IsValid &&
shiva.Item.CanBeCasted() &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled(shiva.Item.Name) &&
distance <= 600
)
{
shiva.UseAbility();
await Await.Delay(GetItemDelay(me), token);
}
else
{
elsecount += 1;
}
if (elsecount == 14 &&
mjollnir != null &&
mjollnir.Item.IsValid &&
mjollnir.Item.CanBeCasted() &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled(mjollnir.Item.Name) &&
me.Distance2D(e) <= 600
)
{
mjollnir.UseAbility(me);
await Await.Delay(GetItemDelay(me), token);
}
}
else
{
if (Q != null &&
Q.CanBeCasted() &&
!inOverload &&
(W == null || !W.CanBeCasted() || !Config.AbilityToggler.Value.IsEnabled(W.Name)) &&
distance <= Q.GetAbilityData("static_remnant_radius") + me.HullRadius &&
Config.AbilityToggler.Value.IsEnabled(Q.Name) &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e)
)
{
Q.UseAbility();
await Await.Delay(GetAbilityDelay(me, Q) + 200, token);
}
if (shiva != null &&
shiva.Item.IsValid &&
shiva.Item.CanBeCasted() &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e) &&
Config.ItemToggler.Value.IsEnabled(shiva.Item.Name) &&
distance <= 600
)
{
shiva.UseAbility();
await Await.Delay(GetItemDelay(me), token);
}
if (W != null &&
W.CanBeCasted() &&
!inOverload &&
me.AghanimState() &&
(checkTimeModif || !buff) &&
!me.IsAttacking() &&
me.CanCast() &&
!ExUnit.IsMagicImmune(e) &&
Config.AbilityToggler.Value.IsEnabled(W.Name)
)
{
W.UseAbility();
await Await.Delay(GetAbilityDelay(me, W), token);
}
}
Vector3 start = e.NetworkActivity == NetworkActivity.Move ? new Vector3((float)((R.GetCastDelay(me, me, true) + 0.3) * Math.Cos(e.RotationRad) * e.MovementSpeed + e.Position.X),
(float)((R.GetCastDelay(me, me, true) + 0.3) * Math.Sin(e.RotationRad) * e.MovementSpeed + e.NetworkPosition.Y), e.NetworkPosition.Z) : e.NetworkPosition;
if (R != null &&
R.CanBeCasted() &&
!inUltBall &&
Q.Cooldown <= 3 &&
!R.IsInAbilityPhase &&
!R.IsChanneling &&
!me.IsAttacking() &&
(W == null || !W.CanBeCasted() || !Config.AbilityToggler.Value.IsEnabled(W.Name)) &&
!ExUnit.IsChanneling(me) &&
(Config.AutoOverload.Value &&
buff ||
!buff) &&
me.Position.Distance2D(start) <= me.GetAttackRange() &&
!ExUnit.IsMagicImmune(e) &&
(Config.savemanamode.Value &&
me.AttackBackswing() > 0.3 - me.TurnTime(e.NetworkPosition) &&
!cooldown ||
!Config.savemanamode.Value) &&
Config.AbilityToggler.Value.IsEnabled(R.Name)
)
{
float angle = e.FindAngleBetween(me.Position, true);
Vector3 pos = new Vector3((float)(me.Position.X - 15 * Math.Cos(angle)),
(float)(me.Position.Y - 15 * Math.Sin(angle)), me.Position.Z);
if (!inOverload)
{
R.UseAbility(pos);
await Await.Delay(GetAbilityDelay(me, R) + 100, token);
}
}
if (!ExUnit.IsAttackImmune(e) && !ExUnit.IsDisarmed(me) && !ExUnit.HasModifier(e, "modifier_item_ethereal_blade_slow"))
{
float angle = e.FindAngleBetween(me.Position, true);
Vector3 pos = new Vector3((float)(me.Position.X + 300 * Math.Cos(angle)),
(float)(me.Position.Y + 300 * Math.Sin(angle)), me.Position.Z);
if (me.Distance2D(e) <= 250 && e.GetTurnTime(me) * 1000 < 35 && cooldown && !me.IsAttacking())
{
me.Move(pos);
await Await.Delay((int)(me.SecondsPerAttack * 100), token);
}
if (me.Distance2D(e) <= 250 && !cooldown && !me.IsAttacking() && ExUnit.CanAttack(me))
{
me.Attack(e);
await Await.Delay((int)(me.SecondsPerAttack * 100), token);
}
if (me.Distance2D(e) >= 250 && !cooldown && ExUnit.CanAttack(me))
{
if (Orbwalker.OrbwalkTo(e))
{
return;
}
}
}
await Await.Delay(10, token);
}
public bool CanMove()
{
return(Game.RawGameTime - 0.1f + Game.Ping / 2000f - LastAttackTime > UnitExtensions.AttackPoint(Owner));
}
public virtual async Task AutoAbilities()
{
var e = TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && x.IsAlive);
if (e == null)
{
return;
}
var f =
EntityManager <Unit> .Entities.First(x => x.Team == me?.Team && x.ClassId == ClassId.CDOTA_Unit_Fountain);
float angle = f.FindAngleBetween(me.Position, true);
Vector3 pos = new Vector3((float)(me.Position.X - 1500 * Math.Cos(angle)),
(float)(me.Position.Y - 1500 * Math.Sin(angle)), 0);
var distance = me.Distance2D(e);
if (me.IsAlive &&
distance <= 800 &&
R != null &&
!R.IsInAbilityPhase &&
!R.IsChanneling &&
R.CanBeCasted() &&
Config.Escape.Value.IsEnabled(R.Name) &&
e.Health > me.Health
)
{
R.UseAbility(pos);
if (
travel != null &&
travel.Item.IsValid &&
travel.Item.CanBeCasted() &&
!ExUnit.IsChanneling(me) &&
Config.Escape.Value.IsEnabled("item_travel_boots_2")
)
{
travel.UseAbility(f.Position);
}
else if (
travel2 != null &&
travel2.Item.IsValid &&
travel2.Item.CanBeCasted() &&
!ExUnit.IsChanneling(me) &&
Config.Escape.Value.IsEnabled("item_travel_boots_2")
)
{
travel2.UseAbility(f.Position);
}
else if (
tp != null &&
tp.Item.IsValid &&
tp.Item.CanBeCasted() &&
!ExUnit.IsChanneling(me) &&
Config.Escape.Value.IsEnabled("item_travel_boots_2")
)
{
tp.UseAbility(f.Position);
}
}
await Await.Delay(250);
}
private void OnOnIngameUpdate(EventArgs args)
{
Mode = OrbwalkingMode.Idle;
if (Game.IsPaused || Game.IsChatOpen)
{
return;
}
if (Members.Menu.Item("Combo.key").GetValue <KeyBind>().Active)
{
Mode = OrbwalkingMode.Combo;
}
else if (Mode == OrbwalkingMode.Idle)
{
_globalTarget = null;
EffectManager.Remove("attackTarget" + Owner.Handle);
return;
}
if (TurnEndTime > Game.RawGameTime)
{
return;
}
var target = GetTarget();
if (!UnitExtensions.HasModifier(Owner, "modifier_templar_assassin_meld"))
{
var tempTarget = GetTarget(false);
if (tempTarget != null)
{
var blink = Owner.GetItemById(AbilityId.item_blink);
var tempPos = new Vector3();
if (blink != null && blink.CanBeCasted() && blink.CanHit(tempTarget, ref tempPos) &&
!_sleeper.Sleeping(blink))
{
blink.UseAbility(tempPos);
_sleeper.Sleep(300, blink);
}
if (!UnitExtensions.HasModifier(tempTarget, "modifier_templar_assassin_trap_slow"))
{
var trap = UnitExtensions.GetAbilityById(ObjectManager.LocalHero,
AbilityId.templar_assassin_psionic_trap);
var trapNearTarget =
EntityManager <Unit> .Entities.FirstOrDefault(
x =>
x.IsValid && x.Name == "npc_dota_templar_assassin_psionic_trap" &&
Ensage.SDK.Extensions.EntityExtensions.Distance2D(tempTarget, x.Position) <= 400);
if (trapNearTarget != null)
{
if (!_sleeper.Sleeping(trap + "activate"))
{
var activator = trapNearTarget.Spellbook.Spell1;
if (activator.CanBeCasted())
{
activator.UseAbility();
}
_sleeper.Sleep(300, trap + "activate");
}
}
else if (trap.CanBeCasted())
{
if (!_sleeper.Sleeping(trap + "place"))
{
trap.UseAbility(tempTarget.Position);
_sleeper.Sleep(300, trap + "place");
}
}
}
}
}
if ((target == null || !CanAttack(target)) && CanMove())
{
if (Move(Game.MousePosition))
{
return;
}
}
if (target != null && CanAttack(target))
{
LastTarget = target;
var refraction = UnitExtensions.GetAbilityById(ObjectManager.LocalHero, AbilityId.templar_assassin_refraction);
if (refraction.CanBeCasted() && !_sleeper.Sleeping(refraction))
{
refraction.UseAbility();
_sleeper.Sleep(300, refraction);
}
var meld = UnitExtensions.GetAbilityById(ObjectManager.LocalHero, AbilityId.templar_assassin_meld);
if (meld.CanBeCasted() && !_sleeper.Sleeping(meld))
{
meld.UseAbility();
_sleeper.Sleep(300, meld);
}
Attack(target);
}
if (LastTarget != null && LastTarget.IsValid && LastTarget.IsAlive)
{
EffectManager.DrawRange(LastTarget, "attackTarget" + Owner.Handle, 60, Color.Red);
}
else
{
EffectManager.Remove("attackTarget" + Owner.Handle);
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
try
{
if (Config.Target.Value.SelectedValue.Contains("Lock") && Context.TargetSelector.IsActive &&
(!CanExecute || EnemyHero == null || !EnemyHero.IsValid || !EnemyHero.IsAlive))
{
EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
else if (Config.Target.Value.SelectedValue.Contains("Default") && Context.TargetSelector.IsActive)
{
EnemyHero = Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
var Silenced = UnitExtensions.IsSilenced(base.Owner);
var SliderData = this.Config.UseBlink.Item.GetValue <Slider>().Value;
var IsInvis = Ensage.SDK.Extensions.UnitExtensions.IsInvisible(this.Owner);
if (EnemyHero != null && !EnemyHero.IsInvulnerable())
{
if (!Silenced && this.Config.AbilityToggler.Value.IsEnabled(this.QAbi.Ability.Name) && this.Owner.IsMelee && !IsInvis && this.Owner.IsInAttackRange(EnemyHero, 350) && !this.Owner.IsInRange(EnemyHero, 150))
{
this.QAbi.Ability.ToggleAbility();
await Await.Delay(this.GetAbilityDelay(base.Owner, QAbi), token);
}
if (!Silenced && this.Config.AbilityToggler.Value.IsEnabled(this.QAbi.Ability.Name) && !IsInvis && this.Owner.IsRanged && this.Owner.IsInRange(EnemyHero, 150))
{
this.QAbi.Ability.ToggleAbility();
await Await.Delay(this.GetAbilityDelay(base.Owner, QAbi), token);
}
if (!Silenced && !this.Owner.IsInAttackRange(EnemyHero) && !IsInvis && this.Owner.IsRanged)
{
this.QAbi.Ability.ToggleAbility();
await Await.Delay(this.GetAbilityDelay(base.Owner, QAbi), token);
}
if (this.Blink != null && this.Blink.CanBeCasted && Owner.Distance2D(EnemyHero) <= 1200 + SliderData && !IsInvis && !(this.Owner.Distance2D(EnemyHero) <= 400) && this.Config.ItemToggler2.Value.IsEnabled(this.Blink.Item.Name))
{
var l = (this.Owner.Distance2D(EnemyHero) - SliderData) / SliderData;
var posA = this.Owner.Position;
var posB = EnemyHero.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
this.Blink.UseAbility(position);
await Await.Delay(Blink.GetCastDelay(position), token);
}
if (!UnitExtensions.IsMagicImmune(EnemyHero))
{
if (!Silenced && this.WAbi != null && this.WAbi.CanBeCasted && !IsInvis && this.WAbi.CanHit(EnemyHero) && this.Config.AbilityToggler.Value.IsEnabled(this.WAbi.Ability.Name))
{
this.WAbi.UseAbility();
await Await.Delay(WAbi.GetCastDelay(), token);
}
if (!Silenced && this.EAbi != null && this.EAbi.CanBeCasted && !IsInvis && this.EAbi.CanHit(EnemyHero) && this.Config.AbilityToggler.Value.IsEnabled(this.EAbi.Ability.Name))
{
this.EAbi.UseAbility(EnemyHero);
await Await.Delay(EAbi.GetCastDelay(), token);
}
if (!Silenced && this.RAbi != null && this.RAbi.CanBeCasted && !IsInvis && this.Owner.IsAttacking() && this.Config.AbilityToggler.Value.IsEnabled(this.RAbi.Ability.Name))
{
this.RAbi.UseAbility();
await Await.Delay(EAbi.GetCastDelay(), token);
}
if (this.BloodThorn != null && this.BloodThorn.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && !this.Owner.IsAttacking() && this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
this.BloodThorn.UseAbility(EnemyHero);
await Await.Delay(BloodThorn.GetCastDelay(EnemyHero), token);
}
if (this.Medalion1 != null && this.Medalion1.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && !this.Owner.IsAttacking() && this.Config.ItemToggler.Value.IsEnabled(this.Medalion1.Item.Name))
{
this.Medalion1.UseAbility(EnemyHero);
await Await.Delay(Medalion1.GetCastDelay(EnemyHero), token);
}
if (this.Medallion2 != null && this.Medallion2.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && !this.Owner.IsAttacking() && this.Config.ItemToggler.Value.IsEnabled(this.Medallion2.Item.Name))
{
this.Medallion2.UseAbility(EnemyHero);
await Await.Delay(Medallion2.GetCastDelay(EnemyHero), token);
}
if (this.SheepStick != null && this.SheepStick.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && this.Config.ItemToggler.Value.IsEnabled(this.SheepStick.Item.Name))
{
this.SheepStick.UseAbility(EnemyHero);
await Await.Delay(SheepStick.GetCastDelay(EnemyHero), token);
}
if (this.DiffBlade != null && this.DiffBlade.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && this.Config.ItemToggler.Value.IsEnabled(DiffBlade.Item.Name))
{
this.DiffBlade.UseAbility(EnemyHero);
await Await.Delay(DiffBlade.GetCastDelay(EnemyHero), token);
}
if (this.Orchid != null && this.Orchid.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && this.Config.ItemToggler.Value.IsEnabled(Orchid.Item.Name))
{
this.Orchid.UseAbility(EnemyHero);
await Await.Delay(Orchid.GetCastDelay(EnemyHero), token);
}
if (this.Mjollnir != null && this.Mjollnir.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && this.Config.ItemToggler2.Value.IsEnabled(Mjollnir.Item.Name))
{
this.Mjollnir.UseAbility(this.Owner);
await Await.Delay(Mjollnir.GetCastDelay(), token);
}
if (this.Heavens_Halberd != null && this.Heavens_Halberd.CanBeCasted && !IsInvis && this.Owner.IsInAttackRange(EnemyHero) && this.Config.ItemToggler2.Value.IsEnabled(Heavens_Halberd.Item.Name))
{
this.Heavens_Halberd.UseAbility(EnemyHero);
await Await.Delay(Heavens_Halberd.GetCastDelay(), token);
}
if (this.Invis_Sword != null && this.Invis_Sword.CanBeCasted && !IsInvis && !this.Owner.IsInRange(EnemyHero, 1000) && !this.Owner.IsAttacking() && this.Config.ItemToggler2.Value.IsEnabled(Invis_Sword.Item.Name))
{
this.Invis_Sword.UseAbility();
await Await.Delay(Invis_Sword.GetCastDelay(), token);
}
if (this.Silver_Edge != null && this.Silver_Edge.CanBeCasted && !IsInvis && !this.Owner.IsInRange(EnemyHero, 1000) && !this.Owner.IsAttacking() && this.Config.ItemToggler2.Value.IsEnabled(Silver_Edge.Item.Name))
{
this.Silver_Edge.UseAbility();
await Await.Delay(Silver_Edge.GetCastDelay(), token);
}
}
if (this.Mask_Of_Madness != null && this.Mask_Of_Madness.CanBeCasted && !IsInvis && this.Config.ItemToggler2.Value.IsEnabled(Mask_Of_Madness.Item.Name))
{
if (Config.MomUsage.Value.SelectedValue.Contains("Melee Form") && this.Owner.IsMelee && !this.EAbi.CanBeCasted && !this.RAbi.CanBeCasted)
{
this.Mask_Of_Madness.UseAbility();
await Await.Delay(Mask_Of_Madness.GetCastDelay(), token);
}
else if (Config.MomUsage.Value.SelectedValue.Contains("Ranged Form") && this.Owner.IsRanged && !this.WAbi.CanBeCasted && !this.RAbi.CanBeCasted)
{
this.Mask_Of_Madness.UseAbility();
await Await.Delay(Mask_Of_Madness.GetCastDelay(), token);
}
}
if (EnemyHero != null && (EnemyHero.IsInvulnerable() || UnitExtensions.IsAttackImmune(EnemyHero)))
{
Orbwalker.Move(Game.MousePosition);
}
else if (EnemyHero != null)
{
Orbwalker.OrbwalkTo(EnemyHero);
}
}
else
{
Orbwalker.Move(Game.MousePosition);
}
}
catch (TaskCanceledException)
{
// canceled
}
catch (Exception e)
{
Log.Error(e);
}
}
