public static bool TargetFinder()
{
if (Core.Target != null && Core.Target.IsValid && Core.Target.IsAlive)
{
if (Core.Target.ClassId == ClassId.CDOTA_Unit_Hero_Phoenix)
{
if (!Core.Target.IsVisible)
{
var egg =
EntityManager <Unit> .Entities.FirstOrDefault(
x =>
UnitExtensions.IsInRange(x, Core.Target, 150) && x.Name == "npc_dota_phoenix_sun" &&
x.IsAlive && x.Team == Core.MainHero.Hero.GetEnemyTeam());
if (egg != null)
{
Core.Target = egg;
Printer.Both(
$"[TargetFinder] new target: phoenix to egg {Core.Target.Name} | {Core.Target.Handle}");
}
}
}
return(true);
}
//modifier_morphling_replicate
var mousePos = Game.MousePosition;
Core.Target = EntityManager <Hero> .Entities.Where(x =>
x.Team != Core.MainHero.Hero.Team && x.IsAlive && x.IsVisible && x.Distance2D(mousePos) <= 500 &&
(!x.IsIllusion || x.HasModifier("modifier_morphling_replicate")))
.OrderBy(x => x.Distance2D(mousePos)).FirstOrDefault();
//TargetSelector.ClosestToMouse(Core.MainHero.Hero, 500);
var tempTarget =
EntityManager <Unit> .Entities.FirstOrDefault(
x =>
(x.NetworkName == "CDOTA_Unit_SpiritBear" || x.Name == "npc_dota_phoenix_sun") && x.IsAlive &&
x.Team == Core.MainHero.Hero.GetEnemyTeam() && x.Distance2D(mousePos) <= 500);
if (Core.Target != null && tempTarget != null)
{
if (Core.Target.Distance2D(mousePos) > tempTarget.Distance2D(mousePos))
{
Core.Target = tempTarget;
}
}
else if (Core.Target == null && tempTarget != null)
{
Core.Target = tempTarget;
}
if (Core.Target == null)
{
return(false);
}
Printer.Both($"[TargetFinder] new target: {Core.Target.Name} | {Core.Target.Handle}");
return(true);
}
public async Task UseAbilities(UnitBase unitBase)
{
if (unitBase.Hero.IsInvisible() || unitBase.Hero.Modifiers.Any(x => x.Name.Contains("windwalk")))
{
return;
}
var flux = unitBase.Flux;
var magneticField = unitBase.MagneticField;
var spark = unitBase.Spark;
if (!_multiSleeper.Sleeping(flux) && unitBase.AbilityChecker.IsAbilityEnabled(flux.GetAbilityId()) &&
flux.CanBeCasted() && flux.CanHit(Core.Target))
{
if (Core.Target.IsLinkensProtected() || !MenuManager.SmartFlux || !EntityManager <Unit> .Entities.Any(
x =>
!x.Equals(Core.Target) && x.Team == Core.Target.Team && x.Name != "npc_dota_thinker" &&
x.IsAlive && x.IsVisible &&
Ensage.SDK.Extensions.EntityExtensions.Distance2D(x, Core.Target) <= 225))
{
flux.UseAbility(Core.Target);
Printer.Both("Flux usages " + flux.GetAbilityDelay());
_multiSleeper.Sleep(500, flux);
await Task.Delay(flux.GetAbilityDelay(), Core.ComboToken.Token);
}
}
var distance = unitBase.Hero.Distance2D(Core.Target);
if (!_multiSleeper.Sleeping(magneticField) && magneticField != null &&
unitBase.AbilityChecker.IsAbilityEnabled(magneticField.GetAbilityId()) && magneticField.CanBeCasted() &&
!unitBase.Hero.HasModifier("modifier_arc_warden_magnetic_field") && distance <= 600 &&
Core.Target.IsVisible)
{
if (!MenuManager.MagneticField && Core.Target.IsMelee)
{
magneticField.UseAbility(Prediction.InFront(unitBase.Hero, -250));
}
else
{
magneticField.UseAbility(Prediction.InFront(unitBase.Hero, 250));
}
_multiSleeper.Sleep(500, magneticField);
Printer.Both("MagneticField usages");
await Task.Delay(magneticField.GetAbilityDelay(), Core.ComboToken.Token);
}
if (!_multiSleeper.Sleeping(spark) && spark != null &&
unitBase.AbilityChecker.IsAbilityEnabled(spark.GetAbilityId()) && spark.CanBeCasted() &&
!Prediction.IsTurning(Core.Target) && unitBase.Hero.IsVisibleToEnemies)
{
if (UnitExtensions.IsInAttackRange(unitBase.Hero, Core.Target) && MenuManager.SmartSpark)
{
return;
}
var delay = spark.GetAbilityDelay();
var predVector3 = Prediction.PredictedXYZ(Core.Target, 2000 + delay);
spark.UseAbility(predVector3);
_multiSleeper.Sleep(500, spark);
Printer.Both("spark usages");
await Task.Delay(spark.GetAbilityDelay(), Core.ComboToken.Token);
}
}
public virtual async Task DrawingTargetDisplay()
{
var e = TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !ExUnit.IsInvulnerable(x) && x.IsAlive);
if (e == null && Effect != null)
{
Effect.Dispose();
Effect = null;
await Await.Delay(100);
}
if (e == null || !e.IsValid || !e.IsAlive)
{
return;
}
if (Effect == null || !Effect.IsValid)
{
Effect = new ParticleEffect(@"particles\ui_mouseactions\range_finder_tower_aoe.vpcf", e);
Effect.SetControlPoint(2, new Vector3(me.Position.X, me.Position.Y, me.Position.Z));
Effect.SetControlPoint(6, new Vector3(1, 0, 0));
Effect.SetControlPoint(7, new Vector3(e.Position.X, e.Position.Y, e.Position.Z));
await Await.Delay(100);
}
else
{
Effect.SetControlPoint(2, new Vector3(me.Position.X, me.Position.Y, me.Position.Z));
Effect.SetControlPoint(6, new Vector3(1, 0, 0));
Effect.SetControlPoint(7, new Vector3(e.Position.X, e.Position.Y, e.Position.Z));
await Await.Delay(100);
}
await Await.Delay(100);
}
private bool IceWallCanHit(Hero target)
{
var myPos = Me.Owner.NetworkPosition;
var startPos = myPos + UnitExtensions.Direction(Me.Owner, 200);
var rotation = Me.Owner.NetworkRotationRad;
var toLeft = rotation - Math.PI / 2;
var toRight = rotation + Math.PI / 2;
for (var i = 0; i < 7; i++)
{
var pos = startPos + Direction(toLeft, 80 * i);
if (Ensage.SDK.Extensions.EntityExtensions.IsInRange(target, pos, 50))
{
return(true);
}
}
for (var i = 0; i < 7; i++)
{
var pos = startPos + Direction(toRight, 80 * i);
if (Ensage.SDK.Extensions.EntityExtensions.IsInRange(target, pos, 50))
{
return(true);
}
}
return(false);
}
protected override void OnActivate()
{
// Init everything (menu, grab abilities, etc)
config = new Config(this);
this.RemoteMines = UnitExtensions.GetAbilityById(context.Owner, AbilityId.techies_remote_mines);
this.context.Inventory.Attach(this);
base.OnActivate();
}
private async Task ExecuteAsync(CancellationToken token)
{
try
{
if (Game.IsPaused || !Owner.IsValid || !Owner.IsAlive || Owner.IsStunned())
{
await Task.Delay(125, token);
return;
}
var target = EntityManager <Hero> .Entities.FirstOrDefault(
x => x.IsAlive &&
(x.Team != this.Owner.Team) &&
!x.IsIllusion &&
Main.SoulAssumption.CanHit(x) &&
Main.SoulAssumption.GetDamage(x) > x.Health);
if (target != null)
{
if (!UnitExtensions.IsBlockingAbilities(target))
{
if (Main.SoulAssumption.UseAbility(target))
{
await Task.Delay(Main.SoulAssumption.GetCastDelay(target) + 20, token);
}
}
else
{
Config.LinkenHandler.RunAsync();
return;
}
}
await Task.Delay(125, token);
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Main.Log.Error(e);
}
}
private async Task OnUpdate(CancellationToken token)
{
if (Game.IsPaused || !this.Owner.IsAlive)
{
await Task.Delay(250, token);
return;
}
// setting walrus kick on OnUpdate so that it can return null if doesn't have aghanim
// and can properly set skill if has aghanim.
if (UnitExtensions.HasAghanimsScepter(this.Owner))
{
this.WalrusKick = this.Owner.GetAbilityById(AbilityId.tusk_walrus_kick);
}
else
{
WalrusKick = null;
}
if (this.CliffKey.Value.Active)
{
var pos = this.Owner.Position;
if (this.IceShards != null && this.IceShards.CanBeCasted() && !this.Owner.IsChanneling())
{
if (this.Owner.IsMoving)
{
this.IceShards.UseAbility(this.Owner.InFront(((float)this.Owner.MovementSpeed / 18) + (Game.Ping / 6))); // magic numbers
await Task.Delay((int)this.IceShards.GetCastDelay(this.Owner, this.Owner, true), token);
}
else
{
this.IceShards.UseAbility(this.Owner.InFront(5));
await Task.Delay((int)this.IceShards.GetCastDelay(this.Owner, this.Owner, true), token);
}
}
await Task.Delay(100, token);
}
}
private void RazeHitCheck()
{
if (this.CurrentTarget == null || !this.CurrentTarget.IsVisible || !Nevermore.PriRaze)
{
return;
}
if (this.Nevermore.RazeShort.IsInAbilityPhase &&
!this.Nevermore.CanHit(Nevermore.RazeShort, CurrentTarget,
this.Nevermore.GetRazeDelay(CurrentTarget, Nevermore.RazeShort)) || (UnitExtensions.IsInvulnerable(this.CurrentTarget)))
{
this.Owner.Stop();
this.Owner.MoveToDirection(this.Nevermore.PredictedTargetPosition);
this.razeUpdateHandler.IsEnabled = false;
Task.Delay(200);
}
if (this.Nevermore.RazeMedium.IsInAbilityPhase &&
!this.Nevermore.CanHit(Nevermore.RazeMedium, CurrentTarget,
this.Nevermore.GetRazeDelay(CurrentTarget, Nevermore.RazeMedium)) || (UnitExtensions.IsInvulnerable(this.CurrentTarget)))
{
this.Owner.Stop();
this.Owner.MoveToDirection(this.Nevermore.PredictedTargetPosition);
this.razeUpdateHandler.IsEnabled = false;
Task.Delay(200);
}
if (this.Nevermore.RazeLong.IsInAbilityPhase &&
!this.Nevermore.CanHit(Nevermore.RazeLong, CurrentTarget,
this.Nevermore.GetRazeDelay(CurrentTarget, Nevermore.RazeLong)) && this.Owner.Distance2D(this.CurrentTarget) <= 730 ||
(UnitExtensions.IsInvulnerable(this.CurrentTarget)))
{
this.Owner.Stop();
this.Owner.MoveToDirection(this.Nevermore.PredictedTargetPosition);
this.razeUpdateHandler.IsEnabled = false;
Task.Delay(200);
}
}
protected override void OnActivate()
{
base.OnActivate();
this._OpenWondAbility = UnitExtensions.GetAbilityById(this.Owner, AbilityId.life_stealer_open_wounds);
this._RageAbility = UnitExtensions.GetAbilityById(this.Owner, AbilityId.life_stealer_rage);
this.Context.Inventory.Attach(this);
var factory = this.Menu.Hero.Factory;
var items = new List <AbilityId>
{
AbilityId.item_medallion_of_courage,
AbilityId.item_solar_crest,
AbilityId.item_mjollnir,
AbilityId.item_abyssal_blade,
AbilityId.item_diffusal_blade,
AbilityId.item_blink
};
this.Items = factory.Item("Items", new AbilityToggler(items.ToDictionary(x => x.ToString(), x => true)));
// this.LSController = UpdateManager.Run(this.OnUpdate);
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (!await this.ShouldExecute(token))
{
return;
}
this.MaxTargetRange = this.GenericHero.MaximumTargetDistance.Value;
if ((this.CurrentTarget == null) || !this.CurrentTarget.IsVisible)
{
this.GenericHero.Context.Orbwalker.Active.OrbwalkTo(null);
return;
}
if (this.CurrentTarget.IsIllusion)
{
this.OrbwalkToTarget();
return;
}
if (UnitExtensions.HasModifier(this.Owner, "modifier_templar_assassin_meld"))
{
this.Owner.Attack(this.CurrentTarget);
}
try
{
if (!this.Owner.IsChanneling() && !UnitExtensions.HasModifier(this.Owner, "modifier_templar_assassin_meld"))
{
this.OrbwalkToTarget();
}
if (this.GenericHero.PrioritizeBlink /*&& !this.Owner.IsChanneling()*/)
{
if (!await this.GenericHero.MoveOrBlinkToEnemy(this.CurrentTarget, token))
{
return;
}
}
var linkens = this.CurrentTarget.IsLinkensProtected();
if (linkens)
{
await BreakLinken(token);
}
if (!this.GenericHero.PrioritizeAbilities)
{
await GenericHero.UseGenericItems(this.CurrentTarget, token);
await GenericHero.DisableEnemy(this.CurrentTarget, token);
await GenericHero.UseGenericAbilities(this.CurrentTarget, token, 0.5f);
await Task.Delay(100, token);
}
else
{
await GenericHero.UseGenericAbilities(this.CurrentTarget, token, 0.5f);
await Task.Delay(100, token);
await GenericHero.UseGenericItems(this.CurrentTarget, token);
await GenericHero.DisableEnemy(this.CurrentTarget, token);
await Task.Delay(100, token);
}
if (!await this.GenericHero.MoveOrBlinkToEnemy(this.CurrentTarget, token))
{
return;
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Debug($"{e}");
}
}
public static void Init()
{
var sleeper = new Sleeper();
var landLevel = Core.LandMine.Level;
var remoteLevel = Core.RemoteMine.Level;
var aghState = Core.Me.AghanimState();
Game.OnUpdate += args =>
{
if (sleeper.Sleeping || !MenuManager.IsEnable)
{
return;
}
sleeper.Sleep(MenuManager.GetUpdateSpeed);
// ReSharper disable once RedundantCheckBeforeAssignment
if (!Core.ExtraDamageFromSuicide)
{
var techiesExtraDamage = Core.Me.GetAbilityById(AbilityId.special_bonus_unique_techies);
if (techiesExtraDamage.Level > 0)
{
Core.ExtraDamageFromSuicide = true;
}
}
if (landLevel != Core.LandMine.Level)
{
landLevel = Core.LandMine.Level;
foreach (var bomb in Core.Bombs.Where(x => !x.IsRemoteMine))
{
bomb.UpdateDamage();
}
}
// ReSharper disable once RedundantCheckBeforeAssignment
/*if (remoteLevel != Core.RemoteMine.Level)
* {
* remoteLevel = Core.RemoteMine.Level;
* foreach (var bomb in Core.Bombs.Where(x => x.IsRemoteMine))
* {
* bomb.UpdateDamage();
* }
* }*/
if (!aghState && Core.Me.AghanimState())
{
aghState = true;
foreach (var bomb in Core.Bombs.Where(x => x.IsRemoteMine))
{
bomb.OnUltimateScepter();
}
}
var landDamage = Core.GetLandMineDamage;
var remoteDamage = Core.GetRemoteMineDamage;
var suicideDamage = Core.GetSuicideDamage + (Core.ExtraDamageFromSuicide ? 400 : 0);
var spellAmp = UnitExtensions.GetSpellAmplification(Core.Me);
foreach (var hero in Heroes.GetByTeam(Core.EnemyTeam))
{
var heroCont = DamageContainers.Find(x => x.Hero.Equals(hero));
if (heroCont == null)
{
heroCont = new HeroDamageContainer(hero);
DamageContainers.Add(heroCont);
}
var heroHealth = hero.Health + hero.HealthRegeneration;
var maxHeroHealth = hero.MaximumHealth;
var reduction = Core.LandMine.GetDamageReduction(hero);
var healthPerTickFromLand = DamageHelpers.GetSpellDamage(landDamage, 0, reduction);
var healthPerTickFromRemote = DamageHelpers.GetSpellDamage(remoteDamage, 0, reduction);
var healthPerSucide = DamageHelpers.GetSpellDamage(suicideDamage, spellAmp, reduction);
//Utils.Printer.Print($"to {hero.GetRealName()} -> {suicideDamage} [res: {reduction}] [amp: {spellAmp}] [defDmg: {healthPerSucide}] [extra400: {Core.ExtraDamageFromSuicide}]");
heroCont.CurrentLandMines = (int)Math.Ceiling(heroHealth / healthPerTickFromLand);
heroCont.MaxLandMines = (int)Math.Ceiling(maxHeroHealth / healthPerTickFromLand);
heroCont.CurrentRemoteMines = (int)Math.Ceiling(heroHealth / healthPerTickFromRemote);
heroCont.MaxRemoteMines = (int)Math.Ceiling(maxHeroHealth / healthPerTickFromRemote);
heroCont.HealthAfterSuicide = heroHealth - healthPerSucide;
heroCont.CanKillWithSuicide = heroCont.HealthAfterSuicide <= 0;
}
};
}
private void PlayerOnOnExecuteOrder(Player player, ExecuteOrderEventArgs args)
{
/*if (!args.IsPlayerInput)
* return;*/
if (!args.Entities.Any(x => x.Equals(Me)))
{
return;
}
if (_config.ComboKey || DisableKey)
{
return;
}
if (Me.IsInvisible() || UnitExtensions.HasAnyModifiers(Me, "modifier_invoker_ghost_walk_self",
"modifier_rune_invis", "modifier_invisible"))
{
return;
}
var order = args.OrderId;
if (args.IsPlayerInput)
{
if (order == OrderId.Ability)
{
var abilityId = args.Ability.Id;
if (abilityId == AbilityId.invoker_quas || abilityId == AbilityId.invoker_wex ||
abilityId == AbilityId.invoker_exort || abilityId == AbilityId.invoker_invoke ||
abilityId == AbilityId.invoker_ghost_walk)
{
Sleeper.Sleep(1500);
}
}
}
if (Sleeper.Sleeping || Me.IsSilenced())
{
return;
}
if (order == OrderId.AttackLocation || order == OrderId.AttackTarget)
{
if (_multySleeper.Sleeping("attack"))
{
return;
}
_multySleeper.Sleep(250, "attack");
var activeSphereForAttack =
Me.GetAbilityById(Buttons.First(x => x.IsActive && x.Type == TypeEnum.Attack).Id);
if (activeSphereForAttack.CanBeCasted())
{
if (CheckForModifiers)
{
var countOfModifiers =
Me.Modifiers.Count(x => x.Name == $"modifier_{activeSphereForAttack.Id}_instance");
if (countOfModifiers >= 3)
{
return;
}
for (var i = countOfModifiers; i < 3; i++)
{
activeSphereForAttack.UseAbility();
}
InChanging.Sleep(250);
}
else
{
InChanging.Sleep(250);
activeSphereForAttack.UseAbility();
activeSphereForAttack.UseAbility();
activeSphereForAttack.UseAbility();
}
}
}
else if (order == OrderId.MoveLocation || order == OrderId.MoveTarget)
{
if (args.Target != null && args.Target.NetworkName == ClassId.CDOTA_BaseNPC_Healer.ToString())
{
return;
}
if (_multySleeper.Sleeping("move"))
{
return;
}
_multySleeper.Sleep(250, "move");
var activeSphereForMove =
Me.GetAbilityById(Buttons.First(x => x.IsActive && x.Type == TypeEnum.Move).Id);
if (VerySmartSpheres)
{
if (UnitExtensions.HealthPercent(Me) <= HpSlider / 100f)
{
if (_config.Main.AbilitiesInCombo.Quas.Level > 0)
{
activeSphereForMove = _config.Main.AbilitiesInCombo.Quas;
}
else
{
activeSphereForMove = _config.Main.AbilitiesInCombo.Wex;
}
}
else
{
if (_config.Main.AbilitiesInCombo.Wex.Level > 0)
{
activeSphereForMove = _config.Main.AbilitiesInCombo.Wex;
}
else
{
activeSphereForMove = _config.Main.AbilitiesInCombo.Quas;
}
}
foreach (var typeButton in Buttons.Where(x => x.Type == TypeEnum.Move))
{
typeButton.IsActive = typeButton.Id == activeSphereForMove.Id;
}
}
if (activeSphereForMove.CanBeCasted())
{
if (CheckForModifiers)
{
var countOfModifiers =
Me.Modifiers.Count(x => x.Name == $"modifier_{activeSphereForMove.Id}_instance");
if (countOfModifiers >= 3)
{
return;
}
for (var i = countOfModifiers; i < 3; i++)
{
activeSphereForMove.UseAbility();
}
InChanging.Sleep(250);
}
else
{
InChanging.Sleep(250);
activeSphereForMove.UseAbility();
activeSphereForMove.UseAbility();
activeSphereForMove.UseAbility();
}
}
}
if (!args.IsPlayerInput)
{
if (!InChanging.Sleeping && order == OrderId.Ability)
{
var abilityId = args.Ability.Id;
if (abilityId == AbilityId.invoker_quas || abilityId == AbilityId.invoker_wex ||
abilityId == AbilityId.invoker_exort || abilityId == AbilityId.invoker_invoke ||
abilityId == AbilityId.invoker_ghost_walk)
{
_multySleeper.Sleep(250, "attack");
_multySleeper.Sleep(250, "move");
//InvokerCrappahilationPaid.Log.Warn($"On Sleep");
}
}
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (!await this.ShouldExecute(token))
{
return;
}
var blink = this.EmberSpirit.BlinkDagger;
if (blink != null)
{
this.MaxTargetRange = Math.Max(this.MaxTargetRange, blink.CastRange + 1200 * 1.3f);
}
else if (blink == null)
{
this.MaxTargetRange = Math.Max(this.MaxTargetRange, 2000);
}
if ((this.CurrentTarget == null) || !this.CurrentTarget.IsVisible)
{
this.EmberSpirit.Context.Orbwalker.Active.OrbwalkTo(null);
return;
}
if (this.CurrentTarget.IsIllusion)
{
this.OrbwalkToTarget();
return;
}
try
{
var linkens = this.CurrentTarget.IsLinkensProtected();
await BreakLinken(token);
var ulti = this.EmberSpirit.FireRemnant;
var activator = this.EmberSpirit.ActiveFireRemnant;
var mod = this.Owner.FindModifier("modifier_ember_spirit_fire_remnant_charge_counter");
var stacks = mod?.StackCount;
var dagger = this.EmberSpirit.BlinkDagger;
var w = this.EmberSpirit.Fist;
var q = this.EmberSpirit.SearingChains;
var prediction =
this.EmberSpirit.Context.Prediction.GetPrediction(
this.EmberSpirit.FistPredictionInput(this.CurrentTarget));
if (dagger != null && dagger.CanBeCasted && this.Owner.Distance2D(this.CurrentTarget) <= dagger.CastRange + w.CastRange &&
this.Owner.Distance2D(this.CurrentTarget) >= 350)
{
dagger.UseAbility(this.CurrentTarget.NetworkPosition.Extend(this.CurrentTarget.NetworkPosition, 1200));
await Task.Delay(dagger.GetCastDelay(this.CurrentTarget.NetworkPosition), token);
}
var veil = this.EmberSpirit.VeilOfDiscord;
if (veil != null && veil.CanBeCasted && veil.CanHit(this.CurrentTarget))
{
veil.UseAbility(this.CurrentTarget.NetworkPosition);
await Task.Delay(veil.GetCastDelay(this.CurrentTarget.NetworkPosition), token);
}
if (
this.Owner.HasModifiers(new[]
{
"modifier_ember_spirit_sleight_of_fist_caster",
"modifier_ember_spirit_fire_remnant"
}, false))
{
if (!this.Owner.IsSilenced() && q.CanBeCasted && q.CanHit(this.CurrentTarget) &&
!this.CurrentTarget.IsMagicImmune() && this.Owner.Distance2D(this.CurrentTarget) <= 350)
{
q.UseAbility();
await Task.Delay(125, token);
}
return;
}
if (w.CanBeCasted && this.Owner.Distance2D(prediction.CastPosition) <= 1400 && !UnitExtensions.IsEthereal(this.CurrentTarget))
{
w.UseAbility(prediction.CastPosition);
await Task.Delay(1, token);
}
if (stacks - this.EmberSpirit.LeaveSpirits.Value.Value > 0 && this.CurrentTarget.IsRooted())
{
for (int i = 0; i < stacks.Value - this.EmberSpirit.LeaveSpirits.Value.Value; i++)
{
ulti.UseAbility(this.CurrentTarget.NetworkPosition);
await Task.Delay(ulti.GetCastDelay(), token);
}
}
else
{
var anySpirits = EntityManager <Entity> .Entities.Any(
x => x.Name == "npc_dota_ember_spirit_remnant" && x.Distance2D(this.CurrentTarget) <= 450);
if (anySpirits)
{
await Task.Delay(150, token);
activator.UseAbility(this.CurrentTarget.NetworkPosition);
await Task.Delay(activator.GetCastDelay(), token);
}
}
if (q.CanBeCasted && this.Owner.Distance2D(this.CurrentTarget) <= 350)
{
q.UseAbility();
await Task.Delay(125, token);
}
var e = this.EmberSpirit.FlameGuard;
if (e.CanBeCasted && this.Owner.Distance2D(this.CurrentTarget) <= 300)
{
e.UseAbility();
await Task.Delay(e.GetCastDelay(), token);
}
var abyssal = this.EmberSpirit.AbyssalBlade;
if (abyssal != null && abyssal.CanBeCasted && abyssal.CanHit(CurrentTarget) && !linkens &&
this.EmberSpirit.AbyssalBladeHeroes.Value.IsEnabled(CurrentTarget.Name))
{
abyssal.UseAbility(CurrentTarget);
await Task.Delay(abyssal.GetCastDelay(), token);
}
var ethereal = this.EmberSpirit.EtherealBlade;
if (ethereal != null && ethereal.CanBeCasted && ethereal.CanHit(CurrentTarget) && !linkens)
{
ethereal.UseAbility(CurrentTarget);
await Task.Delay(ethereal.GetCastDelay(), token);
}
var hex = this.EmberSpirit.Sheepstick;
if (hex != null && hex.CanBeCasted && hex.CanHit(CurrentTarget) && !linkens &&
this.EmberSpirit.HexHeroes.Value.IsEnabled(CurrentTarget.Name))
{
hex.UseAbility(CurrentTarget);
await Task.Delay(hex.GetCastDelay(), token);
}
var shivas = this.EmberSpirit.ShivasGuard;
if (shivas != null && shivas.CanBeCasted && this.Owner.Distance2D(this.CurrentTarget) <= 400)
{
shivas.UseAbility();
await Task.Delay(shivas.GetCastDelay(), token);
}
var manta = this.EmberSpirit.Manta;
if (manta != null && manta.CanBeCasted && this.Owner.Distance2D(CurrentTarget) <= 200 &&
this.EmberSpirit.MantaHeroes.Value.IsEnabled(CurrentTarget.Name))
{
manta.UseAbility();
await Task.Delay(manta.GetCastDelay(), token);
}
var nullifier = this.EmberSpirit.Nullifier;
if (nullifier != null && nullifier.CanBeCasted && nullifier.CanHit(CurrentTarget) && !linkens &&
this.EmberSpirit.NullifierHeroes.Value.IsEnabled(CurrentTarget.Name))
{
nullifier.UseAbility(CurrentTarget);
await Task.Delay(nullifier.GetCastDelay(), token);
}
var mjollnir = this.EmberSpirit.Mjollnir;
if (mjollnir != null && mjollnir.CanBeCasted && this.Owner.Distance2D(this.CurrentTarget) <= 400)
{
mjollnir.UseAbility(this.Owner);
await Task.Delay(mjollnir.GetCastDelay(), token);
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Debug($"{e}");
}
this.OrbwalkToTarget();
}
public async Task <bool> UseAbility(Hero target, CancellationToken token)
{
var comboModifiers = target.HasModifiers(new[]
{
"modifier_obsidian_destroyer_astral_imprisonment_prison", "modifier_eul_cyclone",
"modifier_shadow_demon_disruption", "modifier_invoker_tornado"
}, false);
float time;
var isStunned = target.IsStunned(out time);
switch (Ability.Id)
{
case AbilityId.invoker_cold_snap:
if (target.IsMagicImmune())
{
return(false);
}
Ability.UseAbility(target);
break;
case AbilityId.invoker_ghost_walk:
Ability.UseAbility();
break;
case AbilityId.invoker_tornado:
if (comboModifiers && isStunned)
{
return(true);
}
if (!Ability.CastSkillShot(target))
{
return(false);
}
AfterTornado.Sleep((float)Ability.GetHitDelay(target) * 1000);
break;
case AbilityId.invoker_emp:
if (AfterTornado.Sleeping)
{
return(false);
}
Ability.UseAbility(target.Position);
break;
case AbilityId.invoker_alacrity:
Ability.UseAbility(Ability.Owner as Hero);
break;
case AbilityId.invoker_chaos_meteor:
if (AfterTornado.Sleeping)
{
return(false);
}
if (comboModifiers && isStunned)
{
var timing = 1.3f;
if (time <= timing + Game.Ping / 1000)
{
Ability.UseAbility(target.Position);
}
else
{
await Task.Delay((int)((time - timing + Game.Ping / 1000) * 1000), token);
Ability.UseAbility(target.Position);
}
}
else
{
if (target.HasModifier("modifier_invoker_cold_snap"))
{
Ability.UseAbility(target.Position);
}
else if (!Ability.CastSkillShot(target))
{
return(false);
}
}
break;
case AbilityId.invoker_sun_strike:
if (AfterTornado.Sleeping)
{
return(false);
}
if (comboModifiers && isStunned)
{
var timing = 1.7f;
if (time <= timing + Game.Ping / 1000)
{
Ability.UseAbility(target.Position);
}
else
{
var timeForCast = timing + Me.Config.SsExtraDelay / 100f + Game.Ping / 1000;
var delayTime = (int)((time - timeForCast) * 1000);
Log.Warn($"[SS] delay time: {delayTime} rem time: {time} Time for cast: {timeForCast}");
await Task.Delay(delayTime, token);
Ability.UseAbility(target.Position);
}
}
else
{
if (!Ability.CastSkillShot(target))
{
return(false);
}
}
break;
case AbilityId.invoker_forge_spirit:
Ability.UseAbility();
break;
case AbilityId.invoker_ice_wall:
if (Me.Config.AutoIceWall)
{
var angle = UnitExtensions.FindRotationAngle(ObjectManager.LocalHero,
target.NetworkPosition);
//if (Ensage.SDK.Extensions.EntityExtensions.Distance2D(target, Ability.Owner) > 300 || angle>0.99)
while (Ensage.SDK.Extensions.EntityExtensions.Distance2D(target, Ability.Owner) > 300 ||
angle > 0.99)
{
angle = UnitExtensions.FindRotationAngle(ObjectManager.LocalHero,
target.NetworkPosition);
var hero = Ability.Owner as Hero;
hero?.Move(target.NetworkPosition);
Log.Debug(
$"Dist: [{Ensage.SDK.Extensions.EntityExtensions.Distance2D(target, Ability.Owner)}] angle: [{angle}]");
await Task.Delay(100, token);
}
Ability.UseAbility();
}
else
{
if (IceWallCanHit(target))
{
Me.BlockerSleeper.Sleep(300);
Me.Owner.Stop();
//Me.Owner.Move(Me.Owner.NetworkPosition + UnitExtensions.Direction(Me.Owner, 10));
//await Task.Delay(100, token);
Ability.UseAbility();
await Task.Delay(300, token);
}
else
{
return(false);
}
}
break;
case AbilityId.invoker_deafening_blast:
if (target.IsMagicImmune())
{
return(false);
}
if (!Ability.CastSkillShot(target))
{
return(false);
}
break;
case AbilityId.item_cyclone:
if (comboModifiers && isStunned)
{
return(true);
}
Ability.UseAbility(target);
await WaitForCombo(target);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(true);
}
public async Task <bool> UseItems(UnitBase unitBase)
{
if (!unitBase.Hero.CanUseItems())
{
return(true);
}
if (unitBase is Tempest)
{
var ability = unitBase.Hero.GetItemById(ItemId.item_sphere);
if (ability != null && ability.CanBeCasted() && ability.CanHit(Core.MainHero.Hero))
{
ability.UseAbility(Core.MainHero.Hero);
var delayTime = ability.GetAbilityDelay();
Printer.Both(
$"[{unitBase}][Linken] To main hero-> ({delayTime})");
await Await.Delay(delayTime, Core.ComboToken.Token);
}
if (OrderManager.CurrentOrder is DefaultCombo)
{
ability = unitBase.Hero.GetItemById(ItemId.item_solar_crest) ??
unitBase.Hero.GetItemById(ItemId.item_medallion_of_courage);
if (ability != null && ability.CanBeCasted() && ability.CanHit(Core.MainHero.Hero))
{
ability.UseAbility(Core.MainHero.Hero);
var delayTime = ability.GetAbilityDelay();
Printer.Both(
$"[{unitBase}][Solar] To main hero-> ({delayTime})");
await Await.Delay(delayTime, Core.ComboToken.Token);
}
}
}
var counter = 0;
foreach (var ability in unitBase.GetItems())
{
if (!ability.CanBeCasted(Core.Target))
{
Printer.Log($"cant use {ability.Name} to {Core.Target.Name}");
continue;
}
var canHit = (ability.Id == AbilityId.item_blink
? unitBase.Hero.Distance2D(Core.Target) - MenuManager.GetBlinkExtraRange <
(MenuManager.BlinkUseExtraRange ? ability.TravelDistance() : 50000)
: ability.CanHit(Core.Target)) || _afterBlink.Sleeping;
var isNoTarget = ability.IsAbilityBehavior(AbilityBehavior.NoTarget) &&
(unitBase.Hero.Distance2D(Core.Target) <= 750 || ability.IsInvis());
if (!canHit && !isNoTarget)
{
Printer.Both($"{ability.Name} cant hit target!");
continue;
}
/*if (isNoTarget && unitBase.Hero.Distance2D(Core.Target)>=800)
* continue;*/
// if (canHit || _afterBlink)
if (_afterInvis.Sleeping || unitBase.Hero.IsInvisible())
{
Printer.Both($"{ability.Name} cant cast, cuz under invis!");
continue;
}
var delayTime = 0;
if (ability.IsAbilityBehavior(AbilityBehavior.NoTarget))
{
if (ability.IsInvis())
{
var blink = unitBase.Hero.GetItemById(ItemId.item_blink);
if (blink != null && blink.CanBeCasted())
{
if (MenuManager.SilverEdgeBlocker)
{
counter++;
continue;
}
}
_afterInvis.Sleep(500);
}
if (ability.Id == AbilityId.item_satanic && UnitExtensions.HealthPercent(unitBase.Hero) > 0.7f)
{
counter++;
continue;
}
ability.UseAbility();
}
else if (ability.IsAbilityBehavior(AbilityBehavior.UnitTarget))
{
if (ability.Id == AbilityId.item_hurricane_pike)
{
ability.UseAbility(unitBase.Hero);
}
else if (ability.TargetTeamType == TargetTeamType.Enemy || ability.TargetTeamType == TargetTeamType.All ||
ability.TargetTeamType == TargetTeamType.Custom || ability.TargetTeamType == (TargetTeamType)7)
{
var amWithAghUnderLinken = Core.Target.ClassId == ClassId.CDOTA_Unit_Hero_AntiMage &&
Core.Target.GetItemById(ItemId.item_ultimate_scepter) != null &&
Core.Target.GetAbilityById(AbilityId.antimage_spell_shield)
.CanBeCasted();
var isDisable = ability.IsDisable();
if ((Core.Target.IsLinkensProtected() || amWithAghUnderLinken) &&
(isDisable || ability.IsDagon() || ability.Id == AbilityId.item_ethereal_blade || ability.Id == AbilityId.item_nullifier))
{
counter++;
continue;
}
if (ability.Id == AbilityId.item_ethereal_blade &&
unitBase.GetItems()
.Any(
x =>
(x.Id == AbilityId.item_dagon || x.Id == AbilityId.item_dagon_2 ||
x.Id == AbilityId.item_dagon_3 || x.Id == AbilityId.item_dagon_4 ||
x.Id == AbilityId.item_dagon_5) && x.CanBeCasted()))
{
ability.UseAbility(Core.Target);
await Core.Target.WaitGainModifierAsync("modifier_item_ethereal_blade_ethereal", 2,
Core.ComboToken.Token);
}
else
{
var slarkMod =
Core.Target.HasModifiers(
new[] { "modifier_slark_dark_pact", "modifier_slark_dark_pact_pulses" }, false);
var lotusMid = Core.Target.HasModifier("modifier_item_lotus_orb_active");
if ((slarkMod || lotusMid) && isDisable && ability.Id != AbilityId.item_sheepstick)
{
counter++;
continue;
}
if (ability.Id == AbilityId.item_sheepstick && GlobalHexSleeper.Sleeping)
{
counter++;
continue;
}
if ((ability.Id == AbilityId.item_orchid ||
ability.Id == AbilityId.item_bloodthorn) && GlobalOrchidSleeper.Sleeping)
{
counter++;
continue;
}
if (isDisable)
{
if (Core.Target.IsUnitState(UnitState.Stunned) ||
Core.Target.IsUnitState(UnitState.Hexed))
{
var time = Ensage.Common.Utils.DisableDuration(Core.Target);
if (time >= 0.35f + Game.Ping / 1000)
{
counter++;
continue;
}
}
ability.UseAbility(Core.Target);
GlobalHexSleeper.Sleep(800);
}
else
{
if (ability.IsSilence()) //TODO: check only for real silence
{
if (
Core.Target.HasModifiers(
new[] { "modifier_orchid_malevolence_debuff", "modifier_bloodthorn_debuff" },
false)) //(Core.Target.IsSilenced())
{
counter++;
continue;
}
GlobalOrchidSleeper.Sleep(800);
}
ability.UseAbility(Core.Target);
}
}
}
else
{
ability.UseAbility(unitBase.Hero);
}
}
else
{
if (ability.Id == AbilityId.item_blink)
{
_afterBlink.Sleep(1000);
var pos = (Core.Target.NetworkPosition - unitBase.Hero.NetworkPosition).Normalized();
var firstDist = Core.Target.NetworkPosition.Distance2D(unitBase.Hero.NetworkPosition);
pos *= firstDist <= ability.TravelDistance() ? 50 : MenuManager.GetBlinkExtraRange;
pos = Core.Target.NetworkPosition - pos;
if (pos.Distance2D(unitBase.Hero.NetworkPosition) < MenuManager.GetBlinkMinRange)
{
counter++;
continue;
}
ability.UseAbility(pos);
await Task.Delay((int)MenuManager.GetBlinkExtraDelay, Core.ComboToken.Token);
}
else
{
ability.UseAbility(Core.Target.Position);
}
}
delayTime = ability.GetAbilityDelay(Core.Target);
Printer.Both(
$"[{unitBase}][item] {ability.Name} ({delayTime}) [After Blink: {_afterBlink.Sleeping}] [{ability.TravelDistance()}]");
await Await.Delay(delayTime, Core.ComboToken.Token);
//await Task.Delay(150, Core.ComboToken.Token);
}
Printer.Log("now we can use abilities -> " + (unitBase.GetItems().Count(x => x.CanBeCasted()) <= counter));
return(unitBase.GetItems().Count(x => x.CanBeCasted()) <= counter);
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (!await this.ShouldExecute(token) || this.Owner.IsChanneling())
{
return;
}
if ((this.CurrentTarget == null) || !this.CurrentTarget.IsVisible || UnitExtensions.IsInvulnerable(this.CurrentTarget))
{
this.Nevermore.Context.Orbwalker.Active.OrbwalkTo(null);
return;
}
if (this.CurrentTarget.IsIllusion)
{
this.OrbwalkToTarget();
return;
}
if (this.CurrentTarget != null && this.Owner.HasModifier("modifier_item_silver_edge_windwalk"))
{
this.Owner.Attack(this.CurrentTarget);
await Task.Delay(100, token);
}
if ((this.Nevermore.BlinkDagger != null) &&
(this.Nevermore.BlinkDagger.Item.IsValid) && Owner.Distance2D(this.CurrentTarget) <= 1200 + 350 &&
!(Owner.Distance2D(this.CurrentTarget) <= 400) &&
this.Nevermore.BlinkDagger.CanBeCasted && this.Nevermore.UseBlink)
{
var l = (this.Owner.Distance2D(this.CurrentTarget) - 350) / 350;
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.Nevermore.BlinkDagger.UseAbility(position);
await Task.Delay(this.Nevermore.BlinkDagger.GetCastDelay(position), token);
}
var linkens = this.CurrentTarget.IsLinkensProtected();
await BreakLinken(token, this.CurrentTarget);
var veil = this.Nevermore.VeilOfDiscord;
if (veil != null && veil.CanBeCasted && veil.CanHit(CurrentTarget) &&
this.Nevermore.VeilOfDiscordHeroes.Value.IsEnabled(CurrentTarget.Name))
{
veil.UseAbility(CurrentTarget.Position);
await Task.Delay(veil.GetCastDelay(), token);
}
var sheep = this.Nevermore.Sheepstick;
if (sheep != null && sheep.CanBeCasted && !linkens &&
(this.Nevermore.HexHeroes.Value.IsEnabled(this.CurrentTarget.Name)))
{
sheep.UseAbility(CurrentTarget);
await Task.Delay(sheep.GetCastDelay(), token);
}
var ethereal = this.Nevermore.EtherealBlade;
if (ethereal != null && ethereal.CanBeCasted && ethereal.CanHit(CurrentTarget) && !linkens &&
this.Nevermore.EtherealHeroes.Value.IsEnabled(CurrentTarget.Name))
{
ethereal.UseAbility(CurrentTarget);
await Task.Delay(ethereal.GetCastDelay(this.CurrentTarget), token);
}
var dagon = this.Nevermore.Dagon;
if ((ethereal == null || !ethereal.CanBeCasted) && dagon != null && dagon.CanBeCasted && !linkens &&
dagon.CanHit(this.CurrentTarget))
{
dagon.UseAbility(this.CurrentTarget);
await Task.Delay(dagon.GetCastDelay(), token);
}
var shivas = this.Nevermore.ShivasGuard;
if (!this.Owner.IsChanneling() && shivas != null && shivas.CanBeCasted && Owner.Distance2D(CurrentTarget) <= 700)
{
shivas.UseAbility();
await Task.Delay(shivas.GetCastDelay(), token);
}
var bloodthorn = this.Nevermore.BloodThorn;
if (bloodthorn != null && bloodthorn.CanBeCasted && bloodthorn.CanHit(CurrentTarget) && !linkens &&
this.Nevermore.OrchidBloodthornHeroes.Value.IsEnabled(CurrentTarget.Name))
{
bloodthorn.UseAbility(CurrentTarget);
await Task.Delay(bloodthorn.GetCastDelay(), token);
}
var orchid = this.Nevermore.Orchid;
if (orchid != null && orchid.CanBeCasted && orchid.CanHit(CurrentTarget) && !linkens &&
this.Nevermore.OrchidBloodthornHeroes.Value.IsEnabled(CurrentTarget.Name))
{
orchid.UseAbility(CurrentTarget);
await Task.Delay(orchid.GetCastDelay(), token);
}
var atos = this.Nevermore.RodOfAtos;
if (atos != null && atos.CanBeCasted && atos.CanHit(CurrentTarget) && !linkens &&
this.Nevermore.AtosHeroes.Value.IsEnabled(CurrentTarget.Name))
{
atos.UseAbility(CurrentTarget);
await Task.Delay(atos.GetCastDelay(), token);
}
var halberd = this.Nevermore.HeavensHalberd;
if (halberd != null && halberd.CanBeCasted && halberd.CanHit(CurrentTarget) && !linkens &&
this.Nevermore.AtosHeroes.Value.IsEnabled(CurrentTarget.Name))
{
halberd.UseAbility(CurrentTarget);
await Task.Delay(halberd.GetCastDelay(), token);
}
try
{
// Log.Debug($"{Nevermore.Razes.ToString()}");
if (Nevermore.Razes != null)
{
foreach (
var raze in
Nevermore.Razes.OrderBy(
x => this.Owner.Distance2D(this.Owner.InFront(AbilityExtensions.GetAbilitySpecialData(x, "shadowraze_range")))))
{
if (CurrentTarget == null || UnitExtensions.IsMagicImmune(CurrentTarget) || raze == null ||
!raze.CanBeCasted() || this.Owner.IsSilenced() ||
!this.Nevermore.CanHit(raze, CurrentTarget, Nevermore.GetRazeDelay(CurrentTarget, raze)) || !this.CurrentTarget.IsAlive ||
UnitExtensions.IsInvulnerable(this.CurrentTarget))
{
continue;
}
/*if (raze == this.Nevermore.RazeLong && this.Owner.Distance2D(this.CurrentTarget) >= 730)
* {
* return;
* }
* else
* {*/
raze.UseAbility();
await Task.Delay((int)raze.GetCastDelay(this.Owner, this.CurrentTarget, true) + 100, token);
//}
}
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Debug(e);
}
if (!this.Nevermore.RazeShort.IsInAbilityPhase && !this.Nevermore.RazeMedium.IsInAbilityPhase &&
!this.Nevermore.RazeLong.IsInAbilityPhase)
{
this.OrbwalkToTarget();
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (!await this.ShouldExecute(token))
{
return;
}
if ((this.CurrentTarget == null) || !this.CurrentTarget.IsVisible)
{
this.hero.Context.Orbwalker.Active.OrbwalkTo(null);
return;
}
var items = this.hero.Items.Value;
//---------------------Ability----------------------
var Rage = this.hero._RageAbility;
var openwnd = this.hero._OpenWondAbility;
//------------------ITEM ABILITY-----------------
var diff = this.hero.DiffBlade;
var abysal = this.hero.AbyssalBlade;
var mlonir = this.hero.Mjollnir;
var blink = this.hero.BlinkDagger;
var solar = this.hero.SolarCrest;
var medalion = this.hero.Medalion;
var armlet = this.hero.Armlet;
//-----------------Function--------------------
var blinkReaady = (blink != null) && items.IsEnabled(blink.Ability.Name) && blink.CanBeCasted;
var duffusalReady = (diff != null) && items.IsEnabled(diff.Ability.Name) && diff.CanBeCasted;
var mjonirReady = (mlonir != null) && items.IsEnabled(mlonir.Ability.Name) && mlonir.CanBeCasted;
var AbisalReady = (abysal != null) && items.IsEnabled(abysal.Ability.Name) && abysal.CanBeCasted;
var solarReady = (solar != null) && items.IsEnabled(solar.Ability.Name) && solar.CanBeCasted;
var medalionReady = (medalion != null) && items.IsEnabled(medalion.Ability.Name) && medalion.CanBeCasted;
//-------------------------------------------------------------------------------------------------
var targetDistance = this.Owner.Distance2D(this.CurrentTarget);
var attackRange = UnitExtensions.AttackRange(this.CurrentTarget) + 100;
if (blinkReaady && !this.CurrentTarget.IsIllusion && blink.CanBeCasted && blink.CanHit(this.CurrentTarget) && (((targetDistance > attackRange))))
{
blink.UseAbility(this.CurrentTarget.Position);
await Task.Delay(blink.GetCastDelay(this.CurrentTarget.Position), token);
}
if ((openwnd != null) && openwnd.CanBeCasted() && openwnd.CanHit(this.CurrentTarget))
{
openwnd.UseAbility(this.CurrentTarget);
await Task.Delay(this.GetAbilityDelay(base.CurrentTarget, openwnd), token);
}
if ((Rage != null) && base.Owner.IsAttacking() && Rage.CanBeCasted())
{
Rage.UseAbility();
await Task.Delay(this.GetAbilityDelay(base.Owner, Rage), token);
}
if (mjonirReady && mlonir.CanBeCasted && mlonir.CanHit(this.CurrentTarget))
{
mlonir.UseAbility(this.Owner);
await Await.Delay(mlonir.GetCastDelay(), token);
}
if (!this.CurrentTarget.IsAttacking() && !this.CurrentTarget.IsIllusion)
{
if (AbisalReady && abysal.CanBeCasted && abysal.CanHit(this.CurrentTarget))
{
abysal.UseAbility(this.CurrentTarget);
await Task.Delay(abysal.GetCastDelay(this.CurrentTarget), token);
}
if (duffusalReady && diff.CanBeCasted && this.Owner.IsVisible && diff.CanHit(this.CurrentTarget))
{
diff.UseAbility(this.CurrentTarget);
await Await.Delay(diff.GetCastDelay(this.CurrentTarget), token);
}
if (solarReady && solar.CanBeCasted && this.Owner.IsVisible && solar.CanHit(this.CurrentTarget))
{
solar.UseAbility(this.CurrentTarget);
await Await.Delay(solar.GetCastDelay(this.CurrentTarget), token);
}
if (medalionReady && medalion.CanBeCasted && this.Owner.IsVisible && medalion.CanHit(this.CurrentTarget))
{
medalion.UseAbility(this.CurrentTarget);
await Await.Delay(medalion.GetCastDelay(this.CurrentTarget), token);
}
}
if ((armlet != null) && armlet.CanBeCasted && armlet.CanHit(this.CurrentTarget))
{
armlet.Enabled = false;
}
else
{
armlet.Enabled = true;
}
await Task.Delay(armlet.GetCastDelay(), token);
/* var isInvisible = this.Owner.IsInvisible() || (this.Owner.InvisiblityLevel > 0);
* if ((armlet != null) && !isInvisible)
* {
* var enemiesNear = EntityManager<Hero>.Entities.Any(
* x => x.IsVisible
* && x.IsAlive
* && !x.IsIllusion
* && (x.Team != this.Owner.Team)
* && (x.Distance2D(this.Owner) < 1000));
* if ((enemiesNear !=null) )
* {
* armlet.Enabled = false;
* }
* else
* {
* armlet.Enabled = true;
* }
*
* await Task.Delay(armlet.GetCastDelay(), token);
* }*/
this.OrbwalkToTarget();
}
public async Task <bool> UseAbility(Hero target, CancellationToken token)
{
var comboModifiers = target.HasModifiers(new[]
{
"modifier_obsidian_destroyer_astral_imprisonment_prison", "modifier_eul_cyclone",
"modifier_shadow_demon_disruption", "modifier_invoker_tornado"
}, false);
float time;
var isStunned = target.IsStunned(out time);
switch (Ability.Id)
{
case AbilityId.invoker_cold_snap:
if (target.IsMagicImmune())
{
return(false);
}
Ability.UseAbility(target);
break;
case AbilityId.invoker_ghost_walk:
Ability.UseAbility();
break;
case AbilityId.invoker_tornado:
if (comboModifiers && isStunned)
{
return(true);
}
if (!Ability.CastSkillShot(target))
{
return(false);
}
AfterTornado.Sleep((float)Ability.GetHitDelay(target) * 1000);
break;
case AbilityId.invoker_emp:
if (AfterTornado.Sleeping)
{
return(false);
}
Ability.UseAbility(target.Position);
break;
case AbilityId.invoker_alacrity:
Ability.UseAbility(Ability.Owner as Hero);
break;
case AbilityId.invoker_chaos_meteor:
if (AfterTornado.Sleeping)
{
return(false);
}
if (comboModifiers && isStunned)
{
var timing = 1.3f;
if (time <= timing + Game.Ping / 1000)
{
Ability.UseAbility(target.Position);
}
else
{
await Task.Delay((int)((time - timing + Game.Ping / 1000) * 1000), token);
Ability.UseAbility(target.Position);
}
}
else
{
//var blastModifier = target.FindModifier("modifier_invoker_deafening_blast_knockback");
//if (blastModifier == null)
//{
if (
target.HasModifiers(
new[] { "modifier_invoker_cold_snap", "modifier_invoker_deafening_blast_knockback" },
false))
{
Ability.UseAbility(target.NetworkPosition);
}
else if (!Ability.CastSkillShot(target))
{
return(false);
}
/*}
* else
* {
* var remTime = blastModifier.RemainingTime;
* var newPost
* }*/
}
break;
case AbilityId.invoker_sun_strike:
if (AfterTornado.Sleeping)
{
return(false);
}
if (comboModifiers && isStunned)
{
var cataclysm = Me.Config.Cataclysm &&
Me.Owner.GetAbilityById(AbilityId.special_bonus_unique_invoker_4)?.Level > 0;
var timing = cataclysm ? 1.73f : 1.7f;
if (time <= timing + Game.Ping / 1000)
{
if (cataclysm)
{
Ability.UseAbility(Me.Owner);
}
else
{
Ability.UseAbility(target.Position);
}
}
else
{
var timeForCast = timing + Me.Config.SsExtraDelay / 100f + Game.Ping / 1000;
var delayTime = (int)((time - timeForCast) * 1000);
Log.Warn($"[SS] delay time: {delayTime} rem time: {time} Time for cast: {timeForCast}");
await Task.Delay(Math.Max(delayTime, 30), token);
Log.Debug($"[SS] after delay -> try to use ability. cataclysm -> {cataclysm}");
if (cataclysm)
{
Ability.UseAbility(Me.Owner);
}
else
{
Ability.UseAbility(target.Position);
}
}
}
else
{
var cataclysm = Me.Config.Cataclysm &&
Me.Owner.GetAbilityById(AbilityId.special_bonus_unique_invoker_4)?.Level > 0;
if (cataclysm)
{
Ability.UseAbility(Me.Owner);
Log.Debug($"[SS] cataclysm casted");
}
else
{
if (!Ability.CastSkillShot(target))
{
Log.Debug($"[SS] SkillShot not casted");
return(false);
}
Log.Debug($"[SS] SkillShot casted");
}
}
break;
case AbilityId.invoker_forge_spirit:
var forges =
EntityManager <Unit> .Entities.Any(
x =>
x.IsValid && x.Team == Me.Owner.Team && x.ClassId == ClassId.CDOTA_BaseNPC_Invoker_Forged_Spirit &&
UnitExtensions.HealthPercent(x) > .55f);
if (!forges)
{
Ability.UseAbility();
}
break;
case AbilityId.invoker_ice_wall:
if (Me.Config.AutoIceWall)
{
var angle = UnitExtensions.FindRotationAngle(ObjectManager.LocalHero,
target.NetworkPosition);
//if (Ensage.SDK.Extensions.EntityExtensions.Distance2D(target, Ability.Owner) > 300 || angle>0.99)
while (Ensage.SDK.Extensions.EntityExtensions.Distance2D(target, Ability.Owner) > 300 ||
angle > 0.99)
{
angle = UnitExtensions.FindRotationAngle(ObjectManager.LocalHero,
target.NetworkPosition);
var hero = Ability.Owner as Hero;
hero?.Move(target.NetworkPosition);
Log.Debug(
$"Dist: [{Ensage.SDK.Extensions.EntityExtensions.Distance2D(target, Ability.Owner)}] angle: [{angle}]");
await Task.Delay(100, token);
}
Ability.UseAbility();
}
else
{
if (IceWallCanHit(target))
{
Me.BlockerSleeper.Sleep(300);
Me.Owner.Stop();
//Me.Owner.Move(Me.Owner.NetworkPosition + UnitExtensions.Direction(Me.Owner, 10));
//await Task.Delay(100, token);
Ability.UseAbility();
await Task.Delay(300, token);
}
else
{
return(false);
}
}
break;
case AbilityId.invoker_deafening_blast:
if (target.IsMagicImmune())
{
return(false);
}
if (!Ability.CastSkillShot(target))
{
return(false);
}
break;
case AbilityId.item_cyclone:
Log.Warn($"Eul -> start (modifiers: {comboModifiers}) (isStunned: {isStunned})");
if (comboModifiers && isStunned)
{
Log.Warn($"Eul -> Under shit");
return(true);
}
Ability.UseAbility(target);
Log.Warn($"Eul -> casted ({target.HeroId}). w8 for modifier");
await WaitForCombo(target, Ability);
Log.Warn($"Eul -> modifier was found");
break;
case AbilityId.item_refresher:
Ability.UseAbility();
break;
default:
throw new ArgumentOutOfRangeException();
}
return(true);
}
public static void OnUpdate(EventArgs args)
{
if (!MenuManager.IsEnable)
{
return;
}
if (!MenuManager.IsAutoDetonation)
{
return;
}
var spellAmp = 0;//UnitExtensions.GetSpellAmplification(Me);
foreach (var hero in Heroes.GetByTeam(EnemyTeam))
{
if (HeroSleeper.Sleeping(hero) || !hero.IsAlive || !hero.IsVisible || !hero.CanDie(MenuManager.CheckForAegis))
{
continue;
}
if (hero.HasModifiers(
new[]
{
"modifier_shredder_timber_chain", "modifier_storm_spirit_ball_lightning",
"modifier_item_aeon_disk_buff", "modifier_ember_spirit_sleight_of_fist_caster",
"modifier_ember_spirit_sleight_of_fist_caster_invulnerability"
},
false))
{
continue;
}
var listForDetonation = new List <BombManager>();
var heroHealth = hero.Health + hero.HealthRegeneration;
var rainrop = hero.GetItemById(ItemId.item_infused_raindrop);
if (rainrop != null && rainrop.CanBeCasted())
{
var extraHealth = 90f;//rainrop.GetAbilityData("magic_damage_block");
heroHealth += extraHealth;
}
//Console.WriteLine($"[{hero.GetRealName()}] Total Life -> {heroHealth}");
var reduction = RemoteMine.GetDamageReduction(hero);
var refraction = hero.FindModifier("modifier_templar_assassin_refraction_absorb");
var blockCount = refraction?.StackCount;
var aeon = UnitExtensions.GetItemById(hero, AbilityId.item_aeon_disk);
var breakHealthForAeon = hero.MaximumHealth * .8f;
float treshold = 0;
var heroid = hero.HeroId;
if (heroid == HeroId.npc_dota_hero_medusa)
{
var shield = hero.GetAbilityById(AbilityId.medusa_mana_shield);
if (shield.IsToggled)
{
treshold = shield.GetAbilityData("damage_per_mana");
}
}
var startManaCalc = hero.Mana;
foreach (var element in Bombs)
{
if (element.IsRemoteMine && element.Active)
{
if (element.CanHit(hero))
{
//Printer.Print($"BombDelay: {element.GetBombDelay(hero)} MaxDelay: {MenuManager.GetBombDelay}");
if (MenuManager.IsEnableDelayBlow &&
!(element.GetBombDelay(hero) >= MenuManager.GetBombDelay))
{
continue;
}
if (blockCount > 0)
{
blockCount--;
}
else
{
var damage = DamageHelpers.GetSpellDamage(element.Damage, spellAmp, reduction);
if (heroid == HeroId.npc_dota_hero_medusa)
{
BombDamageManager.CalcDamageForDusa(ref damage, ref startManaCalc, treshold);
}
heroHealth -= damage;
}
listForDetonation.Add(element);
var aeuoByPass = aeon != null && aeon.CanBeCasted() && heroHealth < breakHealthForAeon;
if (heroHealth <= 0 || aeuoByPass)
{
if (MenuManager.IsCameraMovingEnable)
{
if (MenuManager.CameraMovingType == 0)
{
var heroPos = hero.Position;
var consolePosition = $"{heroPos.X} {heroPos.Y}";
Game.ExecuteCommand($"dota_camera_set_lookatpos {consolePosition}");
}
else
{
var pos = hero.Position.WorldToMinimap();
SetCursorPos((int)pos.X, (int)pos.Y);
UpdateManager.BeginInvoke(() =>
{
mouse_event((int)MouseEvent.MouseeventfLeftdown, 0, 0, 0, 0);
mouse_event((int)MouseEvent.MouseeventfLeftup, 0, 0, 0, 0);
}, 100);
}
}
HeroSleeper.Sleep(300 + listForDetonation.Count * 30, hero);
if (MenuManager.IsSuperDetonate)
{
foreach (var manager in Bombs.Where(x => x.IsRemoteMine && x.Active && x.CanHit(hero)))
{
manager.Detonate();
}
}
else
{
foreach (var manager in listForDetonation)
{
manager.Detonate();
}
}
break;
}
}
}
}
}
}
