public override async Task ExecuteAsync(Unit target, CancellationToken tk = default(CancellationToken))
{
var invokeDelay = await this.UseInvokeAbilityAsync(target, tk);
Log.Debug($"ColdSnap {this.ExtraDelay()} | {invokeDelay}");
await Await.Delay(Math.Max(0, this.ExtraDelay() - invokeDelay), tk);
this.Ability.UseAbility(target);
}
public override async Task ExecuteAsync(Unit target, CancellationToken tk = default(CancellationToken))
{
var invokeDelay = await this.UseInvokeAbilityAsync(target, tk);
Log.Debug($"DeafeningBlast {this.ExtraDelay()} - {invokeDelay}");
await Await.Delay(Math.Max(0, this.ExtraDelay() - invokeDelay), tk);
this.Ability.UseAbility(target.NetworkPosition);
}
private async Task ReversePolarity(CancellationToken token, PredictionOutput OffOutput)
{
if (Config.AutoAbilitiesToggler.Value.IsEnabled(Main.ReversePolarity.Ability.Name))
{
// ReversePolarity
Main.ReversePolarity.UseAbility();
Click = true;
await Await.Delay(Main.ReversePolarity.GetCastDelay(), token);
}
}
public virtual async Task linken()
{
var e = TargetSelector.Active.GetTargets()
.FirstOrDefault(x => !x.IsInvulnerable() && x.IsAlive);
if (ExUnit.IsInvisible(me))
{
return;
}
var dagon = me.GetDagon();
if ((cyclone != null && cyclone.Item.CanBeCasted() || force != null && force.Item.CanBeCasted() ||
sheep != null && sheep.Item.CanBeCasted() || atos != null && atos.Item.CanBeCasted() || W != null && W.CanBeCasted()) &&
me.Distance2D(e) <= 900)
{
if (cyclone != null && cyclone.Item.CanBeCasted() &&
cyclone.Item.IsValid &&
Config.Link.Value.IsEnabled(cyclone.Item.Name))
{
cyclone.UseAbility(e);
}
else if (force != null &&
force.Item.IsValid && force.Item.CanBeCasted() &&
Config.Link.Value.IsEnabled(force.Item.Name))
{
force.UseAbility(e);
}
else if (atos != null && atos.Item.CanBeCasted() &&
atos.Item.IsValid &&
Config.Link.Value.IsEnabled(atos.Item.Name))
{
atos.UseAbility(e);
}
else if (dagon != null && dagon.CanBeCasted() &&
dagon.IsValid &&
Config.Link.Value.IsEnabled("item_dagon_5"))
{
dagon.UseAbility(e);
}
else if (W != null && W.CanBeCasted() &&
Config.Link.Value.IsEnabled(W.Name) &&
!ExUnit.IsMagicImmune(e))
{
W.UseAbility(e);
}
else if (sheep != null && sheep.Item.CanBeCasted() &&
sheep.Item.IsValid &&
Config.Link.Value.IsEnabled(sheep.Item.Name))
{
sheep.UseAbility(e);
}
}
await Await.Delay(250);
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
await HasNoLinkens(target, tk);
await UseItems(target, tk);
// make him disabled
await DisableEnemy(target, tk);
var illusions = (await CreateGetIllusions(int.MaxValue, true)).Where(x => x.Distance2D(MyHero) < 1000).ToList();
if (_ripTideAbility.IsAbilityEnabled() && _ripTideAbility.CanBeCasted(target) &&
(_ripTideAbility.CanHit(target) ||
illusions.Any(x => x.Distance2D(target) < _ripTideAbility.GetAbilityData("radius"))))
{
Log.Debug($"Using riptide on target");
_ripTideAbility.UseAbility();
await Await.Delay(GetAbilityDelay(_ripTideAbility), tk);
}
if (illusions.Any())
{
// move illusions to all enemies if possible, if none are available anymore, then to the target
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(x => x.IsValid && x.IsAlive && !x.IsIllusion && x.Team != MyHero.Team).ToList();
foreach (var illusion in illusions)
{
var enemy = enemies.OrderBy(x => x.Distance2D(illusion)).FirstOrDefault();
if (enemy == null)
{
illusion.Attack(target);
}
else
{
enemies.Remove(enemy);
illusion.Attack(enemy);
}
await Await.Delay(50, tk);
}
}
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk))
{
Log.Debug($"return because of blink");
return;
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
}
protected async Task <bool> MoveOrBlinkToEnemy(Unit target, CancellationToken tk = default(CancellationToken), float minimumRange = 0.0f, float maximumRange = 0.0f)
{
var distance = MyHero.Distance2D(target) - target.HullRadius - MyHero.HullRadius;
var testRange = maximumRange == 0.0f ? MyHero.GetAttackRange() : maximumRange;
if (distance <= testRange)
{
return(true);
}
if (!MyHero.IsMuted())
{
if (ZaioMenu.ShouldUseBlinkDagger)
{
var blink = MyHero.Inventory.Items.FirstOrDefault(x => x.ClassID == ClassID.CDOTA_Item_BlinkDagger);
if (blink != null && blink.CanBeCasted())
{
var blinkRange = blink.AbilitySpecialData.First(x => x.Name == "blink_range").Value;
if (distance <= blinkRange)
{
if (minimumRange == 0.0f)
{
minimumRange = MyHero.GetAttackRange() / 2;
}
var pos = (target.NetworkPosition - MyHero.NetworkPosition).Normalized();
pos *= minimumRange;
pos = target.NetworkPosition - pos;
blink.UseAbility(pos);
await Await.Delay((int)(MyHero.GetTurnTime(pos) * 1000) + ItemDelay, tk);
return(false);
}
}
}
var phaseBoots = MyHero.Inventory.Items.FirstOrDefault(x => x.Name == "item_phase_boots");
if (phaseBoots != null && phaseBoots.CanBeCasted())
{
phaseBoots.UseAbility();
await Await.Delay(ItemDelay, tk);
}
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
else
{
MyHero.Attack(target);
await Await.Delay(125, tk);
}
return(false);
}
public async Task UseAbilities(UnitBase unitBase)
{
var necr = unitBase as Necronomicon;
var ability = necr?.ManaBurn;
if (ability != null && ability.CanBeCasted(Core.Target) && ability.CanHit(Core.Target))
{
ability.UseAbility(Core.Target);
await Await.Delay(1000, Core.ComboToken.Token);
}
}
private async Task <IEnumerable <Hero> > CreateGetIllusions(int count = int.MaxValue, bool respectMenuSettings = false)
{
var useManta = new Func <Task <bool> >(async() =>
{
var manta = MyHero.GetItemById(ItemId.item_manta);
if (manta != null && (!respectMenuSettings || manta.IsAbilityEnabled()) && manta.CanBeCasted())
{
Log.Debug($"using manta");
manta.UseAbility();
await Await.Delay(150 + (int)Game.Ping);
await MyHero.WaitLossUnitStateAsync(UnitState.Flying |
UnitState.Unselectable);
return(true);
}
return(false);
});
var useIllu = new Func <Task <bool> >(async() =>
{
if ((!respectMenuSettings || _illuAbility.IsAbilityEnabled()) && _illuAbility.CanBeCasted())
{
// Stunned, Invulnerable, MagicImmune, Unselectable, Flying, FakeAlly
_illuAbility.UseAbility();
var delay = GetAbilityDelay(_illuAbility);
Log.Debug($"using mirror image with delay {delay}");
await Await.Delay(delay);
await MyHero.WaitLossUnitStateAsync(UnitState.Flying |
UnitState.Unselectable);
await Await.Delay(1000);
return(true);
}
return(false);
});
if (count <= 2)
{
if (await useManta())
{
return(MyIllusions);
}
}
else if (count == 3)
{
if (await useIllu())
{
return(MyIllusions);
}
}
await useIllu();
await useManta();
return(MyIllusions);
}
public override async Task ExecuteAsync(CancellationToken token = new CancellationToken())
{
while (OrderManager.CanBeExecuted)
{
if (!_myBase.Hero.IsAlive || _myBase.Hero.IsInvisible())
{
return;
}
await Spammer();
await Await.Delay(25, token);
}
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
if (!MyHero.IsSilenced() && _jumpAbility.CanBeCasted(target))
{
var radius = _jumpAbility.GetAbilityData("pounce_radius");
var range = _jumpAbility.GetAbilityData("pounce_distance");
var time = MyHero.Distance2D(target) / _jumpAbility.GetAbilityData("pounce_speed");
var pos = Prediction.Prediction.PredictPosition(target, (int)(time * 1000.0f), true);
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, MyHero.InFront(range), radius);
if (pos != Vector3.Zero && pos.Distance2D(MyHero) <= range && rec.IsInside(pos))
{
Log.Debug($"using jump");
_jumpAbility.UseAbility();
await Await.Delay((int)(_jumpAbility.FindCastPoint() * 1000.0f + Game.Ping), tk);
}
}
if (!MyHero.IsSilenced() && _purgeAbility.CanBeCasted(target) && _purgeAbility.CanHit(target) ||
MyHero.IsRooted())
{
Log.Debug($"using Q");
_purgeAbility.UseAbility();
await Await.Delay((int)(_purgeAbility.FindCastPoint() * 1000.0f + Game.Ping), tk);
}
await HasNoLinkens(target, tk);
await UseItems(target, tk);
// make him disabled
if (await DisableEnemy(target, tk) == DisabledState.UsedAbilityToDisable)
{
Log.Debug($"disabled!");
// return;
}
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk))
{
Log.Debug($"return because of blink");
return;
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
else
{
MyHero.Attack(target);
await Await.Delay(125, tk);
}
}
public virtual async Task WardsAttack()
{
var wardsShouldAttack = EntityManager <Unit> .Entities.Where(x => x.Name.Contains("npc_dota_shadow_shaman_ward") && x.CanAttack(Target));
foreach (var ward in wardsShouldAttack)
{
if (ward == null || !ward.IsValid || !ward.CanAttack(Target))
{
continue;
}
ward.Attack(Target);
await Await.Delay(150);
}
}
private static async Task UseSpells(Hero hero)
{
var mirrorImage = hero.FindSpell("naga_siren_mirror_image");
if (mirrorImage != null && mirrorImage.CanBeCasted())
{
mirrorImage.UseAbility();
int delay = (int)((mirrorImage.GetCastPoint(0) +
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);
return;
}
var conjureImage = hero.FindSpell("terrorblade_conjure_image");
if (conjureImage != null && conjureImage.CanBeCasted())
{
conjureImage.UseAbility();
int delay = (int)(conjureImage.GetCastPoint(0) * 1000.0f + 250.0f) + (int)Game.Ping;
Log.Debug($"using conjure image with delay {delay}");
await Await.Delay(delay);
return;
}
var doppelWalk = hero.FindSpell("phantom_lancer_doppelwalk");
if (doppelWalk != null && doppelWalk.CanBeCasted())
{
var pos = Game.MousePosition - hero.Position;
if (pos.Length() > doppelWalk.CastRange)
{
pos.Normalize();
pos *= doppelWalk.CastRange;
}
doppelWalk.UseAbility(hero.Position + pos);
int delay = (int)(doppelWalk.GetCastPoint(0) +
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);
// ReSharper disable once RedundantJumpStatement
return;
}
}
public virtual async Task KillStealAsync()
{
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.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 AutokillableTar =
ObjectManager.GetEntitiesFast <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);
}
if (!UnitExtensions.IsSilenced(Owner))
{
if (RemnantAutokillableTar != null && AutokillableTar == null || AutokillableTar != null && !UnitExtensions.HasModifier(Owner, "modifier_storm_spirit_overload"))
{
Remnant.UseAbility();
await Await.Delay((int)Game.Ping + 50);
Owner.Attack(RemnantAutokillableTar);
await Await.Delay(500);
}
}
}
public async Task <bool> CreateStoneOnTarget(Vector3 targetPos, CancellationToken arg)
{
var remnantCaller = Main.StoneCaller;
if (AbilityExtensions.CanBeCasted(remnantCaller))
{
remnantCaller.UseAbility(targetPos);
await Await.Delay(1, arg);
Main.Owner.Stop();
return(true);
}
return(false);
}
public override async Task ExecuteAsync(CancellationToken token = new CancellationToken())
{
while (OrderManager.CanBeExecuted)
{
if (!_myBase.Hero.IsAlive || _myBase.Hero.IsInvisible())
{
return;
}
/*await _myBase.TargetFinder(token);
* await _myBase.UseItems(token);
* await _myBase.UseAbilities(token);*/
await Await.Delay(25, token);
}
}
protected override async Task <bool> Killsteal()
{
if (await base.Killsteal())
{
return(true);
}
if (MyHero.IsSilenced())
{
return(false);
}
if (Target != null)
{
return(false);
}
if (_ultAbility.CanBeCasted())
{
var damage = _ultAbility.GetAbilityData("damage_per_health");
damage *= GetSpellAmp();
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsAlive && x.Team != MyHero.Team && _ultAbility.CanBeCasted(x) &&
_ultAbility.CanHit(x) && !x.IsIllusion &&
(((x.MaximumHealth - x.Health) * damage) * (1 - x.MagicDamageResist)) >= x.Health && !x.CantBeAttacked() &&
!x.CantBeKilled() && !x.IsLinkensProtected());
foreach (var enemy in enemies)
{
if (enemy != null)
{
Log.Debug($"use ulti for killsteal because {(((enemy.MaximumHealth - enemy.Health) * damage) * (1 - enemy.MagicDamageResist))} >= {enemy.Health}");
_ultAbility.UseAbility(enemy);
await Await.Delay(GetAbilityDelay(enemy, _ultAbility));
return(true);
}
}
}
return(false);
}
protected async Task Auto()
{
if (ControlledUnit.AttackCapability == AttackCapability.None)
{
Log.Debug($"no attack");
await Follow();
return;
}
var hero = _myHero.Hero;
var healthPerc = (float)ControlledUnit.Health / ControlledUnit.MaximumHealth;
var time = Game.RawGameTime;
if (_aura != null && !_isNecroUnit && (healthPerc <= 0.25f || !HasActiveSkill))
{
await Follow();
return;
}
if ((hero.IsAttacking() || time - _lastAttackingTime <= hero.AttackBackswing() * 2) &&
_myHero.ComboTarget == null)
{
_lastAttackingTime = time;
var target =
ObjectManager.GetEntitiesParallel <Unit>()
.FirstOrDefault(
x =>
x.IsValid && x.IsAlive && x.Team != hero.Team && hero.IsAttacking(x));
if (target != null)
{
Log.Debug($"attack {target.Name}");
ControlledUnit.Attack(target);
await Await.Delay(250);
}
else
{
Log.Debug($"is attacking but no target");
await Await.Delay(250);
await Follow();
}
}
else
{
Log.Debug($"combo target");
await AttackComboTarget();
}
}
private async Task MoveIllusionsAsync(CancellationToken arg)
{
var illusions = EntityManager <Hero> .Entities.Where(x => x.IsIllusion && x.IsAlive && x.IsControllable && x.Distance2D(this.owner) < this.config.IlluRange.Value)
.ToList();
if (!illusions.Any())
{
return;
}
var middlePosition = illusions.Aggregate(this.owner.Position, (current, illusion) => current + illusion.Position);
var unitCount = illusions.Count + 1;
middlePosition /= unitCount;
var illuAngle = 360.0f / unitCount;
Random random = null;
if (this.config.AngleRandomizer)
{
random = new Random();
}
// Log.Debug($"Moving illusions {illusions.Count}");
var currentHeroDir = this.heroTargetDirection;
foreach (var illusion in illusions)
{
if (random != null)
{
var randomAngle = random.NextFloat(1, illuAngle / unitCount);
currentHeroDir = currentHeroDir.Rotated(MathUtil.DegreesToRadians(illuAngle + randomAngle));
}
else
{
currentHeroDir = currentHeroDir.Rotated(MathUtil.DegreesToRadians(illuAngle));
}
var dir = currentHeroDir.Normalized();
dir *= this.config.MinMoveRange;
var movePos = middlePosition + dir;
illusion.Move(movePos);
await Await.Delay(125, arg);
}
await Await.Delay(250, arg);
}
public override async Task ExecuteAsync(Unit target, CancellationToken tk = default(CancellationToken))
{
var invokeDelay = await this.UseInvokeAbilityAsync(target, tk);
await Await.Delay(Math.Max(0, this.ExtraDelay() - invokeDelay), tk);
this.Ability.UseAbility();
DelayAction.Add(
250,
() =>
ObjectManager.GetEntitiesFast <Unit>()
.Where(x => x.ClassID == ClassID.CDOTA_BaseNPC_Invoker_Forged_Spirit)
.ToList()
.ForEach(x => x.Attack(target)));
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
if (!MyHero.IsSilenced())
{
if (_daggerAbility.CanBeCasted(target) && _daggerAbility.CanHit(target))
{
_daggerAbility.UseAbility(target);
Log.Debug($"using dagger!");
await Await.Delay(GetAbilityDelay(target, _daggerAbility), tk);
}
if (_blinkAbility.CanBeCasted(target) && _blinkAbility.CanHit(target))
{
_blinkAbility.UseAbility(target);
Log.Debug($"using blink!");
await Await.Delay(GetAbilityDelay(target, _blinkAbility), tk);
}
}
// make him disabled
if (await DisableEnemy(target, tk) == DisabledState.UsedAbilityToDisable)
{
Log.Debug($"disabled!");
// return;
}
await UseItems(target, tk);
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk))
{
Log.Debug($"return because of blink");
return;
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
Log.Debug($"orbwalking");
}
else
{
MyHero.Attack(target);
await Await.Delay(125, tk);
}
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
if (!await MoveOrBlinkToEnemy(target, tk)) //We want to initiate with blink first
{
return;
}
await HasNoLinkens(target, tk);
await UseItems(target, tk); //then use items to maximize ulti damage
await DisableEnemy(target, tk);
if (!MyHero.IsSilenced())
{
if (MyHero.Distance2D(target) <= _pulseAbility.GetAbilityData("area_of_effect"))
{
if (_pulseAbility.CanBeCasted() && _pulseAbility.CanHit(target) && MyHero.Mana - _pulseAbility.ManaCost >= _ultAbility.ManaCost)
{
Log.Debug($"using pulse to deal damage target");
_pulseAbility.UseAbility();
await Await.Delay(100, tk);
}
}
if (_ultAbility.CanBeCasted(target) && _ultAbility.CanHit(target) && await HasNoLinkens(target, tk))
{
var damage = _ultAbility.GetAbilityData("damage_per_health");
damage *= GetSpellAmp();
if (_ultAbility.CanHit(target) && (((target.MaximumHealth - target.Health) * damage) * (1 - target.MagicDamageResist)) >= target.Health) //Don't waste ulti if target is can't be killed by ulti
{
Log.Debug($"using ulti to kill enemy. {damage} > {target.Health}");
_ultAbility.UseAbility(target);
await Await.Delay(GetAbilityDelay(target, _ultAbility) + 250, tk);
}
}
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
else
{
MyHero.Attack(target);
await Await.Delay(125, tk);
}
}
public async Task ExecuteAsync(Vector3 target, CancellationToken tk = new CancellationToken())
{
if (this.Owner.Distance2D(target) <= this.EngageRange)
{
return;
}
await Await.Delay(this.ExtraDelay(), tk);
var pos = target - this.Owner.NetworkPosition;
pos.Normalize();
pos *= -InvokerMenu.SafeDistance;
pos = target + pos;
this.Ability.UseAbility(pos);
}
protected async Task <int> UseInvokeAbilityAsync(Unit target, CancellationToken tk = default(CancellationToken))
{
if (this.Ability.IsHidden)
{
var wait1 = await Await.Delay(100, tk);
Log.Debug($"Invoke {this.Ability.Name} - {100 + this.InvokeCooldown}- {100 + this.Invoke.Cooldown}");
// ReSharper disable once CompareOfFloatsByEqualityOperator
var hasCd = this.Invoke.Cooldown != 0;
var wait2 = await this.InvokeAbility(hasCd, tk);
return(wait1 + (hasCd ? this.InvokeCooldown : 0) + wait2); // InvokeCooldown;
}
return(0);
}
protected async Task Follow()
{
var hero = _myHero.Hero;
var distance = hero.Distance2D(ControlledUnit);
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(x => x.IsValid && x.IsAlive && x.Team != hero.Team && x.Distance2D(hero) < 1000);
if (!enemies.Any())
{
ControlledUnit.Follow(hero);
Log.Debug($"follow");
}
else
{
var pos = Vector3.Zero;
foreach (var enemy in enemies)
{
pos += enemy.NetworkPosition;
}
pos /= enemies.Count();
var dir = pos - hero.NetworkPosition;
dir.Normalize();
if (_aura != null)
{
dir *= _auraRadius / 2;
}
else
{
dir *= 500;
}
pos = hero.NetworkPosition - dir;
if (ControlledUnit.Distance2D(pos) < 75)
{
ControlledUnit.Hold();
}
else
{
ControlledUnit.Move(pos);
}
Log.Debug($"follow away from enemy");
}
await Await.Delay(100);
}
private async Task ChargeAwayFunc(CancellationToken tk)
{
if (!MyHero.IsSilenced() && _chargeAbility.CanBeCasted() && !MyHero.IsChanneling())
{
var enemy = ObjectManager.GetEntitiesParallel <Unit>().Where(
x =>
x.IsValid && x.IsAlive && x.Team != MyHero.Team && !(x is Building) &&
x.IsRealUnit() && _chargeAbility.CanBeCasted(x))
.OrderByDescending(x => x.Distance2D(MyHero))
.FirstOrDefault();
if (enemy != null)
{
Log.Debug($"Using charge away on {enemy.Name}");
_chargeAbility.UseAbility(enemy);
await Await.Delay((int)(_chargeAbility.FindCastPoint() * 1000.0 + Game.Ping), tk);
}
}
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
await UseItems(target, tk);
// make him disabled
await DisableEnemy(target, tk);
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
Log.Debug($"orbwalking");
}
else
{
MyHero.Attack(target);
await Await.Delay(125, tk);
}
}
protected override async Task ExecuteAsync(CancellationToken arg)
{
var mousePos = Game.MousePosition;
var myPos = Main.Owner.NetworkPosition;
var dist = myPos.Distance2D(mousePos);
if (myPos.Distance2D(mousePos) >= 1100)
{
Log.Debug($"out of range. [{dist}]");
return;
}
var push = Main.Smash;
if (push.CanBeCasted())
{
if (!Main.StoneManager.AnyStoneInRange(myPos, 160f))
{
var remnantCaller = Main.StoneCaller;
if (remnantCaller.CanBeCasted())
{
if (Main.Owner.IsMoving)
{
Main.Owner.Stop();
await Task.Delay(1, arg);
myPos = Main.Owner.NetworkPosition;
}
var pos = (myPos - mousePos).Normalized();
pos *= 100;
pos = myPos - pos;
remnantCaller.UseAbility(pos);
Log.Debug("Stone not found -> use remnant");
await Await.Delay(1, arg);
}
else
{
return;
}
}
push.UseAbility(mousePos);
Log.Debug("Stone not found -> use smash");
await Await.Delay(1, arg);
}
}
private async Task FarmJungle(List <Hero> illusions)
{
if (!illusions.Any())
{
Log.Debug($"no illus to farm the jungle!");
return;
}
var movespeed = (float)MyHero.MovementSpeed;
var jungleCamps = _availableCamps.Where(x => !x.Ancients).ToList();
Log.Debug($"Available camps: {jungleCamps.Count}");
foreach (var illusion in illusions.OrderBy(x => x.GetIllusionRemainingTime()))
{
var timeRemaining = illusion.GetIllusionRemainingTime();
// all camps are either cleared or already occupied by an illusion, so just send moar
if (!jungleCamps.Any())
{
jungleCamps = _availableCamps.Where(x => !x.Ancients).ToList();
}
foreach (var jungleCamp in jungleCamps.OrderBy(x => x.WaitPosition.Distance2D(illusion)))
{
var distance = jungleCamp.WaitPosition.Distance2D(illusion);
var timeToReachWaitPos = distance / movespeed;
// our illusions doesn't hold long enough to reach the camp
if (timeRemaining < timeToReachWaitPos)
{
Log.Debug($"{jungleCamp.Name}: {timeRemaining} < {timeToReachWaitPos}");
continue;
}
Log.Debug($"Moving illusion to farm {jungleCamp.Name}");
_farmJungleIllusions.Add(new JungleFarmer(illusion, jungleCamp));
illusion.Move(jungleCamp.CampPosition);
illusion.Attack(jungleCamp.CampPosition, true);
await Await.Delay(50);
jungleCamps.Remove(jungleCamp);
break;
}
}
}
public async Task RefreshCommand()
{
if (!CurrentTargetPosition.HasUnit)
{
return;
}
var gameTime = Game.GameTime;
if (gameTime - _gameTime <= 3)
{
return;
}
_gameTime = gameTime;
Unit.Move(CurrentTargetPosition.Position);
Unit.Attack(CurrentTargetPosition.Position, true);
await Await.Delay(50);
}
private async Task <bool> UseRazeOnTarget(Unit target, Ability ability)
{
if (ability.CanBeCasted(target) && !target.IsMagicImmune())
{
var range = ability.GetAbilityData("shadowraze_range");
var radius = ability.GetAbilityData("shadowraze_radius");
var point = MyHero.InFront(range);
var delay = ability.FindCastPoint() * 1000.0f;
var pos = Prediction.Prediction.PredictPosition(target, (int)delay);
if (pos.Distance2D(point) <= radius)
{
Log.Debug($"using {ability.Name}");
ability.UseAbility();
await Await.Delay((int)(ability.FindCastPoint() * 1000 + Game.Ping));
return(true);
}
}
return(false);
}