private void ks()
{
foreach (var enemy in EntityManager.Heroes.Enemies.Where(target => target.HealthPercent > 0 && !target.IsInvulnerable && target.IsEnemy && !target.IsPhysicalImmune && !target.IsZombie))
{
if (enemy.IsInRange(Player.Instance, Q.Range) && Settings.ksQ && Settings.ksR && Q.IsReady() && R.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.Q) + DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.R) && R.GetPrediction(enemy).CollisionObjects.Count() > 0 && R.GetPrediction(enemy).CollisionObjects[0].NetworkId == enemy.NetworkId)
{
Q.Cast(Q.GetPrediction(enemy).CastPosition);
R.Cast(R.GetPrediction(enemy).CastPosition);
}
}
if (enemy.IsInRange(Player.Instance, Q.Range) && Settings.ksQ && Q.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.Q))
{
Q.Cast(Q.GetPrediction(enemy).CastPosition);
}
}
if (enemy.IsInRange(Player.Instance, R.Range) && Settings.ksR && R.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.R) && R.GetPrediction(enemy).CollisionObjects.Count() > 0 && R.GetPrediction(enemy).CollisionObjects[0].NetworkId == enemy.NetworkId)
{
R.Cast(R.GetPrediction(enemy).CastPosition);
}
}
}
}
/// <summary>
/// Returns the amount of active item calculated damage.
/// </summary>
/// <param name="sender"></param>
/// <param name="target"></param>
/// <returns></returns>
public static float GetActiveItemDamage(this AIHeroClient sender, Obj_AI_Base target)
{
float damage = 0;
List <ItemId> itemList = new List <ItemId>
{
ItemId.Bilgewater_Cutlass,
ItemId.Blade_of_the_Ruined_King,
ItemId.Hextech_Gunblade,
ItemId.Hextech_Protobelt_01,
ItemId.Redemption,
ItemId.Ravenous_Hydra,
ItemId.Titanic_Hydra,
ItemId.Tiamat
};
foreach (ItemId id in itemList)
{
InventorySlot item = sender.InventoryItems.FirstOrDefault(a => a.Id == id);
if (item != null && item.CanUseItem())
{
damage += DamageLibrary.GetItemDamage(sender, target, id);
}
}
return(damage);
}
private static void KillSteal()
{
if (Q.IsReady() && GetValue(KillStealM, "Killsteal Q"))
{
var Qtarget = TargetSelector.GetTarget(Q.Range, DamageType.Magical);
if (Qtarget.IsValidTarget(Q.Range))
{
var prediction = Q.GetPrediction(Qtarget);
if (Qtarget.Health < DamageLibrary.GetSpellDamage(Player, Qtarget, SpellSlot.Q) && prediction.HitChance >= HitChance.High)
{
var Speed = GetDynamicQSpeed(ObjectManager.Player.Distance(prediction.CastPosition));
if (Speed > 0f)
{
Q.Cast(prediction.CastPosition);
}
}
}
}
if (E.IsReady() && GetValue(KillStealM, "Killsteal E"))
{
var Etarget = TargetSelector.GetTarget(E.Range, DamageType.Magical);
if (Etarget.IsValidTarget(E.Range))
{
var prediction = E.GetPrediction(Etarget);
if (Etarget.Health < DamageLibrary.GetSpellDamage(Player, Etarget, SpellSlot.E) && prediction.HitChance >= HitChance.High)
{
E.Cast(prediction.CastPosition);
}
}
}
}
//---------------------------------GetComboDamage(Obj_AI_Hero Target)-----------------------------------
static float GetComboDamage(AIHeroClient Target)
{
if (Target != null)
{
float ComboDamage = new float();
ComboDamage = Q.IsReady() ? SpellDamage(Target, SpellSlot.Q) : 0;
ComboDamage = W.IsReady() ? Player.GetAutoAttackDamage(Target) : 0;
ComboDamage += E.IsReady() ? SpellDamage(Target, SpellSlot.E) * 3 : 0;
ComboDamage += Player.GetAutoAttackDamage(Target) * 2;
ComboDamage += Bilgewater.IsReady() ? DamageLibrary.GetItemDamage(Player, Target, ItemId.Bilgewater_Cutlass) : 0;
ComboDamage += BOTRK.IsReady() ? DamageLibrary.GetItemDamage(Player, Target, ItemId.Blade_of_the_Ruined_King) : 0;
ComboDamage += Hydra.IsReady() ? DamageLibrary.GetItemDamage(Player, Target, ItemId.Ravenous_Hydra_Melee_Only) : 0;
ComboDamage += Hextech.IsReady() ? DamageLibrary.GetItemDamage(Player, Target, ItemId.Hextech_Gunblade) : 0;
if (Ignite != null)
{
ComboDamage += Convert.ToSingle(Ignite.IsReady() ? DamageLibrary.GetSummonerSpellDamage(Player, Target, DamageLibrary.SummonerSpells.Ignite) : 0);
}
if (Smite != null)
{
ComboDamage += Convert.ToSingle(Smite.IsReady() && Smite.Name.Contains("gank") ? DamageLibrary.GetSummonerSpellDamage(Player, Target, DamageLibrary.SummonerSpells.Smite) : 0);
}
return(ComboDamage);
}
return(0);
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (args.SData == null)
{
return;
}
var targed = args.Target as Obj_AI_Base;
if (targed != null)
{
if (targed.Type == GameObjectType.AIHeroClient && targed.Team != sender.Team && sender.IsMelee)
{
IncomingDamageList.Add(new UnitIncomingDamage
{
Damage = DamageLibrary.GetSpellDamage((AIHeroClient)sender, (AIHeroClient)targed, Extensions.GetSpellSlotFromName((AIHeroClient)args.Target, args.SData.Name)),
TargetNetworkId = args.Target.NetworkId,
Time = Game.Time,
Skillshot = false
});
}
if (sender.Team != ObjectManager.Player.Team || !sender.IsValidTarget(3000) ||
!EloBuddy.SDK.Constants.AutoAttacks.IsAutoAttack(args.SData.Name) || !(args.Target is Obj_AI_Base))
{
return;
}
var target = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData = new PredictedDamage(
sender,
target,
GameTimeTickCount - Game.Ping / 2,
sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee ? int.MaxValue : (int)args.SData.MissileSpeed,
sender.GetAutoAttackDamage(target, true));
ActiveAttacks.Add(sender.NetworkId, attackData);
}
else
{
foreach (
var champion in
ChampionList.Where(
champion =>
!champion.IsDead && champion.IsVisible && champion.Team != sender.Team &&
champion.Distance(sender) < 2000))
{
if (CanHitSkillShot(champion, args))
{
IncomingDamageList.Add(new UnitIncomingDamage
{
Damage = DamageLibrary.GetSpellDamage((AIHeroClient)sender, (AIHeroClient)targed, Extensions.GetSpellSlotFromName((AIHeroClient)champion, args.SData.Name)),
TargetNetworkId = champion.NetworkId,
Time = Game.Time,
Skillshot = true
});
}
}
}
}
public SpellData(SpellSlot spellSlot, bool checkIfActive, DamageLibrary.SpellStages spellStage, Color c)
{
_onlyIfActive = checkIfActive;
_spellSlot = spellSlot;
_stage = spellStage;
Color = c;
}
public void ks(bool Q, bool W, bool E, bool Smite)
{
var target = TargetSelector.GetTarget(KindredSpells.privW.Range, DamageType.Physical);
if (target == null)
{
return;
}
if (Q && KindredSpells.privQ.IsReady())
{
if (KindredSpells.privQ.IsInRange(target) && DamageLibrary.GetSpellDamage(Player.Instance, target, SpellSlot.Q) >= target.Health)
{
KindredSpells.privQ.Cast(target);
}
}
if (W && KindredSpells.privW.IsReady())
{
if (KindredSpells.privW.IsInRange(target) && DamageLibrary.GetSpellDamage(Player.Instance, target, SpellSlot.W) >= target.Health)
{
KindredSpells.privW.Cast(target);
}
}
if (E && KindredSpells.privE.IsReady())
{
if (KindredSpells.privE.IsInRange(target) && DamageLibrary.GetSpellDamage(Player.Instance, target, SpellSlot.E) >= target.Health)
{
KindredSpells.privE.Cast(target);
}
}
if (Smite && KindredSpells.smite != null && KindredSpells.smite.IsReady() && DamageLibrary.GetSpellDamage(Player.Instance, target, KindredSpells.smite.Slot) >= target.Health)
{
KindredSpells.smite.Cast(target);
}
}
public static float DamageToHero(AIHeroClient unit)
{
float dmg = 0;
if (unit.IsEnemy && !unit.IsZombie && !unit.IsDead && unit.IsValid && !unit.IsInvulnerable)
{
if (ignite != null && ignite.IsReady())
{
dmg += DamageLibrary.GetSummonerSpellDamage(Player.Instance, unit, DamageLibrary.SummonerSpells.Ignite);
}
if (Q.IsReady())
{
dmg += DamageLibrary.GetSpellDamage(Player.Instance, unit, SpellSlot.Q) * 2;
}
if (E.IsReady() && (Q.IsReady() || R.IsReady()))
{
dmg += DamageLibrary.GetSpellDamage(Player.Instance, unit, SpellSlot.E);
}
if (E.IsReady())
{
dmg += DamageLibrary.GetSpellDamage(Player.Instance, unit, SpellSlot.E);
}
if (R.IsReady())
{
dmg += DamageLibrary.GetSpellDamage(Player.Instance, unit, SpellSlot.R);
}
}
return(dmg);
}
public static void ignite()
{
var autoIgnite = TargetSelector.GetTarget(NautibosActivator.ignite.Range, DamageType.True);
if (autoIgnite != null && autoIgnite.Health <= DamageLibrary.GetSpellDamage(Player.Instance, autoIgnite, NautibosActivator.ignite.Slot) || autoIgnite != null && autoIgnite.HealthPercent <= NautibosMenu.spellsHealignite())
{
NautibosActivator.ignite.Cast(autoIgnite);
}
}
public static void ignite()
{
var autoIgnite = TargetSelector.GetTarget(MyActivator.ignite.Range, DamageType.True);
if (autoIgnite != null && autoIgnite.Health <= DamageLibrary.GetSpellDamage(Player, autoIgnite, MyActivator.ignite.Slot) || autoIgnite != null && autoIgnite.HealthPercent <= ThreshMenu.spellsHealignite())
{
MyActivator.ignite.Cast(autoIgnite);
}
}
public void ignite()
{
var autoIgnite = TargetSelector.GetTarget(KindredSpells.ignite.Range, DamageType.True);
if (autoIgnite != null && autoIgnite.Health <= DamageLibrary.GetSpellDamage(Player.Instance, autoIgnite, KindredSpells.ignite.Slot) || autoIgnite != null && autoIgnite.HealthPercent <= KindredMenu.spellsHealignite())
{
KindredSpells.ignite.Cast(autoIgnite);
}
}
private static float GetComboDamage(AIHeroClient Enemy)
{
float Damage = 0;
if (Q.IsReady())
{
Damage += (Player.GetSpellDamage(Enemy, SpellSlot.Q) * 2);
}
if (W.IsReady())
{
Damage += (Player.GetSpellDamage(Enemy, SpellSlot.W));
}
if (E.IsReady())
{
Damage += (Player.GetSpellDamage(Enemy, SpellSlot.E));
}
if (R.IsReady())
{
Damage += (Player.GetSpellDamage(Enemy, SpellSlot.R) * GetRCount());
}
if (Ignite != null && Ignite.IsReady())
{
Damage += DamageLibrary.GetSummonerSpellDamage(Player, Enemy, DamageLibrary.SummonerSpells.Ignite);
}
if (Player.HasBuff("itemmagicshankcharge"))
{
if (Player.GetBuff("itemmagicshankcharge").Count == 100)
{
Damage += Player.CalculateDamageOnUnit(Enemy, DamageType.Magical, 100f + 0.1f * Player.FlatMagicDamageMod);
}
}
if (Sheen.IsReady() && Sheen.IsOwned())
{
Damage += Player.GetAutoAttackDamage(Enemy) + EloBuddy.Player.Instance.BaseAttackDamage * 2;
}
if (Lich_Bane.IsReady() && Lich_Bane.IsOwned())
{
Damage += Player.GetAutoAttackDamage(Enemy) * 0.75f;
Damage += Player.CalculateDamageOnUnit(Enemy, DamageType.Magical, Player.FlatMagicDamageMod * 0.5f);
}
Damage += Player.GetAutoAttackDamage(Enemy, true);
Damage -= Enemy.AllShield;
return(Damage);
}
private static void smite()
{
var unit = ObjectManager.Get <Obj_AI_Base>().Where(a => MyMobs.MinionNames.Contains(a.BaseSkinName) &&
DamageLibrary.GetSummonerSpellDamage(Player, a, DamageLibrary.SummonerSpells.Smite) >= a.Health &&
FapturneMenu.MyActivator[a.BaseSkinName].Cast <CheckBox>().CurrentValue &&
MyActivator.smite.IsInRange(a)).OrderByDescending(a => a.MaxHealth).FirstOrDefault();
if (unit != null && MyActivator.smite.IsReady())
{
MyActivator.smite.Cast(unit);
}
}
private static float damage(AIHeroClient t)
{
float dmg = 0;
if (E.IsReady())
{
dmg += DamageLibrary.GetSpellDamage(Player.Instance, t, SpellSlot.E);
}
dmg += DamageLibrary.GetSpellDamage(Player.Instance, t, SpellSlot.Q);
dmg += Player.Instance.GetAutoAttackDamage(t);
return(dmg);
}
private static void Drawing_OnDraw(EventArgs args)
{
if (!Program.DrawMenu["draw.Damage"].Cast <CheckBox>().CurrentValue)
{
return;
}
foreach (var aiHeroClient in EntityManager.Heroes.Enemies)
{
if (!aiHeroClient.IsHPBarRendered)
{
continue;
}
var pos = new Vector2(
aiHeroClient.HPBarPosition.X + XOffset,
aiHeroClient.HPBarPosition.Y + YOffset);
var fullbar = (BarLength) * (aiHeroClient.HealthPercent / 100);
var drawQ = Program.DrawMenu["draw.Q"].Cast <CheckBox>().CurrentValue;
var drawW = Program.DrawMenu["draw.W"].Cast <CheckBox>().CurrentValue;
var drawE = Program.DrawMenu["draw.E"].Cast <CheckBox>().CurrentValue;
var drawR = Program.DrawMenu["draw.R"].Cast <CheckBox>().CurrentValue;
var damage = (BarLength)
* ((DamageLibrary.CalculateDamage(aiHeroClient, drawQ, drawW, drawE, drawR)
/ aiHeroClient.MaxHealth) > 1
? 1
: (DamageLibrary.CalculateDamage(
aiHeroClient,
drawQ,
drawW,
drawE,
drawR) / aiHeroClient.MaxHealth));
Line.DrawLine(
Color.FromArgb(100, Color.Black),
9f,
new Vector2(pos.X, pos.Y),
new Vector2(pos.X + (damage > fullbar ? fullbar : damage), pos.Y));
Line.DrawLine(
Color.Black,
3,
new Vector2(pos.X + (damage > fullbar ? fullbar : damage), pos.Y),
new Vector2(pos.X + (damage > fullbar ? fullbar : damage), pos.Y));
}
}
private void ks()
{
foreach (var enemy in EntityManager.Heroes.Enemies.Where(target => target.HealthPercent > 0 && !target.IsInvulnerable && target.IsEnemy && !target.IsPhysicalImmune && !target.IsZombie))
{
if (enemy.IsInRange(Player.Instance, E.Range) && Config.ESettings.ksE && E.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.E))
{
E.Cast(enemy);
}
}
}
}
private void ks()
{
foreach (var enemy in EntityManager.Heroes.Enemies.Where(target => target.HealthPercent > 0 && !target.IsInvulnerable && target.IsEnemy && !target.IsPhysicalImmune && !target.IsZombie))
{
if (enemy.IsInRange(Player.Instance, Q.Range) && Settings.ksQ && Q.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.Q))
{
Q.Cast(enemy);
return;
}
}
else if (enemy.IsInRange(Player.Instance, Q1.Range) && Settings.ksQ && Q.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.Q))
{
SpellManager.castQ1(enemy);
}
}
else if (enemy.IsInRange(Player.Instance, Q1.Range + E.Range) && Settings.ksQ && Settings.ksE && E.IsReady() && Q.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.Q))
{
SpellManager.dashToQ1(enemy);
}
}
else if (enemy.IsInRange(Player.Instance, W.Range) && Settings.ksW && W.IsReady())
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.W))
{
if (W.GetPrediction(enemy).GetCollisionObjects <Obj_AI_Base>()[0].NetworkId == enemy.NetworkId)
{
W.Cast(W.GetPrediction(enemy).CastPosition);
}
}
}
else if (enemy.IsInRange(Player.Instance, R.Range) && Settings.ksR && R.IsReady() && Game.Time - Program.RCast > 3)
{
if (enemy.Health < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.R) * 0.3 && R.GetPrediction(enemy).CollisionObjects.Count() > 0)
{
Program.RCastToPosition = SpellManager.R.GetPrediction((AIHeroClient)enemy).CastPosition;
SpellManager.R.Cast(Program.RCastToPosition);
Program.RTarget = enemy;
}
}
}
}
/// <summary>
/// Initalizes the library.
/// </summary>
public static void Load()
{
if (alreadyLoaded)
{
return;
}
SetupLogging();
LogUnhandledExceptions();
DamageLibrary.LoadDamages();
GlobalKeys.Load();
TargetSelector.TargetSelector.Load();
AimtecMenu.Instance.Attach();
Logger.Info($"Aimtec.SDK version {Assembly.GetExecutingAssembly().GetName().Version} loaded.");
alreadyLoaded = true;
}
//-------------------------------------------GetComboDamage()----------------------------------------------
static float GetComboDamage()
{
if (Target != null)
{
float ComboDamage = new float();
ComboDamage = Q.IsReady() ? SpellDamage(Target, SpellSlot.Q) : 0;
ComboDamage += W.IsReady() ? SpellDamage(Target, SpellSlot.W) : 0;
ComboDamage += R.IsReady() ? SpellDamage(Target, SpellSlot.R) : 0;
ComboDamage += Player.GetAutoAttackDamage(Target) * 2;
if (Ignite != null)
{
ComboDamage += Convert.ToSingle(Ignite.IsReady() ? DamageLibrary.GetSummonerSpellDamage(Player, Target, DamageLibrary.SummonerSpells.Ignite) : 0);
}
return(ComboDamage);
}
return(0);
}
private bool castBOTRK()
{
if (Player.Instance.IsDead || !Player.Instance.CanCast || Player.Instance.IsInvulnerable || !Player.Instance.IsTargetable || Player.Instance.IsZombie || Player.Instance.IsInShopRange())
{
return(false);
}
InventorySlot[] inv = Player.Instance.InventoryItems;
foreach (var item in inv)
{
if ((item.Id == ItemId.Blade_of_the_Ruined_King) && item.CanUseItem())
{
var target = TargetSelector.GetTarget(550, DamageType.Physical);
if (target != null && Player.Instance.Health <= DamageLibrary.GetItemDamage(Player.Instance, target, ItemId.Blade_of_the_Ruined_King))
{
return(item.Cast(target));
}
}
}
return(false);
}
static void Obj_AI_Base_OnDoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (args.Target != null && args.SData != null)
{
if (args.Target.Type == GameObjectType.obj_AI_Base && !sender.IsMelee &&
args.Target.Team != sender.Team)
{
IncomingDamageList.Add(new UnitIncomingDamage
{
Damage = DamageLibrary.GetSpellDamage((AIHeroClient)sender, (AIHeroClient)args.Target, Extensions.GetSpellSlotFromName((AIHeroClient)args.Target, args.SData.Name)),
TargetNetworkId = args.Target.NetworkId,
Time = Game.Time,
Skillshot = false
});
}
}
if (ActiveAttacks.ContainsKey(sender.NetworkId) && sender.IsMelee)
{
ActiveAttacks[sender.NetworkId].Processed = true;
}
}
private void ks()
{
foreach (var enemy in EntityManager.Heroes.Enemies.Where(target => target.IsVisible && target.HealthPercent > 0 && !target.IsInvulnerable && target.IsEnemy && !target.IsPhysicalImmune && !target.IsZombie))
{
if (enemy.IsInRange(Player.Instance, W.Range) && Settings.ksW && W.IsReady())
{
if (Prediction.Health.GetPrediction(enemy, W.CastDelay) < DamageLibrary.GetSpellDamage(Player.Instance, enemy, SpellSlot.W))
{
W.Cast(W.GetPrediction(enemy).CastPosition);
return;
}
}
if (enemy.IsInRange(Player.Instance, R.Range) && Settings.ksR && R.IsReady())
{
Console.WriteLine("dmg" + SpellManager.getRDamage(enemy));
if (enemy.Health < SpellManager.getRDamage(enemy) && Settings.ksR && R.IsReady() && SpellManager.RoverkillCheck(enemy))
{
R.Cast(R.GetPrediction(enemy).CastPosition);
}
}
}
}
void Killsteal()
{
var ksQ = _miscMenu["ksQ"].Cast <CheckBox>().CurrentValue;
var ksIgnite = _miscMenu["ksIgnite"].Cast <CheckBox>().CurrentValue;
foreach (
var enemy in
EntityManager.Heroes.Enemies.Where(
e => e.Distance(_Player) <= SpellManager.Q.Range && e.IsValidTarget() && !e.IsInvulnerable))
{
if (ksQ && SpellManager.Q.IsReady() &&
Qdamage(enemy) >= enemy.Health &&
enemy.Distance(_Player) <= SpellManager.Q.Range)
{
SpellManager.Q.Cast(enemy);
Chat.Print("<font color=\"#fffffff\" > Use Q Free Kill</font>");
}
if (ksIgnite)
{
var enemyignite =
EntityManager.Heroes.Enemies.Where(
t =>
t.IsEnemy && !t.IsZombie && !t.IsDead && t.IsValid && !t.IsInvulnerable &&
t.IsInRange(Player.Instance.Position, SpellManager.Ignite.Range) &&
DamageLibrary.GetSummonerSpellDamage(Player.Instance, t,
DamageLibrary.SummonerSpells.Ignite) > t.Health).FirstOrDefault();
if (enemyignite != null)
{
if (SpellManager.Ignite.IsReady())
{
SpellManager.Ignite.Cast(enemyignite);
}
}
}
}
}
//---------------------------------------------Game_OnTick------------------------------------------------
static void Game_OnTick(EventArgs args)
{
if (Player.IsDead)
{
return;
}
if (Player.CountEnemiesInRange(1000) > 0)
{
Modes.SaveAlly();
}
if (Zhonya.IsReady() && Menu["UseZhonya?"].Cast <CheckBox>().CurrentValue&& Player.HealthPercent <= Menu["ZhonyaHealth"].Cast <Slider>().CurrentValue&& EntityManager.Heroes.Enemies.Any(it => it.Distance(Player) <= it.GetAutoAttackRange() && it.IsValidTarget()))
{
if (!Menu["ZhonyaUlt"].Cast <CheckBox>().CurrentValue)
{
Zhonya.Cast();
}
else if (!R.IsReady())
{
Zhonya.Cast();
}
}
if (EntityManager.Heroes.Enemies.Any(it => it.IsValidTarget() && !CanMove(it)))
{
Modes.Immobile();
}
Target = TargetSelector.GetTarget(1100, DamageType.Magical);
//-----------------------------------------------KS----------------------------------------
if (Menu["KS"].Cast <CheckBox>().CurrentValue&& EntityManager.Heroes.Enemies.Any(it => Q.IsInRange(it)))
{
Modes.KS();
}
//-----------------------------------------------Auto Ignite----------------------------------------
if (Menu["Auto Ignite"].Cast <CheckBox>().CurrentValue&& Ignite != null)
{
if (Ignite.IsReady())
{
var IgniteEnemy = EntityManager.Heroes.Enemies.FirstOrDefault(it => DamageLibrary.GetSummonerSpellDamage(Player, it, DamageLibrary.SummonerSpells.Ignite) >= it.Health - 30);
if (IgniteEnemy != null)
{
if ((IgniteEnemy.Distance(Player) >= 300 || Player.HealthPercent <= 40))
{
Ignite.Cast(IgniteEnemy);
}
}
}
}
//--------------------------------------------Orbwalker Modes-------------------------------------------
if (Target != null)
{
if (Target.IsValidTarget())
{
Modes.UpdateVariables();
//---------------------------------------------------Combo--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Modes.Combo();
}
//---------------------------------------------------Mixed--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) && Player.ManaPercent >= Menu["Harass, Mana %"].Cast <Slider>().CurrentValue)
{
Modes.Harass();
}
}
else
{
Target = null;
}
}
//---------------------------------------------------LaneClear--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) && W.IsReady() && Menu["UseWLaneClear"].Cast <CheckBox>().CurrentValue&& Player.ManaPercent >= Menu["LaneClear, Mana %"].Cast <Slider>().CurrentValue)
{
Modes.LaneClear();
}
return;
}
public static void UseItems(List <Obj_AI_Base> enemies, bool ks)
{
#region Item Initialization
InventorySlot QSS = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Quick Silver Sash")) ? Vi.GetItem(ItemId.Quicksilver_Sash) : null,
MercurialsScimitar = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Mercurials Scimitar")) ? Vi.GetItem(ItemId.Mercurial_Scimitar) : null,
RavenousHydra = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Ravenous Hydra")) ? Vi.GetItem(ItemId.Ravenous_Hydra) : null,
TitanicHydra = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Titanic Hydra")) ? Vi.GetItem(ItemId.Titanic_Hydra) : null,
Tiamat = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Tiamat")) ? Vi.GetItem(ItemId.Tiamat) : null,
Youmuus = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Youmuus")) ? Vi.GetItem(ItemId.Youmuus_Ghostblade) : null,
BOTRK = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Blade of the Ruined King")) ? Vi.GetItem(ItemId.Blade_of_the_Ruined_King) : null,
BilgewaterCutlass = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Bilgewater Cutlass")) ? Vi.GetItem(ItemId.Bilgewater_Cutlass) : null,
HextechGunblade = (MenuHandler.GetCheckboxValue(MenuHandler.Items, "Use Hextech Gunblade")) ? Vi.GetItem(ItemId.Hextech_Gunblade) : null;
#endregion
#region QSS
if (!hasDoneActionThisTick &&
QSS.MeetsCriteria() &&
Vi.CanCancleCC())
{
hasDoneActionThisTick = QSS.Cast();
}
#endregion
#region Mercurials Scimitar
if (!hasDoneActionThisTick &&
MercurialsScimitar.MeetsCriteria() &&
Vi.CanCancleCC())
{
hasDoneActionThisTick = MercurialsScimitar.Cast();
}
#endregion
#region Ravenous Hydra
if (!hasDoneActionThisTick &&
RavenousHydra.MeetsCriteria() &&
Vi.IsAutoCanceling(enemies) &&
enemies.Where(a => a.IsInRange(Vi, 400)).FirstOrDefault() != null &&
(!ks || enemies.Where(a => a.MeetsCriteria() && a.Health <= DamageLibrary.GetItemDamage(Vi, a, ItemId.Ravenous_Hydra)).FirstOrDefault() != null))
{
hasDoneActionThisTick = RavenousHydra.Cast();
}
#endregion
#region Titanic Hydra
if (!hasDoneActionThisTick &&
TitanicHydra.MeetsCriteria() &&
enemies.Where(a => a.IsInRange(Vi, Vi.GetAutoAttackRange())).FirstOrDefault() != null &&
Vi.IsAutoCanceling(enemies) &&
(!ks || enemies.Where(a => a.MeetsCriteria() && a.Health <= DamageLibrary.GetItemDamage(Vi, a, ItemId.Titanic_Hydra)).FirstOrDefault() != null))
{
hasDoneActionThisTick = TitanicHydra.Cast();
}
#endregion
#region Tiamat
if (!hasDoneActionThisTick &&
Tiamat.MeetsCriteria() &&
Vi.IsAutoCanceling(enemies) &&
enemies.Where(a => a.IsInRange(Vi, 400)).FirstOrDefault() != null &&
(!ks || enemies.Where(a => a.MeetsCriteria() && a.Health <= DamageLibrary.GetItemDamage(Vi, a, ItemId.Tiamat)).FirstOrDefault() != null))
{
hasDoneActionThisTick = Tiamat.Cast();
}
#endregion
#region Youmuus
if (!hasDoneActionThisTick &&
Youmuus.MeetsCriteria() &&
Vi.CountEnemyHeroesInRangeWithPrediction((int)Vi.GetAutoAttackRange(), 0) >= 1)
{
hasDoneActionThisTick = Youmuus.Cast();
}
#endregion
//all targeted spells that must be used on champions must be called after this
enemies = enemies.Where(a => a.Type == GameObjectType.AIHeroClient).ToList();
var target = enemies.OrderBy(a => a.Health).FirstOrDefault();
#region Hextech Gunblade
if (!hasDoneActionThisTick &&
target != null &&
HextechGunblade.MeetsCriteria() &&
enemies.Where(a => a.IsInRange(Vi, 700)).FirstOrDefault() != null &&
(!ks || enemies.Where(a => a.MeetsCriteria() && a.Health <= DamageLibrary.GetItemDamage(Vi, a, ItemId.Hextech_Gunblade)).FirstOrDefault() != null))
{
hasDoneActionThisTick = HextechGunblade.Cast(target);
}
#endregion
#region BOTRK
if (!hasDoneActionThisTick &&
target != null &&
BOTRK.MeetsCriteria() &&
enemies.Where(a => a.IsInRange(Vi, 550)).FirstOrDefault() != null &&
(!ks || enemies.Where(a => a.MeetsCriteria() && a.Health <= DamageLibrary.GetItemDamage(Vi, a, ItemId.Blade_of_the_Ruined_King)).FirstOrDefault() != null))
{
hasDoneActionThisTick = BOTRK.Cast(target);
}
#endregion
#region Bilgewater Cutlass
if (!hasDoneActionThisTick &&
target != null &&
BilgewaterCutlass.MeetsCriteria() &&
enemies.Where(a => a.IsInRange(Vi, 550)).FirstOrDefault() != null &&
(!ks || enemies.Where(a => a.MeetsCriteria() && a.Health <= DamageLibrary.GetItemDamage(Vi, a, ItemId.Bilgewater_Cutlass)).FirstOrDefault() != null))
{
hasDoneActionThisTick = BilgewaterCutlass.Cast(target);
}
#endregion
}
private void ksWithW()
{
if (Settings.ksW && W.IsReady())
{
foreach (var e in EntityManager.Heroes.Enemies.Where(e => e.IsInRange(Player.Instance, W.Range) && e.Health > 0 && !e.IsInvulnerable && e.IsTargetable && !e.IsZombie && e.Health < DamageLibrary.GetSpellDamage(Player.Instance, e, SpellSlot.W)))
{
if (W.GetPrediction(e).HitChance >= HitChance.Medium)
{
W.Cast(W.GetPrediction(e).CastPosition);
return;
}
}
}
}
public static float GetDamage(Obj_AI_Base random, DamageLibrary.SummonerSpells offensivesum)
{
return Player.Instance.GetSummonerSpellDamage(random, offensivesum);
}
public override void Execute()
{
if (Config.Drawings.ShowKillable)
{
DamageIndicator.DamageToUnit = GetComboDamage;
}
if (Player.Instance.GetSpellSlotFromName("summonerdot") == SpellSlot.Summoner1 ||
Player.Instance.GetSpellSlotFromName("summonerdot") == SpellSlot.Summoner2)
{
if (ObjectManager.Player.IsDead || !IG.IsReady() || !Settings.UseIgnite)
{
return;
}
if (ObjectManager.Get <AIHeroClient>().Where(
h =>
h.IsValidTarget(IG.Range) &&
h.Health <
ObjectManager.Player.GetSummonerSpellDamage(h, DamageLibrary.SummonerSpells.Ignite)).Count() <=
0)
{
return;
}
var target = ObjectManager.Get <AIHeroClient>()
.Where(
h =>
h.IsValidTarget(IG.Range) &&
h.Health <
ObjectManager.Player.GetSummonerSpellDamage(h, DamageLibrary.SummonerSpells.Ignite));
if (Config.Modes.Perma.igniteMode.Equals("0"))
{
IG.Cast(target.First());
}
else
{
if (target.First().Distance(Player.Instance) > 450 || (Player.Instance.HealthPercent < 25))
{
IG.Cast(target.First());
}
}
}
if (Settings.UseW)
{
var target = TargetSelector.GetTarget(W.Range, DamageType.Magical);
if (target != null && target.IsEnemy && target.Distance(Player.Instance.Position) > Player.Instance.AttackRange && (DamageLibrary.GetSpellDamage(Player.Instance, target, SpellSlot.W)) > target.Health)
{
W.Cast(target.Position);
}
}
}
public static float ComboDamage(this AIHeroClient enemy)
{
float qdmg = Program.Q.IsReady() ? Calculations.Q(enemy) : 0;
float edmg = Program.E.IsReady() ? Calculations.E(enemy) : 0;
float rdmg = Program.R.IsReady() ? Calculations.R(enemy) : 0;
float autoDmg = Player.Instance.GetAutoAttackDamage(enemy) * MenuHandler.Drawing.GetSliderValue("Autos in Combo");
float tiamat = Player.Instance.GetItem(ItemId.Tiamat) != null && Player.Instance.GetItem(ItemId.Tiamat).CanUseItem() ? DamageLibrary.GetItemDamage(Player.Instance, enemy, ItemId.Tiamat) : 0;
float thydra = Player.Instance.GetItem(ItemId.Titanic_Hydra) != null && Player.Instance.GetItem(ItemId.Titanic_Hydra).CanUseItem() ? DamageLibrary.GetItemDamage(Player.Instance, enemy, ItemId.Titanic_Hydra) : 0;
float rhydra = Player.Instance.GetItem(ItemId.Ravenous_Hydra) != null && Player.Instance.GetItem(ItemId.Ravenous_Hydra).CanUseItem() ? DamageLibrary.GetItemDamage(Player.Instance, enemy, ItemId.Ravenous_Hydra) : 0;
float comboDamage = qdmg + edmg + rdmg + autoDmg + tiamat + thydra + rhydra;
return(comboDamage);
}
//-------------------------------------------------KS--------------------------------------------------
public static void KS()
{
if (Q.IsReady())
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(Q.Range) && SpellDamage(enemy, SpellSlot.Q) >= enemy.Health);
if (bye != null)
{
Q.Cast(bye); return;
}
}
if (Smite != null)
{
if (Smite.Name.Contains("gank") && Smite.IsReady())
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(Smite.Range) && DamageLibrary.GetSummonerSpellDamage(Player, enemy, DamageLibrary.SummonerSpells.Smite) >= enemy.Health);
if (bye != null)
{
Smite.Cast(bye); return;
}
}
}
}
//-------------------------------------------Game_OnTick----------------------------------------------
static void Game_OnTick(EventArgs args)
{
if (Player.IsDead)
{
return;
}
Target = TargetSelector.GetTarget(900, DamageType.Physical);
//---------------------------------------------Smite Usage---------------------------------------------
if (Smite != null)
{
if (Smite.IsReady() && Menu["Use Smite?"].Cast <CheckBox>().CurrentValue)
{
Obj_AI_Minion Mob = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Position, Smite.Range).FirstOrDefault();
if (Mob != default(Obj_AI_Minion))
{
bool kill = GetSmiteDamage() >= Mob.Health;
if (kill)
{
if ((Mob.Name.Contains("SRU_Dragon") || Mob.Name.Contains("SRU_Baron")))
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Red") && Menu["Red?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Blue") && Menu["Blue?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Murkwolf") && Menu["Wolf?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Krug") && Menu["Krug?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Gromp") && Menu["Gromp?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Razorbeak") && Menu["Raptor?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
}
}
}
}
//------------------------------------------------KS------------------------------------------------
if (Menu["KS"].Cast <CheckBox>().CurrentValue&& EntityManager.Heroes.Enemies.Any(it => Q.IsInRange(it)))
{
Modes.KS();
}
//-----------------------------------------------Auto Ignite----------------------------------------
if (Menu["Auto Ignite"].Cast <CheckBox>().CurrentValue&& Ignite != null)
{
if (Ignite.IsReady())
{
var IgniteEnemy = EntityManager.Heroes.Enemies.FirstOrDefault(it => DamageLibrary.GetSummonerSpellDamage(Player, it, DamageLibrary.SummonerSpells.Ignite) >= it.Health - 30);
if (IgniteEnemy != null)
{
if ((IgniteEnemy.Distance(Player) >= 300 || Player.HealthPercent <= 40))
{
Ignite.Cast(IgniteEnemy);
}
}
}
}
//--------------------------------------------Orbwalker Modes-------------------------------------------
if (Target != null)
{
if (Target.IsValidTarget())
{
Modes.UpdateVariables();
//---------------------------------------------------Combo--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Modes.Combo();
}
//---------------------------------------------------Mixed--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) && Player.ManaPercent >= Menu["Harass, Mana %"].Cast <Slider>().CurrentValue)
{
Modes.Harass();
}
}
else
{
Target = null;
}
}
//-----------------------------------------------LaneClear---------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) && Q.IsReady() && Player.ManaPercent >= Menu["LaneClear, Mana %"].Cast <Slider>().CurrentValue)
{
Modes.LaneClear();
}
return;
}
//-------------------------------------------------KS--------------------------------------------------
public static void KS()
{
if (Q.IsReady())
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(Q.Range) && SpellDamage(enemy, SpellSlot.Q) >= enemy.Health);
if (bye != null)
{
Q.Cast(bye); return;
}
}
if (Q.IsReady() && W.IsReady())
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(Q.Range) && (SpellDamage(enemy, SpellSlot.Q) + SpellDamage(enemy, SpellSlot.W)) >= enemy.Health);
if (bye != null)
{
W.Cast(); Core.DelayAction(() => Q.Cast(bye), Game.Ping + 100); return;
}
}
if (E.IsReady() && Player.HasBuff("JaxCounterStrike"))
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(E.Range) && SpellDamage(enemy, SpellSlot.E) >= enemy.Health);
if (bye != null)
{
E.Cast(); return;
}
}
if (W.IsReady())
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(Player.GetAutoAttackRange()) && SpellDamage(enemy, SpellSlot.W) >= enemy.Health);
if (bye != null)
{
W.Cast(); EloBuddy.Player.IssueOrder(GameObjectOrder.AttackTo, bye); return;
}
}
if (Smite != null)
{
if (Smite.Name.Contains("gank") && Smite.IsReady())
{
var bye = EntityManager.Heroes.Enemies.FirstOrDefault(enemy => enemy.IsValidTarget(Smite.Range) && DamageLibrary.GetSummonerSpellDamage(Player, enemy, DamageLibrary.SummonerSpells.Smite) >= enemy.Health);
if (bye != null)
{
Smite.Cast(bye); return;
}
}
}
}
