static void AreaSpellCheck(Player sender, ExecuteOrderEventArgs args)
{
var spells = new[]
{
new AreaSpell("enigma_black_hole", "pull_radius"),
new AreaSpell("puck_dream_coil", "coil_radius"),
new AreaSpell("obsidian_destroyer_sanity_eclipse", "radius"),
new AreaSpell("faceless_void_chronosphere", "radius"),
};
var spell = spells.FirstOrDefault(x => x.Name == args.Ability.Name);
if (spell != null)
{
var enemies =
ObjectMgr.GetEntities<Hero>()
.Where(
x =>
x.IsAlive && x.IsVisible && !x.IsIllusion && x.Team != sender.Team
&& x.Distance2D(args.TargetPosition) - x.HullRadius
< args.Ability.AbilityData.First(s => s.Name == spell.Radius).Value);
if (!enemies.Any())
{
args.Process = false;
return;
}
}
if (PowerTreadsIntCheck(args))
args.Ability.UseAbility(args.TargetPosition, true);
}
static void Player_OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!Game.IsInGame || loaded == false || enabledAuto.isActive == false || armlet == null || myHero == null || args.Target == null || args.Ability == null || sender.Hero == null) return;
if (args.Target == myHero)
{
var damage = 0f;
switch(args.Ability.Name)
{
case "phantom_lancer_spirit_lance":
damage = (float)args.Ability.AbilityData.First(x => x.Name.ToLower().Contains("total_damage")).GetValue(args.Ability.Level - 1);
break;
default:
damage = (float)args.Ability.AbilityData.First(x => x.Name.ToLower().Contains("damage")).GetValue(args.Ability.Level - 1);
break;
}
if (damage != null && damage < 10000f)
{
var recvDamage = myHero.DamageTaken(damage, args.Ability.DamageType, sender.Hero);
if (recvDamage >= myHero.Health && CanToggleArmlet())
ArmletToggle(true);
}
}
}
private static void AbilityCheck(Player sender, ExecuteOrderEventArgs args)
{
// Check if we waste a no target spell
if (args.Ability.Name == "magnataur_reverse_polarity")
{
var enemies =
ObjectMgr.GetEntities<Hero>()
.Where(
x =>
x.IsAlive && x.IsVisible && !x.IsIllusion && x.Team != sender.Team &&
x.Distance2D(args.Entities.First()) - x.HullRadius < args.Ability.CastRange);
if (!enemies.Any())
{
args.Process = false;
return;
}
}
else if (args.Ability.Name == "tidehunter_ravage")
{
var enemies =
ObjectMgr.GetEntities<Hero>()
.Where(
x =>
x.IsAlive && x.IsVisible && !x.IsIllusion && x.Team != sender.Team &&
x.Distance2D(args.Entities.First()) - x.HullRadius < args.Ability.AbilityData.First(s => s.Name == "radius").Value);
if (!enemies.Any())
{
args.Process = false;
return;
}
}
if (PowerTreadsIntCheck(args))
args.Ability.UseAbility(true);
}
static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if ((args.Order == Order.AbilityTarget || args.Order == Order.AbilityLocation))
if (args.Ability.Name == "item_tpscroll" || args.Ability.Name == "item_travel_boots" ||
args.Ability.Name == "item_travel_boots_2")
TpPos = args.TargetPosition;
if (args.Order != Order.AbilityLocation) return;
if (args.Ability.Name != "item_blink") return;
var me = ObjectMgr.LocalHero;
if (!(me.Distance2D(args.TargetPosition) > 1200))
return;
var tpos = me.Position;
var a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
var p = new Vector3(
tpos.X + 1150 * (float)Math.Cos(a),
tpos.Y + 1150 * (float)Math.Sin(a),
100);
if (me.Modifiers.Any(x => x.Name == "modifier_teleporting"))
{
tpos = TpPos;
a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
p = new Vector3(
tpos.X + 1150*(float) Math.Cos(a),
tpos.Y + 1150*(float) Math.Sin(a),
100);
}
args.Ability.UseAbility(p,me.IsChanneling());
args.Process = false;
}
private static void CastSpell(Unit hero, ExecuteOrderEventArgs args)
{
var spell = args.Ability;
if (hero == null || spell == null || spell.ManaCost <= 25 || IgnoredSpells.Any(spell.Name.Contains))
return;
var powerTreads = hero.FindItem("item_power_treads");
if (powerTreads == null)
return;
args.Process = false;
var sleep = spell.FindCastPoint() * 1000 + 555;
switch (args.Order) {
case Order.AbilityTarget: {
var target = (Unit) args.Target;
if (target != null && target.IsAlive) {
var castRange = spell.GetCastRange() + 300;
if (hero.Distance2D(target) <= castRange) {
ChangePt(powerTreads, Attribute.Intelligence);
sleep += hero.GetTurnTime(target) * 1000;
}
spell.UseAbility(target);
}
break;
}
case Order.AbilityLocation: {
var castRange = spell.GetCastRange() + 300;
if (hero.Distance2D(Game.MousePosition) <= castRange) {
ChangePt(powerTreads, Attribute.Intelligence);
sleep += hero.GetTurnTime(Game.MousePosition) * 1000;
}
spell.UseAbility(Game.MousePosition);
break;
}
case Order.Ability: {
ChangePt(powerTreads, Attribute.Intelligence);
spell.UseAbility();
break;
}
case Order.ToggleAbility: {
ChangePt(powerTreads, Attribute.Intelligence);
spell.ToggleAbility();
break;
}
}
Utils.Sleep(sleep, "delay");
}
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (!Menu.Item("PB.Enable").GetValue<bool>()) return;
/*if (args.Order == Order.AbilityTarget || args.Order == Order.AbilityLocation)
if (args.Ability.Name == "item_tpscroll" || args.Ability.Name == "item_travel_boots" ||
args.Ability.Name == "item_travel_boots_2")
TpPos = args.TargetPosition;*/
if (args.Order == Order.Stop || args.Order == Order.Hold)
_shouldCheckForModifier = false;
if (args.Order != Order.AbilityLocation) return;
if (args.Ability.Name != "item_blink") return;
_me = args.Entities.FirstOrDefault() as Hero;//ObjectMgr.LocalHero);
if (_me==null) return;
var safeRange = _me.FindItem("item_aether_lens") == null ? 1200 : 1400;
if (!(_me.Distance2D(args.TargetPosition) > safeRange))
return;
var tpos = _me.Position;
var a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
safeRange -= (int)_me.HullRadius;
var p = new Vector3(
tpos.X + safeRange * (float)Math.Cos(a),
tpos.Y + safeRange * (float)Math.Sin(a),
100);
if (_me.HasModifier("modifier_teleporting"))
{
if (!EnableAfterTp)
return;
_shouldCheckForModifier = true;
_myAbility = args.Ability;
args.Process = false;
_mySelectedPos = args.TargetPosition.ToVector2();
/*DelayAction.Add(new DelayActionItem((int) _me.FindModifier("modifier_teleporting").RemainingTime*1000+750, () =>
{
tpos = _me.Position;;//TpPos;
a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
p = new Vector3(
tpos.X + safeRange * (float)Math.Cos(a),
tpos.Y + safeRange * (float)Math.Sin(a),
100);
Print("extra action");
args.Ability.UseAbility(p);
}, CancellationToken.None));*/
return;
}
_shouldCheckForModifier = false;
args.Ability.UseAbility(p,_me.IsChanneling());
args.Process = false;
}
static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (args.Order != Order.AbilityLocation) return;
if (args.Ability.Name != "item_blink") return;
var me = ObjectMgr.LocalHero;
if (!(me.Distance2D(args.TargetPosition) > 1200)) return;
var tpos = me.Position;
var a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
var p = new Vector3(
tpos.X + 1150 * (float)Math.Cos(a),
tpos.Y + 1150 * (float)Math.Sin(a),
100);
args.Ability.UseAbility(p);
args.Process = false;
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Entities.Contains(Hero) || !args.Process)
{
return;
}
if (args.OrderId == OrderId.AttackTarget)
{
var target = args.Target as Hero;
if (target != null && target.IsAlive && !target.IsIllusion && target.Team != Team)
{
Target = target;
}
}
else if (dropTargetOrders.Contains(args.OrderId))
{
Target = null;
}
}
private static void AreaSpellCheck(Player sender, ExecuteOrderEventArgs args)
{
var spell = AreaSpells.FirstOrDefault(x => x.Name == args.Ability.Name);
if (spell != null)
{
_testExpr = GetExprFunc(sender, args, spell);
var enemies =
ObjectManager.GetEntities <Hero>().Where(_testExpr);
if (!enemies.Any())
{
args.Process = false;
NotifyPlayer("Stop failing", Game.Localize(args.Ability.Name));
return;
}
_testTime = Game.RawGameTime;
_testAbility = args.Ability;
}
}
private static void PlayerOnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Entities.Contains(hero))
{
return;
}
if (args.Order == Order.DropItem)
{
DroppedItems.Add(args.Ability.Handle);
}
else if (args.Order == Order.PickItem)
{
var physicalItem = args.Target as PhysicalItem;
if (physicalItem != null)
{
DroppedItems.RemoveAll(x => x == physicalItem.Item.Handle);
}
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (!args.IsPlayerInput || !args.Process || args.OrderId != OrderId.AbilityLocation)
{
return;
}
if (args.Ability.Id == AbilityId.ember_spirit_sleight_of_fist)
{
Unit.OnModifierAdded += this.OnModifierAdded;
Unit.OnModifierRemoved += this.OnModifierRemoved;
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.IsPlayerInput || !args.Process)
{
return;
}
if (args.OrderId == OrderId.DropItem)
{
ignoredItems.Add(args.Ability.Handle);
}
else if (args.OrderId == OrderId.PickItem)
{
var physicalItem = args.Target as PhysicalItem;
if (physicalItem != null)
{
ignoredItems.RemoveAll(x => x == physicalItem.Item.Handle);
}
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!menu.IsEnabled)
{
return;
}
switch (args.OrderId)
{
case OrderId.AbilityTarget:
case OrderId.AbilityLocation:
case OrderId.Ability:
case OrderId.ToggleAbility:
{
if (!args.IsPlayerInput && !menu.UniversalUseEnabled || !args.Process || args.IsQueued ||
!args.Entities.Contains(manager.MyHero.Hero))
{
return;
}
if (!soulRing.CanBeCasted() || manager.MyHero.HealthPercentage < menu.HpThreshold ||
manager.MyHero.ManaPercentage > menu.MpThreshold || manager.MyHero.IsInvisible() &&
!manager.MyHero.CanUseAbilitiesInInvisibility())
{
return;
}
var ability = args.Ability;
if (ability.ManaCost <= menu.MpAbilityThreshold || !menu.IsAbilityEnabled(ability.StoredName()))
{
return;
}
soulRing.Use();
order.Recast(args);
break;
}
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Entities.Contains(manager.MyHero.Hero) || args.IsQueued || !args.Process)
{
return;
}
switch (args.OrderId)
{
case OrderId.AbilityTarget:
case OrderId.AbilityLocation:
case OrderId.Ability:
{
if (args.Ability.IsAbilityBehavior(AbilityBehavior.Channeled) || args.Ability.IsInvis())
{
sleeper.Sleep(1000, this);
}
break;
}
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (args.OrderId == OrderId.Ability &&
args.Ability.Name == "magnataur_reverse_polarity")
{
var Targets =
EntityManager <Hero> .Entities.FirstOrDefault(
x => x.IsValid &&
x.IsVisible &&
x.Team != Config.MagnusPlus.Context.Owner.Team &&
!x.IsIllusion &&
Config.MagnusPlus.Context.Owner.Distance2D(x)
<= Config.MagnusPlus.ReversePolarity.Radius);
if (Targets == null)
{
Config.MagnusPlus.Context.Owner.Stop();
Game.PrintMessage($"<font color='#FF6666'>There is no one in the radius.</font>");
}
}
}
public void Player_OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (this.pause || Variables.Hero == null || !Variables.Hero.IsValid || !Variables.Hero.IsAlive)
{
return;
}
autoArmlet.PlayerExecution_Armlet(args);
if (Target == null)
{
return;
}
if (args.OrderId == OrderId.AttackTarget)
{
this.targetFind.UnlockTarget();
this.targetFind.Find();
}
else
{
this.targetFind.UnlockTarget();
}
}
// Token: 0x060009F8 RID: 2552 RVA: 0x0002B6A8 File Offset: 0x000298A8
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (args.Process && !args.IsPlayerInput && args.OrderId == OrderId.AbilityLocation)
{
Ability9 ability = EntityManager9.GetAbility(args.Ability.Handle);
if (!(ability == null))
{
if (!this.IsIgnored(ability))
{
this.abilityPositions[ability.Handle] = args.TargetPosition;
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
//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);
//}
}
// Token: 0x060000DA RID: 218 RVA: 0x0000A5E8 File Offset: 0x000087E8
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (this.updateHandler.IsEnabled && args.Process && !args.IsPlayerInput)
{
OrderId orderId = args.OrderId;
if (orderId == OrderId.ToggleAbility || orderId == OrderId.ToggleAutoCast)
{
if (!this.ignoreToggleDisable.Contains(args.Ability.Id))
{
this.disableToggleAbilities.Add(args.Ability.Handle);
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
/*
* private static void OnAttackChange(object sender, OnValueChangeEventArgs onValueChangeEventArgs)
* {
* var oldValue = onValueChangeEventArgs.GetOldValue<AbilityToggler>();
* var oldQ = oldValue.IsEnabled("invoker_quas");
* var oldW = oldValue.IsEnabled("invoker_wex");
* var oldE = oldValue.IsEnabled("invoker_exort");
*
* var newValue = onValueChangeEventArgs.GetNewValue<AbilityToggler>();
* var newQ = newValue.IsEnabled("invoker_quas");
* var newW = newValue.IsEnabled("invoker_wex");
* var newE = newValue.IsEnabled("invoker_exort");
* Game.PrintMessage(string.Format("old q {0} w {1} e {2}. new q {3} w {4} e {5}", oldQ,oldW,oldE,newQ,newW,newE), MessageType.ChatMessage);
* if (newQ != oldQ)
* {
* Game.PrintMessage("q",MessageType.ChatMessage);
* var onatt = new Dictionary<string, bool>()
* {
* {"invoker_exort", false},
* {"invoker_wex", false},
* {"invoker_quas", true}
* };
* Menu.Item("OnAttacking").SetValue(new AbilityToggler(onatt));
* }
* if (newW != oldW)
* {
* Game.PrintMessage("w", MessageType.ChatMessage);
* var onatt = new Dictionary<string, bool>()
* {
* {"invoker_exort", false},
* {"invoker_wex", true},
* {"invoker_quas", false}
* };
* Menu.Item("OnAttacking").SetValue(new AbilityToggler(onatt));
* }
* if (newE != oldE)
* {
* Game.PrintMessage("e", MessageType.ChatMessage);
* var onatt = new Dictionary<string, bool>()
* {
* {"invoker_exort", true},
* {"invoker_wex", false},
* {"invoker_quas", false}
* };
* Menu.Item("OnAttacking").SetValue(new AbilityToggler(onatt));
* }
* }
*/
/*
* private static void OnMoveChange(object sender, OnValueChangeEventArgs onValueChangeEventArgs)
* {
* }
*/
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (!Menu.Item("smartIsActive").GetValue <bool>())
{
return;
}
if (args.Order != Order.AttackTarget && args.Order != Order.MoveLocation && _inAction)
{
return;
}
var me = sender.Hero;
Ability spell = null;
switch (Menu.Item("OnAttacking").GetValue <StringList>().SelectedIndex)
{
case (int)SmartSphereEnum.Quas:
spell = me.Spellbook.SpellQ;
break;
case (int)SmartSphereEnum.Wex:
spell = me.Spellbook.SpellW;
break;
case (int)SmartSphereEnum.Exort:
spell = me.Spellbook.SpellE;
break;
}
if (!me.IsAlive || args.Order != Order.AttackTarget || !(me.Distance2D(args.Target) <= 650))
{
return;
}
if (spell == null || !spell.CanBeCasted())
{
return;
}
spell.UseAbility();
spell.UseAbility();
spell.UseAbility();
Utils.Sleep(200, "act");
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Entities.Contains(manager.MyHero.Hero) || args.IsQueued || !args.Process)
{
return;
}
if (!phaseBoots.CanBeCasted() || !manager.MyHero.CanUseItems())
{
return;
}
switch (args.OrderId)
{
case OrderId.AttackLocation:
case OrderId.AttackTarget:
{
var location = args.Target?.Position ?? args.TargetPosition;
if (Math.Max(manager.MyHero.Distance2D(location) - manager.MyHero.Hero.GetAttackRange(), 0)
>= menu.Distance)
{
phaseBoots.Use();
}
break;
}
case OrderId.MoveTarget:
case OrderId.MoveLocation:
{
var location = args.Target?.Position ?? args.TargetPosition;
if (manager.MyHero.Distance2D(location) >= menu.Distance)
{
phaseBoots.Use();
}
break;
}
}
}
public void OnExecuteAction(ExecuteOrderEventArgs args)
{
var order = args.Order;
if (order == Order.Hold)
{
var selected = hero.Player.Selection.FirstOrDefault() as Unit;
if (selected == null || selected.Equals(hero))
{
return;
}
var controlable = controllableUnits.FirstOrDefault(x => x.Handle == selected.Handle);
if (controlable != null)
{
controlable.Pause = 3;
}
}
var ability = args.Ability;
if (ability == null)
{
return;
}
var target = args.Target as Unit;
if (target == null)
{
return;
}
if (ability.StoredName() == "item_helm_of_the_dominator" ||
ability.ClassID == ClassID.CDOTA_Ability_Chen_HolyPersuasion ||
ability.ClassID == ClassID.CDOTA_Ability_Enchantress_Enchant)
{
delayedUnit = target;
}
}
// Token: 0x06000D39 RID: 3385 RVA: 0x000266E0 File Offset: 0x000248E0
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (args.Process && !args.IsQueued && (args.OrderId == OrderId.Ability || args.OrderId == OrderId.AbilityLocation))
{
EntityHandle handle = args.Ability.Handle;
if (handle == base.Handle)
{
this.IsSunRayMoving = false;
}
else if (handle == this.sunRayToggleMovement.Handle)
{
this.IsSunRayMoving = !this.IsSunRayMoving;
}
}
}
catch (Exception exception)
{
Logger.Error(exception, null);
}
}
// Token: 0x060004E7 RID: 1255 RVA: 0x00019C0C File Offset: 0x00017E0C
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (this.morphling.IsMorphed)
{
if (args.Process && !args.IsQueued && args.Entities.Contains(base.Owner.BaseUnit))
{
OrderId orderId = args.OrderId;
if (orderId == OrderId.Ability || orderId == OrderId.AbilityLocation || orderId == OrderId.AbilityTarget)
{
Ability ability = args.Ability;
this.morphlingAbilitySleeper.Sleep(ability.Handle, ability.CooldownLength);
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
// Token: 0x06000362 RID: 866 RVA: 0x000139C8 File Offset: 0x00011BC8
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Process || args.IsQueued || !args.IsPlayerInput || args.OrderId != OrderId.Ability)
{
return;
}
uint num = args.Ability.Handle;
DebuffAbility debuffAbility = this.concussive;
if (num != ((debuffAbility != null) ? new uint?(debuffAbility.Ability.Handle) : null))
{
return;
}
foreach (Unit9 unit in EntityManager9.EnemyHeroes)
{
if (this.concussive.Ability.CanHit(unit))
{
return;
}
}
args.Process = false;
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (!args.Process || args.IsQueued || args.OrderId != OrderId.AbilityLocation)
{
return;
}
if (args.Ability.Handle != this.Ult?.Handle)
{
return;
}
this.ultEndTime = Game.RawGameTime + this.ult.Duration;
this.ultPosition = args.TargetPosition;
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (args.OrderId != OrderId.AbilityTarget || args.Ability.Id != AbilityId.windrunner_focusfire || !args.Process)
{
return;
}
this.FocusFireTarget = EntityManager9.GetUnit(args.Target.Handle);
if (this.FocusFireTarget == null || this.FocusFireTarget.IsLinkensProtected || this.FocusFireTarget.IsSpellShieldProtected)
{
return;
}
Unit.OnModifierAdded += this.OnModifierAdded;
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x060005EF RID: 1519 RVA: 0x0001DBA0 File Offset: 0x0001BDA0
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (args.Process && args.OrderId == OrderId.Ability)
{
if (args.Ability.Handle == this.xReturn.Ability.Handle)
{
this.torrent.Modifier = null;
this.xMark.Position = Vector3.Zero;
if (this.ship != null)
{
this.ship.Position = Vector3.Zero;
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!menu.IsEnabled || !args.Entities.Contains(manager.MyHero.Hero) || args.IsQueued ||
manager.MyHero.IsChanneling || !args.Process || blinkDagger.IsSleeping)
{
return;
}
if (args.OrderId == OrderId.AbilityLocation && args.Ability?.Id == AbilityId)
{
var location = args.TargetPosition;
var castRange = blinkDagger.GetCastRange();
if (manager.MyHero.Distance2D(location) <= castRange)
{
return;
}
args.Process = false;
blinkDagger.Use(manager.MyHero.Position.Extend(location, castRange - 50));
}
}
private static void Player_OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (args.Order == Order.Ability)
{
var owner = args.Ability.Owner as Unit;
if (owner != null)
{
var id = args.Ability.GetAbilityId();
var abilities = owner.Inventory.Items.Where(x => x.GetAbilityId() == id).ToList();
if (abilities.Count() > 1)
{
foreach (var ability in abilities)
{
ability.UseAbility();
}
args.Process = false;
}
}
}
else if (args.Order == Order.AbilityTarget)
{
var owner = args.Ability.Owner as Unit;
if (owner != null)
{
var id = args.Ability.GetAbilityId();
var abilities = owner.Inventory.Items.Where(x => x.GetAbilityId() == id).ToList();
if (abilities.Count() > 1)
{
var target = args.Target as Unit;
foreach (var ability in abilities)
{
ability.UseAbility(target);
}
args.Process = false;
}
}
}
}
public void OnExecuteAction(ExecuteOrderEventArgs args)
{
var order = args.Order;
if (order == Order.Hold || order == Order.MoveLocation)
{
foreach (var entity in args.Entities)
{
var controlable = controllableUnits.FirstOrDefault(x => x.Handle == entity.Handle);
if (controlable != null)
{
controlable.Pause = 3;
}
}
return;
}
var ability = args.Ability;
if (ability == null)
{
return;
}
var target = args.Target as Unit;
if (target == null)
{
return;
}
if (ability.StoredName() == "item_helm_of_the_dominator"
|| ability.ClassID == ClassID.CDOTA_Ability_Chen_HolyPersuasion
|| ability.ClassID == ClassID.CDOTA_Ability_Enchantress_Enchant)
{
delayedUnit = target;
}
}
public void OnExecuteAction(ExecuteOrderEventArgs args)
{
var order = args.Order;
if (order == Order.Hold || order == Order.MoveLocation)
{
foreach (var entity in args.Entities)
{
var controlable = controllableUnits.FirstOrDefault(x => x.Handle == entity.Handle);
if (controlable != null)
{
controlable.Pause = 3;
}
}
return;
}
var ability = args.Ability;
if (ability == null)
{
return;
}
var target = args.Target as Unit;
if (target == null)
{
return;
}
if (ability.StoredName() == "item_helm_of_the_dominator" ||
ability.ClassID == ClassID.CDOTA_Ability_Chen_HolyPersuasion ||
ability.ClassID == ClassID.CDOTA_Ability_Enchantress_Enchant)
{
delayedUnit = target;
}
}
public void OnExecuteAction(ExecuteOrderEventArgs args)
{
var order = args.OrderId;
if (args.IsPlayerInput && (order == OrderId.Hold || order == OrderId.MoveLocation))
{
foreach (var entity in args.Entities)
{
var controlable = controllableUnits.FirstOrDefault(x => x.Handle == entity.Handle);
if (controlable != null)
{
controlable.Pause = 3;
}
}
return;
}
var ability = args.Ability;
if (ability == null)
{
return;
}
var target = args.Target as Unit;
if (target == null)
{
return;
}
if (ability.Id == AbilityId.item_helm_of_the_dominator ||
ability.Id == AbilityId.chen_holy_persuasion ||
ability.Id == AbilityId.enchantress_enchant)
{
delayedUnit = target;
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (args.OrderId == OrderId.Ability)
{
var concussiveShot = Abilities.ConcussiveShot;
if (args.Ability == concussiveShot.Base)
{
var targetHit = concussiveShot.TargetHit;
if (targetHit == null)
{
if (SmartConcussiveShotMenu.AntiFailItem)
{
args.Process = false;
}
return;
}
var castDelay = concussiveShot.GetCastDelay();
var hitTime = concussiveShot.GetHitTime(targetHit) - (castDelay + 150);
Helpers.MultiSleeper <string> .DelaySleep($"IsHitTime_{targetHit.Name}_{concussiveShot.Name}", castDelay + 50, hitTime);
}
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (args.OrderId != OrderId.ToggleAbility || !args.IsPlayerInput || !args.Process)
{
return;
}
if (args.Ability.Id != this.shiftStr.Id && args.Ability.Id != this.shiftAgi.Id)
{
return;
}
if (!args.Ability.IsToggled)
{
this.manualToggle = true;
return;
}
var delay = (int)Game.Ping + 100;
UpdateManager.BeginInvoke(
() =>
{
this.balanceHealth = this.Owner.Health;
this.manualToggle = false;
},
delay);
this.sleeper.Sleep(delay / 1000f);
}
catch (Exception e)
{
Logger.Error(e);
}
}
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (!Menu.Item("PB.Enable").GetValue<bool>()) return;
if (args.Order == Order.AbilityTarget || args.Order == Order.AbilityLocation)
if (args.Ability.Name == "item_tpscroll" || args.Ability.Name == "item_travel_boots" ||
args.Ability.Name == "item_travel_boots_2")
TpPos = args.TargetPosition;
if (args.Order != Order.AbilityLocation) return;
if (args.Ability.Name != "item_blink") return;
var me = args.Entities.FirstOrDefault() as Hero;//ObjectMgr.LocalHero);
if (me==null) return;
var safeRange = me.FindItem("item_aether_lens") == null ? 1200 : 1400;
if (!(me.Distance2D(args.TargetPosition) > safeRange))
return;
var tpos = me.Position;
var a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
safeRange -= (int)me.HullRadius;
var p = new Vector3(
tpos.X + safeRange * (float)Math.Cos(a),
tpos.Y + safeRange * (float)Math.Sin(a),
100);
if (me.Modifiers.Any(x => x.Name == "modifier_teleporting"))
{
tpos = TpPos;
a = tpos.ToVector2().FindAngleBetween(args.TargetPosition.ToVector2(), true);
p = new Vector3(
tpos.X + safeRange * (float)Math.Cos(a),
tpos.Y + safeRange * (float)Math.Sin(a),
100);
}
args.Ability.UseAbility(p,me.IsChanneling());
args.Process = false;
}
private void PlayerOnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!sleeper.Sleeping || !args.Entities.Contains(Hero) || !Menu.PhaseShiftBlock)
{
return;
}
switch (args.Order)
{
case Order.AttackLocation:
case Order.AttackTarget:
case Order.Stop:
case Order.Hold:
case Order.MoveTarget:
case Order.MoveLocation:
args.Process = false;
break;
case Order.AbilityTarget:
case Order.AbilityLocation:
case Order.Ability:
sleeper.Sleep(0);
break;
}
}
static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
_powerTreadsRestore = 0;
switch (args.Order)
{
case Order.GlyphOfFortification:
// Test if tower just died a second ago and prevent glyph
if (_lastTowerKillTick + 1000 > Environment.TickCount)
args.Process = false;
break;
case Order.AbilityTarget:
{
var unit = args.Target as Unit;
if (unit != null && args.Ability != null)
TargetSpellCheck(sender, args);
break;
}
case Order.AbilityLocation:
{
AreaSpellCheck(sender, args);
break;
}
case Order.Ability:
{
AbilityCheck(sender, args);
break;
}
}
if (_powerTreadsRestore != 0)
{
var powerTreads =
(Ensage.Items.PowerTreads)ObjectMgr.LocalHero.Inventory.Items.FirstOrDefault(x => x is Ensage.Items.PowerTreads);
for (var i = 0; i < _powerTreadsRestore; ++i)
powerTreads.ToggleAbility(true);
}
}
public void Recast(ExecuteOrderEventArgs args)
{
args.Process = false;
var ability = args.Ability;
switch (args.OrderId)
{
case OrderId.AbilityTarget:
{
var target = args.Target as Unit;
if (target != null && target.IsValid && target.IsAlive)
{
UseAbility(ability, target);
}
break;
}
case OrderId.AbilityLocation:
{
UseAbility(ability, args.TargetPosition);
break;
}
case OrderId.Ability:
{
UseAbility(ability);
break;
}
case OrderId.ToggleAbility:
{
ToggleAbility(ability);
break;
}
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (args.OrderId != OrderId.ToggleAbility || args.Ability.Handle != this.Ability.Handle)
{
return;
}
if (this.toggling.IsSleeping || !this.canToggle)
{
args.Process = false;
return;
}
if (!args.IsPlayerInput)
{
return;
}
if (this.armlet.Enabled)
{
this.manualDisable = true;
this.toggling.Sleep(0.1f);
}
else
{
this.manualDisable = false;
this.toggling.Sleep(ArmletFullEnableTime);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void PlayerOnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!this.IsValid(args))
{
return;
}
var item = new LogItem(LogType.ExecuteOrder, Color.Magenta, "Execute attack/move order");
item.AddLine("Order: " + args.OrderId, args.OrderId);
if (args.Target != null)
{
item.AddLine("Target name: " + args.Target.Name, args.Target.Name);
item.AddLine("Target network name: " + args.Target.NetworkName, args.Target.NetworkName);
item.AddLine("Target classID: " + args.Target.ClassId, args.Target.ClassId);
}
if (!args.TargetPosition.IsZero)
{
item.AddLine("Target position: " + args.TargetPosition, args.TargetPosition);
}
this.log.Display(item);
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Entities.Contains(Hero))
{
return;
}
if (args.Ability?.ClassID != ClassID.CDOTA_Item_Armlet)
{
return;
}
if (Sleeper.Sleeping || !canToggle)
{
args.Process = false;
return;
}
if (Hero.Modifiers.Any(x => x.Name == ArmletModifierName))
{
manualDisable = true;
Sleep(100 + Game.Ping);
}
else
{
manualDisable = false;
Sleep(FullEnableTime * 1000);
}
}
static void TargetSpellCheck(Player sender, ExecuteOrderEventArgs args)
{
var hero = args.Target as Hero;
if (hero != null)
{
// Check if target is illusion and real hero is near
if (hero.IsIllusion)
{
var realTarget = hero.ReplicateFrom;
if (realTarget.IsAlive && realTarget.IsVisible && realTarget.Distance2D(args.Entities.First()) - realTarget.HullRadius < args.Ability.CastRange)
{
args.Ability.UseAbility(realTarget);
args.Process = false;
return;
}
}
}
// Check if target is linkens protected for certain spells
var unit = args.Target as Unit;
var noLinkenSpells = new[]
{
"doom_bringer_doom", "lion_finger_of_death", "lina_laguna_blade", "juggernaut_omni_slash", "antimage_mana_void", "legion_commander_duel",
"bloodseeker_rupture", "terrorblade_sunder", "furion_wrath_of_nature", "bane_fiends_grip", "lich_chain_frost",
};
if (noLinkenSpells.Contains(args.Ability.Name))
{
// TODO: fix linkens check with cooldown testing?
var linkensItem = unit.FindItem("item_sphere");
var linkens = unit.Modifiers.Any(x => x.Name == "modifier_item_sphere_target")
|| (linkensItem != null && linkensItem.Cooldown <= 0);
if (linkens)
{
args.Process = false;
return;
}
}
if (PowerTreadsIntCheck(args))
args.Ability.UseAbility(unit, true);
}
static bool PowerTreadsIntCheck(ExecuteOrderEventArgs args)
{
return false;
//var powerTreads = ObjectMgr.LocalHero.FindItem("item_power_treads");
//if (powerTreads == null)
// return false;
//// agility -> strength -> int
//switch (((Ensage.Items.PowerTreads)powerTreads).ActiveAttribute)
//{
// case Attribute.Agility:
// powerTreads.ToggleAbility();
// powerTreads.ToggleAbility(true);
// _powerTreadsRestore = 1;
// args.Process = false;
// break;
// case Attribute.Strength:
// powerTreads.ToggleAbility();
// _powerTreadsRestore = 2;
// args.Process = false;
// break;
// //case Attribute.Intelligence:
// // args.Process = true;
// // _powerTreadsRestore = 0;
// // break;
//}
//Console.WriteLine(_powerTreadsRestore);
//return args.Process;
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (args.Order == Order.DisassembleItem)
{
Sleeper.Sleep(10000);
}
}
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (Menu.Item("order").GetValue<StringList>().SelectedIndex == (int) Orders.Monkey)
{
//Game.PrintMessage(args.Order.ToString(), MessageType.ChatMessage);
if (args.Order != Order.Stop && args.Order != Order.AttackLocation && args.Order != Order.AttackTarget &&
args.Order != Order.Ability && args.Order != Order.AbilityTarget &&
args.Order != Order.AbilityLocation &&
args.Order != Order.MoveLocation && args.Order != Order.MoveTarget && args.Order != Order.Hold)
return;
foreach (var hero in Objects.Tempest.GetCloneList(sender.Hero))
{
Ability spell;
Ability needed;
switch (args.Order)
{
case Order.Stop:
hero.Stop();
break;
case Order.AttackLocation:
hero.Attack(args.TargetPosition);
break;
case Order.AttackTarget:
var target = args.Target;
hero.Attack(target as Unit);
break;
case Order.Ability:
spell = args.Ability;
needed = hero.FindSpell(spell.Name) ?? hero.FindItem(spell.Name);
if (needed != null && needed.CanBeCasted())
{
needed.UseAbility();
}
break;
case Order.AbilityTarget:
spell = args.Ability;
needed = hero.FindSpell(spell.Name) ?? hero.FindItem(spell.Name);
if (needed != null && needed.CanBeCasted())
{
needed.UseAbility(args.Target as Unit);
}
break;
case Order.AbilityLocation:
spell = args.Ability;
needed = hero.FindSpell(spell.Name) ?? hero.FindItem(spell.Name);
if (needed != null && needed.CanBeCasted())
{
needed.UseAbility(args.TargetPosition);
}
break;
case Order.MoveLocation:
hero.Move(args.TargetPosition);
break;
case Order.MoveTarget:
hero.Move(args.TargetPosition);
break;
case Order.AbilityTargetTree:
break;
case Order.ToggleAbility:
break;
case Order.Hold:
hero.Stop();
break;
}
}
}
else if (Menu.Item("FirstClone").GetValue<bool>())
{
if (args.Order != Order.Ability && args.Order != Order.AbilityTarget &&
args.Order != Order.AbilityLocation)
return;
if (!CloneOnlyItems.Contains(args.Ability.Name)) return;
foreach (var hero in Objects.Tempest.GetCloneList(sender.Hero).Where(x => x.Distance2D(sender.Hero) <= 1000))
{
Ability spell;
Ability needed;
switch (args.Order)
{
case Order.Ability:
spell = args.Ability;
needed = hero.FindSpell(spell.Name) ?? hero.FindItem(spell.Name);
if (needed != null && needed.CanBeCasted())
{
needed.UseAbility(sender.Hero);
args.Process = false;
}
break;
case Order.AbilityTarget:
spell = args.Ability;
needed = hero.FindSpell(spell.Name) ?? hero.FindItem(spell.Name);
if (needed != null && needed.CanBeCasted())
{
needed.UseAbility(args.Target as Unit);
args.Process = false;
}
break;
case Order.AbilityLocation:
spell = args.Ability;
needed = hero.FindSpell(spell.Name) ?? hero.FindItem(spell.Name);
if (needed != null && needed.CanBeCasted())
{
needed.UseAbility(args.TargetPosition);
args.Process = false;
}
break;
}
}
}
}
private static void Player_OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (active && (args.Order == Order.MoveLocation || args.Order == Order.Stop || args.Target == null))
{
target = null;
return;
}
if (active && !Game.IsPaused && !Game.IsChatOpen && Equals(sender, me.Player))
{
damage = me.MinimumDamage + me.BonusDamage;
qblade = me.FindItem("item_quelling_blade");
bfury = me.FindItem("item_bfury");
if (args.Order == Order.MoveLocation || (target != null && !target.IsAlive))
{
target = null;
return;
}
if (args.Order == Order.AttackTarget && me.IsAlive && args.Target != null)
{
target = args.Target;
}
}
}
private void UseAbility(ExecuteOrderEventArgs args)
{
var ability = args.Ability;
if (itemManager.PowerTreads.Equals(ability))
{
switch (itemManager.PowerTreads.ActiveAttribute)
{
case Attribute.Strength:
itemManager.PowerTreads.DefaultAttribute = Attribute.Intelligence;
break;
case Attribute.Agility:
itemManager.PowerTreads.DefaultAttribute = Attribute.Strength;
break;
case Attribute.Intelligence:
itemManager.PowerTreads.DefaultAttribute = Attribute.Agility;
break;
}
Sleeper.Sleep(100 + Game.Ping, "SwitchBackPT");
return;
}
if (ability.ManaCost <= Menu.PowerTreads.ManaThreshold
|| abilityUpdater.IgnoredAbilities.Contains(ability.StoredName()))
{
return;
}
var soulRingCondition = itemManager.SoulRing.CanBeCasted()
&& Menu.SoulRing.AbilityEnabled(ability.StoredName());
var powerTreadsCondition = itemManager.PowerTreads.CanBeCasted()
&& Menu.PowerTreads.AbilityEnabled(ability.StoredName());
if (!soulRingCondition && !powerTreadsCondition)
{
return;
}
args.Process = false;
if (soulRingCondition)
{
itemManager.SoulRing.Use(false);
}
var sleep = Math.Max(ability.FindCastPoint() * 1000, 100) + Game.Ping / 1000 + 300;
switch (args.Order)
{
case Order.AbilityTarget:
var target = args.Target as Unit;
if (target != null && target.IsValid && target.IsAlive)
{
if (powerTreadsCondition && Hero.Distance2D(target) <= ability.GetCastRange() + 300)
{
itemManager.PowerTreads.SwitchTo(Attribute.Intelligence);
sleep += Hero.GetTurnTime(target) * 1000;
}
ability.UseAbility(target);
}
break;
case Order.AbilityLocation:
var targetLocation = args.TargetPosition;
if (powerTreadsCondition
&& (Hero.Distance2D(targetLocation) <= ability.GetCastRange() + 300
|| AbilityDatabase.Find(ability.StoredName()).FakeCastRange))
{
itemManager.PowerTreads.SwitchTo(Attribute.Intelligence);
sleep += Hero.GetTurnTime(targetLocation) * 1000;
}
ability.UseAbility(targetLocation);
break;
case Order.Ability:
if (powerTreadsCondition)
{
itemManager.PowerTreads.SwitchTo(Attribute.Intelligence);
}
ability.UseAbility();
break;
case Order.ToggleAbility:
if (powerTreadsCondition && !itemManager.PowerTreads.DelaySwitch())
{
itemManager.PowerTreads.SwitchTo(Attribute.Intelligence);
}
ability.ToggleAbility();
break;
}
Sleeper.Sleep((float)sleep, "SwitchBackPT", true);
}
public void OnExecuteAbilitiy(Player sender, ExecuteOrderEventArgs args)
{
if (!menuManager.IsEnabled)
{
return;
}
if (menuManager.ChaseEnabled && args.Order == Order.MoveLocation)
{
sleeper.Sleep(500, orbwalker);
}
var ability = args.Ability;
if (ability == null || args.Order != Order.AbilityLocation)
{
return;
}
var chakram = chakrams.FirstOrDefault(x => x.Ability.Equals(ability));
if (chakram != null)
{
chakram.Position = args.TargetPosition;
return;
}
if (!menuManager.IsSafeChainEnabled && ability.Equals(timberChain.Ability)
&& !treeFactory.CheckTree(hero, args.TargetPosition, timberChain))
{
args.Process = false;
}
}
private void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
abuse.OnExecuteAction(sender, args);
}
private static void CastSpell(ExecuteOrderEventArgs args) {
var spell = args.Ability;
if (spell.ManaCost <= PTMenu.Item("manaPTThreshold").GetValue<Slider>().Value ||
IgnoredSpells.Any(spell.Name.Equals))
return;
var soulRing = hero.FindItem("item_soul_ring");
if (powerTreads == null && soulRing == null)
return;
if (!PTMenu.Item("enabledPT").GetValue<bool>() && !SoulRingMenu.Item("enabledSR").GetValue<bool>())
return;
args.Process = false;
if (soulRing != null && soulRing.CanBeCasted() && SoulRingMenu.Item("enabledSR").GetValue<bool>()) {
if (SoulRingMenu.Item("enabledSRAbilities").GetValue<AbilityToggler>().IsEnabled(spell.Name) &&
((float) hero.Health / hero.MaximumHealth) * 100 >=
SoulRingMenu.Item("soulringHPThreshold").GetValue<Slider>().Value &&
hero.Mana / hero.MaximumMana * 100 <=
SoulRingMenu.Item("soulringMPThreshold").GetValue<Slider>().Value)
soulRing.UseAbility();
}
var sleep = spell.FindCastPoint() * 1000 + PTMenu.Item("switchbackPTdelay").GetValue<Slider>().Value;
if (AttackSpells.Any(spell.Name.Equals))
sleep += hero.SecondsPerAttack * 1000;
switch (args.Order) {
case Order.AbilityTarget: {
var target = (Unit) args.Target;
if (target != null && target.IsAlive) {
var castRange = spell.GetCastRange() + 300;
if (hero.Distance2D(target) <= castRange && PTMenu.Item("enabledPT").GetValue<bool>()) {
if (PTMenu.Item("enabledPTAbilities").GetValue<AbilityToggler>().IsEnabled(spell.Name))
ChangePowerTreads(Attribute.Intelligence);
else if (AttackSpells.Any(spell.Name.Equals)) {
ChangePtOnAction("switchPTonAttack", true);
}
sleep += hero.GetTurnTime(target) * 1000;
}
spell.UseAbility(target);
}
break;
}
case Order.AbilityLocation: {
var castRange = spell.GetCastRange() + 300;
if (hero.Distance2D(Game.MousePosition) <= castRange && PTMenu.Item("enabledPT").GetValue<bool>() &&
PTMenu.Item("enabledPTAbilities").GetValue<AbilityToggler>().IsEnabled(spell.Name)) {
ChangePowerTreads(Attribute.Intelligence);
sleep += hero.GetTurnTime(Game.MousePosition) * 1000;
}
spell.UseAbility(Game.MousePosition);
break;
}
case Order.Ability: {
if (PTMenu.Item("enabledPT").GetValue<bool>()) {
if (PTMenu.Item("enabledPTAbilities").GetValue<AbilityToggler>().IsEnabled(spell.Name))
ChangePowerTreads(Attribute.Intelligence);
else if (spell.Name == AttackSpells[3]) {
ChangePtOnAction("switchPTonAttack", true);
}
}
spell.UseAbility();
break;
}
case Order.ToggleAbility: {
if (PTMenu.Item("enabledPT").GetValue<bool>() &&
PTMenu.Item("enabledPTAbilities").GetValue<AbilityToggler>().IsEnabled(spell.Name))
ChangePowerTreads(Attribute.Intelligence);
spell.ToggleAbility();
break;
}
}
Utils.Sleep(sleep, "HpMpAbuseDelay");
}
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args) {
switch (args.Order) {
case Order.AttackTarget:
case Order.AttackLocation:
ChangePtOnAction("switchPTonAttack", true);
break;
case Order.AbilityTarget:
case Order.AbilityLocation:
case Order.Ability:
case Order.ToggleAbility:
if (!Game.IsKeyDown(16))
CastSpell(args);
break;
case Order.MoveLocation:
case Order.MoveTarget:
PickUpItemsOnMove(args);
ChangePtOnAction("switchPTonMove");
break;
default:
attacking = false;
break;
}
}
/*
private static void OnAttackChange(object sender, OnValueChangeEventArgs onValueChangeEventArgs)
{
var oldValue = onValueChangeEventArgs.GetOldValue<AbilityToggler>();
var oldQ = oldValue.IsEnabled("invoker_quas");
var oldW = oldValue.IsEnabled("invoker_wex");
var oldE = oldValue.IsEnabled("invoker_exort");
var newValue = onValueChangeEventArgs.GetNewValue<AbilityToggler>();
var newQ = newValue.IsEnabled("invoker_quas");
var newW = newValue.IsEnabled("invoker_wex");
var newE = newValue.IsEnabled("invoker_exort");
Game.PrintMessage(string.Format("old q {0} w {1} e {2}. new q {3} w {4} e {5}", oldQ,oldW,oldE,newQ,newW,newE), MessageType.ChatMessage);
if (newQ != oldQ)
{
Game.PrintMessage("q",MessageType.ChatMessage);
var onatt = new Dictionary<string, bool>()
{
{"invoker_exort", false},
{"invoker_wex", false},
{"invoker_quas", true}
};
Menu.Item("OnAttacking").SetValue(new AbilityToggler(onatt));
}
if (newW != oldW)
{
Game.PrintMessage("w", MessageType.ChatMessage);
var onatt = new Dictionary<string, bool>()
{
{"invoker_exort", false},
{"invoker_wex", true},
{"invoker_quas", false}
};
Menu.Item("OnAttacking").SetValue(new AbilityToggler(onatt));
}
if (newE != oldE)
{
Game.PrintMessage("e", MessageType.ChatMessage);
var onatt = new Dictionary<string, bool>()
{
{"invoker_exort", true},
{"invoker_wex", false},
{"invoker_quas", false}
};
Menu.Item("OnAttacking").SetValue(new AbilityToggler(onatt));
}
}
*/
/*
private static void OnMoveChange(object sender, OnValueChangeEventArgs onValueChangeEventArgs)
{
}
*/
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (!Menu.Item("smartIsActive").GetValue<bool>()) return;
if (args.Order != Order.AttackTarget && args.Order != Order.MoveLocation && _inAction) return;
var me = sender.Hero;
Ability spell = null;
switch (Menu.Item("OnAttacking").GetValue<StringList>().SelectedIndex)
{
case (int)SmartSphereEnum.Quas:
spell = me.Spellbook.SpellQ;
break;
case (int)SmartSphereEnum.Wex:
spell = me.Spellbook.SpellW;
break;
case (int)SmartSphereEnum.Exort:
spell = me.Spellbook.SpellE;
break;
}
if (!me.IsAlive || args.Order != Order.AttackTarget || !(me.Distance2D(args.Target) <= 650)) return;
if (spell == null || !spell.CanBeCasted()) return;
spell.UseAbility();
spell.UseAbility();
spell.UseAbility();
Utils.Sleep(200, "act");
}
public static void Player_OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
var ability = args.Ability;
if (ability != null && NameManager.Name(ability) == "item_blink")
{
var blinkPos = args.TargetPosition;
if (Me.Distance2D(blinkPos) > 1200)
{
blinkPos = (blinkPos - Me.Position) * (1200) / blinkPos.Distance2D(Me) + Me.Position;
}
MyHeroInfo.Position = blinkPos;
Utils.Sleep(Game.Ping + Me.GetTurnTime(MyHeroInfo.Position) + 100, "mePosition");
return;
}
if (ability != null && NameManager.Name(ability) != null)
{
var hero = args.Target as Hero;
if (hero != null && ability.CanHit(hero, NameManager.Name(ability)))
{
Utils.Sleep(ability.GetCastDelay(Me, hero) * 1000, "GlobalCasting");
Utils.Sleep(ability.GetCastDelay(Me, hero) * 1000, "casting");
return;
}
if (args.TargetPosition != Vector3.Zero
&& (ability.GetCastRange() <= Me.Distance2D(args.TargetPosition)))
{
Utils.Sleep(
ability.FindCastPoint() * 1000 + Me.GetTurnTime(args.TargetPosition) * 1000,
"GlobalCasting");
Utils.Sleep(ability.FindCastPoint() * 1000 + Me.GetTurnTime(args.TargetPosition) * 1000, "casting");
return;
}
}
if (Utils.SleepCheck("cancelorder")) // && !MyHeroInfo.IsChanneling())
{
return;
}
if (args.TargetPosition != Vector3.Zero && args.Order == Order.MoveLocation)
{
lastOrderPosition = args.TargetPosition;
}
args.Process = false;
}
public void OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (!args.Entities.Contains(Hero) || !Menu.Hotkeys.EnabledEvader)
{
return;
}
switch (args.Order)
{
case Order.AttackLocation:
case Order.AttackTarget:
case Order.Stop:
case Order.Hold:
case Order.MoveTarget:
case Order.MoveLocation:
case Order.ConsumeRune:
case Order.Continue:
case Order.Patrol:
movePosition = args.Target?.Position ?? args.TargetPosition;
if (sleeper.Sleeping("block") || sleeper.Sleeping("avoiding"))
{
args.Process = false;
}
break;
case Order.Ability:
case Order.AbilityTarget:
case Order.AbilityLocation:
case Order.AbilityTargetTree:
case Order.AbilityTargetRune:
movePosition = args.TargetPosition;
if ((sleeper.Sleeping("block") || sleeper.Sleeping("avoiding")) && Menu.Settings.BlockAbilityUsage)
{
args.Process = false;
}
break;
default:
movePosition = new Vector3();
break;
}
}
private void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
timbersaw.OnExecuteAbilitiy(sender, args);
}
private static void PickUpItemsOnMove(ExecuteOrderEventArgs args) {
if (enabledRecovery && RecoveryMenu.Item("forcePickMoved").GetValue<bool>()) {
args.Process = false;
PickUpItems(true);
Utils.Sleep(1000, "HpMpAbuseDelay");
}
}
private static void Player_OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (!Menu.Item("Enable").GetValue<bool>()) return;
if (MyHero == null || !MyHero.IsValid || !MyHero.IsAlive) return;
var me = sender.Selection.First();
var order = args.Order;
if (order == Order.Hold || order == Order.MoveLocation)
{
foreach (
var me2 in
args.Entities.Select(entity => MeepoSet.Find(x => x.Handle == entity.Handle))
.Where(me2 => me2 != null)
.Where(me2 => me2.CurrentOrderState != OrderState.Escape))
{
OrderStates[me2.Handle] = OrderState.Idle;
}
}
else if (Menu.Item("Drawing.PoffSystem").GetValue<bool>() &&
(args.Order == Order.AbilityLocation || args.Order == Order.AbilityTarget) &&
args.Ability.StoredName() == SpellW[MyHero.Handle].Name)
{
var pos = args.TargetPosition;
foreach (var meepo in _selectedMeepo.Where(x => !Equals(x, me)))
{
var handle = meepo.Handle;
var spell = SpellW[handle];
if (spell.CanBeCasted())
{
//spell.UseAbility(meepo.Position);
spell.UseAbility(pos);
}
}
}
}
static void Player_OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (!Game.IsInGame || !Loaded || !Enabled.isActive) return;
if (sender == MyPlayer)
{
if (args.Order == Order.MoveLocation)
{
LastMoving = args.TargetPosition;
}
}
}
public void OnExecuteAction(Player sender, ExecuteOrderEventArgs args)
{
if (Hero.IsInvisible())
{
return;
}
switch (args.Order)
{
case Order.TransferItem:
case Order.MoveItem:
case Order.DropItem:
case Order.PickItem:
case Order.BuyItem:
Sleeper.Sleep(200 + Game.Ping, itemManager);
break;
case Order.AttackTarget:
case Order.AttackLocation:
if (itemManager.PowerTreads.IsValid())
{
var attribute = itemManager.PowerTreads.GetAttackAttribute();
if (attribute != itemManager.PowerTreads.ActiveAttribute)
{
itemManager.PowerTreads.SwitchTo(attribute);
heroAttacking = true;
}
}
break;
case Order.AbilityTarget:
case Order.AbilityLocation:
case Order.Ability:
case Order.ToggleAbility:
if (!args.IsQueued)
{
var abilityClassID = args.Ability.ClassID;
if (abilityClassID == ClassID.CDOTA_Item_TeleportScroll
|| abilityClassID == ClassID.CDOTA_Item_BootsOfTravel
|| abilityClassID == ClassID.CDOTA_Item_BootsOfTravel_2)
{
Sleeper.Sleep(1000, "Main");
return;
}
UseAbility(args);
}
break;
case Order.MoveLocation:
case Order.MoveTarget:
if (Menu.Recovery.Active)
{
itemManager.PickUpItemsOnMove(args);
}
if (itemManager.PowerTreads.IsValid() && !itemManager.PowerTreads.DelaySwitch()
&& !Sleeper.Sleeping("SwitchBackPT"))
{
var attribute = itemManager.PowerTreads.GetMoveAttribute();
if (attribute != itemManager.PowerTreads.ActiveAttribute)
{
itemManager.PowerTreads.SwitchTo(attribute);
itemManager.PowerTreads.DefaultAttribute = attribute;
heroAttacking = false;
}
}
break;
default:
heroAttacking = false;
break;
}
}
