private static void CheckDamage(Obj_AI_Base target)
{
if (target == null)
{
return;
}
var qready = Me.Spellbook.CanUseSpell(SpellSlot.Q) == SpellState.Ready;
var wready = Me.Spellbook.CanUseSpell(SpellSlot.W) == SpellState.Ready;
var rready = Me.Spellbook.CanUseSpell(SpellSlot.R) == SpellState.Ready;
var iready = Me.Spellbook.CanUseSpell(Me.GetSpellSlot("summonerdot")) == SpellState.Ready;
_ma = (float)Me.GetAutoAttackDamage(target);
_mq = (float)(qready ? Me.GetSpellDamage(target, SpellSlot.Q) : 0);
_mw = (float)(wready ? Me.GetSpellDamage(target, SpellSlot.W) : 0);
_mr = (float)(rready ? Me.GetSpellDamage(target, SpellSlot.R) : 0);
_mi = (float)(iready ? Me.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) : 0);
_guise = (float)(Items.HasItem(3151)
? Me.GetItemDamage(target, Damage.DamageItems.LiandrysTorment)
: 0);
}
private static float GetComboDamage(Obj_AI_Base enemy)
{
double damage = 0d;
if (Dfg.IsReady())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
}
if (Q.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (R.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.R);
}
if (Dfg.IsReady())
{
damage = damage * 1.2;
}
if (W.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
}
if (IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
}
if (Items.HasItem(3155, (Obj_AI_Hero)enemy))
{
damage = damage - 250;
}
if (Items.HasItem(3156, (Obj_AI_Hero)enemy))
{
damage = damage - 400;
}
return((float)damage);
}
private static float GetComboDamage(Obj_AI_Hero vTarget)
{
var fComboDamage = 0d;
if (Q.IsReady() && Player.Distance(vTarget) < Orbwalking.GetRealAutoAttackRange(Player))
{
fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.Q);
}
if (W.IsReady() && Player.Distance(vTarget) < WDamageRange)
{
fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.W);
}
if (E.IsReady() && Player.Distance(vTarget) < E.Range)
{
fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.E);
}
if (R.IsReady() && Player.Distance(vTarget) < R.Range)
{
fComboDamage += Player.GetSpellDamage(vTarget, SpellSlot.R);
}
if (IgniteSlot != SpellSlot.Unknown && Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready &&
Player.Distance(vTarget) < R.Range)
{
fComboDamage += Player.GetSummonerSpellDamage(vTarget, Damage.SummonerSpell.Ignite);
}
if (Items.CanUseItem(3092) && Player.Distance(vTarget) < R.Range)
{
fComboDamage += Player.GetItemDamage(vTarget, Damage.DamageItems.FrostQueenClaim);
}
return((float)fComboDamage);
}
private static float GetComboDamage(Obj_AI_Base enemy)
{
var damage = 0d;
if (Q.IsReady(420))
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (DFG.IsReady())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
}
if (W.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
}
if (E.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
if (IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
}
if (R.IsReady())
{
damage += Math.Min(7, Player.Spellbook.GetSpell(SpellSlot.R).Ammo) * Player.GetSpellDamage(enemy, SpellSlot.R, 1);
}
return((float)damage * (DFG.IsReady() ? 1.2f : 1));
}
private static float GetComboDamage(Obj_AI_Base enemy)
{
var damage = 0d;
if (_r.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.R);
}
if (_dfg.IsReady())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.Dfg) / 1.2;
}
if (_w.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
}
if (_q.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (_e.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
if (_igniteSlot != SpellSlot.Unknown && Player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
{
damage += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
}
return((float)damage * (_dfg.IsReady() ? 1.2f : 1));
}
private static float ComboDamage(Obj_AI_Base enemy)
{
var itemscheck = SmiteBlue.Any(i => Items.HasItem(i)) || SmiteRed.Any(i => Items.HasItem(i));
var damage = 0d;
if (_igniteSlot != SpellSlot.Unknown &&
_player.Spellbook.CanUseSpell(_igniteSlot) == SpellState.Ready)
{
damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
}
if (_q.IsReady())
{
damage += _player.GetSpellDamage(enemy, SpellSlot.Q);
}
if (_e.IsReady() || ObjectManager.Player.HasBuff("JudicatorRighteousFury"))
{
damage += _player.GetSpellDamage(enemy, SpellSlot.E);
damage = damage + _player.GetAutoAttackDamage(enemy, true) * 4;
}
if (Items.HasItem(3128) && Items.CanUseItem(3128))
{
damage += _player.GetItemDamage(enemy, Damage.DamageItems.Dfg);
damage = damage * 1.2;
}
if (itemscheck &&
ObjectManager.Player.Spellbook.CanUseSpell(_smiteSlot) == SpellState.Ready)
{
damage += ObjectManager.Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Smite);
}
if (ObjectManager.Player.HasBuff("LichBane"))
{
damage += _player.BaseAttackDamage * 0.75 + _player.FlatMagicDamageMod * 0.5;
}
return((float)damage);
}
/*
* HUGE CREDITS TO xSalice I STOLE THIS FROM HIM AND ITS INCREDIBLE
* THIS IS ALL HIS WORK NAD YOU SHOULD CREDIT HIM FOR THIS
*
*
*
*/
public static void SmartKs()
{
if (!Config.Item("smartKS").GetValue <bool>())
{
return;
}
var nearChamps = (from champ in ObjectManager.Get <Obj_AI_Hero>() where _player.Distance(champ.ServerPosition) <= 1375 && champ.IsEnemy select champ).ToList();
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
nearChamps.OrderBy(x => x.Health);
var packets = Config.Item("QNFE").GetValue <bool>();
foreach (var target in nearChamps.Where(target => target != null && !target.IsDead))
{
//dfg
if (Dfg.IsReady() && _player.GetItemDamage(target, Damage.DamageItems.Dfg) > target.Health + 20 && _player.Distance(target.ServerPosition) <= 750)
{
Dfg.Cast(target);
//Game.PrintChat("ks 1");
return;
}
//dfg + q
if (_player.Distance(target.ServerPosition) <= Q.Range &&
(_player.GetItemDamage(target, Damage.DamageItems.Dfg) + (_player.GetSpellDamage(target, SpellSlot.Q)) * 1.2) > target.Health + 20)
{
if (Dfg.IsReady() && Q.IsReady())
{
Dfg.Cast(target);
Q.Cast(target, packets);
//Game.PrintChat("ks 2");
return;
}
}
//dfg + q
if (_player.Distance(target.ServerPosition) <= E.Range &&
(_player.GetItemDamage(target, Damage.DamageItems.Dfg) + (_player.GetSpellDamage(target, SpellSlot.E)) * 1.2) > target.Health + 20)
{
if (Dfg.IsReady() && Q.IsReady())
{
Dfg.Cast(target);
E.Cast(target, packets);
//Game.PrintChat("ks 3");
return;
}
}
//E + W
if (_player.Distance(target.ServerPosition) <= E.Range && (_player.GetSpellDamage(target, SpellSlot.E) + _player.GetSpellDamage(target, SpellSlot.W)) > target.Health + 20)
{
if (E.IsReady() && W.IsReady())
{
E.Cast(target, packets);
W.Cast();
//Game.PrintChat("ks 5");
return;
}
}
//E + Q
if (_player.Distance(target.ServerPosition) <= E.Range && (_player.GetSpellDamage(target, SpellSlot.E) + _player.GetSpellDamage(target, SpellSlot.Q)) > target.Health + 20)
{
if (E.IsReady() && Q.IsReady())
{
E.Cast(target, packets);
Q.Cast(target, packets);
//Game.PrintChat("ks 6");
return;
}
}
//Q
if ((_player.GetSpellDamage(target, SpellSlot.Q)) > target.Health + 20)
{
if (Q.IsReady() && _player.Distance(target.ServerPosition) <= Q.Range)
{
Q.Cast(target, packets);
//Game.PrintChat("ks 7");
return;
}
if (Q.IsReady() && E.IsReady() && _player.Distance(target.ServerPosition) <= 1375 && Config.Item("wardKs").GetValue <bool>() && CountEnemiesNearPosition(target.ServerPosition, 500) < 3)
{
JumpKs(target);
//Game.PrintChat("wardKS!!!!!");
return;
}
}
//E
if (_player.Distance(target.ServerPosition) <= E.Range && (_player.GetSpellDamage(target, SpellSlot.E)) > target.Health + 20)
{
if (E.IsReady())
{
E.Cast(target, packets);
//Game.PrintChat("ks 8");
return;
}
}
}
}
private static void CheckDamage(Obj_AI_Base target)
{
if (target == null)
{
return;
}
var ad = Me.GetAutoAttackDamage(target);
var ignite = Me.GetSpellSlot("summonerdot");
var tmt = Items.HasItem(3077) && Items.CanUseItem(3077)
? Me.GetItemDamage(target, Damage.DamageItems.Tiamat)
: 0;
var hyd = Items.HasItem(3074) && Items.CanUseItem(3074)
? Me.GetItemDamage(target, Damage.DamageItems.Hydra)
: 0;
var bwc = Items.HasItem(3144) && Items.CanUseItem(3144) ?
Me.GetItemDamage(target, Damage.DamageItems.Bilgewater)
: 0;
var brk = Items.HasItem(3153) && Items.CanUseItem(3153)
? Me.GetItemDamage(target, Damage.DamageItems.Botrk)
: 0;
rr = Me.GetSpellDamage(target, SpellSlot.R) - 20;
ra = ad + (ad * (runicpassive[Me.Level] / 100) * runiccount);
rq = q.IsReady() ? DamageQ(target) : 0;
rw = w.IsReady()
? Me.GetSpellDamage(target, SpellSlot.W)
: 0;
ri = Me.Spellbook.CanUseSpell(ignite) == SpellState.Ready
? Me.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite)
: 0;
ritems = tmt + hyd + bwc + brk;
ua = r.IsReady()
? ra +
Me.CalcDamage(target, Damage.DamageType.Physical,
Me.BaseAttackDamage + Me.FlatPhysicalDamageMod * 0.2)
: ua;
uq = r.IsReady()
? rq +
Me.CalcDamage(target, Damage.DamageType.Physical,
Me.BaseAttackDamage + Me.FlatPhysicalDamageMod * 0.2 * 0.7)
: uq;
uw = r.IsReady()
? rw +
Me.CalcDamage(target, Damage.DamageType.Physical,
Me.BaseAttackDamage + Me.FlatPhysicalDamageMod * 0.2 * 1)
: uw;
rr = r.IsReady()
? Me.GetSpellDamage(target, SpellSlot.R)
: 0;
}
private static void KillSteal()
{
Obj_AI_Hero target = ObjectManager.Get <Obj_AI_Hero>()
.Where(x => x.IsValidTarget() && x.Distance(Player.Position) < 1000f)
.OrderBy(x => x.Health).FirstOrDefault();
var usePacket = Config.Item("usePackets").GetValue <bool>();
if (target != null && !target.IsInvulnerable && !target.IsDead && !target.IsZombie)
{
double igniteDmg = Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
double QDmg = getdamages(SpellSlot.Q, target);
double WDmg = Player.GetSpellDamage(target, SpellSlot.W);
double EDmg = Player.GetSpellDamage(target, SpellSlot.E);
double hydradmg = Player.GetItemDamage(target, Damage.DamageItems.Hydra);
double tiamatdmg = Player.GetItemDamage(target, Damage.DamageItems.Tiamat);
if (Config.Item("UseIgnite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
if (igniteDmg > target.Health)
{
Player.Spellbook.CastSpell(IgniteSlot, target);
}
}
if (!ishealthy() && Config.Item("autoescape").GetValue <bool>() && Player.CountEnemiesInRange(300) >= 1)
{
var objAiHero = ObjectManager.Get <Obj_AI_Hero>().FirstOrDefault(x => x.IsAlly && x.CountEnemiesInRange(300) == 0 && x.HealthPercentage() > 45 && E.IsInRange(x));
if (objAiHero != null)
{
var bestposition =
objAiHero.ServerPosition;
E.Cast(bestposition, usePacket);
}
}
if (Q.IsReady() && Player.Distance(target) <= Q.Range && Config.Item("UseQKs").GetValue <bool>())
{
if (target.Health <= QDmg)
{
Orbwalker.SetAttack(false);
Q.Cast(target, usePacket);
Orbwalker.SetAttack(true);
}
}
if (E.IsReady() && Player.Distance(target) <= E.Range && Config.Item("UseEKs").GetValue <bool>())
{
if (target.Health <= EDmg)
{
Utility.DelayAction.Add(
Game.Ping + Config.Item("EDelay").GetValue <Slider>().Value, delegate
{
PredictionOutput pred = E.GetPrediction(target);
if (target.IsValid && !target.IsDead)
{
E.Cast(pred.CastPosition, usePacket);
}
});
}
}
if (W.IsReady() && Wnorm && Player.Distance(target) <= W.Range && Config.Item("UseWKs").GetValue <bool>())
{
if (target.Health <= WDmg)
{
if (W.GetPrediction(target).Hitchance >= HitChance.Medium)
{
PredictionOutput pred = W.GetPrediction(target);
W.Cast(pred.CastPosition);
}
}
if (W.IsReady() && Wevolved && Player.Distance(target) <= W.Range &&
Config.Item("UseWKs").GetValue <bool>())
{
if (target.Health <= WDmg)
{
PredictionOutput pred = W.GetPrediction(target);
CastWE(target, pred.UnitPosition.To2D());
}
if (W.GetPrediction(target).Hitchance >= HitChance.Collision)
{
List <Obj_AI_Base> PCollision = W.GetPrediction(target).CollisionObjects;
foreach (Obj_AI_Base PredCollisionChar in
PCollision.Where(PredCollisionChar => PredCollisionChar.Distance(target) <= 30))
{
W.Cast(PredCollisionChar.Position, Config.Item("usePackets").GetValue <bool>());
}
}
}
}
// Mixed's EQ KS
if (Q.IsReady() && E.IsReady() && Player.Distance(target) <= E.Range + Q.Range &&
Config.Item("UseEQKs").GetValue <bool>())
{
if ((target.Health <= QDmg + EDmg))
{
Utility.DelayAction.Add(Game.Ping + 200, delegate
{
PredictionOutput pred = E.GetPrediction(target);
if (target.IsValid && !target.IsDead)
{
E.Cast(pred.CastPosition);
}
});
}
}
// MIXED EW KS
if (W.IsReady() && E.IsReady() && Wnorm && Player.Distance(target) <= W.Range + E.Range &&
Config.Item("UseEWKs").GetValue <bool>())
{
if (target.Health <= WDmg)
{
Utility.DelayAction.Add(Game.Ping + 200, delegate
{
PredictionOutput pred = E.GetPrediction(target);
if (target.IsValid && !target.IsDead)
{
E.Cast(pred.CastPosition);
}
});
}
}
if (TIA.IsReady() && Player.Distance(target) <= TIA.Range &&
Config.Item("UseTiaKs").GetValue <bool>())
{
if (target.Health <= tiamatdmg)
{
TIA.Cast();
}
}
if (HDR.IsReady() && Player.Distance(target) <= HDR.Range &&
Config.Item("UseTiaKs").GetValue <bool>())
{
if (target.Health <= hydradmg)
{
HDR.Cast();
}
}
}
}
private static float ComboDamage(Obj_AI_Hero hero)
{
float damage = 0;
if (Q.IsReady())
{
damage += (float)Damage.GetSpellDamage(me, hero, SpellSlot.Q);
}
if (E.IsReady())
{
damage += (float)Damage.GetSpellDamage(me, hero, SpellSlot.E);
}
if (W.IsReady())
{
double wdot = new double[] { 40, 70, 100, 130, 160 }[W.Level] +(new double[] { 4, 6, 8, 10, 12 }[W.Level] / 100) * me.MaxHealth;
damage += (float)me.CalcDamage(hero, Damage.DamageType.Magical, wdot);
damage += (float)Damage.GetSpellDamage(me, hero, SpellSlot.W);
}
if (R.IsReady())
{
damage += (float)Damage.GetSpellDamage(me, hero, SpellSlot.R);
}
if ((Items.HasItem(Bft.Id) && Items.CanUseItem(Bft.Id)) ||
(Items.HasItem(Dfg.Id) && Items.CanUseItem(Dfg.Id)))
{
damage = (float)(damage * 1.2);
}
if (Items.HasItem(Bft.Id) && Items.CanUseItem(Bft.Id))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Dfg);
}
if (Items.HasItem(Dfg.Id) && Items.CanUseItem(Dfg.Id))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Dfg);
}
if (me.Spellbook.CanUseSpell(me.GetSpellSlot("summonerdot")) == SpellState.Ready && hero.Health < damage + me.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite))
{
damage += (float)me.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);
}
if (Items.HasItem(3077) && Items.CanUseItem(3077))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Tiamat);
}
if (Items.HasItem(3074) && Items.CanUseItem(3074))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Hydra);
}
if (Items.HasItem(3144) && Items.CanUseItem(3144))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Bilgewater);
}
if (Items.HasItem(3153) && Items.CanUseItem(3153))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Botrk);
}
if (Items.HasItem(3146) && Items.CanUseItem(3146))
{
damage += (float)me.GetItemDamage(hero, Damage.DamageItems.Hexgun);
}
if (Items.HasItem(3091) && Items.CanUseItem(3091))
{
damage += (float)me.CalcDamage(hero, Damage.DamageType.Magical, 42);
}
return(damage);
}
private static float GetComboDamage()
{
var fComboDamage = 0d;
var qTarget = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Magical);
var wTarget = SimpleTs.GetTarget(W.Range, SimpleTs.DamageType.Magical);
var eTarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);
if (Q.IsReady() && qTarget != null)
{
fComboDamage += Player.GetSpellDamage(qTarget, SpellSlot.Q);
}
if (W.IsReady() && wTarget != null)
{
fComboDamage += Player.GetSpellDamage(wTarget, SpellSlot.W);
}
if (E.IsReady() && eTarget != null)
{
fComboDamage += Player.GetSpellDamage(eTarget, SpellSlot.E);
}
var rMode = Player.Spellbook.GetSpell(SpellSlot.R).Name;
switch (rMode)
{
case "LeblancChaosOrbM": // R->Q
{
if (R.IsReady() && qTarget != null)
{
fComboDamage += Player.GetSpellDamage(qTarget, SpellSlot.R);
}
break;
}
case "LeblancSlideM": // R->W
{
if (R.IsReady() && wTarget != null)
{
fComboDamage += Player.GetSpellDamage(wTarget, SpellSlot.R);
}
break;
}
case "LeblancSoulShackleM": // R->E
{
if (R.IsReady() && eTarget != null)
{
fComboDamage += Player.GetSpellDamage(eTarget, SpellSlot.R);
}
break;
}
}
if (IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
fComboDamage += Player.GetSummonerSpellDamage(wTarget, Damage.SummonerSpell.Ignite);
}
if (Items.CanUseItem(3128))
{
fComboDamage += Player.GetItemDamage(wTarget, Damage.DamageItems.Dfg);
}
if (Items.CanUseItem(3092))
{
fComboDamage += Player.GetItemDamage(wTarget, Damage.DamageItems.FrostQueenClaim);
}
return((float)fComboDamage);
}
internal static void OnCombo()
{
bool useQ = boolLinks["comboUseQ"].Value;
bool useE = boolLinks["comboUseE"].Value;
Obj_AI_Hero target;
if (useQ && Q.IsReady())
{
target = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Physical);
}
else
{
target = SimpleTs.GetTarget(E.Range * 1.2f, SimpleTs.DamageType.Physical);
}
if (target == null)
{
return;
}
// Item usage
if (boolLinks["comboUseItems"].Value)
{
if (boolLinks["itemsBotrk"].Value)
{
bool foundCutlass = Items.HasItem(3144);
bool foundBotrk = Items.HasItem(3153);
if (foundCutlass || foundBotrk)
{
if (foundCutlass || player.Health + player.GetItemDamage(target, Damage.DamageItems.Botrk) < player.MaxHealth)
{
Items.UseItem(foundCutlass ? 3144 : 3153, target);
}
}
}
}
// Spell usage
if (useQ && Q.IsReady() && !player.IsDashing())
{
Q.Cast(target);
}
if (useE && (E.IsReady() || E.Instance.State == SpellState.Surpressed))
{
// Target is not in range but has E stacks on
if (player.Distance(target, true) > Math.Pow(Orbwalking.GetRealAutoAttackRange(player), 2) && target.HasRendBuff())
{
// Get minions around
var minions = ObjectManager.Get <Obj_AI_Minion>().Where(m => m.IsValidTarget(Orbwalking.GetRealAutoAttackRange(player)));
// Check if a minion can die with the current E stacks
if (minions.Any(m => m.IsRendKillable()))
{
E.Cast(true);
}
else
{
// Check if a minion can die with one AA and E. Also, the AA minion has be be behind the player direction for a further leap
var minion = GetDashObjects(minions).FirstOrDefault(m => m.Health > player.GetAutoAttackDamage(m) && m.Health < player.GetAutoAttackDamage(m) + GetRendDamage(m, 1));
if (minion != null)
{
menu.Orbwalker.ForceTarget(minion);
}
}
}
// Target is in range and has at least the set amount of E stacks on
if (E.InRange(target.ServerPosition) && (target.IsRendKillable() || target.HasRendBuff() && target.GetRendBuff().Count >= sliderLinks["comboNumE"].Value.Value))
{
var buff = target.GetRendBuff();
// Check if the target would die from E
if (target.IsRendKillable())
{
E.Cast(true);
}
// If the target is still in range or the buff is active for longer than 0.25 seconds, if not, cast it
else if (GetRendDamage(target, buff.Count + 2) < target.Health && target.ServerPosition.Distance(player.Position, true) > Math.Pow(E.Range * 0.8, 2) || buff.EndTime - Game.Time <= 0.25)
{
E.Cast(true);
}
}
}
}
private static float GetComboDamage(Obj_AI_Base target)
{
double DamageDealt = 0;
var useQ = Config.Item("combo_Q").GetValue <bool>();
var useW = Config.Item("combo_W").GetValue <bool>();
var useE = Config.Item("combo_E").GetValue <bool>();
var useR = Config.Item("combo_R").GetValue <bool>();
var useRUSH = Config.Item("combo_RUSH").GetValue <bool>();
var useTMT = Config.Item("item_TMT").GetValue <bool>();
var useHYD = Config.Item("item_HYD").GetValue <bool>();
var useSOTD = Config.Item("item_SOTD").GetValue <bool>();
// Q
if (Q.IsReady() && useQ)
{
DamageDealt += DamageDealt += Q.GetDamage(target);
}
// W
if (W.IsReady() && useW)
{
DamageDealt += W.GetDamage(target);
}
// R
if (R.IsReady() && (useR || useRUSH))
{
DamageDealt += R.GetDamage(target);
}
// Double AA + SOTD
int SOTDbonus = SOTD.IsReady() && useSOTD ? 2 : 1;
DamageDealt += ((Player.GetAutoAttackDamage(target) * 1.1 * (Q.IsReady() ? 2 : 1)) * SOTDbonus);
// Tiamat
if (TMT.IsReady() && useTMT)
{
DamageDealt += Player.GetItemDamage(target, Damage.DamageItems.Tiamat);
}
// Hydra
if (HYD.IsReady() && useHYD)
{
DamageDealt += Player.GetItemDamage(target, Damage.DamageItems.Hydra);
}
// E damage amplification
double[] Amp = { 0, 1.03, 1.06, 1.09, 1.12, 1.15 };
if (E.IsReady() && useE)
{
DamageDealt += DamageDealt * Amp[E.Level];
}
return((float)DamageDealt);
}
private static void KillSteal()
{
Obj_AI_Hero target = HeroList
.Where(x => x.IsValidTarget() && x.Distance(Player.Position) < 1000f && !x.IsZombie)
.MinOrDefault(x => x.Health);
if (target != null)
{
if (Config.Item("UseIgnite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
double igniteDmg = Player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
if (igniteDmg > target.Health)
{
Player.Spellbook.CastSpell(IgniteSlot, target);
return;
}
}
if (Config.Item("autoescape").GetValue <bool>() && !ishealthy())
{
var ally =
HeroList.FirstOrDefault(h => h.HealthPercent > 50 && h.CountEnemiesInRange(400) == 0 && !PointUnderEnemyTurret(h.ServerPosition));
if (ally != null && ally.IsValid)
{
E.Cast(ally.ServerPosition);
return;
}
var objAiturret = EnemyTurretPositions.Where(x => Vector3.Distance(Player.ServerPosition, x) <= 900f);
if (objAiturret.Any() || Player.CountEnemiesInRange(500) >= 1)
{
var bestposition = Player.ServerPosition.Extend(NexusPosition, E.Range);
E.Cast(bestposition);
return;
}
}
if (Config.Item("UseQKs").GetValue <bool>() && Q.IsReady() &&
Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= Q.Range)
{
double QDmg = GetQDamage(target);
if (!Jumping && target.Health <= QDmg)
{
Q.Cast(target);
return;
}
}
if (Config.Item("UseEKs").GetValue <bool>() && E.IsReady() &&
Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= E.Range && Vector3.Distance(Player.ServerPosition, target.ServerPosition) > Q.Range)
{
double EDmg = Player.GetSpellDamage(target, SpellSlot.E);
if (!Jumping && target.Health < EDmg)
{
Utility.DelayAction.Add(
Game.Ping + Config.Item("EDelay").GetValue <Slider>().Value, delegate
{
PredictionOutput pred = E.GetPrediction(target);
if (target.IsValid && !target.IsDead)
{
E.Cast(pred.CastPosition);
}
});
}
}
if (W.IsReady() && Wnorm && Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= W.Range &&
Config.Item("UseWKs").GetValue <bool>())
{
double WDmg = Player.GetSpellDamage(target, SpellSlot.W);
if (target.Health <= WDmg)
{
var pred = W.GetPrediction(target);
if (pred.Hitchance >= HitChance.Medium)
{
W.Cast(pred.CastPosition);
return;
}
}
}
if (W.IsReady() && Wevolved &&
Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= W.Range &&
Config.Item("UseWKs").GetValue <bool>())
{
double WDmg = Player.GetSpellDamage(target, SpellSlot.W);
PredictionOutput pred = W.GetPrediction(target);
if (target.Health <= WDmg && pred.Hitchance > HitChance.Medium)
{
CastWE(target, pred.UnitPosition.To2D());
return;
}
if (pred.Hitchance >= HitChance.Collision)
{
List <Obj_AI_Base> PCollision = pred.CollisionObjects;
var x =
PCollision
.FirstOrDefault(PredCollisionChar => Vector3.Distance(PredCollisionChar.ServerPosition, target.ServerPosition) <= 30);
if (x != null)
{
W.Cast(x.Position);
return;
}
}
}
// Mixed's EQ KS
if (Q.IsReady() && E.IsReady() &&
Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= E.Range + Q.Range &&
Config.Item("UseEQKs").GetValue <bool>())
{
double QDmg = GetQDamage(target);
double EDmg = Player.GetSpellDamage(target, SpellSlot.E);
if ((target.Health <= QDmg + EDmg))
{
Utility.DelayAction.Add(Config.Item("EDelay").GetValue <Slider>().Value, delegate
{
PredictionOutput pred = E.GetPrediction(target);
if (target.IsValidTarget() && !target.IsZombie)
{
E.Cast(pred.CastPosition);
}
});
}
}
// MIXED EW KS
if (W.IsReady() && E.IsReady() && Wnorm &&
Vector3.Distance(Player.ServerPosition, target.ServerPosition) <= W.Range + E.Range &&
Config.Item("UseEWKs").GetValue <bool>())
{
double WDmg = Player.GetSpellDamage(target, SpellSlot.W);
if (target.Health <= WDmg)
{
Utility.DelayAction.Add(Config.Item("EDelay").GetValue <Slider>().Value, delegate
{
PredictionOutput pred = E.GetPrediction(target);
if (target.IsValid && !target.IsDead)
{
E.Cast(pred.CastPosition);
}
});
}
}
if (Tiamat.IsReady() &&
Vector2.Distance(Player.ServerPosition.To2D(), target.ServerPosition.To2D()) <= Tiamat.Range &&
Config.Item("UseTiamatKs").GetValue <bool>())
{
double Tiamatdmg = Player.GetItemDamage(target, Damage.DamageItems.Tiamat);
if (target.Health <= Tiamatdmg)
{
Tiamat.Cast();
return;
}
}
if (Hydra.IsReady() &&
Vector2.Distance(Player.ServerPosition.To2D(), target.ServerPosition.To2D()) <= Hydra.Range &&
Config.Item("UseTiamatKs").GetValue <bool>())
{
double hydradmg = Player.GetItemDamage(target, Damage.DamageItems.Hydra);
if (target.Health <= hydradmg)
{
Hydra.Cast();
}
}
}
}
public static float ComboDamage(Obj_AI_Hero hero)
{
float damage = 0;
if (Q.IsReady())
{
damage += (float)Damage.GetSpellDamage(player, hero, SpellSlot.Q);
}
if (E.IsReady())
{
damage += (float)Damage.GetSpellDamage(player, hero, SpellSlot.E);
}
//lich
if (Items.HasItem(3100) && Items.CanUseItem(3100))
{
damage += (float)player.CalcDamage(hero, Damage.DamageType.Magical, player.BaseAttackDamage * 0.75 + player.FlatMagicDamageMod * 0.5);
}
//sheen
if (Items.HasItem(3057) && (Items.CanUseItem(3057) || player.HasBuff("sheen", true)))
{
damage += (float)player.CalcDamage(hero, Damage.DamageType.Physical, player.BaseAttackDamage);
}
//gaunlet
if (Items.HasItem(3025) && Items.CanUseItem(3025))
{
damage += (float)player.CalcDamage(hero, Damage.DamageType.Physical, player.BaseAttackDamage * 1.25);
}
//trinity
if (Items.HasItem(3078) && Items.CanUseItem(3078))
{
damage += (float)player.CalcDamage(hero, Damage.DamageType.Physical, player.BaseAttackDamage * 2);
}
if ((Items.HasItem(Bft.Id) && Items.CanUseItem(Bft.Id)) ||
(Items.HasItem(Dfg.Id) && Items.CanUseItem(Dfg.Id)))
{
damage = (float)(damage * 1.2);
}
if (Items.HasItem(Bft.Id) && Items.CanUseItem(Bft.Id))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Dfg);
}
if (Items.HasItem(Dfg.Id) && Items.CanUseItem(Dfg.Id))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Dfg);
}
if (player.Spellbook.CanUseSpell(player.GetSpellSlot("summonerdot")) == SpellState.Ready)
{
damage += (float)player.GetSummonerSpellDamage(hero, Damage.SummonerSpell.Ignite);
}
if (Items.HasItem(3077) && Items.CanUseItem(3077))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Tiamat);
}
if (Items.HasItem(3074) && Items.CanUseItem(3074))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Hydra);
}
if (Items.HasItem(3144) && Items.CanUseItem(3144))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Bilgewater);
}
if (Items.HasItem(3153) && Items.CanUseItem(3153))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Botrk);
}
if (Items.HasItem(3146) && Items.CanUseItem(3146))
{
damage += (float)player.GetItemDamage(hero, Damage.DamageItems.Hexgun);
}
if (Items.HasItem(3091) && Items.CanUseItem(3091))
{
damage += (float)player.CalcDamage(hero, Damage.DamageType.Magical, 42);
}
return(damage);
}
private static float GetComboDamage(Obj_AI_Base enemy)
{
var damage = 0d;
if (Q.IsReady())
{
var d = Player.GetSpellDamage(enemy, SpellSlot.Q);
if (enemy.HasQBuff() || enemy.HasQRBuff())
{
d *= 2;
}
damage += d;
}
if (R.IsReady())
{
var d = 0d;
var level = Player.Spellbook.GetSpell(SpellSlot.R).Level;
var maxDamage = new double[] { 200, 400, 600 }[level - 1] +1.3f * Player.FlatMagicDamageMod;
switch (R.GetSpellSlot())
{
case SpellSlot.Q:
var qDmg = Player.CalcDamage(
enemy, Damage.DamageType.Magical,
new double[] { 100, 200, 300 }[level - 1] +.65f * Player.FlatMagicDamageMod);
d = qDmg > maxDamage ? maxDamage : qDmg;
break;
case SpellSlot.W:
d = Player.CalcDamage(
enemy, Damage.DamageType.Magical,
new double[] { 150, 300, 450 }[level - 1] +.975f * Player.FlatMagicDamageMod);
break;
case SpellSlot.E:
var eDmg = Player.CalcDamage(
enemy, Damage.DamageType.Magical,
new double[] { 100, 200, 300 }[level - 1] +.65f * Player.FlatMagicDamageMod);
d = eDmg > maxDamage ? maxDamage : eDmg;
break;
}
if (enemy.HasQBuff() || enemy.HasQRBuff())
{
d += Player.GetSpellDamage(enemy, SpellSlot.Q);
}
damage += d;
}
if (E.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.E);
}
if (W.IsReady())
{
damage += Player.GetSpellDamage(enemy, SpellSlot.W);
}
if (Items.FQC.IsReady())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.FrostQueenClaim);
}
if (Items.BOTRK.IsReady())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.Botrk);
}
if (Items.LT.HasItem())
{
damage += Player.GetItemDamage(enemy, Damage.DamageItems.LiandrysTorment);
}
if (Spells.Ignite.IsReady())
{
damage += Player.GetSummonerSpellDamage(enemy, Damage.SummonerSpell.Ignite);
}
damage += Player.GetAutoAttackDamage(enemy, true);
return((float)damage);
}
/// <summary>
/// Gets the hero average damage to the opposing team.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="Enemies">The enemies.</param>
/// <returns></returns>
public static float GetHeroAvgDamage(Obj_AI_Hero player, List<Obj_AI_Hero> Enemies)
{
var totalEnemies = Enemies.Count();
if (totalEnemies == 0)
{
return -1;
}
var AADamage = Enemies.Aggregate(0, (current, s) => (int) (current + player.GetAutoAttackDamage(s) * 2));
var QDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.Q).IsReady() ? player.GetSpellDamage(s, SpellSlot.Q) : 0f)));
var WDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.W).IsReady() ? player.GetSpellDamage(s, SpellSlot.W) : 0f)));
var EDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.E).IsReady() ? player.GetSpellDamage(s, SpellSlot.E) : 0f)));
var RDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.R).IsReady() ? player.GetSpellDamage(s, SpellSlot.R) : 0f)));
var itemsDamage = 0f;
foreach (var item in player.InventoryItems)
{
foreach (var hero in Enemies)
{
var itemID = item.Id;
switch (itemID)
{
case ItemId.Bilgewater_Cutlass:
itemsDamage +=
(float) player.GetItemDamage(hero, Damage.DamageItems.Bilgewater);
break;
case ItemId.Blade_of_the_Ruined_King:
itemsDamage += (float) player.GetItemDamage(hero, Damage.DamageItems.Botrk);
break;
case ItemId.Hextech_Gunblade:
itemsDamage += (float) player.GetItemDamage(hero, Damage.DamageItems.Hexgun);
break;
case ItemId.Frost_Queens_Claim:
itemsDamage +=
(float) player.GetItemDamage(hero, Damage.DamageItems.FrostQueenClaim);
break;
case ItemId.Tiamat_Melee_Only:
itemsDamage += player.IsMelee
? (float) player.GetItemDamage(hero, Damage.DamageItems.Tiamat)
: 0f;
break;
case ItemId.Ravenous_Hydra_Melee_Only:
itemsDamage += player.IsMelee
? (float) player.GetItemDamage(hero, Damage.DamageItems.Hydra)
: 0f;
break;
case ItemId.Liandrys_Torment:
itemsDamage +=
(float) player.GetItemDamage(hero, Damage.DamageItems.LiandrysTorment);
break;
}
}
}
var totalDamage = AADamage + QDamage + WDamage + EDamage + RDamage + itemsDamage;
return (float) totalDamage / totalEnemies;
}
// Main combo logic function
private static void Combo()
{
// initalize variables
var wTarget = SimpleTs.GetTarget(W.Range / 2, SimpleTs.DamageType.Magical);
var eTarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);
var rTarget = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Magical);
var useQ = Config.Item("ComboUseQ").GetValue <bool>();
var useW = Config.Item("ComboUseW").GetValue <bool>();
var useE = Config.Item("ComboUseE").GetValue <bool>();
var useR = Config.Item("ComboUseR").GetValue <bool>();
// Filter out people we shouldnt ult
useR = (Config.Item("DontUlt" + rTarget.BaseSkinName) != null &&
Config.Item("DontUlt" + rTarget.BaseSkinName).GetValue <bool>() == false) && useR;
// Shut off auto attack via orbwalker so it doesnt interrupt any combos
Orbwalker.SetAttack(false);
// -----------------------------------------------
// ---- MAIN ATTACK LOGIC START
// -----------------------------------------------
// ----------------------------------------------------------------------------------------
// First priority is to see if there is anyone in E range that can be insta killed
if (useE && eTarget != null && eTarget.Health < Player.GetSpellDamage(eTarget, SpellSlot.E))
{
E.Cast(eTarget.Position);
}
// See if DFG or BFT are useable
if (Items.CanUseItem(3128) || Items.CanUseItem(3188))
{
// See if we had a DFG
if (useE && eTarget != null && Items.CanUseItem(3128))
{
if (eTarget.Health < Player.GetSpellDamage(eTarget, SpellSlot.E) + Player.GetItemDamage(eTarget, Damage.DamageItems.Dfg) + (Player.GetSpellDamage(eTarget, SpellSlot.E) * 0.15))
{
Items.UseItem(3128, eTarget);
E.Cast(eTarget.Position);
}
}
// Or else we had a BFT
else if (useE && eTarget != null && Items.CanUseItem(3188))
{
if (eTarget.Health < Player.GetSpellDamage(eTarget, SpellSlot.E) + Player.GetItemDamage(eTarget, Damage.DamageItems.BlackFireTorch) + (Player.GetSpellDamage(eTarget, SpellSlot.E) * 0.15))
{
Items.UseItem(3188, eTarget);
E.Cast(eTarget.Position);
}
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// Second priority is to see if there is anyone in R range that can be insta killed without any of the DOT
if (useR && rTarget != null && !MordekaiserHaveSlave && rTarget.Health < (Player.GetSpellDamage(rTarget, SpellSlot.R) / 2))
{
R.CastOnUnit(rTarget);
}
// See if DFG or BFT are useable
if (Items.CanUseItem(3128) || Items.CanUseItem(3188))
{
// See if we had a DFG
if (Items.CanUseItem(3128))
{
if (useR && rTarget != null && !MordekaiserHaveSlave && Player.Distance(rTarget) < 695)
{
if (rTarget.Health < (Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) + Player.GetItemDamage(rTarget, Damage.DamageItems.Dfg) + ((Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) * 0.15))
{
if (Player.Distance(rTarget) < 599 && IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
Player.SummonerSpellbook.CastSpell(IgniteSlot, rTarget);
}
Items.UseItem(3128, rTarget);
R.CastOnUnit(rTarget);
}
}
}
// Or else we had a BFT
else if (Items.CanUseItem(3188))
{
if (useR && rTarget != null && !MordekaiserHaveSlave && Player.Distance(rTarget) < 695)
{
if (rTarget.Health < (Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) + Player.GetItemDamage(rTarget, Damage.DamageItems.BlackFireTorch) + ((Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) * 0.15))
{
if (Player.Distance(rTarget) < 599 && IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
Player.SummonerSpellbook.CastSpell(IgniteSlot, rTarget);
}
Items.UseItem(3188, rTarget);
R.CastOnUnit(rTarget);
}
}
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// Thrid priority is to see if there is anyone in E range that can be insta killed without any of the DOT using both E and R
if (useR && useE && eTarget != null && !MordekaiserHaveSlave && eTarget.Health < Player.GetSpellDamage(eTarget, SpellSlot.E) + (Player.GetSpellDamage(eTarget, SpellSlot.R) / 2))
{
if (Player.Distance(eTarget) < 599 && IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
Player.SummonerSpellbook.CastSpell(IgniteSlot, eTarget);
}
E.Cast(eTarget.Position);
R.CastOnUnit(eTarget);
}
// See if DFG or BFT are useable
if (Items.CanUseItem(3128) || Items.CanUseItem(3188))
{
// See if we had a DFG
if (useE && useR && eTarget != null && Items.CanUseItem(3128))
{
if (eTarget.Health < Player.GetSpellDamage(eTarget, SpellSlot.E) + Player.GetItemDamage(eTarget, Damage.DamageItems.Dfg) + (Player.GetSpellDamage(eTarget, SpellSlot.E) * 0.15) + (Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) + ((Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) * 0.15))
{
if (Player.Distance(eTarget) < 599 && IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
Player.SummonerSpellbook.CastSpell(IgniteSlot, eTarget);
}
Items.UseItem(3128, eTarget);
E.Cast(eTarget.Position);
R.CastOnUnit(eTarget);
}
}
// Or else we had a BFT
else if (useE && useR && eTarget != null && Items.CanUseItem(3188))
{
if (eTarget.Health < Player.GetSpellDamage(eTarget, SpellSlot.E) + Player.GetItemDamage(eTarget, Damage.DamageItems.BlackFireTorch) + (Player.GetSpellDamage(eTarget, SpellSlot.E) * 0.15) + (Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) + ((Player.GetSpellDamage(rTarget, SpellSlot.R) / 2) * 0.15))
{
if (Player.Distance(eTarget) < 599 && IgniteSlot != SpellSlot.Unknown && Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
Player.SummonerSpellbook.CastSpell(IgniteSlot, eTarget);
}
Items.UseItem(3188, eTarget);
E.Cast(eTarget.Position);
R.CastOnUnit(eTarget);
}
}
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// Next priority is to see if Q is up and if we have a target in autoattack range
if (useQ && Q.IsReady() && Player.Distance(wTarget) < Orbwalking.GetRealAutoAttackRange(ObjectManager.Player))
{
// Shut off movement via orbwalker so it doesnt interrupt any combos
Orbwalker.SetMovement(false);
// See if we can Q + E them for a kill using at least 1/3 of Q damage
if (useE && E.IsReady() && wTarget.Health < (Player.GetSpellDamage(wTarget, SpellSlot.Q) / 3) + Player.GetSpellDamage(wTarget, SpellSlot.E))
{
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, wTarget);
E.Cast(wTarget.Position);
}
// See if we can Q + E + R them for a kill using at least 1/3 of Q damage
else if (useE && E.IsReady() && useR && R.IsReady() && !MordekaiserHaveSlave && wTarget != null && wTarget.Health < (Player.GetSpellDamage(wTarget, SpellSlot.Q) / 3) + Player.GetSpellDamage(wTarget, SpellSlot.E) + (Player.GetSpellDamage(wTarget, SpellSlot.R) / 2))
{
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, wTarget);
E.Cast(wTarget.Position);
R.CastOnUnit(wTarget);
}
// Couldn't combo anyone so we just use Q for dps
else if (wTarget != null)
{
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, wTarget);
// Auto Slave Control
if (MordekaiserHaveSlave)
{
R.Cast(wTarget);
SlaveDelay = Environment.TickCount + 1500;
}
}
// Turn movement via orbwalker since we are done with combos
Orbwalker.SetMovement(true);
}
// ----------------------------------------------------------------------------------------
// Re-check for targets before final dps alternatives
wTarget = SimpleTs.GetTarget(W.Range / 2, SimpleTs.DamageType.Magical);
eTarget = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);
// -----------------------------------------------
// Couldn't combo anyone so we just use E for dps
if (useE && eTarget != null)
{
E.Cast(eTarget.Position);
// Auto Slave Control
if (MordekaiserHaveSlave)
{
R.Cast(eTarget);
SlaveDelay = Environment.TickCount + 1500;
}
}
// Use W is we have an enemy player in metal shard range
if (useW && wTarget != null && Player.Distance(wTarget) < WDamageRange)
{
W.CastOnUnit(Player);
// Auto Slave Control
if (MordekaiserHaveSlave)
{
R.Cast(wTarget);
SlaveDelay = Environment.TickCount + 1500;
}
}
// Turn on autoattack via orbwalker since we are done casting spells
Orbwalker.SetAttack(true);
// ----------------------------------------------------------------------------------------
// -----------------------------------------------
// ---- MAIN ATTACK LOGIC END
// -----------------------------------------------
}
/// <summary>
/// Gets the hero average damage to the opposing team.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="Enemies">The enemies.</param>
/// <returns></returns>
public static float GetHeroAvgDamage(Obj_AI_Hero player, List <Obj_AI_Hero> Enemies)
{
var totalEnemies = Enemies.Count();
if (totalEnemies == 0)
{
return(-1);
}
var AADamage = Enemies.Aggregate(0, (current, s) => (int)(current + player.GetAutoAttackDamage(s) * 2));
var QDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.Q).IsReady() ? player.GetSpellDamage(s, SpellSlot.Q) : 0f)));
var WDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.W).IsReady() ? player.GetSpellDamage(s, SpellSlot.W) : 0f)));
var EDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.E).IsReady() ? player.GetSpellDamage(s, SpellSlot.E) : 0f)));
var RDamage = Enemies.Aggregate(0, (current, s) => (int)(current + (player.GetSpell(SpellSlot.R).IsReady() ? player.GetSpellDamage(s, SpellSlot.R) : 0f)));
var itemsDamage = 0f;
foreach (var item in player.InventoryItems)
{
foreach (var hero in Enemies)
{
var itemID = item.Id;
switch (itemID)
{
case ItemId.Bilgewater_Cutlass:
itemsDamage +=
(float)player.GetItemDamage(hero, Damage.DamageItems.Bilgewater);
break;
case ItemId.Blade_of_the_Ruined_King:
itemsDamage += (float)player.GetItemDamage(hero, Damage.DamageItems.Botrk);
break;
case ItemId.Hextech_Gunblade:
itemsDamage += (float)player.GetItemDamage(hero, Damage.DamageItems.Hexgun);
break;
case ItemId.Frost_Queens_Claim:
itemsDamage +=
(float)player.GetItemDamage(hero, Damage.DamageItems.FrostQueenClaim);
break;
case ItemId.Tiamat_Melee_Only:
itemsDamage += player.IsMelee
? (float)player.GetItemDamage(hero, Damage.DamageItems.Tiamat)
: 0f;
break;
case ItemId.Ravenous_Hydra_Melee_Only:
itemsDamage += player.IsMelee
? (float)player.GetItemDamage(hero, Damage.DamageItems.Hydra)
: 0f;
break;
case ItemId.Liandrys_Torment:
itemsDamage +=
(float)player.GetItemDamage(hero, Damage.DamageItems.LiandrysTorment);
break;
}
}
}
var totalDamage = AADamage + QDamage + WDamage + EDamage + RDamage + itemsDamage;
return((float)totalDamage / totalEnemies);
}
