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); }