private static void Drawing_OnDraw(EventArgs args)
{
if (!Menu.Item("DrawLines").GetValue <Circle>().Active)
{
return;
}
var minionList = MinionManager.GetMinions(Player.Position, Menu.Item("DrRange").GetValue <Slider>().Value, MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.MaxHealth);
foreach (var minion in minionList.Where(minion => minion.IsValidTarget(Menu.Item("DrRange").GetValue <Slider>().Value)))
{
var attackToKill = Math.Ceiling(minion.MaxHealth / Player.GetAutoAttackDamage(minion, true));
var hpBarPosition = minion.HPBarPosition;
var barWidth = minion.IsMelee() ? 75 : 80;
if (minion.HasBuff("turretshield", true))
{
barWidth = 70;
}
var barDistance = barWidth / attackToKill;
for (var i = 0; i < attackToKill; i++)
{
if (i != 0)
{
Drawing.DrawLine(
new Vector2(hpBarPosition.X + 45 + (float)(barDistance) * i, hpBarPosition.Y + 18),
new Vector2(hpBarPosition.X + 45 + ((float)(barDistance) * i), hpBarPosition.Y + 23), Menu.Item("Thick").GetValue <Slider>().Value,
((minion.Health <= Player.GetAutoAttackDamage(minion, true) && Menu.Item("LastHitH").GetValue <Circle>().Active) ? Menu.Item("LastHitH").GetValue <Circle>().Color : Menu.Item("DrawLines").GetValue <Circle>().Color));
}
}
}
}
public static void Obj_AI_Base_OnBasicAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!(args.Target is AIHeroClient))
{
return;
}
var target = (AIHeroClient)args.Target;
if ((sender is AIHeroClient || sender is Obj_AI_Turret) && sender.IsEnemy && target != null && target.IsAlly)
{
if (target.IsValidTarget(Items.Face_of_the_moutain.Range) &&
Config.Defensive["Face"].Cast <CheckBox>().CurrentValue)
{
var ShieldValue = Player.Instance.MaxHealth * 0.1 * Config.FOTMSlider.CurrentValue / 100;
if (sender.GetAutoAttackDamage(target, true) >= ShieldValue)
{
if (Config.Defensive["Face" + target.ChampionName].Cast <CheckBox>().CurrentValue)
{
if (Items.Face_of_the_moutain.IsOwned() && Items.Face_of_the_moutain.IsReady())
{
Items.Face_of_the_moutain.Cast(target);
}
}
}
}
if (target.IsValidTarget(Items.Locket_of_the_iron_Solari.Range) &&
Config.Defensive["Solari"].Cast <CheckBox>().CurrentValue)
{
var ShieldValue = (75 + 15 * Player.Instance.Level) * Config.SolariSlider.CurrentValue / 100;
if (sender.GetAutoAttackDamage(target, true) >= ShieldValue)
{
if (Config.Defensive["Solari" + target.ChampionName].Cast <CheckBox>().CurrentValue)
{
if (Items.Locket_of_the_iron_Solari.IsOwned() && Items.Locket_of_the_iron_Solari.IsReady())
{
Items.Locket_of_the_iron_Solari.Cast();
}
}
}
}
if (!Extensions.ChampNoMana)
{
if (target.IsMe && Config.Defensive["Ser"].Cast <CheckBox>().CurrentValue)
{
var ShieldValue = (150 + 0.2 * Player.Instance.Mana) * Config.SerSlider.CurrentValue / 100;
if (sender.GetAutoAttackDamage(target, true) >= ShieldValue)
{
if (Items.Seraph_s_Embrace.IsOwned() && Items.Seraph_s_Embrace.IsReady())
{
Items.Seraph_s_Embrace.Cast();
}
}
}
}
}
}
public static float GetAutoAttackDamageOverride(this Obj_AI_Base Attacker, Obj_AI_Base Target, bool IncludePassive)
{
// in case of Bugs or not updated stuff inside the SDK
if (Attacker != null && Target != null && Attacker.Type == GameObjectType.AIHeroClient)
{
var attacker = (AIHeroClient)Attacker;
switch (attacker.Hero)
{
case Champion.MissFortune:
switch (Target.Type)
{
case GameObjectType.AIHeroClient:
return(Attacker.GetAutoAttackDamage(Target, IncludePassive) +
Attacker.CalculateDamageOnUnit(Target, DamageType.Physical,
Attacker.BaseAttackDamage * (0.5f + (0.5f / 17 * (attacker.Level - 1) * 0.95f))));
case GameObjectType.obj_AI_Minion:
case GameObjectType.obj_AI_Turret:
return(Attacker.GetAutoAttackDamage(Target, IncludePassive) +
Attacker.CalculateDamageOnUnit(Target, DamageType.Physical,
Attacker.BaseAttackDamage * (0.25f + (0.25f / 17 * (attacker.Level - 1) * 0.95f))));
}
break;
case Champion.Thresh:
if (Attacker.Spellbook.GetSpell(SpellSlot.E).Level >= 1)
{
float passivePercent = 0;
if (Attacker.HasBuff("Threshqpassive1") && Attacker.HasBuff("Threshqpassive2") &&
Attacker.HasBuff("Threshqpassive3") && Attacker.HasBuff("Threshqpassive4"))
{
if (Attacker.HasBuff("Threshqpassive4"))
{
passivePercent = 1;
}
else
{
var timegone = Game.Time - Attacker.GetBuff("Threshqpassive").StartTime;
passivePercent = 10 / timegone - 0.05f;
}
if (passivePercent >= 1)
{
passivePercent = 1;
}
}
var souls = Attacker.HasBuff("threshpassivesoulsgain") ? Attacker.GetBuff("threshpassivesoulsgain").Count : 0;
float[] passive = { 0.8f, 1.1f, 1.4f, 1.7f, 2.0f };
return(Attacker.CalculateDamageOnUnit(Target, DamageType.Physical, Attacker.BaseAttackDamage) +
Attacker.CalculateDamageOnUnit(Target, DamageType.Magical,
(passivePercent * passive[Attacker.Spellbook.GetSpell(SpellSlot.E).Level]) * attacker.BaseAttackDamage + souls));
}
break;
}
}
return(Attacker.GetAutoAttackDamage(Target, IncludePassive));
}
/// <summary>
/// Handles the <see cref="E:ProcessSpell" /> event.
/// </summary>
/// <param name="unit">The unit.</param>
/// <param name="Spell">The <see cref="GameObjectProcessSpellCastEventArgs"/> instance containing the event data.</param>
private static void OnProcessSpell(Obj_AI_Base unit, GameObjectProcessSpellCastEventArgs Spell)
{
try
{
//改动
if (unit.Type == GameObjectType.obj_AI_Turret && unit.IsAlly && IsLaneClear)
{
var target = Spell.Target as Obj_AI_Base;
if (target.Type == GameObjectType.obj_AI_Minion && Player.Distance(target) < GetRealAutoAttackRange(Player))
{
if (target.Health > unit.GetAutoAttackDamage(target) + Player.GetAutoAttackDamage(target, true) &&
target.Health < unit.GetAutoAttackDamage(target) + Player.GetAutoAttackDamage(target, true) * 2)
{
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
var spellName = Spell.SData.Name;
if (unit.IsMe && IsAutoAttackReset(spellName) && Spell.SData.SpellCastTime == 0)
{
ResetAutoAttackTimer();
}
if (!IsAutoAttack(spellName))
{
return;
}
if (unit.IsMe &&
(Spell.Target is Obj_AI_Base || Spell.Target is Obj_BarracksDampener || Spell.Target is Obj_HQ))
{
LastAATick = Utils.GameTimeTickCount - Game.Ping / 2;
_missileLaunched = false;
LastMoveCommandT = 0;
if (Spell.Target is Obj_AI_Base)
{
var target = (Obj_AI_Base)Spell.Target;
if (target.IsValid)
{
FireOnTargetSwitch(target);
_lastTarget = target;
}
}
}
FireOnAttack(unit, _lastTarget);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private void Game_OnUpdate(System.EventArgs args)
{
if (targetUnderTurret != null && targetUnderTurret.IsDead)
{
targetUnderTurret = null;
turrent = null;
}
if (zedOrbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo &&
zedOrbwalker.ActiveMode != Orbwalking.OrbwalkingMode.None && turrent != null &&
targetUnderTurret != null && !targetUnderTurret.IsDead && targetUnderTurret.IsValid)
{
if (targetUnderTurret.IsValid)
{
if (ObjectManager.Player.Distance(targetUnderTurret)
< Orbwalking.GetRealAutoAttackRange(targetUnderTurret) + 20F &&
(targetUnderTurret.Health
< (ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret) * 2)
+ turrent.GetAutoAttackDamage(targetUnderTurret) &&
targetUnderTurret.Health
> turrent.GetAutoAttackDamage(targetUnderTurret)
+ ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret)))
{
ObjectManager.Player.IssueOrder(GameObjectOrder.AttackUnit, targetUnderTurret);
}
if (q.IsReady() && q.CanCast(targetUnderTurret) &&
ObjectManager.Player.Distance(targetUnderTurret)
< Orbwalking.GetRealAutoAttackRange(targetUnderTurret) + 20F &&
targetUnderTurret.Health
< q.GetDamage(targetUnderTurret)
+ ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret, true))
{
q.Cast(targetUnderTurret);
return;
}
if (e.IsReady() && e.CanCast(targetUnderTurret) && !q.IsReady() &&
ObjectManager.Player.Distance(targetUnderTurret)
< Orbwalking.GetRealAutoAttackRange(targetUnderTurret) + 20F &&
targetUnderTurret.Health
< e.GetDamage(targetUnderTurret)
+ ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret, true))
{
e.Cast(targetUnderTurret);
}
}
}
}
public static void OnBasicAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (Player.Instance.IsDead)
{
return;
}
if (!Solari.IsOwned() || !Solari.IsReady())
{
return;
}
if (!(args.Target is AIHeroClient))
{
return;
}
if (!(sender is AIHeroClient || sender is Obj_AI_Turret) || !sender.IsEnemy || sender == null)
{
return;
}
var hero = sender as AIHeroClient;
var target = (AIHeroClient)args.Target;
if (hero.IsEnemy && target != null)
{
var AttackPercent = (sender.GetAutoAttackDamage(target, true) / target.TotalShieldHealth()) * 100;
var Death = sender.GetAutoAttackDamage(target, true) >= target.TotalShieldHealth() || AttackPercent >= target.HealthPercent;
if (target.IsMe)
{
if (target.HealthPercent <= Status_Slider(M_Item, "Item.Solari.MyHp") || Death || AttackPercent >= Status_Slider(M_Item, "Item.Solari.AMyHp"))
{
Solari.Cast();
}
}
if (target.IsAlly && !target.IsMe)
{
if (Player.Instance.Distance(target) <= 600)
{
if (target.HealthPercent <= Status_Slider(M_Item, "Item.Solari.TeamHp") || Death)
{
Solari.Cast();
}
}
}
}
}
private static void OnCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsEnemy) return;
if (SoulBoundHero == null) return;
// Calculate Damage
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == SoulBoundHero.NetworkId)
{
// Calculate arrival time and damage
_incomingDamage.Add(SoulBoundHero.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time, (float)sender.GetAutoAttackDamage(SoulBoundHero));
}
// Sender is a hero
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot == SpellSlot.Unknown) return;
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null && args.Target.NetworkId == SoulBoundHero.NetworkId)
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSummonerSpellDamage(SoulBoundHero, LeagueSharp.Common.Damage.SummonerSpell.Ignite));
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == SoulBoundHero.NetworkId) ||
args.End.Distance(SoulBoundHero.ServerPosition) < Math.Pow(args.SData.LineWidth, 2)))
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(SoulBoundHero, slot));
}
}
float DamageDealtInTime(Obj_AI_Base sender, Obj_AI_Base minion, int time)
{
var autos = this.NumberOfAutoAttacksInTime(sender, minion, time);
var dmg = autos * sender.GetAutoAttackDamage(minion);
return((float)(autos * dmg));
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.LSIsValidTarget(3000) || sender.Team != ObjectManager.Player.Team || sender is AIHeroClient ||
!Utility.IsAutoAttack(args.SData.Name) || !(args.Target is Obj_AI_Base) ||
sender.Type == GameObjectType.obj_AI_Turret)
{
return;
}
var target = (Obj_AI_Base)args.Target;
if (ActiveAttacks.ContainsKey(sender.NetworkId))
{
ActiveAttacks.Remove(sender.NetworkId);
}
var attackData = new PredictedDamage(
sender,
target,
Utils.TickCount,
sender.AttackCastDelay * 1000f,
sender.AttackDelay * 1000f,
sender.IsMelee() ? float.MaxValue : args.SData.MissileSpeed,
sender.GetAutoAttackDamage(target) - 1);
ActiveAttacks.Add(sender.NetworkId, attackData);
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (args.SData == null)
{
return;
}
var targed = args.Target as Obj_AI_Base;
if (targed != null)
{
if (targed.Type == GameObjectType.AIHeroClient && targed.Team != sender.Team && sender.IsMelee)
{
IncomingDamageList.Add(new UnitIncomingDamage
{
Damage = DamageLibrary.GetSpellDamage((AIHeroClient)sender, (AIHeroClient)targed, Extensions.GetSpellSlotFromName((AIHeroClient)args.Target, args.SData.Name)),
TargetNetworkId = args.Target.NetworkId,
Time = Game.Time,
Skillshot = false
});
}
if (sender.Team != ObjectManager.Player.Team || !sender.IsValidTarget(3000) ||
!EloBuddy.SDK.Constants.AutoAttacks.IsAutoAttack(args.SData.Name) || !(args.Target is Obj_AI_Base))
{
return;
}
var target = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData = new PredictedDamage(
sender,
target,
GameTimeTickCount - Game.Ping / 2,
sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee ? int.MaxValue : (int)args.SData.MissileSpeed,
sender.GetAutoAttackDamage(target, true));
ActiveAttacks.Add(sender.NetworkId, attackData);
}
else
{
foreach (
var champion in
ChampionList.Where(
champion =>
!champion.IsDead && champion.IsVisible && champion.Team != sender.Team &&
champion.Distance(sender) < 2000))
{
if (CanHitSkillShot(champion, args))
{
IncomingDamageList.Add(new UnitIncomingDamage
{
Damage = DamageLibrary.GetSpellDamage((AIHeroClient)sender, (AIHeroClient)targed, Extensions.GetSpellSlotFromName((AIHeroClient)champion, args.SData.Name)),
TargetNetworkId = champion.NetworkId,
Time = Game.Time,
Skillshot = true
});
}
}
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (OnSpellDmg == null)
{
return;
}
if (!(sender is Obj_AI_Hero))
{
return;
}
if (!(args.Target is Obj_AI_Hero))
{
return;
}
var _sender = sender as Obj_AI_Hero;
var target = args.Target as Obj_AI_Hero;
var dmg = Orbwalking.IsAutoAttack(args.SData.Name) ? (float)sender.GetAutoAttackDamage(target) : GetDmg(_sender, target, _sender.GetSpellSlot(args.SData.Name));
if (dmg != 0)
{
OnSpellDmg(_sender, target, dmg);
}
}
/// <summary>
/// Process Spell Cast subscribed event function.
/// </summary>
/// <param name="sender"><see cref="Obj_AI_Base" /> sender</param>
/// <param name="args">Processed Spell Cast Data</param>
private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.LSIsValidTarget(2000, false) || !AutoAttack.IsAutoAttack(args.SData.Name) || !sender.IsAlly)
{
return;
}
if (!(sender is Obj_AI_Minion) && !(sender is Obj_AI_Turret))
{
return;
}
var target = args.Target as Obj_AI_Minion;
if (target == null)
{
return;
}
ActiveAttacks.Remove(sender.NetworkId);
ActiveAttacks.Add(
sender.NetworkId,
new PredictedDamage(
sender,
target,
Variables.TickCount - (Game.Ping / 2),
sender.AttackCastDelay * 1000,
(sender.AttackDelay * 1000) - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target)));
}
private void Game_ProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!W.IsReady(2000))
{
return;
}
if (!(sender is Obj_AI_Base))
{
return;
}
Obj_AI_Hero target = args.Target as Obj_AI_Hero;
if (target != null && target.IsMe)
{
if (sender.IsValid && !sender.IsDead && sender.IsEnemy && target.IsValid && target.IsMe)
{
if (Orbwalking.IsAutoAttack(args.SData.Name))
{
var dmg = (float)sender.GetAutoAttackDamage(player, true);
DamageTaken += dmg;
}
else
{
if (W.IsReady())
{
IncSpell = true;
Utility.DelayAction.Add(300, () => IncSpell = false);
}
}
}
}
}
/// <summary>
/// Fired when the game processes a spell cast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="GameObjectProcessSpellCastEventArgs"/> instance containing the event data.</param>
private static void ObjAiBaseOnOnProcessSpellCast(
Obj_AI_Base sender,
GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsValidTarget(3000, false) || sender.Team != ObjectManager.Player.Team ||
sender is AIHeroClient || !(args.Target is Obj_AI_Base))
{
return;
}
var target = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData = new PredictedDamage(
sender,
target,
Helper.GameTimeTickCount - Game.Ping / 2,
sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target, true));
ActiveAttacks.Add(sender.NetworkId, attackData);
}
internal static void OnAnnoyable(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (Player.Instance.Distance(args.Target) > 500 || args.Target.IsEnemy)
{
return;
}
Obj_AI_Base annoy = sender;
if (sender.Type != GameObjectType.AIHeroClient)
{
return;
}
Obj_AI_Minion minion = args.Target as Obj_AI_Minion;
if (annoy == null)
{
return;
}
if (minion == null)
{
return;
}
if (minion.Health < annoy.GetAutoAttackDamage(minion) && (SpellManager.E.Level * 30) + 30 + (0.2 * annoy.FlatMagicDamageMod) + minion.Health > annoy.GetAutoAttackDamage(minion) && Settings.UseEA && SpellManager.E.IsReady()) //TODO: Add Config!
{
SpellManager.E.Cast();
}
return;
}
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>());
}
Obj_AI_Hero target = args.Target as Obj_AI_Hero;
if (target != null && !activatedP)
{
if (sender.IsValid && !sender.IsDead && sender.IsEnemy && target.IsValid && target.IsMe)
{
if (Orbwalking.IsAutoAttack(args.SData.Name))
{
var dmg = (float)sender.GetAutoAttackDamage(player, true);
DamageTaken += dmg;
DamageCount++;
}
else
{
if (W.IsReady())
{
IncSpell = true;
Utility.DelayAction.Add(300, () => IncSpell = false);
}
}
}
}
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>());
}
}
private void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (sender.IsMe)
{
if (args.SData.Name == "KalistaExpungeWrapper")
{
Orbwalking.ResetAutoAttackTimer();
}
}
if (!sender.IsEnemy || SoulBound.Unit == null || R.Level == 0 ||
!Menu.Item(Menu.Name + ".ultimate.save").GetValue <bool>())
{
return;
}
if (args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId &&
(!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()))
{
SoulBound.Add(
SoulBound.Unit.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed +
Game.Time, (float)sender.GetAutoAttackDamage(SoulBound.Unit));
}
else
{
var hero = sender as Obj_AI_Hero;
if (hero != null)
{
var slot = hero.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
var damage = 0f;
if (args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId &&
slot == hero.GetSpellSlot("SummonerDot"))
{
damage =
(float)hero.GetSummonerSpellDamage(SoulBound.Unit, Damage.SummonerSpell.Ignite);
}
else if ((slot == SpellSlot.Q || slot == SpellSlot.W || slot == SpellSlot.E ||
slot == SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId) ||
args.End.Distance(SoulBound.Unit.ServerPosition, true) <
Math.Pow(args.SData.LineWidth, 2)))
{
damage = (float)hero.GetSpellDamage(SoulBound.Unit, slot);
}
if (damage > 0)
{
SoulBound.Add(Game.Time + 2, damage);
}
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private static void OnCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsEnemy) return;
if (Properties.SoulBoundHero == null) return;
// Calculate Damage
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == Properties.SoulBoundHero.NetworkId)
{
// Calculate arrival time and damage
_incomingDamage.Add(Properties.SoulBoundHero.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time, (float)sender.GetAutoAttackDamage(Properties.SoulBoundHero));
}
// Sender is a hero
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null && args.Target.NetworkId == Properties.SoulBoundHero.NetworkId)
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSummonerSpellDamage(Properties.SoulBoundHero, Damage.SummonerSpell.Ignite));
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == Properties.SoulBoundHero.NetworkId) ||
args.End.Distance(Properties.SoulBoundHero.ServerPosition) < Math.Pow(args.SData.LineWidth, 2)))
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(Properties.SoulBoundHero, slot));
}
}
if (!Properties.MainMenu.Item("bBST").GetValue<bool>() || !Properties.Champion.R.IsReady()) return;
var buffName = "";
switch (Properties.SoulBoundHero.ChampionName)
{
case "Blitzcrank":
buffName = "rocketgrab2";
break;
case "Skarner":
buffName = "skarnerimpale";
break;
case "TahmKench":
buffName = "tahmkenchwdevoured";
break;
}
if (buffName.Length <= 0) return;
if (Properties.SoulBoundHero.Distance(Properties.PlayerHero) > Orbwalking.GetRealAutoAttackRange(Properties.PlayerHero)) return;
foreach (var target in HeroManager.Enemies.Where(t => t.IsValid && t.HasBuff(buffName)))
{
if (target.Distance(Properties.PlayerHero) < Properties.MainMenu.Item("sBST").GetValue<Slider>().Value) continue;
Properties.Champion.R.Cast();
return;
}
}
private void Game_ProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe)
{
switch (args.SData.Name)
{
case "UdyrTigerStance":
stance = Stance.Tiger;
break;
case "UdyrTurtleStance":
stance = Stance.Turtle;
break;
case "UdyrBearStance":
stance = Stance.Bear;
break;
case "UdyrPhoenixStance":
stance = Stance.Phoenix;
break;
}
}
if (!(sender is Obj_AI_Base))
{
return;
}
Obj_AI_Hero target = args.Target as Obj_AI_Hero;
if (target != null)
{
if (sender.IsValid && !sender.IsDead && sender.IsEnemy && target.IsValid && target.IsMe)
{
if (((config.Item("usewLC", true).GetValue <bool>() &&
orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear) ||
(orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo &&
config.Item("usew", true).GetValue <bool>())))
{
/*var ShieldBuff = new Int32[] { 60, 100, 140, 180, 220 }[W.Level - 1] +
* 0.5 * player.FlatMagicDamageMod;*/
if (Orbwalking.IsAutoAttack(args.SData.Name))
{
var dmg = (float)sender.GetAutoAttackDamage(player, true);
DamageTaken += dmg;
}
else
{
if (W.IsReady())
{
IncSpell = true;
Utility.DelayAction.Add(300, () => IncSpell = false);
}
}
}
}
}
}
private void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe && args.SData.Name == "KalistaExpungeWrapper")
{
Utility.DelayAction.Add(0x7D, Orbwalking.ResetAutoAttackTimer);
}
if (sender.IsEnemy)
{
if (this.SoulBound == null || !this.GetItemValue <bool>("com.iseries.kalista.misc.saveAlly"))
{
return;
}
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null &&
args.Target.NetworkId == this.SoulBound.NetworkId)
{
this.incomingDamage.Add(
this.SoulBound.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed
+ Game.Time,
(float)sender.GetAutoAttackDamage(this.SoulBound));
}
else
{
var hero = sender as Obj_AI_Hero;
if (hero == null)
{
return;
}
var attacker = hero;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot == SpellSlot.Unknown)
{
return;
}
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null &&
args.Target.NetworkId == this.SoulBound.NetworkId)
{
this.instantDamage.Add(
Game.Time + 2,
(float)attacker.GetSummonerSpellDamage(this.SoulBound, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == this.SoulBound.NetworkId) ||
args.End.Distance(this.SoulBound.ServerPosition, true)
< Math.Pow(args.SData.LineWidth, 2)))
{
this.instantDamage.Add(
Game.Time + 2,
(float)attacker.GetSpellDamage(this.SoulBound, slot));
}
}
}
}
public DamageMaker(Obj_AI_Base sourceIn, Obj_AI_Base targetIn, GameObject missleIn, SpellData dataIn,
bool meleeIn = false)
{
Source = sourceIn;
Target = targetIn;
Missle = missleIn;
SData = dataIn;
Melee = !meleeIn;
CreatedTick = Now;
IsAutoAtack = SData.IsAutoAttack();
if (IsAutoAtack)
{
DealDamage = (float)Source.GetAutoAttackDamage(Target, true);
if (Source.IsMelee)
{
Cycle = (int)(Source.AttackDelay * 1000);
}
else
{
//var dist = source.Distance(target);
Cycle = (int)((Source.AttackDelay * 1000)) /*+ (dist*1000)/sData.MissileSpeed)*/;
//Console.WriteLine("cycle: " + cycle);
}
//Console.WriteLine("cycle: " + source.AttackSpeedMod);
}
else
{
Cycle = 0;
var client = Source as AIHeroClient;
if (client != null)
{
var tSpell = TargetSpellDatabase.GetByName(SData.Name);
if (tSpell == null)
{
//Console.WriteLine("Unknown targeted spell: " + sData.Name);
DealDamage = 0;
}
else
{
try
{
DealDamage = (float)client.GetSpellDamage(Target, tSpell.Spellslot);
}
catch (Exception)
{
DealDamage = 0;
}
}
}
else
{
DealDamage = 0;
}
}
}
public override void Obj_AI_Base_OnProcessSpellCast(
Obj_AI_Base sender,
GameObjectProcessSpellCastEventArgs args)
{
//attackMinions.Clear();
if (sender == null)
{
return;
}
if (sender.IsEnemy)
{
if (SoulBound != null && Program.Config.Item("SoulBoundSaver").GetValue <bool>())
{
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null &&
args.Target.NetworkId == SoulBound.NetworkId)
{
incomingDamage.Add(
SoulBound.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed
+ Game.Time,
(float)sender.GetAutoAttackDamage(SoulBound));
}
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null &&
args.Target.NetworkId == SoulBound.NetworkId)
{
InstantDamage.Add(
Game.Time + 2,
(float)attacker.GetSummonerSpellDamage(SoulBound, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == SoulBound.NetworkId) ||
args.End.Distance(SoulBound.ServerPosition, true)
< Math.Pow(args.SData.LineWidth, 2)))
{
InstantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(SoulBound, slot));
}
}
}
}
}
if (sender.IsMe && args.SData.Name == E.Instance.Name)
{
Utility.DelayAction.Add(250, Orbwalking.ResetAutoAttackTimer);
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
foreach (var ally in EntityManager.Heroes.Allies.Where(ally => E.IsInRange(ally) && !ally.IsZombie))
{
if (sender.IsEnemy)
{
// Calculations to save your souldbound
if (ally != null && Settings.UseE)
{
// Auto attacks
if ((!(sender is AIHeroClient) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == ally.NetworkId)
{
// Calculate arrival time and damage
IncDamage[ally.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time] = sender.GetAutoAttackDamage(ally);
}
// Sender is a hero
else
{
var attacker = sender as AIHeroClient;
if (attacker != null)
{
var slot = attacker.GetSpellSlotFromName(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlotFromName("SummonerDot") && args.Target != null && args.Target.NetworkId == ally.NetworkId)
{
// Ingite damage (dangerous)
InstDamage[Game.Time + 2] = attacker.GetSummonerSpellDamage(ally, DamageLibrary.SummonerSpells.Ignite);
}
else
{
switch (slot)
{
case SpellSlot.Q:
case SpellSlot.W:
case SpellSlot.E:
case SpellSlot.R:
if ((args.Target != null && args.Target.NetworkId == ally.NetworkId) || args.End.Distance(ally.ServerPosition) < Math.Pow(args.SData.LineWidth, 2))
{
// Instant damage to target
InstDamage[Game.Time + 2] = attacker.GetSpellDamage(ally, slot);
}
break;
}
}
}
}
}
}
}
}
}
public DamageMaker(Obj_AI_Base sourceIn, Obj_AI_Base targetIn, GameObject missleIn, SpellData dataIn, bool meleeIn = false)
{
source = sourceIn;
target = targetIn;
missle = missleIn;
sData = dataIn;
melee = !meleeIn;
createdTick = now;
isAutoAtack = sData.IsAutoAttack();
if (isAutoAtack)
{
dealDamage = (float)source.GetAutoAttackDamage(target, true);
if (source.IsMelee)
{
cycle = (int)(source.AttackDelay * 1000);
}
else
{
//var dist = source.Distance(target);
cycle = (int)((source.AttackDelay * 1000)) /*+ (dist*1000)/sData.MissileSpeed)*/;
//Console.WriteLine("cycle: " + cycle);
}
//Console.WriteLine("cycle: " + source.AttackSpeedMod);
}
else
{
cycle = 0;
if (source is AIHeroClient)
{
var tSpell = TargetSpellDatabase.GetByName(sData.Name);
if (tSpell == null)
{
//Console.WriteLine("Unknown targeted spell: " + sData.Name);
dealDamage = 0;
}
else
{
try
{
dealDamage = (float)((AIHeroClient)source).GetSpellDamage(target, tSpell.Spellslot);
}
catch (Exception)
{
dealDamage = 0;
}
}
}
else
{
dealDamage = 0;
}
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!Settings.useHeal)
return;
if (sender.IsEnemy || sender.IsMonster)
{
if ((sender.IsMinion || sender.IsMonster || args.SData.IsAutoAttack()) && args.Target != null)
{
for (int i = 0; i < EntityManager.Heroes.Allies.Count; i++)
{
if (args.Target.NetworkId == EntityManager.Heroes.Allies[i].NetworkId)
{
IncDamage[i][EntityManager.Heroes.Allies[i].ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time] = sender.GetAutoAttackDamage(EntityManager.Heroes.Allies[i]);
}
}
}
else if (!(sender is AIHeroClient))
{
return;
}
else
{
var attacker = sender as AIHeroClient;
if (attacker != null)
{
var slot = attacker.GetSpellSlotFromName(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlotFromName("SummonerDot") && args.Target != null)
{
for (int i = 0; i < EntityManager.Heroes.Allies.Count; i++)
{
if (args.Target.NetworkId == EntityManager.Heroes.Allies[i].NetworkId)
{
InstDamage[i][Game.Time + 2] = attacker.GetSummonerSpellDamage(EntityManager.Heroes.Allies[i], DamageLibrary.SummonerSpells.Ignite);
}
}
}
else
{
for (int i = 0; i < EntityManager.Heroes.Allies.Count; i++)
{
if ((args.Target != null && args.Target.NetworkId == EntityManager.Heroes.Allies[i].NetworkId) || args.End.Distance(EntityManager.Heroes.Allies[i].ServerPosition) < Math.Pow(args.SData.LineWidth, 2))
{
InstDamage[i][Game.Time + 2] = attacker.GetSpellDamage(EntityManager.Heroes.Allies[i], slot);
}
}
}
}
}
}
}
}
private float getDamage()
{
var tar = getTarget();
if (tar == null || source == null)
{
return(0);
}
// Console.WriteLine("Return damge");
return((float)source.GetAutoAttackDamage(tar, true));
}
public static float GetAttackDamage(this Obj_AI_Base from, Obj_AI_Base target, bool respectPassive = false)
{
if (!CachedAutoAttackDamage.ContainsKey(from.NetworkId))
{
CachedAutoAttackDamage.Add(from.NetworkId, new Dictionary <int, float>());
}
if (!CachedAutoAttackDamage[from.NetworkId].ContainsKey(target.NetworkId))
{
CachedAutoAttackDamage[from.NetworkId].Add(target.NetworkId, from.GetAutoAttackDamage(target, respectPassive));
}
return(CachedAutoAttackDamage[from.NetworkId][target.NetworkId]);
}
private void Obj_AI_Turret_OnTarget(Obj_AI_Base sender, Obj_AI_BaseTargetEventArgs args)
{
if (sender == null || args.Target == null || !sender.IsAlly || !args.Target.IsEnemy ||
!sender.SkinName.ToLowerInvariant().Contains("turret") ||
!args.Target.Name.ToLowerInvariant().Contains("minion"))
{
return;
}
if (player.Distance(args.Target) <= player.AttackRange + player.BoundingRadius + args.Target.BoundingRadius)
{
var target = (Obj_AI_Minion)args.Target;
var predictedHealth = HealthPrediction.GetHealthPrediction(target, (int)GetAATime(target), 500);
if (predictedHealth > sender.GetAutoAttackDamage(target) + AutoAttackDamage(target) &&
predictedHealth < sender.GetAutoAttackDamage(target) * 2)
{
EnqueueAA(target);
}
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsEnemy || !SpellMemeger.R.IsReady())
{
return;
}
if (SoulBoundAlly == null ||
!MenuMemeger.ComboMenu.GetMenuItem <CheckBox>("com.ikalista.combo.useR").CurrentValue)
{
return;
}
if ((!(sender is AIHeroClient) || args.SData.IsAutoAttack()) && args.Target != null &&
args.Target.NetworkId == SoulBoundAlly.NetworkId)
{
IncDamage[
SoulBoundAlly.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed +
Game.Time] = sender.GetAutoAttackDamage(SoulBoundAlly);
}
else
{
var attacker = sender as AIHeroClient;
if (attacker == null)
{
return;
}
var slot = attacker.GetSpellSlotFromName(args.SData.Name);
if (slot == SpellSlot.Unknown)
{
return;
}
if (slot == attacker.GetSpellSlotFromName("SummonerDot") && args.Target != null &&
args.Target.NetworkId == SoulBoundAlly.NetworkId)
{
InstDamage[Game.Time + 2] = attacker.GetSummonerSpellDamage(SoulBoundAlly,
DamageLibrary.SummonerSpells.Ignite);
}
else if (slot == SpellSlot.Q || slot == SpellSlot.W || slot == SpellSlot.E || slot == SpellSlot.R)
{
if (args.Target != null && args.Target.NetworkId == SoulBoundAlly.NetworkId ||
args.End.Distance(SoulBoundAlly.ServerPosition) <
Math.Pow(args.SData.LineWidth, 2))
{
InstDamage[Game.Time + 2] = attacker.GetSpellDamage(SoulBoundAlly, slot);
}
}
}
}
private static void Obj_AI_Base_OnBasicAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsAlly || !DamageEngine["TrackDamage"].Cast <CheckBox>().CurrentValue || !DamageEngine["ConsiderAttacks"].Cast <CheckBox>().CurrentValue || sender.IsMinion() && !DamageEngine["ConsiderMinions"].Cast <CheckBox>().CurrentValue)
{
return;
}
if (Damages.ContainsKey(args.Target.NetworkId))
{
var target = (Obj_AI_Base)args.Target;
Damages[args.Target.NetworkId].AddDamage(args.SData.Name, sender.GetAutoAttackDamage(target),
(target.IsMelee ? sender.AttackDelay : target.Distance(sender) / args.SData.MissileSpeed) * 1000);
}
}
internal static float GetAutoAttackDamageCached(this Obj_AI_Base from, Obj_AI_Base target,
bool respectPassives = false)
{
if (!MenuManager.IsCacheEnabled)
{
return(from.GetAutoAttackDamage(target, respectPassives));
}
if (
CachedAutoAttackDamage.Exist(new Tuple <int, int, bool>(from.NetworkId, target.NetworkId, respectPassives)))
{
return
(CachedAutoAttackDamage.Get(new Tuple <int, int, bool>(from.NetworkId, target.NetworkId,
respectPassives)));
}
CachedAutoAttackDamage.Add(new Tuple <int, int, bool>(from.NetworkId, target.NetworkId, respectPassives),
from.GetAutoAttackDamage(target, respectPassives));
return
(CachedAutoAttackDamage.Get(new Tuple <int, int, bool>(from.NetworkId, target.NetworkId, respectPassives)));
}
public static void OnBasicAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (Player.Instance.IsDead)
{
return;
}
if (Status_CheckBox(M_Item, "Item.Zy") == false)
{
return;
}
if (!Zhonyas.IsOwned() || !Zhonyas.IsReady())
{
return;
}
if (!(args.Target is AIHeroClient))
{
return;
}
var hero = sender as AIHeroClient;
var target = (AIHeroClient)args.Target;
if (!(sender is AIHeroClient || sender is Obj_AI_Turret) || !sender.IsEnemy || target == null || sender == null)
{
return;
}
var aaprecent = (sender.GetAutoAttackDamage(Player.Instance, true) / Player.Instance.TotalShieldHealth()) * 100;
var death = sender.GetAutoAttackDamage(Player.Instance, true) >= Player.Instance.TotalShieldHealth() || aaprecent >= Player.Instance.HealthPercent;
if ((hero.IsEnemy || sender is Obj_AI_Turret) && target.IsMe)
{
if (Player.Instance.HealthPercent <= Status_Slider(M_Item, "Item.Zy.BHp") || death || aaprecent >= Status_Slider(M_Item, "Item.Zy.BDmg"))
{
Core.DelayAction(() => Zhonyas.Cast(), (int)args.SData.MissileSpeed + 100);
}
}
}
private static void ObjAiBaseOnOnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender is Obj_AI_Turret && sender.IsAlly)
{
var target2 = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData2 = new PredictedDamage(
sender, target2, Environment.TickCount - Game.Ping / 2, sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee() ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target2, true));
ActiveAttacksTower.Remove(sender.NetworkId);
ActiveAttacksTower.Add(sender.NetworkId, attackData2);
return;
}
if (!sender.IsValidTarget(3000, false) || sender.Team != ObjectManager.Player.Team || sender is Obj_AI_Hero ||
!Orbwalking.IsAutoAttack(args.SData.Name) || !(args.Target is Obj_AI_Base))
{
return;
}
var target = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData = new PredictedDamage(
sender, target, Environment.TickCount - Game.Ping / 2, sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee() ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target, true));
ActiveAttacks.Add(sender.NetworkId, attackData);
}
//credits to hellsing, and jquery
public static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if (Program.E.IsReady())
{
if ((!(sender is AIHeroClient) || args.SData.IsAutoAttack()) && args.Target != null &&
args.Target.NetworkId == ObjectManager.Player.NetworkId)
{
_incomingDamage.Add(
ObjectManager.Player.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed +
Game.Time, (float)sender.GetAutoAttackDamage(ObjectManager.Player));
}
else if (sender is AIHeroClient)
{
var attacker = (AIHeroClient)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null &&
args.Target.NetworkId == ObjectManager.Player.NetworkId)
{
_instantDamage.Add(Game.Time + 2,
(float)
attacker.GetSummonerSpellDamage(ObjectManager.Player,
Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == ObjectManager.Player.NetworkId) ||
args.End.Distance(ObjectManager.Player.ServerPosition) <
Math.Pow(args.SData.LineWidth, 2)))
{
_instantDamage.Add(Game.Time + 2,
(float)attacker.GetSpellDamage(ObjectManager.Player, slot));
}
}
}
}
}
if (sender.IsMe)
{
if (args.SData.Name == "KalistaExpungeWrapper")
{
LeagueSharp.Common.Utility.DelayAction.Add(250, MyOrbwalker.ResetAutoAttackTimer);
}
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if ((!(sender is AIHeroClient) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId)
{
IncDamage[Player.Instance.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time] = sender.GetAutoAttackDamage(Player.Instance);
}
else if (!(sender is AIHeroClient))
{
return;
}
else
{
var attacker = sender as AIHeroClient;
if (attacker != null)
{
var slot = attacker.GetSpellSlotFromName(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlotFromName("SummonerDot") && args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId)
{
InstDamage[Game.Time + 2] = attacker.GetSummonerSpellDamage(Player.Instance, DamageLibrary.SummonerSpells.Ignite);
}
else
{
switch (slot)
{
case SpellSlot.Q:
case SpellSlot.W:
case SpellSlot.E:
case SpellSlot.R:
if ((args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId) || args.End.Distance(Player.Instance.ServerPosition) < Math.Pow(args.SData.LineWidth, 2))
{
// Instant damage to target
InstDamage[Game.Time + 2] = attacker.GetSpellDamage(Player.Instance, slot);
}
break;
}
}
}
}
}
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!(sender is Obj_AI_Hero) || !(args.Target is Obj_AI_Hero))
return;
var senderH = sender as Obj_AI_Hero;
var targetH = args.Target as Obj_AI_Hero;
var damage = Orbwalking.IsAutoAttack(args.SData.Name) ? sender.GetAutoAttackDamage(targetH) : GetDamage(senderH, targetH, senderH.GetSpellSlot(args.SData.Name));
if (damage > targetH.Health + 15)
{
if (OnSpellWillKill != null)
{
OnSpellWillKill(senderH, targetH, args.SData);
}
}
}
//credits to hellsing, and jquery
public static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if (_connectedAlly != null && Program.R.IsReady())
{
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null &&
args.Target.NetworkId == _connectedAlly.NetworkId)
{
_incomingDamage.Add(
_connectedAlly.ServerPosition.Distance(sender.ServerPosition)/args.SData.MissileSpeed +
Game.Time, (float) sender.GetAutoAttackDamage(_connectedAlly));
}
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero) sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null &&
args.Target.NetworkId == _connectedAlly.NetworkId)
{
_instantDamage.Add(Game.Time + 2,
(float) attacker.GetSummonerSpellDamage(_connectedAlly, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == _connectedAlly.NetworkId) ||
args.End.Distance(_connectedAlly.ServerPosition) <
Math.Pow(args.SData.LineWidth, 2)))
{
_instantDamage.Add(Game.Time + 2, (float) attacker.GetSpellDamage(_connectedAlly, slot));
}
}
}
}
}
if (sender.IsMe)
{
if (args.SData.Name == "KalistaExpungeWrapper")
{
Utility.DelayAction.Add(250, Orbwalking.ResetAutoAttackTimer);
}
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!(sender is Obj_AI_Hero) || !(args.Target is Obj_AI_Hero))
return;
var senderH = sender as Obj_AI_Hero;
var targetH = args.Target as Obj_AI_Hero;
var damage = Orbwalking.IsAutoAttack(args.SData.Name)?sender.GetAutoAttackDamage(targetH):GetDamage(senderH,targetH, senderH.GetSpellSlot(args.SData.Name));
//DebugHelper.AddEntry("Damage to "+targetH.ChampionName+" from spell "+args.SData.Name+" -> "+senderH.ChampionName+" ("+senderH.GetSpellSlot(args.SData.Name)+")",damage.ToString());
if (damage > targetH.Health + 20)
{
if (OnSpellWillKill != null)
{
OnSpellWillKill(senderH, targetH,args.SData);
}
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!CConfig.ConfigMenu.Item("useUltimate").GetValue<bool>() || !R.IsReady() || !sender.IsEnemy)
return;
// Calculations to smart save allies
foreach (var ally in HeroManager.Allies)
{
//Auto Attack
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null &&
args.Target.NetworkId == ally.NetworkId && !ally.IsBlocked())
{
// Calculate arrival time and damage
_incomingDamage.Add(
ally.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time,
(float)sender.GetAutoAttackDamage(ally));
}
// Sender is a hero
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null &&
args.Target.NetworkId == ally.NetworkId && !ally.IsBlocked())
{
// Ingite damage (dangerous)
_instantDamage.Add(Game.Time + 2,
(float)attacker.GetSummonerSpellDamage(ally, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == ally.NetworkId) ||
args.End.Distance(ally.ServerPosition) < Math.Pow(args.SData.LineWidth, 2)))
{
// Instant damage to target
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(ally, slot));
}
}
}
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (OnSpellDmg == null)
return;
if (!(sender is Obj_AI_Hero))
return;
if (!(args.Target is Obj_AI_Hero))
return;
var _sender = sender as Obj_AI_Hero;
var target = args.Target as Obj_AI_Hero;
var dmg = Orbwalking.IsAutoAttack(args.SData.Name) ? (float)sender.GetAutoAttackDamage(target) : GetDmg(_sender, target, _sender.GetSpellSlot(args.SData.Name));
if (dmg != 0)
{
OnSpellDmg(_sender, target, dmg);
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
// Calculations to save your souldbound
if (SoulBound != null && R.IsEnabled("misc"))
{
// Auto attacks
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == SoulBound.NetworkId)
{
// Calculate arrival time and damage
_incomingDamage.Add(SoulBound.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time, (float)sender.GetAutoAttackDamage(SoulBound));
}
// Sender is a hero
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null && args.Target.NetworkId == SoulBound.NetworkId)
{
// Ingite damage (dangerous)
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSummonerSpellDamage(SoulBound, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == SoulBound.NetworkId) ||
args.End.Distance(SoulBound.ServerPosition) < Math.Pow(args.SData.LineWidth, 2)))
{
// Instant damage to target
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(SoulBound, slot));
}
}
}
}
}
}
private static void OnCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsEnemy) return;
if (Properties.SoulBoundHero == null) return;
// Calculate Damage
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == Properties.SoulBoundHero.NetworkId)
{
// Calculate arrival time and damage
_incomingDamage.Add(Properties.SoulBoundHero.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time, (float)sender.GetAutoAttackDamage(Properties.SoulBoundHero));
}
// Sender is a hero
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null && args.Target.NetworkId == Properties.SoulBoundHero.NetworkId)
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSummonerSpellDamage(Properties.SoulBoundHero, Damage.SummonerSpell.Ignite));
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == Properties.SoulBoundHero.NetworkId) ||
args.End.Distance(Properties.SoulBoundHero.ServerPosition) < Math.Pow(args.SData.LineWidth, 2)))
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(Properties.SoulBoundHero, slot));
}
}
if (!Properties.MainMenu.Item("bBST").GetValue<bool>()) return;
var buffName = "";
switch (Properties.SoulBoundHero.ChampionName)
{
case "Blitzcrank":
buffName = "rocketgrab2";
break;
case "Skarner":
buffName = "skarnerimpale";
break;
case "TahmKench":
buffName = "tahmkenchwdevoured";
break;
}
if (Properties.MainMenu.Item("bBST").GetValue<bool>() && buffName.Length > 0)
{
foreach (var target in ObjectManager.Get<Obj_AI_Hero>())
{
if (!target.IsValid) continue;
if (!target.IsEnemy) continue;
if (target.Distance(ObjectManager.Player) > 2300f) continue;// out of range
if (target.Buffs == null) continue;
for (var i = 0; i < target.Buffs.Count(); i++)
{
if (target.Distance(ObjectManager.Player) > Properties.MainMenu.Item("sBST").GetValue<Slider>().Value)continue;
if (target.Buffs[i].Name.ToLower() != buffName || !target.Buffs[i].IsActive) continue;
Properties.Champion.R.Cast();//Else
}
}
}
}
/// <summary>
/// Handles the <see cref="E:ProcessSpell" /> event.
/// </summary>
/// <param name="unit">The unit.</param>
/// <param name="Spell">The <see cref="GameObjectProcessSpellCastEventArgs"/> instance containing the event data.</param>
private static void OnProcessSpell(Obj_AI_Base unit, GameObjectProcessSpellCastEventArgs Spell) {
try
{
//改动
if (unit.Type == GameObjectType.obj_AI_Turret && unit.IsAlly && IsLaneClear)
{
var target = Spell.Target as Obj_AI_Base;
if (target.Type == GameObjectType.obj_AI_Minion && Player.Distance(target) < GetRealAutoAttackRange(Player))
{
if (target.Health > unit.GetAutoAttackDamage(target) + Player.GetAutoAttackDamage(target, true)
&& target.Health < unit.GetAutoAttackDamage(target) + Player.GetAutoAttackDamage(target, true) * 2)
{
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
var spellName = Spell.SData.Name;
if (unit.IsMe && IsAutoAttackReset(spellName) && Spell.SData.SpellCastTime == 0)
{
ResetAutoAttackTimer();
}
if (!IsAutoAttack(spellName))
{
return;
}
if (unit.IsMe &&
(Spell.Target is Obj_AI_Base || Spell.Target is Obj_BarracksDampener || Spell.Target is Obj_HQ))
{
LastAATick = Utils.GameTimeTickCount - Game.Ping / 2;
_missileLaunched = false;
LastMoveCommandT = 0;
if (Spell.Target is Obj_AI_Base)
{
var target = (Obj_AI_Base)Spell.Target;
if (target.IsValid)
{
FireOnTargetSwitch(target);
_lastTarget = target;
}
}
}
FireOnAttack(unit, _lastTarget);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe) return;
double ShouldUseOn = ShouldUse(args.SData.Name);
if (sender.Team != ObjectManager.Player.Team && ShouldUseOn >= 0f && sender.IsValidTarget(Q.Range))
{
if (MiscMenu["Interrupter"].Cast<CheckBox>().CurrentValue && W.IsReady() && _Player.Distance(sender) <= W.Range)
{
if(W.MinimumHitChance >= HitChance.High)
{
W.Cast(sender);
}
}
}
if (ComboMenu["SafeR"].Cast<CheckBox>().CurrentValue && R.IsReady())
{
if (_Player.HealthPercent <= ComboMenu["SafeRHP"].Cast<Slider>().CurrentValue)
{
if (sender.IsEnemy && args.Target.IsMe)
{
if (_Player.CountEnemiesInRange(1300) > 1)
{
if (_Player.CountAlliesInRange(1300) >= 1 + 1)
{
R.Cast();
return;
}
if (_Player.CountAlliesInRange(1300) == 0 + 1)
{
if (sender.GetAutoAttackDamage(_Player) >= _Player.Health)
{
R.Cast();
return;
}
}
}
else if (sender.GetAutoAttackDamage(_Player) >= _Player.Health)
{
R.Cast();
return;
}
}
}
}
if (Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Harass)
{
if (HarassMenu["QHarass"].Cast<CheckBox>().CurrentValue && sender.IsEnemy && args.Target.IsMe && Q.IsReady() && _Player.Distance(sender) <= Q.Range)
{
if(Q.MinimumHitChance >= HitChance.High)
{
Q.Cast(sender);
}
}
Harass();
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
#region Hero Detection
if (sender.IsEnemy && sender.Type == GameObjectType.obj_AI_Hero)
{
Casted = Utils.GameTimeTickCount;
foreach (var hero in Activator.Allies())
{
if (!hero.Player.IsValidTarget(float.MaxValue, false) || hero.Player.IsZombie || hero.Immunity)
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Clear();
continue;
}
#region auto attack dectection
if (args.SData.IsAutoAttack())
{
if (args.Target.NetworkId != hero.Player.NetworkId)
continue;
// delay a little bit before missile endtime
Utility.DelayAction.Add(250, () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.AutoAttack);
hero.IncomeDamage += (float) Math.Abs(sender.GetAutoAttackDamage(hero.Player));
// lazy reset
Utility.DelayAction.Add(550, delegate
{
hero.Attacker = null;
hero.HitTypes.Remove(HitType.AutoAttack);
hero.IncomeDamage = 0;
});
});
}
#endregion
foreach (var data in spelldata.spells.Where(x => x.SDataName == args.SData.Name.ToLower()))
{
#region self/selfaoe spell detection
if (args.SData.TargettingType == SpellDataTargetType.Self ||
args.SData.TargettingType == SpellDataTargetType.SelfAoe)
{
var fromObj =
ObjectManager.Get<GameObject>()
.FirstOrDefault(
x => data.FromObject != null && data.FromObject.Any(y => x.Name.Contains(y)));
var correctpos = fromObj != null ? fromObj.Position : sender.ServerPosition;
if (hero.Player.Distance(correctpos) > data.CastRange)
continue;
if (data.SDataName == "kalistaexpungewrapper" &&
!hero.Player.HasBuff("kalistaexpungemarker", true))
continue;
var evadetime = 1000 * (data.CastRange - hero.Player.Distance(correctpos) +
hero.Player.BoundingRadius) / hero.Player.MoveSpeed;
if (Activator.Origin.Item("evade").GetValue<bool>())
{
// ignore if can evade
if (hero.Player.NetworkId == Activator.Player.NetworkId)
{
if (hero.Player.CanMove && evadetime < data.Delay)
{
// check next player
continue;
}
}
}
// delay the spell a bit before missile endtime
Utility.DelayAction.Add((int) (data.Delay - (data.Delay * 0.3)), () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage +=
(float) Math.Abs(sender.GetSpellDamage(hero.Player, args.SData.Name));
foreach (var type in data.HitType)
hero.HitTypes.Add(type);
// lazy safe reset
Utility.DelayAction.Add((int) (data.Delay + 300), () =>
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Clear();
});
});
}
#endregion
#region skillshot detection completerino
if (args.SData.TargettingType == SpellDataTargetType.Cone ||
args.SData.TargettingType.ToString().Contains("Location"))
{
var fromObj =
ObjectManager.Get<GameObject>()
.FirstOrDefault(
x => data.FromObject != null && data.FromObject.Any(y => x.Name.Contains(y)));
// correct datas
var islineskillshot = args.SData.LineWidth != 0;
var correctpos = fromObj != null ? fromObj.Position : sender.ServerPosition;
var correctwidth = !islineskillshot ? args.SData.CastRadius : args.SData.LineWidth;
if (hero.Player.Distance(correctpos) > data.CastRange)
continue;
var distance = (int)(1000 * (correctpos.Distance(hero.Player.ServerPosition) / data.MissileSpeed));
var endtime = data.Delay - 100 + Game.Ping/2 + distance - (Utils.GameTimeTickCount - Casted);
// get the real end position normalized
var direction = (args.End.To2D() - correctpos.To2D()).Normalized();
var endpos = correctpos.To2D() + direction * data.CastRange;
// setup projection
var proj = hero.Player.ServerPosition.To2D().ProjectOn(correctpos.To2D(), endpos);
var projdist = hero.Player.ServerPosition.To2D().Distance(proj.SegmentPoint);
// get the evade time
int evadetime;
if (islineskillshot)
{
evadetime =
(int)
(1000 * (correctwidth - projdist + hero.Player.BoundingRadius) /
hero.Player.MoveSpeed);
}
else
{
evadetime =
(int)
(1000 *
(correctwidth - hero.Player.Distance(correctpos) + hero.Player.BoundingRadius) /
hero.Player.MoveSpeed);
}
if (!islineskillshot && hero.Player.Distance(args.End) <= correctwidth ||
islineskillshot && correctwidth + hero.Player.BoundingRadius > projdist)
{
if (data.Global || Activator.Origin.Item("evade").GetValue<bool>())
{
// ignore if can evade
if (hero.Player.NetworkId == Activator.Player.NetworkId)
{
if (hero.Player.CanMove && evadetime < endtime)
{
// check next player
continue;
}
}
}
// vayne invis check
if (data.SDataName == "vaynetumble" && sender.HasBuff("VayneInquisition", true))
hero.HitTypes.Add(HitType.Stealth);
// delay the action a little bit before endtime
Utility.DelayAction.Add((int) (endtime - (endtime * 0.3)), () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage +=
(float) Math.Abs(sender.GetSpellDamage(hero.Player, args.SData.Name));
foreach (var type in data.HitType)
hero.HitTypes.Add(type);
// lazy safe reset
Utility.DelayAction.Add((int) (endtime + 300), () =>
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Clear();
});
});
}
}
#endregion
#region unit type detection
if (args.SData.TargettingType == SpellDataTargetType.Unit ||
args.SData.TargettingType == SpellDataTargetType.SelfAndUnit)
{
// check if is targeteting the hero on our table
if (hero.Player.NetworkId != args.Target.NetworkId)
continue;
// target spell dectection
if (hero.Player.Distance(sender.ServerPosition) > data.CastRange)
continue;
var distance = (int) (1000 * (sender.Distance(hero.Player.ServerPosition) / data.MissileSpeed));
var endtime = data.Delay - 100 + Game.Ping / 2 + distance - (Utils.GameTimeTickCount - Casted);
Utility.DelayAction.Add((int) (endtime - (endtime * 0.3)), () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage +=
(float) Math.Abs(sender.GetSpellDamage(hero.Player, args.SData.Name));
foreach (var type in data.HitType)
hero.HitTypes.Add(type);
// lazy reset
Utility.DelayAction.Add((int) (endtime + 300), () =>
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Clear();
});
});
}
#endregion
}
}
}
#endregion
#region Turret Detection
if (sender.IsEnemy && sender.Type == GameObjectType.obj_AI_Turret)
{
foreach (var hero in Activator.Allies())
{
if (args.Target.NetworkId != hero.Player.NetworkId)
continue;
if (hero.Immunity)
continue;
if (sender.Distance(hero.Player.ServerPosition) <= 900 &&
Activator.Player.Distance(hero.Player.ServerPosition) <= 1000)
{
Utility.DelayAction.Add(500, () =>
{
hero.HitTypes.Add(HitType.TurretAttack);
hero.IncomeDamage =
(float) Math.Abs(sender.CalcDamage(hero.Player, Damage.DamageType.Physical,
sender.BaseAttackDamage + sender.FlatPhysicalDamageMod));
// lazy reset
Utility.DelayAction.Add(800, () =>
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Remove(HitType.TurretAttack);
});
});
}
}
}
#endregion
#region Minion Detection
if (sender.IsEnemy && sender.Type == GameObjectType.obj_AI_Minion)
{
foreach (var hero in Activator.Allies())
{
if (hero.Player.NetworkId != args.Target.NetworkId)
continue;
if (hero.Immunity)
continue;
if (hero.Player.Distance(sender.ServerPosition) <= 750 &&
Activator.Player.Distance(hero.Player.ServerPosition) <= 1000)
{
hero.HitTypes.Add(HitType.MinionAttack);
hero.MinionDamage =
(float) Math.Abs(sender.CalcDamage(hero.Player, Damage.DamageType.Physical,
sender.BaseAttackDamage + sender.FlatPhysicalDamageMod));
// lazy reset
Utility.DelayAction.Add(500, () =>
{
hero.HitTypes.Remove(HitType.MinionAttack);
hero.MinionDamage = 0;
});
}
}
}
#endregion
}
public DamageMaker(Obj_AI_Base sourceIn, Obj_AI_Base targetIn, GameObject missleIn, SpellData dataIn,
bool meleeIn = false)
{
Source = sourceIn;
Target = targetIn;
Missle = missleIn;
SData = dataIn;
Melee = !meleeIn;
CreatedTick = Now;
IsAutoAtack = SData.IsAutoAttack();
if (IsAutoAtack)
{
DealDamage = (float) Source.GetAutoAttackDamage(Target, true);
if (Source.IsMelee)
Cycle = (int) (Source.AttackDelay*1000);
else
{
//var dist = source.Distance(target);
Cycle = (int) ((Source.AttackDelay*1000)) /*+ (dist*1000)/sData.MissileSpeed)*/;
//Console.WriteLine("cycle: " + cycle);
}
//Console.WriteLine("cycle: " + source.AttackSpeedMod);
}
else
{
Cycle = 0;
var client = Source as AIHeroClient;
if (client != null)
{
var tSpell = TargetSpellDatabase.GetByName(SData.Name);
if (tSpell == null)
{
//Console.WriteLine("Unknown targeted spell: " + sData.Name);
DealDamage = 0;
}
else
{
try
{
DealDamage = (float) client.GetSpellDamage(Target, tSpell.Spellslot);
}
catch (Exception)
{
DealDamage = 0;
}
}
}
else
{
DealDamage = 0;
}
}
}
private void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (sender.IsMe)
{
if (args.SData.Name == "KalistaExpungeWrapper")
{
Orbwalking.ResetAutoAttackTimer();
}
}
if (!sender.IsEnemy || SoulBound.Unit == null || R.Level == 0 ||
!Menu.Item(Menu.Name + ".ultimate.save").GetValue<bool>())
{
return;
}
if (args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId &&
(!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()))
{
SoulBound.Add(
SoulBound.Unit.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed +
Game.Time, (float) sender.GetAutoAttackDamage(SoulBound.Unit));
}
else
{
var hero = sender as Obj_AI_Hero;
if (hero != null)
{
var slot = hero.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
var damage = 0f;
if (args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId &&
slot == hero.GetSpellSlot("SummonerDot"))
{
damage =
(float) hero.GetSummonerSpellDamage(SoulBound.Unit, Damage.SummonerSpell.Ignite);
}
else if ((slot == SpellSlot.Q || slot == SpellSlot.W || slot == SpellSlot.E ||
slot == SpellSlot.R) &&
((args.Target != null && args.Target.NetworkId == SoulBound.Unit.NetworkId) ||
args.End.Distance(SoulBound.Unit.ServerPosition) <
Math.Pow(args.SData.LineWidth, 2)))
{
damage = (float) hero.GetSpellDamage(SoulBound.Unit, slot);
}
if (damage > 0)
{
SoulBound.Add(Game.Time + 2, damage);
}
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
public DamageMaker(Obj_AI_Base sourceIn, Obj_AI_Base targetIn, GameObject missleIn, SpellData dataIn, bool meleeIn = false)
{
source = sourceIn;
target = targetIn;
missle = missleIn;
sData = dataIn;
melee = !meleeIn;
createdTick = now;
isAutoAtack = sData.IsAutoAttack();
if (isAutoAtack)
{
dealDamage = (float) source.GetAutoAttackDamage(target, true);
if (source.IsMelee)
cycle = (int) (source.AttackDelay*1000);
else
{
//var dist = source.Distance(target);
cycle = (int)((source.AttackDelay * 1000)) /*+ (dist*1000)/sData.MissileSpeed)*/;
//Console.WriteLine("cycle: " + cycle);
}
//Console.WriteLine("cycle: " + source.AttackSpeedMod);
}
else
{
cycle = 0;
if (source is Obj_AI_Hero)
{
var tSpell = TargetSpellDatabase.GetByName(sData.Name);
if (tSpell == null)
{
//Console.WriteLine("Unknown targeted spell: " + sData.Name);
dealDamage = 0;
}
else
{
try
{
dealDamage = (float)((Obj_AI_Hero)source).GetSpellDamage(target, tSpell.Spellslot);
}
catch (Exception)
{
dealDamage = 0;
}
}
}
else
{
dealDamage = 0;
}
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if (((args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId)) && sender is AIHeroClient && dangerousSpell(args.SData, (AIHeroClient)sender))
{
var slot = ((AIHeroClient)sender).GetSpellSlotFromName(args.SData.Name);
//TODO TEST!
if (Player.Instance.ServerPosition.Distance(sender.ServerPosition) < 2500)
{
bool shielded = false;
if (Settings.useSpellshields && Program.Shield != null && Program.Shield.IsReady())
{
switch (Player.Instance.ChampionName)
{
case "Fiora":
var target = TargetSelector.GetTarget(Program.Shield.Range, DamageType.Physical);
if (target != null)
{
Program.Shield.Cast(target);
}
else
{
Program.Shield.Cast(Player.Instance);
}
shielded = true;
break;
case "Sivir":
Program.Shield.Cast(Player.Instance);
shielded = true;
break;
default:
break;
}
}
if (!shielded && !castZhonyas())
castSeraphs();
}
}
if ((!(sender is AIHeroClient) || args.SData.IsAutoAttack()) && args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId)
{
IncDamage[Player.Instance.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed + Game.Time] = sender.GetAutoAttackDamage(Player.Instance);
}
else
{
var attacker = sender as AIHeroClient;
if (attacker != null)
{
var slot = attacker.GetSpellSlotFromName(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlotFromName("SummonerDot") && args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId)
{
InstDamage[Game.Time + 2] = attacker.GetSummonerSpellDamage(Player.Instance, DamageLibrary.SummonerSpells.Ignite);
}
else
{
switch (slot)
{
case SpellSlot.Q:
case SpellSlot.W:
case SpellSlot.E:
case SpellSlot.R:
if ((args.Target != null && args.Target.NetworkId == Player.Instance.NetworkId))
{
// Instant damage to target
InstDamage[Game.Time + 2] = attacker.GetSpellDamage(Player.Instance, slot);
}
break;
}
}
}
}
}
}
}
private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!Enabled)
{
return;
}
try
{
if (args.Target != null && args.Target.IsEnemy)
{
var target = args.Target as Obj_AI_Hero;
if (target != null)
{
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()))
{
Damages.Add(
target.NetworkId,
target.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed +
Game.Time, (float) sender.GetAutoAttackDamage(target));
}
else
{
var slot = target.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown && slot == target.GetSpellSlot("SummonerDot"))
{
Damages.Add(
target.NetworkId, Game.Time + 2,
(float) target.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite));
}
}
}
}
var hero = sender as Obj_AI_Hero;
if (hero != null && hero.IsAlly)
{
var slot = hero.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == SpellSlot.Q || slot == SpellSlot.W || slot == SpellSlot.E || slot == SpellSlot.R)
{
if (args.Target != null && args.Target.IsEnemy)
{
Damages.Add(
args.Target.NetworkId, Game.Time + 1,
(float) hero.GetSpellDamage(args.Target as Obj_AI_Hero, slot));
}
else if (args.Target == null)
{
foreach (var enemy in
GameObjects.EnemyHeroes.Where(
e => e.IsValidTarget() && e.Distance(args.Start) < 300))
{
var length = (int) (args.Start.Distance(args.End));
for (int i = 0, l = length > 300 ? 300 : length; i < l; i = i + 50)
{
var pos = args.Start.Extend(args.End, i);
if (enemy.Distance(pos) <= 50)
{
Damages.Add(
enemy.NetworkId, Game.Time + 1, (float) hero.GetSpellDamage(enemy, slot));
break;
}
}
}
}
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
#region Hero Detection
if (sender.IsEnemy && sender.Type == GameObjectType.obj_AI_Hero)
{
Casted = Utils.GameTimeTickCount;
foreach (var hero in Activator.Allies())
{
if (!hero.Player.IsValidTarget(float.MaxValue, false) || hero.Player.IsZombie || hero.Immunity)
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Clear();
continue;
}
if (hero.IncomeDamage < 12)
hero.IncomeDamage = 0;
#region auto attack dectection
if (args.SData.IsAutoAttack())
{
if (args.Target.NetworkId == hero.Player.NetworkId)
{
float dmg = 0;
var enemy = sender as Obj_AI_Hero;
if (!sender.HasBuff("lichbane") && !sender.HasBuff("sheen"))
dmg = (int) Math.Abs(sender.GetAutoAttackDamage(hero.Player, true));
if (sender.HasBuff("sheen"))
dmg = (int) Math.Abs(sender.GetAutoAttackDamage(hero.Player, true) +
enemy.GetCustomDamage("sheen", hero.Player));
if (sender.HasBuff("lichbane"))
dmg = (int) Math.Abs(sender.GetAutoAttackDamage(hero.Player, true) +
enemy.GetCustomDamage("lichbane", hero.Player));
Utility.DelayAction.Add(250, () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.AutoAttack);
hero.IncomeDamage += dmg;
Utility.DelayAction.Add(800, delegate
{
hero.Attacker = null;
hero.IncomeDamage -= dmg;
hero.HitTypes.Remove(HitType.AutoAttack);
});
});
}
}
#endregion
foreach (var data in spelldata.spells.Where(x => x.SDataName == args.SData.Name.ToLower()))
{
#region self/selfaoe spell detection
if (args.SData.TargettingType == SpellDataTargetType.Self ||
args.SData.TargettingType == SpellDataTargetType.SelfAoe)
{
var fromObj =
ObjectManager.Get<GameObject>()
.FirstOrDefault(
x => data.FromObject != null && data.FromObject.Any(y => x.Name.Contains(y)));
var correctpos = fromObj != null ? fromObj.Position : sender.ServerPosition;
if (hero.Player.Distance(correctpos) > data.CastRange)
continue;
if (data.SDataName == "kalistaexpungewrapper" &&
!hero.Player.HasBuff("kalistaexpungemarker", true))
continue;
var evadetime = 1000 * (data.CastRange - hero.Player.Distance(correctpos) +
hero.Player.BoundingRadius) / hero.Player.MoveSpeed;
if (Activator.Origin.Item("evade").GetValue<bool>())
{
// ignore if can evade
if (hero.Player.NetworkId == Activator.Player.NetworkId)
{
if (hero.Player.IsMoving && evadetime < data.Delay)
{
// check next player
continue;
}
}
}
if (!Activator.Origin.Item(data.SDataName + "predict").GetValue<bool>())
return;
var dmg = (int) Math.Abs(sender.GetSpellDamage(hero.Player, args.SData.Name));
// delay the spell a bit before missile endtime
Utility.DelayAction.Add((int) (data.Delay - (data.Delay * 0.7)), () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage += dmg;
if (Activator.Origin.Item(data.SDataName + "danger").GetValue<bool>())
hero.HitTypes.Add(HitType.Danger);
if (Activator.Origin.Item(data.SDataName + "crowdcontrol").GetValue<bool>())
hero.HitTypes.Add(HitType.CrowdControl);
if (Activator.Origin.Item(data.SDataName + "ultimate").GetValue<bool>())
hero.HitTypes.Add(HitType.Ultimate);
if (Activator.Origin.Item(data.SDataName + "forceexhaust").GetValue<bool>())
hero.HitTypes.Add(HitType.ForceExhaust);
// lazy safe reset
Utility.DelayAction.Add((int) (data.Delay + 500), () =>
{
hero.Attacker = null;
hero.IncomeDamage -= dmg;
hero.HitTypes.Remove(HitType.Spell);
if (Activator.Origin.Item(data.SDataName + "danger").GetValue<bool>())
hero.HitTypes.Remove(HitType.Danger);
if (Activator.Origin.Item(data.SDataName + "crowdcontrol").GetValue<bool>())
hero.HitTypes.Remove(HitType.CrowdControl);
if (Activator.Origin.Item(data.SDataName + "ultimate").GetValue<bool>())
hero.HitTypes.Remove(HitType.Ultimate);
if (Activator.Origin.Item(data.SDataName + "forceexhaust").GetValue<bool>())
hero.HitTypes.Remove(HitType.ForceExhaust);
});
});
}
#endregion
#region skillshot detection completerino
if (args.SData.TargettingType == SpellDataTargetType.Cone ||
args.SData.TargettingType.ToString().Contains("Location") ||
args.SData.TargettingType == (SpellDataTargetType) 10 && data.SDataName == "azirq")
{
var fromObj =
ObjectManager.Get<GameObject>()
.FirstOrDefault(
x =>
!x.IsAlly && data.FromObject != null &&
data.FromObject.Any(y => x.Name.Contains(y)));
var islineskillshot = args.SData.LineWidth != 0;
var startpos = fromObj != null ? fromObj.Position : sender.ServerPosition;
var correctwidth = !islineskillshot ? data.CastRange : args.SData.LineWidth;
if (data.SDataName == "azirq")
{
correctwidth = 275f;
islineskillshot = true;
}
if (hero.Player.Distance(startpos) > data.CastRange)
continue;
var distance = (int)(1000 * (startpos.Distance(hero.Player.ServerPosition) / data.MissileSpeed));
var endtime = data.Delay - 100 + Game.Ping/2 + distance - (Utils.GameTimeTickCount - Casted);
var direction = (args.End.To2D() - startpos.To2D()).Normalized();
var endpos = startpos.To2D() + direction * data.CastRange;
var proj = hero.Player.ServerPosition.To2D().ProjectOn(startpos.To2D(), endpos);
var projdist = hero.Player.ServerPosition.To2D().Distance(proj.SegmentPoint);
int evadetime;
if (islineskillshot)
{
evadetime =
(int)
(1000 * (correctwidth - projdist + hero.Player.BoundingRadius) /
hero.Player.MoveSpeed);
}
else
{
evadetime =
(int)
(1000 *
(correctwidth - hero.Player.Distance(startpos) + hero.Player.BoundingRadius) /
hero.Player.MoveSpeed);
}
if (!islineskillshot && hero.Player.Distance(endpos) <= correctwidth ||
islineskillshot && correctwidth + hero.Player.BoundingRadius > projdist)
{
if (data.Global || Activator.Origin.Item("evade").GetValue<bool>())
{
if (hero.Player.NetworkId == Activator.Player.NetworkId)
{
if (hero.Player.IsMoving && evadetime < endtime)
{
continue;
}
}
}
// vayne invis check
if (data.SDataName == "vaynetumble" && sender.HasBuff("VayneInquisition", true))
hero.HitTypes.Add(HitType.Stealth);
if (!Activator.Origin.Item(data.SDataName + "predict").GetValue<bool>())
return;
var dmg = (int) Math.Abs(sender.GetSpellDamage(hero.Player, args.SData.Name));
Utility.DelayAction.Add((int) (endtime - (endtime * 0.7)), () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage += dmg;
if (Activator.Origin.Item(data.SDataName + "danger").GetValue<bool>())
hero.HitTypes.Add(HitType.Danger);
if (Activator.Origin.Item(data.SDataName + "crowdcontrol").GetValue<bool>())
hero.HitTypes.Add(HitType.CrowdControl);
if (Activator.Origin.Item(data.SDataName + "ultimate").GetValue<bool>())
hero.HitTypes.Add(HitType.Ultimate);
if (Activator.Origin.Item(data.SDataName + "forceexhaust").GetValue<bool>())
hero.HitTypes.Add(HitType.ForceExhaust);
Utility.DelayAction.Add((int) (endtime + 500), () =>
{
hero.Attacker = null;
hero.IncomeDamage -= dmg;
hero.HitTypes.Remove(HitType.Spell);
if (Activator.Origin.Item(data.SDataName + "danger").GetValue<bool>())
hero.HitTypes.Remove(HitType.Danger);
if (Activator.Origin.Item(data.SDataName + "crowdcontrol").GetValue<bool>())
hero.HitTypes.Remove(HitType.CrowdControl);
if (Activator.Origin.Item(data.SDataName + "ultimate").GetValue<bool>())
hero.HitTypes.Remove(HitType.Ultimate);
if (Activator.Origin.Item(data.SDataName + "forceexhaust").GetValue<bool>())
hero.HitTypes.Remove(HitType.ForceExhaust);
});
});
}
}
#endregion
#region unit type detection
if (args.SData.TargettingType == SpellDataTargetType.Unit ||
args.SData.TargettingType == SpellDataTargetType.SelfAndUnit)
{
// check if is targeteting the hero on our table
if (hero.Player.NetworkId != args.Target.NetworkId)
continue;
// target spell dectection
if (hero.Player.Distance(sender.ServerPosition) > data.CastRange)
continue;
var distance = (int) (1000 * (sender.Distance(hero.Player.ServerPosition) / data.MissileSpeed));
var endtime = data.Delay - 100 + Game.Ping / 2 + distance - (Utils.GameTimeTickCount - Casted);
if (!Activator.Origin.Item(data.SDataName + "predict").GetValue<bool>())
return;
var dmg = (int) Math.Abs(sender.GetSpellDamage(hero.Player, args.SData.Name));
Utility.DelayAction.Add((int) (endtime - (endtime * 0.7)), () =>
{
hero.Attacker = sender;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage += dmg;
//if (data.ChampionName == "annie" && spelldebuffhandler.Pyromania)
//{
// hero.HitTypes.Add(HitType.CrowdControl);
// spelldebuffhandler.Pyromania = false;
//}
if (Activator.Origin.Item(data.SDataName + "danger").GetValue<bool>())
hero.HitTypes.Add(HitType.Danger);
if (Activator.Origin.Item(data.SDataName + "crowdcontrol").GetValue<bool>())
hero.HitTypes.Add(HitType.CrowdControl);
if (Activator.Origin.Item(data.SDataName + "ultimate").GetValue<bool>())
hero.HitTypes.Add(HitType.Ultimate);
if (Activator.Origin.Item(data.SDataName + "forceexhaust").GetValue<bool>())
hero.HitTypes.Add(HitType.ForceExhaust);
// lazy reset
Utility.DelayAction.Add((int) (endtime + 500), () =>
{
hero.Attacker = null;
hero.IncomeDamage -= dmg;
hero.HitTypes.Remove(HitType.Spell);
if (Activator.Origin.Item(data.SDataName + "danger").GetValue<bool>())
hero.HitTypes.Remove(HitType.Danger);
if (Activator.Origin.Item(data.SDataName + "crowdcontrol").GetValue<bool>())
hero.HitTypes.Remove(HitType.CrowdControl);
if (Activator.Origin.Item(data.SDataName + "ultimate").GetValue<bool>())
hero.HitTypes.Remove(HitType.Ultimate);
if (Activator.Origin.Item(data.SDataName + "forceexhaust").GetValue<bool>())
hero.HitTypes.Remove(HitType.ForceExhaust);
});
});
}
#endregion
}
}
}
#endregion
#region Turret Detection
if (sender.IsEnemy && sender.Type == GameObjectType.obj_AI_Turret)
{
foreach (var hero in Activator.Allies())
{
if (args.Target.NetworkId == hero.Player.NetworkId && !hero.Immunity)
{
var dmg = (int) Math.Abs(sender.CalcDamage(hero.Player, Damage.DamageType.Physical,
sender.BaseAttackDamage + sender.FlatPhysicalDamageMod));
if (sender.Distance(hero.Player.ServerPosition) <= 900)
{
if (Activator.Player.Distance(hero.Player.ServerPosition) <= 1000)
{
Utility.DelayAction.Add(450, () =>
{
hero.HitTypes.Add(HitType.TurretAttack);
hero.IncomeDamage += dmg;
Utility.DelayAction.Add(650, () =>
{
hero.Attacker = null;
hero.IncomeDamage -= dmg;
hero.HitTypes.Remove(HitType.TurretAttack);
});
});
}
}
}
}
}
#endregion
#region Minion Detection
if (sender.IsEnemy && sender.Type == GameObjectType.obj_AI_Minion)
{
foreach (var hero in Activator.Allies())
{
if (hero.Player.NetworkId != args.Target.NetworkId || hero.Immunity)
continue;
if (hero.Player.Distance(sender.ServerPosition) <= 750)
{
if (Activator.Player.Distance(hero.Player.ServerPosition) <= 1000)
{
hero.HitTypes.Add(HitType.MinionAttack);
hero.MinionDamage =
(int) Math.Abs(sender.CalcDamage(hero.Player, Damage.DamageType.Physical,
sender.BaseAttackDamage + sender.FlatPhysicalDamageMod));
Utility.DelayAction.Add(500, () =>
{
hero.HitTypes.Remove(HitType.MinionAttack);
hero.MinionDamage = 0;
});
}
}
}
}
#endregion
#region Gangplank Barell
if (sender.IsEnemy)
{
var enemy = sender as Obj_AI_Hero;
if (enemy.IsValid<Obj_AI_Hero>() && enemy.ChampionName == "Gangplank")
{
foreach (var hero in Activator.Allies())
{
foreach (var b in ObjectManager.Get<GameObject>()
.Where(x => x.Name.Contains("E_AoE") && x.Position.Distance(x.Position) <= 400 && !x.IsAlly)
.OrderBy(y => y.Position.Distance(hero.Player.ServerPosition)))
{
if (hero.Player.Distance(b.Position) > 400 || args.Target.Name != "Barrel")
{
continue;
}
var dmg = (int)Math.Abs(enemy.GetAutoAttackDamage(hero.Player, true) * 1.6 + 200);
if (args.SData.Name.ToLower() == "gangplankcritattack")
{
dmg = dmg * 2;
}
if (!hero.Player.IsValidTarget(float.MaxValue, false) || hero.Player.IsZombie || hero.Immunity)
{
hero.Attacker = null;
hero.IncomeDamage = 0;
hero.HitTypes.Clear();
continue;
}
if (hero.IncomeDamage < 12)
hero.IncomeDamage = 0;
Utility.DelayAction.Add(250, () =>
{
hero.Attacker = enemy;
hero.HitTypes.Add(HitType.Spell);
hero.IncomeDamage += dmg;
Utility.DelayAction.Add(800, delegate
{
hero.Attacker = null;
hero.HitTypes.Remove(HitType.Spell);
hero.IncomeDamage -= dmg;
});
});
}
}
}
}
#endregion
}
private void Game_ProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!(sender is Obj_AI_Base))
{
return;
}
if (sender.IsMe && args.SData.Name == "MonkeyKingDoubleAttack")
{
justQ = true;
Utility.DelayAction.Add(200, () => justQ = false);
}
if (sender.IsMe && args.SData.Name == "MonkeyKingNimbus")
{
justE = true;
Utility.DelayAction.Add(500, () => justE = false);
}
if (sender.IsMe && args.SData.Name == "MonkeyKingDecoy")
{
justW = true;
Utility.DelayAction.Add(config.Item("wMinTime", true).GetValue<Slider>().Value, () => justW = false);
}
Obj_AI_Hero target = args.Target as Obj_AI_Hero;
if (target != null && target.IsMe)
{
if (sender.IsValid && !sender.IsDead && sender.IsEnemy)
{
if (Orbwalking.IsAutoAttack(args.SData.Name) && DamageTakenLastId != sender.NetworkId)
{
var dmg = (float) sender.GetAutoAttackDamage(target, true);
DamageTaken += dmg;
DamageCount++;
DamageTakenLastId = sender.NetworkId;
}
}
}
}
public static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base unit, GameObjectProcessSpellCastEventArgs args)
{
if (Config.Item("Cassiopeia.AutoSeraphsEmbrace").GetValue<bool>() && SeraphsEmbrace.IsReady() && Player.HealthPercent <= Config.Item("Cassiopeia.AutoSeraphsEmbraceMiniHP").GetValue<Slider>().Value && (unit.IsValid<Obj_AI_Hero>() || unit.IsValid<Obj_AI_Turret>()) && unit.IsEnemy && args.Target.IsMe)
{
SeraphsEmbrace.Cast();
}
if ((unit.IsValid<Obj_AI_Hero>() || unit.IsValid<Obj_AI_Turret>()) && unit.IsEnemy && args.Target.IsMe && Config.Item("Cassiopeia.useZhonyasHourglass").GetValue<bool>() && ZhonyasHourglass.IsReady() && Player.HealthPercent <= Config.Item("Cassiopeia.MinimumHPtoZhonyasHourglass").GetValue<Slider>().Value)
{
if (Player.CountEnemiesInRange(1300) > 1)
{
if (Player.CountAlliesInRange(1300) >= 1 + 1)
{
ZhonyasHourglass.Cast();
return;
}
if (Player.CountAlliesInRange(1300) == 0 + 1)
{
if (unit.GetSpellDamage(Player, args.SData.Name) >= Player.Health || (unit.GetAutoAttackDamage(Player) >= Player.Health && args.SData.IsAutoAttack()))
{
ZhonyasHourglass.Cast();
return;
}
}
}
if (Player.CountEnemiesInRange(1300) == 1)
{
if (unit.GetSpellDamage(Player, args.SData.Name) >= Player.Health || (unit.GetAutoAttackDamage(Player) >= Player.Health && args.SData.IsAutoAttack()))
{
ZhonyasHourglass.Cast();
return;
}
}
}
if ((unit.IsValid<Obj_AI_Hero>() || unit.IsValid<Obj_AI_Turret>()) && unit.IsEnemy && args.Target.IsMe && Config.Item("Cassiopeia.useWoogletsWitchcap").GetValue<bool>() && WoogletsWitchcap.IsReady() && Player.HealthPercent <= Config.Item("Cassiopeia.MinimumHPtoWoogletsWitchcap").GetValue<Slider>().Value)
{
if (Player.CountEnemiesInRange(1300) > 1)
{
if (Player.CountAlliesInRange(1300) >= 1 + 1)
{
WoogletsWitchcap.Cast();
return;
}
if (Player.CountAlliesInRange(1300) == 0 + 1)
{
if (unit.GetSpellDamage(Player, args.SData.Name) >= Player.Health || (unit.GetAutoAttackDamage(Player) >= Player.Health && args.SData.IsAutoAttack()))
{
WoogletsWitchcap.Cast();
return;
}
}
}
if (Player.CountEnemiesInRange(1300) == 1)
{
if (unit.GetSpellDamage(Player, args.SData.Name) >= Player.Health || (unit.GetAutoAttackDamage(Player) >= Player.Health && args.SData.IsAutoAttack()))
{
WoogletsWitchcap.Cast();
return;
}
}
}
double InterruptOn = SpellToInterrupt(args.SData.Name);
if (Config.Item(unit.BaseSkinName + "INT").GetValue<bool>() && Config.Item("Cassiopeia.InterruptSpells").GetValue<bool>() && unit.Team != ObjectManager.Player.Team && InterruptOn >= 0f && unit.IsValidTarget(R.Range))
{
if (R.IsReady() && Player.Mana > RMANA && Player.Distance(unit) < R.Range - 50 && unit.IsFacing(Player))
{
R.CastIfHitchanceEquals(unit, HitChance.High, true);
}
}
if (Config.Item("Cassiopeia.HarassActive").GetValue<KeyBind>().Active || Config.Item("Cassiopeia.HarassActiveT").GetValue<KeyBind>().Active)
{
if (Config.Item("Cassiopeia.AutoQWhenEnemyCastHarass").GetValue<bool>() && Player.ManaPercent >= Config.Item("Cassiopeia.QEnemyAttackMiniManaHarass").GetValue<Slider>().Value && (unit.IsValid<Obj_AI_Hero>() && !unit.IsValid<Obj_AI_Turret>()) && unit.IsEnemy && args.Target.IsMe && Q.IsReady() && Player.Distance(unit) <= Q.Range)
{
Q.CastIfHitchanceEquals(unit, HitChance.High, true);
}
if (Config.Item("Cassiopeia.AutoWWhenEnemyCastHarass").GetValue<bool>() && Player.ManaPercent >= Config.Item("Cassiopeia.WEnemyAttackMiniManaHarass").GetValue<Slider>().Value && (unit.IsValid<Obj_AI_Hero>() && !unit.IsValid<Obj_AI_Turret>()) && unit.IsEnemy && args.Target.IsMe && W.IsReady() && Player.Distance(unit) <= W.Range)
{
W.CastIfHitchanceEquals(unit, HitChance.High, true);
}
}
var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
var useQ = Config.Item("Cassiopeia.UseQCombo").GetValue<bool>();
var useW = Config.Item("Cassiopeia.UseWCombo").GetValue<bool>();
if (unit.NetworkId == target.NetworkId)
{
if (useQ && Q.IsReady() && Player.Mana >= QMANA)
{
if (unit.BaseSkinName.Equals("Katarina", StringComparison.CurrentCultureIgnoreCase) || unit.BaseSkinName.Equals("Talon", StringComparison.CurrentCultureIgnoreCase) || unit.BaseSkinName.Equals("Zed", StringComparison.CurrentCultureIgnoreCase))
{
if (args.Target.IsMe && (args.SData.Name.Contains("KatarinaE") || args.SData.Name.Contains("TalonCutthroat") || args.SData.Name.Contains("zedult")))
{
var delay = (int)(Game.Time - Q.Delay - 0.1f);
if (delay > 0)
{
Utility.DelayAction.Add(delay * 1000, () => Q.Cast(args.End));
lastCastQ = Environment.TickCount;
}
else
{
Q.Cast(args.End);
lastCastQ = Environment.TickCount;
}
}
}
}
if (useW && W.IsReady() && Player.Mana >= WMANA)
{
if (unit.BaseSkinName.Equals("Katarina", StringComparison.CurrentCultureIgnoreCase) || unit.BaseSkinName.Equals("Talon", StringComparison.CurrentCultureIgnoreCase) || unit.BaseSkinName.Equals("Zed", StringComparison.CurrentCultureIgnoreCase))
{
if (args.Target.IsMe && (args.SData.Name.Contains("KatarinaE") || args.SData.Name.Contains("TalonCutthroat") || args.SData.Name.Contains("zedult")))
{
var delay = (int)(Game.Time - W.Delay - 0.1f);
if (delay > 0)
{
Utility.DelayAction.Add(delay * 1000, () => W.Cast(args.End));
lastCastW = Environment.TickCount;
}
else
{
W.Cast(args.End);
lastCastW = Environment.TickCount;
}
}
}
}
}
}
public override void Obj_AI_Base_OnProcessSpellCast(
Obj_AI_Base sender,
GameObjectProcessSpellCastEventArgs args)
{
//attackMinions.Clear();
if (sender == null) return;
if (sender.IsEnemy)
{
if (SoulBound != null && Program.Config.Item("SoulBoundSaver").GetValue<bool>())
{
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null
&& args.Target.NetworkId == SoulBound.NetworkId)
{
incomingDamage.Add(
SoulBound.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed
+ Game.Time,
(float)sender.GetAutoAttackDamage(SoulBound));
}
else if (sender is Obj_AI_Hero)
{
var attacker = (Obj_AI_Hero)sender;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null
&& args.Target.NetworkId == SoulBound.NetworkId)
{
InstantDamage.Add(
Game.Time + 2,
(float)attacker.GetSummonerSpellDamage(SoulBound, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R)
&& ((args.Target != null && args.Target.NetworkId == SoulBound.NetworkId)
|| args.End.Distance(SoulBound.ServerPosition, true)
< Math.Pow(args.SData.LineWidth, 2)))
{
InstantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(SoulBound, slot));
}
}
}
}
}
if (sender.IsMe && args.SData.Name == E.Instance.Name)
{
Utility.DelayAction.Add(250, Marksman.Utils.Orbwalking.ResetAutoAttackTimer);
}
}
private void GetIncomingDamage_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
foreach (var damage in Damages)
{
foreach (IncomingDamage incomingDamage in damage.Value.ToArray())
{
if (incomingDamage.TimeHit < Game.Time)
damage.Value.Remove(incomingDamage);
}
if (sender.NetworkId == damage.Key.NetworkId)
continue;
//if (args.Target.Type == GameObjectType.obj_LampBulb || args.Target.Type == GameObjectType.Unknown)
// //No target, find it later
//{
// try
// {
// double spellDamage = sender.GetSpellDamage((Obj_AI_Base) args.Target, args.SData.Name);
// if (spellDamage != 0.0f)
// Damages[Damages.Last().Key].Add(new IncomingDamage(args.SData.Name, sender, args.Start,
// args.End, spellDamage,
// IncomingDamage.CalcTimeHit(args.TimeCast, sender, damage.Key, args.End)));
// }
// catch (InvalidOperationException)
// {
// //Cannot find spell
// }
// catch (InvalidCastException)
// {
// //TODO Need a workaround to get the spelldamage for args.Target
// return;
// }
//}
if (args.SData.Name.ToLower().Contains("attack") && args.Target.NetworkId == damage.Key.NetworkId)
{
double aaDamage = sender.GetAutoAttackDamage((Obj_AI_Base)args.Target);
if (aaDamage != 0.0f)
if (sender.Type == GameObjectType.obj_AI_Minion)
{
Damages[damage.Key].Add(new IncomingDamage(args.SData.Name, sender, args.Start, args.End,
aaDamage, IncomingDamage.CalcTimeHit(args.TimeCast, sender, damage.Key, args.End),
args.Target, false, true));
}
else if (sender.Type == GameObjectType.obj_AI_Turret)
{
Damages[damage.Key].Add(new IncomingDamage(args.SData.Name, sender, args.Start, args.End,
aaDamage, IncomingDamage.CalcTimeHit(args.TimeCast, sender, damage.Key, args.End),
args.Target, true));
}
else
{
Damages[damage.Key].Add(new IncomingDamage(args.SData.Name, sender, args.Start, args.End,
aaDamage, IncomingDamage.CalcTimeHit(args.TimeCast, sender, damage.Key, args.End),
args.Target));
}
continue;
}
if (sender.Type == GameObjectType.obj_AI_Hero && args.Target.NetworkId == damage.Key.NetworkId)
{
try
{
double spellDamage = sender.GetSpellDamage((Obj_AI_Base)args.Target, args.SData.Name);
if (spellDamage != 0.0f)
Damages[damage.Key].Add(new IncomingDamage(args.SData.Name, sender, args.Start, args.End,
spellDamage, IncomingDamage.CalcTimeHit(args.TimeCast, sender, damage.Key, args.End),
args.Target));
}
catch (InvalidOperationException)
{
//Cannot find spell
}
}
if (sender.Type == GameObjectType.obj_AI_Turret && args.Target.NetworkId == damage.Key.NetworkId)
Damages[damage.Key].Add(new IncomingDamage(args.SData.Name, sender, args.Start, args.End, 300,
IncomingDamage.CalcTimeHit(args.TimeCast, sender, damage.Key, args.End), args.Target, true));
}
}
private static void ObjAiBaseOnOnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsValidTarget(3000, false) || sender.Team != ObjectManager.Player.Team || sender is Obj_AI_Hero
|| !Orbwalking.IsAutoAttack(args.SData.Name) || !(args.Target is Obj_AI_Base))
{
return;
}
var target = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData = new PredictedDamage(
sender,
target,
Utils.GameTimeTickCount - Game.Ping / 2,
sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee() ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target, true));
ActiveAttacks.Add(sender.NetworkId, attackData);
}
void Obj_AI_Hero_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
//Patented by XcxooxL
if (!sender.IsEnemy || !sender.IsValidTarget() || !sender.IsVisible) return;
if (args.Target != null && !args.Target.IsAlly) return;
double damage = 0;
//if it is an Auto Attack !
if (args.SData.IsAutoAttack())
{
var Target = args.Target as Obj_AI_Hero;
if (Target == null)
return; //must be a champion
if (args.SData.Name.ToLower().Contains("crit"))
{
damage += sender.GetAutoAttackDamage(Target) * 2;
//Console.WriteLine("Critical " + damage);
if (sender.InventoryItems.Any(item => item.Id.Equals(3031)))
{
Console.WriteLine("Infinity Edge");
damage += damage * 1.25;
}
//Infinity edge
}
else
{
damage += sender.GetAutoAttackDamage(Target, true);
}
damage += 2; //to be on the safe side
Add(Target, damage, sender.Distance(Target) / args.SData.MissileSpeed + 1 / sender.AttackDelay);
Console.WriteLine(
"Target : " + Target.Name + "Damage : " + damage + " Time To Hit : " +
sender.Distance(Target) / args.SData.MissileSpeed * 1000);
}
else //if its a Spell
{
float delay = 0;
var missileSpeed = args.SData.MissileSpeed;
foreach (var spellInfo in
SpellDatabase.Spells.Where(spellInfo => spellInfo.spellName.Equals(args.SData.Name)))
{
if (spellInfo.spellType.Equals(SpellType.Line))
{
_myPoly = new Geometry.Polygon.Rectangle(
args.Start, args.Start.Extend(args.End, spellInfo.range), spellInfo.radius);
}
else if (spellInfo.spellType.Equals(SpellType.Circular))
{
var pos = sender.Distance(args.End) > spellInfo.range
? sender.Position.Extend(args.End, spellInfo.range)
: args.End;
_myPoly = new Geometry.Polygon.Circle(pos, spellInfo.radius);
}
missileSpeed = spellInfo.projectileSpeed;
delay += spellInfo.spellDelay;
break;
}
//Patented by xcxooxl ALL OF THIS IS MINE ! YOU WANT IT? CREDIT ME!
if (sender is Obj_AI_Hero)
{
var enemy = sender as Obj_AI_Hero;
foreach (var ally in TrackList)
{
var timeToHit = delay + ally.Distance(args.Start) / missileSpeed * 1000 +
args.SData.ChannelDuration + args.SData.DelayTotalTimePercent * -1;
if (args.SData.TargettingType.Equals(SpellDataTargetType.Unit)) //Targeted
{
damage += enemy.GetDamageSpell(args.Target as Obj_AI_Base, args.Slot).CalculatedDamage;
Add(ally, damage, timeToHit);
}
Console.WriteLine(
"Spellname" + args.SData.Name + " Time to hit " + timeToHit + "MissileSpeed " + missileSpeed);
var futurePos = Prediction.GetPrediction(ally, timeToHit / 1000).UnitPosition;
futurePosCircle = new Geometry.Polygon.Circle(futurePos, 125);
if (_myPoly.IsInside(futurePos))
{
damage += enemy.GetDamageSpell(ally, args.Slot).CalculatedDamage;
Add(ally, damage, timeToHit);
}
Utility.DelayAction.Add(
(int) (timeToHit + 1200), () =>
{
futurePosCircle = null;
_myPoly = null;
}); //stop drawing polygons
}
}
}
//Patented by XcxooxL
}
private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (!Enabled)
{
return;
}
var enemy = sender as Obj_AI_Hero;
var turret = sender as Obj_AI_Turret;
foreach (
var hero in GameObjects.Heroes.Where(h => h.IsValid && IncomingDamages.ContainsKey(h.NetworkId)))
{
if (ShouldReset(hero))
{
IncomingDamages[hero.NetworkId] = 0;
continue;
}
if (enemy != null && enemy.IsValid && enemy.IsEnemy && enemy.Distance(hero) <= 2000f)
{
if (args.Target != null && args.Target.NetworkId.Equals(hero.NetworkId))
{
if (args.SData.IsAutoAttack())
{
AddDamage(
hero, (int) (GetTime(sender, hero, args.SData) * 0.3f),
(float) sender.GetAutoAttackDamage(hero, true));
}
else if (args.SData.TargettingType == SpellDataTargetType.Unit ||
args.SData.TargettingType == SpellDataTargetType.SelfAndUnit)
{
AddDamage(
hero, (int) (GetTime(sender, hero, args.SData) * 0.3f),
(float) sender.GetSpellDamage(hero, args.SData.Name));
}
}
if (args.Target == null && Skillshots)
{
var slot = enemy.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown &&
(slot == SpellSlot.Q || slot == SpellSlot.E || slot == SpellSlot.W ||
slot == SpellSlot.R))
{
var width = Math.Min(
750f,
(args.SData.TargettingType == SpellDataTargetType.Cone || args.SData.LineWidth > 0) &&
args.SData.TargettingType != SpellDataTargetType.Cone
? args.SData.LineWidth
: (args.SData.CastRadius <= 0
? args.SData.CastRadiusSecondary
: args.SData.CastRadius));
if (args.End.Distance(hero.ServerPosition) <= Math.Pow(width, 2))
{
AddDamage(
hero, (int) (GetTime(sender, hero, args.SData) * 0.6f),
(float) sender.GetSpellDamage(hero, args.SData.Name));
}
}
}
}
if (turret != null && turret.IsValid && turret.IsEnemy && turret.Distance(hero) <= 1500f)
{
if (args.Target != null && args.Target.NetworkId.Equals(hero.NetworkId))
{
AddDamage(
hero, (int) (GetTime(sender, hero, args.SData) * 0.3f),
(float)
sender.CalcDamage(
hero, Damage.DamageType.Physical,
sender.BaseAttackDamage + sender.FlatPhysicalDamageMod));
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe && args.SData.Name == "KalistaExpungeWrapper")
{
Utility.DelayAction.Add(0x7D, Orbwalking.ResetAutoAttackTimer);
}
if (sender.IsEnemy)
{
if (this.SoulBound == null || !this.GetItemValue<bool>("com.iseries.kalista.misc.saveAlly"))
{
return;
}
if ((!(sender is Obj_AI_Hero) || args.SData.IsAutoAttack()) && args.Target != null
&& args.Target.NetworkId == this.SoulBound.NetworkId)
{
this.incomingDamage.Add(
this.SoulBound.ServerPosition.Distance(sender.ServerPosition) / args.SData.MissileSpeed
+ Game.Time,
(float)sender.GetAutoAttackDamage(this.SoulBound));
}
else
{
var hero = sender as Obj_AI_Hero;
if (hero == null)
{
return;
}
var attacker = hero;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot == SpellSlot.Unknown)
{
return;
}
if (slot == attacker.GetSpellSlot("SummonerDot") && args.Target != null
&& args.Target.NetworkId == this.SoulBound.NetworkId)
{
this.instantDamage.Add(
Game.Time + 2,
(float)attacker.GetSummonerSpellDamage(this.SoulBound, Damage.SummonerSpell.Ignite));
}
else if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R)
&& ((args.Target != null && args.Target.NetworkId == this.SoulBound.NetworkId)
|| args.End.Distance(this.SoulBound.ServerPosition, true)
< Math.Pow(args.SData.LineWidth, 2)))
{
this.instantDamage.Add(
Game.Time + 2,
(float)attacker.GetSpellDamage(this.SoulBound, slot));
}
}
}
}
/// <summary>
/// Fired when the game processes a spell cast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="GameObjectProcessSpellCastEventArgs"/> instance containing the event data.</param>
private static void ObjAiBaseOnOnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsValid || sender.Distance(ObjectManager.Player) > 3000 ||
sender.Team != ObjectManager.Player.Team || sender is AIHeroClient
|| args.SData.IsAutoAttack() || !(args.Target is Obj_AI_Base))
{
return;
}
var target = (Obj_AI_Base)args.Target;
ActiveAttacks.Remove(sender.NetworkId);
var attackData = new PredictedDamage(
sender,
target,
Environment.TickCount - Game.Ping / 2,
sender.AttackCastDelay * 1000,
sender.AttackDelay * 1000 - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target, true));
ActiveAttacks.Add(sender.NetworkId, attackData);
}
