/// <summary>
/// Initializes a new instance of the <see cref="SpellDamage" /> class.
/// </summary>
/// <param name="sdata">
/// The spell damage data.
/// </param>
internal SpellDamage(SpellDamageData sdata)
{
this.SData = sdata;
this.GetDamageFunc = (@base, aiBase) =>
{
if (@base.Spellbook.GetSpell(sdata.Slot).Level == 0)
{
return 0d;
}
var spellLevel = @base.Spellbook.GetSpell(sdata.Slot).Level - 1;
var damage = 0d;
var abilityPowerDamageAmount = 0d;
var attackDamageAmount = 0d;
if (sdata.Base != null && sdata.Base.Length > 0)
{
if (sdata.Flags.HasFlag(DamageFlags.SpecialDistance)
&& @base.Distance(aiBase) > sdata.DistanceOffset)
{
damage += sdata.BaseDistance[Math.Min(spellLevel, sdata.BaseDistance.Length - 1)];
}
else
{
if (sdata.BaseMinion != null && sdata.BaseMinion.Length > 0 && aiBase is Obj_AI_Minion)
{
damage += sdata.BaseMinion[Math.Min(spellLevel, sdata.BaseMinion.Length - 1)];
}
else
{
SpellSlot spellSlot;
int intValue;
if (sdata.Flags.HasFlag(DamageFlags.SpecialPassiveAlternative)
&& ((sdata.AlternativePassive.Length == 1
&& @base.HasBuff(sdata.AlternativePassive[0]))
|| (sdata.AlternativePassive.Length == 2
&& Enum.TryParse(sdata.AlternativePassive[0], out spellSlot)
&& int.TryParse(sdata.AlternativePassive[1], out intValue)
&& @base.Spellbook.GetSpell(spellSlot).ToggleState == intValue))
&& sdata.BaseAlternative != null && sdata.BaseAlternative.Length > 0)
{
damage +=
sdata.BaseAlternative[Math.Min(spellLevel, sdata.BaseAlternative.Length - 1)];
}
else
{
damage += sdata.Base[Math.Min(spellLevel, sdata.Base.Length - 1)];
}
}
}
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPower))
{
var value = @base.TotalMagicalDamage * sdata.AbilityPower
+ @base.TotalMagicalDamage * sdata.AbilityPowerMinion;
damage += value;
abilityPowerDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.AttackDamage))
{
var value = @base.TotalAttackDamage * sdata.AttackDamage;
damage += value;
attackDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.BonusAttackDamage))
{
var value = (sdata.Flags.HasFlag(DamageFlags.SpecialDistance)
&& @base.Distance(aiBase) > sdata.DistanceOffset)
? @base.FlatPhysicalDamageMod * sdata.DistanceBonusAttackDamage
: @base.FlatPhysicalDamageMod * sdata.BonusAttackDamage;
damage += value;
attackDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.EnemyMaxHealth) && sdata.EnemyMaxHealthBase != null
&& sdata.EnemyMaxHealthBase.Length > 0)
{
damage += aiBase.MaxHealth
* sdata.EnemyMaxHealthBase[Math.Min(spellLevel, sdata.EnemyMaxHealthBase.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPowerEnemyMaxHealth))
{
damage += @base.TotalMagicalDamage * sdata.AbilityPowerEnemyMaxHealth;
}
if (sdata.Flags.HasFlag(DamageFlags.BaseAttackDamagePercent)
&& sdata.BaseAttackDamagePercent != null && sdata.BaseAttackDamagePercent.Length > 0)
{
damage += @base.TotalAttackDamage
* sdata.BaseAttackDamagePercent[
Math.Min(spellLevel, sdata.BaseAttackDamagePercent.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.BaseAbilityPowerPercent)
&& sdata.BaseAbilityPowerPercent != null && sdata.BaseAbilityPowerPercent.Length > 0)
{
damage += @base.TotalAttackDamage
* sdata.BaseAbilityPowerPercent[
Math.Min(spellLevel, sdata.BaseAbilityPowerPercent.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.BaseBonusAttackDamagePercent)
&& sdata.BaseAttackDamagePercent != null && sdata.BaseAttackDamagePercent.Length > 0)
{
damage += @base.TotalAttackDamage
* sdata.BaseBonusAttackDamagePercent[
Math.Min(spellLevel, sdata.BaseBonusAttackDamagePercent.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.BaseChampionLevel) && sdata.BaseChampionLevel != null
&& sdata.BaseChampionLevel.Length > 0)
{
damage += sdata.BaseChampionLevel[Math.Min(@base.Level, sdata.BaseChampionLevel.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.MaxHealth))
{
damage += @base.MaxHealth * sdata.MaxHealth;
}
if (sdata.Flags.HasFlag(DamageFlags.TargetHealth))
{
SpellSlot spellSlot;
int intValue;
var flag = !sdata.Flags.HasFlag(DamageFlags.SpecialPassiveAlternative)
|| !((sdata.AlternativePassive.Length == 1
&& @base.HasBuff(sdata.AlternativePassive[0]))
|| (sdata.AlternativePassive.Length == 2
&& Enum.TryParse(sdata.AlternativePassive[0], out spellSlot)
&& int.TryParse(sdata.AlternativePassive[1], out intValue)
&& @base.Spellbook.GetSpell(spellSlot).ToggleState == intValue));
var baseTargetHealth = flag ? sdata.BaseTargetHealth : sdata.BaseAlternativeTargetHealth;
var targetHealthBaseAbilityPowerScale = flag
? sdata.TargetHealthBaseAbilityPowerScale
: sdata.AlternativeTargetHealthBaseAbilityPowerScale;
var targetHealthBaseMinimumDamage = flag
? sdata.TargetHealthBaseMinimumDamage
: sdata.AlternativeTargetHealthBaseMinimumDamage;
var minionHealthBaseMaximumDamage = flag
? sdata.MinionHealthBaseMaximumDamage
: sdata.AlternativeMinionHealthBaseMaximumDamage;
var flagDamage = 0f;
if (baseTargetHealth != null && baseTargetHealth.Length > 0)
{
flagDamage += aiBase.Health
* baseTargetHealth[Math.Min(spellLevel, baseTargetHealth.Length - 1)];
}
if (targetHealthBaseAbilityPowerScale != null && targetHealthBaseAbilityPowerScale.Length > 0)
{
float value;
switch (targetHealthBaseAbilityPowerScale.Length)
{
case 1:
value = aiBase.Health * targetHealthBaseAbilityPowerScale[0];
flagDamage += value;
abilityPowerDamageAmount += value;
break;
case 2:
if (@base.TotalMagicalDamage / targetHealthBaseAbilityPowerScale[1] >= 1f)
{
value = aiBase.Health
* ((@base.TotalMagicalDamage / targetHealthBaseAbilityPowerScale[1])
* targetHealthBaseAbilityPowerScale[0]);
flagDamage += value;
abilityPowerDamageAmount += value;
}
break;
}
}
if (targetHealthBaseMinimumDamage != null && targetHealthBaseMinimumDamage.Length > 0)
{
flagDamage =
Math.Max(
targetHealthBaseMinimumDamage[
Math.Min(spellLevel, targetHealthBaseMinimumDamage.Length - 1)],
flagDamage);
}
if (minionHealthBaseMaximumDamage != null && minionHealthBaseMaximumDamage.Length > 0
&& aiBase is Obj_AI_Minion)
{
flagDamage =
Math.Min(
minionHealthBaseMaximumDamage[
Math.Min(spellLevel, minionHealthBaseMaximumDamage.Length - 1)],
flagDamage);
}
damage += flagDamage;
flagDamage = 0f;
var baseTargetMissingHealth = flag
? sdata.BaseTargetMissingHealth
: sdata.BaseAlternativeTargetMissingHealth;
var targetMissingHealthBaseAbilityPowerScale = flag
? sdata
.TargetMissingHealthBaseAbilityPowerScale
: sdata
.AlternativeTargetMissingHealthBaseAbilityPowerScale;
var targetMissingHealthBaseMinimumDamage = flag
? sdata.TargetMissingHealthBaseMinimumDamage
: sdata
.AlternativeTargetMissingHealthBaseMinimumDamage;
var minionMissingHealthBaseMaximumDamage = flag
? sdata.MinionMissingHealthBaseMaximumDamage
: sdata
.AlternativeMinionMissingHealthBaseMaximumDamage;
var missingHealth = aiBase.MaxHealth - aiBase.Health;
if (baseTargetMissingHealth != null && baseTargetMissingHealth.Length > 0)
{
flagDamage += missingHealth
* baseTargetMissingHealth[
Math.Min(spellLevel, baseTargetMissingHealth.Length - 1)];
}
if (targetMissingHealthBaseAbilityPowerScale != null
&& targetMissingHealthBaseAbilityPowerScale.Length > 0)
{
float value;
switch (targetMissingHealthBaseAbilityPowerScale.Length)
{
case 1:
value = missingHealth * targetMissingHealthBaseAbilityPowerScale[0];
flagDamage += value;
abilityPowerDamageAmount += value;
break;
case 2:
if (@base.TotalMagicalDamage / targetMissingHealthBaseAbilityPowerScale[1] >= 1f)
{
value = missingHealth
* ((@base.TotalMagicalDamage
/ targetMissingHealthBaseAbilityPowerScale[1])
* targetMissingHealthBaseAbilityPowerScale[0]);
flagDamage += value;
abilityPowerDamageAmount += value;
}
break;
}
}
if (targetMissingHealthBaseMinimumDamage != null
&& targetMissingHealthBaseMinimumDamage.Length > 0)
{
flagDamage =
Math.Max(
targetMissingHealthBaseMinimumDamage[
Math.Min(spellLevel, targetMissingHealthBaseMinimumDamage.Length - 1)],
flagDamage);
}
if (minionMissingHealthBaseMaximumDamage != null
&& minionMissingHealthBaseMaximumDamage.Length > 0 && aiBase is Obj_AI_Minion)
{
flagDamage =
Math.Min(
minionMissingHealthBaseMaximumDamage[
Math.Min(spellLevel, minionMissingHealthBaseMaximumDamage.Length - 1)],
flagDamage);
}
damage += flagDamage;
}
damage = Math.Round(damage);
attackDamageAmount = Math.Round(attackDamageAmount);
abilityPowerDamageAmount = Math.Round(abilityPowerDamageAmount);
return sdata.Type == DamageType.Mixed
? @base.CalculateMixedDamage(aiBase, attackDamageAmount, abilityPowerDamageAmount)
: @base.CalculateDamage(aiBase, sdata.Type, damage);
};
}
internal SpellDamage(SpellDamageData sdata)
{
this.SData = sdata;
this.GetDamageFunc = (@base, aiBase) =>
{
if (@base.Spellbook.GetSpell(sdata.Slot).Level == 0)
{
return 0d;
}
var spellLevel = sdata.Flags.HasFlag(DamageFlags.LevelScale)
? @base.Spellbook.GetSpell(sdata.LevelScale).Level - 1
: @base.Spellbook.GetSpell(sdata.Slot).Level - 1;
var damage = 0d;
var abilityPowerDamageAmount = 0d;
var attackDamageAmount = 0d;
SpellSlot spellSlot;
int intValue;
var alternativePassive = sdata.Flags.HasFlag(DamageFlags.SpecialPassiveAlternative)
&& ((sdata.AlternativePassive.Length == 1
&& @base.HasBuff(sdata.AlternativePassive[0]))
|| (sdata.AlternativePassive.Length == 2
&& Enum.TryParse(sdata.AlternativePassive[0], out spellSlot)
&& int.TryParse(sdata.AlternativePassive[1], out intValue)
&& @base.Spellbook.GetSpell(spellSlot).ToggleState == intValue));
if (sdata.Base != null && sdata.Base.Length > 0)
{
if (sdata.Flags.HasFlag(DamageFlags.SpecialDistance)
&& @base.Distance(aiBase) > sdata.DistanceOffset)
{
damage += sdata.BaseDistance[Math.Min(spellLevel, sdata.BaseDistance.Length - 1)];
}
else
{
if (sdata.BaseMinion != null && sdata.BaseMinion.Length > 0 && aiBase is Obj_AI_Minion)
{
damage += sdata.BaseMinion[Math.Min(spellLevel, sdata.BaseMinion.Length - 1)];
}
else
{
if (alternativePassive)
{
damage +=
sdata.BaseAlternative[Math.Min(spellLevel, sdata.BaseAlternative.Length - 1)];
}
else
{
damage += sdata.Base[Math.Min(spellLevel, sdata.Base.Length - 1)];
}
}
}
}
if (sdata.TargetBase != null && sdata.TargetBase.Length > 0 && aiBase is Obj_AI_Hero)
{
damage += sdata.TargetBase[Math.Min(spellLevel, sdata.TargetBase.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPower))
{
var value = @base.TotalMagicalDamage
* (aiBase is Obj_AI_Minion && sdata.AbilityPowerMinion > float.Epsilon
? sdata.AbilityPowerMinion
: sdata.AbilityPower);
if (alternativePassive)
{
value = @base.TotalMagicalDamage * sdata.AlternativeAbilityPower;
}
damage += value;
abilityPowerDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.AttackDamage))
{
var value = @base.TotalAttackDamage
* (aiBase is Obj_AI_Minion && sdata.AttackDamageMinion > float.Epsilon
? sdata.AttackDamageMinion
: sdata.AttackDamage);
if (alternativePassive)
{
value = @base.TotalAttackDamage * sdata.AlternativeAttackDamage;
}
damage += value;
attackDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.BonusAttackDamage))
{
var value = (sdata.Flags.HasFlag(DamageFlags.SpecialDistance)
&& @base.Distance(aiBase) > sdata.DistanceOffset)
? @base.FlatPhysicalDamageMod * sdata.DistanceBonusAttackDamage
: @base.FlatPhysicalDamageMod * sdata.BonusAttackDamage;
if (alternativePassive)
{
value = @base.FlatPhysicalDamageMod * sdata.AlternativeBonusAttackDamage;
}
damage += value;
attackDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.EnemyMaxHealth) && sdata.EnemyMaxHealthBase != null
&& sdata.EnemyMaxHealthBase.Length > 0)
{
damage += aiBase.MaxHealth
* sdata.EnemyMaxHealthBase[Math.Min(spellLevel, sdata.EnemyMaxHealthBase.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPowerEnemyMaxHealth))
{
damage += @base.TotalMagicalDamage * sdata.AbilityPowerEnemyMaxHealth;
}
if (sdata.Flags.HasFlag(DamageFlags.BaseAttackDamagePercent)
&& ((sdata.BaseAttackDamagePercent != null && sdata.BaseAttackDamagePercent.Length > 0)
|| (sdata.BaseMinionAttackDamagePercent != null
&& sdata.BaseMinionAttackDamagePercent.Length > 0)))
{
var value = @base.TotalAttackDamage
* (aiBase is Obj_AI_Minion && sdata.BaseMinionAttackDamagePercent != null
&& sdata.BaseMinionAttackDamagePercent.Length > 0
? sdata.BaseMinionAttackDamagePercent[
Math.Min(spellLevel, sdata.BaseMinionAttackDamagePercent.Length - 1)]
: sdata.BaseAttackDamagePercent[
Math.Min(spellLevel, sdata.BaseAttackDamagePercent.Length - 1)]);
damage += value;
attackDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.BaseAbilityPowerPercent)
&& sdata.BaseAbilityPowerPercent != null && sdata.BaseAbilityPowerPercent.Length > 0)
{
var value = @base.TotalMagicalDamage
* sdata.BaseAbilityPowerPercent[
Math.Min(spellLevel, sdata.BaseAbilityPowerPercent.Length - 1)];
damage += value;
abilityPowerDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.BaseBonusAttackDamagePercent)
&& sdata.BaseBonusAttackDamagePercent != null && sdata.BaseBonusAttackDamagePercent.Length > 0)
{
var value = @base.TotalAttackDamage
* sdata.BaseBonusAttackDamagePercent[
Math.Min(spellLevel, sdata.BaseBonusAttackDamagePercent.Length - 1)];
damage += value;
attackDamageAmount += value;
}
if (sdata.Flags.HasFlag(DamageFlags.BaseChampionLevel) && sdata.BaseChampionLevel != null
&& sdata.BaseChampionLevel.Length > 0)
{
damage += sdata.BaseChampionLevel[Math.Min(@base.Level, sdata.BaseChampionLevel.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.MaxHealth))
{
damage += @base.MaxHealth * sdata.MaxHealth;
}
if (sdata.Flags.HasFlag(DamageFlags.TargetHealth))
{
var baseTargetHealth = alternativePassive
? sdata.BaseTargetHealth
: sdata.BaseAlternativeTargetHealth;
var targetHealthBaseAbilityPowerScale = alternativePassive
? sdata.TargetHealthBaseAbilityPowerScale
: sdata.AlternativeTargetHealthBaseAbilityPowerScale;
var targetHealthBaseMinimumDamage = alternativePassive
? sdata.TargetHealthBaseMinimumDamage
: sdata.AlternativeTargetHealthBaseMinimumDamage;
var minionHealthBaseMaximumDamage = alternativePassive
? sdata.MinionHealthBaseMaximumDamage
: sdata.AlternativeMinionHealthBaseMaximumDamage;
var flagDamage = 0f;
if (baseTargetHealth != null && baseTargetHealth.Length > 0)
{
flagDamage += aiBase.Health
* baseTargetHealth[Math.Min(spellLevel, baseTargetHealth.Length - 1)];
}
if (targetHealthBaseAbilityPowerScale != null && targetHealthBaseAbilityPowerScale.Length > 0)
{
float value;
switch (targetHealthBaseAbilityPowerScale.Length)
{
case 1:
value = aiBase.Health * targetHealthBaseAbilityPowerScale[0];
flagDamage += value;
abilityPowerDamageAmount += value;
break;
case 2:
if (@base.TotalMagicalDamage / targetHealthBaseAbilityPowerScale[1] >= 1f)
{
value = aiBase.Health
* ((@base.TotalMagicalDamage / targetHealthBaseAbilityPowerScale[1])
* targetHealthBaseAbilityPowerScale[0]);
flagDamage += value;
abilityPowerDamageAmount += value;
}
break;
}
}
if (targetHealthBaseMinimumDamage != null && targetHealthBaseMinimumDamage.Length > 0)
{
flagDamage =
Math.Max(
targetHealthBaseMinimumDamage[
Math.Min(spellLevel, targetHealthBaseMinimumDamage.Length - 1)],
flagDamage);
}
if (minionHealthBaseMaximumDamage != null && minionHealthBaseMaximumDamage.Length > 0
&& aiBase is Obj_AI_Minion)
{
flagDamage =
Math.Min(
minionHealthBaseMaximumDamage[
Math.Min(spellLevel, minionHealthBaseMaximumDamage.Length - 1)],
flagDamage);
}
damage += flagDamage;
flagDamage = 0f;
var baseTargetMissingHealth = alternativePassive
? sdata.BaseTargetMissingHealth
: sdata.BaseAlternativeTargetMissingHealth;
var targetMissingHealthBaseAbilityPowerScale = alternativePassive
? sdata
.TargetMissingHealthBaseAbilityPowerScale
: sdata
.AlternativeTargetMissingHealthBaseAbilityPowerScale;
var targetMissingHealthBaseMinimumDamage = alternativePassive
? sdata.TargetMissingHealthBaseMinimumDamage
: sdata
.AlternativeTargetMissingHealthBaseMinimumDamage;
var minionMissingHealthBaseMaximumDamage = alternativePassive
? sdata.MinionMissingHealthBaseMaximumDamage
: sdata
.AlternativeMinionMissingHealthBaseMaximumDamage;
var missingHealth = aiBase.MaxHealth - aiBase.Health;
if (baseTargetMissingHealth != null && baseTargetMissingHealth.Length > 0)
{
flagDamage += missingHealth
* baseTargetMissingHealth[
Math.Min(spellLevel, baseTargetMissingHealth.Length - 1)];
}
if (targetMissingHealthBaseAbilityPowerScale != null
&& targetMissingHealthBaseAbilityPowerScale.Length > 0)
{
float value;
switch (targetMissingHealthBaseAbilityPowerScale.Length)
{
case 1:
value = missingHealth * targetMissingHealthBaseAbilityPowerScale[0];
flagDamage += value;
abilityPowerDamageAmount += value;
break;
case 2:
if (@base.TotalMagicalDamage / targetMissingHealthBaseAbilityPowerScale[1] >= 1f)
{
value = missingHealth
* ((@base.TotalMagicalDamage
/ targetMissingHealthBaseAbilityPowerScale[1])
* targetMissingHealthBaseAbilityPowerScale[0]);
flagDamage += value;
abilityPowerDamageAmount += value;
}
break;
}
}
if (targetMissingHealthBaseMinimumDamage != null
&& targetMissingHealthBaseMinimumDamage.Length > 0)
{
flagDamage =
Math.Max(
targetMissingHealthBaseMinimumDamage[
Math.Min(spellLevel, targetMissingHealthBaseMinimumDamage.Length - 1)],
flagDamage);
}
if (minionMissingHealthBaseMaximumDamage != null
&& minionMissingHealthBaseMaximumDamage.Length > 0 && aiBase is Obj_AI_Minion)
{
flagDamage =
Math.Min(
minionMissingHealthBaseMaximumDamage[
Math.Min(spellLevel, minionMissingHealthBaseMaximumDamage.Length - 1)],
flagDamage);
}
damage += flagDamage;
}
if (sdata.Flags.HasFlag(DamageFlags.SpecialTargetPassive))
{
if (sdata.TargetPassiveIdentifier != null && sdata.TargetPassiveIdentifier.Length > 0)
{
var passiveName = sdata.TargetPassiveIdentifier[0];
int rawTempValue;
var passiveCountPrefix = sdata.TargetPassiveIdentifier.Length > 1
&& int.TryParse(sdata.TargetPassiveIdentifier[1], out rawTempValue)
? rawTempValue
: 0;
var enemyPassiveCount = aiBase.GetBuffCount(passiveName) - passiveCountPrefix;
if (enemyPassiveCount > 0)
{
if (sdata.BaseTargetPassive != null && sdata.BaseTargetPassive.Length > 0)
{
damage += enemyPassiveCount
* sdata.BaseTargetPassive[
Math.Min(spellLevel, sdata.BaseTargetPassive.Length - 1)];
}
if (sdata.BaseTargetPassiveAttackDamage != null
&& sdata.BaseTargetPassiveAttackDamage.Length > 0)
{
damage += enemyPassiveCount
* sdata.BaseTargetPassiveAttackDamage[
Math.Min(spellLevel, sdata.BaseTargetPassiveAttackDamage.Length - 1)]
* @base.TotalAttackDamage;
}
}
}
}
var trueDamage = 0d;
if (alternativePassive)
{
trueDamage += damage * sdata.AlternativeTrueDamage;
}
var forceIgnoreArmor = -sdata.TargetArmorIgnore;
return (sdata.Type == DamageType.Mixed
? @base.CalculateMixedDamage(aiBase, attackDamageAmount, abilityPowerDamageAmount)
: @base.CalculateDamage(aiBase, sdata.Type, damage, forceIgnoreArmor)) + trueDamage;
};
}
/// <summary>
/// Initializes a new instance of the <see cref="SpellDamage" /> class.
/// </summary>
/// <param name="sdata">
/// The spell damage data.
/// </param>
internal SpellDamage(SpellDamageData sdata)
{
this.SData = sdata;
this.GetDamageFunc = (@base, aiBase) =>
{
var spellLevel = @base.Spellbook.GetSpell(sdata.Slot).Level - 1;
var damage = 0d;
if (spellLevel >= 0 && sdata.Base.Length > 0)
{
damage += sdata.Base[Math.Min(spellLevel, sdata.Base.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPower))
{
damage += @base.TotalMagicalDamage * sdata.AbilityPower;
}
if (sdata.Flags.HasFlag(DamageFlags.AttackDamage))
{
damage += @base.TotalAttackDamage * sdata.AttackDamage;
}
if (sdata.Flags.HasFlag(DamageFlags.BonusAttackDamage))
{
damage += @base.FlatPhysicalDamageMod * sdata.BonusAttackDamage;
}
if (sdata.Flags.HasFlag(DamageFlags.EnemyMaxHealth))
{
damage += aiBase.MaxHealth
* sdata.EnemyMaxHealthBase[Math.Min(spellLevel, sdata.EnemyMaxHealthBase.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPowerEnemyMaxHealth))
{
damage += @base.TotalMagicalDamage * sdata.AbilityPowerEnemyMaxHealth;
}
if (sdata.Flags.HasFlag(DamageFlags.BaseAttackDamagePercent))
{
damage += @base.TotalAttackDamage
* sdata.BaseAttackDamagePercent[
Math.Min(spellLevel, sdata.BaseAttackDamagePercent.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.BaseChampionLevel))
{
damage += sdata.BaseChampionLevel[Math.Min(@base.Level, sdata.BaseChampionLevel.Length - 1)];
}
if (sdata.Flags.HasFlag(DamageFlags.MaxHealth))
{
damage += sdata.MaxHealth * @base.MaxHealth;
}
return @base.CalculateDamage(aiBase, sdata.Type, damage);
};
}
/// <summary>
/// Initializes a new instance of the <see cref="SpellDamage" /> class.
/// </summary>
/// <param name="sdata">
/// The spell damage data.
/// </param>
internal SpellDamage(SpellDamageData sdata)
{
this.SData = sdata;
this.GetDamageFunc = (@base, aiBase) =>
{
var spellLevel = @base.Spellbook.GetSpell(sdata.Slot).Level - 1;
var damage = 0d;
if (spellLevel >= 0)
{
damage += sdata.Base[Math.Min(spellLevel, sdata.Base.Length)];
}
if (sdata.Flags.HasFlag(DamageFlags.AbilityPower))
{
damage += @base.TotalMagicalDamage * sdata.AbilityPower;
}
if (sdata.Flags.HasFlag(DamageFlags.AttackDamage))
{
damage += @base.TotalAttackDamage * sdata.AttackDamage;
}
if (sdata.Flags.HasFlag(DamageFlags.BonusAttackDamage))
{
damage += @base.FlatPhysicalDamageMod * sdata.BonusAttackDamage;
}
return @base.CalculateDamage(aiBase, sdata.Type, damage);
};
}