private void OnHarass()
{
bool useQ = Menu["harass"]["useq"].Enabled;
float useQHP = Menu["harass"]["hpq"].As <MenuSlider>().Value;
if (Q.Ready && useQ && Player.HealthPercent() >= useQHP)
{
var target = GetBestEnemyHeroTargetInRange(Q.Range);
if (target != null && target.IsValidTarget(Player.AttackRange + target.BoundingRadius))
{
Q.Cast();
}
}
bool useE = Menu["harass"]["usee"].Enabled;
float useEHP = Menu["harass"]["hpe"].As <MenuSlider>().Value;
if (E.Ready && useE && Player.HealthPercent() >= useEHP)
{
var target = GetBestEnemyHeroTargetInRange(E.Range);
if (target.IsValidTarget(E.Range) && target != null)
{
E.Cast(target);
}
}
}
/// <summary>
/// Gets the real Damage the R spell would deal to a determined enemy hero.
/// </summary>
/// <param name="target">The target.</param>
public double GetTotalLivingArtilleryDamage(Obj_AI_Hero target)
{
var missingHealth = Math.Min(60, 100 / target.HealthPercent());
var damage = UtilityClass.Player.GetSpellDamage(target, SpellSlot.R) * (1 + 0.833 * missingHealth / 100);
return(damage * (target.HealthPercent() < 40 ? 2 : 1));
}
static void Potions()
{
if (Menus._menu["consumable"]["usepot"].Enabled)
{
bool hasBuff = false;
foreach (string buff in Extensions.PotionBuffs)
{
if (_player.HasBuff(buff))
{
if (!hasBuff)
{
hasBuff = true;
}
}
}
foreach (uint item in Extensions.PotionItems)
{
if (_player.HasAndCanUseItem(item) && !hasBuff &&
_player.HealthPercent() <= Menus._menu["consumable"]["potpercent"].Value)
{
_player.UseItem(item);
}
}
}
}
private static void Game_OnUpdate()
{
if (_player.IsDead)
{
return;
}
bool hasBuff = false;
foreach (string buff in Extensions.PotionBuffs)
{
if (_player.HasBuff(buff) && !hasBuff)
{
hasBuff = true;
}
}
foreach (uint item in Extensions.PotionItems)
{
if (_player.HasAndCanUseItem(item) && !hasBuff &&
_player.HealthPercent() <= Menus._menu["pots"]["potpercent"].Value)
{
_player.UseItem(item);
}
}
}
private void OnCombo()
{
var target = GetBestEnemyHeroTargetInRange(1500);
bool useQ = Menu["combo"]["useq"].Enabled;
float useQHP = Menu["combo"]["useqhp"].As <MenuSlider>().Value;
bool useWF = Menu["combo"]["usewf"].Enabled;
bool useW = Menu["combo"]["usew"].Enabled;
bool useE = Menu["combo"]["usee"].Enabled;
var EPredition = E.GetPrediction(target);
bool useR = Menu["combo"]["user"].Enabled;
float useRHP = Menu["combo"]["userhp"].As <MenuSlider>().Value;
if (!target.IsValidTarget())
{
return;
}
if (Q.Ready && target.IsValidTarget(400) && useQ && Player.HealthPercent() < useQHP)
{
Q.Cast();
}
if (W.Ready)
{
if (!target.IsFacing(Player) && useWF && target.IsValidTarget(W.Range))
{
W.Cast();
}
else if (target.IsFacing(Player) && useW && target.IsValidTarget(W.Range) && Player.HealthPercent() < target.HealthPercent())
{
W.Cast();
}
}
if (E.Ready && target.IsValidTarget(E.Range) && useE)
{
if (EPredition.HitChance >= HitChance.High)
{
E.Cast(EPredition.CastPosition);
}
}
if (R.Ready && !Player.IsRecalling() && Player.HealthPercent() <= useRHP && target.IsValidTarget(500))
{
R.Cast();
}
}
public static void Healing()
{
List <Obj_AI_Base> targets = ObjectManager.Get <Obj_AI_Base>()
.Where(a => a.IsLegitimate() && Extensions.BigMonsterNameList.Contains(a.UnitSkinName)).ToList();
if (_player.HealthPercent() <= Menus._menu["settings"]["smiteheal"].Value)
{
Spells.CastSmite(targets);
}
}
private void OnCombo()
{
bool useQ = Menu["combo"]["useq"].Enabled;
float QRange = Menu["combo"]["qrange"].As <MenuSlider>().Value;
bool useQGap = Menu["combo"]["useq2"].Enabled;
if (Q.Ready)
{
var targetq = GetBestEnemyHeroTargetInRange(QRange);
var targetq2 = GetBestEnemyHeroTargetInRange(Q2.Range);
if (targetq.IsValidTarget(QRange) && useQ && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "ThreshQ")
{
Q.Cast(targetq);
}
if (targetq2.IsValidTarget(Q2.Range) && useQGap && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "ThreshQLeap" && targetq2.HasBuff("ThreshQ"))
{
Q2.Cast();
}
}
bool useWself = Menu["combo"]["usewself"].Enabled;
float WSHP = Menu["combo"]["wshp"].As <MenuSlider>().Value;
if (W.Ready && useWself && Player.HealthPercent() <= WSHP)
{
var target = GetBestEnemyHeroTargetInRange(W.Range);
if (target.IsValidTarget(W.Range))
{
W.Cast(Player.ServerPosition);
}
}
bool useE = Menu["combo"]["usee"].Enabled;
if (E.Ready && useE)
{
var target = GetBestEnemyHeroTargetInRange(E.Range);
if (target.IsValidTarget(E.Range) && !target.HasBuff("ThreshQ"))
{
E.Cast(target);
}
}
bool useR = Menu["combo"]["user"].Enabled;
float REnemies = Menu["combo"]["usere"].As <MenuSlider>().Value;
if (R.Ready && useR && Player.CountEnemyHeroesInRange(R.Range) >= REnemies)
{
var target = GetBestEnemyHeroTargetInRange(R.Range);
if (target.IsValidTarget(R.Range))
{
R.Cast();
}
}
}
public void Combo()
{
bool useQ = WorldMenu.Combo["useQ"].As <MenuBool>().Enabled;
bool useW = WorldMenu.Combo["useW"].As <MenuBool>().Enabled;
bool useE = WorldMenu.Combo["useE"].As <MenuBool>().Enabled;
bool useR = WorldMenu.Combo["useR"].As <MenuBool>().Enabled;
var percentHealW = WorldMenu.Combo["lifeW"].As <MenuSlider>().Value;
var percentHealR = WorldMenu.Combo["lifeR"].As <MenuSlider>().Value;
var target = TargetSelector.GetTarget(ManageSpells.Q.Range);
if (!target.IsValidTarget())
{
return;
}
if (useQ && ManageSpells.Q.Ready)
{
if (target.IsValidTarget())
{
ManageSpells.Q.Cast(target);
}
}
if (useW && ManageSpells.W.Ready && Player.HealthPercent() <= percentHealW)
{
ManageSpells.W.Cast(Player);
}
if (useE && ManageSpells.E.Ready)
{
if (target.IsValidTarget())
{
ManageSpells.E.Cast(Player);
}
}
if (useR && ManageSpells.R.Ready && Player.HealthPercent() <= percentHealR)
{
ManageSpells.R.Cast(Player);
}
}
public static bool ShouldJump(Vector3 position, Obj_AI_Hero target = null)
{
if (!Variables.Menu["safety"]["enabled"].Enabled)
{
return(true);
}
if (Variables.Menu["safety"]["turretCheck"].Enabled && position.PointUnderEnemyTurret())
{
return(false);
}
else if (Variables.Menu["safety"]["enabled"].Enabled)
{
if (ObjectManager.GetLocalPlayer().HealthPercent() < Variables.Menu["safety"]["minHealth"].Value &&
ObjectManager.GetLocalPlayer().GetBurstDamage(target) < target.HealthPercent())
{
return(false);
}
if (Variables.Menu["safety"]["countCheck"].Enabled)
{
var enemies = position.GetEnemiesInRange(400);
var allies = position.GetAlliesInRange(400);
var ec = enemies.Count;
var ac = allies.Count;
//if no enemies within 400 radius of jumping position then dont jump
if (ec == 0)
{
return(false);
}
float ratio = ac / ec;
var setratio = Variables.Menu["safety"]["ratio"].Value / 5f;
//Ratio of allies:enemies
//if < allies then enemies
if (ratio < setratio)
{
return(false);
}
}
return(true);
}
return(false);
}
private void ProtectorOnTargetedProtection(Obj_AI_Base caster, Obj_AI_Hero target, SpellData spell)
{
try
{
if (!ConfigValue <bool>("Misc.Shield.Target"))
{
return;
}
if (Orbwalking.IsAutoAttack(spell.Name) &&
target.HealthPercent() > ConfigValue <Slider>("Misc.Shield.Health").Value)
{
return;
}
if (spell.MissileSpeed > 2000 || spell.MissileSpeed == 0)
{
return;
}
// TODO: blacklist FiddleQ, FioraQ/R, LeonaE, VladQ, ZileanQ
if (target.IsMe && E.IsReady())
{
CastShield(caster.Position);
}
if (!target.IsMe && W.IsReady() && W.IsInRange(target) && (IsShieldActive || E.IsReady()))
{
var jumpTime = (Player.Distance(target) * 1000 / W.Instance.SData.MissileSpeed) +
(W.Instance.SData.SpellCastTime * 1000);
var missileTime = caster.Distance(target) * 1000 / spell.MissileSpeed;
if (jumpTime > missileTime)
{
Console.WriteLine("Abort Jump - Missile too Fast: {0} {1}", jumpTime, missileTime);
return;
}
W.CastOnUnit(target, UsePackets);
Utility.DelayAction.Add((int)jumpTime, () => CastShield(caster.Position));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private void Game_OnUpdate()
{
if (Player.IsDead || MenuGUI.IsChatOpen())
{
return;
}
switch (Orbwalker.Mode)
{
case OrbwalkingMode.Combo:
OnCombo();
break;
case OrbwalkingMode.Mixed:
OnHarass();
break;
case OrbwalkingMode.Laneclear:
OnLaneClear();
OnJungleClear();
break;
}
Killsteal();
if (Q.Ready && Menu["misc"]["autoq"].Enabled)
{
foreach (var target in GameObjects.EnemyHeroes.Where(
t => (t.HasBuffOfType(BuffType.Charm) || t.HasBuffOfType(BuffType.Stun) ||
t.HasBuffOfType(BuffType.Fear) || t.HasBuffOfType(BuffType.Snare) ||
t.HasBuffOfType(BuffType.Taunt) || t.HasBuffOfType(BuffType.Knockback) ||
t.HasBuffOfType(BuffType.Suppression)) && t.IsValidTarget(Q.Range) &&
!Invulnerable.Check(t, DamageType.Magical)))
{
Q.Cast(target);
}
}
var EkkoR = ObjectManager.Get <GameObject>().FirstOrDefault(o => o.IsValid && o.Name == "Ekko_Base_R_TrailEnd.troy");
bool autoR = Menu["misc"]["autor"].Enabled;
float hpR = Menu["misc"]["minhp"].As <MenuSlider>().Value;
if (R.Ready && EkkoR != null && autoR && Player.HealthPercent() <= hpR)
{
R.Cast();
}
}
private void ProtectorOnTargetedProtection(Obj_AI_Base caster, Obj_AI_Hero target, SpellData spell)
{
try
{
if (!ConfigValue<bool>("Misc.Shield.Target"))
return;
if (Orbwalking.IsAutoAttack(spell.Name) &&
target.HealthPercent() > ConfigValue<Slider>("Misc.Shield.Health").Value)
return;
if (spell.MissileSpeed > 2000 || spell.MissileSpeed == 0)
return;
// TODO: blacklist FiddleQ, FioraQ/R, LeonaE, VladQ, ZileanQ
if (target.IsMe && E.IsReady())
{
CastShield(caster.Position);
}
if (!target.IsMe && W.IsReady() && W.IsInRange(target) && (IsShieldActive || E.IsReady()))
{
var jumpTime = (Player.Distance(target)*1000/W.Instance.SData.MissileSpeed) +
(W.Instance.SData.SpellCastTime*1000);
var missileTime = caster.Distance(target)*1000/spell.MissileSpeed;
if (jumpTime > missileTime)
{
Console.WriteLine("Abort Jump - Missile too Fast: {0} {1}", jumpTime, missileTime);
return;
}
W.CastOnUnit(target, UsePackets);
Utility.DelayAction.Add((int) jumpTime, () => CastShield(caster.Position));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
internal static bool R2Logic(Obj_AI_Hero target)
{
if (target == null || !target.IsValidTarget() || !MyLogic.isRActive ||
MyLogic.ComboMenu["FlowersRiven.ComboMenu.RMode"].As <MenuList>().Value == 3 ||
!MyLogic.ComboMenu["FlowersRiven.ComboMenu.RTargetFor" + target.ChampionName].Enabled)
{
return(false);
}
switch (MyLogic.ComboMenu["FlowersRiven.ComboMenu.RMode"].As <MenuList>().Value)
{
case 0:
if (target.HealthPercent() < 20 ||
target.Health >
ObjectManager.GetLocalPlayer().GetSpellDamage(target, SpellSlot.R) +
ObjectManager.GetLocalPlayer().GetAutoAttackDamage(target) * 2 && target.HealthPercent() < 40 ||
target.Health <= ObjectManager.GetLocalPlayer().GetSpellDamage(target, SpellSlot.R) ||
target.Health <= GetComboDamage(target))
{
return(MyLogic.R.Cast(target.ServerPosition));
}
break;
case 1:
if (ObjectManager.GetLocalPlayer().GetSpellDamage(target, SpellSlot.R) > target.Health && target.DistanceToPlayer() < 600)
{
return(MyLogic.R.Cast(target.ServerPosition));
}
break;
case 2:
if (target.DistanceToPlayer() < 600)
{
return(MyLogic.R.Cast(target.ServerPosition));
}
break;
}
return(false);
}
private void RCombo()
{
var target = GetBestEnemyHeroTargetInRange(R.Range);
if (!target.IsValidTarget())
{
return;
}
bool useR = Menu["combo"]["user"].Enabled;
float RHp = Menu["combo"]["rhp"].As <MenuSlider>().Value;
float REnemies = Menu["combo"]["defr"].As <MenuSlider>().Value;
if (R.Ready && useR && Player.HealthPercent() <= RHp && target.IsValidTarget(R.Range))
{
R.Cast(Player);
}
if (R.Ready && useR && target.IsValidTarget(R.Range) && Player.CountEnemyHeroesInRange(R.Range - 50) >= REnemies)
{
R.Cast(Player);
}
}
/// <summary>
/// Checks if the specified target is invulnerable.
/// </summary>
/// <param name="hero">The target.</param>
/// <param name="damageType">Type of the damage.</param>
/// <param name="ignoreShields">if set to <c>true</c> [ignore shields].</param>
/// <param name="damage">The damage.</param>
/// <returns></returns>
public static bool Check(
Obj_AI_Hero hero,
DamageType damageType = DamageType.True,
bool ignoreShields = true,
float damage = -1f)
{
if (hero.ValidActiveBuffs().Any(b => b.Type == BuffType.Invulnerability))
{
return(true);
}
foreach (var entry in Entries)
{
if (entry.ChampionName == null || entry.ChampionName == hero.ChampionName)
{
if (entry.DamageType == null || entry.DamageType == damageType)
{
if (hero.HasBuff(entry.BuffName))
{
if (!ignoreShields || !entry.IsShield)
{
if (entry.CheckFunction == null || ExecuteCheckFunction(entry, hero, damageType))
{
if (entry.MinHealthPercent <= 0 || hero.HealthPercent() < entry.MinHealthPercent)
{
return(true);
}
}
}
}
}
}
}
return(false);
}
private void OnCombo()
{
var target = GetBestEnemyHeroTargetInRange(E.Range);
if (!target.IsValidTarget())
{
return;
}
bool useQ = Menu["combo"]["useq"].Enabled;
if (Q.Ready && useQ && target.IsValidTarget(Q.Range))
{
switch (Menu["combo"]["qco"].As <MenuList>().Value)
{
case 0:
Q.Cast(target);
break;
case 1:
Q2.Cast(target);
break;
}
}
bool useW = Menu["combo"]["usew"].Enabled;
float hpW = Menu["combo"]["whp"].As <MenuSlider>().Value;
if (W.Ready && useW && target.IsValidTarget(500))
{
switch (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState)
{
case 1:
if (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 1 && Player.HealthPercent() > hpW)
{
W.Cast();
}
break;
case 2:
if (Player.SpellBook.GetSpell(SpellSlot.W).ToggleState == 2 && Player.HealthPercent() < hpW)
{
W.Cast();
}
break;
}
}
bool useE = Menu["combo"]["usee"].Enabled;
if (E.Ready && target.IsValidTarget(E.Range) && useE)
{
E.Cast(target);
}
bool useR = Menu["combo"]["user"].Enabled;
float thpR = Menu["combo"]["rhp"].As <MenuSlider>().Value;
float thR = Menu["combo"]["rce"].As <MenuSlider>().Value;
if (R.Ready && useR && target.IsValidTarget(R.Range) && Player.CountEnemyHeroesInRange(R.Range) >= thR || target.HealthPercent() < thpR)
{
R.Cast();
}
}
static void HealUltManager(bool forceheal = false, bool forceult = false, Obj_AI_Hero target = null)
{
if (W.Ready)
{
if (Game.TickCount - LastHealDetection < 1000 && HealTarget.IsValidTarget(W.Range, false))
{
var setvaluehealt = Getslider("hpct" + HealTarget.ChampionName);
if (HealTarget.Health <= setvaluehealt)
{
W.Cast(HealTarget);
}
}
}
if (R.Ready)
{
if (Game.TickCount - LastUltDetection < 1000 && UltTarget.IsValidTarget(R.Range, false))
{
var setvalueult = Getslider("upct" + UltTarget.ChampionName);
if (UltTarget.Health <= setvalueult)
{
R.Cast(UltTarget);
}
}
}
if (forceheal && target != null && W.Ready && Player.Distance(target) <= W.Range)
{
W.CastOnUnit(target);
return;
}
if (forceult && target != null && R.Ready && Player.Distance(target) <= R.Range)
{
if (debug())
{
Console.WriteLine("Forceult");
}
R.CastOnUnit(target);
return;
}
if (GetBool("Healingon") && !GetBool("onlyhincdmg"))
{
var herolistheal = GameObjects.AllyHeroes
.Where(
h =>
!h.IsDead && GetBool("heal" + h.ChampionName) &&
h.HealthPercent() <= Getslider("hpct" + h.ChampionName) && Player.Distance(h) <= R.Range)
.OrderByDescending(i => i.IsMe)
.ThenBy(i => i.HealthPercent());
if (W.Ready)
{
if (herolistheal.Contains(Player) && !Player.IsRecalling())
{
W.CastOnUnit(Player);
return;
}
else if (herolistheal.Any())
{
var hero = herolistheal.FirstOrDefault();
if (Player.Distance(hero) <= R.Range && !Player.IsRecalling() && !hero.IsRecalling())
{
W.CastOnUnit(hero);
return;
}
}
}
}
if (GetBool("Ultingon") && !GetBool("onlyuincdmg"))
{
Console.WriteLine(Player.HealthPercent());
var herolist = GameObjects.AllyHeroes
.Where(
h =>
!h.IsDead &&
GetBool("ult" + h.ChampionName) &&
h.HealthPercent() <= Getslider("upct" + h.ChampionName) &&
Player.Distance(h) <= R.Range && Player.CountEnemyHeroesInRange(500) > 0).OrderByDescending(i => i.IsMe).ThenBy(i => i.HealthPercent());
if (R.Ready)
{
if (herolist.Contains(Player))
{
if (debug())
{
Console.WriteLine("regultself");
}
R.CastOnUnit(Player);
return;
}
else if (herolist.Any())
{
var hero = herolist.FirstOrDefault();
if (Player.Distance(hero) <= R.Range)
{
if (debug())
{
Console.WriteLine("regultotherorself");
}
R.CastOnUnit(hero);
return;
}
}
}
}
}
private void Game_OnUpdate()
{
if (Player.IsDead || MenuGUI.IsChatOpen() || Player.IsRecalling())
{
return;
}
switch (Orbwalker.Mode)
{
case OrbwalkingMode.Combo:
OnCombo();
break;
case OrbwalkingMode.Mixed:
OnHarass();
break;
case OrbwalkingMode.Laneclear:
Jungle();
break;
}
Killsteal();
if (Menu["misc"]["autoq"].Enabled && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "JavelinToss")
{
foreach (var target in GameObjects.EnemyHeroes.Where(
t => (t.HasBuffOfType(BuffType.Charm) || t.HasBuffOfType(BuffType.Stun) ||
t.HasBuffOfType(BuffType.Fear) || t.HasBuffOfType(BuffType.Snare) ||
t.HasBuffOfType(BuffType.Taunt) || t.HasBuffOfType(BuffType.Knockback) ||
t.HasBuffOfType(BuffType.Suppression)) && t.IsValidTarget(QH.Range) &&
!Invulnerable.Check(t, DamageType.Magical)))
{
QH.Cast(target);
}
}
if (Menu["misc"]["autow"].Enabled && Player.SpellBook.GetSpell(SpellSlot.W).Name == "Bushwhack")
{
foreach (var target in GameObjects.EnemyHeroes.Where(
t => (t.HasBuffOfType(BuffType.Charm) || t.HasBuffOfType(BuffType.Stun) ||
t.HasBuffOfType(BuffType.Fear) || t.HasBuffOfType(BuffType.Snare) ||
t.HasBuffOfType(BuffType.Taunt) || t.HasBuffOfType(BuffType.Knockback) ||
t.HasBuffOfType(BuffType.Suppression)) && t.IsValidTarget(WH.Range) &&
!Invulnerable.Check(t, DamageType.Magical)))
{
WH.Cast(target);
}
}
float hp = Menu["misc"]["autoeh"].As <MenuSlider>().Value;
if (Menu["misc"]["autoe"].Enabled && EH.Ready && Player.SpellBook.GetSpell(SpellSlot.E).Name == "PrimalSurge" && Player.HealthPercent() <= hp)
{
EH.Cast(Player);
}
if (Menu["flee"]["key"].Enabled)
{
Flee();
}
}
public static bool IsHealthy(this Obj_AI_Hero source)
{
return(source.HealthPercent() >= Variables.Menu["safety"]["minHealth"].Value);
}
private void OnUpdate()
{
var Modes = new Modes();
var percentHealW = WorldMenu.miscs["lifeW"].As <MenuSlider>().Value;
var percentHealR = WorldMenu.miscs["lifeR"].As <MenuSlider>().Value;
if (Player.IsDead || MenuGUI.IsChatOpen())
{
return;
}
switch (Orbwalker.Implementation.Mode)
{
case OrbwalkingMode.Combo:
Modes.Combo();
break;
case OrbwalkingMode.Mixed:
Modes.Harass();
break;
case OrbwalkingMode.Laneclear:
Modes.LaneClear();
break;
}
if (WorldMenu.miscs["autoW"].As <MenuBool>().Enabled&& ManageSpells.W.Ready && Player.HealthPercent() <= percentHealW && !(Player.IsRecalling()))
{
ManageSpells.W.Cast(Player);
}
if (WorldMenu.miscs["autoR"].As <MenuBool>().Enabled&& ManageSpells.R.Ready && Player.HealthPercent() <= percentHealR && !(Player.IsRecalling()))
{
ManageSpells.R.Cast(Player);
}
}
private static void AutoPeel()
{
if (Setup.Misc["Peel"].As <MenuBool>().Enabled&& Spells.E.Ready)
{
var target = TargetSelector.GetTarget(450);
if (target != null && target.AttackRange < 400 && Setup.Misc["HP"].As <MenuSlider>().Value > Player.HealthPercent())
{
Spells.E.Cast(target);
}
}
}
private void Combo()
{
bool useQ = Menu["combo"]["useq"].Enabled;
if (Q.Ready && useQ)
{
var target = GetBestEnemyHeroTargetInRange(Q.Range);
if (target != null)
{
Q.Cast(target);
}
}
bool useW = Menu["combo"]["usew"].Enabled;
float useWhp = Menu["combo"]["usewhp"].As <MenuSlider>().Value;
if (W.Ready && useW && Player.HealthPercent() <= useWhp)
{
var target = GetBestEnemyHeroTargetInRange(W.Range);
if (target != null)
{
W.Cast();
}
}
bool useE = Menu["combo"]["usee"].Enabled;
if (E.Ready && useE)
{
switch (Player.SpellBook.GetSpell(SpellSlot.E).ToggleState)
{
case 0:
var etarget = GetBestEnemyHeroTargetInRange(E.Range);
if (etarget != null)
{
if (etarget.IsValidTarget(E.Range) && Player.SpellBook.GetSpell(SpellSlot.E).ToggleState == 0)
{
E.Cast(etarget);
}
}
break;
case 1:
var target = GetBestEnemyHeroTargetInRange(E2.Range);
if (missiles != null && target != null)
{
if (target.IsValidTarget(350f, false, false, missiles.ServerPosition) && Player.SpellBook.GetSpell(SpellSlot.E).ToggleState == 1)
{
E2.Cast();
}
}
break;
}
}
bool useR = Menu["combo"]["user"].Enabled;
if (R.Ready && useR)
{
var target = GetBestEnemyHeroTargetInRange(R.Range);
if (target != null && R.CastIfWillHit(target, Menu["combo"]["userhit"].As <MenuSlider>().Value - 1))
{
R.Cast(target);
}
}
}
private static bool CanbeRKillAble(Obj_AI_Hero target)
{
return(target != null && target.IsValidTarget() && isRActive && HaveRBuff(target) && target.HealthPercent() < 25 && R.Ready);
}
private void OnCombo()
{
bool useQ = Menu["combo"]["useq"].Enabled;
bool useW = Menu["combo"]["usew"].Enabled;
float WHP = Menu["combo"]["whp"].As <MenuSlider>().Value;
bool useE = Menu["combo"]["usee"].Enabled;
bool useR = Menu["combo"]["user"].Enabled;
var target = GetBestEnemyHeroTargetInRange(Player.AttackRange + 800);
if (target.IsValidTarget())
{
switch (Menu["combo"]["cs"].As <MenuList>().Value)
{
case 0:
if (useE && E.Ready)
{
if (Player.Distance(target) > E.Range)
{
E.Cast();
}
else if (Player.Distance(target) <= E.Range && !target.HasBuff("udyrbearstuncheck"))
{
E.Cast();
}
}
if (useR && R.Ready && !Player.HasBuff("UdyrPhoenixStance") && Player.Distance(target) <= R.Range && target.HasBuff("udyrbearstuncheck"))
{
R.Cast();
}
if (useQ && Q.Ready && Player.Distance(target) <= Q.Range && target.HasBuff("udyrbearstuncheck"))
{
Q.Cast();
}
break;
case 1:
if (useE && E.Ready)
{
if (Player.Distance(target) > E.Range)
{
E.Cast();
}
else if (Player.Distance(target) <= E.Range && !target.HasBuff("udyrbearstuncheck"))
{
E.Cast();
}
}
if (useQ && Q.Ready && Player.Distance(target) <= Q.Range && target.HasBuff("udyrbearstuncheck"))
{
Q.Cast();
}
if (useR && R.Ready && !Player.HasBuff("UdyrPhoenixStance") && Player.Distance(target) <= R.Range && target.HasBuff("udyrbearstuncheck"))
{
R.Cast();
}
break;
}
}
if (useW && Player.Distance(target) < 1000)
{
if (Player.HealthPercent() <= WHP && !Player.HasBuff("udyrmonkeyagilitybuff"))
{
W.Cast();
}
}
}
private void OnCombo()
{
bool useQ = Menu["combo"]["useq"].Enabled;
if (Q.Ready && useQ && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "YasuoQW" && !Player.IsDashing())
{
var qtarget = GetBestEnemyHeroTargetInRange(Q.Range);
if (qtarget.IsValidTarget(Q.Range) && qtarget != null)
{
Q.Cast(qtarget);
}
}
if (Q.Ready && useQ && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "YasuoQ2W" && !Player.IsDashing())
{
var qtarget = GetBestEnemyHeroTargetInRange(Q2.Range);
if (qtarget.IsValidTarget(Q2.Range) && qtarget != null)
{
Q2.Cast(qtarget);
}
}
bool useQ2 = Menu["combo"]["useq"].Enabled;
if (Q.Ready && useQ2 && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "YasuoQ3W" && !Player.IsDashing())
{
var qtarget = GetBestEnemyHeroTargetInRange(Q3.Range);
if (qtarget.IsValidTarget(Q3.Range) && qtarget != null)
{
Q3.Cast(qtarget);
}
}
bool useE = Menu["combo"]["usee"].Enabled;
if (E.Ready && useE)
{
var etarget = GetBestEnemyHeroTargetInRange(E.Range);
if (etarget.IsValidTarget(E.Range) && etarget != null)
{
E.Cast(etarget);
}
}
if (R.Ready)
{
var rtarget = GetBestEnemyHeroTargetInRange(R.Range);
bool useSmartR = Menu["combo"]["usersmart"].Enabled;
float tRHP = Menu["combo"]["userhp"].As <MenuSlider>().Value;
float hitR = Menu["combo"]["userhit"].As <MenuSlider>().Value;
bool useR = Menu["combo"]["userauto"].Enabled;
float hittR = Menu["combo"]["userautohit"].As <MenuSlider>().Value;
float aroundTR = Menu["combo"]["useraround"].As <MenuSlider>().Value;
float selfhpR = Menu["combo"]["usermyhp"].As <MenuSlider>().Value;
if (useSmartR && rtarget != null)
{
var KockedUp = GameObjects.EnemyHeroes
.Where(x => x.IsValidTarget(R.Range))
.Where(x => x.HasBuffOfType(BuffType.Knockback) || x.HasBuffOfType(BuffType.Knockup));
var enemies = KockedUp as IList <Obj_AI_Hero> ?? KockedUp.ToList();
if (enemies.Count >= hitR && rtarget != null)
{
R.CastOnUnit(enemies.FirstOrDefault());
}
else if (rtarget.HealthPercent() <= tRHP)
{
R.Cast();
}
}
else if (useR && rtarget != null)
{
var KockedUp = GameObjects.EnemyHeroes
.Where(x => x.IsValidTarget(R.Range))
.Where(x => x.HasBuffOfType(BuffType.Knockback) || x.HasBuffOfType(BuffType.Knockup));
var enemies = KockedUp as IList <Obj_AI_Hero> ?? KockedUp.ToList();
if (enemies.Count >= hittR)
{
R.CastOnUnit(enemies.FirstOrDefault());
}
else if (rtarget.CountEnemyHeroesInRange(700) <= aroundTR && (rtarget.HasBuffOfType(BuffType.Knockup) || rtarget.HasBuffOfType(BuffType.Knockback)))
{
R.Cast();
}
else if (Player.HealthPercent() >= selfhpR && (rtarget.HasBuffOfType(BuffType.Knockup) || rtarget.HasBuffOfType(BuffType.Knockback)))
{
R.Cast();
}
}
}
}
