public static double CalculateDamage(
this Obj_AI_Base source,
Obj_AI_Base target,
DamageType damageType,
float amount,
float forceDamageModifier = 0f)
{
var damage = 0d;
switch (damageType)
{
case DamageType.Magical:
damage = source.CalculateDamageOnUnit(target, damageType, amount);
break;
case DamageType.Physical:
damage = source.CalculateDamageOnUnit(target, damageType, amount);
break;
case DamageType.True:
damage = amount;
break;
}
return(Math.Max(damage, 0d));
}
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));
}
public static float GetSoldierDamage(Obj_AI_Base target)
{
var damage = 45f;
float calcdamage;
var AP = Program._Player.FlatMagicDamageMod;
foreach (var soldier in Orbwalker.ValidAzirSoldiers)
{
if (soldier.IsValid && soldier != null)
{
if (Orbwalker.ValidAzirSoldiers.Count == 2)
{
damage += (((Program._Player.Level * 5) + ((60f / 100f) * AP)) * 2);
}
if (Orbwalker.ValidAzirSoldiers.Count == 1)
{
damage += (((Program._Player.Level * 5) + ((60f / 100f) * AP)));
}
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
{
damage = (Program.Menu["mDamageBuffer"].Cast <Slider>().CurrentValue / 100f) * damage;
}
calcdamage = target.CalculateDamageOnUnit(target, DamageType.Magical, damage);
return(calcdamage);
}
private static float GetCalculatedDamage(Obj_AI_Base target, DamageType type, float rawdamage)
{
var damage = 0f;
damage += target.CalculateDamageOnUnit(target, type, rawdamage);
return damage;
}
private static double IsRapeble(Obj_AI_Base victim)
{
double comboDamage = 0d;
if (Q.IsReady())
{
comboDamage += Q.GetSpellDamage(victim) + Player.Instance.CalculateDamageOnUnit(victim, DamageType.Magical, (float)(45 + 35 * Q.Level + 0.5 * player.FlatMagicDamageMod));
}
if (E.IsReady())
{
comboDamage += E.GetSpellDamage(victim);
}
if (hasBuff(victim, "AkaliMota"))
{
comboDamage += Player.Instance.CalculateDamageOnUnit(victim, DamageType.Magical, (float)(45 + 35 * Q.Level + 0.5 * player.FlatMagicDamageMod));
}
//comboDamage += player.GetAutoAttackDamage(victim, true);
comboDamage += player.CalculateDamageOnUnit(victim, DamageType.Magical, (float)CalcPassiveDmg());
comboDamage += player.CalculateDamageOnUnit(victim, DamageType.Magical, (float)CalcItemsDmg(victim));
foreach (var item in player.InventoryItems)
{
if ((int)item.Id == 3128)
{
if (player.Spellbook.CanUseSpell((SpellSlot)item.Slot) == SpellState.Ready)
{
comboDamage *= 1.2;
}
}
}
if (hasBuff(victim, "deathfiregraspspell"))
{
comboDamage *= 1.2;
}
if (ultiCount() > 0)
{
comboDamage += Player.Instance.GetSpellDamage(victim, SpellSlot.Unknown) * (ultiCount() - (int)(victim.Distance(player.Position) / R.Range));
}
if (IgniteSlot != SpellSlot.Unknown && player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
{
comboDamage += ObjectManager.Player.GetSummonerSpellDamage(victim, DamageLibrary.SummonerSpells.Ignite);
}
return(comboDamage);
}
/// <summary>
/// Gets Lux Passive Damage
/// </summary>
/// <param name="target">The Target</param>
/// <returns>The damage that the passive will do.</returns>
private static float LuxPassiveDamage(Obj_AI_Base target)
{
if (target.HasBuff("luxilluminatingfraulein"))
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical, (float)(10 + (8 * Player.Instance.Level) * (Player.Instance.FlatMagicDamageMod * 0.2))));
}
return(0);
}
private static float GetCalculatedDamage(Obj_AI_Base target, DamageType type, float rawdamage)
{
var damage = 0f;
damage += target.CalculateDamageOnUnit(target, type, rawdamage);
return(damage);
}
/// <summary>
/// Gets Lux Passive Damage
/// </summary>
/// <param name="target">The Target</param>
/// <returns>The damage that the passive will do.</returns>
private static float LuxPassiveDamage(Obj_AI_Base target)
{
if (target.HasBuff("luxilluminatingfraulein"))
{
return target.CalculateDamageOnUnit(target, DamageType.Magical, (float)(10 + (8 * Player.Instance.Level) * (Player.Instance.FlatMagicDamageMod * 0.2)));
}
return 0;
}
public static float DmgE(Obj_AI_Base target)
{
if (Player.Instance.HasBuff("cardmasterstackparticle"))
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 55, 80, 105, 130, 155 }[SpellManager.E.Level] +(Player.Instance.TotalMagicalDamage * 0.5f)));
}
return(0);
}
public static float GetKSQDamage(Obj_AI_Base target)
{
var damage = 45f;
float calcdamage;
var AP = Program._Player.FlatMagicDamageMod;
damage += ((Program._Q.Level * 20) + ((50f / 100f) * AP));
calcdamage = target.CalculateDamageOnUnit(target, DamageType.Magical, damage);
return(calcdamage);
}
public static float GetWDamage(this Obj_AI_Base unit)
{
if (!SpellManager.W.IsLearned)
{
return(0);
}
var damage = RawWDamage[SpellManager.W.Level] + Player.Instance.GetTotalAP() * WAPScaling + Player.Instance.MaxMana * WManaScaling;
return(unit.CalculateDamageOnUnit(unit, DamageType.Magical, damage));
}
public static float GetIgniteDamage(Obj_AI_Base target)
{
var damage = 20f;
float calcdamage;
damage += (Program._Player.Level * 20);
calcdamage = target.CalculateDamageOnUnit(target, DamageType.True, damage);
if (Program._Ignite == null || !Program._Ignite.IsReady())
{
calcdamage = 0;
}
return(calcdamage);
}
public float CalculateDamage(Obj_AI_Base source, TrackedRecall recall)
{
if (recall.Caster == null)
{
return(-1f);
}
var rawDamage = this.Damage;
if (source.BaseSkinName.Equals("Jinx"))
{
rawDamage += (0.2f + 0.05f * source.Spellbook.GetSpell(this.Slot).Level) * (recall.Caster.MaxHealth - Program.healthAfterTime(recall, TravelTime(recall.CastPosition(this, source))));
}
return(source.CalculateDamageOnUnit(recall.Caster, DamageType, rawDamage));
}
public static float GetWDamage(this Obj_AI_Base unit, bool all = false)
{
if (!SpellManager.W.IsLearned)
{
return(0);
}
var damage = RawWDamage[SpellManager.W.Level] + Player.Instance.GetTotalAP() * WScaling;
if (all)
{
var secound = damage * WSecoundAndThirdHitMultiplier;
damage = damage + secound * 2;
}
return(unit.CalculateDamageOnUnit(unit, DamageType.Magical, damage));
}
/// <summary>
/// Gets Q + AA Damage Totally Done to Target
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Damage Totally Done to Target</returns>
public static double GetDamage(Obj_AI_Base target)
{
double dmgItem = 0;
if (Item.HasItem(3057) && (Item.CanUseItem(3057) || Player.HasBuff("sheen")) &&
PlayerInstance.BaseAttackDamage > dmgItem)
{
dmgItem = PlayerInstance.GetAutoAttackDamage(target);
}
if (Item.HasItem(3025) && (Item.CanUseItem(3025) || Player.HasBuff("itemfrozenfist")) &&
PlayerInstance.BaseAttackDamage * 1.25 > dmgItem)
{
dmgItem = PlayerInstance.GetAutoAttackDamage(target) * 1.25;
}
return(target.CalculateDamageOnUnit(target, DamageType.Mixed, new float[] { 0, 30, 50, 70, 90, 110 }[Q.Level] +PlayerInstance.FlatPhysicalDamageMod + PlayerInstance.GetBuffCount("NasusQStacks")) + PlayerInstance.GetAutoAttackDamage(target) + dmgItem);
}
public static float GetEDamage(Obj_AI_Base target)
{
var damage = 30f;
float calcdamage;
var AP = Program._Player.FlatMagicDamageMod;
foreach (var soldier in Orbwalker.ValidAzirSoldiers)
{
if (Orbwalker.ValidAzirSoldiers.Count > 0)
{
damage += ((Program._E.Level * 30) + ((60f / 100f) * AP));
}
if (Orbwalker.ValidAzirSoldiers.Count == 0)
{
damage = 0;
}
}
calcdamage = target.CalculateDamageOnUnit(target, DamageType.Magical, damage);
return(calcdamage);
}
public static float DmgE(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 70, 110, 150, 190, 230 }[SpellManager.E.Level] +(Player.Instance.TotalMagicalDamage * 0.4f)));
}
public static float DmgE(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 55, 95, 135, 175, 215 }[SpellManager.E.Level] +(Player.Instance.TotalMagicalDamage * 0.6f)));
}
public static float DmgRedemption(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.True, target.MaxHealth * 0.1f));
}
/// <summary>
/// Calculates the Damage done with Q
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with Q</returns>
private static float QDamage(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 80, 125, 170, 215, 260 }[SpellManager.Q.Level] +(Player.Instance.TotalMagicalDamage * 0.8f)));
}
/// <summary>
/// Calculates the Damage Done with R
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with R</returns>
private static float RDamage(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
(float)
(new[] { 0, 50, 81.25, 112.5 }[SpellManager.R.Level] +(Player.Instance.TotalMagicalDamage * 0.125f))));
}
public static float Q2Damage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Magical, new float[] { 60, 100, 140, 180, 220 }[Elise.Q2.Level - 1] +(0.08f + 0.03f / 100 * Player.Instance.TotalMagicalDamage) * (T.MaxHealth - T.Health)));
}
public static float GetSoldierDamage(Obj_AI_Base target)
{
var damage = 45f;
float calcdamage;
var AP = Program._Player.FlatMagicDamageMod;
foreach (var soldier in Orbwalker.ValidAzirSoldiers)
{
if (soldier.IsValid && soldier != null)
{
if (Orbwalker.ValidAzirSoldiers.Count == 2)
{
damage += (((Program._Player.Level * 5) + ((60f / 100f) * AP)) * 2);
}
if (Orbwalker.ValidAzirSoldiers.Count == 1)
{
damage += (((Program._Player.Level * 5) + ((60f / 100f) * AP)));
}
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
{
damage = (Program.Menu["mDamageBuffer"].Cast<Slider>().CurrentValue/100f)*damage;
}
calcdamage = target.CalculateDamageOnUnit(target, DamageType.Magical, damage);
return calcdamage;
}
public static float GetIgniteDamage(Obj_AI_Base target)
{
var damage = 20f;
float calcdamage;
damage += (Program._Player.Level*20);
calcdamage = target.CalculateDamageOnUnit(target, DamageType.True, damage);
if (Program._Ignite == null || !Program._Ignite.IsReady())
calcdamage = 0;
return calcdamage;
}
public static float GetKSQDamage(Obj_AI_Base target)
{
var damage = 45f;
float calcdamage;
var AP = Program._Player.FlatMagicDamageMod;
damage += ((Program._Q.Level*20) + ((50f/100f)*AP));
calcdamage = target.CalculateDamageOnUnit(target, DamageType.Magical, damage);
return calcdamage;
}
public static float QDamage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Physical, new float[] { 45, 55, 65, 75, 85 }[Draven.Q.Level - 1] / 100 * Player.Instance.BaseAttackDamage + Player.Instance.FlatPhysicalDamageMod));
}
public static float RDamage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Physical, new float[] { 175, 275, 375 }[Draven.R.Level - 1] +1.1f * Player.Instance.FlatPhysicalDamageMod));
}
/// <summary>
/// Calculates the Damage Done with R
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with R</returns>
private static float RDamage(Obj_AI_Base target)
{
return target.CalculateDamageOnUnit(target, DamageType.Magical,
(float) (new[] {0, 50, 81.25, 112.5}[Program.R.Level] + (Player.Instance.TotalMagicalDamage*0.125f)));
}
/// <summary>
/// Calculates the Damage done with E
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with E</returns>
private static float EDamage(Obj_AI_Base target)
{
return target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] {0, 10, 20, 30, 40, 50}[Program.E.Level] + (Player.Instance.TotalMagicalDamage*0.3f));
}
/// <summary>
/// Calculates the Damage done with Q
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with Q</returns>
private static float QDamage(Obj_AI_Base target)
{
return target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] {0, 80, 125, 170, 215, 260}[Program.Q.Level] + (Player.Instance.TotalMagicalDamage*0.8f));
}
public static float DmgIgnite(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.True, 50 + 20 * Player.Instance.Level - (target.HPRegenRate / 5 * 3)));
}
/// <summary>
/// Calculates the Damage done with E
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with E</returns>
private static float EDamage(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 55, 95, 135, 175, 215 }[Program.E.Level] +(Player.Instance.TotalMagicalDamage * 0.6f)));
}
public static float QDamage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Magical, new float[] { 40, 75, 110, 145, 180 }[Elise.Q.Level - 1] +(0.08f + 0.03f / 100 * Player.Instance.TotalMagicalDamage) * T.Health));
}
/// <summary>
/// Gets Q + AA Damage Totally Done to Target
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Damage Totally Done to Target</returns>
public static double GetDamage(Obj_AI_Base target)
{
double dmgItem = 0;
if (Item.HasItem(3057) && (Item.CanUseItem(3057) || Player.HasBuff("sheen"))
&& PlayerInstance.BaseAttackDamage > dmgItem)
{
dmgItem = PlayerInstance.GetAutoAttackDamage(target);
}
if (Item.HasItem(3025) && (Item.CanUseItem(3025) || Player.HasBuff("itemfrozenfist"))
&& PlayerInstance.BaseAttackDamage * 1.25 > dmgItem)
{
dmgItem = PlayerInstance.GetAutoAttackDamage(target) * 1.25;
}
return target.CalculateDamageOnUnit(target, DamageType.Mixed, new float[] { 0, 30, 50, 70, 90, 110 }[Q.Level] + PlayerInstance.FlatPhysicalDamageMod + PlayerInstance.GetBuffCount("NasusQStacks")) + PlayerInstance.GetAutoAttackDamage(target) + dmgItem;
}
public static float WDamage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Magical, new float[] { 75, 125, 175, 225, 275 }[Elise.W.Level - 1] +0.08f * Player.Instance.TotalMagicalDamage));
}
public static float GetQDamage(Obj_AI_Base target)
{
var damage = 45f;
float calcdamage;
var AP = Program._Player.FlatMagicDamageMod;
foreach (var soldier in Orbwalker.ValidAzirSoldiers)
{
if (Orbwalker.ValidAzirSoldiers.Count == 2)
{
damage += ((Program._Q.Level * 20) + ((50f / 100f) * AP) * 2);
}
if (Orbwalker.ValidAzirSoldiers.Count == 1)
{
damage += ((Program._Q.Level * 20) + ((50f / 100f) * AP));
}
if (Orbwalker.ValidAzirSoldiers.Count == 0)
{
damage = 0;
}
}
calcdamage = target.CalculateDamageOnUnit(target, DamageType.Magical, damage);
return calcdamage;
}
public static float EDamage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Physical, new float[] { 70, 105, 140, 175, 210 }[Draven.E.Level - 1] +0.05f * Player.Instance.FlatPhysicalDamageMod));
}
/// <summary>
/// Calculates the Damage done with E
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with E</returns>
private static float EDamage(Obj_AI_Base target)
{
return target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] {0, 55, 95, 135, 175, 215}[Program.E.Level] + (Player.Instance.TotalMagicalDamage*0.6f));
}
public static float PDamage(Obj_AI_Base T)
{
return(T.CalculateDamageOnUnit(T, DamageType.Physical, 0.45f + (Player.Instance.BaseAttackDamage + Player.Instance.FlatPhysicalDamageMod)));
}
private static float EDamage(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 10, 20, 30, 40, 50 }[Program.E.Level] +(Player.Instance.TotalMagicalDamage * 0.3f)));
}
private static float RDamage(Obj_AI_Base target)
{
return(target.CalculateDamageOnUnit(target, DamageType.Magical,
(float)(new[] { 0, 200, 325, 450 }[Program.R.Level] +(Player.Instance.TotalMagicalDamage * 0.125f))));
}
/// <summary>
/// Calculates the Damage done with W
/// </summary>
/// <param name="target">The Target</param>
/// <returns>Returns the Damage done with W</returns>
private static float WDamage(Obj_AI_Base target)
{
return target.CalculateDamageOnUnit(target, DamageType.Magical,
new[] { 0, 120, 170, 220, 270, 320 }[Program.Q.Level] + (Player.Instance.TotalMagicalDamage * 1.0f));
}
