public static void LastHit()
{
if (!Utils.SleepCheck("Lasthit.Cast"))
{
return;
}
if (!Var.DisableAaKeyPressed)
{
Common.Autoattack(0);
Var.DisableAaKeyPressed = true;
Var.AutoAttackTypeDef = false;
}
Var.CreeptargetH = KillableCreep(Var.Me, false, false, 2);
if (MenuVar.UseSpell && Utils.SleepCheck("Lasthit.Cooldown"))
{
SpellCast();
}
if (Var.CreeptargetH != null && Var.CreeptargetH.IsValid &&
Var.CreeptargetH.IsVisible && Var.CreeptargetH.IsAlive)
{
var time = Var.Me.IsRanged == false
? Var.HeroAPoint / 1000 + Var.Me.GetTurnTime(Var.CreeptargetH.Position)
: Var.HeroAPoint / 1000 + Var.Me.GetTurnTime(Var.CreeptargetH.Position) +
Var.Me.Distance2D(Var.CreeptargetH) / MyHeroInfo.GetProjectileSpeed(Var.Me);
var getDamage = GetDamageOnUnit(Var.Me, Var.CreeptargetH, 0);
if (Var.CreeptargetH.Distance2D(Var.Me) <= MyHeroInfo.AttackRange())
{
if (Var.CreeptargetH.Health < getDamage ||
Var.CreeptargetH.Health < getDamage && Var.CreeptargetH.Team == Var.Me.Team &&
(MenuVar.Denie || MenuVar.Aoc))
{
if (!Var.Me.IsAttacking())
{
Var.Me.Attack(Var.CreeptargetH);
}
}
else if (Var.CreeptargetH.Health < getDamage * 2 && Var.CreeptargetH.Health >= getDamage &&
Var.CreeptargetH.Team != Var.Me.Team && Utils.SleepCheck("Lasthit.Stop"))
{
Var.Me.Hold();
Var.Me.Attack(Var.CreeptargetH);
Utils.Sleep((float)Var.HeroAPoint / 2 + Game.Ping, "Lasthit.Stop");
}
}
else if (Var.Me.Distance2D(Var.CreeptargetH) >= MyHeroInfo.AttackRange() && Utils.SleepCheck("Lasthit.Walk"))
{
Var.Me.Move(Var.CreeptargetH.Position);
Utils.Sleep(100 + Game.Ping, "Lasthit.Walk");
}
}
else
{
Var.Target = MenuVar.Harass ? Var.Me.BestAATarget() : null;
Orbwalking.Orbwalk(Var.Target, 500);
}
}
public static void Phase_boots()
{
if (CanUse("item_phase_boots") &&
Var.Me.NetworkActivity == NetworkActivity.Move && MenuVar.ItemPhaseBootsUse &&
Utils.SleepCheck("AutoUse.item_phase_boots"))
{
MyHeroInfo.GetItem("item_phase_boots").UseAbility(false);
Utils.Sleep(500, "AutoUse.item_phase_boots");
}
}
public static void Magic_wand()
{
if (CanUse("item_magic_wand") && (double)Var.Me.Health / Var.Me.MaximumHealth < MenuVar.PercentStickUse &&
MenuVar.ItemMagicWandUse && Utils.SleepCheck("AutoUse.item_magic_wand"))
{
if (MyHeroInfo.GetItem("item_magic_wand").CurrentCharges > 0)
{
MyHeroInfo.GetItem("item_magic_wand").UseAbility(false);
}
Utils.Sleep(500, "AutoUse.item_magic_wand");
}
}
public static float GetOutRange(Unit unit)
{
if (unit.Handle == Var.Me.Handle)
{
return(MyHeroInfo.AttackRange() + MenuVar.Outrange);
}
else
{
if (unit.IsRanged)
{
return(500 + MenuVar.Outrange);
}
else
{
return(200 + MenuVar.Outrange);
}
}
}
private static bool NothingCanCast()
{
var listitems = MyHeroInfo.GetItems();
if (listitems.Any(x => AllDodge.Eul.Contains(x.Name)))
{
if (listitems.First(x => AllDodge.Eul.Contains(x.Name)).CanBeCasted())
{
return(false);
}
}
if (listitems.Any(x => AllDodge.BlinkAbilities.Contains(x.Name)))
{
if (listitems.First(x => AllDodge.BlinkAbilities.Contains(x.Name)).CanBeCasted())
{
return(false);
}
}
return(true);
}
public static void Game_OnUpdate(EventArgs args)
{
if (!OnUpdateChecks.CanUpdate())
{
return;
}
MyHeroInfo.UpdatePosition();
var enemyHeroes = EnemyHeroes.UsableHeroes;
var allyHeroes = AllyHeroes.UsableHeroes;
GankDamage.UpdateDamage(enemyHeroes, allyHeroes);
if (!Me.IsAlive || Me.IsChanneling() || Me.HasModifier("modifier_spirit_breaker_charge_of_darkness") ||
(MyAbilities.ChargeOfDarkness != null && MyAbilities.ChargeOfDarkness.IsValid &&
MyAbilities.ChargeOfDarkness.IsInAbilityPhase) || !Utils.SleepCheck("Ability#.Sleep"))
{
return;
}
var keyDown = Game.IsKeyDown(MainMenu.ComboKeysMenu.Item("abilityKey1").GetValue <KeyBind>().Key);
if (Utils.SleepCheck("cancelorder") || !keyDown)
{
if (lastOrderPosition != Vector3.Zero && lastActivity == NetworkActivity.Move)
{
var ctarget = TargetSelector.ClosestToMouse(Me, 150);
if (ctarget != null && ctarget.IsValid)
{
Me.Attack(ctarget);
}
else
{
Me.Move(lastOrderPosition);
}
lastOrderPosition = Vector3.Zero;
}
}
else
{
lastActivity = Me.NetworkActivity;
lastOrderPosition = Game.MousePosition;
}
var ping = Game.Ping;
var invisible = Me.IsInvisible() && Me.ClassID != ClassID.CDOTA_Unit_Hero_Riki &&
(!Me.HasModifier("modifier_templar_assassin_meld") || !Orbwalking.CanCancelAnimation());
if (!invisible && MainMenu.Menu.Item("Ability#.EnableAutoUsage").GetValue <bool>() &&
MyAbilities.DefensiveAbilities.Any() && Utils.SleepCheck("casting"))
{
if (Utils.SleepCheck("Orbwalk.Attack") &&
allyHeroes.Any(allyHero => FullCombo.DeffensiveAutoUsage(allyHero, Me, enemyHeroes, ping)))
{
return;
}
}
var targetLock =
MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.TargetLock").GetValue <StringList>().SelectedIndex;
if (!keyDown)
{
target = null;
}
if (Game.IsChatOpen)
{
return;
}
var meMissingHp = Me.MaximumHealth - Me.Health;
var meMana = Me.Mana;
ManageAutoAttack.UpdateAutoAttack();
if (keyDown)
{
if (Utils.SleepCheck("UpdateTarget") &&
(target == null || !target.IsValid || !target.IsAlive || !target.IsVisible ||
(target.IsVisible && targetLock <= 1)))
{
var mode =
MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.Target").GetValue <StringList>().SelectedIndex;
target = mode == 0
? TargetSelector.ClosestToMouse(Me, 2000)
: EnemyHeroes.UsableHeroes.Where(x => x.Distance2D(Me) < 2000)
.MaxOrDefault(x => x.GetDoableDamage());
Utils.Sleep(250, "UpdateTarget");
}
var selectedCombo = MainMenu.ComboKeysMenu.Item("abilityComboType").GetValue <StringList>().SelectedIndex;
var combo = false;
if (!invisible && target != null && Orbwalking.CanCancelAnimation() && Utils.SleepCheck("Orbwalk.Attack"))
{
combo = FullCombo.Execute(
target,
enemyHeroes,
ping,
selectedCombo == 2,
selectedCombo == 1,
Me,
meMana,
selectedCombo == 3);
}
if (!combo &&
(target == null ||
(target.Distance2D(MyHeroInfo.Position) > 500 && Me.HasModifier("modifier_pudge_rot") &&
!target.HasModifier("modifier_pudge_meat_hook"))) &&
AllyHeroes.AbilityDictionary.ContainsKey(Me.StoredName()))
{
foreach (var ability in AllyHeroes.AbilityDictionary[Me.StoredName()].Where(x => x.IsToggled))
{
var handle = ability.Handle.ToString();
if (!Utils.SleepCheck(handle))
{
continue;
}
ability.ToggleAbility();
Utils.Sleep(500 + Game.Ping, handle);
return;
}
}
if (Me.ClassID == ClassID.CDOTA_Unit_Hero_TemplarAssassin && target != null && target.IsVisible)
{
var meld = Me.Spellbook.SpellW;
if (meld.ManaCost <= meMana && meld.Cooldown >= 0 && meld.Cooldown < UnitDatabase.GetAttackRate(Me) &&
target.Health > Dictionaries.HitDamageDictionary[target.Handle] * 2)
{
if (!Utils.SleepCheck("Ability.Move"))
{
return;
}
Me.Move(Game.MousePosition);
Utils.Sleep(100, "Ability.Move");
return;
}
}
if (combo || !Utils.SleepCheck("GlobalCasting") ||
(!(Game.MousePosition.Distance2D(Me)
> MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.NoMoveRange").GetValue <Slider>().Value) &&
(target == null || !(Me.Distance2D(target) <= MyHeroInfo.AttackRange() + 100))))
{
return;
}
MoveMode(target);
}
if (!invisible && MainMenu.Menu.Item("Ability#.EnableAutoKillSteal").GetValue <bool>() &&
Utils.SleepCheck("casting"))
{
Variables.Killsteal.FindTarget(enemyHeroes, Me);
if (Variables.Killsteal.TryKillsteal(Me, ping, enemyHeroes))
{
return;
}
}
if (!invisible && MainMenu.Menu.Item("Ability#.EnableAutoUsage").GetValue <bool>() &&
Utils.SleepCheck("Orbwalk.Attack") &&
enemyHeroes.Any(
enemyHero => Variables.AutoUsage.Try(enemyHero, enemyHeroes, meMissingHp, ping, Me, meMana)))
{
return;
}
}
public static void OnUpdate(EventArgs args)
{
if (!OnUpdateChecks.CanUpdate())
{
return;
}
if (!Utils.SleepCheck("DamageUpdate") || !Utils.SleepCheck("GlobalCasting"))
{
return;
}
Utils.Sleep(100, "DamageUpdate");
foreach (var hero in
new List <Hero>(EnemyHeroes.Heroes).Where(x => x != null && x.IsValid && x.IsAlive && x.IsVisible))
{
var heroName = NameManager.Name(hero);
var heroHandle = hero.Handle;
if (Utils.SleepCheck("calculate"))
{
var enumerable =
MyAbilities.OffensiveAbilities.Where(
ability =>
ability.Value.IsValid && ability.Key.Contains("nuke") &&
Nukes.NukesMenuDictionary[NameManager.Name(ability.Value)].Item(
NameManager.Name(ability.Value) + "herotoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) &&
MainMenu.Menu.Item("nukesToggler")
.GetValue <AbilityToggler>()
.IsEnabled(NameManager.Name(ability.Value)) &&
Nukes.NukesMenuDictionary[NameManager.Name(ability.Value)].Item(
NameManager.Name(ability.Value) + "combo").GetValue <bool>())
.OrderBy(x => ComboOrder.GetDamageOrder(x.Value))
.ToList();
float[] intakenDamage = { 0 };
var minusMagicResistancePerc = 0f;
var tempList = new List <Ability>();
float[] outtakenDamage = { 0 };
var manaLeft = AbilityMain.Me.Mana;
foreach (var ability in
enumerable.Where(
ability =>
(ability.Value.CanBeCasted() || ability.Value.IsInAbilityPhase ||
(AbilityMain.Me.ClassID == ClassID.CDOTA_Unit_Hero_Invoker &&
MyAbilities.InvokerInvoke.CanBeCasted() && ability.Value.Cooldown <= 0.5 &&
ability.Value.ManaCost + MyAbilities.InvokerInvoke.ManaCost < manaLeft)))
.Select(data => data.Value))
{
var name = NameManager.Name(ability);
if (manaLeft < ability.ManaCost ||
manaLeft
< Nukes.NukesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value)
{
continue;
}
manaLeft -= ability.ManaCost;
if (DamageAmps.IsDamageAmp(ability))
{
minusMagicResistancePerc += DamageAmps.DamageAmpValue(ability);
}
float tempdmg;
if (ability.CanHit(hero, MyHeroInfo.Position))
{
tempdmg = AbilityDamage.CalculateDamage(
ability,
AbilityMain.Me,
hero,
minusHealth: intakenDamage[0] + outtakenDamage[0],
minusMagicResistancePerc: minusMagicResistancePerc);
intakenDamage[0] += tempdmg;
tempList.Add(ability);
if (!Dictionaries.InDamageDictionary.ContainsKey(heroHandle))
{
Dictionaries.InDamageDictionary.Add(heroHandle, intakenDamage[0]);
}
else
{
Dictionaries.InDamageDictionary[heroHandle] = intakenDamage[0];
}
if (intakenDamage[0] >= hero.Health)
{
MyAbilities.NukesCombo = tempList;
AbilityMain.DealtDamage = 0;
break;
}
}
else
{
tempdmg = AbilityDamage.CalculateDamage(
ability,
AbilityMain.Me,
hero,
minusHealth: outtakenDamage[0] + intakenDamage[0],
minusMagicResistancePerc: minusMagicResistancePerc);
outtakenDamage[0] += tempdmg;
}
}
if (!Dictionaries.OutDamageDictionary.ContainsKey(heroHandle))
{
Dictionaries.OutDamageDictionary.Add(heroHandle, outtakenDamage[0]);
}
else
{
Dictionaries.OutDamageDictionary[heroHandle] = outtakenDamage[0];
}
if (!Dictionaries.InDamageDictionary.ContainsKey(heroHandle))
{
Dictionaries.InDamageDictionary.Add(heroHandle, intakenDamage[0]);
}
else
{
Dictionaries.InDamageDictionary[heroHandle] = intakenDamage[0];
}
}
float dmg;
if (!Dictionaries.InDamageDictionary.TryGetValue(heroHandle, out dmg))
{
dmg = 0;
}
float outdmg;
if (!Dictionaries.OutDamageDictionary.TryGetValue(heroHandle, out outdmg))
{
outdmg = 0;
}
var hp = Math.Max(hero.Health - dmg, 0);
var lhp = Math.Max(hp - outdmg, 0);
float hitDmg;
if (!Dictionaries.HitDamageDictionary.TryGetValue(heroHandle, out hitDmg))
{
hitDmg = hero.DamageTaken(
MyDamage.BonusDamage + MyDamage.MinDamage,
DamageType.Physical,
AbilityMain.Me);
Dictionaries.HitDamageDictionary.Add(heroHandle, hitDmg);
}
else
{
hitDmg = hero.DamageTaken(
MyDamage.BonusDamage + MyDamage.MinDamage,
DamageType.Physical,
AbilityMain.Me);
Dictionaries.HitDamageDictionary[heroHandle] = hitDmg;
Utils.Sleep(250, heroHandle + "updatehitdamage");
}
var currentHits = lhp / hitDmg;
double hits;
if (!Dictionaries.HitsDictionary.TryGetValue(heroHandle.ToString(), out hits))
{
hits = Math.Ceiling(
(currentHits * MyHeroInfo.AttackRate() * hero.HealthRegeneration + lhp) / hitDmg);
Dictionaries.HitsDictionary.Add(heroHandle.ToString(), hits);
}
else if (Utils.SleepCheck(heroHandle + "updatehits"))
{
hits = Math.Ceiling(
(currentHits * MyHeroInfo.AttackRate() * hero.HealthRegeneration + lhp) / hitDmg);
Dictionaries.HitsDictionary[heroHandle.ToString()] = hits;
Utils.Sleep(250, heroHandle + "updatehits");
}
}
}
public static bool Cast(
Ability ability,
Unit target,
Unit buffTarget,
string name,
List <Modifier> modifiers,
bool togglearmlet = false)
{
if (name == "item_armlet")
{
if (buffTarget.Modifiers.Any(x => x.Name == "modifier_ice_blast"))
{
return(false);
}
if (!togglearmlet && buffTarget.Distance2D(target) > Math.Max(target.GetAttackRange(), 500))
{
return(false);
}
var armlettoggled = modifiers.Any(x => x.Name == "modifier_item_armlet_unholy_strength") &&
ability.IsToggled;
Game.ExecuteCommand("dota_player_units_auto_attack_after_spell 0");
ManageAutoAttack.AutoAttackDisabled = true;
if (armlettoggled)
{
ability.ToggleAbility();
ability.ToggleAbility();
return(true);
}
ability.ToggleAbility();
return(true);
}
if (!(buffTarget.Distance2D(target) < MyHeroInfo.AttackRange() + 150))
{
return(false);
}
SoulRing.Cast(ability);
if (ability.Name == "templar_assassin_refraction")
{
var meld = AbilityMain.Me.Spellbook.Spell2;
if (meld != null && meld.CanBeCasted())
{
if (
!(target.Distance2D(MyHeroInfo.Position)
< (AbilityMain.Me.GetAttackRange() + 50 + target.HullRadius + AbilityMain.Me.HullRadius)) ||
Orbwalking.AttackOnCooldown(target) || AbilityMain.Me.IsAttacking() ||
(target.Predict(Game.Ping).Distance2D(MyHeroInfo.Position)
> (AbilityMain.Me.GetAttackRange() + 50 + target.HullRadius + AbilityMain.Me.HullRadius)) ||
!Utils.SleepCheck("GlobalCasting"))
{
return(false);
}
Game.ExecuteCommand("dota_player_units_auto_attack_after_spell 0");
ManageAutoAttack.AutoAttackDisabled = true;
ability.UseAbility();
if (Nuke.Cast(meld, target, NameManager.Name(meld)))
{
DelayAction.Add(
new DelayActionItem(
(int)meld.GetCastDelay(AbilityMain.Me, target) * 1000 + 100,
() =>
{
AbilityMain.Me.Attack(target);
},
CancellationToken.None));
}
Utils.Sleep(meld.GetCastDelay(AbilityMain.Me, target) * 1000, "GlobalCasting");
Utils.Sleep(meld.GetHitDelay(target, name) * 1000 + 200, "casting");
Utils.Sleep(meld.GetHitDelay(target, name) * 1000 + 200, ability.Handle.ToString());
return(true);
}
}
if (ability.IsAbilityBehavior(AbilityBehavior.NoTarget, name))
{
Game.ExecuteCommand("dota_player_units_auto_attack_after_spell 0");
ManageAutoAttack.AutoAttackDisabled = true;
ability.UseAbility();
return(true);
}
Game.ExecuteCommand("dota_player_units_auto_attack_after_spell 0");
ManageAutoAttack.AutoAttackDisabled = true;
ability.UseAbility(buffTarget);
return(true);
}
public static bool Execute(
Hero target,
Hero[] enemyHeroes,
float ping,
bool onlyDamage,
bool onlyDisable,
Hero me,
float mana,
bool customOrder)
{
var toggler = MainMenu.ComboKeysMenu.Item("comboAbilitiesToggler").GetValue <AbilityToggler>();
if (Utils.SleepCheck("UpdateCombo"))
{
if (customOrder)
{
MyAbilities.Combo =
MyAbilities.OffensiveAbilities.Where(
x =>
x.Value.IsValid && x.Value.Owner.Equals(me) && toggler.IsEnabled(NameManager.Name(x.Value)))
.OrderByDescending(
x =>
MainMenu.ComboKeysMenu.Item("Ability#.ComboOrder")
.GetValue <PriorityChanger>()
.GetPriority(x.Value.StoredName()));
}
else
{
MyAbilities.Combo =
MyAbilities.OffensiveAbilities.Where(
x =>
x.Value.IsValid && x.Value.Owner.Equals(me) && toggler.IsEnabled(NameManager.Name(x.Value)))
.OrderBy(x => ComboOrder.GetComboOrder(x.Value, onlyDisable));
}
Utils.Sleep(500, "UpdateCombo");
}
if (Utils.SleepCheck("casting") && MyAbilities.Combo != null)
{
if (target != null)
{
if (Dictionaries.HitDamageDictionary.ContainsKey(target.Handle) &&
Dictionaries.HitDamageDictionary[target.Handle] * 1.5 >= target.Health &&
target.Distance2D(MyHeroInfo.Position) <= me.GetAttackRange() + 150)
{
return(false);
}
if (!Utils.SleepCheck(target.Handle + "KeyCombo"))
{
return(false);
}
if (AbilityMain.Me.ClassID == ClassID.CDOTA_Unit_Hero_TemplarAssassin)
{
var r = MyAbilities.Combo.FirstOrDefault(x => x.Key == "templar_assassin_psionic_trapslow");
var modifier = target.FindModifier("modifier_templar_assassin_trap_slow");
if (modifier == null || modifier.RemainingTime < r.Value.GetHitDelay(target))
{
Slow.TemplarAssasinUseTrap(target);
}
}
if (me.ClassID == ClassID.CDOTA_Unit_Hero_Tinker && toggler.IsEnabled("tinker_rearm") &&
MyAbilities.TinkerRearm.CanBeCasted() && Utils.SleepCheck("Ability.TinkerRearm") &&
!MyAbilities.Combo.Any(
x =>
x.Value.CanBeCasted() ||
(x.Value.CanBeCasted(SoulRing.ManaGained) && SoulRing.Check(x.Value))))
{
MyAbilities.TinkerRearm.UseAbility();
Utils.Sleep(
MyAbilities.TinkerRearm.FindCastPoint() * 1000 + Game.Ping
+ MyAbilities.TinkerRearm.GetChannelTime(MyAbilities.TinkerRearm.Level - 1) * 1000 + 500,
"Ability.TinkerRearm");
Utils.Sleep(
MyAbilities.TinkerRearm.FindCastPoint() * 1000 + Game.Ping
+ MyAbilities.TinkerRearm.GetChannelTime(MyAbilities.TinkerRearm.Level - 1) * 1000,
"GlobalCasting");
Utils.Sleep(
MyAbilities.TinkerRearm.FindCastPoint() * 1000 + Game.Ping
+ MyAbilities.TinkerRearm.GetChannelTime(MyAbilities.TinkerRearm.Level - 1) * 1000,
"casting");
Utils.Sleep(
MyAbilities.TinkerRearm.FindCastPoint() * 1000 + Game.Ping
+ MyAbilities.TinkerRearm.GetChannelTime(MyAbilities.TinkerRearm.Level - 1) * 1000,
"cancelorder");
Utils.Sleep(
MyAbilities.TinkerRearm.FindCastPoint() * 1000 + Game.Ping
+ MyAbilities.TinkerRearm.GetChannelTime(MyAbilities.TinkerRearm.Level - 1) * 1000,
"Orbwalk.Attack");
Utils.Sleep(
MyAbilities.TinkerRearm.FindCastPoint() * 1000 + Game.Ping
+ MyAbilities.TinkerRearm.GetChannelTime(MyAbilities.TinkerRearm.Level - 1) * 1000,
"Ability#.Sleep");
return(true);
}
foreach (var data in
MyAbilities.Combo.Where(
x =>
x.Value.IsValid && !x.Value.IsToggled &&
(x.Value.CanBeCasted() || x.Value.CanInvoke() ||
(x.Value.CanBeCasted(SoulRing.ManaGained) && SoulRing.Check(x.Value))) &&
(!x.Value.IsAbilityBehavior(AbilityBehavior.Hidden) ||
(AbilityMain.Me.ClassID == ClassID.CDOTA_Unit_Hero_Invoker &&
(x.Value.CanBeCasted() || x.Value.CanInvoke()))) &&
((x.Value is Item && me.CanUseItems()) || (!(x.Value is Item) && me.CanCast())) &&
(Utils.SleepCheck(x.Value.Handle.ToString()) ||
(!x.Value.IsInAbilityPhase && x.Value.FindCastPoint() > 0))))
{
var ability = data.Value;
var name = NameManager.Name(ability);
var category = (name == "lion_impale") ? "disable" : data.Key.Substring(name.Length);
// if (category == "special" || category == "buff")
// {
// continue;
// }
// if (onlyDamage && (category == "disable" || category == "slow" || category == "silence"))
// {
// continue;
// }
// if (onlyDisable && (category == "nuke" || category == "harras"))
// {
// continue;
// }
var handleString = ability.Handle.ToString();
if (category == "blink")
{
var range = MainMenu.BlinkMenu.Item("Ability#.BlinkRange").GetValue <Slider>().Value;
var blinkPosition = target.PredictedPosition(0.3 + me.GetTurnTime(target));
if (MyHeroInfo.Position.Distance2D(blinkPosition) > 1500 + range ||
MyHeroInfo.Position.Distance2D(blinkPosition) < 500 + range)
{
continue;
}
var minEnemiesAround =
MainMenu.BlinkMenu.Item("Ability#.BlinkMaxEnemiesAround").GetValue <Slider>().Value;
if (
Heroes.GetByTeam(target.Team)
.Count(
x =>
x.IsValid && !x.Equals(target) && x.IsAlive && !x.IsIllusion &&
x.Distance2D(target) < 500 + range) > minEnemiesAround)
{
continue;
}
if (MyHeroInfo.Position.Distance2D(blinkPosition) > 1200)
{
blinkPosition = (blinkPosition - MyHeroInfo.Position) * 1200
/ blinkPosition.Distance2D(MyHeroInfo.Position) + MyHeroInfo.Position;
}
if (blinkPosition.Distance2D(target) < range)
{
blinkPosition.Extend(MyHeroInfo.Position, range);
}
ability.UseAbility(blinkPosition);
MyHeroInfo.Position = blinkPosition;
Utils.Sleep(Game.Ping + me.GetTurnTime(MyHeroInfo.Position) + 200, "mePosition");
Utils.Sleep(500, handleString);
Utils.Sleep(500, "GlobalCasting");
return(true);
}
if (category != "buff" && target.IsMagicImmune() && ability.ImmunityType != (ImmunityType)3)
{
continue;
}
if (!CastingChecks.All(name, target, ability))
{
continue;
}
if (Variables.EtherealHitTime >= (Utils.TickCount + ability.GetHitDelay(target, name) * 1000))
{
continue;
}
if (Variables.EtherealHitTime >= Utils.TickCount && name == "pudge_dismember")
{
continue;
}
if (name == "omniknight_purification")
{
if (Nukes.NukesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value
< mana && MainMenu.Menu.Item("nukesToggler").GetValue <AbilityToggler>().IsEnabled(name) &&
Nukes.NukesMenuDictionary[name].Item(name + "herotoggler")
.GetValue <HeroToggler>()
.IsEnabled(NameManager.Name(target)) &&
(Variables.EtherealHitTime
< (Utils.TickCount + ability.GetHitDelay(target, name) * 1000)) &&
target.Health
> Nukes.NukesMenuDictionary[name].Item(NameManager.Name(ability) + "minhealthslider")
.GetValue <Slider>()
.Value)
{
var target1 =
AllyHeroes.UsableHeroes.Where(x => !x.IsMagicImmune())
.MinOrDefault(x => x.Distance2D(target));
if (target1 != null && ability.CanHit(target1, MyHeroInfo.Position, name) &&
target1.PredictedPosition().Distance2D(target.PredictedPosition())
< ability.GetRadius(name) &&
target1.PredictedPosition()
.Distance2D(
target.PredictedPosition(
ability.FindCastPoint(NameManager.Name(ability))))
< ability.GetRadius(name))
{
if (Nuke.Cast(ability, target1, name))
{
Utils.Sleep(
Math.Max(ability.GetCastDelay(me, target1, abilityName: name), 0.2) * 1000,
"GlobalCasting");
Utils.Sleep(ability.GetHitDelay(target1, name) * 1000, "calculate");
Utils.Sleep(
Math.Max(
ability.GetCastDelay(
me,
target1,
useCastPoint: false,
abilityName: name),
0.15) * 1000 + Game.Ping,
// + (Math.Max(me.Distance2D(target) - ability.GetCastRange(name) - 50, 0)
// / me.MovementSpeed) * 1000,
"casting");
Utils.Sleep(
Math.Max(ability.GetCastDelay(me, target1, abilityName: name), 0.2) * 1000,
"cancelorder");
return(true);
}
}
else if (target1 != null && target1.Equals(me))
{
AbilityMain.MoveMode(target);
return(true);
}
}
return(false);
}
if (!ability.CanHit(target, MyHeroInfo.Position, name) && category != "buff" &&
(!target.HasModifier("modifier_pudge_meat_hook") ||
me.ClassID != ClassID.CDOTA_Unit_Hero_Pudge || target.Distance2D(me) > 600))
{
Variables.DealtDamage = 0;
if (name == "templar_assassin_meld")
{
if (!Nuke.Cast(ability, target, name) && Utils.SleepCheck("Ability.Move"))
{
AbilityMain.MoveMode(target);
Utils.Sleep(100, "Ability.Move");
}
Utils.Sleep(200, "GlobalCasting");
return(true);
}
if (name == "pudge_rot")
{
continue;
}
if (ability.IsAbilityBehavior(AbilityBehavior.NoTarget, NameManager.Name(ability)) &&
target.PredictedPosition().Distance2D(MyHeroInfo.Position)
< ability.GetRadius() + 150 && me.ClassID != ClassID.CDOTA_Unit_Hero_Pudge)
{
if (Utils.SleepCheck("Ability.Move"))
{
AbilityMain.MoveMode(target);
Utils.Sleep(100, "Ability.Move");
}
Utils.Sleep(200, "GlobalCasting");
return(true);
}
if (me.ClassID == ClassID.CDOTA_Unit_Hero_Pudge)
{
return(false);
}
var distance = target.Distance2D(MyHeroInfo.Position);
if (distance > ability.GetCastRange(name) + 250 &&
((name != "item_cyclone" && category != "disable") ||
distance > ability.GetCastRange(name) + 1200))
{
continue;
}
if (Game.MousePosition.Distance2D(me)
< MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.NoMoveRange").GetValue <Slider>().Value)
{
return(false);
}
if (!Utils.SleepCheck("Ability.Move"))
{
return(true);
}
AbilityMain.MoveMode(target);
Utils.Sleep(100, "Ability.Move");
return(true);
}
if (name == "item_cyclone" && coldFeetLastUse - Utils.TickCount < 2500 &&
coldFeetLastUse - Utils.TickCount > -1000)
{
continue;
}
if (((Dictionaries.InDamageDictionary.ContainsKey(target.Handle) &&
Dictionaries.InDamageDictionary[target.Handle] >= target.Health) ||
(Dictionaries.OutDamageDictionary.ContainsKey(target.Handle) &&
Dictionaries.InDamageDictionary.ContainsKey(target.Handle) &&
(Dictionaries.InDamageDictionary[target.Handle]
+ Dictionaries.OutDamageDictionary[target.Handle]) >= target.Health)) &&
MainMenu.Menu.Item("Ability#.EnableAutoKillSteal").GetValue <bool>())
{
return(false);
}
if (category == "nuke" &&
(Nukes.NukesMenuDictionary[name].Item(name + "minManaCheckCombo")
.GetValue <Slider>()
.Value > mana || !Utils.SleepCheck(target.Handle + "KillSteal") ||
(name == "axe_culling_blade" && !CastingChecks.Killsteal(ability, target, name)) ||
(target.Health
< Nukes.NukesMenuDictionary[name].Item(name + "minhealthslider")
.GetValue <Slider>()
.Value) ||
(name == "zuus_thundergods_wrath" &&
(1
+ enemyHeroes.Count(
x =>
!x.Equals(target) &&
x.Health <= AbilityDamage.CalculateDamage(ability, me, x)))
< Nukes.NukesMenuDictionary[name].Item(name + "minenemykill")
.GetValue <Slider>()
.Value)))
{
continue;
}
if (name == "item_urn_of_shadows" && target.HasModifier("modifier_item_urn_damage"))
{
continue;
}
if (category == "nuke")
{
var casted = Nuke.Cast(ability, target, name);
if (!casted)
{
continue;
}
if (AbilityDamage.CalculateDamage(ability, me, target) >= target.Health)
{
Utils.Sleep(ability.GetHitDelay(target, name) * 1000 + 500, target.Handle + "KillSteal");
}
}
if (category == "disable" &&
Disables.DisablesMenuDictionary[name].Item(name + "minManaCheckCombo")
.GetValue <Slider>()
.Value < mana && !Disable.Cast(ability, target, name))
{
continue;
}
if (category == "slow" &&
Slows.SlowsMenuDictionary[name].Item(name + "minManaCheckCombo").GetValue <Slider>().Value
< mana && !Slow.Cast(ability, target, name))
{
continue;
}
if (category == "harras" &&
Harrases.HarrasesMenuDictionary[name].Item(name + "minManaCheckCombo")
.GetValue <Slider>()
.Value < mana && !Harras.Cast(ability, target, name))
{
continue;
}
if (category == "silence" &&
Silences.SilencesMenuDictionary[name].Item(name + "minManaCheckCombo")
.GetValue <Slider>()
.Value < mana &&
(((name == "item_orchid" || name == "item_bloodthorn" ||
name == "skywrath_mage_ancient_seal") &&
MainMenu.ComboKeysMenu.Item("Ability#.MaximizeDamage").GetValue <bool>() &&
!Nuke.Cast(ability, target, name)) || !Silence.Cast(ability, target, name)))
{
continue;
}
if (category == "special" &&
Specials.SpecialsMenuDictionary[name].Item(name + "minManaCheckCombo")
.GetValue <Slider>()
.Value < mana && !Special.Cast(ability, target, name))
{
continue;
}
if (category == "buff" &&
Buffs.BuffsMenuDictionary[name].Item(name + "minManaCheckCombo").GetValue <Slider>().Value
< mana &&
(name == "item_armlet" || name == "item_satanic" || !Buff.Cast(ability, target, me, name)))
{
continue;
}
if (Utils.SleepCheck(ability.Handle.ToString()))
{
Variables.DealtDamage += AbilityDamage.CalculateDamage(ability, me, target);
}
var delay = Math.Max(
ability.GetCastDelay(me, target, abilityName: name, useCastPoint: false),
0.2) * 1000;
switch (name)
{
case "riki_blink_strike":
Utils.Sleep(MyHeroInfo.AttackRate() * 1000, handleString);
break;
case "necrolyte_reapers_scythe":
Utils.Sleep(delay + ping + 1500, "calculate");
break;
case "necrolyte_death_pulse":
Utils.Sleep(delay + ping + 200, "calculate");
break;
case "item_ethereal_blade":
// Variables.EtherealHitTime =
// (float)
// (Utils.TickCount + me.GetTurnTime(target) * 1000
// + Prediction.CalculateReachTime(target, 1200, target.Position - me.Position)
// + ping * 2);
Variables.LastEtherealTarget = target;
Variables.LastEtherealCastPosition = me.NetworkPosition;
Variables.LastEtherealCastTime =
(float)(Utils.TickCount + (me.GetTurnTime(target) * 1000) + ping);
Utils.Sleep(
me.GetTurnTime(target) * 1000 + 100
+ (MyHeroInfo.Position.Distance2D(target) / 1200) * 1000 + ping,
"calculate");
break;
case "tusk_snowball":
Utils.Sleep(
me.GetTurnTime(target) * 1000
+ (MyHeroInfo.Position.Distance2D(target) / 675) * 1000,
"GlobalCasting");
break;
case "ancient_apparition_cold_feet":
coldFeetLastUse = Utils.TickCount + 4000;
break;
case "item_cyclone":
Utils.Sleep(Game.Ping + (me.GetTurnTime(target) * 1000) + 450, "GlobalCasting");
Utils.Sleep(Game.Ping + (me.GetTurnTime(target) * 1000) + 450, "casting");
break;
}
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 4, "GlobalCasting");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 4, "casting");
}
Utils.Sleep(delay, handleString);
Utils.Sleep(
ability.GetCastDelay(me, target, abilityName: name, useCastPoint: false) * 1000,
"GlobalCasting");
Utils.Sleep(ability.GetHitDelay(target, name) * 1000, "calculate");
Utils.Sleep(
Math.Max(ability.GetCastDelay(me, target, useCastPoint: false, abilityName: name), 0.15)
* 1000 + Game.Ping,
// + (Math.Max(me.Distance2D(target) - ability.GetCastRange(name) - 50, 0)
// / me.MovementSpeed) * 1000,
"casting");
Utils.Sleep(delay, "cancelorder");
if (name == "pudge_rot")
{
continue;
}
return(true);
}
}
}
return(false);
}
public static void Drawing(EventArgs args)
{
if (!OnUpdate.CanUpdate())
{
return;
}
if (MenuVar.Maphack || MenuVar.ShowLastPos)
{
foreach (var hero in EnemyHeroes.Heroes)
{
ShowMeMore.DrawLastPosition(hero);
}
}
#region Hero radius
MyHero.RadiusHeroParticleEffect("ExpRange", 1300, new Color(0, 100, 0), MenuVar.ShowExpRange.GetValue <bool>());
MyHero.RadiusHeroParticleEffect("AttackRange", Var.Me.IsRanged
? MyHeroInfo.AttackRange() + 70
: MyHeroInfo.AttackRange(), new Color(255, 0, 0), MenuVar.ShowAttackRange.GetValue <bool>());
#endregion Hero radius
#region Runes
if (MenuVar.ShowRunesMinimap)
{
RunesOnMinimap.Draw();
}
#endregion Runes
#region Lasthit
if (MenuVar.LastHitEnable)
{
if (MenuVar.ShowHp)
{
Lasthit.Drawhpbar();
}
}
#endregion Lasthit
#region JungleStack
if (MenuVar.StackKey && MenuVar.DrawStackLine)
{
JungleDraw.DrawLine();
}
else
{
JungleDraw.Clear();
}
#endregion JungleStack
#region ShowMeMore
if (MenuVar.ShowIllusions && EnemyHeroes.Illusions.Count > 0)
{
ShowMeMore.ShowIllusion();
}
else
{
ShowMeMore.ClearParticle();
}
foreach (var hero in AllyHeroes.Heroes)
{
ShowMeMore.DrawShowMeMoreBara(hero);
}
#endregion ShowMeMore
#region Top ovellay
if (MenuVar.ShowTopOverlayEnemyHp)
{
Overlay.DrawTopOverlayHealth(EnemyHeroes.Heroes, MenuVar.HealthHeightEnemy,
new Color(MenuVar.OverlayHealthEnemyRed, MenuVar.OverlayHealthEnemyGreen, MenuVar.OverlayHealthEnemyBlue, MenuVar.OverlayAlpha));
}
if (MenuVar.ShowTopOverlayEnemyMp)
{
Overlay.DrawTopOverlayMana(EnemyHeroes.Heroes, MenuVar.ManaHeightEnemy,
new Color(MenuVar.OverlayManaEnemyRed, MenuVar.OverlayManaEnemyGreen, MenuVar.OverlayManaEnemyBlue, MenuVar.OverlayAlpha));
}
if (MenuVar.ShowTopOverlayEnemyUltLine)
{
Overlay.DrawTopOverlayUltimateCooldownLine(EnemyHeroes.Heroes, MenuVar.UltimateHeightEnemy, MenuVar.OverlayAlpha);
}
if (MenuVar.ShowTopOverlayEnemyUltText)
{
Overlay.DrawTopOverlayUltimateCooldownText(EnemyHeroes.Heroes, MenuVar.OverlayAlpha);
}
if (MenuVar.ShowTopOverlayEnemy)
{
Overlay.DrawTopOverlay(EnemyHeroes.Heroes);
}
if (MenuVar.ShowTopOverlayAllyHp)
{
Overlay.DrawTopOverlayHealth(AllyHeroes.Heroes, MenuVar.HealthHeightAlly,
new Color(MenuVar.OverlayHealthAllyRed, MenuVar.OverlayHealthAllyGreen, MenuVar.OverlayHealthAllyBlue, MenuVar.OverlayAlpha));
}
if (MenuVar.ShowTopOverlayAllyMp)
{
Overlay.DrawTopOverlayMana(AllyHeroes.Heroes, MenuVar.ManaHeightAlly,
new Color(MenuVar.OverlayManaAllyRed, MenuVar.OverlayManaAllyGreen, MenuVar.OverlayManaAllyBlue, MenuVar.OverlayAlpha));
}
if (MenuVar.ShowTopOverlayAllyUltLine)
{
Overlay.DrawTopOverlayUltimateCooldownLine(AllyHeroes.Heroes, MenuVar.UltimateHeightAlly, MenuVar.OverlayAlpha);
}
if (MenuVar.ShowTopOverlayAllyUltText)
{
Overlay.DrawTopOverlayUltimateCooldownText(AllyHeroes.Heroes, MenuVar.OverlayAlpha);
}
if (MenuVar.ShowTopOverlayAlly)
{
Overlay.DrawTopOverlay(AllyHeroes.Heroes);
}
Overlay.DrawTopHelpOverlay(EnemyHeroes.Heroes,
new Color(MenuVar.OverlayHealthEnemyRed, MenuVar.OverlayHealthEnemyGreen, MenuVar.OverlayHealthEnemyBlue, MenuVar.OverlayAlpha));
Overlay.DrawTopHelpOverlay(AllyHeroes.Heroes,
new Color(MenuVar.OverlayHealthAllyRed, MenuVar.OverlayHealthAllyGreen, MenuVar.OverlayHealthAllyBlue, MenuVar.OverlayAlpha));
#endregion Top ovellay
#region JungleStack
if (MenuVar.StackKey)
{
JungleDraw.DrawCamp();
}
//foreach (var x in ShowMeMore.Courier)
//{
// try
// {
// var pos = Ensage.Drawing.WorldToScreen(x.Value);
// DrawText(x.Key.Name, (int) pos.X, (int) pos.Y, Color.Aqua, Var.VisibleFont);
// }
// catch (Exception)
// {
// //
// }
//}
//if (Utils.SleepCheck("111"))
//{
// ShowMeMore.Courier.Clear();
// Utils.Sleep(3000, "111");
//}
#endregion JungleStack
#region CouInfo
if (MenuVar.CouForced)
{
Overlay.DrawCouForce();
}
if (MenuVar.CouAbuse)
{
Overlay.DrawCouAbuse();
}
if (MenuVar.CouLock)
{
Overlay.DrawCouLock();
}
#endregion CouInfo
#region DevInfo
if (MenuVar.ShowInfo)
{
Dev.DevInfo();
}
else
{
Dev.DevInfoDispose();
}
#endregion DevInfo
}
/// <summary>
/// The try kill steal.
/// </summary>
/// <param name="me">
/// The me.
/// </param>
/// <param name="ping">
/// The ping.
/// </param>
/// <param name="enemyHeroes">
/// The enemy heroes.
/// </param>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public bool TryKillsteal(Hero me, float ping, Hero[] enemyHeroes)
{
if (this.possibleTarget == null || !this.possibleTarget.IsValid || !this.possibleTarget.CanDie() ||
!MyAbilities.NukesCombo.Any())
{
return(false);
}
if (!(Dictionaries.InDamageDictionary[this.possibleTarget.Handle] >= this.possibleTarget.Health))
{
return(false);
}
foreach (var ability in from ability in MyAbilities.NukesCombo.OrderBy(ComboOrder.GetAbilityOrder)
where
ability != null &&
(ability.CanBeCasted() ||
(ability.CanBeCasted(SoulRing.ManaGained) && SoulRing.Check(ability)) ||
ability.CanInvoke()) &&
(Utils.SleepCheck(ability.Handle.ToString()) ||
(!ability.IsInAbilityPhase && ability.FindCastPoint() > 0))
select ability)
{
var name = NameManager.Name(ability);
var handleString = ability.Handle.ToString();
if (Variables.EtherealHitTime
>= (Utils.TickCount + (ability.GetHitDelay(this.possibleTarget, name) * 1000)))
{
continue;
}
if (name == "omniknight_purification")
{
if (this.PurificationUsage(name, ability, me, ping, handleString))
{
return(true);
}
}
if (this.possibleTarget.Health - Variables.DealtDamage <= 0 ||
this.possibleTarget.Health - Variables.DealtDamage
< Nukes.NukesMenuDictionary[name].Item(name + "minhealthslider").GetValue <Slider>().Value)
{
Utils.Sleep(500, this.possibleTarget.Handle + "KillSteal");
Variables.DealtDamage = 0;
return(false);
}
if (name == "item_urn_of_shadows" && this.possibleTarget.HasModifier("modifier_item_urn_damage"))
{
continue;
}
if (!ability.CanHit(this.possibleTarget, MyHeroInfo.Position, name) ||
(name == "zuus_thundergods_wrath" &&
(1
+ enemyHeroes.Count(
x =>
!x.Equals(this.possibleTarget) &&
x.Health <= AbilityDamage.CalculateDamage(ability, me, x)))
< Nukes.NukesMenuDictionary[name].Item(name + "minenemykill").GetValue <Slider>().Value) ||
!MainMenu.Menu.Item("nukesToggler").GetValue <AbilityToggler>().IsEnabled(name) ||
!Nukes.NukesMenuDictionary[name].Item(name + "herotoggler")
.GetValue <HeroToggler>()
.IsEnabled(NameManager.Name(this.possibleTarget)) ||
!Nuke.Cast(ability, this.possibleTarget, name))
{
return(false);
}
if (Utils.SleepCheck(handleString))
{
Variables.DealtDamage += AbilityDamage.CalculateDamage(ability, me, this.possibleTarget);
if (this.possibleTarget.Health - Variables.DealtDamage <= 0)
{
Utils.Sleep(
(ability.GetHitDelay(this.possibleTarget, name) * 1000) + 500,
this.possibleTarget.Handle + "KillSteal");
}
}
var delay = ability.GetCastDelay(me, this.possibleTarget, abilityName: name) * 1000;
if (name == "riki_blink_strike")
{
Utils.Sleep(MyHeroInfo.AttackRate() * 1000, handleString);
}
if (name == "necrolyte_reapers_scythe")
{
Utils.Sleep(delay + ping + 1500, "calculate");
}
if (name == "necrolyte_death_pulse")
{
Utils.Sleep(delay + ping + 200, "calculate");
}
if (name == "item_ethereal_blade")
{
// Variables.EtherealHitTime =
// (float)
// (Utils.TickCount + (me.GetTurnTime(this.possibleTarget) * 1000)
// + Prediction.CalculateReachTime(
// this.possibleTarget,
// 1200,
// this.possibleTarget.Position - MyHeroInfo.Position) + (ping * 2));
Variables.LastEtherealTarget = this.possibleTarget;
Variables.LastEtherealCastPosition = MyHeroInfo.Position;
Variables.LastEtherealCastTime =
(float)(Utils.TickCount + (me.GetTurnTime(this.possibleTarget) * 1000) + ping);
Utils.Sleep(
(me.GetTurnTime(this.possibleTarget) * 1000) + 100
+ ((MyHeroInfo.Position.Distance2D(this.possibleTarget) / 1200) * 1000) + ping,
"calculate");
}
if (name == "tusk_snowball")
{
Utils.Sleep(
(me.GetTurnTime(this.possibleTarget) * 1000)
+ ((MyHeroInfo.Position.Distance2D(this.possibleTarget) / 675) * 1000),
"GlobalCasting");
}
var hitDelay = ability.GetHitDelay(this.possibleTarget, name);
Utils.Sleep(delay, handleString);
Utils.Sleep(
ability.GetCastDelay(me, this.possibleTarget, useCastPoint: false, abilityName: name) * 1000,
"GlobalCasting");
Utils.Sleep((hitDelay * 1000) + 200, "calculate");
Utils.Sleep(
ability.GetCastDelay(me, this.possibleTarget, useCastPoint: false, abilityName: name) * 1000,
"casting");
Utils.Sleep(delay, "cancelorder");
this.targetFindSleeper.Sleep((float)((hitDelay * 1000) + 400));
return(true);
}
return(true);
}
public static void Game_OnUpdate(EventArgs args)
{
if (!OnUpdateChecks.CanUpdate())
{
return;
}
MyHeroInfo.UpdatePosition();
ManageAutoAttack.UpdateAutoAttack();
var enemyHeroes = EnemyHeroes.UsableHeroes;
var allyHeroes = AllyHeroes.UsableHeroes;
GankDamage.UpdateDamage(enemyHeroes, allyHeroes);
if (!Me.IsAlive ||
(Me.IsInvisible() && !Me.IsVisibleToEnemies && Me.ClassID != ClassID.CDOTA_Unit_Hero_Riki &&
(Me.Modifiers.All(x => x.Name != "modifier_templar_assassin_meld") ||
!Orbwalking.CanCancelAnimation())) || Me.IsChanneling())
{
return;
}
if (Utils.SleepCheck("cancelorder"))
{
if (lastOrderPosition != Vector3.Zero)
{
var ctarget = TargetSelector.ClosestToMouse(Me, 150);
if (ctarget != null)
{
Me.Attack(ctarget);
}
else
{
Me.Attack(lastOrderPosition);
}
lastOrderPosition = Vector3.Zero;
}
}
else
{
lastOrderPosition = Game.MousePosition;
}
var meModifiers = Me.Modifiers.ToList();
var ping = Game.Ping;
if (LaunchSnowball(meModifiers))
{
return;
}
if (MyAbilities.DeffensiveAbilities.Any() && Utils.SleepCheck("casting"))
{
if (allyHeroes.Any(allyHero => FullCombo.DeffensiveAutoUsage(allyHero, Me, enemyHeroes, ping)))
{
return;
}
}
if (!MyAbilities.OffensiveAbilities.Any())
{
if (Game.IsChatOpen)
{
return;
}
if (Game.IsKeyDown(MainMenu.ComboKeysMenu.Item("abilityKey1").GetValue <KeyBind>().Key))
{
if (Utils.SleepCheck("UpdateTarget"))
{
target = TargetSelector.ClosestToMouse(Me, 2000);
Utils.Sleep(250, "UpdateTarget");
}
if (target != null && !target.IsValid)
{
target = null;
}
if (Utils.SleepCheck("GlobalCasting"))
{
Orbwalking.Orbwalk(target, attackmodifiers: true);
}
}
}
if (Utils.SleepCheck("casting"))
{
if (FullCombo.KillSteal(enemyHeroes, ping, Me))
{
return;
}
}
var meMissingHp = Me.MaximumHealth - Me.Health;
var meMana = Me.Mana;
if (
enemyHeroes.Any(
enemyHero => FullCombo.AutoUsage(enemyHero, enemyHeroes, meMissingHp, meModifiers, ping, Me, meMana)))
{
return;
}
if (Game.IsChatOpen)
{
return;
}
if (Game.IsKeyDown(MainMenu.ComboKeysMenu.Item("abilityKey1").GetValue <KeyBind>().Key))
{
if (Utils.SleepCheck("UpdateTarget"))
{
target = TargetSelector.ClosestToMouse(Me, 2000);
Utils.Sleep(250, "UpdateTarget");
}
if (target != null && !target.IsValid)
{
target = null;
}
var selectedCombo = MainMenu.ComboKeysMenu.Item("abilityComboType").GetValue <StringList>().SelectedIndex;
if (target != null && Utils.SleepCheck("Orbwalk.Attack"))
{
FullCombo.Execute(
target,
enemyHeroes,
ping,
selectedCombo == 2,
selectedCombo == 1,
Me,
meModifiers,
meMana);
}
if (Me.ClassID == ClassID.CDOTA_Unit_Hero_TemplarAssassin && target != null && target.IsVisible)
{
var meld = Me.Spellbook.SpellW;
if (meld.ManaCost <= meMana && meld.Cooldown >= 0 && meld.Cooldown < UnitDatabase.GetAttackRate(Me) &&
target.Health > Dictionaries.HitDamageDictionary[target.Handle] * 2)
{
if (!Utils.SleepCheck("Ability.Move"))
{
return;
}
Me.Move(Game.MousePosition);
Utils.Sleep(100, "Ability.Move");
return;
}
}
if (Utils.SleepCheck("GlobalCasting"))
{
Orbwalking.Orbwalk(target, attackmodifiers: true);
}
}
}
private static double GetDamageOnUnitForDrawhpbar(Unit unit, double bonusdamage)
{
var quellingBlade = Var.Me.FindItem("item_quelling_blade");
double modif = 1;
double magicdamage = 0;
double physDamage = Var.Me.MinimumDamage + Var.Me.BonusDamage;
if (quellingBlade != null && unit.Team != Var.Me.Team)
{
if (Var.Me.IsRanged)
{
physDamage = Var.Me.MinimumDamage * 1.15 + Var.Me.BonusDamage;
}
else
{
physDamage = Var.Me.MinimumDamage * 1.4 + Var.Me.BonusDamage;
}
}
double bonusdamage2 = 0;
switch (Var.Me.ClassID)
{
case ClassID.CDOTA_Unit_Hero_AntiMage:
if (unit.MaximumMana > 0 && unit.Mana > 0 && Var.Q.Level > 0 && unit.Team != Var.Me.Team)
{
bonusdamage2 = (Var.Q.Level - 1) * 12 + 28 * 0.6;
}
break;
case ClassID.CDOTA_Unit_Hero_Viper:
if (Var.W.Level > 0 && unit.Team != Var.Me.Team)
{
var nethertoxindmg = Var.W.Level * 2.5;
//var percent = Math.Floor((double) unit.Health / unit.MaximumHealth * 100);
//if (percent > 80 && percent <= 100)
// bonusdamage2 = nethertoxindmg * 0.5;
//else if (percent > 60 && percent <= 80)
// bonusdamage2 = nethertoxindmg * 1;
//else if (percent > 40 && percent <= 60)
// bonusdamage2 = nethertoxindmg * 2;
//else if (percent > 20 && percent <= 40)
// bonusdamage2 = nethertoxindmg * 4;
//else if (percent > 0 && percent <= 20)
// bonusdamage2 = nethertoxindmg * 8;
}
break;
case ClassID.CDOTA_Unit_Hero_Ursa:
var furymodif = 0;
if (Var.Me.Modifiers.Any(x => x.Name == "modifier_ursa_fury_swipes_damage_increase"))
{
furymodif =
unit.Modifiers.Find(x => x.Name == "modifier_ursa_fury_swipes_damage_increase").StackCount;
}
if (Var.E.Level > 0)
{
if (furymodif > 0)
{
bonusdamage2 = furymodif * ((Var.E.Level - 1) * 5 + 15);
}
else
{
bonusdamage2 = (Var.E.Level - 1) * 5 + 15;
}
}
break;
case ClassID.CDOTA_Unit_Hero_BountyHunter:
if (Var.W.Level > 0 && Var.W.AbilityState == AbilityState.Ready)
{
bonusdamage2 = physDamage * ((Var.W.Level - 1) * 0.25 + 0.50);
}
break;
case ClassID.CDOTA_Unit_Hero_Weaver:
if (Var.E.Level > 0 && Var.E.AbilityState == AbilityState.Ready)
{
bonusdamage2 = physDamage;
}
break;
case ClassID.CDOTA_Unit_Hero_Kunkka:
if (Var.W.Level > 0 && Var.W.AbilityState == AbilityState.Ready && Var.W.IsAutoCastEnabled)
{
bonusdamage2 = (Var.W.Level - 1) * 15 + 25;
}
break;
case ClassID.CDOTA_Unit_Hero_Juggernaut:
if (Var.E.Level > 0)
{
if (Var.Me.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage2 = physDamage;
}
}
break;
case ClassID.CDOTA_Unit_Hero_Brewmaster:
if (Var.E.Level > 0)
{
if (Var.Me.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage2 = physDamage;
}
}
break;
case ClassID.CDOTA_Unit_Hero_ChaosKnight:
if (Var.E.Level > 0)
{
if (Var.Me.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage2 = physDamage * ((Var.E.Level - 1) * 0.5 + 0.25);
}
}
break;
case ClassID.CDOTA_Unit_Hero_Clinkz:
if (Var.W.Level > 0 && Var.W.IsAutoCastEnabled && unit.Team != Var.Me.Team)
{
bonusdamage2 = (Var.W.Level - 1) * 10 + 30;
}
break;
case ClassID.CDOTA_Unit_Hero_SkeletonKing:
if (Var.E.Level > 0)
{
if (Var.Me.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage2 = physDamage * ((Var.E.Level - 1) * 0.5 + 0.5);
}
}
break;
case ClassID.CDOTA_Unit_Hero_Life_Stealer:
if (Var.W.Level > 0)
{
bonusdamage2 = unit.Health * ((Var.W.Level - 1) * 0.01 + 0.045);
}
break;
case ClassID.CDOTA_Unit_Hero_PhantomAssassin:
if (Var.R.Level > 0)
{
if (Var.Me.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage2 = physDamage * ((Var.R.Level - 1) * 1.1 + 1.3);
}
}
break;
}
if (Var.Me.Modifiers.Any(x => x.Name == "modifier_bloodseeker_bloodrage"))
{
modif = modif *
(ObjectManager.GetEntities <Hero>()
.First(x => x.ClassID == ClassID.CDOTA_Unit_Hero_Bloodseeker)
.Spellbook.Spell1.Level - 1) * 0.05 + 1.25;
}
if (Var.Me.Modifiers.Any(x => x.Name == "modifier_storm_spirit_overload"))
{
magicdamage = magicdamage + (Var.E.Level - 1) * 20 + 30;
}
if (Var.Me.Modifiers.Any(x => x.Name == "modifier_chilling_touch"))
{
magicdamage = magicdamage + (Var.E.Level - 1) * 20 + 50;
}
if (Var.Me.ClassID == ClassID.CDOTA_Unit_Hero_Pudge && Var.W.Level > 0 && MenuVar.UseSpell &&
Var.Me.Distance2D(unit) <= MyHeroInfo.AttackRange())
{
magicdamage = magicdamage + (Var.W.Level - 1) * 6 + 6;
}
bonusdamage = bonusdamage + bonusdamage2;
var damageMp = 1 - 0.06 * unit.Armor / (1 + 0.06 * Math.Abs(unit.Armor));
magicdamage = magicdamage * (1 - unit.MagicDamageResist);
var realDamage = ((bonusdamage + physDamage) * damageMp + magicdamage) * modif;
if (unit.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege ||
unit.ClassID == ClassID.CDOTA_BaseNPC_Tower)
{
realDamage = realDamage / 2;
}
if (realDamage > unit.MaximumHealth)
{
realDamage = unit.Health + 10;
}
return(realDamage);
}
private static double GetDamageOnUnit(Unit unit, Unit minion, double bonusdamage)
{
double modif = 1;
double magicdamage = 0;
double physDamage = unit.MinimumDamage + unit.BonusDamage;
if (unit.Handle == Var.Me.Handle)
{
var quellingBlade = unit.FindItem("item_quelling_blade");
if (quellingBlade != null && minion.Team != unit.Team)
{
if (unit.IsRanged)
{
physDamage = unit.MinimumDamage * 1.15 + unit.BonusDamage;
}
else
{
physDamage = unit.MinimumDamage * 1.4 + unit.BonusDamage;
}
}
switch (unit.ClassID)
{
case ClassID.CDOTA_Unit_Hero_AntiMage:
if (minion.MaximumMana > 0 && minion.Mana > 0 && Var.Q.Level > 0 && minion.Team != unit.Team)
{
bonusdamage += (Var.Q.Level - 1) * 12 + 28 * 0.6;
}
break;
case ClassID.CDOTA_Unit_Hero_Viper:
if (Var.W.Level > 0 && minion.Team != unit.Team)
{
var nethertoxindmg = Var.W.Level * 2.5;
//var percent = Math.Floor((double) unit.Health / unit.MaximumHealth * 100);
//if (percent > 80 && percent <= 100)
// bonusdamage2 = nethertoxindmg * 0.5;
//else if (percent > 60 && percent <= 80)
// bonusdamage2 = nethertoxindmg * 1;
//else if (percent > 40 && percent <= 60)
// bonusdamage2 = nethertoxindmg * 2;
//else if (percent > 20 && percent <= 40)
// bonusdamage2 = nethertoxindmg * 4;
//else if (percent > 0 && percent <= 20)
// bonusdamage2 = nethertoxindmg * 8;
}
break;
case ClassID.CDOTA_Unit_Hero_Ursa:
var furymodif = 0;
if (unit.Modifiers.Any(x => x.Name == "modifier_ursa_fury_swipes_damage_increase"))
{
furymodif =
minion.Modifiers.Find(x => x.Name == "modifier_ursa_fury_swipes_damage_increase")
.StackCount;
}
if (Var.E.Level > 0)
{
if (furymodif > 0)
{
bonusdamage += furymodif * ((Var.E.Level - 1) * 5 + 15);
}
else
{
bonusdamage += (Var.E.Level - 1) * 5 + 15;
}
}
break;
case ClassID.CDOTA_Unit_Hero_BountyHunter:
if (Var.W.Level > 0 && Var.W.AbilityState == AbilityState.Ready)
{
bonusdamage += physDamage * ((Var.W.Level - 1) * 0.25 + 0.50);
}
break;
case ClassID.CDOTA_Unit_Hero_Weaver:
if (Var.E.Level > 0 && Var.E.AbilityState == AbilityState.Ready)
{
bonusdamage += physDamage;
}
break;
case ClassID.CDOTA_Unit_Hero_Kunkka:
if (Var.W.Level > 0 && Var.W.AbilityState == AbilityState.Ready && Var.W.IsAutoCastEnabled)
{
bonusdamage += (Var.W.Level - 1) * 15 + 25;
}
break;
case ClassID.CDOTA_Unit_Hero_Juggernaut:
if (Var.E.Level > 0)
{
if (unit.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage += physDamage;
}
}
break;
case ClassID.CDOTA_Unit_Hero_Brewmaster:
if (Var.E.Level > 0)
{
if (unit.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage += physDamage;
}
}
break;
case ClassID.CDOTA_Unit_Hero_ChaosKnight:
if (Var.E.Level > 0)
{
if (unit.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage += physDamage * ((Var.E.Level - 1) * 0.5 + 0.25);
}
}
break;
case ClassID.CDOTA_Unit_Hero_SkeletonKing:
if (Var.E.Level > 0)
{
if (unit.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage += physDamage * ((Var.E.Level - 1) * 0.5 + 0.5);
}
}
break;
case ClassID.CDOTA_Unit_Hero_Life_Stealer:
if (Var.E.Level > 0)
{
bonusdamage += minion.Health * ((Var.E.Level - 1) * 0.01 + 0.045);
}
break;
case ClassID.CDOTA_Unit_Hero_PhantomAssassin:
if (Var.E.Level > 0)
{
if (unit.NetworkActivity == NetworkActivity.Crit)
{
bonusdamage += physDamage * ((Var.E.Level - 1) * 1.1 + 1.3);
}
}
break;
}
if (unit.Modifiers.Any(x => x.Name == "modifier_storm_spirit_overload"))
{
magicdamage += (Var.E.Level - 1) * 20 + 30;
}
if (unit.Modifiers.Any(x => x.Name == "modifier_chilling_touch"))
{
magicdamage += (Var.E.Level - 1) * 20 + 50;
}
if (unit.ClassID == ClassID.CDOTA_Unit_Hero_Pudge && Var.W.Level > 0 &&
MenuVar.UseSpell &&
unit.Distance2D(minion) <= MyHeroInfo.AttackRange())
{
magicdamage += (Var.W.Level - 1) * 6 + 6;
}
}
if (unit.Modifiers.Any(x => x.Name == "modifier_bloodseeker_bloodrage"))
{
modif = modif *
(ObjectManager.GetEntities <Hero>()
.First(x => x.ClassID == ClassID.CDOTA_Unit_Hero_Bloodseeker)
.Spellbook.Spell1.Level - 1) * 0.05 + 1.25;
}
if (Var.Summons != null && Var.Summons.Count > 1 && Var.Summons.Any(x => x.Key.IsAlive) &&
Var.Summons.Any(x => x.Key.Handle != unit.Handle) && Var.CreeptargetS != null)
{
if (Var.CreeptargetH == null ||
(Var.CreeptargetH.Handle != Var.CreeptargetS.Handle && Var.Me.Handle != unit.Handle))
{
bonusdamage =
Var.Summons.Where(
x =>
x.Key.Handle != unit.Handle && x.Key.CanAttack() &&
(Math.Abs(x.Key.Distance2D(minion) - x.Key.AttackRange) < 100 ||
Math.Abs(x.Key.Distance2D(minion) - unit.Distance2D(minion)) < 100))
.Aggregate(bonusdamage, (current, x) => current + x.Key.MinimumDamage + x.Key.BonusDamage);
}
else if (Var.CreeptargetH.Handle == Var.CreeptargetS.Handle && Var.Me.Handle != unit.Handle)
{
if (Var.Summons.Any(x => x.Key.Handle != unit.Handle))
{
bonusdamage +=
Var.Summons.Where(
x =>
x.Key.Handle != unit.Handle && x.Key.CanAttack() &&
x.Key.Distance2D(minion) < x.Key.AttackRange)
.Aggregate(bonusdamage,
(current, x) => current + x.Key.MinimumDamage + x.Key.BonusDamage);
}
if (Var.Me.Distance2D(minion) < Var.Me.AttackRange && Var.Me.CanAttack())
{
bonusdamage += Var.Me.MinimumDamage + Var.Me.BonusDamage;
}
}
else if (Var.Me.Handle == unit.Handle && Var.CreeptargetH.Handle == Var.CreeptargetS.Handle)
{
bonusdamage +=
Var.Summons.Where(x => x.Key.Distance2D(minion) < x.Key.AttackRange && x.Key.CanAttack())
.Aggregate(bonusdamage, (current, x) => current + x.Key.MinimumDamage + x.Key.BonusDamage);
}
}
var damageMp = 1 - 0.06 * minion.Armor / (1 + 0.06 * Math.Abs(minion.Armor));
magicdamage = magicdamage * (1 - minion.MagicDamageResist);
var realDamage = ((bonusdamage + physDamage) * damageMp + magicdamage) * modif;
if (minion.ClassID == ClassID.CDOTA_BaseNPC_Creep_Siege ||
minion.ClassID == ClassID.CDOTA_BaseNPC_Tower)
{
realDamage = realDamage / 2;
}
if (realDamage > minion.MaximumHealth)
{
realDamage = minion.Health + 10;
}
return(realDamage);
}
public static void UseSpell(float delay = 0)
{
var ability = MyHeroInfo.GetAbilities();
var listitems = MyHeroInfo.GetItems();
}
public static void Drawhpbar()
{
try
{
UpdateCreeps();
if (Var.Creeps.Count == 0)
{
return;
}
foreach (var creep in Var.Creeps)
{
if ((MenuVar.Sapport && Var.Me.Team != creep.Team) ||
(!MenuVar.Sapport && Var.Me.Team == creep.Team))
{
continue;
}
var health = creep.Health;
var maxHealth = creep.MaximumHealth;
if (health == maxHealth)
{
continue;
}
var damge = (float)GetDamageOnUnitForDrawhpbar(creep, 0);
var hpperc = health / maxHealth;
var hbarpos = HUDInfo.GetHPbarPosition(creep);
Vector2 screenPos;
var enemyPos = creep.Position + new Vector3(0, 0, creep.HealthBarOffset);
if (!Drawing.WorldToScreen(enemyPos, out screenPos))
{
continue;
}
var start = screenPos;
hbarpos.X = start.X - HUDInfo.GetHPBarSizeX(creep) / 2;
hbarpos.Y = start.Y;
var hpvarx = hbarpos.X;
var a = (float)Math.Floor(damge * HUDInfo.GetHPBarSizeX(creep) / creep.MaximumHealth);
var position = hbarpos + new Vector2(hpvarx * hpperc + 10, -12);
if (creep.ClassID == ClassID.CDOTA_BaseNPC_Tower)
{
hbarpos.Y = start.Y - HUDInfo.GetHpBarSizeY(creep) * 6;
position = hbarpos + new Vector2(hpvarx * hpperc - 5, -1);
}
else if (creep.ClassID == ClassID.CDOTA_BaseNPC_Barracks)
{
hbarpos.X = start.X - HUDInfo.GetHPBarSizeX(creep);
hbarpos.Y = start.Y - HUDInfo.GetHpBarSizeY(creep) * 6;
position = hbarpos + new Vector2(hpvarx * hpperc + 10, -1);
}
else if (creep.ClassID == ClassID.CDOTA_BaseNPC_Building)
{
hbarpos.X = start.X - HUDInfo.GetHPBarSizeX(creep) / 2;
hbarpos.Y = start.Y - HUDInfo.GetHpBarSizeY(creep);
position = hbarpos + new Vector2(hpvarx * hpperc + 10, -1);
}
Drawing.DrawRect(
position,
new Vector2(a, HUDInfo.GetHpBarSizeY(creep) - 4),
creep.Health > damge
? creep.Health > damge * 2 ? new Color(180, 205, 205, 40) : new Color(255, 0, 0, 60)
: new Color(127, 255, 0, 80));
Drawing.DrawRect(position, new Vector2(a, HUDInfo.GetHpBarSizeY(creep) - 4), Color.Black, true);
if (!MenuVar.Test)
{
continue;
}
var time = Var.Me.IsRanged == false
? Var.HeroAPoint / 1000 + Var.Me.GetTurnTime(Var.CreeptargetH.Position)
: Var.HeroAPoint / 1000 + Var.Me.GetTurnTime(creep.Position) +
Var.Me.Distance2D(creep) / MyHeroInfo.GetProjectileSpeed(Var.Me);
var damgeprediction = Healthpredict(creep, time);
var b = (float)Math.Round(damgeprediction * 1 * HUDInfo.GetHPBarSizeX(creep) / creep.MaximumHealth);
var position2 = position + new Vector2(a, 0);
Drawing.DrawRect(position2, new Vector2(b, HUDInfo.GetHpBarSizeY(creep) - 4), Color.YellowGreen);
Drawing.DrawRect(position2, new Vector2(b, HUDInfo.GetHpBarSizeY(creep) - 4), Color.Black, true);
}
}
catch (Exception)
{
if (MenuVar.ShowErrors)
{
Common.PrintError("Draw Hpbar Error");
}
}
}
private static void SpellCast()
{
try
{
foreach (var creep in Var.Creeps.Where(x => x.Team != Var.Me.Team)
.OrderByDescending(creep => creep.Health))
{
double damage = 0;
switch (Var.Me.ClassID)
{
case ClassID.CDOTA_Unit_Hero_Zuus:
if (Var.Q.Level > 0 && Var.Q.CanBeCasted() && Var.Me.Distance2D(creep) > MyHeroInfo.AttackRange())
{
damage = ((Var.Q.Level - 1) * 15 + 85) * (1 - creep.MagicDamageResist);
if (damage > creep.Health)
{
Var.Q.UseAbility(creep);
Utils.Sleep(Var.Q.GetCastPoint(Var.Q.Level) * 1000 + 50 + Game.Ping, "Lasthit.Cast");
Utils.Sleep(Var.Q.GetCooldown(Var.Q.Level) * 1000 + 50 + Game.Ping, "Lasthit.Cooldown");
}
}
break;
case ClassID.CDOTA_Unit_Hero_Bristleback:
if (Var.W.Level > 0 && Var.W.CanBeCasted() && Var.Me.Distance2D(creep) > MyHeroInfo.AttackRange())
{
double quillSprayDmg = 0;
if (creep.Modifiers.Any(
x =>
x.Name == "modifier_bristleback_quill_spray_stack" ||
x.Name == "modifier_bristleback_quill_spray"))
{
quillSprayDmg =
creep.Modifiers.Find(
x =>
x.Name == "modifier_bristleback_quill_spray_stack" ||
x.Name == "modifier_bristleback_quill_spray").StackCount * 30 +
(Var.W.Level - 1) * 2;
}
damage = ((Var.W.Level - 1) * 20 + 20 + quillSprayDmg) *
(1 - 0.06 * creep.Armor / (1 + 0.06 * creep.Armor));
if (damage > creep.Health && Var.W.CastRange > Var.Me.Distance2D(creep))
{
Var.W.UseAbility();
Utils.Sleep(Var.W.GetCastPoint(Var.W.Level) * 1000 + 50 + Game.Ping, "Lasthit.Cast");
Utils.Sleep(Var.W.GetCooldown(Var.W.Level) * 1000 + 50 + Game.Ping, "Lasthit.Cooldown");
}
}
break;
case ClassID.CDOTA_Unit_Hero_PhantomAssassin:
if (Var.Q.Level > 0 && Var.Q.CanBeCasted() && Var.Me.Distance2D(creep) > MyHeroInfo.AttackRange())
{
var time = 300 + Var.Me.Distance2D(creep) / Var.Q.GetProjectileSpeed();
if (time < creep.SecondsPerAttack * 1000)
{
damage = ((Var.Q.Level - 1) * 40 + 60) * (1 - 0.06 * creep.Armor / (1 + 0.06 * creep.Armor));
}
if (damage > creep.Health)
{
Var.Q.UseAbility(creep);
Utils.Sleep(Var.Q.GetCastPoint(Var.Q.Level) * 1000 + 50 + Game.Ping, "Lasthit.Cast");
Utils.Sleep(6 * 1000 + Game.Ping, "Lasthit.Cooldown");
}
}
break;
case ClassID.CDOTA_Unit_Hero_Pudge:
if (Var.W.Level > 0)
{
if (Var.CreeptargetH != null && creep.Handle == Var.CreeptargetH.Handle &&
Var.Me.Distance2D(creep) <= MyHeroInfo.AttackRange())
{
damage = GetDamageOnUnit(Var.Me, creep, 0);
if (damage > creep.Health && !Var.W.IsToggled && Var.Me.IsAttacking())
{
Var.W.ToggleAbility();
Utils.Sleep(200 + Game.Ping, "Lasthit.Cooldown");
}
}
if (Var.W.IsToggled)
{
Var.W.ToggleAbility();
Utils.Sleep((float)Var.HeroAPoint + Game.Ping, "Lasthit.Cooldown");
}
}
break;
}
}
}
catch (Exception)
{
//
}
}
/// <summary>
/// The try.
/// </summary>
/// <param name="enemyHero">
/// The enemy hero.
/// </param>
/// <param name="enemyHeroes">
/// The enemy heroes.
/// </param>
/// <param name="mineMissingHp">
/// The mine missing health.
/// </param>
/// <param name="ping">
/// The ping.
/// </param>
/// <param name="me">
/// The me.
/// </param>
/// <param name="mana">
/// The mana.
/// </param>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public bool Try(Hero enemyHero, Hero[] enemyHeroes, float mineMissingHp, float ping, Hero me, float mana)
{
var hero = enemyHero;
var heroName = NameManager.Name(hero);
var heroDistance = MyHeroInfo.Position.Distance2D(hero);
if (!Utils.SleepCheck("GlobalCasting") || !Utils.SleepCheck("casting"))
{
return(false);
}
Ability tuskSnowBall;
if (me.ClassId == ClassId.CDOTA_Unit_Hero_Tusk && Dictionaries.InDamageDictionary.ContainsKey(hero.Handle) &&
(Dictionaries.OutDamageDictionary[hero.Handle] + Dictionaries.InDamageDictionary[hero.Handle])
>= enemyHero.Health && Utils.SleepCheck("tusk_snowball") && heroDistance <= 1350 &&
me.FindSpell("tusk_snowball", out tuskSnowBall).CanBeCasted())
{
if (!Nuke.Cast(tuskSnowBall, hero, "tusk_snowball"))
{
return(false);
}
DelayAction.Add(
new DelayActionItem(300, () => { AbilityMain.LaunchSnowball(); }, CancellationToken.None));
Utils.Sleep(100 + (me.GetTurnTime(hero) * 1000) + ping, "tusk_snowball");
var delay = (me.GetTurnTime(hero) * 1000) + ((heroDistance / 675) * 1000);
Utils.Sleep(delay + 100, "GlobalCasting");
Utils.Sleep(delay + 100, "calculate");
Utils.Sleep(delay, "cancelorder");
return(true);
}
foreach (var data in
MyAbilities.OffensiveAbilities.Where(
x =>
x.Value.IsValid &&
(x.Value.CanBeCasted() || (x.Value.CanBeCasted(SoulRing.ManaGained) && SoulRing.Check(x.Value)) ||
x.Value.CanInvoke()) &&
((x.Value is Item && me.CanUseItems()) || (!(x.Value is Item) && me.CanCast())) &&
(Utils.SleepCheck(x.Value.Handle.ToString()) ||
(!x.Value.IsInAbilityPhase && x.Value.FindCastPoint() > 0)))
.OrderBy(x => ComboOrder.GetAbilityOrder(x.Value)))
{
var ability = data.Value;
var name = NameManager.Name(ability);
var category = data.Key.Substring(name.Length);
var handleString = ability.Handle.ToString();
if (category != "buff" && hero.IsMagicImmune() && ability.SpellPierceImmunityType != SpellPierceImmunityType.EnemiesYes)
{
continue;
}
if (!CastingChecks.All(name, hero))
{
continue;
}
var delay = (ability.GetCastDelay(me, hero, true, abilityName: name) * 1000) + 100;
var canHit = ability.CanHit(hero, MyHeroInfo.Position, name);
if (name == "omniknight_purification")
{
if (!MainMenu.Menu.Item("Ability#.EnableAutoKillSteal").GetValue <bool>())
{
continue;
}
if (!(Nukes.NukesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana) ||
!MainMenu.Menu.Item("nukesToggler").GetValue <AbilityToggler>().IsEnabled(name) ||
!Nukes.NukesMenuDictionary[name].Item(name + "herotoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) ||
(!(Variables.EtherealHitTime < (Utils.TickCount + (ability.GetHitDelay(hero, name) * 1000)))) ||
hero.Health
<= Nukes.NukesMenuDictionary[name].Item(NameManager.Name(ability) + "minhealthslider")
.GetValue <Slider>()
.Value || !CastingChecks.Killsteal(ability, hero, name))
{
return(false);
}
var target = FullCombo.FindPurificationTarget(hero);
if (target == null || !ability.CanHit(target, MyHeroInfo.Position, name) ||
!(target.PredictedPosition().Distance2D(hero.PredictedPosition()) < ability.GetRadius(name)) ||
!(target.PredictedPosition()
.Distance2D(hero.PredictedPosition(ability.FindCastPoint(NameManager.Name(ability))))
< ability.GetRadius(name)))
{
return(false);
}
if (!Nuke.Cast(ability, target, name))
{
return(false);
}
Utils.Sleep((ability.GetCastDelay(me, hero, abilityName: name) * 1000) + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (category == "nuke" && !MainMenu.Menu.Item("Ability#.EnableAutoKillSteal").GetValue <bool>())
{
continue;
}
if (name == "item_urn_of_shadows" && hero.HasModifier("modifier_item_urn_damage"))
{
continue;
}
if (category == "nuke" && Nukes.NukesMenuDictionary[name].Item(name + "ondisabletoggler") != null &&
Nukes.NukesMenuDictionary[name].Item(name + "ondisabletoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) &&
Nukes.NukesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("nukesToggler").GetValue <AbilityToggler>().IsEnabled(name) && canHit &&
(Variables.EtherealHitTime < (Utils.TickCount + (ability.GetHitDelay(hero, name) * 1000))) &&
hero.Health
> Nukes.NukesMenuDictionary[name].Item(NameManager.Name(ability) + "minhealthslider")
.GetValue <Slider>()
.Value)
{
var duration = Utils.DisableDuration(hero);
if (duration > 0 &&
duration
> ability.GetHitDelay(hero, name)
- ((ability.EndRadius() + hero.HullRadius) / hero.MovementSpeed) - (Game.Ping / 1000) &&
(!hero.IsInvul() || duration < ability.GetHitDelay(hero, name)) &&
Nuke.Cast(ability, hero, name, true))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + ((ability.ChannelTime(name) * 1000) / 3), "cancelorder");
Utils.Sleep(delay + ((ability.ChannelTime(name) * 1000) / 3), "casting");
}
Utils.Sleep(
(ability.GetCastDelay(me, hero, abilityName: name) * 1000) + ping + 100,
handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
}
if (category == "nuke" && Utils.SleepCheck(hero.Handle + "KillSteal") &&
Nukes.NukesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("nukesToggler").GetValue <AbilityToggler>().IsEnabled(name) &&
Nukes.NukesMenuDictionary[name].Item(name + "herotoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit &&
(Variables.EtherealHitTime < (Utils.TickCount + (ability.GetHitDelay(hero, name) * 1000))) &&
hero.Health
> Nukes.NukesMenuDictionary[name].Item(NameManager.Name(ability) + "minhealthslider")
.GetValue <Slider>()
.Value&& CastingChecks.Killsteal(ability, hero, name) &&
(name != "zuus_thundergods_wrath" ||
(1
+ enemyHeroes.Count(
x => !x.Equals(hero) && x.Health <= AbilityDamage.CalculateDamage(ability, me, x)))
>= Nukes.NukesMenuDictionary[name].Item(name + "minenemykill").GetValue <Slider>().Value))
{
if ((hero.Health - Variables.DealtDamage) <= 0 ||
(hero.Health - Variables.DealtDamage)
< Nukes.NukesMenuDictionary[name].Item(name + "minhealthslider").GetValue <Slider>().Value)
{
Variables.DealtDamage = 0;
return(false);
}
if (Nuke.Cast(ability, hero, name))
{
if (Utils.SleepCheck(handleString) &&
ability.GetCastDelay(AbilityMain.Me, hero, true) * 1000 - Game.Ping > 0.1)
{
DelayAction.Add(
new DelayActionItem(
(int)(ability.GetCastDelay(AbilityMain.Me, hero, true) * 1000 - Game.Ping - 50),
() =>
{
if (!CastingChecks.Killsteal(ability, hero, name) || !hero.IsAlive ||
hero.Health <= 0)
{
AbilityMain.Me.Stop();
}
},
CancellationToken.None));
Utils.Sleep(ability.GetHitDelay(hero, name) * 1000 + 500, hero.Handle + "KillSteal");
}
if (name == "riki_blink_strike")
{
Utils.Sleep(MyHeroInfo.AttackRate() * 1000 + ping + 100, handleString);
}
if (name == "item_ethereal_blade")
{
Variables.LastEtherealTarget = hero;
Variables.LastEtherealCastPosition = me.NetworkPosition;
Variables.LastEtherealCastTime =
(float)(Utils.TickCount + (me.GetTurnTime(hero) * 1000) + ping);
Utils.Sleep(
me.GetTurnTime(hero) * 1000 + 100 + (MyHeroInfo.Position.Distance2D(hero) / 1200) * 1000
+ ping,
"calculate");
}
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
// Utils.Sleep(ping, "killsteal");
return(true);
}
continue;
}
if (Dictionaries.HitDamageDictionary.ContainsKey(hero.Handle) &&
Dictionaries.HitDamageDictionary[hero.Handle] * 1.5 >= hero.Health &&
hero.Distance2D(MyHeroInfo.Position) <= me.GetAttackRange() + 150)
{
continue;
}
if (category == "disable" &&
Disables.DisablesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("disablesToggler").GetValue <AbilityToggler>().IsEnabled(name))
{
if (
Disables.DisablesMenuDictionary[name].Item(name + "onsighttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Disable.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Disables.DisablesMenuDictionary[name].Item(name + "onchainstuntoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.ChainStun(ability, hero, name) &&
Disable.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (CastingChecks.UnderTower(ability, hero) &&
Disables.DisablesMenuDictionary[name].Item(name + "undertowertoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Disable.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Disables.DisablesMenuDictionary[name].Item(name + "onchanneltoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && CastingChecks.Channel(hero) && canHit &&
Disable.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Disables.DisablesMenuDictionary[name].Item(name + "oncasttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Cast(hero, ability) &&
Disable.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
continue;
}
if (Dictionaries.InDamageDictionary.ContainsKey(hero.Handle) &&
Dictionaries.InDamageDictionary[hero.Handle] >= hero.Health &&
MainMenu.Menu.Item("Ability#.EnableAutoKillSteal").GetValue <bool>())
{
continue;
}
if (category == "slow" &&
Slows.SlowsMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("slowsToggler").GetValue <AbilityToggler>().IsEnabled(name))
{
if (
Slows.SlowsMenuDictionary[name].Item(name + "onsighttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Slow.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
if (name == "item_ethereal_blade")
{
Utils.Sleep(
me.GetTurnTime(hero) * 1000
+ Prediction.CalculateReachTime(hero, 1200, hero.Position - MyHeroInfo.Position),
"casting");
Utils.Sleep(
me.GetTurnTime(hero) * 1000 + 100 + (MyHeroInfo.Position.Distance2D(hero) / 1200) * 1000
+ ping,
"calculate");
}
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Slows.SlowsMenuDictionary[name].Item(name + "onchainstuntoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.ChainStun(ability, hero, name) &&
Slow.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
if (name == "item_ethereal_blade")
{
Utils.Sleep(
me.GetTurnTime(hero) * 1000
+ Prediction.CalculateReachTime(hero, 1200, hero.Position - MyHeroInfo.Position),
"casting");
Utils.Sleep(
me.GetTurnTime(hero) * 1000 + 100 + (MyHeroInfo.Position.Distance2D(hero) / 1200) * 1000
+ ping,
"calculate");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (CastingChecks.UnderTower(ability, hero) &&
Slows.SlowsMenuDictionary[name].Item(name + "undertowertoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Slow.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
if (name == "item_ethereal_blade")
{
Utils.Sleep(
me.GetTurnTime(hero) * 1000
+ Prediction.CalculateReachTime(hero, 1200, hero.Position - MyHeroInfo.Position),
"casting");
Utils.Sleep(
me.GetTurnTime(hero) * 1000 + 100 + (MyHeroInfo.Position.Distance2D(hero) / 1200) * 1000
+ ping,
"calculate");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
continue;
}
if (category == "special" &&
(name == "rubick_spell_steal" ||
Specials.SpecialsMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value
< mana) && MainMenu.Menu.Item("specialsToggler").GetValue <AbilityToggler>().IsEnabled(name))
{
if (name == "rubick_spell_steal")
{
var spell4 = me.Spellbook.Spell4;
if ((!spell4.CanBeCasted()) && Rubick.LastCasted(heroName) != null &&
NameManager.Name(spell4) != NameManager.Name(Rubick.LastCasted(heroName)) &&
Specials.SpecialsMenuDictionary[name].Item(heroName)
.GetValue <AbilityToggler>()
.IsEnabled(NameManager.Name(Rubick.LastCasted(heroName))) && canHit &&
Special.Cast(ability, hero, name))
{
Utils.Sleep(
ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100,
handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
continue;
}
if (
Specials.SpecialsMenuDictionary[name].Item(name + "onsighttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Special.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (Specials.SpecialsMenuDictionary[name].Item(name + "onpurgetoggler") != null &&
Specials.SpecialsMenuDictionary[name].Item(name + "onpurgetoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Purgable(hero) &&
Special.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (Specials.SpecialsMenuDictionary[name].Item(name + "oninvistoggler") != null &&
Specials.SpecialsMenuDictionary[name].Item(name + "oninvistoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Invisible(hero) &&
Special.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (Specials.SpecialsMenuDictionary[name].Item(name + "onattacktoggler") != null &&
Specials.SpecialsMenuDictionary[name].Item(name + "onattacktoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Attacking(hero, me) &&
Special.Cast(ability, hero, name))
{
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
continue;
}
if (category == "buff" &&
Buffs.BuffsMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("buffsToggler").GetValue <AbilityToggler>().IsEnabled(name))
{
if (name == "item_armlet")
{
if (ability.IsToggled &&
Buffs.BuffsMenuDictionary[name].Item(name + "belowhpslider").GetValue <Slider>().Value
< me.Health)
{
continue;
}
if (Buffs.BuffsMenuDictionary[name].Item(name + "alwaystoggle").GetValue <bool>() &&
Buffs.BuffsMenuDictionary[name].Item(name + "belowhpslider").GetValue <Slider>().Value
> me.Health && AbilityMain.Me.Distance2D(Base.Position()) > 1300 &&
Buff.Cast(ability, hero, me, name, true))
{
Utils.Sleep(
Buffs.BuffsMenuDictionary[name].Item(name + "armletdelay").GetValue <Slider>().Value,
handleString);
Utils.Sleep(ping + 200, "GlobalCasting");
Utils.Sleep(ping + 200, "casting");
return(true);
}
}
if (name == "item_satanic" &&
Buffs.BuffsMenuDictionary[name].Item(name + "missinghpslider").GetValue <Slider>().Value
> mineMissingHp &&
Buffs.BuffsMenuDictionary[name].Item(name + "belowhpslider").GetValue <Slider>().Value
< me.Health)
{
continue;
}
if (
Buffs.BuffsMenuDictionary[name].Item(name + "onsighttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Buff.Cast(ability, hero, me, name))
{
if (name == "item_armlet")
{
Utils.Sleep(
Buffs.BuffsMenuDictionary[name].Item(name + "armletdelay").GetValue <Slider>().Value,
handleString);
Utils.Sleep(ping + 200, "GlobalCasting");
Utils.Sleep(ping + 200, "casting");
}
else
{
Utils.Sleep(
ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100,
handleString);
}
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Buffs.BuffsMenuDictionary[name].Item(name + "onattacktoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Attacking(hero, me) &&
Buff.Cast(ability, hero, me, name))
{
if (name == "item_armlet")
{
Utils.Sleep(
Buffs.BuffsMenuDictionary[name].Item(name + "armletdelay").GetValue <Slider>().Value,
handleString);
Utils.Sleep(ping + 200, "GlobalCasting");
Utils.Sleep(ping + 200, "casting");
}
else
{
Utils.Sleep(
ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100,
handleString);
}
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
continue;
}
if (category == "silence" &&
Silences.SilencesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("silencesToggler").GetValue <AbilityToggler>().IsEnabled(name))
{
if (
Silences.SilencesMenuDictionary[name].Item(name + "onsighttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Silence.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Silences.SilencesMenuDictionary[name].Item(name + "oncasttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Cast(hero, ability) &&
Silence.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Silences.SilencesMenuDictionary[name].Item(name + "oninvistoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Invisible(hero) &&
Silence.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
continue;
}
if (category == "harras" &&
Harrases.HarrasesMenuDictionary[name].Item(name + "minManaCheck").GetValue <Slider>().Value < mana &&
MainMenu.Menu.Item("harrasesToggler").GetValue <AbilityToggler>().IsEnabled(name))
{
if (
Harrases.HarrasesMenuDictionary[name].Item(name + "onsighttoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && Harras.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
if (
Harrases.HarrasesMenuDictionary[name].Item(name + "onattacktoggler")
.GetValue <HeroToggler>()
.IsEnabled(heroName) && canHit && CastingChecks.Attacking(hero, me) &&
Harras.Cast(ability, hero, name))
{
if (ability.ChannelTime(name) > 0)
{
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "cancelorder");
Utils.Sleep(delay + (ability.ChannelTime(name) * 1000) / 3, "casting");
}
Utils.Sleep(ability.GetCastDelay(me, hero, abilityName: name) * 1000 + ping + 100, handleString);
Utils.Sleep(delay, "GlobalCasting");
Utils.Sleep(delay, "cancelorder");
return(true);
}
}
}
return(false);
}
public static bool Attacking(Hero target, Hero me)
{
return(me.IsAttacking() && me.Distance2D(target) <= MyHeroInfo.AttackRange() + 150 &&
me.GetTurnTime(target.Position) < 0.1);
}
public static void Game_OnUpdate(EventArgs args)
{
if (!OnUpdateChecks.CanUpdate())
{
return;
}
MyHeroInfo.UpdatePosition();
ManageAutoAttack.UpdateAutoAttack();
var enemyHeroes = EnemyHeroes.UsableHeroes;
var allyHeroes = AllyHeroes.UsableHeroes;
GankDamage.UpdateDamage(enemyHeroes, allyHeroes);
if (!Me.IsAlive ||
(Me.IsInvisible() && !Me.IsVisibleToEnemies && Me.ClassID != ClassID.CDOTA_Unit_Hero_Riki &&
(!Me.HasModifier("modifier_templar_assassin_meld") ||
!Orbwalking.CanCancelAnimation())) || Me.IsChanneling())
{
return;
}
if (Utils.SleepCheck("cancelorder"))
{
if (lastOrderPosition != Vector3.Zero && lastActivity == NetworkActivity.Move)
{
var ctarget = TargetSelector.ClosestToMouse(Me, 150);
if (ctarget != null && ctarget.IsValid)
{
Me.Attack(ctarget);
}
else
{
Me.Move(lastOrderPosition);
}
lastOrderPosition = Vector3.Zero;
}
}
else
{
lastActivity = Me.NetworkActivity;
lastOrderPosition = Game.MousePosition;
}
var ping = Game.Ping;
if (MyAbilities.DeffensiveAbilities.Any() && Utils.SleepCheck("casting"))
{
if (Utils.SleepCheck("Orbwalk.Attack") &&
allyHeroes.Any(allyHero => FullCombo.DeffensiveAutoUsage(allyHero, Me, enemyHeroes, ping)))
{
return;
}
}
var targetLock =
MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.TargetLock").GetValue <StringList>().SelectedIndex;
var keyDown = Game.IsKeyDown(MainMenu.ComboKeysMenu.Item("abilityKey1").GetValue <KeyBind>().Key);
if (!keyDown)
{
target = null;
}
if (!MyAbilities.OffensiveAbilities.Any())
{
if (Game.IsChatOpen)
{
return;
}
if (keyDown)
{
if (Utils.SleepCheck("UpdateTarget") &&
(target == null || !target.IsValid || !target.IsAlive || (!target.IsVisible && targetLock == 0)))
{
var mode =
MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.Target").GetValue <StringList>().SelectedIndex;
target = mode == 0
? TargetSelector.ClosestToMouse(Me, 2000)
: EnemyHeroes.UsableHeroes.Where(x => x.Distance2D(Me) < 2000)
.MaxOrDefault(x => x.GetDoableDamage());
Utils.Sleep(250, "UpdateTarget");
}
if (target != null && !target.IsValid)
{
target = null;
}
if (Utils.SleepCheck("GlobalCasting") &&
(Game.MousePosition.Distance2D(Me)
> MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.NoMoveRange").GetValue <Slider>().Value ||
(target != null &&
Me.Distance2D(target)
<= MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.NoMoveRange").GetValue <Slider>().Value)))
{
var mode =
MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.Mode").GetValue <StringList>().SelectedIndex;
switch (mode)
{
case 0:
Orbwalking.Orbwalk(target, attackmodifiers: true);
break;
case 1:
if (!Utils.SleepCheck("Ability.Move"))
{
return;
}
Me.Move(Game.MousePosition);
Utils.Sleep(100, "Ability.Move");
break;
case 2:
if (!Utils.SleepCheck("Ability.Move") || target == null)
{
return;
}
Me.Attack(target);
Utils.Sleep(100, "Ability.Move");
break;
case 3:
return;
}
}
}
}
var meMissingHp = Me.MaximumHealth - Me.Health;
var meMana = Me.Mana;
if (Utils.SleepCheck("Orbwalk.Attack") &&
enemyHeroes.Any(
enemyHero => FullCombo.AutoUsage(enemyHero, enemyHeroes, meMissingHp, ping, Me, meMana)))
{
return;
}
if (Utils.SleepCheck("casting"))
{
if (FullCombo.KillSteal(enemyHeroes, ping, Me))
{
return;
}
}
if (Game.IsChatOpen)
{
return;
}
if (keyDown)
{
if (Utils.SleepCheck("UpdateTarget") &&
(target == null || !target.IsValid || !target.IsAlive || (!target.IsVisible && targetLock == 0)))
{
var mode =
MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.Target").GetValue <StringList>().SelectedIndex;
target = mode == 0
? TargetSelector.ClosestToMouse(Me, 2000)
: EnemyHeroes.UsableHeroes.Where(x => x.Distance2D(Me) < 2000)
.MaxOrDefault(x => x.GetDoableDamage());
Utils.Sleep(250, "UpdateTarget");
}
var selectedCombo = MainMenu.ComboKeysMenu.Item("abilityComboType").GetValue <StringList>().SelectedIndex;
if (target != null && Utils.SleepCheck("Orbwalk.Attack"))
{
var combo = FullCombo.Execute(
target,
enemyHeroes,
ping,
selectedCombo == 2,
selectedCombo == 1,
Me,
meMana);
}
if (Me.ClassID == ClassID.CDOTA_Unit_Hero_TemplarAssassin && target != null && target.IsVisible)
{
var meld = Me.Spellbook.SpellW;
if (meld.ManaCost <= meMana && meld.Cooldown >= 0 && meld.Cooldown < UnitDatabase.GetAttackRate(Me) &&
target.Health > Dictionaries.HitDamageDictionary[target.Handle] * 2)
{
if (!Utils.SleepCheck("Ability.Move"))
{
return;
}
Me.Move(Game.MousePosition);
Utils.Sleep(100, "Ability.Move");
return;
}
}
if (Utils.SleepCheck("GlobalCasting") &&
(Game.MousePosition.Distance2D(Me)
> MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.NoMoveRange").GetValue <Slider>().Value ||
(target != null &&
Me.Distance2D(target)
<= MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.NoMoveRange").GetValue <Slider>().Value)))
{
var mode = MainMenu.ComboKeysMenu.Item("Ability.KeyCombo.Mode").GetValue <StringList>().SelectedIndex;
switch (mode)
{
case 0:
Orbwalking.Orbwalk(target, attackmodifiers: true);
break;
case 1:
if (!Utils.SleepCheck("Ability.Move"))
{
return;
}
Me.Move(Game.MousePosition);
Utils.Sleep(100, "Ability.Move");
break;
case 2:
if (!Utils.SleepCheck("Ability.Move") || target == null)
{
return;
}
Me.Attack(target);
Utils.Sleep(100, "Ability.Move");
break;
case 3:
return;
}
}
}
}
