private void OnOrderAdding(OrderAddingEventArgs e) { try { if (e.IsCustom || !e.Process) { return; } var order = e.Order; if (order.Type != OrderType.CastPosition) { return; } if (order.Ability.Id == AbilityId.ember_spirit_sleight_of_fist) { ModifierManager.ModifierAdded += this.OnModifierAdded; ModifierManager.ModifierRemoved += this.OnModifierRemoved; } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (e.IsCustom || !e.Process) { return; } var order = e.Order; if (order.Type == OrderType.DropItem) { this.ignoredItems.Add(order.Ability.Handle); } else if (order.Type == OrderType.PickUpItem) { var physicalItem = order.Target as PhysicalItem; if (physicalItem != null) { this.ignoredItems.Remove(physicalItem.Item.Handle); } } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!this.morphling.IsMorphed) { return; } if (!e.Process) { return; } var order = e.Order; if (order.IsQueued || !order.Units.Contains(this.Owner.BaseUnit)) { return; } var type = order.Type; if (type != OrderType.Cast && type != OrderType.CastPosition && type != OrderType.CastTarget) { return; } var ability = order.Ability; this.morphlingAbilitySleeper.Sleep(ability.Handle, ability.CooldownLength); } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; if (order.Ability?.Id == AbilityId.pangolier_swashbuckle && this.Owner.HasModifier("modifier_axe_berserkers_call")) { //dota bug fix e.Process = false; return; } if (!e.Process || e.IsCustom || order.Type != OrderType.Cast || order.Ability.Id != AbilityId.pangolier_gyroshell) { return; } if (this.thunder == null) { return; } this.ultSleeper.Sleep(this.thunder.Ability.GetCastDelay() + 0.15f); } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process || !e.IsCustom) { return; } var order = e.Order; if (order.Type != OrderType.CastPosition) { return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } if (this.IsIgnored(ability)) { return; } this.abilityPositions[ability.Handle] = order.Position; } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { var order = e.Order; if (order.IsQueued || !e.Process) { return; } try { switch (order.Type) { case OrderType.AttackTarget: { SetTarget(order.Units, order.Target.Handle); break; } case OrderType.Hold: case OrderType.Stop: { var units = order.Units; DropTarget(units); StopChanneling(units); break; } case OrderType.MovePosition: case OrderType.MoveTarget: { DropTarget(order.Units); break; } case OrderType.CastTarget: { var target = EntityManager9.GetUnitFast(order.Target.Handle); if (target?.IsLinkensProtected == true) { return; } StartChanneling(order.Ability.Handle); break; } case OrderType.Cast: case OrderType.CastPosition: { StartChanneling(order.Ability.Handle); break; } } } catch (Exception ex) { Logger.Error(ex); } }
private void OnPowerTreadsOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process || e.IsCustom) { return; } var order = e.Order; if (order.Type != OrderType.Cast || order.Ability.Handle != this.powerTreads.Handle) { return; } if (!order.Units.Contains(this.owner)) { return; } if (!this.powerTreads.CanBeCasted()) { return; } this.powerTreads.UseAbility(); this.defaultAttribute = this.powerTreads.ActiveAttribute; e.Process = false; } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!this.updateHandler.IsEnabled || !e.Process || !e.IsCustom) { return; } var order = e.Order; switch (order.Type) { case OrderType.CastToggleAutocast: case OrderType.CastToggle: { if (this.ignoreToggleDisable.Contains(order.Ability.Id)) { return; } this.disableToggleAbilities.Add(order.Ability.Handle); break; } } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process) { return; } var order = e.Order; if (order.Type != OrderType.Cast) { return; } if (order.Ability.Handle != this.xReturn.Ability.Handle) { return; } this.torrent.Modifier = null; this.xMark.Position = Vector3.Zero; if (this.ship != null) { this.ship.Position = Vector3.Zero; } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process) { return; } var order = e.Order; if (order.IsQueued || !this.Ability.CanBeCasted()) { return; } if (order.Units.All(x => x.Handle != this.OwnerHandle)) { return; } if (!this.Owner.CanMove() || (!this.Owner.CanUseAbilitiesInInvisibility && this.Owner.IsInvisible)) { return; } switch (order.Type) { case OrderType.AttackPosition: case OrderType.AttackTarget: { var location = order.Target?.Position ?? order.Position; if (this.Owner.Distance(location) - this.Owner.GetAttackRange() >= this.settings.Distance) { this.Ability.UseAbility(); } break; } case OrderType.MoveTarget: case OrderType.MovePosition: { var location = order.Target?.Position ?? order.Position; if (this.Owner.Distance(location) >= this.settings.Distance) { this.Ability.UseAbility(); } break; } } } catch (Exception ex) { Logger.Error(ex); } }
private void OnUnitOrder(OrderAddingEventArgs e) { if (e.IsCustom || IsIgnoreInput || !isEnable) { return; } Ability boulSmash = myHero.Spellbook.Spell1; Ability pull = myHero.Spellbook.Spell3; Ability roll = myHero.Spellbook.Spell2; Vector3 mousePos = GameManager.MousePosition; if (e.Order.Ability == boulSmash && !EntityManager.GetEntities <Entity>() .Where(x => x.Name == "npc_dota_earth_spirit_stone" && x.IsAlive && myHero.Distance2D(x.Position) < 200) .Any()) { bool isIn = false; isIn = EntityManager.GetEntities <Hero>().Where(x => x.IsEnemy(myHero) && x.Distance2D(myHero) < 200).Any(); if (isIn) { myHero.Spellbook.Spell1.Cast(mousePos); return; } var extendet = myHero.Position.Extend(mousePos, 100); myHero.Spellbook.Spell4.Cast(extendet); return; } if (e.Order.Ability == pull && !EntityManager.GetEntities <Entity>() .Where(x => x.Name == "npc_dota_earth_spirit_stone" && x.IsAlive && mousePos.Distance2D(x.Position) < 200) .Any()) { myHero.Spellbook.Spell4.Cast(mousePos); return; } if (AutoStone.Value && e.Order.Ability == roll) { if (myHero.Distance2D(mousePos) > 1600) { myHero.Stop(); myHero.Move(mousePos); return; } if (!HasStoneBetween(myHero, myHero.Position, mousePos)) { myHero.MoveToDirection(mousePos); Vector3 stonePos = myHero.Position.Extend(mousePos, 100); SleeperOrder.Sleep(myHero.TurnTime(mousePos) * 1.2f + 500 + GameManager.AvgPing); UpdateManager.BeginInvoke(300, () => { myHero.Spellbook.Spell4.Cast(stonePos); }); } return; } e.Process = true; return; }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process || e.IsCustom) { return; } var order = e.Order; if (order.IsQueued) { return; } if (order.Type == OrderType.AttackTarget) { if (this.OrbAbility.Enabled || !this.OrbAbility.CanBeCasted() || this.Owner.ManaPercentage < this.settings.MpThreshold) { return; } this.target = EntityManager9.GetUnit(order.Target.Handle); if (this.target?.IsHero != true || this.target.IsIllusion || !this.settings.IsHeroEnabled(this.target.Name)) { return; } if (order.Units.All(x => x.Handle != this.OwnerHandle)) { return; } if (!this.groupSettings.UseWhenInvisible && !this.Owner.CanUseAbilitiesInInvisibility && this.Owner.IsInvisible) { return; } e.Process = false; this.autocastHandler.IsEnabled = true; } else if (this.autocastHandler.IsEnabled) { this.autocastHandler.IsEnabled = false; } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (e.IsCustom || !e.Process) { return; } var order = e.Order; if (order.IsQueued) { return; } if (order.Type != OrderType.CastPosition || order.Ability.Id != AbilityId.item_blink) { return; } var blink = (ActiveAbility)EntityManager9.GetAbility(order.Ability.Handle); var hero = blink.Owner; if (hero.IsChanneling) { return; } var blinkRange = blink.Range; var blinkPosition = order.Position; var heroPosition = hero.Position; if (heroPosition.Distance2D(blinkPosition) < blinkRange) { return; } var newBlinkPosition = heroPosition.Extend2D(blinkPosition, blinkRange - 50); if (!Hud.IsPositionOnScreen(newBlinkPosition)) { return; } blink.UseAbility(newBlinkPosition); e.Process = false; } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { var order = e.Order; if (order.IsQueued || order.Type != OrderType.CastPosition) { return; } if (order.Ability.Handle == this.Ability.Handle) { this.castPosition = order.Position; } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (e.IsCustom || e.Order.Type != OrderType.DropItemAtFountain) { return; } UpdateManager.BeginInvoke(589, this.SwapNeutralItem); } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; if (!this.actionBlockSleeper || !this.blockedOrders.Contains(order.Type) || !order.Units.Contains(this.owner.Hero.BaseHero)) { return; } e.Process = false; } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; if (order.Type != OrderType.Cast || order.Ability.Id != AbilityId.morphling_morph_replicate) { return; } this.sleeper.Sleep(0.2f); } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process) { return; } var order = e.Order; var orderType = order.Type; if (orderType != OrderType.Cast && orderType != OrderType.CastPosition && orderType != OrderType.CastTarget) { return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } var owner = ability.Owner; if (!owner.Equals(this.ModifierOwner)) { return; } var damage = this.netherWard.GetDamage(owner, ability.ManaCost); if (damage <= 0) { return; } if (damage > 300 || owner.Health - damage <= 0) { e.Process = false; } } catch (Exception ex) { OrderManager.OrderAdding -= this.OnOrderAdding; Logger.Error(ex); } }
private void OrderAdding(OrderAddingEventArgs e) { if (this.menuManager.LastHitMenu.HoldKey) { return; } var order = e.Order; if (!e.Process || order.IsQueued || e.IsCustom || !this.stopFarmOrders.Contains(order.Type)) { return; } foreach (var farmMode in this.farmModes) { this.RemoveEffects(order.Units); farmMode.RemoveUnits(order.Units); } }
private void OnOrderAdding(OrderAddingEventArgs e) { //todo delete ? //try //{ // if (!args.Entities.Contains(this.owner)) // { // return; // } // if (this.blockedOrders.Contains(args.OrderId)) // { // args.Process = false; // } //} //catch (Exception e) //{ // Logger.Error(e); //} }
private void OrderManager_OrderAdding(OrderAddingEventArgs e) { if (e.Order.Ability != Context.Dawnbreaker.Hammer) { return; } var Target = EntityManager.GetEntities <Hero>().Where(x => x.Position.Distance2D(GameManager.MousePosition) < 200 && x.IsAlive && x.IsEnemy(Context.Dawnbreaker.LocalHero) && !x.IsIllusion).OrderBy(y => y.Position.Distance2D(GameManager.MousePosition)); if (Target == null || Target.Count() == 0) { return; } var input = new PredictionInput { Owner = Context.Dawnbreaker.LocalHero, Speed = 1200, Delay = 0.6f, PredictionSkillshotType = PredictionSkillshotType.SkillshotLine }; var range = HammerCastRange(); input = input.WithTarget(Target.FirstOrDefault()); var predictPos = PredictionManager.GetPrediction(input).CastPosition; var pos = Context.Dawnbreaker.LocalHero.Distance2D(predictPos); var predict = Context.Dawnbreaker.LocalHero.Position.Extend(predictPos, pos * 1.75f > range ? range : pos * 1.75f); Context.Dawnbreaker.Hammer.Cast(predict, false, true); UpdateManager.BeginInvoke((int)(Context.Dawnbreaker.LocalHero.Position.Distance2D(predict) > 800 ? Context.Dawnbreaker.LocalHero.Position.Distance2D(predict) : 800), () => { Context.Dawnbreaker.Converge.Cast(); }); }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process || e.IsCustom) { return; } var order = e.Order; if (order.Type != OrderType.CastToggle) { return; } if (order.Ability.Id != this.shiftStr.Id && order.Ability.Id != this.shiftAgi.Id) { return; } if (!order.Ability.IsToggled) { this.manualToggle = true; return; } var delay = (int)GameManager.Ping + 100; UpdateManager.BeginInvoke(delay, () => { this.balanceHealth = this.Owner.Health; this.manualToggle = false; }); this.sleeper.Sleep(delay / 1000f); } catch (Exception ex) { Logger.Error(ex); } }
private void OnUnitOrder(OrderAddingEventArgs e) { if (!Razes2Mouse.Value) { return; } var localHero = EntityManager.LocalHero; Ability order = e.Order.Ability; if (localHero.Name != "npc_dota_hero_nevermore" || e.IsCustom) { return; } if (e.Order.Type == OrderType.Cast && (order.Id == AbilityId.nevermore_shadowraze1 || order.Id == AbilityId.nevermore_shadowraze2 || order.Id == AbilityId.nevermore_shadowraze3)) { localHero.MoveToDirection(GameManager.MousePosition); order.Cast(); e.Process = true; } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (!e.Process) { return; } var order = e.Order; if (order.Type != OrderType.Cast) { return; } if (!this.ids.Contains(order.Ability.Id)) { return; } if (!(order.Units.FirstOrDefault() is Courier courier)) { return; } var burst = courier.Spellbook.Spells.FirstOrDefault(x => x.Id == AbilityId.courier_burst); if (burst == null || burst.Level == 0 || burst.Cooldown > 0) { return; } UpdateManager.BeginInvoke(200, () => GameManager.ExecuteCommand("dota_courier_burst")); } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; if (order.Type != OrderType.CastTarget || order.Ability.Id != AbilityId.windrunner_focusfire || !e.Process) { return; } this.FocusFireTarget = EntityManager9.GetUnit(order.Target.Handle); if (this.FocusFireTarget == null || this.FocusFireTarget.IsLinkensProtected || this.FocusFireTarget.IsSpellShieldProtected) { return; } ModifierManager.ModifierAdded += this.OnModifierAdded; } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; if (!e.Process || order.IsQueued || order.Type != OrderType.CastPosition) { return; } if (order.Ability.Handle != this.Ult?.Handle) { return; } this.ultEndTime = GameManager.RawGameTime + this.ult.Duration; this.ultPosition = order.Position; } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; if (order.Type != OrderType.CastToggle || order.Ability.Handle != this.Ability.Handle) { return; } if (this.toggling.IsSleeping || !this.canToggle) { e.Process = false; return; } if (e.IsCustom) { return; } if (this.armlet.Enabled) { this.manualDisable = true; this.toggling.Sleep(0.1f); } else { this.manualDisable = false; this.toggling.Sleep(ArmletFullEnableTime); } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { var order = e.Order; var orderType = e.Order.Type; if (!this.actionCheck.IsSleeping || this.ignoredActions.Contains(orderType)) { return; } if (order.Type == OrderType.CastToggle) { if (this.abilityInputBlocked.IsSleeping(order.Ability.Handle)) { e.Process = false; } return; } if (this.overrideKey.IsActive) { return; } if (order.Units.Any(x => this.unitInputBlocked.IsSleeping(x.Handle))) { e.Process = false; } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (this.ignoreNextOrder) { this.ignoreNextOrder = false; return; } if (this.orderSync.IgnoreSoulRingOrder) { this.orderSync.IgnoreSoulRingOrder = false; return; } var order = e.Order; if (!e.Process || order.IsQueued || this.recoveryKey) { return; } if (this.manualOnly && e.IsCustom) { return; } if (!order.Units.Contains(this.owner)) { return; } switch (order.Type) { case OrderType.Cast: { if (order.Ability.Id == AbilityId.item_soul_ring) { return; } if (this.SoulRingUsed(order.Ability, false, !e.IsCustom)) { e.Process = false; } break; } case OrderType.CastPosition: { if (this.SoulRingUsed(order.Ability, order.Position, !e.IsCustom)) { e.Process = false; } break; } case OrderType.CastTarget: { if (this.SoulRingUsed(order.Ability, (Unit)order.Target, !e.IsCustom)) { e.Process = false; } break; } case OrderType.CastToggle: { if (order.Ability.IsToggled) { return; } if (this.SoulRingUsed(order.Ability, true, !e.IsCustom)) { e.Process = false; } break; } case OrderType.CastRune: { if (this.SoulRingUsed(order.Ability, (Rune)order.Target, !e.IsCustom)) { e.Process = false; } break; } //case OrderId.AbilityTargetTree: //{ // break; //} } } catch (Exception ex) { Logger.Error(ex); } }
private void OnOrderAdding(OrderAddingEventArgs e) { try { if (this.ignoreNextOrder) { this.ignoreNextOrder = false; return; } if (!e.Process || this.recoveryKey) { return; } var order = e.Order; if (order.IsQueued) { return; } var isPlayerInput = !e.IsCustom; if (this.orderSync.ForceNextOrderManual) { isPlayerInput = true; this.orderSync.ForceNextOrderManual = false; } if (this.manualOnly && !isPlayerInput) { return; } if (!order.Units.Contains(this.owner)) { return; } switch (order.Type) { case OrderType.Cast: { if (order.Ability.Id == AbilityId.item_power_treads) { return; } if (this.switchingThreads) { e.Process = false; return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } if (this.PowerTreadsSwitched(ability, false, isPlayerInput)) { e.Process = false; } break; } case OrderType.CastPosition: { if (this.switchingThreads) { e.Process = false; return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } if (this.PowerTreadsSwitched(ability, order.Position, isPlayerInput)) { e.Process = false; } break; } case OrderType.CastTarget: { if (this.switchingThreads) { e.Process = false; return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } if (this.PowerTreadsSwitched(ability, (Unit)order.Target, isPlayerInput)) { e.Process = false; } break; } case OrderType.CastToggle: { if (order.Ability.IsToggled) { return; } if (this.switchingThreads) { e.Process = false; return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } if (this.PowerTreadsSwitched(ability, true, isPlayerInput)) { e.Process = false; } break; } case OrderType.CastRune: { if (this.switchingThreads) { e.Process = false; return; } var ability = EntityManager9.GetAbility(order.Ability.Handle); if (ability == null) { return; } if (this.PowerTreadsSwitched(ability, (Rune)order.Target, isPlayerInput)) { e.Process = false; } break; } //case OrderId.AbilityTargetTree: //{ // break; //} } } catch (Exception ex) { Logger.Error(ex); } }