protected override async Task KillStealAsync(CancellationToken token)
{
if (Game.IsPaused || !this.Owner.IsAlive || !AbilityExtensions.CanBeCasted(this.SpectralDagger))
{
await Task.Delay(125, token);
return;
}
var killstealTarget = EntityManager <Hero> .Entities.FirstOrDefault(
x => x.IsAlive && x.Team != this.Owner.Team && AbilityExtensions.CanBeCasted(this.SpectralDagger) &&
AbilityExtensions.CanHit(this.SpectralDagger, x) &&
!x.IsIllusion &&
x.Health < SpectralDaggerDamage(this.SpectralDagger.Level - 1, x));
var hauntIllusions = EntityManager <Unit> .Entities.Where(x => x.Name == this.Owner.Name && x.IsAlive && x.IsIllusion && !x.IsInvulnerable() &&
x.IsAlly(this.Owner) && x.HasModifier("modifier_spectre_haunt")).ToList();
if (killstealTarget != null)
{
if (hauntIllusions.Count != 0)
{
if (Reality.UseAbility(killstealTarget.NetworkPosition))
{
var castDelay = AbilityExtensions.GetCastDelay(this.Reality, this.Owner, killstealTarget);
await this.AwaitKillstealDelay((int)castDelay + 20, token);
}
}
else if (AbilityExtensions.CanBeCasted(this.Haunt) && KillstealWithUlti && this.Owner.Distance2D(killstealTarget) > this.SpectralDagger.CastRange)
{
if (this.Haunt.UseAbility())
{
var castDelay = AbilityExtensions.GetCastDelay(this.Haunt, this.Owner, killstealTarget);
await this.AwaitKillstealDelay((int)castDelay + 20, token);
this.Reality.UseAbility(killstealTarget.NetworkPosition);
}
}
if (killstealTarget.Distance2D(this.Owner) <= this.SpectralDagger.CastRange)
{
if (this.SpectralDagger.UseAbility(killstealTarget))
{
var castDelay = AbilityExtensions.GetCastDelay(this.SpectralDagger, this.Owner, killstealTarget);
await this.AwaitKillstealDelay((int)castDelay, token);
}
}
}
await Task.Delay(125, token);
}
public static void OnUpdate(EventArgs args)
{
if (!MenuManager.IsEnableForceStaff || Updater.Sleeping || !MenuManager.IsEnable)
{
return;
}
Updater.Sleep(1);
var forceStuff = Core.Me.GetItemById(AbilityId.item_force_staff);
if (forceStuff != null && ItemExtensions.CanBeCasted(forceStuff))
{
foreach (var hero in Heroes.GetByTeam(Core.EnemyTeam))
{
if (Core.HeroSleeper.Sleeping(hero) || !hero.IsAlive || !hero.IsVisible ||
!hero.CanDie(MenuManager.CheckForAegis) || Prediction.IsTurning(hero) ||
!AbilityExtensions.CanHit(forceStuff, hero))
{
continue;
}
var heroPos = Prediction.InFront(hero, 600);
var heroHealth = hero.Health + hero.HealthRegeneration;
var reduction = Core.RemoteMine.GetDamageReduction(hero);
foreach (var element in Core.Bombs)
{
if (element.IsRemoteMine && element.Active)
{
if (element.CanHit(heroPos, hero))
{
heroHealth -= DamageHelpers.GetSpellDamage(element.Damage, 0, reduction);
if (heroHealth <= 0)
{
forceStuff.UseAbility(hero);
Core.HeroSleeper.Sleep(250, hero);
Updater.Sleep(250);
}
}
}
}
}
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (_target == null || !_target.IsValid || !_target.IsAlive)
{
if (!Main.Context.TargetSelector.IsActive)
{
Main.Context.TargetSelector.Activate();
}
_target = Main.Context.TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
if (_target != null)
{
Log.Info("target detected");
if (Main.Context.TargetSelector.IsActive)
{
Main.Context.TargetSelector.Deactivate();
}
}
else
{
Log.Info("Cant find target");
}
}
if (_target != null)
{
if (Owner.CanCastAbilities())
{
var grip = Main.Grip;
var roll = Main.Boulder;
var push = Main.Smash;
var ultimate = Main.Magnetize;
Unit stone = null;
if (IsAbilityEnable(push) && AbilityExtensions.CanBeCasted(push) &&
AbilityExtensions.CanHit(push, _target))
{
stone = Main.StoneManager.FindStone(Owner.NetworkPosition, 160f);
if (stone == null)
{
/*var turnTime = UnitExtensions.GetTurnTime(Owner,
* _target.NetworkPosition) * 1000 + Game.Ping;*/
await CreateStone(_target.NetworkPosition, token);
//Game.PrintMessage($"{turnTime}");
//await Await.Delay((int) turnTime, token);
//await Await.Delay(GetDelay, token);
stone = Main.StoneManager.FindStone(Owner.NetworkPosition, 160f);
Log.Info($"({GetDelay}) stone -> {stone != null}");
}
if (stone != null)
{
if (Main.Config.EnablePrediction)
{
if (!AbilityExtensions.CastSkillShot(push, _target))
{
Log.Error("Smash can't be casted due cant hit with prediction");
return;
}
}
else
{
push.UseAbility(_target.NetworkPosition);
Log.Info("Push");
}
await Await.Delay(GetDelay, token);
}
}
if (IsAbilityEnable(grip) && AbilityExtensions.CanBeCasted(grip) &&
AbilityExtensions.CanHit(grip, _target))
{
if (stone != null)
{
await StoneTracker(stone, token);
stone = Main.StoneManager.FindStone(_target.NetworkPosition, 180);
if (stone == null)
{
Log.Info("Stone == null (1)");
await CreateStone(_target.NetworkPosition, token);
stone = Main.StoneManager.FindStone(_target.NetworkPosition, 180);
Log.Info($"Stone -> {stone == null} (1)");
}
Log.Info("Grip");
grip.UseAbility(stone == null ? _target.NetworkPosition : stone.NetworkPosition);
await Await.Delay(GetDelay, token);
}
else
{
Log.Error("stone == null");
var created = await CreateStoneOnTarget(_target.NetworkPosition, token);
if (created)
{
grip.UseAbility(_target.NetworkPosition);
Log.Info("grip");
}
else
{
Log.Info("cant create new stone for grip");
}
}
}
if (IsAbilityEnable(roll) && AbilityExtensions.CanBeCasted(roll) &&
AbilityExtensions.CanHit(roll, _target))
{
if (stone == null)
{
if (!Main.StoneManager.AnyStoneInRange(Owner.NetworkPosition, 180))
{
await CreateStone(_target.NetworkPosition, token);
roll.UseAbility(_target.NetworkPosition);
Log.Info("new stone for rolling");
}
}
roll.UseAbility(_target.NetworkPosition);
Log.Info("roll");
await Await.Delay(GetDelay, token);
}
if (IsAbilityEnable(ultimate) && AbilityExtensions.CanBeCasted(ultimate) &&
AbilityExtensions.CanHit(ultimate, _target))
{
ultimate.UseAbility();
Log.Info("ultimate");
await Await.Delay(GetDelay, token);
}
}
if (UnitExtensions.CanUseItems(Owner))
{
await UseItems(token);
}
if (_target.IsAttackImmune() || _target.IsInvulnerable())
{
Orbwalker.Move(Game.MousePosition);
}
else
{
Orbwalker.OrbwalkTo(_target);
}
}
else
{
Orbwalker.Move(Game.MousePosition);
}
}
private async Task ExecuteAsync(CancellationToken token)
{
try
{
if (Game.IsPaused)
{
return;
}
Hero target = null;
if (Config.FamiliarsLock)
{
target = Config.FamiliarTarget;
}
else
{
target = Config.Target;
}
foreach (var unit in Main.Updater.AllOtherUnits)
{
var ability1 = unit.Ability;
var ability2 = unit.Ability2;
if (target != null)
{
if (!target.IsInvulnerable() && !target.IsAttackImmune() && !target.IsMagicImmune() &&
((ability1 != null && AbilityExtensions.CanBeCasted(ability1)) || (ability2 != null && AbilityExtensions.CanBeCasted(ability2))))
{
//Main.Log.Debug($"null? {ability1 != null}");
//Main.Log.Debug($"CanBeCasted? {AbilityExtensions.CanBeCasted(ability1)}");
//Main.Log.Debug($"TargetTeamType? {ability1?.TargetTeamType.ToString()}");
//Main.Log.Debug($"Distance2D? {unit.Unit.Distance2D(target) <= ability1?.CastRange}");
//Main.Log.Debug($"cast range {AbilityExtensions.GetRadius(ability1)}");
//Main.Log.Debug($"AbilityBehavior? {ability1?.AbilityBehavior.ToString()}");
//Main.Log.Debug($"AbilityBehavior? {ability1?.AbilityBehavior == AbilityBehavior.UnitTarget}");
if (ability1 != null &&
AbilityExtensions.CanBeCasted(ability1) &&
AbilityExtensions.CanHit(ability1, target) &&
(ability1.TargetTeamType == TargetTeamType.Enemy ||
ability1.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(target) <= ability1.CastRange - 70 ||
unit.Unit.Distance2D(target) <= AbilityExtensions.GetRadius(ability1) - 70))
{
if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
ability1.UseAbility();
await Task.Delay(250, token);
}
else if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
ability1.UseAbility(target);
await Task.Delay(250, token);
}
else if (ability1.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
ability1.UseAbility(target.Position);
await Task.Delay(250, token);
}
}
else if (ability1 != null &&
AbilityExtensions.CanBeCasted(ability1) &&
ability1.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= ability1.CastRange)
{
ability1.UseAbility(this.Owner);
await Task.Delay(250, token);
}
if (ability2 != null &&
AbilityExtensions.CanBeCasted(ability2) &&
AbilityExtensions.CanHit(ability2, target) &&
(ability2.TargetTeamType == TargetTeamType.Enemy ||
ability2.TargetTeamType == TargetTeamType.None) &&
(unit.Unit.Distance2D(target) <= ability2.CastRange - 70 ||
unit.Unit.Distance2D(target) <= AbilityExtensions.GetRadius(ability2) - 70))
{
if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
ability2.UseAbility();
await Task.Delay(250, token);
}
else if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.UnitTarget))
{
ability2.UseAbility(target);
await Task.Delay(250, token);
}
else if (ability2.AbilityBehavior.HasFlag(AbilityBehavior.Point))
{
ability2.UseAbility(target.Position);
await Task.Delay(250, token);
}
}
else if (ability2 != null &&
AbilityExtensions.CanBeCasted(ability2) &&
ability2.TargetTeamType == TargetTeamType.Allied &&
unit.Unit.Distance2D(this.Owner) <= ability2.CastRange)
{
ability2.UseAbility(this.Owner);
await Task.Delay(250, token);
}
unit.FamiliarMovementManager.Move(target.InFront(50));
}
if (target.IsInvulnerable() || target.IsAttackImmune())
{
unit.FamiliarMovementManager.Orbwalk(null);
}
else if (target.IsMagicImmune() ||
(!AbilityExtensions.CanBeCasted(ability1) || !AbilityExtensions.CanBeCasted(ability2)))
{
unit.FamiliarMovementManager.Orbwalk(target);
}
}
else
{
if (this.Config.FamiliarMenu.GetValue <bool>("Follow Mouse"))
{
unit.FamiliarMovementManager.Orbwalk(null);
}
else
{
unit.Unit.Follow(this.Owner);
await Task.Delay(350, token);
}
}
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Main.Log.Error(e);
}
}
