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);
}
}
}
public static void Muramana(Obj_AI_Hero target, bool activate, float overrideRange = -1f)
{
try
{
var muramana = ObjectManager.Player.GetSpellSlot("Muramana");
if (muramana == SpellSlot.Unknown || !muramana.IsReady())
{
return;
}
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.ManaPercent >=
_menu.Item(_menu.Name + ".muramana.player-mana-above").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)
{
ObjectManager.Player.Spellbook.CastSpell(muramana);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
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
{
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
{
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 float CalcComboDamage(Obj_AI_Hero target, float resMulti, bool rangeCheck, bool q, bool w, bool r)
{
try
{
if (target == null)
{
return(0);
}
var damage = 0f;
var totalMana = 0f;
var pred = R.GetPrediction(target);
var position = target.Position;
if (!pred.UnitPosition.Equals(Vector3.Zero))
{
position = pred.UnitPosition;
}
if (r && R.IsReady() && (!rangeCheck || R.IsInRange(target)))
{
var rMana = R.ManaCost * resMulti;
if (totalMana + rMana <= Player.Mana)
{
totalMana += rMana;
damage += GetRDamage(target);
}
}
var qMana = Q.ManaCost * resMulti;
if (totalMana + qMana <= Player.Mana && q && (!rangeCheck || Q.IsInRange(position)))
{
totalMana += qMana;
damage += Q.GetDamage(target);
if (totalMana + qMana <= Player.Mana)
{
totalMana += qMana;
damage += Q.GetDamage(target);
}
}
if (w && W.IsReady() && (!rangeCheck || W.IsInRange(position)))
{
var wMana = W.ManaCost * resMulti;
if (totalMana + wMana <= Player.Mana)
{
damage += W.GetDamage(target);
}
}
if (!rangeCheck ||
position.Distance(Player.Position) <= Orbwalking.GetRealAutoAttackRange(target) * 0.9f)
{
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 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));
}
}
static ItemManager()
{
try
{
// Speed + Atk Speed
Youmuu = new CustomItem
{
Name = "youmuus-ghostblade",
DisplayName = "Youmuu's Ghostblade",
Item = ItemData.Youmuus_Ghostblade.GetItem(),
Flags = ItemFlags.Offensive | ItemFlags.Flee,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.AttackSpeed | EffectFlags.MovementSpeed,
CastType = CastType.None,
Range =
ObjectManager.Player.IsMelee
? ObjectManager.Player.AttackRange * 3
: Orbwalking.GetRealAutoAttackRange(ObjectManager.Player)
};
// AOE damage, only melee
Hydra = new CustomItem
{
Name = "hydra",
DisplayName = "Hydra",
Item = ItemData.Ravenous_Hydra_Melee_Only.GetItem(),
Flags = ItemFlags.Offensive,
CombatFlags = CombatFlags.Melee,
EffectFlags = EffectFlags.Damage,
CastType = CastType.None,
Damage = Damage.DamageItems.Hydra,
Range = ItemData.Ravenous_Hydra_Melee_Only.GetItem().Range
};
// Slow + Damage
BilgewaterCutlass = new CustomItem
{
Name = "bilgewater-cutlass",
DisplayName = "Bilgewater Cutlass",
Item = ItemData.Bilgewater_Cutlass.GetItem(),
Flags = ItemFlags.Offensive | ItemFlags.Flee,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.Damage | EffectFlags.MovementSlow,
CastType = CastType.Target,
Damage = Damage.DamageItems.Bilgewater,
Range = ItemData.Bilgewater_Cutlass.GetItem().Range
};
// Slow + Damage
BladeRuinedKing = new CustomItem
{
Name = "blade-ruined-king",
DisplayName = "Blade of the Ruined King",
Item = ItemData.Blade_of_the_Ruined_King.GetItem(),
Flags = ItemFlags.Offensive | ItemFlags.Flee,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.Damage | EffectFlags.MovementSlow,
CastType = CastType.Target,
Damage = Damage.DamageItems.Botrk,
Range = ItemData.Blade_of_the_Ruined_King.GetItem().Range
};
// Damage + Slow
HextechGunblade = new CustomItem
{
Name = "hextech-gunblade",
DisplayName = "Hextech Gunblade",
Item = ItemData.Hextech_Gunblade.GetItem(),
Flags = ItemFlags.Offensive | ItemFlags.Flee,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.Damage | EffectFlags.MovementSlow,
CastType = CastType.Target,
Damage = Damage.DamageItems.Hexgun,
Range = ItemData.Hextech_Gunblade.GetItem().Range
};
// AOE Shield
LocketIronSolari = new CustomItem
{
Name = "locket-iron-solari",
DisplayName = "Locket of the Iron Solari",
Item = ItemData.Locket_of_the_Iron_Solari.GetItem(),
Flags = ItemFlags.Supportive | ItemFlags.Defensive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.Shield,
CastType = CastType.None,
Range = ItemData.Locket_of_the_Iron_Solari.GetItem().Range
};
// Remove stun + heal
MikaelsCrucible = new CustomItem
{
Name = "mikaels-crucible",
DisplayName = "Mikael's Crucible",
Item = ItemData.Mikaels_Crucible.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.RemoveStun | EffectFlags.Heal,
CastType = CastType.Target,
Range = ItemData.Mikaels_Crucible.GetItem().Range
};
// Slow
FrostQueensClaim = new CustomItem
{
Name = "frost-queens-claim",
DisplayName = "Frost Queen's Claim",
Item = ItemData.Frost_Queens_Claim.GetItem(),
Flags = ItemFlags.Supportive | ItemFlags.Flee,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.MovementSlow,
CastType = CastType.None,
Range = ItemData.Frost_Queens_Claim.GetItem().Range
};
// Speed
TalismanOfAscension = new CustomItem
{
Name = "talisman-of-ascension",
DisplayName = "Talisman of Ascension",
Item = ItemData.Talisman_of_Ascension.GetItem(),
Flags = ItemFlags.Supportive | ItemFlags.Flee,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.MovementSpeed,
CastType = CastType.None,
Range = ItemData.Talisman_of_Ascension.GetItem().Range
};
// Shield
FaceOfTheMountain = new CustomItem
{
Name = "face-of-the-mountain",
DisplayName = "Face of the Mountain",
Item = ItemData.Face_of_the_Mountain.GetItem(),
Flags = ItemFlags.Supportive | ItemFlags.Flee | ItemFlags.Defensive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
EffectFlags = EffectFlags.Shield,
CastType = CastType.Self,
Range = ItemData.Face_of_the_Mountain.GetItem().Range
};
// Place wards
Sightstone = new CustomItem
{
Name = "sightstone",
DisplayName = "Sightstone",
Item = ItemData.Sightstone.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
CastType = CastType.Position,
Range = ItemData.Sightstone.GetItem().Range
};
// Place wards
RubySightstone = new CustomItem
{
Name = "ruby-sightstone",
DisplayName = "Ruby Sightstone",
Item = ItemData.Ruby_Sightstone.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
CastType = CastType.Position,
Range = ItemData.Ruby_Sightstone.GetItem().Range
};
// Place wards
EyeOfTheWatchers = new CustomItem
{
Name = "eye-of-the-watchers",
DisplayName = "Eye of the Watchers",
Item = ItemData.Eye_of_the_Watchers.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
CastType = CastType.Position,
Range = ItemData.Eye_of_the_Watchers.GetItem().Range
};
// Place wards
EyeOfTheEquinox = new CustomItem
{
Name = "eye-of-the-equinox",
DisplayName = "Eye of the Equinox",
Item = ItemData.Eye_of_the_Equinox.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
CastType = CastType.Position,
Range = ItemData.Eye_of_the_Equinox.GetItem().Range
};
// Place wards
EyeOfTheOasis = new CustomItem
{
Name = "eye-of-the-oasis",
DisplayName = "Eye of the Oasis",
Item = ItemData.Eye_of_the_Oasis.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
CastType = CastType.Position,
Range = ItemData.Eye_of_the_Oasis.GetItem().Range
};
// Place wards
TrackersKnife = new CustomItem
{
Name = "trackers-knife",
DisplayName = "Tracker's Knife",
Item = ItemData.Trackers_Knife.GetItem(),
Flags = ItemFlags.Supportive,
CombatFlags = CombatFlags.Melee | CombatFlags.Ranged,
CastType = CastType.Position,
Range = ItemData.Trackers_Knife.GetItem().Range
};
Items = new List <CustomItem>
{
Youmuu,
Hydra,
BilgewaterCutlass,
BladeRuinedKing,
HextechGunblade,
MikaelsCrucible,
LocketIronSolari,
FrostQueensClaim,
TalismanOfAscension,
FaceOfTheMountain,
Sightstone,
RubySightstone,
EyeOfTheWatchers,
EyeOfTheEquinox,
EyeOfTheOasis,
TrackersKnife
};
MaxRange = Items.Max(s => s.Range);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
protected override void SetupSpells()
{
Q = new Spell(SpellSlot.Q, 650f);
Q.Range += GameObjects.EnemyHeroes.Select(e => e.BoundingRadius).DefaultIfEmpty(25).Min();
Q.SetTargetted(0.25f, 1400f);
Q1 = new Spell(SpellSlot.Q, Q.Range + 450f);
W = new Spell(SpellSlot.W, Orbwalking.GetRealAutoAttackRange(null) * 1.25f);
W.Range += GameObjects.EnemyHeroes.Select(e => e.BoundingRadius).DefaultIfEmpty(25).Min();
E = new Spell(SpellSlot.E, 1000f);
E.SetSkillshot(0.5f, 175f, float.MaxValue, false, SkillshotType.SkillshotCircle);
R = new Spell(SpellSlot.R, 1200f);
R.SetSkillshot(0.25f, 100f, 2000f, false, SkillshotType.SkillshotLine);
Ultimate = new UltimateManager
{
Combo = true,
Assisted = true,
Auto = true,
Flash = false,
Required = true,
Force = true,
Gapcloser = false,
GapcloserDelay = false,
Interrupt = false,
InterruptDelay = false,
Spells = Spells,
SingleDamagePercent = 100,
DamagePercent = 100,
ComboDamageCheck = true,
DamageCalculation = (hero, resMulti, rangeCheck) => CalcUltimateDamage(hero, resMulti, rangeCheck)
};
/*
* Drawing.OnDraw += delegate
* {
* var minions = MinionManager.GetMinions(
* Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.None);
* foreach (var minion in minions)
* {
* var coneBuff = new Geometry.Polygon.Sector(
* minion.Position, Player.Position.Extend(minion.Position, Player.Distance(minion) + Q.Range / 2f),
* (float) (40 * Math.PI / 180), Q1.Range - Q.Range);
* var coneNormal = new Geometry.Polygon.Sector(
* minion.Position, Player.Position.Extend(minion.Position, Player.Distance(minion) + Q.Range / 2f),
* (float) (60 * Math.PI / 180), Q1.Range - Q.Range);
* for (var i = 0; i < coneBuff.Points.Count - 1; i++)
* {
* var p1 = Drawing.WorldToScreen(coneBuff.Points[i].To3D());
* var p2 = Drawing.WorldToScreen(coneBuff.Points[i + 1].To3D());
* Drawing.DrawLine(p1, p2, 3, Color.Red);
* }
* Drawing.DrawLine(
* Drawing.WorldToScreen(coneBuff.Points.First().To3D()),
* Drawing.WorldToScreen(coneBuff.Points.Last().To3D()), 3, Color.Red);
* for (var i = 0; i < coneNormal.Points.Count - 1; i++)
* {
* var p1 = Drawing.WorldToScreen(coneNormal.Points[i].To3D());
* var p2 = Drawing.WorldToScreen(coneNormal.Points[i + 1].To3D());
* Drawing.DrawLine(p1, p2, 3, Color.White);
* }
* Drawing.DrawLine(
* Drawing.WorldToScreen(coneNormal.Points.First().To3D()),
* Drawing.WorldToScreen(coneNormal.Points.Last().To3D()), 3, Color.White);
* }
* };
*/
}
protected override void OnPostUpdate()
{
if (Ultimate.IsActive(UltimateModeType.Flash) && R.IsReady() && SummonerManager.Flash.IsReady())
{
if (Ultimate.ShouldMove(UltimateModeType.Flash))
{
Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
}
var targets =
Targets.Where(
t =>
t.Distance(Player) < (R.Range + R.Width + SummonerManager.Flash.Range) * 1.5f &&
!t.IsDashing() &&
(t.IsFacing(Player)
? t.Distance(Player)
: R.GetPrediction(t).UnitPosition.Distance(Player.Position)) > R.Range);
var backwards = Menu.Item(Menu.Name + ".ultimate.backwards").GetValue <bool>();
foreach (var target in targets)
{
var flashPos = Player.Position.Extend(target.Position, SummonerManager.Flash.Range);
var maxHits = GetMaxRHits(HitChance.High, flashPos);
if (maxHits.Item1.Count > 0)
{
var castPos = backwards
? Player.Position.Extend(maxHits.Item2, -(Player.Position.Distance(maxHits.Item2) * 2))
: Player.Position.Extend(maxHits.Item2, Player.Position.Distance(maxHits.Item2));
if (Ultimate.Check(UltimateModeType.Flash, maxHits.Item1))
{
if (R.Cast(castPos))
{
Utility.DelayAction.Add(300 + Game.Ping / 2, () => SummonerManager.Flash.Cast(flashPos));
}
}
else if (Ultimate.ShouldSingle(UltimateModeType.Flash))
{
if (
maxHits.Item1.Where(hit => Ultimate.CheckSingle(UltimateModeType.Flash, hit))
.Any(hit => R.Cast(castPos)))
{
Utility.DelayAction.Add(300 + Game.Ping / 2, () => SummonerManager.Flash.Cast(flashPos));
}
}
}
}
}
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")))
{
RLogicSingle(UltimateModeType.Assisted, R.GetHitChance("combo"), false);
}
}
if (Ultimate.IsActive(UltimateModeType.Auto) && R.IsReady())
{
if (!RLogic(UltimateModeType.Auto, R.GetHitChance("combo")))
{
RLogicSingle(UltimateModeType.Auto, R.GetHitChance("combo"));
}
}
if (HeroListManager.Enabled("w-immobile") && W.IsReady())
{
var target =
Targets.FirstOrDefault(
t =>
HeroListManager.Check("w-immobile", t) && BestTargetOnlyManager.Check("w-immobile", W, t) &&
Utils.IsImmobile(t));
if (target != null)
{
Casting.SkillShot(target, W, HitChance.High);
}
}
}
protected override void Harass()
{
if (Menu.Item(Menu.Name + ".harass.q").GetValue <bool>() && Q.IsReady() && ResourceManager.Check("harass-q") &&
!Player.IsWindingUp && !Player.IsDashing())
{
var target = TargetSelector.GetTarget(Q);
if (target != null)
{
var prediction = Q.GetPrediction(target);
if (prediction.Hitchance >= Q.GetHitChance("harass"))
{
Q.Cast(prediction.CastPosition);
}
else if (prediction.Hitchance == HitChance.Collision)
{
QCollisionCheck(target);
}
}
}
if (Menu.Item(Menu.Name + ".harass.e").GetValue <bool>() && E.IsReady() && ResourceManager.Check("harass-e"))
{
var target = TargetSelector.GetTarget(E, false);
if (target != null && Rend.HasBuff(target))
{
if (Rend.IsKillable(target, false))
{
CastE();
}
if (target.Distance(Player) > Orbwalking.GetRealAutoAttackRange(target))
{
if (
GameObjects.EnemyMinions.Any(
m => m.IsValidTarget(E.Range * 0.95f) && Rend.IsKillable(m, m.HealthPercent < 10)))
{
CastE();
}
else
{
var dashObjects =
GameObjects.EnemyMinions.Where(
m => m.IsValidTarget(Orbwalking.GetRealAutoAttackRange(m))).ToList();
var minion =
dashObjects.FirstOrDefault(
m =>
m.Health > Player.GetAutoAttackDamage(m) * 1.1f &&
m.Health < Player.GetAutoAttackDamage(m) + Rend.GetDamage(m, 1));
if (minion != null)
{
Orbwalker.ForceTarget(minion);
if (Orbwalking.CanAttack())
{
ObjectManager.Player.IssueOrder(GameObjectOrder.AttackUnit, minion);
}
}
}
}
else if (E.IsInRange(target))
{
if (Rend.IsKillable(target, false))
{
CastE();
}
else
{
var buff = Rend.GetBuff(target);
if (buff != null &&
buff.Count >= Menu.Item(Menu.Name + ".harass.e-min").GetValue <Slider>().Value)
{
if (target.Distance(Player) > E.Range * 0.8 && !target.IsFacing(Player) ||
buff.EndTime - Game.Time < 0.3)
{
CastE();
}
}
}
}
}
}
}
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 = Ultimate.IsActive(UltimateModeType.Combo) && R.IsReady();
if (useR)
{
var target = TargetSelector.GetTarget(R.Range, R.DamageType);
if (target != null)
{
if (!RLogic(UltimateModeType.Combo, target))
{
RLogicSingle(UltimateModeType.Combo);
}
}
}
if (useE && !Player.IsWindingUp && !IsReloading())
{
var target = TargetSelector.GetTarget(
E.Range + Player.AttackRange + Player.BoundingRadius, E.DamageType);
if (target != null)
{
var pos = Menu.Item(Menu.Name + ".combo.e-mode").GetValue <StringList>().SelectedIndex == 0
? Utils.GetDashPosition(
E, target, Menu.Item(Menu.Name + ".combo.e-safety").GetValue <Slider>().Value)
: Player.Position.Extend(
Game.CursorPos, Math.Min(E.Range, Player.Position.Distance(Game.CursorPos)));
if (!pos.Equals(Vector3.Zero))
{
if (GetAmmoCount() == 1 && !pos.IsUnderTurret(false) ||
(!GameObjects.EnemyHeroes.Any(e => e.IsValidTarget() && Orbwalking.InAutoAttackRange(e)) &&
GameObjects.EnemyHeroes.Any(
e =>
e.IsValidTarget() &&
pos.Distance(e.Position) < Orbwalking.GetRealAutoAttackRange(e)) &&
target.Health < Player.GetAutoAttackDamage(target) * 2))
{
E.Cast(pos);
}
}
}
}
if (useQ)
{
QLogic(Q.GetHitChance("combo"));
}
if (useW)
{
var target = TargetSelector.GetTarget(W);
if (target != null)
{
var best = CPrediction.Circle(W, target, W.GetHitChance("combo"));
if (best.TotalHits > 0 && !best.CastPosition.Equals(Vector3.Zero))
{
W.Cast(best.CastPosition);
}
}
}
}
private void OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (!args.Unit.IsMe)
{
return;
}
var forced = Orbwalker.ForcedTarget();
if (forced != null && forced.IsValidTarget() && forced is Obj_AI_Hero &&
Orbwalking.InAutoAttackRange(forced))
{
return;
}
if (HasQBuff() || Game.Time - _lastQCast <= 0.5f + Game.Ping / 1000f)
{
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 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:
if (target.Team == GameObjectTeam.Neutral)
{
useW = Menu.Item(Menu.Name + ".jungle-clear.w").GetValue <bool>() &&
ResourceManager.Check("jungle-clear-w");
wMin = 1;
jungleClear = true;
}
else
{
useW = Menu.Item(Menu.Name + ".lane-clear.w").GetValue <bool>() &&
ResourceManager.Check("lane-clear-w");
wMin = Menu.Item(Menu.Name + ".lane-clear.w-min").GetValue <Slider>().Value;
laneclear = true;
}
break;
}
if (useW)
{
var range = W.Range + Player.BoundingRadius * 2f;
var targets = laneclear || jungleClear
? 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 OnOrbwalkingBeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
try
{
if (!args.Unit.IsMe)
{
return;
}
if ((Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit) && args.Target is Obj_AI_Minion)
{
args.Process = args.Target.NetworkId != _lastFarmQKill;
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
