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