public void OnInitialize(int version)
{
Logger.KefkaLog($"Initializing Version: GitHub {System.Windows.Forms.Application.ProductVersion}");
TreeRoot.OnStart += OnBotStart;
TreeRoot.OnStop += OnBotStop;
if (version == 2)
{
IsChineseVersion = true;
}
HookBehaviors();
InterruptManager.ResetInterrupts();
IgnoreTargetManager.ResetIgnoreTargets();
TankBusterManager.ResetTankBusters();
OpenerManager.ResetOpeners();
CombatHelper.ResetLastUsed();
}
private void Orbwalking_BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
{
if (args.Unit.IsMe && stance == Stance.Phoenix && player.GetBuff("UdyrPhoenixStance").Count == 3)
{
justR2 = true;
LeagueSharp.Common.Utility.DelayAction.Add((int)(player.AttackDelay * 1000), () => justR2 = false);
}
if (!args.Unit.IsMe || !R.IsReady())
{
return;
}
var target =
HeroManager.Enemies.FirstOrDefault(
h => h.Distance(player) < R2.Range && CombatHelper.IsFacing(player, h.Position, 45f));
if (target != null && orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo)
{
Harass();
}
}
public override void OnEnemyClick(Enemy clickedEnemy)
{
if (_currentEnemy != clickedEnemy)
{
_currentEnemy = clickedEnemy;
_clickCount = 0;
}
_clickCount++;
if (_clickCount == ClickThreshold)
{
var damageDealt = _currentEnemy is Monster ? (int)Math.Ceiling(_currentEnemy.Health * DamageAgainstMonsters) : (int)Math.Ceiling(_currentEnemy.Health * DamageAgainstBosses);
CombatHelper.DealDamageToEnemy(_currentEnemy, damageDealt, DamageType.Magic);
_clickCount = 0;
}
base.OnEnemyClick(clickedEnemy);
}
private static void Combo()
{
Ulti();
float perc = (float)config.Item("minmana").GetValue <Slider>().Value / 100f;
var minHit = config.Item("useemin").GetValue <Slider>().Value;
Obj_AI_Hero target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target);
}
if (W.IsReady() && config.Item("usew").GetValue <bool>() && me.CountEnemysInRange((int)me.AttackRange) > 0 && me.Spellbook.GetSpell(SpellSlot.W).ManaCost <= me.Mana)
{
W.Cast();
}
var buffs = CombatHelper.SejuaniCountFrostHero(E.Range);
if (E.IsReady() && me.Distance(target.Position) < E.Range && buffs > 0 && (
(buffs > minHit) ||
(Damage.GetSpellDamage(me, target, SpellSlot.E) >= target.Health) ||
(me.Distance(target) > config.Item("useEminr").GetValue <Slider>().Value&& me.Distance(target) < E.Range && buffs == 1)))
{
if (!(Q.IsReady() && me.Mana - me.Spellbook.GetSpell(SpellSlot.Q).ManaCost < me.MaxMana * perc) || !(W.IsReady() && me.Mana - me.Spellbook.GetSpell(SpellSlot.W).ManaCost < me.MaxMana * perc))
{
E.Cast();
}
}
if (Q.IsReady() && config.Item("useq").GetValue <bool>() && me.Spellbook.GetSpell(SpellSlot.Q).ManaCost <= me.Mana)
{
Q.Cast(target, config.Item("packets").GetValue <bool>());
}
bool hasIgnite = me.Spellbook.CanUseSpell(me.GetSpellSlot("SummonerDot")) == SpellState.Ready;
var ignitedmg = (float)me.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
if (ignitedmg > target.Health && hasIgnite && !E.CanCast(target) && !W.CanCast(target) && !Q.CanCast(target))
{
me.Spellbook.CastSpell(me.GetSpellSlot("SummonerDot"), target);
}
}
private void HandeR(Obj_AI_Base target, Vector3 toVector3, bool toBarrel)
{
if (target == null || !toVector3.IsValid())
{
return;
}
if (target.HasBuffOfType(BuffType.Snare) || target.HasBuffOfType(BuffType.Stun) ||
target.HasBuffOfType(BuffType.Suppression) ||
target.HasBuffOfType(BuffType.Knockup) && !target.HasBuffOfType(BuffType.Knockback) && !target.IsMoving &&
!target.IsDashing() && !justE)
{
var pred = Prediction.GetPrediction(target, 1000f);
var cast = pred.UnitPosition.Extend(toVector3, -200);
if (player.Distance(cast) < R.Range && checkBuffs(target, player.Distance(cast)) &&
pred.UnitPosition.Distance(target.Position) < 15 &&
((!CombatHelper.CheckWalls(target.Position, toVector3)) ||
(toBarrel && savedQ.position.Distance(target.Position) < QExplosionRange)))
{
if (toBarrel &&
4000 - savedQ.deltaT() > (player.Distance(cast) + cast.Distance(savedQ.position)) / R.Speed)
{
R.Cast(cast);
return;
}
else if (!toBarrel)
{
R.Cast(cast);
}
}
}
/*
* if (!config.Item("insecOnlyStun", true).GetValue<bool>())
* {
* var cast = R.GetPrediction(target, true, 90);
* if (cast.Hitchance >= HitChance.VeryHigh)
* {
* R.Cast(cast.CastPosition.Extend(savedQ.position, -100));
* }
* }*/
}
private Vector3 GetVectorE(AIHeroClient target)
{
var pos = Vector3.Zero;
var pred = Prediction.GetPrediction(target, 0.28f);
if (!target.IsMoving)
{
return(pos);
}
var distW = E.Width / 2 + target.BoundingRadius;
var points = CombatHelper.PointsAroundTheTarget(pred.UnitPosition, distW);
var walls =
points.Where(p => p.IsWall() && player.Distance(target) > target.BoundingRadius)
.OrderBy(p => p.Distance(pred.UnitPosition));
var wall = walls.FirstOrDefault();
if (wall.IsValid() && wall.Distance(target.Position) < 350 &&
walls.Any(w => w.Distance(target.Position) < distW))
{
pos = wall.Extend(pred.UnitPosition, (target.BoundingRadius + distW));
}
if (config.Item("useeWall", true).GetValue <bool>())
{
return(pos);
}
if (pred.Hitchance < HitChance.Medium || target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target))
{
return(pos);
}
if (pred.UnitPosition.Distance(player.Position) > player.Distance(target))
{
var dist = target.BoundingRadius + E.Width;
var predPos = pred.UnitPosition;
if (target.Distance(predPos) < dist)
{
predPos = target.Position.Extend(predPos, dist);
}
pos = predPos.Extend(target.Position, -dist);
}
return(pos);
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(1490, TargetSelector.DamageType.Physical);
if (target == null)
{
return;
}
if (config.Item("selected").GetValue <bool>())
{
target = CombatHelper.SetTarget(target, TargetSelector.GetSelectedTarget());
orbwalker.ForceTarget(target);
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
if (config.Item("useq").GetValue <bool>() && Q.IsReady() && !QEnabled && player.Distance(target) >= config.Item("useqmin").GetValue <Slider>().Value&& player.Distance(target) < (player.MoveSpeed * MsBonus(target)) * 3.0f)
{
Q.Cast(config.Item("packets").GetValue <bool>());
}
if (config.Item("usew").GetValue <bool>() && CanW && W.CanCast(target) && (player.CalcDamage(target, Damage.DamageType.Physical, Wdmg(target)) > target.Health || player.HealthPercent < 10))
{
W.Cast(target, config.Item("packets").GetValue <bool>());
}
if (config.Item("usee").GetValue <bool>() && E.CanCast(target) && ((config.Item("useenotccd").GetValue <bool>() && (!target.HasBuffOfType(BuffType.Snare) && !target.HasBuffOfType(BuffType.Slow) && !target.HasBuffOfType(BuffType.Stun) && !target.HasBuffOfType(BuffType.Suppression))) || !config.Item("useenotccd").GetValue <bool>()))
{
E.Cast(config.Item("packets").GetValue <bool>());
}
if (R.IsReady() && player.HealthPercent > 20 && ((config.Item("user").GetValue <bool>() && player.Distance(target) < 200 && ComboDamage(target) + R.GetDamage(target) * 10 > target.Health && ComboDamage(target) < target.Health) || (config.Item("usertf").GetValue <Slider>().Value <= player.CountEnemiesInRange(300))))
{
R.Cast(config.Item("packets").GetValue <bool>());
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite && !W.CanCast(target))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
}
public void Pulse()
{
Monitor.OverlayUpdate();
if (DateTime.Now < _pulseLimiter)
{
return;
}
_pulseLimiter = DateTime.Now.AddSeconds(1);
if (DateTime.Now > _saveFormTime)
{
FormManager.SaveFormInstances();
if (Me.ClassLevel < 70)
{
Logger.KefkaLog("We are currently level synced to level {0}", Me.ClassLevel);
}
if (_inInstance && Common_Utils.InActiveInstance())
{
Logger.DebugLog($"Instance Time Remaining: {Common_Utils.InstanceTimeRemaining}");
}
_saveFormTime = DateTime.Now.AddSeconds(60);
}
try
{
Group.UpdateAllies();
}
catch (Exception e)
{
Logger.KefkaLog(e.ToString());
}
Monitor.SpellLog();
AutoDuty.AutoDutyRoot();
FormManager.Window_Check();
TargetSelectorManager.UpdatePartyMembers();
CombatHelper.ResetLastUsed();
}
private static void FlashCombo()
{
var target = TargetSelector.GetTarget(EFlash.Range, DamageType.Magical);
if (target != null && E.IsReady() && E.ManaCost < player.Mana &&
player.LSDistance(target.Position) < EFlash.Range && player.LSDistance(target.Position) > 480 &&
!getPosToEflash(target.Position).IsWall())
{
var pred = EFlash.GetPrediction(target);
var poly = CombatHelper.GetPolyFromVector(getPosToEflash(target.Position), pred.UnitPosition, E.Width);
var enemiesBehind =
HeroManager.Enemies.Count(
e =>
e.NetworkId != target.NetworkId && e.LSIsValidTarget(E.Range) &&
(poly.IsInside(E.GetPrediction(e).UnitPosition) || poly.IsInside(e.Position)) &&
e.Position.LSDistance(player.Position) > player.LSDistance(pred.UnitPosition));
if (pred.HitChance >= EloBuddy.SDK.Enumerations.HitChance.High)
{
Utility.DelayAction.Add(
30, () =>
{
if (enemiesBehind > 0)
{
E.Cast(
player.ServerPosition.LSExtend(pred.CastPosition, E.Range),
getCheckBoxItem(config, "packets"));
}
else
{
E.Cast(
player.ServerPosition.LSExtend(
pred.CastPosition,
player.LSDistance(pred.CastPosition) + Orbwalking.GetRealAutoAttackRange(target)),
getCheckBoxItem(config, "packets"));
}
});
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), getPosToEflash(target.Position));
}
}
Orbwalker.MoveTo(Game.CursorPos);
}
private void Game_ProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe)
{
if (args.SData.Name == "RumbleGrenade")
{
var dist = player.Distance(args.End);
justE = true;
Utility.DelayAction.Add(
(int)((dist > E.Range ? E.Range : dist) / E.Speed * 1000), () => justE = false);
lastE = System.Environment.TickCount;
}
}
if (config.Item("usew", true).GetValue <bool>() && sender is Obj_AI_Hero && sender.IsEnemy &&
player.Distance(sender) < Q.Range &&
CombatHelper.isDangerousSpell(
args.SData.Name, args.Target as Obj_AI_Hero, sender as Obj_AI_Hero, args.End, float.MaxValue))
{
W.Cast();
}
}
private static double getEDamage(AIHeroClient target, bool bufftime = false)
{
var spins = 0d;
if (bufftime)
{
spins = CombatHelper.GetBuffTime(player.GetBuff("GarenE")) * GetSpins() / 3;
}
else
{
spins = GetSpins();
}
var dmg = (baseEDamage[E.Level - 1] + bonusEDamage[E.Level - 1] / 100 * player.TotalAttackDamage) * spins;
var bonus = target.HasBuff("garenpassiveenemytarget") ? target.MaxHealth / 100f * spins : 0;
if (ObjectManager.Get <Obj_AI_Base>().Count(o => o.LSIsValidTarget() && o.LSDistance(target) < 650) == 0)
{
return(player.CalcDamage(target, DamageType.Physical, dmg) * 1.33 + bonus);
}
return(player.CalcDamage(target, DamageType.Physical, dmg) + bonus);
}
public override void OnDealingClickDamage(ref int clickDamage, DamageType clickDamageType)
{
if (_isNextClickEmpowered)
{
_isNextClickEmpowered = false;
if (clickDamageType == DamageType.Normal)
{
var criticalDamageDealt = (int)Math.Ceiling(clickDamage * User.Instance.CurrentHero.CritDamage);
CombatHelper.DealDamageToCurrentEnemy(criticalDamageDealt, DamageType.Critical);
CombatHelper.DealDamageToCurrentEnemy((int)(criticalDamageDealt * DamageModifier), DamageType.Magic);
clickDamage = 0;
}
else if (clickDamageType == DamageType.Critical)
{
CombatHelper.DealDamageToCurrentEnemy((int)(clickDamage * DamageModifier), DamageType.Magic);
}
}
}
private static void CastETarget(AIHeroClient target)
{
var pred = E.GetPrediction(target);
var poly = CombatHelper.GetPoly(pred.UnitPosition, E.Range, E.Width);
var enemiesBehind =
HeroManager.Enemies.Count(
e =>
e.NetworkId != target.NetworkId && e.LSIsValidTarget(E.Range) &&
(poly.IsInside(E.GetPrediction(e).UnitPosition) || poly.IsInside(e.Position)) &&
e.Position.LSDistance(player.Position) > player.LSDistance(pred.UnitPosition));
if (pred.HitChance >= EloBuddy.SDK.Enumerations.HitChance.High)
{
if (enemiesBehind > 0)
{
E.Cast(
player.ServerPosition.LSExtend(pred.CastPosition, E.Range),
getCheckBoxItem(config, "packets"));
}
else
{
if (poly.IsInside(pred.UnitPosition) && poly.IsInside(target.Position))
{
E.Cast(
player.ServerPosition.LSExtend(
pred.CastPosition,
player.LSDistance(pred.CastPosition) + Orbwalking.GetRealAutoAttackRange(target)),
getCheckBoxItem(config, "packets"));
}
else
{
E.Cast(
player.ServerPosition.LSExtend(
pred.CastPosition,
player.LSDistance(pred.CastPosition) + Orbwalking.GetRealAutoAttackRange(target)),
getCheckBoxItem(config, "packets"));
}
}
}
}
private void CastW()
{
if (justW)
{
return;
}
var allyW = ObjectManager.Get <Obj_AI_Base>().FirstOrDefault(o => o.HasBuff("mordekaisercreepingdeath"));
if (allyW != null)
{
if (allyW.HealthPercent < 20 || player.HealthPercent < 20 ||
CombatHelper.GetBuffTime(allyW.GetBuff("mordekaisercreepingdeath")) < 0.5f)
{
if ((allyW.CountEnemiesInRange(250) +
Environment.Minion.countMinionsInrange(allyW.Position, 250f) / 2f >= 1 ||
player.CountEnemiesInRange(250f) +
Environment.Minion.countMinionsInrange(player.Position, 250f) / 2f >= 1))
{
W.Cast(config.Item("packets").GetValue <bool>());
}
}
}
else
{
Obj_AI_Base wTarget = Environment.Hero.mostEnemyAtFriend(player, W.Range, 250f);
if (MordeGhost)
{
var ghost =
ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(m => m.HasBuff("mordekaisercotgpetbuff2"));
if (wTarget == null || ghost.CountEnemiesInRange(250f) > wTarget.CountEnemiesInRange(250f))
{
wTarget = ghost;
}
}
if (wTarget != null && (wTarget.CountEnemiesInRange(250) > 0 || player.CountEnemiesInRange(250) > 0))
{
W.Cast(wTarget, config.Item("packets").GetValue <bool>());
}
}
}
private void Game_OnGameUpdate(EventArgs args)
{
if (FpsBalancer.CheckCounter())
{
return;
}
switch (orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
Combo();
break;
case Orbwalking.OrbwalkingMode.Mixed:
Harass();
break;
case Orbwalking.OrbwalkingMode.LaneClear:
Clear();
break;
case Orbwalking.OrbwalkingMode.LastHit:
Lasthit();
break;
default:
break;
}
if (config.Item("EzAutoQ", true).GetValue <KeyBind>().Active&& Q.IsReady() &&
config.Item("EzminmanaaQ", true).GetValue <Slider>().Value < player.ManaPercent &&
orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo && Orbwalking.CanMove(100))
{
AIHeroClient target = LeagueSharp.Common.TargetSelector.GetTarget(Q.Range, LeagueSharp.Common.TargetSelector.DamageType.Physical);
if (target != null && Q.CanCast(target) && target.IsValidTargetLS())
{
Q.CastIfHitchanceEquals(
target, CombatHelper.GetHitChance(config.Item("qHit", true).GetValue <Slider>().Value));
}
}
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(900, TargetSelector.DamageType.Magical, true);
if (target == null || target.IsInvulnerable || target.MagicImmune)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite", true).GetValue <bool>() &&
ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
!CombatHelper.CheckCriticalBuffs(target))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && !justWOut)
{
handeQ(target, HitChance.High);
}
if (W.IsReady() && !SomebodyInYou && config.Item("usew", true).GetValue <bool>() && !blockW)
{
if (!config.Item("dontusewks", true).GetValue <bool>() ||
((getWDamage(target) < HealthPrediction.GetHealthPrediction(target, 600) &&
player.CountAlliesInRange(1200) > 0) || player.CountAlliesInRange(1200) == 0))
{
handleWEnemyHero(target);
}
}
if (config.Item("usewmini", true).GetValue <bool>())
{
HandleWHarass(target);
}
}
private void Game_ProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe)
{
if (args.SData.Name == "SionQ")
{
if (!justQ)
{
justQ = true;
qStart = System.Environment.TickCount;
lastQPos = player.Position.Extend(args.End, Q.Range);
Utility.DelayAction.Add(600, () => justQ = false);
}
}
if (args.SData.Name == "SionE")
{
if (!justE)
{
justE = true;
Utility.DelayAction.Add(400, () => justE = false);
}
}
}
if (!activatedW && W.IsReady() && args.Target is Obj_AI_Hero && sender is Obj_AI_Hero &&
CombatHelper.isDangerousSpell(
args.SData.Name, (Obj_AI_Hero)args.Target, (Obj_AI_Hero)sender, args.End, W.Range, true))
{
W.Cast(config.Item("packets").GetValue <bool>());
}
if (config.Item("userCC", true).GetValue <bool>() && sender is Obj_AI_Hero && sender.IsEnemy &&
player.Distance(sender) < Q.Range &&
CombatHelper.isDangerousSpell(
args.SData.Name, args.Target as Obj_AI_Hero, sender as Obj_AI_Hero, args.End, float.MaxValue, false) &&
HeroManager.Enemies.FirstOrDefault(e => e.Distance(Game.CursorPos) < 300) != null)
{
R.Cast(Game.CursorPos, config.Item("packets").GetValue <bool>());
}
}
public override bool TakeAction()
{
int maxDonateGold = ConfigEnvSet.GetInt("UserGuild.MaxDonateGold");
if (string.IsNullOrEmpty(ContextUser.MercenariesID))
{
ErrorCode = LanguageManager.GetLang().ErrorCode;
ErrorInfo = LanguageManager.GetLang().St6203_GuildMemberNotEnough;
return(false);
}
UserGuild guild = new ShareCacheStruct <UserGuild>().FindKey(ContextUser.MercenariesID);
if (guild == null)
{
ErrorCode = LanguageManager.GetLang().ErrorCode;
return(false);
}
if (guild.AbilityInfo.Count == 0)
{
UserHelper.UserGuildAbilityList(ContextUser.MercenariesID);
}
CombatHelper.RepairGuildAbility(ContextUser.MercenariesID);
currExperience = guild.CurrDonateNum;
if (guild.AbilityInfo.Count > 0)
{
List <GuildAbility> abilitiesList = guild.AbilityInfo.ToList();
abilityArray = abilitiesList.GetPaging(pageIndex, pageSize, out pageCount);
}
GuildMember member = new ShareCacheStruct <GuildMember>().FindKey(ContextUser.MercenariesID, ContextUser.UserID);
if (member != null)
{
donateCoin = MathUtils.Subtraction(UserHelper.MaxDonateGameCoin(ContextUser.UserLv.ToInt()), member.DonateCoin);
donateGold = MathUtils.Subtraction(maxDonateGold, member.DonateGold);
}
return(true);
}
private static void FlashCombo()
{
AIHeroClient target = DrawHelper.GetBetterTarget(EFlash.Range, TargetSelector.DamageType.Magical);
if (target != null && E.IsReady() && E.ManaCost < player.Mana &&
player.Distance(target.Position) < EFlash.Range && player.Distance(target.Position) > 480 &&
!((getPosToEflash(target.Position)).IsWall()))
{
var pred = EFlash.GetPrediction(target);
var poly = CombatHelper.GetPolyFromVector(getPosToEflash(target.Position), pred.UnitPosition, E.Width);
var enemiesBehind =
HeroManager.Enemies.Count(
e =>
e.NetworkId != target.NetworkId && e.IsValidTarget(E.Range) &&
(poly.IsInside(E.GetPrediction(e).UnitPosition) || poly.IsInside(e.Position)) &&
e.Position.Distance(player.Position) > player.Distance(pred.UnitPosition));
if (pred.Hitchance >= HitChance.High)
{
LeagueSharp.Common.Utility.DelayAction.Add(
30, () =>
{
if (enemiesBehind > 0)
{
E.Cast(player.ServerPosition.Extend(pred.CastPosition, E.Range));
}
else
{
E.Cast(
player.ServerPosition.Extend(
pred.CastPosition,
player.Distance(pred.CastPosition) + Orbwalking.GetRealAutoAttackRange(target)));
}
});
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), getPosToEflash(target.Position));
}
}
ItemHandler.UseItems(target, config);
Orbwalking.MoveTo(Game.CursorPos);
}
private Vector3 getBestRVector3(Obj_AI_Base target, PredictionOutput targE)
{
var otherHeroes =
HeroManager.Enemies.Where(
e => e.IsValidTarget() && e.NetworkId != target.NetworkId && player.Distance(e) < 1000)
.Select(e => R.GetPrediction(e))
.Where(o => o.Hitchance > HitChance.High && o.CastPosition.Distance(targE.UnitPosition) < 1000);
if (otherHeroes.Any())
{
var best =
otherHeroes.OrderByDescending(
hero =>
CombatHelper.GetCollisionCount(
target, target.Position.LSExtend(hero.CastPosition, 1000), R.Width,
new[] { CollisionableObjects.Heroes })).FirstOrDefault();
if (best != null)
{
return(best.CastPosition);
}
}
return(Vector3.Zero);
}
public void OnInitialize(int version)
{
//Logger.KefkaLog($"Initializing Version: {File.ReadAllText(VersionPath)}");
Logger.KefkaLog($"Initializing Version: GitHub 1.0.0");
TreeRoot.OnStart += OnBotStart;
TreeRoot.OnStop += OnBotStop;
if (version == 2)
{
IsChineseVersion = true;
}
HookBehaviors();
var _class = RoutineManager.CurrentClass;
InterruptManager.ResetInterrupts();
IgnoreTargetManager.ResetIgnoreTargets();
TankBusterManager.ResetTankBusters();
OpenerManager.ResetOpeners();
CombatHelper.ResetLastUsed();
}
public override bool TakeAction()
{
var package = UserEnchant.Get(ContextUser.UserID);
if (package != null)
{
userEnchant = package.EnchantPackage.Find(m => m.UserEnchantID == userEnchantID);
if (userEnchant != null)
{
matureNum = (decimal)userEnchant.MaxMature / GameConfigSet.MaxEnchantMature;
maxMature = CombatHelper.EnchantFinalNum(userEnchant);
enchantInfo = new ConfigCacheSet <EnchantInfo>().FindKey(userEnchant.EnchantID);
EnchantLvInfo enchantLvInfo = new ConfigCacheSet <EnchantLvInfo>().FindKey(userEnchant.EnchantID,
userEnchant.EnchantLv);
if (enchantLvInfo != null)
{
abilityNum = TrumpHelper.GetTransformData(enchantLvInfo.Num);
}
}
}
enchantList = EnchantHelper.EnchantCultureList();
return(true);
}
public void Consume(Artifact ammunitionArtifact)
{
ammunitionArtifact.RemoveItem(1);
var currentEnemy = InterfaceHelper.CurrentEnemy;
int damageDealt;
if (currentEnemy is Monster)
{
damageDealt = (int)Math.Ceiling(currentEnemy.CurrentHealth * PercentageHealthDamageAgainstMonsters);
}
else
{
damageDealt = (int)Math.Ceiling(currentEnemy.CurrentHealth * PercentageHealthDamageAgainstBosses);
}
CombatHelper.DealDamageToCurrentEnemy(damageDealt, DamageType.OnHit);
foreach (var artifact in User.Instance.CurrentHero.EquippedArtifacts)
{
artifact.ArtifactFunctionality.OnConsumed(ammunitionArtifact);
}
}
private void Game_OnGameUpdate(EventArgs args)
{
switch (orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
Combo();
break;
case Orbwalking.OrbwalkingMode.Mixed:
Harass();
break;
case Orbwalking.OrbwalkingMode.LaneClear:
Clear();
break;
case Orbwalking.OrbwalkingMode.LastHit:
Lasthit();
break;
default:
break;
}
Jungle.CastSmite(config.Item("useSmite").GetValue <KeyBind>().Active);
if (config.Item("EzAutoQ", true).GetValue <KeyBind>().Active&& Q.IsReady() &&
config.Item("EzminmanaaQ", true).GetValue <Slider>().Value < player.ManaPercent &&
orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo && Orbwalking.CanMove(100))
{
Obj_AI_Hero target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
if (target != null && Q.CanCast(target) && target.IsValidTarget())
{
Q.CastIfHitchanceEquals(
target, CombatHelper.GetHitChance(config.Item("qHit", true).GetValue <Slider>().Value),
config.Item("packets").GetValue <bool>());
}
}
}
private static void getIncDmg()
{
var color = Color.Red;
float result = CombatHelper.getIncDmg();
var barPos = player.HPBarPosition;
var damage = (float)result;
if (damage == 0)
{
return;
}
var percentHealthAfterDamage = Math.Max(0, player.Health - damage) / player.MaxHealth;
var xPos = barPos.X + XOffset + Width * percentHealthAfterDamage;
if (damage > player.Health)
{
Text.X = (int)barPos.X + XOffset;
Text.Y = (int)barPos.Y + YOffset - 13;
Text.text = ((int)(player.Health - damage)).ToString();
Text.OnEndScene();
}
Drawing.DrawLine(xPos, barPos.Y + YOffset, xPos, barPos.Y + YOffset + Height, 3, color);
}
public CombatRound Hit(Player player)
{
var round = new CombatRound();
// roll to hit, if success, then hit
if (Server.Current.Random.Next(HitRoll) + 1 >= player.Armor)
{
// hit
var damage = Server.Current.Random.Next(DamRoll) + 1;
player.HitPoints -= damage;
var damageAction = CombatHelper.GetDamageAction(player, damage);
var playerText = string.Format("{0} {1} you for {2} damage!\n", Name, damageAction.Plural, damage);
round.AddText(player, playerText, CombatTextType.Player);
var groupText = string.Format("{0} {1} {2}!\n", Name, damageAction.Plural, player.Forename);
round.AddText(player, groupText, CombatTextType.Group);
}
else
{
// miss
var playerText = string.Format("{0} misses you!", Name);
round.AddText(player, playerText, CombatTextType.Player);
var groupText = string.Format("{0} misses {1}!\n", Name, player.Forename);
round.AddText(player, groupText, CombatTextType.Group);
}
if (!_skillLoopStarted && Skills.Count > 0)
{
doSkillLoop(null, null);
}
return(round);
}
private static void Combo()
{
AIHeroClient target = LeagueSharp.Common.TargetSelector.GetTarget(1000, LeagueSharp.Common.TargetSelector.DamageType.Magical);
if (config.Item("usee", true).GetValue <bool>() && !VorpalSpikes && E.GetHitCount() > 0 &&
(Environment.Turret.countTurretsInRange(player) < 1 || target.Health < 150))
{
E.Cast();
}
if (target == null)
{
return;
}
if (config.Item("selected", true).GetValue <bool>())
{
target = CombatHelper.SetTarget(target, LeagueSharp.Common.TargetSelector.GetSelectedTarget());
}
var combodmg = ComboDamage(target);
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, combodmg);
}
bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
if (hasIgnite && ignitedmg > target.Health && !R.CanCast(target) && !W.CanCast(target) && !Q.CanCast(target))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (hasIgnite && combodmg > target.Health && R.CanCast(target) &&
(float)Damage.GetSpellDamageLS(player, target, SpellSlot.R) < target.Health)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (hasIgnite)
{
flashRblock = true;
}
else
{
flashRblock = false;
}
if (config.Item("useq", true).GetValue <bool>() && Q.IsReady())
{
int qHit = config.Item("qHit", true).GetValue <Slider>().Value;
var hitC = HitChance.VeryHigh;
switch (qHit)
{
case 1:
hitC = HitChance.Low;
break;
case 2:
hitC = HitChance.Medium;
break;
case 3:
hitC = HitChance.High;
break;
case 4:
hitC = HitChance.VeryHigh;
break;
}
if (Program.IsSPrediction)
{
Q.SPredictionCast(target, hitC);
}
else
{
var pred = Q.GetPrediction(target);
if (pred.Hitchance >= hitC)
{
if (target.IsMoving)
{
if (pred.CastPosition.Distance(target.ServerPosition) > 250f)
{
Q.Cast(target.Position.Extend(pred.CastPosition, 250f));
}
else
{
Q.Cast(pred.CastPosition);
}
}
else
{
Q.CastIfHitchanceEquals(target, hitC);
}
}
}
}
if (config.Item("usew", true).GetValue <bool>() && W.CanCast(target))
{
if (Program.IsSPrediction)
{
W.SPredictionCast(target, HitChance.High);
}
else
{
W.Cast(target);
}
}
if (config.Item("UseFlashC", true).GetValue <bool>() && !flashRblock && R.IsReady() && hasFlash &&
!CombatHelper.CheckCriticalBuffs(target) && player.GetSpell(SpellSlot.R).SData.Mana <= player.Mana &&
player.Distance(target.Position) >= 400 && player.GetSpellDamageLS(target, SpellSlot.R) > target.Health &&
!Q.IsReady() && !W.IsReady() && player.Distance(target.Position) <= RFlash.Range &&
!player.Position.Extend(target.Position, 400).IsWall())
{
player.Spellbook.CastSpell(
player.GetSpellSlot("SummonerFlash"), player.Position.Extend(target.Position, 400).To3DWorld());
LeagueSharp.Common.Utility.DelayAction.Add(50, () => R.Cast(target));
}
var rtarget =
HeroManager.Enemies.Where(e => e.IsValidTargetLS() && R.CanCast(e))
.OrderByDescending(e => LeagueSharp.Common.TargetSelector.GetPriority(e))
.FirstOrDefault();
if (config.Item("user", true).GetValue <bool>() && rtarget != null &&
player.GetSpellDamageLS(target, SpellSlot.R) > rtarget.Health)
{
R.Cast(rtarget);
}
}
private static void Game_OnGameUpdate(EventArgs args)
{
/*
* if (FpsBalancer.CheckCounter())
* {
* return;
* }*/
AIHeroClient targetf = DrawHelper.GetBetterTarget(1000, TargetSelector.DamageType.Magical);
if (config.Item("useeflashforced", true).GetValue <KeyBind>().Active)
{
if (targetf == null)
{
Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
}
else
{
var bestpos = CombatHelper.bestVectorToPoppyFlash2(targetf);
bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) ==
SpellState.Ready;
if (E.IsReady() && hasFlash && !CheckWalls(player, targetf) && bestpos.IsValid())
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), bestpos);
Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
}
else if (!hasFlash)
{
Combo();
LeagueSharp.Common.Orbwalking.Orbwalk(targetf, Game.CursorPos, 90, 90);
}
}
}
switch (orbwalker.ActiveMode)
{
case LeagueSharp.Common.Orbwalking.OrbwalkingMode.Combo:
Combo();
break;
case LeagueSharp.Common.Orbwalking.OrbwalkingMode.Mixed:
Harass();
break;
case LeagueSharp.Common.Orbwalking.OrbwalkingMode.LaneClear:
Clear();
break;
case LeagueSharp.Common.Orbwalking.OrbwalkingMode.LastHit:
break;
default:
break;
}
if (!player.IsDead)
{
foreach (var dashingEnemy in
HeroManager.Enemies.Where(
e =>
e.IsValidTarget() && e.Distance(player) < 1600 &&
config.Item("useAutoW" + e.BaseSkinName, true).GetValue <Slider>().Value > 0)
.OrderByDescending(e => config.Item("useAutoW" + e.BaseSkinName, true).GetValue <Slider>().Value)
.ThenBy(e => e.Distance(player)))
{
var nextpos = Prediction.GetPrediction(dashingEnemy, 0.1f).UnitPosition;
if (dashingEnemy.IsDashing() && !dashingEnemy.HasBuffOfType(BuffType.SpellShield) &&
!dashingEnemy.HasBuff("poppyepushenemy") && dashingEnemy.Distance(player) <= W.Range &&
(nextpos.Distance(player.Position) > W.Range || (player.Distance(dashingEnemy) < W.Range - 100)) &&
dashingEnemy.IsTargetable && !NotDash.Contains(dashingEnemy.ChampionName))
{
W.Cast();
}
if (
CombatHelper.DashDatas.Any(
d => d.ChampionName == dashingEnemy.ChampionName && d.IsReady(dashingEnemy)))
{
break;
}
}
}
}
private static void Combo()
{
if (Orbwalking.CanMove(config.Item("canmove", true).GetValue <Slider>().Value))
{
Chat.Print("CanMove");
}
if (Orbwalking.CanMove(300))
{
Chat.Print("300");
}
AIHeroClient target = DrawHelper.GetBetterTarget(1000, TargetSelector.DamageType.Magical);
if (target == null)
{
return;
}
var cmbdmg = ComboDamage(target);
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;
if (config.Item("usee", true).GetValue <bool>() && E.IsReady())
{
if (config.Item("useewall", true).GetValue <bool>())
{
var bestpos = CombatHelper.bestVectorToPoppyFlash2(target);
float damage =
(float)
(ComboDamage(target) +
Damage.CalcDamage(
player, target, Damage.DamageType.Magical,
(eSecond[E.Level - 1] + 0.8f * player.FlatMagicDamageMod)) +
(player.GetAutoAttackDamage(target) * 4));
float damageno = (float)(ComboDamage(target) + (player.GetAutoAttackDamage(target) * 4));
if (config.Item("useeflash", true).GetValue <bool>() && hasFlash && !CheckWalls(player, target) &&
damage > target.Health && target.Health > damageno &&
CombatHelper.bestVectorToPoppyFlash(target).IsValid())
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), bestpos);
LeagueSharp.Common.Utility.DelayAction.Add(100, () => E.CastOnUnit(target));
}
if (E.CanCast(target) &&
(CheckWalls(player, target) ||
target.Health < E.GetDamage(target) + player.GetAutoAttackDamage(target, true)))
{
E.CastOnUnit(target);
}
if (E.CanCast(target) && Q.IsReady() && Q.Instance.SData.Mana + E.Instance.SData.Mana > player.Mana &&
target.Health <
E.GetDamage(target) + Q.GetDamage(target) + player.GetAutoAttackDamage(target, true))
{
E.CastOnUnit(target);
}
}
else
{
if (E.CanCast(target))
{
E.CastOnUnit(target);
}
}
}
if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && Q.CanCast(target) && target.Distance(player) < Q.Range &&
(player.Distance(target) > LeagueSharp.Common.Orbwalking.GetRealAutoAttackRange(target) || !LeagueSharp.Common.Orbwalking.CanAttack()))
{
Q.CastIfHitchanceEquals(target, HitChance.High);
}
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready && config.Item("useIgnite").GetValue <bool>();
var ignitedmg = hasIgnite ? (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) : 0f;
if (ignitedmg > target.Health && hasIgnite && !E.CanCast(target) && !Q.CanCast(target) &&
(player.Distance(target) > Q.Range || player.HealthPercent < 30))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (config.Item("userindanger", true).GetValue <bool>() && R.IsReady() &&
((player.CountEnemiesInRange(800) >= 2 &&
player.CountEnemiesInRange(800) > player.CountAlliesInRange(1500) + 1 && player.HealthPercent < 60) ||
(player.Health < target.Health && player.HealthPercent < 40 &&
player.CountAlliesInRange(1000) + 1 < player.CountEnemiesInRange(1000))))
{
var targ =
HeroManager.Enemies.Where(
e =>
e.IsValidTarget() && R.CanCast(e) &&
(player.HealthPercent < 60 || e.CountEnemiesInRange(300) > 2) &&
HeroManager.Enemies.Count(h => h.Distance(e) < 400 && e.HealthPercent < 35) == 0 &&
R.GetPrediction(e).CastPosition.Distance(player.Position) < R.ChargedMaxRange)
.OrderByDescending(e => R.GetPrediction(e).CastPosition.CountEnemiesInRange(400))
.ThenByDescending(e => e.Distance(target))
.FirstOrDefault();
if (R.Range > 1300 && targ == null)
{
targ =
HeroManager.Enemies.Where(
e =>
e.IsValidTarget() && R.CanCast(e) &&
R.GetPrediction(e).CastPosition.Distance(player.Position) < R.ChargedMaxRange)
.OrderByDescending(e => R.GetPrediction(e).CastPosition.CountEnemiesInRange(400))
.ThenByDescending(e => e.Distance(target))
.FirstOrDefault();
}
if (!R.IsCharging && targ != null)
{
R.StartCharging();
}
if (R.IsCharging && targ != null && R.CanCast(targ) && R.Range > 1000 && R.Range > targ.Distance(player))
{
R.CastIfHitchanceEquals(targ, HitChance.Medium);
}
if (R.IsCharging && targ != null && R.Range < 1000)
{
return;
}
}
if (config.Item("user", true).GetValue <bool>() && R.IsReady() && player.Distance(target) < 1400 &&
!target.UnderTurret(true))
{
var cond = ((Rdmg(target) < target.Health && /*ignitedmg +*/ Rdmg(target) > target.Health &&
player.Distance(target) < 600) ||
(target.Distance(player) > E.Range && Rdmg(target) > target.Health &&
target.Distance(player) < 1100));
if (!R.IsCharging && cond && !Q.IsReady() && player.HealthPercent < 40)
{
R.StartCharging();
if (hasIgnite && cmbdmg > target.Health && cmbdmg - Rdmg(target) < target.Health)
{
if (!target.HasBuff("summonerdot"))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
}
}
if (R.IsCharging && R.CanCast(target) && R.Range > target.Distance(player) && cond)
{
R.CastIfHitchanceEquals(target, HitChance.High);
}
}
}
private bool Qhit(Vector3 target)
{
return(Q.IsReady() && CombatHelper.IsFacing(player, target, 80) &&
target.Distance(player.Position) < Q.Range);
}
