public static Vector3 WalkBehindMinion(Obj_AI_Base target)
{
var minion = GameObjects.Enemy
.Where(x =>
x.IsValidTarget(Q.Range) &&
(x.IsMinion || x.IsHero) &&
Cone(x).IsInside(Q.GetPrediction(target).CastPosition.To2D()) &&
x.NetworkId != target.NetworkId)
.OrderBy(x => x.Distance(Global.Player))
.ThenBy(x => x.Health)
.FirstOrDefault();
if (target == null || minion == null || !minion.IsValid)
{
return(Vector3.Zero);
}
var position = minion.ServerPosition + (minion.ServerPosition - target.ServerPosition).Normalized() * Global.Player.Distance(minion) / 2;
var isValid = position.Distance(ObjectManager.GetLocalPlayer()) < 350;
if (isValid && !position.PointUnderEnemyTurret())
{
return(position);
}
return(Vector3.Zero);
}
private static void ThreshQ()
{
var target = TargetSelector.GetTarget(Main["combo"]["QMaximumRange"].As <MenuSlider>().Value);
if (target == null)
{
return;
}
var prediction = _q.GetPrediction(target);
if (Main["combo"]["q"].As <MenuBool>().Enabled&& Main["whiteList"]["qWhiteList" + target.ChampionName.ToLower()].As <MenuBool>().Enabled&& target.IsInRange(_q.Range) && target.IsValidTarget() && !target.HasBuff("threshQ") && _q.Ready && target.Distance(Thresh) > Main["combo"]["QMinimumRange"].As <MenuSlider>().Value)
{
if (prediction.HitChance >= HitChance.High)
{
_q.Cast(prediction.CastPosition);
}
}
if (target.HasBuff("threshQ") && Main["combo"]["q2"].As <MenuBool>().Enabled&& !target.IsUnderEnemyTurret())
{
if (target.Distance(Thresh.ServerPosition) >= 400)
{
DelayAction.Queue(1000, () => _q.CastOnUnit(Thresh));
}
}
if (target.HasBuff("threshQ") && target.IsUnderEnemyTurret() && Main["combo"]["q2Turret"].As <MenuBool>().Enabled)
{
if (target.Distance(Thresh.ServerPosition) >= 400)
{
DelayAction.Queue(1000, () => _q.CastOnUnit(Thresh));
}
}
}
public static void CastQ(Obj_AI_Base target)
{
if (!target.IsValidTarget(Q.ChargedMaxRange))
{
return;
}
if (!Q.IsCharging)
{
Q.StartCharging(target.ServerPosition);
}
var rect = QRealRect(target);
if (rect == null || !Q.IsCharging)
{
return;
}
var targetPosIn250ms = target.Position + (target.Position - Q.GetPrediction(target).CastPosition).Normalized() * (0.25f * target.MoveSpeed);
if (rect.IsInside(targetPosIn250ms.To2D()) && rect.End.Distance(targetPosIn250ms) > 90)
{
Q.ShootChargedSpell(Q.GetPrediction(target).CastPosition);
}
}
private static bool IsSpellHeroCollision(Obj_AI_Hero t, Aimtec.SDK.Spell r, int extraWith = 50)
{
foreach (
var hero in
GameObjects.EnemyHeroes.Where(
hero =>
hero.IsValidTarget(r.Range + r.Width, false, false, r.From) &&
t.NetworkId != hero.NetworkId))
{
var prediction = r.GetPrediction(hero);
var powCalc = Math.Pow(r.Width + extraWith + hero.BoundingRadius, 2);
if (
prediction.UnitPosition.To2D()
.Distance(Me.ServerPosition.To2D(), r.GetPrediction(t).CastPosition.To2D(), true, true) <=
powCalc)
{
return(true);
}
if (
prediction.UnitPosition.To2D()
.Distance(Me.ServerPosition.To2D(), t.ServerPosition.To2D(), true, true) <= powCalc)
{
return(true);
}
}
return(false);
}
public static Result GetLineAoePrediction(this Spell spell, Obj_AI_Hero target, HitChance hitChance,
bool boundingRadius = true, bool maxRange = true, Vector3?sourcePosition = null)
{
try
{
if (spell == null || target == null)
{
return(new Result(Vector3.Zero, new List <Obj_AI_Hero>()));
}
var fromPosition = sourcePosition ?? ObjectManager.GetLocalPlayer().ServerPosition;
var range = (spell.IsChargedSpell && maxRange ? spell.ChargedMaxRange : spell.Range) +
spell.Width * 0.9f +
(boundingRadius ? target.BoundingRadius * BoundingRadiusMultiplicator : 0);
var positions = (from t in GameObjects.EnemyHeroes
where t.IsValidTarget(range, false, false, fromPosition)
let prediction = spell.GetPrediction(t)
where prediction.HitChance >= hitChance
select new Position(t, prediction.UnitPosition)).ToList();
if (positions.Any())
{
var hits = new List <Obj_AI_Hero>();
var pred = spell.GetPrediction(target);
if (pred.HitChance >= hitChance)
{
hits.Add(target);
var rect = new MyPolygon.Rectangle(
spell.From, spell.From.Extend(pred.CastPosition, range), spell.Width);
if (boundingRadius)
{
hits.AddRange(
from point in positions.Where(p => p.Hero.NetworkId != target.NetworkId)
let circle =
new MyPolygon.Circle(
point.UnitPosition, point.Hero.BoundingRadius * BoundingRadiusMultiplicator)
where circle.Points.Any(p => rect.IsInside(p))
select point.Hero);
}
else
{
hits.AddRange(
from position in positions
where rect.IsInside(position.UnitPosition)
select position.Hero);
}
return(new Result(pred.CastPosition, hits));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(new Result(Vector3.Zero, new List <Obj_AI_Hero>()));
}
public static void CastQ(Obj_AI_Base target, bool extend = true)
{
foreach (var soldier in SoldierManager.Soldiers)
{
if (soldier == null || soldier.ServerPosition == Vector3.Zero)
{
return;
}
var pred = Q.GetPrediction(target, soldier.ServerPosition);
Q.Cast(extend ? soldier.ServerPosition.Extend(pred.CastPosition, target.Distance(soldier) + 200) : pred.CastPosition);
}
}
public static void CastQ(Obj_AI_Base target)
{
if (Game.TickCount - _lastCastTime < 800 - Game.Ping / 2)
{
return;
}
if (PaddleStarPosition == Vector3.Zero)
{
var paddleStarPrediction = GeneratePaddleStarPrediction(target, Q);
if (paddleStarPrediction.IsZero)
{
return;
}
Q.Cast(paddleStarPrediction);
}
else if (target.IsValidTarget(Q.Range + 150))
{
var pred = Q.GetPrediction(target, PaddleStarPosition, Global.Player.ServerPosition);
if (pred.CastPosition.IsZero)
{
return;
}
Q.Cast(pred.CastPosition);
}
}
public static void CastQ(Obj_AI_Base target, int minHit = -1)
{
if (minHit == -1)
{
Q.CastOnUnit(target);
}
else if (!Global.Player.IsDashing())
{
var rect = GetQRectangle(target);
if (Q.GetPrediction(target).HitChance >= HitChance.High && GameObjects.EnemyMinions.Count(x => x.IsValidTarget() && rect.IsInside(x.ServerPosition.To2D())) >= minHit)
{
Q.CastOnUnit(target);
}
}
}
public static void CastQ(Obj_AI_Base target, int minHit = 1)
{
if (Global.Player.Mana < Global.Player.GetSpell(SpellSlot.Q).Cost)
{
return;
}
if (target.IsValidTarget(Q.Range))
{
Q.Cast(target);
return;
}
foreach (var shadow in ShadowManager.Shadows)
{
if (minHit == 1)
{
Q.Cast(target.ServerPosition);
}
else
{
var pred = Q.GetPrediction(target, shadow.ServerPosition, shadow.ServerPosition);
var rect = new Geometry.Rectangle(shadow.ServerPosition.To2D(), pred.CastPosition.To2D(), Q.Width);
if (GameObjects.EnemyMinions.Count(x => rect.IsInside(x.ServerPosition.To2D())) >= minHit)
{
Q.Cast(pred.CastPosition);
}
}
}
}
/*Combo*/
private static void Combo()
{
var targetQ = TargetSelector.GetTarget(_q.Range);
if (targetQ != null)
{
if (Main["combo"]["q"].As <MenuBool>().Enabled&& _q.Ready)
{
if (IsQActive)
{
var prediction = _q.GetPrediction(targetQ, Velkoz.Position);
if (prediction.HitChance >= HitChance.Medium)
{
_q.Cast(prediction.CastPosition);
}
}
}
}
var targetW = TargetSelector.GetTarget(_w.Range);
if (targetW != null)
{
if (Main["combo"]["w"].As <MenuBool>().Enabled&& _w.Ready)
{
var prediction = _w.GetPrediction(targetW, Velkoz.Position);
if (prediction.HitChance >= HitChance.High)
{
_w.Cast(prediction.CastPosition);
}
}
}
var targetE = TargetSelector.GetTarget(_e.Range);
if (targetE != null)
{
if (Main["combo"]["e"].As <MenuBool>().Enabled&& _e.Ready)
{
var prediction = _e.GetPrediction(targetE, Velkoz.Position, targetE.Position);
if (prediction.HitChance >= HitChance.High)
{
_e.Cast(prediction.CastPosition);
}
}
}
}
public static Vector3 GeneratePaddleStarPrediction(Obj_AI_Base target, Spell spell)
{
if (PaddleStarPosition != Vector3.Zero)
{
return(Vector3.Zero);
}
var dir = target.Orientation.To2D();
var pos = target.ServerPosition + (target.ServerPosition - Global.Player.ServerPosition).Normalized();
for (var i = 0; i < 360; i += 10)
{
var angleRad = Maths.DegreeToRadian(i);
var rotated = (pos.To2D() + spell.Range * dir.Rotated((float)angleRad)).To3D();
var rectBefore = new Geometry.Rectangle(Global.Player.ServerPosition.To2D(), rotated.To2D(), Q.Width + target.BoundingRadius);
var rectAfter = new Geometry.Rectangle(rotated.To2D(), Q.GetPrediction(target).CastPosition.To2D(), Q.Width + target.BoundingRadius + 100);
if (GameObjects.Enemy.OrderBy(x => x.Distance(Global.Player)).
Where(x => x.NetworkId != target.NetworkId).
Any(x => x.MaxHealth > 20 && (rectAfter.IsInside(x.ServerPosition.To2D()) || rectBefore.IsInside(x.ServerPosition.To2D()))))
{
continue;
}
if (GameObjects.Jungle.OrderBy(x => x.Distance(Global.Player)).
Where(x => x.NetworkId != target.NetworkId).
Any(x => x.MaxHealth > 20 && (rectAfter.IsInside(x.ServerPosition.To2D()) || rectBefore.IsInside(x.ServerPosition.To2D()))))
{
continue;
}
if (rotated.Distance(target) < Global.Player.Distance(target) || rotated.Distance(Global.Player) > Q.Range + 200)
{
continue;
}
return(rotated);
}
return(Vector3.Zero);
}
public void OnGapcloser(object sender, Dash.DashArgs args)
{
if (Player.IsDead)
{
return;
}
var gapSender = (Obj_AI_Hero)args.Unit;
if (gapSender == null || !gapSender.IsEnemy)
{
return;
}
/// <summary>
/// The Anti-Gapcloser E.
/// </summary>
if (Q.Ready &&
Champions.Nami.MenuClass.miscmenu["antigapq"].Enabled)
{
var playerPos = Player.ServerPosition;
if (args.EndPos.Distance(playerPos) <= 200)
{
var prediction = Q.GetPrediction(gapSender);
Q.Cast(prediction.CastPosition);
}
else
{
var bestAlly = GameObjects.AllyHeroes
.Where(a =>
a.IsValidTarget(Q.Range, true) &&
args.EndPos.Distance(a.ServerPosition) <= 200)
.OrderBy(o => o.Distance(args.EndPos))
.FirstOrDefault();
if (bestAlly != null)
{
var prediction = Q.GetPrediction(gapSender);
Q.Cast(prediction.CastPosition);
}
}
}
}
private void Mixed()
{
var target = TargetSelector.GetTarget(Q.Range);
if (target == null)
{
return;
}
var prediction = Q.GetPrediction(target);
if (Menu["combo"]["useq"].Enabled && Q.Ready)
{
if (prediction.HitChance >= HitChance.High)
{
//Use CastPosition for circular skillshots
Q.Cast(prediction.CastPosition);
}
}
}
/*Combo*/
private static void Combo()
{
var target = TargetSelector.GetTarget(1500);
if (target != null)
{
if (Main["combo"]["w"].As <MenuBool>().Enabled&& _w.Ready && target.IsValidTarget(_w.Range))
{
if (GameObjects.EnemyHeroes.Count(t => t.IsValidTarget(_w.Width, false, true, _w.GetPrediction(target).CastPosition)) >= Main["combo"]["UnitsWhit"].As <MenuSlider>().Value)
{
_w.Cast(_w.GetPrediction(target).CastPosition);
}
}
}
if (Main["combo"]["q"].As <MenuBool>().Enabled&& _q.Ready && target.IsValidTarget(_q.Range))
{
if (GameObjects.EnemyHeroes.Count(t => t.IsValidTarget(_q.Width, false, true, _q.GetPrediction(target).CastPosition)) >= 1)
{
_q.Cast(_q.GetPrediction(target).CastPosition);
}
}
if (Main["combo"]["e"].As <MenuBool>().Enabled&& _e.Ready && target.IsValidTarget(_e.Range))
{
_e.CastOnUnit(target);
}
if (Main["combo"]["r"].As <MenuBool>().Enabled&& _r.Ready)
{
if (Swain.HasBuff("SwainMetamorphism") && Swain.CountEnemyHeroesInRange(800) == 0 && Main["combo"]["rClose"].As <MenuBool>().Enabled)
{
_r.Cast();
}
if (!Swain.HasBuff("SwainMetamorphism") && target.IsValidTarget(_r.Range))
{
_r.Cast();
}
}
}
public static void CastQ(Obj_AI_Base target, bool insec = false)
{
if (Barrel != null)
{
return;
}
if (insec)
{
Q.Cast(InsecManager.QInsecPos(target));
}
else if (Q.GetPrediction(target).HitChance >= HitChance.High)
{
Q.Cast(target);
}
}
//Extend the fizz ult for better accuracy
public static void CastRSmart(Obj_AI_Hero target)
{
if (Champions.Fizz.MenuClass.combormenu["onlyrkill"].Enabled)
{
if (!CanKillWithUltCombo(target))
{
return;
}
}
var castPosition = R.GetPrediction(target).UnitPosition;
castPosition = Player.ServerPosition.Extend(castPosition, R.Range);
R.Cast(castPosition);
}
/*Comob*/
private static void Combo()
{
var targetC = TargetSelector.GetTarget(_q.ChargedMaxRange - 100);
if (targetC == null)
{
return;
}
if (Main["combo"]["q"].As <MenuBool>().Enabled&& Main["combo"]["whiteListQ"]["qWhiteList" + targetC.ChampionName.ToLower()].As <MenuBool>().Enabled&& _q.Ready)
{
if ((Main["combo"]["qstcW"].As <MenuSliderBool>().Enabled&& Varus.Distance(targetC) < 750 && GetBuffCount(targetC) >= Main["combo"]["qstcW"].As <MenuSliderBool>().Value) || !Main["combo"]["qstcW"].As <MenuSliderBool>().Enabled || _q.ChargePercent >= 100 || targetC.Health <= QDamage(targetC) || Varus.Distance(targetC) > 800)
{
if (!_q.IsCharging && !IsPreAa)
{
_q.StartCharging(_q.GetPrediction(targetC).CastPosition); return;
}
if (!_q.IsCharging)
{
return;
}
if (Varus.Distance(targetC) < 750 && _q.ChargePercent >= 30 || Varus.Distance(targetC) > 750 && _q.ChargePercent >= 100)
{
var prediction = _q.GetPrediction(targetC);
if (prediction.HitChance >= HitChance.Medium)
{
_q.Cast(_q.GetPrediction(targetC).CastPosition);
}
}
}
}
if (!Main["combo"]["e"].As <MenuBool>().Enabled || !targetC.IsValidTarget(_e.Range) || !_e.Ready)
{
return;
}
if ((!Main["combo"]["eStcW"].As <MenuSliderBool>().Enabled || !(Varus.Distance(targetC) < 700) ||
GetBuffCount(targetC) < Main["combo"]["eStcW"].As <MenuSliderBool>().Value) && Main["combo"]["eStcW"].As <MenuSliderBool>().Enabled&& !(Varus.Distance(targetC) > 750))
{
return;
}
foreach (var enemy in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(_e.Range)))
{
if (enemy == null)
{
continue;
}
if (GameObjects.EnemyHeroes.Count(t => t.IsValidTarget(_e.Width, false, true, _e.GetPrediction(enemy).CastPosition)) >= Main["combo"]["UnitsEhit"].As <MenuSlider>().Value)
{
_e.Cast(targetC.Position);
}
}
}
public static bool IsSpellHeroCollision(Obj_AI_Base t, Spell ulti, int extraWith = 50)
{
foreach (var hero in GameObjects.EnemyHeroes.Where(hero => hero.IsValidTarget(ulti.Range + ulti.Width, false, false, ulti.From) && t.NetworkId != hero.NetworkId))
{
var prediction = ulti.GetPrediction(hero);
var powCalc = Math.Pow(ulti.Width + extraWith + hero.BoundingRadius, 2);
if (prediction.UnitPosition.To2D().Distance(Player.ServerPosition.To2D(), ulti.GetPrediction(t).CastPosition.To2D(), true, true) <= powCalc)
{
return(true);
}
if (prediction.UnitPosition.To2D().Distance(Player.ServerPosition.To2D(), t.ServerPosition.To2D(), true, true) <= powCalc)
{
return(true);
}
}
return(false);
}
private static void Combo()
{
foreach (var targetC in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(1000)))
{
if (targetC == null)
{
return;
}
switch (Main["combo"]["e"].As <MenuList>().Value)
{
case 0:
if (Veigar.CountEnemyHeroesInRange(800) >= Main["combo"]["UnitsEhit"].As <MenuSlider>().Value&& Main["combo"]["e2"].As <MenuBool>().Enabled&& _e.Ready)
{
if (GameObjects.EnemyHeroes.Count(t => t.IsValidTarget(_e2.Width, false, true,
_e2.GetPrediction(targetC).CastPosition)) >= Main["combo"]["UnitsEhit"].As <MenuSlider>().Value)
{
_e2.Cast(targetC.Position);
}
}
break;
case 1:
if (Veigar.Distance(targetC.Position) <= 900 && Main["combo"]["e2"].As <MenuBool>().Enabled&& _e.Ready)
{
CastE(targetC);
}
break;
case 2:
if (Veigar.Distance(targetC.Position) <= 900 && Main["combo"]["e2"].As <MenuBool>().Enabled&& _e.Ready)
{
CastE2(targetC);
}
break;
}
switch (Main["combo"]["w"].As <MenuList>().Value)
{
case 0:
var predW = _w.GetPrediction(targetC, Veigar.Position, targetC.Position);
if (targetC.IsInRange(_w.Range) && Main["combo"]["w2"].As <MenuBool>().Enabled&& _w.Ready)
{
if (predW.HitChance >= HitChance.VeryHigh)
{
_w.Cast(predW.CastPosition);
}
}
break;
case 1:
if (targetC.IsInRange(_w.Range) && Main["combo"]["w2"].As <MenuBool>().Enabled&& _w.Ready && TargetStun(targetC) >= _w.Delay)
{
_w.Cast(targetC.Position);
}
break;
}
if (Main["combo"]["q"].As <MenuBool>().Enabled&& _q.Ready && targetC.IsInRange(_q.Range))
{
var pred = _q.GetPrediction(targetC);
if (pred.HitChance >= HitChance.High && pred.CollisionObjects.Count == 0)
{
_q.Cast(pred.CastPosition);
}
}
if (Main["combo"]["rKillSteal"].As <MenuBool>().Enabled&& _r.Ready && targetC.IsValidTarget(_r.Range))
{
if (Veigar.GetSpellDamage(targetC, SpellSlot.R) > targetC.Health)
{
_r.CastOnUnit(targetC);
}
}
if (Main["combo"]["r"].As <MenuSliderBool>().Enabled&& !Main["combo"]["rKillSteal"].As <MenuBool>().Enabled&& _r.Ready && targetC.IsValidTarget(_r.Range))
{
if (targetC.HealthPercent() < Main["combo"]["r"].As <MenuSliderBool>().Value)
{
_r.CastOnUnit(targetC);
}
}
}
}
public static Geometry.Rectangle Q3Rect(Obj_AI_Base target)
{
return(new Geometry.Rectangle(Global.Player.ServerPosition.To2D(), Global.Player.ServerPosition.Extend(Q.GetPrediction(target).CastPosition, Q.Range).To2D(), Q.Width));
}
private void Combo()
{
var skillstarget = TargetSelector.GetTarget(E.Range);
//R logic
if (Champions.Rumble.MenuClass.combormenu["user"].Enabled && R.Ready)
{
var heroes = GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidSpellTarget(R.Range));
var heroPositions = heroes as Obj_AI_Hero[] ?? heroes.ToArray();
var positions = heroPositions.Select(x => x.ServerPosition).ToList();
var locations = new List <Vector3>();
UltResult maxhit = null;
locations.AddRange(positions);
var max = positions.Count;
for (var i = 0; i < max; i++)
{
for (var j = 0; j < max; j++)
{
if (positions[j] != positions[i])
{
locations.Add((positions[j] + positions[i]) / 5);
}
}
}
var results = new HashSet <UltResult>();
//Go through all targets within R range + length of rumble ult
foreach (var target in GameObjects.EnemyHeroes.Where(x => x.IsValidSpellTarget(R.Range) && !x.IsDead && Champions.Rumble.MenuClass.comboronmenu[x.ChampionName.ToLower()].Enabled))
{
foreach (var p in locations)
{
var rect = new Rectangle(target.Position, p, R.Width);
var count = heroPositions.Count(m => rect.Contains(m.Position));
results.Add(new UltResult(count, p, target));
}
}
//best endpoint
maxhit = results.MaxBy(x => x.NumberOfChampionsHit);
//Then ult
if (maxhit != null && maxhit.GetTarget != null && maxhit.NumberOfChampionsHit >= Champions.Rumble.MenuClass.combormenu["minenemies"].Value - 1) //-1 because initial target.
{
/*Render.Circle(maxhit.CastPosition, 30, 30, Color.Blue);
* Render.Circle(maxhit.GetTarget.Position, 30, 30, Color.Red);
* Render.Line(maxhit.CastPosition.ToScreenPosition(), maxhit.GetTarget.ServerPosition.ToScreenPosition(), Color.White);*/
R.Cast(maxhit.GetTarget.Position, maxhit.CastPosition);
}
}
//Q logic
if (Champions.Rumble.MenuClass.comboqmenu["useq"].Enabled && Q.Ready && skillstarget.IsValidTarget(Q.Range) /*&& Player.IsFacing(skillstarget)*/ && Player.Mana < 80)
{
Q.Cast();
}
//E logic
var prediction = E.GetPrediction(skillstarget);
if (Champions.Rumble.MenuClass.comboemenu["usee"].Enabled && E.Ready && skillstarget.IsValidTarget(E.Range) && (Player.Mana < 80))
{
if (prediction.HitChance >= HitChance.High)
{
E.Cast(prediction.UnitPosition);
}
}
//W logic
if (Champions.Rumble.MenuClass.combowmenu["usew"].Enabled && W.Ready && Player.CountEnemyHeroesInRange(1000) > Champions.Rumble.MenuClass.combowmenu["enemies"].Value && Player.HealthPercent() <= Champions.Rumble.MenuClass.combowmenu["health"].Value)
{
W.Cast();
}
}
private void Combo()
{
if (HumanForm)
{
if (E.Ready && Champions.Elise.MenuClass.combohumanmenu["humane"].Enabled)
{
foreach (Obj_AI_Hero target in GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidTarget(E.Range)))
{
var prediction = E.GetPrediction(target);
if (E.Ready && Champions.Elise.MenuClass.combomenuwhitelist["useeon" + target.ChampionName.ToLower()].Enabled && prediction.HitChance >= HitChance.High)
{
E.Cast(prediction.UnitPosition);
}
}
}
if (Q.Ready && Champions.Elise.MenuClass.combohumanmenu["humanq"].Enabled)
{
foreach (Obj_AI_Hero target in GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidTarget(Q.Range)))
{
Q.Cast(target);
}
}
if (W.Ready && Champions.Elise.MenuClass.combohumanmenu["humanw"].Enabled)
{
foreach (Obj_AI_Hero target in GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidTarget(Player.AttackRange)))
{
W.Cast(target);
}
}
if (!Q.Ready && !W.Ready && !E.Ready && R.Ready && Champions.Elise.MenuClass.combomenu["autor"].Enabled)
{
R.Cast();
}
}
if (SpiderForm)
{
if (WS.Ready && Champions.Elise.MenuClass.combospidermenu["spiderw"].Enabled)
{
foreach (Obj_AI_Hero target in GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidTarget(QS.Range)))
{
WS.Cast();
}
}
if (QS.Ready && Champions.Elise.MenuClass.combospidermenu["spiderq"].Enabled)
{
foreach (Obj_AI_Hero target in GameObjects.EnemyHeroes.Where(x => !x.IsDead && x.IsValidTarget(QS.Range)))
{
QS.Cast(target);
}
}
if (ES.Ready && Champions.Elise.MenuClass.combospidermenu["spidere"].Enabled)
{
foreach (var target in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(E.Range)))
{
if (Player.Distance(target) <= ES.Range && Player.Distance(target) > QS.Range &&
Champions.Elise.MenuClass.combospidermenu["spidere"].Enabled && ES.Ready)
{
E.Cast(target);
}
if (Player.Distance(target) <= ES.Range && Player.Distance(target) > QS.Range &&
Champions.Elise.MenuClass.combospidermenu["spidere"].Enabled && ES.Ready && Player.CountAllyHeroesInRange(E.Range) == 1 && target.HealthPercent() < 5)
{
E.Cast(target);
}
}
}
if (!QS.Ready && !WS.Ready && R.Ready && Champions.Elise.MenuClass.combomenu["autor"].Enabled)
{
R.Cast();
}
}
}
private void Combo()
{
var target = TargetSelector.GetTarget(Q.Range);
if (target == null || !target.IsValidTarget())
{
return;
}
if (mini)
{
if (Q.Ready && Champions.Gnar.MenuClass.combominimenu["miniq"].Enabled)
{
var prediction = Q.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
Q.Cast(prediction.UnitPosition);
}
}
}
else //mega
{
//R
if (target != null && R.Ready && Champions.Gnar.MenuClass.comborwhitelist[target.ChampionName.ToLower()].Enabled && Champions.Gnar.MenuClass.combomegamenu["megar"].Enabled && !target.HasBuffOfType(BuffType.Stun))
{
var prediction = R.GetPrediction(target); //We're not actually going to use this though really. Slows things down.
var maxAngle = 180f;
var step = maxAngle / 24f;
var currentAngle = 0f;
var currentStep = 0f;
var direction = (Player.ServerPosition - prediction.UnitPosition).Normalized();
//Go through angles
while (true)
{
//If no good angle then stop trying to find one
if (currentStep > maxAngle && currentAngle < 0)
{
break;
}
//Go through angles...
if ((currentAngle == 0 || currentAngle < 0) && currentStep != 0)
{
currentAngle = (currentStep) * (float)Math.PI / 180;
currentStep += step;
}
else if (currentAngle > 0)
{
currentAngle = -currentAngle;
}
Vector3 checkPoint;
//Check direct line
if (currentStep == 0)
{
currentStep = step;
checkPoint = prediction.UnitPosition + 500 * direction;
}
//Check via angles
else
{
checkPoint = prediction.UnitPosition + 500 * direction.To2D().Rotated(currentAngle).To3D();
Render.Circle(Player.Position + 500 * (checkPoint - prediction.UnitPosition).Normalized(), 50, 30, Color.Red);
}
//Is wall or building?
if (NavMesh.WorldToCell(checkPoint).Flags.HasFlag(NavCellFlags.Wall | NavCellFlags.Building))
{
//Cast ult in that direction
if (prediction.HitChance >= HitChance.High)
{
Render.Circle(Player.Position + 500 * (checkPoint - prediction.UnitPosition).Normalized(), 50, 30, Color.LightGreen);
R.Cast(Player.Position + 500 * (checkPoint - prediction.UnitPosition).Normalized());
}
break;
}
}
}
//W
if (Wmega.Ready && Champions.Gnar.MenuClass.combomegamenu["megaw"].Enabled)
{
if (target != null || target.HasBuffOfType(BuffType.Stun))
{
var prediction = Wmega.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
Wmega.Cast(prediction.CastPosition);
}
}
}
//E
if (Emega.Ready && Champions.Gnar.MenuClass.combomegamenu["megae"].Enabled)
{
if (target != null)
{
var prediction = Emega.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
Emega.Cast(prediction.CastPosition);
}
}
}
//Q
if (Qmega.Ready && Champions.Gnar.MenuClass.combomegamenu["megaq"].Enabled)
{
if (target != null)
{
var prediction = Qmega.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
Qmega.Cast(prediction.UnitPosition);
}
}
}
}
}
private void Combo()
{
var target = TargetSelector.GetTarget(E.Range);
if (target == null || !target.IsValidTarget())
{
return;
}
if (Champions.KhaZix.MenuClass.assassinmenutargets[target.ChampionName.ToLower()].Enabled && Champions.KhaZix.MenuClass.combomenu["usee"].Enabled && Champions.KhaZix.MenuClass.combomenu["useq"].Enabled)
{
//Console.WriteLine(Game.ClockTime + " assassin combo");
//Look for reset!
var JumpPoint1 = GetDoubleJumpPoint(target, true);
E.Cast(JumpPoint1.To2D());
Q.Cast(target);
if (Champions.KhaZix.MenuClass.combomenu["usew"].Enabled && W.Ready)
{
var prediction = W.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
W.Cast(prediction.UnitPosition);
}
}
DelayAction.Queue(Game.Ping + 200, () =>
{
if (E.Ready && !isMidAir)
{
//2nd jump
var Jumppoint2 = GetDoubleJumpPoint(target, false);
if (Jumppoint2 != null && Jumppoint2.X != 0 && Jumppoint2.Y != 0)
{
E.Cast(Jumppoint2.To2D());
}
}
});
}
else
{
//Console.WriteLine(Game.ClockTime + " standard combo");
//STANDARD COMBO
/*if (Champions.KhaZix.MenuClass.combomenu["user"].Enabled && Player.CountEnemyHeroesInRange(E.Range) >= Champions.KhaZix.MenuClass.combomenu["minenemies"].Value)
* {
* R.Cast();
* }*/
if (Champions.KhaZix.MenuClass.combomenu["usee"].Enabled && E.Ready && !target.IsInRange(Q.Range) && !isMidAir)
{
if (target.IsUnderEnemyTurret() /* && MENU CHECK FOR DONT E UNDER TURRET*/)
{
return;
}
E.Cast(target.Position);
}
if (Champions.KhaZix.MenuClass.combomenu["useq"].Enabled && Q.Ready && !isMidAir)
{
Q.CastOnUnit(target);
}
/* DO HYDRA MID AIR? here*/
if (Champions.KhaZix.MenuClass.combomenu["usew"].Enabled && W.Ready)
{
var prediction = W.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
W.Cast(prediction.UnitPosition);
}
}
/* DO ITEM SUPPORT HERE*/
}
}
public static Result GetCircleAoePrediction(this Spell spell, Obj_AI_Hero target, HitChance hitChance,
bool boundingRadius = true, bool extended = true, Vector3?sourcePosition = null)
{
try
{
if (spell == null || target == null)
{
return(new Result(Vector3.Zero, new List <Obj_AI_Hero>()));
}
var fromPosition = sourcePosition ?? ObjectManager.GetLocalPlayer().ServerPosition;
var hits = new List <Obj_AI_Hero>();
var center = Vector3.Zero;
var radius = float.MaxValue;
var range = spell.Range + (extended ? spell.Width * 0.85f : 0) +
(boundingRadius ? target.BoundingRadius * BoundingRadiusMultiplicator : 0);
var positions = (from t in GameObjects.EnemyHeroes
where t.IsValidTarget(range * 1.5f, false, false, fromPosition)
let prediction = spell.GetPrediction(t)
where prediction.HitChance >= hitChance
select new Position(t, prediction.UnitPosition)).ToList();
var spellWidth = spell.Width;
if (positions.Any())
{
var mainTarget = positions.FirstOrDefault(p => p.Hero.NetworkId == target.NetworkId);
var possibilities =
ProduceEnumeration(
positions.Where(
p => p.UnitPosition.Distance(mainTarget.UnitPosition) <= spell.Width * 0.85f).ToList())
.Where(p => p.Count > 0 && p.Any(t => t.Hero.NetworkId == mainTarget.Hero.NetworkId))
.ToList();
foreach (var possibility in possibilities)
{
var mec = Mec.GetMec(possibility.Select(p => p.UnitPosition.To2D()).ToList());
var distance = spell.From.Distance(mec.Center.To3D());
if (mec.Radius < spellWidth && distance < range)
{
var lHits = new List <Obj_AI_Hero>();
var circle =
new MyPolygon.Circle(
spell.From.Extend(
mec.Center.To3D(), spell.Range > distance ? distance : spell.Range), spell.Width);
if (boundingRadius)
{
lHits.AddRange(
from position in positions
where
new MyPolygon.Circle(
position.UnitPosition,
position.Hero.BoundingRadius * BoundingRadiusMultiplicator).Points.Any(
p => circle.IsInside(p))
select position.Hero);
}
else
{
lHits.AddRange(
from position in positions
where circle.IsInside(position.UnitPosition)
select position.Hero);
}
if ((lHits.Count > hits.Count || lHits.Count == hits.Count && mec.Radius < radius ||
lHits.Count == hits.Count &&
spell.From.Distance(circle.Center.To3D()) < spell.From.Distance(center)) &&
lHits.Any(p => p.NetworkId == target.NetworkId))
{
center = To3D2(circle.Center);
radius = mec.Radius;
hits.Clear();
hits.AddRange(lHits);
}
}
}
if (!center.Equals(Vector3.Zero))
{
return(new Result(center, hits));
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(new Result(Vector3.Zero, new List <Obj_AI_Hero>()));
}
private void Combo()
{
//Store boolean value of menu items
bool useQ = Menu["combo"]["useq"].Enabled;
bool useE = Menu["combo"]["usee"].Enabled;
bool useR = Menu["combo"]["user"].Enabled;
var rAOE = Menu["combo"]["rAOE"].As <MenuSliderBool>().Value;
var target = TargetSelector.GetTarget(Q.Range);
//Q logic
if (target != null && useQ && Q.Ready && Menu["combo"]["useqon" + target.ChampionName.ToLower()].Enabled && target.IsValidTarget(Q.Range))
{
var prediction = Q.GetPrediction(target);
//Draw prediction
if (Menu["draw"]["drawPrediction"].Enabled)
{
Render.WorldToScreen(Player.Position, out Vector2 playerScreenPos);
Color lineColour;
switch (prediction.HitChance)
{
case HitChance.Collision:
lineColour = Color.Red;
break;
case HitChance.Impossible:
lineColour = Color.Orange;
break;
case HitChance.Medium:
lineColour = Color.Orange;
break;
case HitChance.High:
lineColour = Color.LightGreen;
break;
default:
lineColour = Color.Red;
return;
}
Render.WorldToScreen(prediction.UnitPosition, out Vector2 predictionSreenPos);
Render.Line(playerScreenPos, predictionSreenPos, lineColour);
}
//If prediction high chance -> Q
HitChance slider = HitChance.High;
switch (Menu["combo"]["predictionSlider"].Value)
{
case 1:
slider = HitChance.Impossible;
break;
case 2:
slider = HitChance.Low;
break;
case 3:
slider = HitChance.Medium;
break;
case 4:
slider = HitChance.High;
break;
}
//if (prediction.HitChance >= HitChance.High)
if (prediction.HitChance >= slider)
{
Q.Cast(prediction.UnitPosition);
}
}
//E logic - Avoid using E on already knocked up target
if (useE && E.Ready && target.IsValidTarget(E.Range) && !target.HasBuffOfType(BuffType.Knockup))
{
E.Cast();
}
//R logic - Use R for AOE
if (useR && R.Ready && target.IsValidTarget(R.Range) && Player.CountEnemyHeroesInRange(R.Range) >= rAOE)
{
R.Cast();
}
}
private void Combo()
{
var target = TargetSelector.GetTarget(1200);
if (target == null)
{
return;
}
#region COUGAR COMBO
//COUGAR COMBO
if (cougarForm && target.IsValidTarget(Q.Range))
{
//Check if Cougar Q ready
if (CQ == 0 && Champions.Nidalee.MenuClass.combocatmenu["useq"].Enabled && target.IsInRange(catQ.Range))
{
catQ.CastOnUnit(Player);
}
//Check if pounce is ready
if ((CW == 0 || catW.Ready) && Champions.Nidalee.MenuClass.combocatmenu["usew"].Enabled && (target.Distance(Player.ServerPosition) <= 750 || CougarDamage(target) >= target.Health))
{
//Check if pounce target is marked
if (TargetHunted(target) & target.Distance(Player.ServerPosition) <= 750)
{
catW.Cast(target.ServerPosition);
}
else if (target.Distance(Player.ServerPosition) <= 400)
{
catW.Cast(target.ServerPosition);
}
}
//Check if swipe is ready
if ((CE == 0 || catE.Ready) && Champions.Nidalee.MenuClass.combocatmenu["usee"].Enabled)
{
if (target.IsInRange(catE.Range))
{
if (!catW.Ready || Player.SpellBook.CanUseSpell(catW.Slot) == false) //i.e. not learned
{
catE.Cast(target.ServerPosition);
}
}
}
//FORCE TRANSFORM if Q ready + no collision
if ((HQ == 0 && Champions.Nidalee.MenuClass.combomenu["user"].Enabled))
{
if (!R.Ready)
{
return;
}
//or stay cougar if we can kill with spells
if (target.Health <= CougarDamage(target) && target.IsInRange(catW.Range))
{
return;
}
var prediction = Q.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
R.Cast();
}
}
//Switch to human form if can kill in aa && cougar skills not available
if ((CW != 0 || !catW.Ready) && (CE != 0 || !catE.Ready) && (CQ != 0 || !catQ.Ready))
{
if (target.Distance(Player) > catQ.Range && CanKillAA(target))
{
if (Champions.Nidalee.MenuClass.combomenu["user"].Enabled && target.Distance(Player) <= Math.Pow(Player.AttackRange + 50, 2))
{
if (R.Ready)
{
R.Cast();
}
}
}
}
}
#endregion
#region Human combo
//HUMAN COMBO
if (!cougarForm && target.IsValidTarget(Q.Range))
{
var qtarget = TargetSelector.GetTarget(Q.Range);
if ((HQ == 0 || Q.Ready) && Champions.Nidalee.MenuClass.combohumanmenu["useq"].Enabled)
{
var prediction = Q.GetPrediction(qtarget);
if (prediction.HitChance >= HitChance.High)
{
Q.Cast(prediction.UnitPosition);
}
}
}
if (!cougarForm && target.IsValidTarget(Q.Range))
{
//Switch to cat if target marked or can kill
if (R.Ready && Champions.Nidalee.MenuClass.combomenu["user"].Enabled && (TargetHunted(target) || target.Health <= CougarDamage(target) && !Q.Ready))
{
if ((CW == 0 || catW.Ready) && (CQ == 0 || CE == 0))
{
if (TargetHunted(target) && target.Distance(Player.ServerPosition) <= 750)
{
R.Cast();
}
if (target.Health <= CougarDamage(target) && target.Distance(Player.ServerPosition) <= 350)
{
R.Cast();
}
}
}
//Check bushwack and cast
if ((HW == 0 || W.Ready) && Champions.Nidalee.MenuClass.combohumanmenu["usew"].Enabled && target.IsInRange(W.Range))
{
var prediction = W.GetPrediction(target);
if (prediction.HitChance >= HitChance.High)
{
W.Cast(prediction.CastPosition);
}
}
}
#endregion
}
public static FarmPosition GetCircleFarmPosition(Aimtec.SDK.Spell spell, IEnumerable <Obj_AI_Base> minionList,
bool addBoundRadius = true, float extraRange = 0, Vector3?source = null)
{
if (ObjectManager.GetLocalPlayer().SpellBook.GetSpell(spell.Slot).Level == 0 ||
!ObjectManager.GetLocalPlayer().SpellBook.CanUseSpell(spell.Slot))
{
return(new FarmPosition());
}
var range = spell.Range + extraRange;
var sourcePosition = source?.To2D() ?? ObjectManager.GetLocalPlayer().ServerPosition.To2D();
var minions =
minionList.Where(
x =>
x.ServerPosition.DistanceSquared(sourcePosition) <=
(range + (addBoundRadius ? x.BoundingRadius : 0)) *
(range + (addBoundRadius ? x.BoundingRadius : 0))).ToArray();
if (minions.Length == 0)
{
return(new FarmPosition());
}
if (minions.Length == 1)
{
return(new FarmPosition
{
CastPosition = spell.GetPrediction(minions[0]).UnitPosition,
HitCount = 1
});
}
var positionList = new List <Vector2>();
positionList.AddRange(minions.Where(x => !x.IsDead).Select(x => x.ServerPosition.To2D()));
var resultPos = Vector2.Zero;
var hitCount = 0;
foreach (var pos in positionList.Where(p => p.DistanceSquared(sourcePosition) <= range * range))
{
var count =
minions.Where(
x =>
x.IsValidTarget() &&
x.ServerPosition.To2D().DistanceSquared(sourcePosition) <=
(range + (addBoundRadius ? x.BoundingRadius : 0)) *
(range + (addBoundRadius ? x.BoundingRadius : 0)))
.Count(x => x.ServerPosition.DistanceSquared(pos) <= spell.Width * spell.Width);
if (count >= hitCount)
{
resultPos = pos;
hitCount = count;
}
}
return(new FarmPosition
{
CastPosition = resultPos.To3D(),
HitCount = hitCount
});
}