public static void Muramana(Obj_AI_Hero target, bool activate, float overrideRange = -1f)
{
try
{
var hasBuff = ObjectManager.Player.HasBuff("Muramana");
if ((activate && !hasBuff &&
(_menu == null ||
_menu.Item(_menu.Name + ".muramana.combo").GetValue <bool>() &&
ObjectManager.Player.CountEnemiesInRange(
overrideRange > 0 ? overrideRange : Orbwalking.GetRealAutoAttackRange(ObjectManager.Player)) >=
_menu.Item(_menu.Name + ".muramana.min-enemies-range").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent <=
_menu.Item(_menu.Name + ".muramana.player-health-below").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent >=
_menu.Item(_menu.Name + ".muramana.player-health-above").GetValue <Slider>().Value&&
(target == null ||
target.HealthPercent <=
_menu.Item(_menu.Name + ".muramana.target-health-below").GetValue <Slider>().Value&&
target.HealthPercent >=
_menu.Item(_menu.Name + ".muramana.target-health-above").GetValue <Slider>().Value))) ||
!activate && hasBuff)
{
var muramana = ItemData.Muramana.GetItem();
if (muramana.IsOwned(ObjectManager.Player))
{
muramana.Cast();
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnCoreBoot(EventArgs args)
{
try
{
OnLoad();
SetupSpells();
SetupMenu();
Weights.Range = Math.Max(
Weights.Range,
Spells.Select(e => e.Range).DefaultIfEmpty(Orbwalking.GetRealAutoAttackRange(null) * 1.2f).Max());
Core.OnPreUpdate += OnCorePreUpdate;
Core.OnPostUpdate += OnCorePostUpdate;
Orbwalking.BeforeAttack += OnOrbwalkingBeforeAttack;
Orbwalking.AfterAttack += OnOrbwalkingAfterAttack;
Obj_AI_Base.OnProcessSpellCast += OnObjAiBaseProcessSpellCast;
Drawing.OnDraw += OnDrawingDraw;
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
protected override void Killsteal()
{
if (Menu.Item(Menu.Name + ".killsteal.q-aa").GetValue <bool>() && Q.IsReady())
{
var target =
GameObjects.EnemyHeroes.FirstOrDefault(t => t.IsValidTarget() && Orbwalking.InAutoAttackRange(t));
if (target != null)
{
var damage = CalcPassiveDamage(target) + Q.GetDamage(target);
if (damage - 10 > target.Health)
{
Casting.TargetSkill(target, Q);
Orbwalker.ForceTarget(target);
}
}
}
if (Menu.Item(Menu.Name + ".killsteal.e").GetValue <bool>() && E.IsReady())
{
foreach (var target in
GameObjects.EnemyHeroes.Where(t => t.IsValidTarget() && t.Distance(Player) < MaxERange))
{
var damage = E.GetDamage(target);
if (damage - 10 > target.Health)
{
if (ELogic(target, GameObjects.EnemyHeroes.ToList(), E.GetHitChance("combo")))
{
break;
}
}
}
}
}
protected override void Harass()
{
if (ResourceManager.Check("harass"))
{
var useQ = Menu.Item(Menu.Name + ".harass.q").GetValue <bool>() && Q.IsReady();
var useW = Menu.Item(Menu.Name + ".harass.w").GetValue <bool>() && W.IsReady();
if (useQ)
{
Casting.SkillShot(Q, Q.GetHitChance("harass"));
}
if (useW)
{
WLogic();
}
}
if (ResourceManager.Check("harass-r"))
{
var useR = Menu.Item(Menu.Name + ".harass.r").GetValue <bool>() && R.IsReady();
if (useR && Menu.Item(Menu.Name + ".miscellaneous.r-max").GetValue <Slider>().Value > GetRBuffCount())
{
var target = TargetSelector.GetTarget(R);
if (target != null &&
(Player.FlatMagicDamageMod > 50 ||
!GameObjects.Enemy.Any(e => e.IsValidTarget() && Orbwalking.InAutoAttackRange(e))))
{
Casting.SkillShot(R, R.GetHitChance("harass"));
}
}
}
}
public IOrderedEnumerable <Obj_AI_Base> GetDashObjects()
{
try
{
var objects =
GameObjects.EnemyMinions.Concat(GameObjects.Jungle)
.Where(o => o.IsValidTarget(Orbwalking.GetRealAutoAttackRange(o)))
.Select(o => o as Obj_AI_Base)
.ToList();
var apexPoint = Player.ServerPosition.To2D() +
(Player.ServerPosition.To2D() - Game.CursorPos.To2D()).Normalized() *
Orbwalking.GetRealAutoAttackRange(Player);
return
(objects.Where(
o =>
Utils.IsLyingInCone(
o.ServerPosition.To2D(), apexPoint, Player.ServerPosition.To2D(), Math.PI))
.OrderBy(o => o.Distance(apexPoint, true)));
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(null);
}
protected override void OnPostUpdate()
{
if (UltimateManager.Assisted() && R.IsReady())
{
if (Menu.Item(Menu.Name + ".ultimate.assisted.move-cursor").GetValue <bool>())
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
if (
!RLogic(
TargetSelector.GetTarget(R),
Menu.Item(Menu.Name + ".ultimate.assisted.min").GetValue <Slider>().Value,
Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady()))
{
RLogicSingle(Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady());
}
}
if (UltimateManager.Auto() && R.IsReady())
{
if (
!RLogic(
TargetSelector.GetTarget(R),
Menu.Item(Menu.Name + ".ultimate.auto.min").GetValue <Slider>().Value,
Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady(), UltimateModeType.Auto))
{
RLogicSingle(Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady());
}
}
}
protected override void Flee()
{
if (Menu.Item(Menu.Name + ".flee.w").GetValue <bool>())
{
if (W.IsReady() || Cards.Status == SelectStatus.Ready)
{
var target = TargetSelector.GetTarget(W, false);
if (target != null)
{
var best = GetBestCard(target, "flee");
if (best.Any())
{
Cards.Select(best);
Orbwalker.ForceTarget(target);
}
}
}
if (Player.CanAttack && (Cards.Has(CardColor.Red) || Cards.Has(CardColor.Gold)))
{
var target =
GameObjects.EnemyHeroes.Where(e => Orbwalking.InAutoAttackRange(e) && e.IsValidTarget())
.OrderBy(e => e.Distance(Player))
.FirstOrDefault();
if (target != null)
{
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
}
void IChampion.Flee()
{
try
{
Orbwalker.SetAttack(false);
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
Flee();
Utility.DelayAction.Add(
750, delegate
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Flee)
{
ItemManager.UseFleeItems();
}
});
Utility.DelayAction.Add(
125, delegate
{
if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Flee)
{
Orbwalker.SetAttack(true);
}
});
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingAfterAttack(AttackableUnit unit, AttackableUnit target)
{
try
{
if (unit.IsMe && W.IsReady())
{
var useW = false;
var wMin = 0;
var laneclear = false;
var jungleClear = false;
switch (Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
useW = Menu.Item(Menu.Name + ".combo.w").GetValue <bool>();
break;
case Orbwalking.OrbwalkingMode.Mixed:
useW = Menu.Item(Menu.Name + ".harass.w").GetValue <bool>();
break;
case Orbwalking.OrbwalkingMode.LaneClear:
useW = Menu.Item(Menu.Name + ".lane-clear.w").GetValue <bool>();
wMin = target.Team != GameObjectTeam.Neutral
? Menu.Item(Menu.Name + ".lane-clear.w-min").GetValue <Slider>().Value
: 1;
laneclear = true;
jungleClear = target.Team == GameObjectTeam.Neutral;
break;
}
if (useW &&
(!laneclear ||
(jungleClear
? (ResourceManager.Check("lane-clear-w") || ResourceManager.IgnoreJungle("lane-clear-w"))
: ResourceManager.Check("lane-clear-w"))))
{
var range = W.Range + Player.BoundingRadius * 2f;
var targets = laneclear
? MinionManager.GetMinions(range + 450, MinionTypes.All, MinionTeam.NotAlly)
: GameObjects.EnemyHeroes.Where(e => e.IsValidTarget(range + 450))
.Cast <Obj_AI_Base>()
.ToList();
if (targets.Count >= wMin && targets.Any(Orbwalking.InAutoAttackRange) &&
(wMin == 0 ||
targets.Any(
t =>
Orbwalking.InAutoAttackRange(t) &&
targets.Any(t2 => t2.NetworkId != t.NetworkId && t2.Distance(t) <= 450))))
{
W.Cast();
Orbwalking.ResetAutoAttackTimer();
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (sender.IsMe)
{
if (args.SData.Name == "KalistaExpungeWrapper")
{
Orbwalking.ResetAutoAttackTimer();
}
}
if (!sender.IsEnemy || SoulBound.Unit == null || R.Level == 0 ||
!Menu.Item(Menu.Name + ".ultimate.save").GetValue <bool>())
{
return;
}
if (args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId &&
(!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()))
{
SoulBound.Add(
SoulBound.Unit.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed +
Game.Time, (float)sender.GetAutoAttackDamage(SoulBound.Unit));
}
else
{
var hero = sender as Obj_AI_Hero;
if (hero != null)
{
var slot = hero.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
var damage = 0f;
if (args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId &&
slot == hero.GetSpellSlot("SummonerDot"))
{
damage =
(float)hero.GetSummonerSpellDamage(SoulBound.Unit, Damage.SummonerSpell.Ignite);
}
else if ((slot == SpellSlot.Q || slot == SpellSlot.W || slot == SpellSlot.E ||
slot == SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId) ||
args.End.Distance(SoulBound.Unit.ServerPosition, true) <
Math.Pow(args.SData.LineWidth, 2)))
{
damage = (float)hero.GetSpellDamage(SoulBound.Unit, slot);
}
if (damage > 0)
{
SoulBound.Add(Game.Time + 2, damage);
}
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
protected override void Flee()
{
Orbwalker.SetAttack(true);
var dashObjects = GetDashObjects();
if (dashObjects != null && dashObjects.Any())
{
Orbwalking.Orbwalk(dashObjects.First(), Game.CursorPos);
}
}
protected override void Combo()
{
var q = Menu.Item(Menu.Name + ".combo.q").GetValue <bool>();
var e = Menu.Item(Menu.Name + ".combo.e").GetValue <bool>();
var r = _ultimate.IsActive(UltimateModeType.Combo);
if (e && !Q.IsCharging && E.IsReady())
{
var target = TargetSelector.GetTarget(E);
if (target != null)
{
var stacks = W.Level == 0 &&
Menu.Item(Menu.Name + ".combo.e-settings.stacks").GetValue <Slider>().Value > 0;
if (Menu.Item(Menu.Name + ".combo.e-settings.always").GetValue <bool>() || stacks ||
GetWStacks(target) >= Menu.Item(Menu.Name + ".combo.e-settings.stacks").GetValue <Slider>().Value ||
E.IsKillable(target) ||
CPrediction.Circle(E, target, E.GetHitChance("combo")).TotalHits >=
Menu.Item(Menu.Name + ".combo.e-settings.min").GetValue <Slider>().Value)
{
ELogic(target, E.GetHitChance("combo"));
}
}
}
if (q && Q.IsReady())
{
var target = TargetSelector.GetTarget((Q.ChargedMaxRange + Q.Width) * 1.1f, Q.DamageType);
if (target != null)
{
var stacks = W.Level == 0 &&
Menu.Item(Menu.Name + ".combo.q-settings.stacks").GetValue <Slider>().Value > 0;
if (Q.IsCharging || Menu.Item(Menu.Name + ".combo.q-settings.always").GetValue <bool>() ||
target.Distance(Player) > Orbwalking.GetRealAutoAttackRange(target) * 1.2f || stacks ||
GetWStacks(target) >= Menu.Item(Menu.Name + ".combo.q-settings.stacks").GetValue <Slider>().Value ||
CPrediction.Line(Q, target, Q.GetHitChance("combo")).TotalHits >=
Menu.Item(Menu.Name + ".combo.q-settings.min").GetValue <Slider>().Value || Q.IsKillable(target))
{
QLogic(
target, Q.GetHitChance("combo"),
Menu.Item(Menu.Name + ".combo.q-settings.fast-cast-min").GetValue <Slider>().Value);
}
}
}
if (r && R.IsReady())
{
var target = TargetSelector.GetTarget(R);
if (target != null)
{
if (!RLogic(UltimateModeType.Combo, R.GetHitChance("combo"), target))
{
RLogicSingle(UltimateModeType.Combo, R.GetHitChance("combo"));
}
}
}
}
private float CalcComboDamage(Obj_AI_Hero target, float resMulti, bool rangeCheck, bool q, bool e, bool r)
{
try
{
if (target == null)
{
return(0);
}
float damage = 0;
var totalMana = 0f;
if (r && R.IsReady() && (!rangeCheck || R.IsInRange(target)))
{
var rMana = R.ManaCost * resMulti;
if (totalMana + rMana <= Player.Mana)
{
totalMana += rMana;
damage += R.GetDamage(target);
}
}
if (q && Q.IsReady() && (!rangeCheck || Q.IsInRange(target, Q.ChargedMaxRange)))
{
var qMana = Q.ManaCost * resMulti;
if (totalMana + qMana <= Player.Mana)
{
totalMana += qMana;
damage += GetQDamage(target, 1);
}
}
if (e && E.IsReady() && (!rangeCheck || E.IsInRange(target, E.Range + E.Width)))
{
var eMana = E.ManaCost * resMulti;
if (totalMana + eMana <= Player.Mana)
{
damage += E.GetDamage(target);
}
}
if (!rangeCheck || Orbwalking.InAutoAttackRange(target))
{
damage += 5f * (float)Player.GetAutoAttackDamage(target);
}
damage += ItemManager.CalculateComboDamage(target, rangeCheck);
damage += SummonerManager.CalculateComboDamage(target, rangeCheck);
return(damage);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(0);
}
/// <summary>
/// Gets fishbones range based on level
/// </summary>
/// <returns></returns>
private float GetFishbonesRange()
{
try
{
var level = Q.Level;
return(550 + 25 * level);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(Orbwalking.GetRealAutoAttackRange(null));
}
protected override void OnPostUpdate()
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit && !Player.IsWindingUp &&
Menu.Item(Menu.Name + ".lasthit.q").GetValue <bool>() && Q.IsReady())
{
var m =
MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly)
.FirstOrDefault(
e =>
e.HealthPercent <= 75 &&
(_lastAaMinion == null || e.NetworkId != _lastAaMinion.NetworkId ||
Game.Time > _lastAaMinionEndTime) &&
HealthPrediction.GetHealthPrediction(e, (int)(Q.Delay * 1000f)) < Q.GetDamage(e));
if (m != null)
{
Casting.TargetSkill(m, Q);
}
}
if (_ultimate.IsActive(UltimateModeType.Assisted) && R.IsReady())
{
if (_ultimate.ShouldMove(UltimateModeType.Assisted))
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
var target = TargetSelector.GetTarget(R);
if (target != null && !RLogic(UltimateModeType.Assisted, target))
{
RLogicSingle(UltimateModeType.Assisted);
}
}
if (_ultimate.IsActive(UltimateModeType.Auto) && R.IsReady())
{
var target = TargetSelector.GetTarget(R);
if (target != null && !RLogic(UltimateModeType.Auto, target))
{
RLogicSingle(UltimateModeType.Auto);
}
}
if (Menu.Item(Menu.Name + ".miscellaneous.e-auto").GetValue <bool>() && E.IsReady() &&
ResourceManager.Check("auto-e") && !Player.IsRecalling() && !Player.InFountain())
{
var buff = GetEBuff();
if (buff == null || (buff.EndTime - Game.Time) <= Game.Ping / 2000f + 0.5f)
{
E.Cast();
}
}
}
protected override void Killsteal()
{
if (Menu.Item(Menu.Name + ".killsteal.q").GetValue <bool>() && Q.IsReady())
{
var killable =
GameObjects.EnemyHeroes.FirstOrDefault(
e =>
e.IsValidTarget(Q.Range) && !Orbwalking.InAutoAttackRange(e) &&
(QIsKillable(e, 1) || QMaxRangeHit(e) && QIsKillable(e, 2)));
if (killable != null)
{
QLogic(killable, HitChance.High, 100);
}
}
}
protected override void Killsteal()
{
if (Menu.Item(Menu.Name + ".killsteal.r").GetValue <bool>() && R.IsReady())
{
var fPredEnemy =
GameObjects.EnemyHeroes.Where(
e => e.IsValidTarget(R.Range) && !Orbwalking.InAutoAttackRange(e) && R.IsKillable(e))
.Select(enemy => R.GetPrediction(enemy, true))
.FirstOrDefault(pred => pred.Hitchance >= HitChance.High);
if (fPredEnemy != null)
{
R.Cast(fPredEnemy.CastPosition);
}
}
}
protected override void Combo()
{
var useQ = Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady();
var useW = Menu.Item(Menu.Name + ".combo.w").GetValue <bool>() && W.IsReady();
var useE = Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady();
var useR = UltimateManager.Combo() && R.IsReady();
if (useQ)
{
Casting.SkillShot(Q, Q.GetHitChance("combo"));
}
if (useW)
{
var target = TargetSelector.GetTarget(W);
var best = CPrediction.Circle(W, target, W.GetHitChance("combo"));
if (best.TotalHits > 0 && !best.CastPosition.Equals(Vector3.Zero))
{
W.Cast(best.CastPosition);
}
}
if (useE)
{
var target = TargetSelector.GetTarget((E.Range + Player.AttackRange) * 0.9f, E.DamageType);
if (target != null)
{
var pos = Player.Position.Extend(Game.CursorPos, E.Range);
if (!pos.UnderTurret(true))
{
E.Cast(pos);
}
}
}
if (useR)
{
var target = TargetSelector.GetTarget(R);
if (target != null && Orbwalking.InAutoAttackRange(target))
{
if (!RLogic(target, Menu.Item(Menu.Name + ".ultimate.combo.min").GetValue <Slider>().Value, useQ))
{
if (Menu.Item(Menu.Name + ".ultimate.combo.single").GetValue <bool>())
{
RLogicSingle(useQ);
}
}
}
}
}
protected override void Harass()
{
if (!ResourceManager.Check("harass") && !Q.IsCharging)
{
return;
}
if (Menu.Item(Menu.Name + ".harass.e").GetValue <bool>() && !Q.IsCharging && E.IsReady())
{
var target = TargetSelector.GetTarget(E);
if (target != null)
{
var stacks = W.Level == 0 &&
Menu.Item(Menu.Name + ".harass.e-settings.stacks").GetValue <Slider>().Value > 0;
if (Menu.Item(Menu.Name + ".harass.e-settings.always").GetValue <bool>() || stacks ||
GetWStacks(target) >=
Menu.Item(Menu.Name + ".harass.e-settings.stacks").GetValue <Slider>().Value ||
E.IsKillable(target) ||
CPrediction.Circle(E, target, E.GetHitChance("harass")).TotalHits >=
Menu.Item(Menu.Name + ".combo.e-settings.min").GetValue <Slider>().Value)
{
ELogic(target, E.GetHitChance("harass"));
}
}
}
if (Menu.Item(Menu.Name + ".harass.q").GetValue <bool>() && Q.IsReady())
{
var target = TargetSelector.GetTarget((Q.ChargedMaxRange + Q.Width) * 1.1f, Q.DamageType);
if (target != null)
{
var stacks = W.Level == 0 &&
Menu.Item(Menu.Name + ".harass.q-settings.stacks").GetValue <Slider>().Value > 0;
if (Q.IsCharging || Menu.Item(Menu.Name + ".harass.q-settings.always").GetValue <bool>() ||
target.Distance(Player) > Orbwalking.GetRealAutoAttackRange(target) * 1.2f || stacks ||
GetWStacks(target) >=
Menu.Item(Menu.Name + ".harass.q-settings.stacks").GetValue <Slider>().Value ||
Q.IsKillable(target) ||
CPrediction.Line(Q, target, Q.GetHitChance("harass")).TotalHits >=
Menu.Item(Menu.Name + ".harass.q-settings.min").GetValue <Slider>().Value)
{
QLogic(
target, Q.GetHitChance("harass"),
Menu.Item(Menu.Name + ".harass.q-settings.fast-cast-min").GetValue <Slider>().Value);
}
}
}
}
private void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (sender.IsMe)
{
if (args.SData.Name == "KalistaExpungeWrapper")
{
Orbwalking.ResetAutoAttackTimer();
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// Calculates the combo damage
/// </summary>
/// <param name="target"></param>
/// <param name="rangeCheck"></param>
/// <param name="ult"></param>
/// <returns></returns>
private float CalculateComboDamage(Obj_AI_Hero target, bool rangeCheck, bool ult)
{
try
{
if (target == null)
{
return(0);
}
var damage = 0f;
if (ult && R.IsReady() && (!rangeCheck || R.IsInRange(target)))
{
//damage += R.GetDamage(target);
var level = R.Level;
var percentHealth = 20f + (level * 5); // 25, 30, 35
var targetMissingHealth = target.MaxHealth - target.Health;
var percentMissingHealth = percentHealth / 100 * targetMissingHealth;
var physicalDamageModifier = 15f + (level * 10) + 0.1 * Player.FlatPhysicalDamageMod; // 25, 35, 45
var distanceDamageModifier = Math.Min((1 + Player.Distance(target.ServerPosition) / 15 * 0.09d), 10);
var amount = percentMissingHealth + (physicalDamageModifier * distanceDamageModifier);
damage += (float)Player.CalcDamage(target, Damage.DamageType.Physical, amount);
}
if (!rangeCheck || target.Distance(Player) <= Orbwalking.GetRealAutoAttackRange(target) * 0.85f)
{
damage += 2 * (float)Player.GetAutoAttackDamage(target, true);
}
damage += ItemManager.CalculateComboDamage(target, rangeCheck);
damage += SummonerManager.CalculateComboDamage(target, rangeCheck);
return(damage);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(0);
}
private void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
{
try
{
if (sender != null && sender.IsEnemy && args.DangerLevel == Interrupter2.DangerLevel.High &&
Orbwalking.InAutoAttackRange(sender))
{
if (Cards.Has(CardColor.Gold))
{
Orbwalker.ForceTarget(sender);
Player.IssueOrder(GameObjectOrder.AttackUnit, sender);
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private float CalcComboDamage(Obj_AI_Hero target, float resMulti, bool rangeCheck, bool q, bool r)
{
try
{
if (target == null)
{
return(0);
}
var damage = 0f;
var totalMana = 0f;
if (r && R.IsReady() && (!rangeCheck || R.IsInRange(target, R.Range + R2.Range)))
{
var rMana = R.ManaCost * resMulti;
if (totalMana + rMana <= Player.Mana)
{
totalMana += rMana;
damage += R.GetDamage(target);
}
}
if (q && Q.IsReady() && (!rangeCheck || Q.IsInRange(target)))
{
var qMana = Q.ManaCost * resMulti;
if (totalMana + qMana <= Player.Mana)
{
damage += Q.GetDamage(target);
}
}
if (!rangeCheck || target.Distance(Player) <= Orbwalking.GetRealAutoAttackRange(target) * 0.85f)
{
damage += 2 * (float)Player.GetAutoAttackDamage(target, true);
}
damage += ItemManager.CalculateComboDamage(target, rangeCheck);
damage += SummonerManager.CalculateComboDamage(target, rangeCheck);
return(damage);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(0);
}
private void OnOrbwalkingAfterAttack(AttackableUnit unit, AttackableUnit target)
{
try
{
if (unit.IsMe)
{
var minion = target as Obj_AI_Minion;
if (minion != null)
{
_lastAaMinion = minion;
_lastAaMinionEndTime = Game.Time + minion.Distance(Player) / Orbwalking.GetMyProjectileSpeed() +
0.25f;
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// Post update
/// </summary>
protected override void OnPostUpdate()
{
// Assisted Ultimate
if (_ultimateManager.IsActive(UltimateModeType.Assisted) && R.IsReady())
{
if (_ultimateManager.ShouldMove(UltimateModeType.Assisted))
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
if (!CastUltimate(UltimateModeType.Assisted, TargetSelector.GetTarget(R)))
{
CastUltimateSingle(UltimateModeType.Assisted);
}
}
// Auto Ultimate
if (_ultimateManager.IsActive(UltimateModeType.Auto) && R.IsReady())
{
if (!CastUltimate(UltimateModeType.Auto, TargetSelector.GetTarget(R)))
{
CastUltimateSingle(UltimateModeType.Auto);
}
}
// E Immobile targets
if (HeroListManager.Enabled("e-immobile") && E.IsReady())
{
var target = GameObjects.EnemyHeroes.FirstOrDefault(t =>
t.IsValidTarget(E.Range) &&
HeroListManager.Check("e-immobile", t) &&
BestTargetOnlyManager.Check("e-immobile", E, t) &&
Utils.IsImmobile(t)
);
if (target != null)
{
E.Cast(target);
}
}
}
public List <Obj_AI_Base> GetDashObjects(List <Obj_AI_Base> targets)
{
try
{
var apexPoint = Player.ServerPosition.To2D() +
(Player.ServerPosition.To2D() - Game.CursorPos.To2D()).Normalized() *
Orbwalking.GetRealAutoAttackRange(Player);
return
(targets.Where(
o =>
Utils.IsLyingInCone(
o.ServerPosition.To2D(), apexPoint, Player.ServerPosition.To2D(), Math.PI))
.OrderBy(o => o.Distance(apexPoint, true))
.ToList());
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(null);
}
private void OnCorePostUpdate(EventArgs args)
{
try
{
if (UltimateManager.Assisted() && R.IsReady())
{
if (Menu.Item(Menu.Name + ".ultimate.assisted.move-cursor").GetValue <bool>())
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
if (
!RLogic(
TargetSelector.GetTarget(R),
Menu.Item(Menu.Name + ".ultimate.assisted.min").GetValue <Slider>().Value,
Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady()))
{
RLogicDuel(Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady());
}
}
if (UltimateManager.Auto() && R.IsReady())
{
if (
!RLogic(
TargetSelector.GetTarget(R),
Menu.Item(Menu.Name + ".ultimate.auto.min").GetValue <Slider>().Value,
Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady(), "auto"))
{
RLogicDuel(Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady());
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
protected override void OnPostUpdate()
{
if (_ultimate.IsActive(UltimateModeType.Assisted) && R.IsReady())
{
if (_ultimate.ShouldMove(UltimateModeType.Assisted))
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
if (!RLogic(UltimateModeType.Assisted, TargetSelector.GetTarget(R)))
{
RLogicSingle(UltimateModeType.Assisted);
}
}
if (_ultimate.IsActive(UltimateModeType.Auto) && R.IsReady())
{
if (!RLogic(UltimateModeType.Auto, TargetSelector.GetTarget(R)))
{
RLogicSingle(UltimateModeType.Auto);
}
}
}
protected override void OnPostUpdate()
{
Orbwalker.SetAttack(!Q.IsCharging);
if (_ultimate.IsActive(UltimateModeType.Assisted) && R.IsReady())
{
if (_ultimate.ShouldMove(UltimateModeType.Assisted))
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
if (!RLogic(UltimateModeType.Assisted, R.GetHitChance("combo"), TargetSelector.GetTarget(R)))
{
RLogicSingle(UltimateModeType.Assisted, R.GetHitChance("combo"));
}
}
if (_ultimate.IsActive(UltimateModeType.Auto) && R.IsReady())
{
if (!RLogic(UltimateModeType.Auto, R.GetHitChance("combo"), TargetSelector.GetTarget(R)))
{
RLogicSingle(UltimateModeType.Auto, R.GetHitChance("combo"));
}
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
var hero = args.Target as Obj_AI_Hero;
if (hero != null)
{
args.Process = Cards.Status != SelectStatus.Selecting && !Cards.ShouldWait;
if (args.Process)
{
if (Cards.Has(CardColor.Gold))
{
_qDelay = Game.Time + W.Delay / 2f +
hero.Distance(Player) * 1.5f / Player.BasicAttack.MissileSpeed;
_qTarget = hero;
var target = TargetSelector.GetTarget(W, false);
if (target != null && !target.NetworkId.Equals(hero.NetworkId))
{
Orbwalker.ForceTarget(target);
args.Process = false;
}
}
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
if (Cards.Has(CardColor.Red))
{
var target = Orbwalker.ForcedTarget();
if (target != null && target.NetworkId != args.Target.NetworkId)
{
args.Process = false;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
var t = args.Target as Obj_AI_Hero;
if (t != null &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed))
{
args.Process = Q.Instance.ManaCost > Player.Mana && W.Instance.ManaCost > Player.Mana &&
(E.Instance.ManaCost > Player.Mana || GetPoisonBuffEndTime(t) < E.ArrivalTime(t)) ||
!Q.IsReady() && !E.IsReady();
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
args.Process = Menu.Item(Menu.Name + ".lane-clear.aa").GetValue<bool>();
if (args.Process == false)
{
var m = args.Target as Obj_AI_Minion;
if (m != null && (_lastEEndTime < Game.Time || E.IsReady()) ||
(GetPoisonBuffEndTime(m) < E.ArrivalTime(m) || E.Instance.ManaCost > Player.Mana) ||
!ManaManager.Check("lane-clear"))
{
args.Process = true;
}
}
}
if ((Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit))
{
var m = args.Target as Obj_AI_Minion;
if (m != null && E.CanCast(m))
{
if (E.Instance.ManaCost < Player.Mana)
{
args.Process = Menu.Item(Menu.Name + ".lasthit.e").GetValue<bool>() ||
(Menu.Item(Menu.Name + ".lasthit.e-poison").GetValue<bool>() &&
GetPoisonBuffEndTime(m) > E.ArrivalTime(m)) && ManaManager.Check("lasthit");
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (HasQBuff())
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if ((_rObject == null || !_rObject.IsValid) && R.IsReady() && UltimateManager.Combo() &&
R.Instance.Name.Equals("ViktorChaosStorm", StringComparison.OrdinalIgnoreCase) &&
GameObjects.EnemyHeroes.Any(Orbwalking.InAutoAttackRange) &&
(RLogicDuel(true, Menu.Item(Menu.Name + ".combo.e").GetValue<bool>() && E.IsReady(), true) ||
GameObjects.EnemyHeroes.Where(e => e.IsValidTarget(R.Range + R.Width))
.Any(
e =>
RLogic(
e, Menu.Item(Menu.Name + ".ultimate.combo.min").GetValue<Slider>().Value,
Menu.Item(Menu.Name + ".combo.q").GetValue<bool>() && Q.IsReady(),
Menu.Item(Menu.Name + ".combo.e").GetValue<bool>() && E.IsReady(), true))))
{
args.Process = false;
return;
}
}
if (!(args.Target is Obj_AI_Hero))
{
var targets = TargetSelector.GetTargets(Player.AttackRange + Player.BoundingRadius * 3f);
if (targets != null && targets.Any())
{
var hero = targets.FirstOrDefault(Orbwalking.InAutoAttackRange);
if (hero != null)
{
Orbwalker.ForceTarget(hero);
args.Process = false;
}
else if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
{
if (
targets.Any(
t =>
t.Distance(Player) <
(Player.BoundingRadius + t.BoundingRadius + Player.AttackRange) *
(IsSpellUpgraded(Q) ? 1.4f : 1.2f)))
{
args.Process = false;
}
}
}
}
}
else
{
if ((args.Target is Obj_AI_Hero) &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed) &&
(Q.IsReady() && Player.Mana >= Q.Instance.ManaCost ||
E.IsReady() && Player.Mana >= E.Instance.ManaCost))
{
args.Process = false;
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
var minion = args.Target as Obj_AI_Minion;
if (minion != null &&
HealthPrediction.LaneClearHealthPrediction(
minion, (int) (Player.AttackDelay * 1000), Game.Ping / 2) <
Player.GetAutoAttackDamage(minion))
{
_lastBeforeFarmTarget = minion;
}
if (_lastQKillableTarget != null && _lastQKillableTarget.NetworkId == args.Target.NetworkId)
{
args.Process = false;
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// Should we use fish bones aoe in lane clear
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
private Tuple<int, Obj_AI_Base> FishbonesLaneClearLogic(Orbwalking.BeforeAttackEventArgs args)
{
var useQ = Menu.Item(Menu.Name + ".lane-clear.q").GetValue<bool>() && Q.IsReady();
if (!useQ)
{
return null;
}
if (!ResourceManager.Check("lane-clear-q"))
{
return null;
}
// If target is a hero don't change anything
var target = args.Target as Obj_AI_Hero;
if (target != null)
{
return null;
}
var usingFishBones = IsUsingFishbones();
var bestMinion = BestFishBonesMinion();
if (bestMinion == null)
{
if (usingFishBones)
{
Q.Cast();
}
return null;
}
var fishBonesMinimum = Menu.Item(Menu.Name + ".lane-clear.q-min").GetValue<Slider>().Value;
if (bestMinion.Item1 < fishBonesMinimum)
{
if (usingFishBones)
{
Q.Cast();
}
return null;
}
if (!usingFishBones)
{
Q.Cast();
}
return bestMinion;
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (Player.HasBuff("viktorpowertransferreturn"))
{
if (args.Target.Type != GameObjectType.obj_AI_Hero)
{
var hero = Targets.FirstOrDefault(Orbwalking.InAutoAttackRange);
if (hero != null)
{
args.Process = false;
Orbwalker.ForceTarget(hero);
return;
}
}
var target = args.Target as Obj_AI_Minion;
if (target != null)
{
var health = HealthPrediction.GetHealthPrediction(target, (int) ((Player.AttackDelay * 1000)));
if (health * 2 > CalcPassiveDamage(target) || health < CalcPassiveDamage(target))
{
args.Process = true;
return;
}
var minions =
MinionManager.GetMinions(
1000, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth)
.Where(Orbwalking.InAutoAttackRange)
.ToList();
var killable =
minions.FirstOrDefault(
m =>
HealthPrediction.GetHealthPrediction(m, (int) ((Player.AttackDelay * 1000))) <
CalcPassiveDamage(m));
if (killable != null)
{
Orbwalker.ForceTarget(killable);
}
else
{
var other =
minions.FirstOrDefault(
m =>
HealthPrediction.GetHealthPrediction(m, (int) ((Player.AttackDelay * 1000))) * 2 >
CalcPassiveDamage(m));
if (other != null)
{
Orbwalker.ForceTarget(other);
}
}
args.Process = false;
return;
}
args.Process = true;
return;
}
if (args.Target.Type == GameObjectType.obj_AI_Hero &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed))
{
args.Process = (!Q.IsReady() || Player.Mana < Q.Instance.ManaCost) &&
(!E.IsReady() || Player.Mana < E.Instance.ManaCost);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (!args.Unit.IsMe)
{
return;
}
var forced = Orbwalker.ForcedTarget();
if (forced != null && forced.IsValidTarget() && Orbwalking.InAutoAttackRange(forced))
{
if (Player.CanAttack || Orbwalking.CanAttack(0))
{
Orbwalker.ForceTarget(null);
}
return;
}
if (HasQBuff())
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if ((_rObject == null || !_rObject.IsValid) && R.IsReady() &&
_ultimate.IsActive(UltimateModeType.Combo) &&
R.Instance.Name.Equals("ViktorChaosStorm", StringComparison.OrdinalIgnoreCase) &&
GameObjects.EnemyHeroes.Any(Orbwalking.InAutoAttackRange) &&
(RLogicSingle(UltimateModeType.Combo, true) ||
GameObjects.EnemyHeroes.Where(e => e.IsValidTarget(R.Range + R.Width))
.Any(e => RLogic(UltimateModeType.Combo, e, true))))
{
args.Process = false;
return;
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
if (!(args.Target is Obj_AI_Hero))
{
var target =
TargetSelector.GetTarget(
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear
? -1
: (Player.BoundingRadius * 2 + Player.AttackRange) * 1.25f);
if (target != null)
{
if (Orbwalking.InAutoAttackRange(target))
{
Orbwalker.ForceTarget(target);
}
args.Process = false;
}
}
}
}
else
{
if ((args.Target is Obj_AI_Hero) &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed) &&
(Q.IsReady() && Player.Mana >= Q.Instance.ManaCost ||
E.IsReady() && Player.Mana >= E.Instance.ManaCost))
{
args.Process = false;
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
var minion = args.Target as Obj_AI_Minion;
if (minion != null &&
HealthPrediction.LaneClearHealthPrediction(
minion, (int) (Player.AttackDelay * 1000), Game.Ping / 2) <
Player.GetAutoAttackDamage(minion))
{
_lastBeforeFarmTarget = minion;
}
if (_lastQKillableTarget != null && _lastQKillableTarget.NetworkId == args.Target.NetworkId)
{
args.Process = false;
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
var hero = args.Target as Obj_AI_Hero;
if (hero != null)
{
args.Process = Cards.Status != SelectStatus.Selecting && !Cards.ShouldWait;
if (args.Process)
{
if (Cards.Has(CardColor.Gold))
{
var delay = 0f;
var pos = hero.ServerPosition;
if (hero.IsDashing())
{
var dash = hero.GetDashInfo();
delay = dash.EndTick / 1000f;
pos = dash.EndPos.To3D();
}
_qDelay = Game.Time + Game.Ping / 2000f +
pos.Distance(Player.Position) * 1.5f / Player.BasicAttack.MissileSpeed + delay +
Player.AttackDelay;
_qTarget = hero;
var target = TargetSelector.GetTarget(W, false);
if (target != null && !target.NetworkId.Equals(hero.NetworkId))
{
Orbwalker.ForceTarget(target);
args.Process = false;
}
}
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
if (Cards.Has(CardColor.Red))
{
var target = Orbwalker.ForcedTarget();
if (target != null && target.NetworkId != args.Target.NetworkId)
{
args.Process = false;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// Before attack event
/// </summary>
/// <param name="args"></param>
private void Orbwalking_BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
var fishbones = FishbonesLaneClearLogic(args);
if (fishbones == null)
{
return;
}
args.Target = fishbones.Item2;
}
else if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
{
var target = args.Target as Obj_AI_Base;
if (target == null)
{
return;
}
var fishbones = FishbonesComboHarassLogic(target);
if (fishbones == null)
{
return;
}
args.Target = fishbones.Item2;
}
else if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
var fishbones = IsUsingFishbones();
if (fishbones)
{
var target = args.Target as Obj_AI_Base;
if (target == null)
{
return;
}
if (Player.Distance(target) <= GetRealAutoAttackRange(MinigunRange, target))
{
Q.Cast();
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Flee)
{
args.Process = false;
return;
}
if (Player.HasBuff("viktorpowertransferreturn"))
{
if (args.Target.Type != GameObjectType.obj_AI_Hero)
{
var hero =
TargetSelector.GetTargets(Player.AttackRange + Player.BoundingRadius * 4f)
.FirstOrDefault(Orbwalking.InAutoAttackRange);
if (hero != null)
{
Orbwalker.ForceTarget(hero);
args.Process = false;
return;
}
}
}
if (args.Target.Type == GameObjectType.obj_AI_Hero &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed))
{
args.Process = (!Q.IsReady() || Player.Mana < Q.Instance.ManaCost) &&
(!E.IsReady() || Player.Mana < E.Instance.ManaCost);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (!args.Unit.IsMe)
{
return;
}
var t = args.Target as Obj_AI_Hero;
if (t != null &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed))
{
args.Process =
Menu.Item(
Menu.Name + "." +
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ? "combo" : "harass") + ".aa")
.GetValue<bool>();
if (!args.Process)
{
var poison = GetPoisonBuffEndTime(t);
args.Process = (!Q.IsReady() || Q.Instance.ManaCost > Player.Mana) &&
((!E.IsReady() && Game.Time - _lastECast > 3) ||
E.Instance.ManaCost > Player.Mana || poison <= 0 || poison < E.ArrivalTime(t));
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
args.Process = Menu.Item(Menu.Name + ".lane-clear.aa").GetValue<bool>();
if (!args.Process)
{
var m = args.Target as Obj_AI_Minion;
if (m != null && (_lastEEndTime < Game.Time || E.IsReady()) ||
(GetPoisonBuffEndTime(m) < E.ArrivalTime(m) || E.Instance.ManaCost > Player.Mana) ||
!ResourceManager.Check("lane-clear"))
{
args.Process = true;
}
}
}
if ((Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit))
{
var m = args.Target as Obj_AI_Minion;
if (m != null && E.IsReady() && E.CanCast(m) && E.Instance.ManaCost < Player.Mana)
{
var useE = Menu.Item(Menu.Name + ".lasthit.e").GetValue<bool>();
var useEPoison = Menu.Item(Menu.Name + ".lasthit.e-poison").GetValue<bool>();
if ((useE || useEPoison && GetPoisonBuffEndTime(m) > E.ArrivalTime(m)) &&
ResourceManager.Check("lasthit"))
{
args.Process = false;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
var hero = args.Target as Obj_AI_Hero;
if (hero != null)
{
args.Process = Cards.Status != SelectStatus.Selecting && !Cards.ShouldWait;
if (args.Process)
{
if (Cards.Has(CardColor.Gold))
{
_wTarget = hero;
_wTargetEndTime = Game.Time + 5f;
var target = TargetSelector.GetTarget(W, false);
if (target != null && !target.NetworkId.Equals(hero.NetworkId))
{
Orbwalker.ForceTarget(target);
args.Process = false;
}
}
}
}
else
{
if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Flee &&
Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.None)
{
if (Cards.Has(CardColor.Gold) || Cards.Has(CardColor.Blue))
{
var targets = TargetSelector.GetTargets(
Orbwalking.GetRealAutoAttackRange(null) * 1.25f, DamageType.Magical);
if (targets != null)
{
var target = targets.FirstOrDefault(Orbwalking.InAutoAttackRange);
if (target != null)
{
Orbwalker.ForceTarget(target);
args.Process = false;
}
}
}
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
if (Cards.Has(CardColor.Red))
{
var target = Orbwalker.ForcedTarget();
if (target != null && target.NetworkId != args.Target.NetworkId)
{
args.Process = false;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (args.Unit.IsMe)
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
var enemy = args.Target as Obj_AI_Hero;
if (enemy != null)
{
ItemManager.Muramana(enemy, true);
}
}
else
{
ItemManager.Muramana(null, false);
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private List <CardColor> GetBestCard(Obj_AI_Hero target, string mode)
{
var cards = new List <CardColor>();
if (target == null || !target.IsValid || target.IsDead)
{
return(cards);
}
try
{
if (IsWKillable(target, 2))
{
cards.Add(CardColor.Gold);
}
if (IsWKillable(target))
{
cards.Add(CardColor.Blue);
}
if (IsWKillable(target, 1))
{
cards.Add(CardColor.Red);
}
if (cards.Any())
{
return(cards);
}
var selectedCard =
GetSelectedCardColor(Menu.Item(Menu.Name + ".harass.w-card").GetValue <StringList>().SelectedIndex);
var burst = Menu.Item(Menu.Name + ".miscellaneous.mode").GetValue <StringList>().SelectedIndex == 0;
var red = 0;
var blue = 0;
var gold = 0;
var shouldBlue = Player.Mana <W.ManaCost + Q.ManaCost &&
Player.Mana + (25 + 25 * W.Level)> Q.ManaCost + W.ManaCost;
if (!burst && (mode == "combo" || mode == "harass" && selectedCard == CardColor.None))
{
if (Q.Level == 0)
{
return(new List <CardColor> {
CardColor.Blue
});
}
gold++;
if (target.Distance(Player) > W.Range * 0.8f)
{
gold++;
}
if (mode == "combo" && (Player.ManaPercent < 10 || shouldBlue) ||
mode == "harass" && !ResourceManager.Check("harass-blue"))
{
return(new List <CardColor> {
CardColor.Blue
});
}
var minRed = Menu.Item(Menu.Name + ".combo.red-min").GetValue <Slider>().Value;
var redHits = GetWHits(target, GameObjects.EnemyHeroes.Cast <Obj_AI_Base>().ToList(), CardColor.Red);
red += redHits;
if (red > blue && red > gold && redHits >= minRed)
{
cards.Add(CardColor.Red);
if (red == blue)
{
cards.Add(CardColor.Blue);
}
if (red == gold)
{
cards.Add(CardColor.Gold);
}
}
else if (gold > blue && gold > red)
{
cards.Add(CardColor.Gold);
if (gold == blue)
{
cards.Add(CardColor.Blue);
}
if (gold == red && redHits >= minRed)
{
cards.Add(CardColor.Red);
}
}
else if (blue > red && blue > gold)
{
cards.Add(CardColor.Blue);
if (blue == red && redHits >= minRed)
{
cards.Add(CardColor.Red);
}
if (blue == gold)
{
cards.Add(CardColor.Gold);
}
}
}
if (mode == "combo" && !cards.Any())
{
if (Q.Level == 0)
{
return(new List <CardColor> {
CardColor.Blue
});
}
var distance = target.Distance(Player);
var damage = ItemManager.CalculateComboDamage(target) - target.HPRegenRate * 2f - 10;
if (HasEBuff())
{
damage += E.GetDamage(target);
}
if (Q.IsReady() && (Utils.GetImmobileTime(target) > 0.5f || distance < Q.Range / 4f))
{
damage += Q.GetDamage(target);
}
if (W.GetDamage(target, 2) + damage > target.Health)
{
cards.Add(CardColor.Gold);
}
if (distance < Orbwalking.GetRealAutoAttackRange(target) * 0.85f)
{
if (W.GetDamage(target) + damage > target.Health)
{
cards.Add(CardColor.Blue);
}
if (W.GetDamage(target, 1) + damage > target.Health)
{
cards.Add(CardColor.Red);
}
}
if (!cards.Any())
{
if (ObjectManager.Player.HealthPercent <=
Menu.Item(Menu.Name + ".combo.gold-percent").GetValue <Slider>().Value)
{
cards.Add(CardColor.Gold);
}
else if (Player.ManaPercent < 10 || shouldBlue)
{
cards.Add(CardColor.Blue);
}
else
{
var redHits = GetWHits(
target, GameObjects.EnemyHeroes.Cast <Obj_AI_Base>().ToList(), CardColor.Red);
if (redHits >= Menu.Item(Menu.Name + ".combo.red-min").GetValue <Slider>().Value)
{
cards.Add(CardColor.Red);
}
}
}
if (!cards.Any())
{
cards.Add(CardColor.Gold);
}
}
else if (mode == "harass" && !cards.Any())
{
if (selectedCard == CardColor.None && burst)
{
cards.Add(target.Distance(Player) > W.Range * 0.8f ? CardColor.Gold : CardColor.Blue);
}
else
{
var card = !ResourceManager.Check("harass-blue") ? CardColor.Blue : selectedCard;
if (card != CardColor.None)
{
cards.Add(card);
}
}
}
else if (mode == "flee")
{
cards.Add(
GetWHits(target, GameObjects.EnemyHeroes.Cast <Obj_AI_Base>().ToList(), CardColor.Red) >= 2
? CardColor.Red
: CardColor.Gold);
}
if (!cards.Any())
{
cards.Add(CardColor.Gold);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(cards);
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (!args.Unit.IsMe)
{
return;
}
var hero = args.Target as Obj_AI_Hero;
if (hero != null)
{
args.Process = Cards.Status != SelectStatus.Selecting && !Cards.ShouldWait;
if (args.Process)
{
if (Cards.Has(CardColor.Gold))
{
_wTarget = hero;
_wTargetEndTime = Game.Time + 5f;
var target = TargetSelector.GetTarget(W, false);
if (target != null && !target.NetworkId.Equals(hero.NetworkId))
{
Orbwalker.ForceTarget(target);
args.Process = false;
}
}
}
}
else
{
if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Flee &&
Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.None)
{
if (Cards.Has(CardColor.Gold) || Cards.Has(CardColor.Blue))
{
var targets = TargetSelector.GetTargets(
Orbwalking.GetRealAutoAttackRange(null) * 1.25f, DamageType.Magical);
if (targets != null)
{
var target = targets.FirstOrDefault(Orbwalking.InAutoAttackRange);
if (target != null)
{
Orbwalker.ForceTarget(target);
args.Process = false;
}
}
}
}
}
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
if (Cards.Has(CardColor.Red))
{
var bestMinion = BestRedMinion();
var buff = ObjectManager.Player.GetBuff("redcardpreattack");
if (bestMinion != null && bestMinion.NetworkId != args.Target.NetworkId &&
(buff == null || buff.EndTime - Game.Time > 0.15f))
{
Orbwalker.ForceTarget(bestMinion);
args.Process = false;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
