public void OnPosibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (E.IsReady() && Config.Item("EInterruptable").GetValue<bool>() && unit.IsValidTarget(E.Range))
{
E.Cast(unit);
}
}
private static void BlitzOnInterruptableSpell(Obj_AI_Base unit, InterruptableSpell spell)
{
if (_menu.Item("interruptq").GetValue<bool>() && _q.IsReady())
{
if (unit.Distance(Me.ServerPosition, true) <= _q.RangeSqr)
{
var prediction = _q.GetPrediction(unit);
if (prediction.Hitchance >= HitChance.Low)
{
_q.Cast(prediction.CastPosition);
}
}
}
if (_menu.Item("interruptr").GetValue<bool>() && _r.IsReady())
{
if (unit.Distance(Me.ServerPosition, true) <= _r.RangeSqr)
{
_r.Cast();
}
}
if (_menu.Item("interrupte").GetValue<bool>() && _e.IsReady())
{
if (unit.Distance(Me.ServerPosition, true) <= _e.RangeSqr)
{
_e.CastOnUnit(Me);
Me.IssueOrder(GameObjectOrder.AttackUnit, unit);
}
}
}
public void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (E.IsReady() && unit.IsValidTarget(E.Range))
{
E.Cast(unit);
}
}
public void Game_OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (R.IsReady() && Config.Item("RInterruptable" + Id).GetValue<bool>() && unit.IsValidTarget(1500))
{
R.Cast(unit);
}
}
public override void Interrupter_OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell) {
if (!GetValue<bool>("InterruptSpells")) return;
if (ObjectManager.Player.Distance(unit) < E.Range && E.IsReady()) {
E.Cast(unit);
} else if (ObjectManager.Player.Distance(unit) < Q.Range && Q.IsReady()) {
Q.Cast(unit);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.High || unit.IsAlly)
return;
if (W.CastCheck(unit, "InterruptW"))
{
W.CastOnUnit(unit, UsePackets);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.High || unit.IsAlly)
{
return;
}
if (R.CastCheck(unit, "Interrupt.R"))
{
R.Cast(unit);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.High || unit.IsAlly)
{
return;
}
if (R.IsReady() && unit.IsValidTarget(R.Range))
{
R.Cast(unit);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.High || unit.IsAlly)
{
return;
}
if (E.CastCheck(unit, "Interrupt.E"))
{
E.CastIfHitchanceEquals(unit, HitChance.Medium);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base target, InterruptableSpell spell)
{
if (!ConfigValue<bool>("InterruptE") ||
spell.DangerLevel < InterruptableDangerLevel.High ||
target.IsAlly)
return;
if (!target.IsValidTarget(E.Range))
return;
if (!E.IsReady())
return;
E.Cast(target);
}
private static void BlitzInterruptableSpell(Obj_AI_Base unit, InterruptableSpell spell)
{
Obj_AI_Hero target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
var qSpell = Config.Item("qint").GetValue<bool>();
var rSpell = Config.Item("rint").GetValue<bool>();
if (qSpell)
{
Q.Cast(target);
}
if (rSpell)
{
if (unit.Distance(Player.ServerPosition, true) <= R.RangeSqr)
{
R.Cast();
}
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.High || unit.IsAlly)
{
return;
}
if (GetPassiveStacks() >= 4)
{
if (Q.CastCheck(unit, "Interrupt.Q"))
{
Q.Cast(unit);
return;
}
if (W.CastCheck(unit, "Interrupt.W"))
{
W.CastOnUnit(unit);
return;
}
}
if (GetPassiveStacks() == 3)
{
if (E.IsReady())
{
E.Cast();
if (Q.CastCheck(unit, "Interrupt.Q"))
{
Q.Cast(unit);
return;
}
if (W.CastCheck(unit, "Interrupt.W"))
{
W.CastOnUnit(unit);
return;
}
}
if (Q.CastCheck(unit, "Interrupt.Q") && W.CastCheck(unit, "Interrupt.W"))
{
Q.Cast(unit);
W.CastOnUnit(unit);
}
}
}
private static void BlitzOnInterruptableSpell(Obj_AI_Base unit, InterruptableSpell spell)
{
if (_menu.Item("interruptq").GetValue<bool>() && _q.IsReady())
{
if (unit.Distance(Me.ServerPosition, true) <= _q.RangeSqr)
_q.CastIfHitchanceEquals(unit, HitChance.Medium);
}
if (_menu.Item("interruptr").GetValue<bool>() && _r.IsReady())
{
if (unit.Distance(Me.ServerPosition, true) <= _r.RangeSqr)
_r.Cast();
}
if (_menu.Item("interrupte").GetValue<bool>() && _e.IsReady())
{
if (unit.Distance(Me.ServerPosition, true) <= _e.RangeSqr)
_e.CastOnUnit(Me);
}
}
private static void Game_OnGameLoad(EventArgs args)
{
if (!Interrupter.Spells.Any(spell => spell.ChampionName.Equals(ObjectManager.Player.ChampionName)))
{
return;
}
Bootstrap.Initialize();
Menu = new Menu("AntiEvadeInterrupter", "AntiEvadeInterrupter", true);
Menu.AddBool("Enabled", "Enabled");
Menu.Item("Enabled").SetTooltip("Stops evade from interrupting important spells.");
Menu.AddToMainMenu();
Spell =
Interrupter.Spells.FirstOrDefault(spell => spell.ChampionName.Equals(ObjectManager.Player.ChampionName));
Obj_AI_Base.OnProcessSpellCast += Obj_AI_Base_OnProcessSpellCast;
Game.OnUpdate += Game_OnUpdate;
}
private void OnInterruptableSpell(Obj_AI_Hero unit, InterruptableSpell spell)
{
if (E.IsReady() && unit.IsValidTarget(E.Range))
E.Cast(unit);
}
private static void Interrupter_OnPosibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (!Config.Item("InterruptSpells").GetValue<bool>()) return;
E.Cast(unit.ServerPosition);
}
private static void Interrupter_OnPosibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (!Wolf.Item("Interrupt").GetValue<bool>()) return;
Q.Cast(unit);
}
static void Interrupter_OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (mustDebug)
Game.PrintChat(string.Format("OnPosibleToInterrupt -> {0} cast {1}", unit.SkinName, spell.SpellName));
var EInterrupt = Config.Item("EInterrupt").GetValue<bool>();
var packetCast = Config.Item("PacketCast").GetValue<bool>();
if (EInterrupt && E.IsReady() && unit.IsValidTarget(E.Range))
{
E.CastIfHitchanceEquals(unit, unit.IsMoving ? HitChance.High : HitChance.Medium, packetCast);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.Medium || unit.IsAlly)
return;
if (Menu.Item("Misc_useE_Interrupt").GetValue<bool>() && unit.IsValidTarget(E.Range))
E.Cast(unit, UsePackets());
}
private void OnPossibleToInterrupt(Obj_AI_Hero unit, InterruptableSpell spell)
{
if (Player.IsDead || !GetValue<bool>("Interrupt", "Q") ||
!GetValue<bool>("Interrupt", unit.ChampionName + "_" + spell.Slot) || !Q.CanCast(unit))
{
return;
}
Q.CastIfHitchanceEquals(unit, HitChance.High, PacketCast);
}
private void OnPossibleToInterrupt(Obj_AI_Hero unit, InterruptableSpell spell)
{
if (Player.IsDead || !GetValue<bool>("Interrupt", "EQ") ||
!GetValue<bool>("Interrupt", unit.ChampionName + "_" + spell.Slot) || !Q.IsReady())
{
return;
}
if (E.CanCast(unit) && Player.Mana >= Q.Instance.ManaCost + E.Instance.ManaCost)
{
var predE = E.GetPrediction(unit);
if (predE.Hitchance >= HitChance.High &&
E.Cast(predE.CastPosition.Extend(Player.ServerPosition, -E.Width), PacketCast) &&
Q.Cast(predE.CastPosition, PacketCast))
{
return;
}
}
foreach (var flag in
Flag.Where(i => unit.Distance(i) <= 60 || Q2.WillHit(unit, i.ServerPosition)))
{
Q.Cast(flag.ServerPosition, PacketCast);
}
}
public override void OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (spell.DangerLevel < InterruptableDangerLevel.High || unit.IsAlly)
return;
if (Q.CastCheck(unit, "InterruptQ"))
{
}
if (W.CastCheck(unit, "InterruptW"))
{
}
if (E.CastCheck(unit, "InterruptE"))
{
}
if (R.CastCheck(unit, "InterruptR"))
{
}
}
private static void OnPossibleToInterrupt(Obj_AI_Hero unit, InterruptableSpell spell)
{
if (Player.IsDead || !GetValue<bool>("Interrupt", "R") ||
!GetValue<bool>("Interrupt", unit.ChampionName + "_" + spell.Slot) || !R.IsReady())
{
return;
}
if (R.IsInRange(unit))
{
R.CastOnUnit(unit, PacketCast);
}
else if (W.IsReady() && IsWOne)
{
var pos = unit.ServerPosition.Randomize(0, (int) R.Range);
if (Flee(pos, false))
{
return;
}
if (GetValue<bool>("Interrupt", "RWard"))
{
Flee(pos);
}
}
}
private void Interrupter_OnPosibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (!ChampionMenu.Item("useE_Interrupt").GetValue<bool>())
return;
E.CastIfHitchanceEquals(unit,HitChance.Medium,UsePackets());
}
private static void OnInterruptableSpell(Obj_AI_Base unit, InterruptableSpell spell)
{
if (Q.IsReady() && unit.IsValidTarget(Q.Range) && Config.Item("interQ").GetValue<bool>())
Q.Cast(unit);
else if (R.IsReady() && unit.IsValidTarget(R.Range) && Config.Item("interR").GetValue<bool>())
R.Cast(unit);
}
private static void Interrupter_OnPosibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
W.Cast(unit);
}
private static void Interrupter_OnPossibleToInterrupt(Obj_AI_Base unit, InterruptableSpell spell)
{
if (_e.IsReady() && unit.IsValidTarget(_e.Range) && Config.Item("Inter_E").GetValue<bool>())
_e.Cast();
}
/// <summary>
/// Registers the spell.
/// </summary>
/// <param name="champName">Name of the champ.</param>
/// <param name="spell">The spell.</param>
private static void RegisterSpell(string champName, InterruptableSpell spell)
{
if (!InterruptableSpells.ContainsKey(champName))
{
InterruptableSpells.Add(champName, new List<InterruptableSpell>());
}
InterruptableSpells[champName].Add(spell);
}
private static void OnInterruptableSpell(Obj_AI_Base unit, InterruptableSpell spell)
{
var eSpell = Config.Item("useE2I").GetValue<bool>();
if (eSpell
&& E.IsReady()
&& unit.IsValidTarget(E.Range)
)
{
E.Cast(unit);
}
}
private static void FireOnInterruptable(Obj_AI_Base unit, InterruptableSpell spell)
{
if (OnPosibleToInterrupt != null)
{
OnPosibleToInterrupt(unit, spell);
}
}
