public static double GetItemDamage(this Obj_AI_Hero source, uint itemID, Obj_AI_Hero target)
{
if (!source.HasItem(itemID) || !source.CanUseItem(itemID) ||
source.IsDead || target == null || !target.IsValidTarget())
{
return(0d);
}
switch (itemID)
{
case 3153: //BladeoftheRuinedKing 破败
return(source.CalculateDamage(target, DamageType.Magical, 100));
case 3030: //HextechGLP800 冰冻枪
var GLP800DMG = 100 + source.Level * 5.5 + 0.35 * source.FlatMagicDamageMod + 1;
return(source.CalculateDamage(target, DamageType.Magical, GLP800DMG));
case 3144: //BilgewaterCutlass 比尔沃特吉弯刀
return(source.CalculateDamage(target, DamageType.Magical, 100));
case 3146: //HextechGunblade 科技枪
var HexGunDMG = 175 + source.Level * 4.1 + 0.30 * source.FlatMagicDamageMod + 1;
return(source.CalculateDamage(target, DamageType.Magical, HexGunDMG));
case 3152: //HextechProtobelt01 推推棒
var HexProDMG = 150 + 0.25 * source.FlatMagicDamageMod;
return(source.CalculateDamage(target, DamageType.Magical, HexProDMG));
default:
return(0d);
}
}
private static double Qdmg(Obj_AI_Base enemy)
{
if (Spells.Q.Ready)
{
return(Player.CalculateDamage(enemy, DamageType.Physical, (float)new double[] { 0.5, 0.55, 0.6, 0.65, 0.7 }[Player.SpellBook.GetSpell(SpellSlot.Q).Level] +Player.TotalAttackDamage));
}
return(0);
}
private static double Qdmg(Obj_AI_Base enemy)
{
if (Spells.Q.Ready)
{
var level = Player.SpellBook.GetSpell(SpellSlot.Q).Level;
return(Player.CalculateDamage(enemy, DamageType.Physical, (0.45 + 0.05 * level + Player.TotalAttackDamage)));
}
return(0);
}
public static float RDamage(Obj_AI_Base target)
{
if (target.HasBuff("garenpassiveenemytarget"))
{
return((float)_player.CalculateDamage(target, DamageType.True, Damage.GetSpellDamage(_player, target, SpellSlot.R)));
}
return((float)_player.CalculateDamage(target, DamageType.Magical, Damage.GetSpellDamage(_player, target, SpellSlot.R)));
}
public static float SmiteDamage(Obj_AI_Base target)
{
float damage = new float[]
{
390, 410, 430, 450, 480, 510, 540, 570, 600, 640, 680, 720, 760, 800, 850, 900, 950, 1000
}[_player.Level - 1];
return((float)_player.CalculateDamage(target, DamageType.True, damage));
}
private static double Qdmg(Obj_AI_Base enemy)
{
var level = Player.SpellBook.GetSpell(SpellSlot.Q).Level;
if (Spells.Q.Ready)
{
return(Player.CalculateDamage(enemy, DamageType.Magical, 50 + 30 * level + 0.55 * Player.TotalAbilityDamage));
}
return(0);
}
private static double Edmg(Obj_AI_Base enemy)
{
if (Spells.E.Ready)
{
var level = Player.SpellBook.GetSpell(SpellSlot.E).Level;
var BaseDamage = Player.CalculateDamage(enemy, DamageType.Physical, 5 + 15 * level);
var StackDamage = Player.CalculateDamage(enemy, DamageType.Physical, 10 + 5 * level + 0.25 * (Player.TotalAttackDamage - Player.BaseAttackDamage) + 0.2 * Player.TotalAbilityDamage);
return(BaseDamage + StackDamage * enemy.GetBuffCount("TwitchDeadlyVenom"));
}
return(0);
}
public static double GetUltTickDamage(Obj_AI_Base target)
{
double dmg = 0;
var ultLevel = Player.SpellBook.GetSpell(SpellSlot.R).Level;
dmg = ((100 * ultLevel) + 50) * 3;
dmg += Player.TotalAbilityDamage * 0.6;
dmg = Player.CalculateDamage(target, DamageType.Magical, dmg);
return(dmg);
}
public static int GetCustomDamage(this Obj_AI_Hero source, string auraname, Obj_AI_Hero target)
{
if (auraname == "sheen")
{
return
((int)
source.CalculateDamage(target, DamageType.Physical,
1.0 * source.FlatPhysicalDamageMod + source.BaseAttackDamage));
}
if (auraname == "lichbane")
{
return
((int)
source.CalculateDamage(target, DamageType.Magical,
(0.75 * source.FlatPhysicalDamageMod + source.BaseAttackDamage) +
(0.50 * source.FlatMagicDamageMod)));
}
return(0);
}
private static double Rdmg(Obj_AI_Base enemy)
{
if (Spells.R.Ready)
{
var DamagePerSphere = Player.CalculateDamage(enemy, DamageType.Magical, 45 + 45 * Player.SpellBook.GetSpell(SpellSlot.R).Level);
var Spheres = GameObjects.AllGameObjects.Where(x => x.Name == "Seed" && x.IsValid && !x.IsDead && x.Distance(Player) <= Spells.R.Range).ToList();
foreach (var number in Spheres)
{
;
}
return(DamagePerSphere * 3 + DamagePerSphere * Spheres.Count);
}
return(0);
}
/// <summary>
/// Gets the damage of an Item.
/// </summary>
/// <param name="source"><see cref="Obj_AI_Base" /> where the damage is coming from.</param>
/// <param name="target"><see cref="Obj_AI_Base" /> where the damage is going to.</param>
/// <param name="damageItem">Item</param>
/// <returns>Damage of the item.</returns>
public static double GetItemDamage(this Obj_AI_Hero source, Obj_AI_Base target, DamageItems damageItem)
{
switch (damageItem)
{
case DamageItems.BilgewaterCutlass:
return(source.CalculateDamage(target, DamageType.Magical, 100));
case DamageItems.BlackFireTorch:
return(source.CalculateDamage(target, DamageType.Magical, target.MaxHealth * 0.2));
case DamageItems.BladeOfTheRuinedKing:
return(source.CalculateDamage(target, DamageType.Physical, target.MaxHealth * 0.1));
case DamageItems.FrostQueenClaim:
return(source.CalculateDamage(target, DamageType.Magical, 50 + 5 * source.Level));
case DamageItems.HextechGunblade:
return(source.CalculateDamage(target, DamageType.Magical, 150 + 0.4 * source.FlatMagicDamageMod));
case DamageItems.RavenousHydra:
return(source.CalculateDamage(
target, DamageType.Physical, source.BaseAttackDamage + source.FlatPhysicalDamageMod));
case DamageItems.OdynsVeil:
return(source.CalculateDamage(target, DamageType.Magical, 200));
case DamageItems.Tiamat:
return(source.CalculateDamage(
target, DamageType.Physical, source.BaseAttackDamage + source.FlatPhysicalDamageMod));
case DamageItems.LiandrysTorment:
var d = target.Health * .2f * 3f;
return((target.CanMove || target.HasBuffOfType(BuffType.Slow)) ? d : d * 2);
}
return(0d);
}
static void TotalActiveDamage()
{
bool hasCutlass = Menus._menu["offensive"]["cutlass"].Enabled && _player.HasAndCanUseItem(ItemId.BilgewaterCutlass);
bool hasBotrk = Menus._menu["offensive"]["botrk"].Enabled && _player.HasAndCanUseItem(ItemId.BladeoftheRuinedKing);
bool hasGunblade = Menus._menu["offensive"]["gunblade"].Enabled && _player.HasAndCanUseItem(ItemId.HextechGunblade);
bool hasTiamat = Menus._menu["offensive"]["tiamat"].Enabled && _player.HasAndCanUseItem(ItemId.Tiamat);
bool hasRavenous = Menus._menu["offensive"]["ravenous"].Enabled && _player.HasAndCanUseItem(ItemId.RavenousHydra);
if (hasCutlass || hasBotrk || hasGunblade || hasTiamat || hasRavenous)
{
_target = GameObjects.EnemyHeroes
.OrderBy(a => a.Health)
.Where(a => a.IsLegitimate())
.FirstOrDefault();
}
if (_target != null)
{
if (hasTiamat || hasRavenous)
{
if (_target.IsInRange(250))
{
_totalDamage += (float)_player.CalculateDamage(_target, DamageType.Physical, (_player.TotalAttackDamage));
if (hasTiamat)
{
useTiamat = true;
}
else if (hasRavenous)
{
useRavenous = true;
}
}
else if (_target.IsInRange(400))
{
_totalDamage += (float)_player.CalculateDamage(_target, DamageType.Physical, (_player.TotalAttackDamage * 0.6));
if (hasTiamat)
{
useTiamat = true;
}
else if (hasRavenous)
{
useRavenous = true;
}
}
}
if (_target.IsInRange(550))
{
if (hasCutlass)
{
_totalDamage += (float)_player.CalculateDamage(_target, DamageType.Magical, 100);
useCutlass = true;
}
if (hasBotrk)
{
_totalDamage += (float)_player.CalculateDamage(_target, DamageType.Magical, 100);
useBotrk = true;
}
}
if (_target.IsInRange(700) && hasGunblade)
{
float damage = new float[] { 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 220, 225, 230, 235, 240, 245, 250 }[_player.Level - 1];
damage += _player.TotalAbilityDamage * 0.3f;
_totalDamage += (float)_player.CalculateDamage(_target, DamageType.Magical, damage);
useGunblade = true;
}
}
}
/// <summary>
/// Gets the spell damage.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="spellSlot">The spell slot.</param>
/// <param name="stage">The stage.</param>
/// <returns>System.Double.</returns>
public static double GetSpellDamage(
this Obj_AI_Hero source,
Obj_AI_Base target,
SpellSlot spellSlot,
DamageStage stage = DamageStage.Default)
{
if (source == null || !source.IsValid || target == null || !target.IsValid)
{
return(0);
}
if (!DamageLibrary.Damages.TryGetValue(source.ChampionName, out ChampionDamage value))
{
return(0);
}
var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData;
if (spellData == null)
{
return(0);
}
var scaleSlot = spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot;
var spellLevel = source.SpellBook.GetSpell(scaleSlot).Level;
if (spellLevel == 0)
{
return(0);
}
var alreadyAdd1 = false;
var targetHero = target as Obj_AI_Hero;
var targetMinion = target as Obj_AI_Minion;
var dmgBase = 0d;
var dmgBonus = 0d;
var dmgPassive = 0d;
var dmgReduce = 1d;
if (spellData.DamagesPerLvl?.Count > 0)
{
dmgBase = spellData.DamagesPerLvl[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)];
}
else if (spellData.Damages?.Count > 0)
{
dmgBase = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)];
if (!string.IsNullOrEmpty(spellData.ScalingBuff))
{
var scalingTarget = spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target;
var buffCount = scalingTarget.GetRealBuffCount(spellData.ScalingBuff);
dmgBase = buffCount > 0 ? dmgBase * (buffCount + spellData.ScalingBuffOffset) : 0;
}
}
if (dmgBase > 0)
{
if (targetMinion != null && spellData.BonusDamageOnMinion?.Count > 0)
{
dmgBase += spellData.BonusDamageOnMinion[Math.Min(
spellLevel - 1,
spellData.BonusDamageOnMinion.Count - 1)];
}
if (spellData.IsApplyOnHit ||
spellData.IsModifiedDamage ||
spellData.SpellEffectType == SpellEffectType.Single)
{
alreadyAdd1 = true;
}
dmgBase = source.CalculateDamage(target, spellData.DamageType, dmgBase);
}
if (spellData.BonusDamages?.Count > 0)
{
foreach (var bonusDmg in spellData.BonusDamages)
{
var dmg = source.GetBonusSpellDamage(target, bonusDmg, spellLevel - 1);
if (dmg <= 0)
{
continue;
}
if (!alreadyAdd1 &&
(spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single))
{
alreadyAdd1 = true;
}
dmgBonus += source.CalculateDamage(target, bonusDmg.DamageType, dmg);
}
}
var totalDamage = dmgBase + dmgBonus;
if (totalDamage > 0)
{
if (spellData.ScalePerCritPercent > 0)
{
totalDamage *= source.Crit * 100 * spellData.ScalePerCritPercent;
}
if (spellData.ScalePerTargetMissHealth > 0)
{
totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth * spellData.ScalePerTargetMissHealth + 1;
}
if (target is Obj_AI_Minion)
{
if (spellData.MaxDamageOnMinion?.Count > 0)
{
totalDamage = Math.Min(
totalDamage,
spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]);
}
if (target.Team == GameObjectTeam.Neutral &&
spellData.MaxDamageOnMonster?.Count > 0)
{
totalDamage = Math.Min(
totalDamage,
spellData.MaxDamageOnMonster[Math.Min(spellLevel - 1, spellData.MaxDamageOnMonster.Count - 1)]);
}
}
if (spellData.IsModifiedDamage)
{
if (targetHero != null &&
targetHero.HasItem(ItemId.NinjaTabi))
{
dmgReduce *= 0.9;
}
}
}
if (spellData.IsApplyOnHit ||
spellData.IsModifiedDamage)
{
var itemDamage = DamageItems.ComputeItemDamages(source, target);
totalDamage += source.CalculateDamage(target, DamageType.Physical, itemDamage.PhysicalDamage);
totalDamage += source.CalculateDamage(target, DamageType.Magical, itemDamage.MagicalDamage);
}
if (source.ChampionName == "Sejuani" &&
target.HasBuff("sejuanistun"))
{
switch (target.Type)
{
case GameObjectType.obj_AI_Hero:
if (source.Level < 7)
{
dmgPassive += 0.1 * target.MaxHealth;
}
else if (source.Level < 14)
{
dmgPassive += 0.15 * target.MaxHealth;
}
else
{
dmgPassive += 0.2 * target.MaxHealth;
}
break;
case GameObjectType.obj_AI_Minion:
dmgPassive += 400;
break;
}
dmgPassive = source.CalculateDamage(target, DamageType.Magical, dmgPassive);
}
return(Math.Max(Math.Floor(totalDamage * dmgReduce + dmgPassive), 0));
}
/// <summary>
/// Get the spell damage value.
/// </summary>
/// <param name="source">
/// The source
/// </param>
/// <param name="target">
/// The target
/// </param>
/// <param name="spellSlot">
/// The spell slot
/// </param>
/// <param name="stage">
/// The stage
/// </param>
/// <returns>
/// The <see cref="double" /> value of damage.
/// </returns>
public static double GetSpellDamage(
this Obj_AI_Hero source,
Obj_AI_Base target,
SpellSlot spellSlot,
DamageStage stage = DamageStage.Default)
{
if (source == null || !source.IsValid || target == null || !target.IsValid)
{
return(0);
}
ChampionDamage value;
if (!DamageCollection.TryGetValue(source.ChampionName, out value))
{
return(0);
}
var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData;
if (spellData == null)
{
return(0);
}
var spellLevel =
source.Spellbook.GetSpell(spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot)
.Level;
if (spellLevel == 0)
{
return(0);
}
var baseDamage = 0d;
var bonusDamage = 0d;
if (spellData.Damages?.Count > 0)
{
if (spellData.DamageType == DamageType.Mixed)
{
var oriDamage = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)];
baseDamage = source.CalculateMixedDamage(target, oriDamage / 2, oriDamage / 2);
if (!string.IsNullOrEmpty(spellData.ScalingBuff))
{
var buffCount =
(spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount(
spellData.ScalingBuff);
baseDamage = buffCount != 0 ? baseDamage * (buffCount + spellData.ScalingBuffOffset) : 0;
}
}
else
{
baseDamage = source.CalculateDamage(
target,
spellData.DamageType,
spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)]);
if (!string.IsNullOrEmpty(spellData.ScalingBuff))
{
var buffCount =
(spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount(
spellData.ScalingBuff);
baseDamage = buffCount != 0 ? baseDamage * (buffCount + spellData.ScalingBuffOffset) : 0;
}
}
}
if (spellData.DamagesPerLvl?.Count > 0)
{
baseDamage = source.CalculateDamage(
target,
spellData.DamageType,
spellData.Damages[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)]);
}
if (spellData.BonusDamages?.Count > 0)
{
foreach (var bonusDmg in
spellData.BonusDamages.Where(i => source.ResolveBonusSpellDamage(target, i, spellLevel - 1) > 0))
{
if (bonusDmg.DamageType == DamageType.Mixed)
{
var oriDamage = source.ResolveBonusSpellDamage(target, bonusDmg, spellLevel - 1);
bonusDamage += source.CalculateMixedDamage(target, oriDamage / 2, oriDamage / 2);
}
else
{
bonusDamage += source.CalculateDamage(
target,
bonusDmg.DamageType,
source.ResolveBonusSpellDamage(target, bonusDmg, spellLevel - 1));
}
}
}
var totalDamage = baseDamage + bonusDamage;
var passiveDamage = 0d;
if (totalDamage > 0)
{
if (spellData.ScalePerTargetMissHealth > 0)
{
totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth
* spellData.ScalePerTargetMissHealth + 1;
}
if (target is Obj_AI_Minion && spellData.MaxDamageOnMinion?.Count > 0)
{
totalDamage = Math.Min(
totalDamage,
spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]);
}
if (spellData.SpellEffectType == SpellEffectType.Single && target is Obj_AI_Minion)
{
var savagery = source.GetCunning(DamageMastery.Cunning.Savagery);
if (savagery.IsValid())
{
passiveDamage += savagery.Points;
}
}
}
return(totalDamage + passiveDamage);
}
/*
* private static void Unit_Ondash(Obj_AI_Base sender, Dash.DashArgs args)
* {
* var target = TargetSelector.GetTarget(Q.Range, DamageType.Magical);
* var qSpell = Config.Item("useQW2D").GetValue<bool>();
*
* if (!sender.IsEnemy)
* {
* return;
* }
*
* if (sender.NetworkId == target.NetworkId)
* {
* if (qSpell)
* {
*
* if (Q.IsReady()
* && args.EndPos.Distance(target) < Q.Range)
* {
* var delay = (int)(args.EndTick - Game.Time - Q.Delay - 0.1f);
* if (delay > 0)
* {
* DelayAction.Add(delay * 1000, () => Q.Cast(args.EndPos));
* }
* else
* {
* Q.Cast(args.EndPos);
* }
* if (Q.IsReady()
* && args.EndPos.Distance(new Vector2 Player.Position, < Q.Range)
* {
* if (delay > 0)
* {
* DelayAction.Add(delay * 1000, () => Q.Cast(args.EndPos));
* }
* else
* {
* W.CastOnUnit(target);
* }
* }
* }
* }
* }
* }
*/
private static double eDamage(Obj_AI_Base target)
{
return
(Player.CalculateDamage(target, DamageType.Magical,
new[] { 50, 66, 82, 98, 114 }[E.Level - 1] +0.3 * Player.FlatMagicDamageMod + 0.02 * Player.Mana));
}
/// <summary>
/// Get the spell damage value.
/// </summary>
/// <param name="source">
/// The source
/// </param>
/// <param name="target">
/// The target
/// </param>
/// <param name="spellSlot">
/// The spell slot
/// </param>
/// <param name="stage">
/// The stage
/// </param>
/// <returns>
/// The <see cref="double" /> value of damage.
/// </returns>
public static double GetSpellDamage(
this Obj_AI_Hero source,
Obj_AI_Base target,
SpellSlot spellSlot,
DamageStage stage = DamageStage.Default)
{
if (source == null || !source.IsValid || target == null || !target.IsValid)
{
return(0);
}
ChampionDamage value;
if (!DamageCollection.TryGetValue(source.ChampionName, out value))
{
return(0);
}
var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData;
if (spellData == null)
{
return(0);
}
var spellLevel =
source.Spellbook.GetSpell(spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot)
.Level;
if (spellLevel == 0)
{
return(0);
}
bool alreadyAdd1 = false, alreadyAdd2 = false;
var targetHero = target as Obj_AI_Hero;
var targetMinion = target as Obj_AI_Minion;
double dmgBase = 0, dmgBonus = 0, dmgPassive = 0;
var dmgReduce = 1d;
if (spellData.DamagesPerLvl?.Count > 0)
{
dmgBase = spellData.DamagesPerLvl[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)];
}
else if (spellData.Damages?.Count > 0)
{
dmgBase = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)];
if (!string.IsNullOrEmpty(spellData.ScalingBuff))
{
var buffCount =
(spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount(
spellData.ScalingBuff);
dmgBase = buffCount > 0 ? dmgBase * (buffCount + spellData.ScalingBuffOffset) : 0;
}
}
if (dmgBase > 0)
{
if (targetMinion != null && spellData.BonusDamageOnMinion?.Count > 0)
{
dmgBase +=
spellData.BonusDamageOnMinion[Math.Min(spellLevel - 1, spellData.BonusDamageOnMinion.Count - 1)];
}
if (spellData.IsApplyOnHit || spellData.IsModifiedDamage ||
spellData.SpellEffectType == SpellEffectType.Single)
{
if (source.HasBuff("Serrated"))
{
dmgBase += 15;
}
if (targetHero != null)
{
if (!spellData.IsApplyOnHit && Items.HasItem((int)ItemId.Dorans_Shield, targetHero))
{
dmgBase -= 8;
}
}
else if (targetMinion != null)
{
var savagery = source.GetCunning(Cunning.Savagery);
if (savagery.IsValid())
{
dmgBase += savagery.Points;
}
}
alreadyAdd1 = true;
}
dmgBase = source.CalculateDamage(target, spellData.DamageType, dmgBase);
if (spellData.IsModifiedDamage && spellData.DamageType == DamageType.Physical && targetHero != null &&
targetHero.ChampionName == "Fizz")
{
dmgBase -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d));
alreadyAdd2 = true;
}
}
if (spellData.BonusDamages?.Count > 0)
{
foreach (var bonusDmg in spellData.BonusDamages)
{
var dmg = source.ResolveBonusSpellDamage(target, bonusDmg, spellLevel - 1);
if (dmg <= 0)
{
continue;
}
if (!alreadyAdd1 &&
(spellData.IsModifiedDamage || spellData.SpellEffectType == SpellEffectType.Single))
{
if (source.HasBuff("Serrated"))
{
dmg += 15;
}
if (targetHero != null)
{
if (Items.HasItem((int)ItemId.Dorans_Shield, targetHero))
{
dmg -= 8;
}
}
else if (targetMinion == null)
{
var savagery = source.GetCunning(Cunning.Savagery);
if (savagery.IsValid())
{
dmg += savagery.Points;
}
}
alreadyAdd1 = true;
}
dmgBonus += source.CalculateDamage(target, bonusDmg.DamageType, dmg);
if (!alreadyAdd2 && spellData.IsModifiedDamage && bonusDmg.DamageType == DamageType.Physical &&
targetHero != null && targetHero.ChampionName == "Fizz")
{
dmgBonus -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d));
alreadyAdd2 = true;
}
}
}
var totalDamage = dmgBase + dmgBonus;
if (totalDamage > 0)
{
if (spellData.ScalePerTargetMissHealth > 0)
{
totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth
* spellData.ScalePerTargetMissHealth + 1;
}
if (target is Obj_AI_Minion && spellData.MaxDamageOnMinion?.Count > 0)
{
totalDamage = Math.Min(
totalDamage,
spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]);
}
if (spellData.IsApplyOnHit || spellData.IsModifiedDamage)
{
dmgPassive += source.GetPassiveDamageInfo(target, false).Value;
if (targetHero != null)
{
if (spellData.IsModifiedDamage &&
new[] { 3047, 1316, 1318, 1315, 1317 }.Any(i => Items.HasItem(i, targetHero)))
{
dmgReduce *= 0.9;
}
if (source.GetFerocity(Ferocity.FervorofBattle).IsValid())
{
var fervorBuffCount = source.GetBuffCount("MasteryOnHitDamageStacker");
if (fervorBuffCount > 0)
{
dmgPassive += source.CalculateDamage(
target,
DamageType.Physical,
(0.13 + (0.77 * source.Level)) * fervorBuffCount);
}
}
}
}
}
return
(Math.Max(
Math.Floor(
totalDamage * dmgReduce
+ (spellData.IsApplyOnHit || spellData.IsModifiedDamage ? source.PassiveFlatMod(target) : 0)
+ dmgPassive),
0));
}
/// <summary>
/// Gets the spell damage.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="spellSlot">The spell slot.</param>
/// <param name="stage">The stage.</param>
/// <returns>System.Double.</returns>
public static double GetSpellDamage(
this Obj_AI_Hero source,
Obj_AI_Base target,
SpellSlot spellSlot,
DamageStage stage = DamageStage.Default)
{
if (source == null || !source.IsValid || target == null || !target.IsValid)
{
return(0);
}
if (!DamageLibrary.Damages.TryGetValue(source.ChampionName, out ChampionDamage value))
{
return(0);
}
var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData;
if (spellData == null)
{
return(0);
}
var spellLevel = source.SpellBook.GetSpell(
spellData.ScaleSlot != SpellSlot.Unknown ? spellData.ScaleSlot : spellSlot)
.Level;
if (spellLevel == 0)
{
return(0);
}
var alreadyAdd1 = false;
var alreadyAdd2 = false;
var targetHero = target as Obj_AI_Hero;
var targetMinion = target as Obj_AI_Minion;
var dmgBase = 0d;
var dmgBonus = 0d;
var dmgPassive = 0d;
var dmgReduce = 1d;
if (spellData.DamagesPerLvl?.Count > 0)
{
dmgBase = spellData.DamagesPerLvl[Math.Min(source.Level - 1, spellData.DamagesPerLvl.Count - 1)];
}
else if (spellData.Damages?.Count > 0)
{
dmgBase = spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count - 1)];
if (!string.IsNullOrEmpty(spellData.ScalingBuff))
{
var buffCount = (spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target)
.GetBuffCount(spellData.ScalingBuff);
dmgBase = buffCount > 0 ? dmgBase * (buffCount + spellData.ScalingBuffOffset) : 0;
}
}
if (dmgBase > 0)
{
if (targetMinion != null && spellData.BonusDamageOnMinion?.Count > 0)
{
dmgBase += spellData.BonusDamageOnMinion[Math.Min(
spellLevel - 1,
spellData.BonusDamageOnMinion.Count - 1)];
}
if (spellData.IsApplyOnHit || spellData.IsModifiedDamage ||
spellData.SpellEffectType == SpellEffectType.Single)
{
alreadyAdd1 = true;
}
dmgBase = source.CalculateDamage(target, spellData.DamageType, dmgBase);
if (spellData.IsModifiedDamage && spellData.DamageType == DamageType.Physical && targetHero != null &&
targetHero.ChampionName == "Fizz")
{
dmgBase -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d));
alreadyAdd2 = true;
}
}
if (spellData.BonusDamages?.Count > 0)
{
foreach (var bonusDmg in spellData.BonusDamages)
{
var dmg = source.GetBonusSpellDamage(target, bonusDmg, spellLevel - 1);
if (dmg <= 0)
{
continue;
}
if (!alreadyAdd1 && (spellData.IsModifiedDamage ||
spellData.SpellEffectType == SpellEffectType.Single))
{
alreadyAdd1 = true;
}
dmgBonus += source.CalculateDamage(target, bonusDmg.DamageType, dmg);
if (alreadyAdd2 || !spellData.IsModifiedDamage || bonusDmg.DamageType != DamageType.Physical ||
targetHero == null || targetHero.ChampionName != "Fizz")
{
continue;
}
dmgBonus -= 4 + (2 * Math.Floor((targetHero.Level - 1) / 3d));
alreadyAdd2 = true;
}
}
var totalDamage = dmgBase + dmgBonus;
if (totalDamage > 0)
{
if (spellData.ScalePerCritPercent > 0)
{
totalDamage *= source.Crit * 100 * spellData.ScalePerCritPercent;
}
if (spellData.ScalePerTargetMissHealth > 0)
{
totalDamage *= (target.MaxHealth - target.Health) / target.MaxHealth
* spellData.ScalePerTargetMissHealth + 1;
}
if (target is Obj_AI_Minion && spellData.MaxDamageOnMinion?.Count > 0)
{
totalDamage = Math.Min(
totalDamage,
spellData.MaxDamageOnMinion[Math.Min(spellLevel - 1, spellData.MaxDamageOnMinion.Count - 1)]);
}
if (spellData.IsApplyOnHit || spellData.IsModifiedDamage)
{
dmgPassive += 0; // todo get passive shit
if (targetHero != null)
{
if (spellData.IsModifiedDamage && targetHero.HasItem(3047))
{
dmgReduce *= 0.9;
}
}
}
}
return(Math.Max(
Math.Floor(
totalDamage * dmgReduce + (spellData.IsApplyOnHit || spellData.IsModifiedDamage
? source.GetPassiveFlatMod(target)
: 0) + dmgPassive),
0));
}
/// <summary>
/// Get the spell damage value.
/// </summary>
/// <param name="source">
/// The source
/// </param>
/// <param name="target">
/// The target
/// </param>
/// <param name="spellSlot">
/// The spell slot
/// </param>
/// <param name="stage">
/// The stage
/// </param>
/// <returns>
/// The <see cref="double" /> value of damage.
/// </returns>
public static double GetSpellDamage(
this Obj_AI_Hero source,
Obj_AI_Base target,
SpellSlot spellSlot,
DamageStage stage = DamageStage.Default)
{
if (source == null || !source.IsValid || target == null || !target.IsValid)
{
return(0d);
}
var spellLevel = source.Spellbook.GetSpell(spellSlot).Level;
if (spellLevel == 0)
{
return(0d);
}
ChampionDamage value;
if (DamageCollection.TryGetValue(source.ChampionName, out value))
{
var baseDamage = 0d;
var bonusDamage = 0d;
var spellData = value.GetSlot(spellSlot)?.FirstOrDefault(e => e.Stage == stage)?.SpellData;
if (spellData?.Damages?.Count > 0)
{
baseDamage = source.CalculateDamage(
target,
spellData.DamageType,
spellData.Damages[Math.Min(spellLevel - 1, spellData.Damages.Count)]);
if (!string.IsNullOrEmpty(spellData.ScalingBuff))
{
var buffCount =
(spellData.ScalingBuffTarget == DamageScalingTarget.Source ? source : target).GetBuffCount(
spellData.ScalingBuff);
if (buffCount != 0)
{
baseDamage *= buffCount + spellData.ScalingBuffOffset;
}
}
}
if (spellData?.BonusDamages?.Count > 0)
{
bonusDamage =
spellData.BonusDamages.Sum(
instance =>
source.CalculateDamage(
target,
instance.DamageType,
source.ResolveBonusSpellDamage(target, instance, spellLevel - 1)));
}
return(baseDamage + bonusDamage);
}
return(0d);
}
private static double Qdmg(Obj_AI_Base target)
{
return
(Player.CalculateDamage(target, DamageType.Physical,
new[] { 40, 65, 90, 115, 140 }[Program.Q.Level - 1] +0.6 * Player.FlatPhysicalDamageMod));
}
private static double Qdmg(Obj_AI_Base target)
{
return
(Player.CalculateDamage(target, DamageType.Magical,
new[] { 75, 115, 155, 195, 235 }[Q.Level - 1] +0.45 * Player.FlatMagicDamageMod));
}
/// <summary>
/// TODO The get rend damage.
/// </summary>
/// <param name="target">
/// TODO The target.
/// </param>
/// <param name="customStacks">
/// TODO The custom stacks.
/// </param>
/// <returns>
/// The <see cref="float"/>.
/// </returns>
public static float GetRendDamage(Obj_AI_Base target, int customStacks = -1)
{
// Calculate the damage and return
return((float)Player.CalculateDamage(target, DamageType.Physical, GetRawRendDamage(target, customStacks)));
}
