private void PassiveControl(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.Q || args.Slot == SpellSlot.W || args.Slot == SpellSlot.E)
{
ProcessSpell();
}
}
private void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.E)
{
NextCicleOn = Game.Time + 9.8f;
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe && args.Slot == F.Slot)
{
var wall = SummMenu["wall"].Cast<CheckBox>().CurrentValue
&& (NavMesh.GetCollisionFlags(args.EndPosition) == CollisionFlags.Wall
|| NavMesh.GetCollisionFlags(args.EndPosition) == CollisionFlags.Building);
if (wall && SummMenu["wall"].Cast<CheckBox>().CurrentValue
|| args.EndPosition.Distance(Player.Instance) < 450 && SummMenu["extend"].Cast<CheckBox>().CurrentValue)
{
args.Process = false;
}
if (args.EndPosition.Distance(Player.Instance) < 450 && SummMenu["extend"].Cast<CheckBox>().CurrentValue)
{
if (wall && SummMenu["wall"].Cast<CheckBox>().CurrentValue)
{
args.Process = false;
}
F.Cast(Player.Instance.Position.Extend(Game.CursorPos, 450).To3D());
}
}
}
private static void OnSpellbookCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!Enabled)
{
return;
}
try
{
if (sender.Owner.IsMe)
{
var target = args.Target as Obj_AI_Hero;
if (target != null)
{
switch (args.Slot)
{
case SpellSlot.Q:
case SpellSlot.W:
case SpellSlot.E:
case SpellSlot.R:
Damages.Clean();
if (Damages.IsDying(target))
{
args.Process = false;
}
break;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
public static void OnSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.Q)
{
PortAIO.OrbwalkerManager.ResetAutoAttackTimer();
}
}
public static void OnSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.Q)
{
Orbwalker.ResetAutoAttack();
}
}
protected override void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe && args.Slot == SpellSlot.Q)
{
LastCast = myUtility.TickCount;
}
}
static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender == null || !sender.Owner.IsMe) {
return;
}
var antiswitch = Config.Item("antiswitchenabled").GetValue<bool>();
var useforthis = Config.Item("Spells." + args.Slot).GetValue<bool>();
var target = args.Target as Obj_AI_Hero;
var mindelay = Config.Item("mindelay").GetValue<Slider>().Value;
if (antiswitch && target != null)
{
if (target != Player.LastCastedSpellTarget() && Utils.TickCount - Player.LastCastedSpellT() <= mindelay)
{
args.Process = false;
return;
}
}
var humanizerenabled = Config.Item("humanizerenabled").GetValue<bool>();
var delayforthis = Config.Item(args.Slot + "delay").GetValue<Slider>().Value;
if (humanizerenabled && useforthis)
{
if (Utils.TickCount - Player.LastCastedSpellT() <= delayforthis)
{
args.Process = false;
}
}
}
protected override void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe && args.Slot == SpellSlot.E && Player.IsDashing())
{
args.Process = false;
}
}
public static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe && args.Slot == SpellSlot.Q && Program.Player.IsDashing())
{
args.Process = false;
}
}
private void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.Q || args.Slot == SpellSlot.W || args.Slot == SpellSlot.E)
{
passRdy = true;
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe)
{
switch (args.Slot)
{
case SpellSlot.Q:
case SpellSlot.W:
case SpellSlot.E:
case SpellSlot.R:
if (IsReady)
{
// We are safe to cast a spell
_sendTime = TickCount;
}
else
{
// Don't allow the spellcast
args.Process = false;
}
break;
}
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe)
{
if (args.Slot == SpellSlot.Q)
{
args.Process = Orbwalker.CanMove;
QCastSpellTime = Core.GameTickCount;
}
else if (args.Slot == SpellSlot.W)
{
args.Process = Core.GameTickCount - Champion.ShouldWaitTime > W.CastDelay && Orbwalker.CanMove;
if (args.Process)
{
WCastSpellTime = Core.GameTickCount;
}
}
else if (args.Slot == SpellSlot.R)
{
if (args.Process)
{
RCastSpellTime = Core.GameTickCount;
}
}
}
}
void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!IsActive() || SummonerSpells.GetFlashSlot() == args.Slot || !sender.Owner.IsMe)
return;
var startWall = GetStartWall();
if (!startWall.IsZero && Game.CursorPos.IsWall() && ObjectManager.Player.Distance(startWall) < 1000)
{
args.Process = false;
ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, startWall);
return;
}
for (var dist = ObjectManager.Player.Distance(Game.CursorPos); dist < 800; dist += 25)
{
var curPos = ObjectManager.Player.Position.Extend(Game.CursorPos, dist);
if (!curPos.IsWall())
{
ObjectManager.Player.Spellbook.CastSpell(args.Slot, curPos, false);
return;
}
}
if (ObjectManager.Player.ServerPosition.To2D().Distance(args.StartPosition) < 390f)
{
args.Process = false;
ObjectManager.Player.Spellbook.CastSpell(args.Slot, ObjectManager.Player.ServerPosition.Extend(args.StartPosition, 400f));
}
}
public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe)
{
lock (m_lock)
{
if (SPredictioner.Config.Item("ENABLED").GetValue<bool>() && (SPredictioner.Config.Item("COMBOKEY").GetValue<KeyBind>().Active || SPredictioner.Config.Item("HARASSKEY").GetValue<KeyBind>().Active))
{
if (!ShineCommon.Utility.IsValidSlot(args.Slot))
return;
if (SPredictioner.Spells[(int)args.Slot] == null)
return;
if (handleEvent[(int)args.Slot])
{
args.Process = false;
handleEvent[(int)args.Slot] = false;
var enemy = args.EndPosition.GetEnemiesInRange(200f).OrderByDescending(p => ShineCommon.Utility.GetPriority(p.ChampionName)).FirstOrDefault();
if (enemy == null)
enemy = TargetSelector.GetTarget(SPredictioner.Spells[(int)args.Slot].Range, TargetSelector.DamageType.Physical);
if (enemy != null)
SPredictioner.Spells[(int)args.Slot].SPredictionCast(enemy, ShineCommon.Utility.HitchanceArray[SPredictioner.Config.Item("SPREDHITC").GetValue<StringList>().SelectedIndex]);
}
}
}
}
}
private static void OnCast(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.E)
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && args.Target is Obj_AI_Hero) CastYoumoo();
}
if (args.Slot == SpellSlot.Q) Orbwalking.LastAATick = 0;
}
protected override void OnSpellCast(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (Orbwalker.ActiveModesFlags != Orbwalker.ActiveModes.Combo || !_q.IsReady() || !sender.Owner.IsMe ||
args.Slot != SpellSlot.W || args.Process == false || !sender.Owner.IsMe) return;
var qdelay = Math.Max(0, Player.Distance(args.Target) - 365)/1.2f - 25;
Core.DelayAction(() => _q.Cast(), (int) qdelay);
}
static void SpellbookOnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
{
if (spellbook.Owner.IsMe)
{
LastCastPacketSent = new LastCastPacketSentEntry(
args.Slot, Utils.TickCount, (args.Target is Obj_AI_Base) ? args.Target.NetworkId : 0);
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.R || args.Slot == SpellSlot.E || args.Slot == SpellSlot.Q || args.Slot == SpellSlot.W)
{
dontAtt = true;
dontatttimer = Environment.TickCount;
}
}
/// <summary>
/// Called on spell cast.
/// </summary>
/// <param name="spellbook">The spellbook.</param>
/// <param name="args">The <see cref="SpellbookCastSpellEventArgs" /> instance containing the event data.</param>
public static void OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
{
if (spellbook.Owner.IsMe && ObjectManager.Player.Spellbook.GetSpell(args.Slot).Name.Equals("recall")
&& Variables.QMenu.Item("logical").IsActive())
{
Variables.Q.Cast();
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (Orbwalker.ActiveModesFlags.Equals(Orbwalker.ActiveModes.Combo))
if (sender.Owner.IsMe)
if ((args.Slot == SpellSlot.W)
&& PiSkills.Q.IsReady() && PiSkills.E.IsReady())
args.Process = false;
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.Q)
{
args.Process = false;
Player.Spellbook.CastSpell(SpellSlot.Q, Player.Position.Extend(args.StartPosition, Variables.Q.Range), false);
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
// Avoid stupid Q casts while jumping in mid air!
if (sender.Owner.IsMe && args.Slot == SpellSlot.Q && Player.Instance.IsDashing())
{
// Don't process the packet since we are jumping!
args.Process = false;
}
}
/// <summary>
/// Called on spell cast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="SpellbookCastSpellEventArgs" /> instance containing the event data.</param>
public static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe &&
GameObjects.Player.Spellbook.GetSpell(args.Slot).Name.Equals("recall") &&
Vars.getCheckBoxItem(Vars.QMenu, "logical"))
{
Vars.Q.Cast();
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.Q || args.Slot == SpellSlot.W || args.Slot == SpellSlot.E)
{
passive = true;
Utility.DelayAction.Add(150, () => passive = false);
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!sender.Owner.IsMe
|| (args.Slot != SpellSlot.E && args.Slot != SpellSlot.W && args.Slot != SpellSlot.Q
&& args.Slot != SpellSlot.R) || LastSpell == args.Slot)
{
return;
}
LastSpell = args.Slot;
}
protected override void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Custom && (config.Item("UseRHitChecks").GetValue<bool>()))
{
if (args.Slot == SpellSlot.R && myUtility.SpellHits(R).Item1 == 0)
{
args.Process = false;
}
}
}
public static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.R)
{
if (Items.HasItem(3142) && Items.CanUseItem(3142))
{
Items.UseItem(3142);
}
}
}
/// <summary>
/// Called upon calling a spellaneclearast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="SpellbookCastSpellEventArgs" /> instance containing the event data.</param>
public static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe && args.Slot == SpellSlot.Q)
{
/// <summary>
/// Initializes the action blocking process.
/// </summary>
Logics.Automatic(sender, args);
}
}
private void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe && args.Slot == SpellSlot.R && W.IsReady())
{
if (player.Mana > R.Instance.ManaCost + W.Instance.ManaCost)
{
W.Cast(player, config.Item("packets").GetValue<bool>());
}
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!Ismelee())
{
if (args.Slot == SpellSlot.Q)
{
var qperlevel = new[] { 8, 8, 8, 8, 8, 8 }[Q.Level - 1];
TimeStamp["Q"] = Game.Time + 1.5f + (qperlevel + (qperlevel * Cooldown));
}
if (args.Slot == SpellSlot.W)
{
var wperlevel = new[] { 13, 11.4f, 9.8f, 8.2f, 6.6f, 5 }[W.Level - 1];
TimeStamp["W"] = Game.Time + 2.0f + (wperlevel + (wperlevel * Cooldown));
}
if (args.Slot == SpellSlot.E)
{
var eperlevel = new[] { 16, 16, 16, 16, 16, 16 }[E.Level - 1];
TimeStamp["E"] = Game.Time + 1.5f + (eperlevel + (eperlevel * Cooldown));
}
}
else
{
if (args.Slot == SpellSlot.Q)
{
var qmperlevel = new[] { 16, 14, 12, 10, 8, 6 }[Qm.Level - 1];
TimeStamp["Qm"] = Game.Time + 1.5f + (qmperlevel + (qmperlevel * Cooldown));
}
if (args.Slot == SpellSlot.W)
{
var wmperlevel = new[] { 10, 10, 10, 10, 10, 10 }[Wm.Level - 1];
TimeStamp["Wm"] = Game.Time + 1.5f + (wmperlevel + (wmperlevel * Cooldown));
}
if (args.Slot == SpellSlot.E)
{
var emperlevel = new[] { 15, 14, 13, 12, 11, 10 }[Em.Level - 1];
TimeStamp["Em"] = Game.Time + 1.5f + (emperlevel + (emperlevel * Cooldown));
}
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (Extension.IsUltShooting() && args.Slot != SpellSlot.R)
{
args.Process = false;
return;
}
switch (args.Slot)
{
case SpellSlot.W:
if (ComboMenu.WRangeBool.Enabled && GameObjects.EnemyHeroes.Any(x =>
x.DistanceToPlayer() <= Player.GetCurrentAutoAttackRange(x)))
{
args.Process = false;
}
break;
}
}
private void OnSpellcast(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsEnemy && args.Slot == SpellSlot.R && UseOnUltimates)
{
var halfLineLength = (args.EndPosition - args.StartPosition).Length() / 2f;
if (ObjectManager.Player.Position.Distance(args.StartPosition) > halfLineLength && ObjectManager.Player.Position.Distance(args.EndPosition) > halfLineLength)
{
return;
}
if (UseAlways)
{
SafeCast();
}
else
{
_shouldUse = true;
}
}
}
void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!MenuHelper.isMenuEnabled("dzaio.cassiopeia.misc.blockr"))
{
return;
}
if (sender.Owner.IsMe)
{
if (args.Slot == SpellSlot.R)
{
var finalPosition = args.EndPosition;
var hit = HeroManager.Enemies.FindAll(m => _spells[SpellSlot.R].WillHit(m, finalPosition));
if (hit.Count == 0)
{
args.Process = false;
}
}
}
}
public static void SafeCast(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot != SpellSlot.W)
{
return;
}
if (!CardSelector.Starting &&
(Config.IsKeyPressed(Config.CardSelectorMenu, "csYellow") ||
Config.IsKeyPressed(Config.CardSelectorMenu, "csBlue") ||
Config.IsKeyPressed(Config.CardSelectorMenu, "csRed")))
{
args.Process = false;
}
if (CardSelector.Starting)
{
CardSelector.Starting = false;
}
}
public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender != null && sender.Owner != null && sender.Owner.IsMe && args.Slot == SpellSlot.E && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo)))
{
if (!(args.Target is AIHeroClient))
{
args.Process = false;
return;
}
if (GetCondemnTarget(Variables._Player.ServerPosition).IsValidTarget())
{
if (!Shine.GetTarget(Variables._Player.ServerPosition).IsValidTarget())
{
args.Process = false;
}
}
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!sender.Owner.IsMe)
{
return;
}
if (args.Slot == SpellSlot.Recall)
{
evadePoint2 = Vector2.Zero;
}
if (!Evading)
{
return;
}
var blockLvl = Configs.Menu.Item("CheckBlock").GetValue <StringList>().SelectedIndex;
if (blockLvl == 0)
{
return;
}
var isDangerous = false;
foreach (var spell in DetectedSpells.Values.Where(i => i.Enable && i.IsDanger(PlayerPosition)))
{
isDangerous = spell.GetValue <bool>("IsDangerous");
if (isDangerous)
{
break;
}
}
if (blockLvl == 1 && !isDangerous)
{
return;
}
args.Process = !SpellBlocker.CanBlock(args.Slot);
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs Args)
{
if (Program.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if (Args.Slot == SpellSlot.Q)
{
if (Program.Menu.Item("ComboR", true).GetValue <bool>() && Program.R.IsReady() &&
Program.R.Instance.Name == "RivenIzunaBlade")
{
var t = TargetSelector.GetTarget(900, TargetSelector.DamageType.Physical);
if (t.IsValidTarget() && !t.IsDead)
{
switch (Program.Menu.Item("R2Mode", true).GetValue <StringList>().SelectedIndex)
{
case 0:
if (Program.R.GetDamage(t) > t.Health && t.IsValidTarget(Program.R.Range) &&
t.DistanceToPlayer() < 600)
{
Program.R.Cast(t);
}
break;
case 1:
if (t.HealthPercent < 25 && t.Health > Program.R.GetDamage(t) +
Program.Me.GetAutoAttackDamage(t) * 2)
{
Program.R.Cast(t);
}
break;
case 2:
if (t.IsValidTarget(Program.R.Range) && t.Distance(Program.Me.ServerPosition) < 600)
{
Program.R.Cast(t);
}
break;
}
}
}
}
}
}
private void OnSpellbookCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
try
{
if (sender.Owner != null && sender.Owner.IsMe)
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
var endPos = args.EndPosition;
var spell = Spells.FirstOrDefault(s => s.Slot == args.Slot);
if (spell != null)
{
var enemy1 =
GameObjects.EnemyHeroes.FirstOrDefault(
e => e.IsValidTarget() && e.Distance(endPos) < spell.Range / 2f);
var enemy2 =
GameObjects.EnemyHeroes.FirstOrDefault(
e => e.IsValidTarget() && e.Distance(Player) < spell.Range / 2f);
if (enemy1 != null)
{
ItemManager.Muramana(
enemy1, true,
spell.Range + spell.Width + enemy1.BoundingRadius + Player.BoundingRadius);
}
if (enemy2 != null)
{
ItemManager.Muramana(
enemy2, true,
spell.Range + spell.Width + enemy2.BoundingRadius + Player.BoundingRadius);
}
}
}
else
{
ItemManager.Muramana(null, false);
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!sender.Owner.IsMe)
{
return;
}
if (args.Slot == SpellSlot.Recall)
{
evadePoint2 = Vector2.Zero;
}
if (!Evading)
{
return;
}
var blockLvl = Configs.CheckBlock;
if (blockLvl == 0)
{
return;
}
var isDangerous = false;
foreach (var spell in Spells.Where(i => !i.IsSafePoint(PlayerPosition)))
{
isDangerous = spell.GetValue <bool>("IsDangerous");
if (isDangerous)
{
break;
}
}
if (blockLvl == 1 && !isDangerous)
{
return;
}
args.Process = !SpellBlocker.CanBlock(args.Slot);
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot == SpellSlot.R)
{
if (getCheckBoxItem(rMenu, "trinkiet") && !IsCastingR)
{
ScryingOrb.Range = Player.Level < 9 ? 2500 : 3500;
if (ScryingOrb.IsReady())
{
ScryingOrb.Cast(Rtarget);
}
if (FarsightOrb.IsReady())
{
FarsightOrb.Cast(Rtarget);
}
}
}
}
public override void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
var nClosesTarget = HeroManager.Enemies.Find(e => e.LSIsValidTarget(Orbwalking.GetRealAutoAttackRange(null) + 65));
{
if (nClosesTarget != null)
{
if (Program.combo["UseWMC"].Cast <CheckBox>().CurrentValue&&
ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).Level > 0 &&
Math.Abs(W.Cooldown) < 0.00001 &&
args.Slot != SpellSlot.W)
{
var lastMana = ObjectManager.Player.Mana - ObjectManager.Player.Spellbook.GetSpell(args.Slot).SData.Mana;
if (lastMana < ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).SData.Mana)
{
args.Process = false;
}
}
}
}
}
public override void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
var nClosesTarget = HeroManager.Enemies.Find(e => e.IsValidTarget(Orbwalking.GetRealAutoAttackRange(null) + 65));
{
if (nClosesTarget != null)
{
if (GetValue <bool>("UseWMC") &&
ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).Level > 0 &&
Math.Abs(W.Cooldown) < 0.00001 &&
args.Slot != SpellSlot.W)
{
var lastMana = ObjectManager.Player.Mana - ObjectManager.Player.Spellbook.GetSpell(args.Slot).ManaCost;
if (lastMana < ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).ManaCost)
{
args.Process = false;
}
}
}
}
}
private void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!ObjectManager.Player.IsDead)
{
if (sender.Owner.IsMe)
{
if (args.Slot == SpellSlot.E)
{
if (_eLastCastTime > Utils.TickCount - 700)
{
args.Process = false;
}
else
{
_eLastCastTime = Utils.TickCount;
}
}
}
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
var spell = (int)args.Slot;
var senderValid = sender != null && sender.Owner != null && sender.Owner.IsMe;
if (!senderValid || !args.Slot.IsMainSpell() || !Menu.Item("Enabled" + spell).IsActive())
{
return;
}
var delay = Menu.Item("Delay" + spell).GetValue <Slider>().Value;
if (Utils.TickCount - LastCast[spell] < delay)
{
args.Process = false;
return;
}
LastCast[spell] = Utils.TickCount;
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs Args)
{
if (sender?.Owner != null && sender.Owner.IsMe)
{
if (Args.Slot == SpellSlot.Q)
{
if (ComboOption.UseW && W.IsReady() && Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
W.Cast();
}
Args.Process = Variables.GameTimeTickCount - lastETime >= 750 + Game.Ping;
}
if (Args.Slot == SpellSlot.E)
{
Args.Process = Variables.GameTimeTickCount - lastQTime >= 750 + Game.Ping;
}
}
}
/// <summary>
/// Called upon calling a spellcast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="SpellbookCastSpellEventArgs" /> instance containing the event data.</param>
public static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (BallPosition == null)
{
return;
}
if (sender.Owner.IsMe && args.Slot == SpellSlot.R &&
Vars.Menu["miscellaneous"]["blockr"].GetValue <MenuBool>().Value)
{
if (
!GameObjects.EnemyHeroes.Any(
t =>
t.Distance((Vector2)BallPosition) < Vars.R.Range - 25 &&
!Invulnerable.Check(t, DamageType.Magical, false)))
{
args.Process = false;
}
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!sender.Owner.IsMe)
{
return;
}
if (IsTryingToQE)
{
if (args.Slot == SpellSlot.Q)
{
E.Cast(args.EndPosition);
}
if (args.Slot == SpellSlot.W)
{
args.Process = false;
}
}
}
public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
// if (!Program.Config["CameraControl"].GetValue<MenuBool>().Enabled)
// return;
// if (args.StartPosition.Distance(ObjectManager.Player.Position) <= 20)
// return;
// Vector3 start = args.StartPosition;
// if (ObjectManager.Player.CharacterName == "Yasuo" && args.Slot == SpellSlot.W)
// start = ObjectManager.Player.Position.Extend(args.StartPosition, 250);
// if (!start.IsOnScreen())
// {
// var pos = NavMesh.Ca.Position;
// Vector3 NewCameraPos = new Vector3(start.X + _random.Next(400), start.Y + _random.Next(400), Camera.Position.Z);
// Camera.Position = NewCameraPos;
// Utility.DelayAction.Add(300, () => Camera.Position = pos);
// }
}
internal static void OnProcess(Spellbook sender, SpellbookCastSpellEventArgs args)
{
// if (sender.SpellWasCast)
{
if (args.Slot == SpellSlot.W ||
args.Slot == SpellSlot.Q ||
args.Slot == SpellSlot.E)
{
casted = true;
MenuManager.Orbwalker.SetMovement(false);
MenuManager.Orbwalker.SetAttack(false);
}
if (casted)
{
Utility.DelayAction.Add(10000, () => MenuManager.Orbwalker.SetMovement(true));
Utility.DelayAction.Add(400, () => MenuManager.Orbwalker.SetMovement(true));
casted = false;
}
}
}
static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (args.Slot != flashSlot)
{
return;
}
Vector2 mypos = new Vector2(me.Position.X, me.Position.Y);
Vector2 flashpos = new Vector2(me.Position.X, me.Position.Y - (menu.Item("rangeupdated").GetValue <Slider>().Value)).RotateAroundPoint(mypos,
getAngleDegree(mypos, Game.CursorPos.To2D()));
Vector2 nearestfree = nearestFree(flashpos);
if (nearestfree == flashpos || mypos.Distance(nearestfree) > mypos.Distance(flashpos))
{
if (!menu.Item("fr").GetValue <bool>())
{
return;
}
args.Process = false;
me.Spellbook.CastSpell(flashSlot, new Vector2(me.Position.X, me.Position.Y - (500)).RotateAroundPoint(mypos,
getAngleDegree(mypos, Game.CursorPos.To2D())).To3D(), false);
me.IssueOrder(GameObjectOrder.MoveTo, me.Position, false);
}
else if (menu.Item("af").GetValue <bool>())
{
angl = getAngleDegree(mypos, Game.CursorPos.To2D());
WallOut w = calcWall(mypos, angl);
me.IssueOrder(GameObjectOrder.MoveTo, w.wallStart.To3D(), false);
Game.OnUpdate += Game_OnUpdate;
Obj_AI_Base.OnIssueOrder += Obj_AI_Base_OnIssueOrder;
turnoff = Game.ClockTime + 4;
args.Process = false;
}
else if (menu.Item("bf").GetValue <bool>())
{
args.Process = false;
}
}
/// <summary>
/// Fired on spell cast.
/// </summary>
/// <param name="spellbook">The spellbook.</param>
/// <param name="args">The <see cref="SpellbookCastSpellEventArgs" /> instance containing the event data.</param>
public static void OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
{
if (spellbook.Owner.IsMe)
{
switch (args.Slot)
{
case SpellSlot.W:
/// <summary>
/// Blocks trap cast if there is another trap nearby.
/// </summary>
if (ObjectManager.Get <Obj_AI_Minion>().Any(
m =>
m.Distance(args.EndPosition) < 200 &&
m.CharData.BaseSkinName.Equals("caitlyntrap")))
{
args.Process = false;
}
break;
case SpellSlot.E:
if (Environment.TickCount - Vars.LastTick < 1000)
{
return;
}
/// <summary>
/// The Dash to CursorPos Option.
/// </summary>
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.None) &&
Vars.getCheckBoxItem(Vars.MiscMenu, "reversede"))
{
Vars.LastTick = Environment.TickCount;
Vars.E.Cast(GameObjects.Player.ServerPosition.Extend(Game.CursorPos, -Vars.E.Range));
}
break;
default:
break;
}
}
}
public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsValid && sender.Owner.IsMe)
{
if (args.Slot == SpellSlot.Recall)
{
EvadeToPoint = new Vector2();
}
if (Evading)
{
var blockLevel = Config.EvadeMenu.Item("BlockSpells").GetValue <StringList>().SelectedIndex;
if (blockLevel == 0)
{
return;
}
var isDangerous = false;
foreach (var skillshot in DetectedSkillshots)
{
if (skillshot.Evade() && skillshot.IsDanger(PlayerPosition))
{
isDangerous = skillshot.GetValue <bool>("IsDangerous");
if (isDangerous)
{
break;
}
}
}
if (blockLevel == 1 && !isDangerous)
{
return;
}
args.Process = !SpellBlocker.ShouldBlock(args.Slot);
}
}
}
public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe)
{
if (OKTWPredictioner.Config.Item("ENABLED").GetValue <bool>() && (OKTWPredictioner.Config.Item("COMBOKEY").GetValue <KeyBind>().Active || OKTWPredictioner.Config.Item("HARASSKEY").GetValue <KeyBind>().Active))
{
if (!Utility.IsValidSlot(args.Slot))
{
return;
}
if (OKTWPredictioner.Spells[(int)args.Slot] == null)
{
return;
}
if (!OKTWPredictioner.Config.Item(String.Format("{0}{1}", ObjectManager.Player.ChampionName, args.Slot)).GetValue <bool>())
{
return;
}
if (handleEvent[(int)args.Slot])
{
args.Process = false;
handleEvent[(int)args.Slot] = false;
var enemy = args.EndPosition.GetEnemiesInRange(200f).OrderByDescending(p => Utility.GetPriority(p.ChampionName)).FirstOrDefault();
if (enemy == null)
{
enemy = TargetSelector.GetTarget(OKTWPredictioner.Spells[(int)args.Slot].Range, TargetSelector.DamageType.Physical);
}
if (enemy != null)
{
OKTWPredictioner.Spells[(int)args.Slot].CastSebby(enemy, Utility.HitchanceArray[OKTWPredictioner.Config.Item("HITCHANCE").GetValue <StringList>().SelectedIndex]);
}
}
}
}
}
public static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe)
{
if (getCheckBoxItem(menu, "ENABLED") && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass)))
{
if (menu[String.Format("{0}{1}", ObjectManager.Player.ChampionName, args.Slot)] == null)
{
return;
}
if (!ShineCommon.Utility.IsValidSlot(args.Slot))
{
return;
}
if (SPredictioner._spells[(int)args.Slot] == null)
{
return;
}
if (!getCheckBoxItem(menu, String.Format("{0}{1}", ObjectManager.Player.ChampionName, args.Slot)))
{
return;
}
if (handleEvent[(int)args.Slot])
{
args.Process = false;
handleEvent[(int)args.Slot] = false;
var enemy = TargetSelector.GetTarget(SPredictioner._spells[(int)args.Slot].Range, DamageType.Physical);
if (enemy != null)
{
args.Process = false;
SPredictioner.Cast(args.Slot);
}
}
}
}
}
private static void OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (sender.Owner.IsMe)
{
if (Map == Utility.Map.MapType.SummonersRift)
{
if (Heroes.Player.InFountain() && args.Slot == SpellSlot.Recall)
{
args.Process = false;
}
if (Heroes.Player.HasBuff("Recall"))
{
args.Process = false;
}
}
if (Heroes.Player.UnderTurret(true) && args.Target.IsValid <Obj_AI_Hero>())
{
args.Process = false;
}
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
return;
if (sender != null && sender.Owner != null && sender.Owner.IsMe && args.Slot == SpellSlot.E && (Variables.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo))
{
if (!(args.Target is Obj_AI_Hero))
{
args.Process = false;
return;
}
if (GetCondemnTarget(ObjectManager.Player.ServerPosition).IsValidTarget())
{
if (!Shine.GetTarget(ObjectManager.Player.ServerPosition).IsValidTarget())
{
args.Process = false;
}
}
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!Settings.Combo.RBlockMovement)
{
return;
}
if (args.Slot == SpellSlot.R)
{
RCasted = true;
RCastTime = Core.GameTickCount;
Orbwalker.DisableAttacking = true;
Orbwalker.DisableMovement = true;
}
if (RCasted && Player.Instance.Spellbook.IsChanneling)
{
args.Process = false;
}
}
private static void Spellbook_OnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if ((args.Slot == SpellSlot.E) && ((Game.Time * 1000 - _lastETime < 3000) && (_lastEPosition.DistanceCached(args.EndPosition) < 300)))
{
args.Process = false;
}
else if (args.Slot == SpellSlot.E)
{
_lastETime = Game.Time * 1000;
_lastEPosition = args.EndPosition;
}
if ((args.Slot == SpellSlot.R) && (Player.Instance.Spellbook.GetSpell(SpellSlot.R).Name == "JhinRShot") && (Game.Time * 1000 - _lastRTime < Settings.Combo.RDelay + 1000))
{
args.Process = false;
}
else if ((args.Slot == SpellSlot.R) && (Player.Instance.Spellbook.GetSpell(SpellSlot.R).Name == "JhinRShot"))
{
_lastRTime = Game.Time * 1000;
}
}
private void SpellbookOnOnCastSpell(Spellbook sender, SpellbookCastSpellEventArgs args)
{
if (!sender.Owner.IsMe || !EvadeEnabled)
{
return;
}
if (SpellBlocker.WillBlock(args.Slot) && IsHeroInDanger())
{
args.Process = false;
return;
}
if (BlockDangerousDashes && EvadeSpellManager.IsDashSpell(args.Slot) && !IsHeroInDanger())
{
if (!EvadeSpellManager.IsDashSafe(EvadeSpellDatabase.Spells.First(x => x.Slot == args.Slot), args.EndPosition.To2D(), this))
{
args.Process = false;
}
}
}
