public MagicDamage(string name, Character character, StatsRetri stats, DamageType damageType, bool noMultiplier = false) : base(name, character, stats, AbilityType.Spell, damageType, false, noMultiplier)
{
CT = new BaseSpellCombatTable(Character.BossOptions, _stats, Attacktype.Spell);
switch ((int)damageType)
{
case (int)DamageType.Holy:
AbilityDamage = stats.HolyDamage;
break;
case (int)DamageType.Fire:
AbilityDamage = stats.FireDamage;
break;
case (int)DamageType.Nature:
AbilityDamage = stats.NatureDamage;
break;
case (int)DamageType.Frost:
AbilityDamage = stats.FrostDamage;
break;
case (int)DamageType.Shadow:
AbilityDamage = stats.ShadowDamage;
break;
case (int)DamageType.Arcane:
AbilityDamage = stats.ArcaneDamage;
break;
default:
AbilityDamage = 0f;
break;
}
}
public JudgementOfTruth(Character character, StatsRetri stats, float averageStack) : base("Judgement of Truth", character, stats)
{
AverageStackSize = averageStack;
AbilityDamage += (_stats.SpellPower * PaladinConstants.JOT_JUDGE_COEFF_SP +
_stats.AttackPower * PaladinConstants.JOT_JUDGE_COEFF_AP)
* (1f + PaladinConstants.JOT_JUDGE_COEFF_STACK * AverageStackSize);
}
public DivineStorm(Character character, StatsRetri stats) : base("Divine Storm", character, stats, AbilityType.Melee, DamageType.Physical)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
Cooldown = PaladinConstants.DS_COOLDOWN / (Talents.SanctityOfBattle > 0 ? (1f + _stats.PhysicalHaste) : 1f);
MaxTargets = 100;
AbilityDamage = AbilityHelper.WeaponDamage(_character, _stats.AttackPower, true) * PaladinConstants.DS_DMG_BONUS;
}
public SealOfRighteousness(Character character, StatsRetri stats) : base("Seal of Righteousness", character, stats, AbilityType.Spell)
{
CT = new BaseSpellCombatTable(Character.BossOptions, _stats, Attacktype.Spell);
CT.CanMiss = false;
MaxTargets = 100;
AbilityDamage = AbilityHelper.BaseWeaponSpeed(_character) * (PaladinConstants.SOR_COEFF_AP * _stats.AttackPower +
PaladinConstants.SOR_COEFF_SP * _stats.SpellPower);
}
public Judgement(string name, Character character, StatsRetri stats) : base(name, character, stats, AbilityType.Range, DamageType.Holy)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.Ranged);
CT.AbilityCritCorr = Talents.ArbiterOfTheLight * PaladinConstants.ARBITER_OF_THE_LIGHT;
AbilityDamageMulitplier[Multiplier.Glyphs] = (1f + (Talents.GlyphOfJudgement ? PaladinConstants.GLYPH_OF_JUDGEMENT : 0f));
AbilityDamageMulitplier[Multiplier.Others] = (1f + PaladinConstants.TWO_H_SPEC);
Cooldown = PaladinConstants.JUDGE_COOLDOWN - _stats.JudgementCDReduction;
AbilityDamage = PaladinConstants.JUDGE_DMG;
}
public HammerOfWrath(Character character, StatsRetri stats) : base("Hammer of Wrath", character, stats, AbilityType.Range, DamageType.Holy)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.Ranged);
CT.AbilityCritCorr = Talents.SanctifiedWrath * PaladinConstants.SANCTIFIED_WRATH;
Cooldown = PaladinConstants.HOW_COOLDOWN;
AbilityDamage = PaladinConstants.HOW_AVG_DMG +
PaladinConstants.HOW_COEFF_SP * _stats.SpellPower +
PaladinConstants.HOW_COEFF_AP * _stats.AttackPower;
}
public GuardianOfTheAncientKings(Character character, StatsRetri stats) : base("Guardian of the ancient Kings", character, new StatsRetri(), AbilityType.Melee, DamageType.Physical, false)
{
CT = new BasePhysicalWhiteCombatTable(character.BossOptions, _stats, Attacktype.MeleeMH);
TickCount = PaladinConstants.GOAK_ATTACKS_PER_CAST;
AbilityDamageMulitplier.Remove(Multiplier.Others); //Remove Two handed Spec
AbilityDamage = 7000f;
//Final Cast
AddTrigger(new GuardianOfTheAncientKingsFinal(character, stats));
}
public HolyWrath(Character character, StatsRetri stats) : base("Holy Wrath", character, stats, AbilityType.Spell, DamageType.Holy)
{
CT = new BaseSpellCombatTable(Character.BossOptions, _stats, Attacktype.Spell);
CT.AbilityCritCorr = (Character.BossOptions.MobType == (int)MOB_TYPES.DEMON || Character.BossOptions.MobType == (int)MOB_TYPES.UNDEAD) ? 1f : 0;
Cooldown = PaladinConstants.HOLY_WRATH_COOLDOWN;
Meteor = true;
MaxTargets = 100;
AbilityDamage = PaladinConstants.HOLY_WRATH_BASE_DMG +
PaladinConstants.HOLY_WRATH_COEFF * _stats.SpellPower;
}
public HandofLight(Character character, StatsRetri stats, float amountBefore) : base("Hand of Light", character, stats, AbilityType.Spell, DamageType.Holy, false)
{
AmountBefore = amountBefore;
CT = new BaseSpellCombatTable(Character.BossOptions, _stats, Attacktype.Spell);
CT.CanMiss = false;
CT.CanCrit = false;
AbilityDamageMulitplier.Clear(); //Only benefit from Magical
AbilityDamageMulitplier[Multiplier.Magical] = (1f + _stats.BonusHolyDamageMultiplier) * (1f + InqUptime * PaladinConstants.INQ_COEFF);
AbilityDamage = AmountBefore * (8f + StatConversion.GetMasteryFromRating(_stats.MasteryRating, CharacterClass.Paladin)) * PaladinConstants.HOL_COEFF;
}
public SealOfTruthDoT(Character character, StatsRetri stats, float averageStack) : base("Seal of Truth DoT", character, stats, AbilityType.Melee, DamageType.Holy, false)
{
AverageStackSize = averageStack;
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
CT.CanMiss = false;
AbilityDamageMulitplier[Multiplier.Talents] = (1f + PaladinConstants.SEALS_OF_THE_PURE * Talents.SealsOfThePure +
PaladinConstants.INQUIRY_OF_FAITH_SEAL * Talents.InquiryOfFaith);
AbilityDamage = AverageStackSize * (_stats.AttackPower * PaladinConstants.SOT_CENSURE_COEFF_AP +
_stats.SpellPower * PaladinConstants.SOT_CENSURE_COEFF_SP);
}
public Exorcism(Character character, StatsRetri stats, float chanceToProc) : base("Exorcism", character, stats, AbilityType.Spell, DamageType.Holy)
{
CT = new BaseSpellCombatTable(Character.BossOptions, _stats, Attacktype.Spell);
CT.AbilityCritCorr = (Character.BossOptions.MobType == (int)MOB_TYPES.DEMON || Character.BossOptions.MobType == (int)MOB_TYPES.UNDEAD) ? 1f : 0;
AbilityDamageMulitplier[Multiplier.Talents] = (1f + (Talents.TheArtOfWar > 0 ? PaladinConstants.THE_ART_OF_WAR : 0f) +
PaladinConstants.BLAZING_LIGHT * Talents.BlazingLight);
AbilityDamageMulitplier[Multiplier.Glyphs] = (1f + (Talents.GlyphOfExorcism ? PaladinConstants.GLYPH_OF_EXORCISM : 0f));
Cooldown = AbilityHelper.WeaponSpeed(_character, _stats.PhysicalHaste) * (1f / (Talents.TheArtOfWar * PaladinConstants.EXO_PROC_CHANCE)) / chanceToProc;
AbilityDamage = PaladinConstants.EXO_AVG_DMG +
PaladinConstants.EXO_COEFF * Math.Max(_stats.SpellPower, _stats.AttackPower);
}
public Consecration(Character character, StatsRetri stats) : base("Consecration", character, stats, AbilityType.Spell, DamageType.Holy)
{
CT = new BaseSpellCombatTable(Character.BossOptions, _stats, Attacktype.Spell);
CT.CanCrit = false;
Cooldown = PaladinConstants.CONS_COOLDOWN;
TickCount = (Talents.GlyphOfConsecration ? 12f : 10f);
MaxTargets = 100;
AbilityDamage = (PaladinConstants.CONS_BASE_DMG +
PaladinConstants.CONS_COEFF_SP * _stats.SpellPower +
PaladinConstants.CONS_COEFF_AP * _stats.AttackPower)
/ 10;
}
public RotationCalculation(Character character, StatsRetri stats)
{
Character = character;
Stats = stats;
CalcOpts = character.CalculationOptions as CalculationOptionsRetribution;
dpChance = character.PaladinTalents.DivinePurpose * PaladinConstants.DP_CHANCE;
#region Initialization
casts[DamageAbility.Consecration] = 0f;
casts[DamageAbility.CrusaderStrike] = 0f;
casts[DamageAbility.Exorcism] = 0f;
casts[DamageAbility.Inquisition] = 0f;
casts[DamageAbility.HammerOfWrath] = 0f;
casts[DamageAbility.HolyWrath] = 0f;
casts[DamageAbility.Judgement] = 0f;
casts[DamageAbility.TemplarsVerdict] = 0f;
casts[DamageAbility.GoaK] = 0f;
skills[DamageAbility.CrusaderStrike] = new CrusaderStrike(Character, Stats);
skills[DamageAbility.TemplarsVerdict] = new TemplarsVerdict(Character, Stats);
skills[DamageAbility.White] = new White(Character, Stats);
skills[DamageAbility.Exorcism] = new Exorcism(Character, Stats, White.CT.ChanceToLand);
skills[DamageAbility.Inquisition] = new Inquisition(Character, Stats, CalcOpts.HPperInq);
skills[DamageAbility.HolyWrath] = new HolyWrath(Character, Stats);
skills[DamageAbility.HammerOfWrath] = new HammerOfWrath(Character, Stats);
skills[DamageAbility.Consecration] = new Consecration(Character, Stats);
skills[DamageAbility.GoaK] = new GuardianOfTheAncientKings(Character, Stats);
skills[DamageAbility.SoC] = new SealOfCommand(Character, Stats);
switch (CalcOpts.Seal)
{
case SealOf.Righteousness:
skills[DamageAbility.Seal] = new SealOfRighteousness(Character, Stats);
skills[DamageAbility.SealDot] = new NullSealDoT(Character, Stats);
skills[DamageAbility.Judgement] = new JudgementOfRighteousness(Character, Stats);
break;
case SealOf.Truth:
skills[DamageAbility.Seal] = new SealOfTruth(Character, Stats);
skills[DamageAbility.SealDot] = new SealOfTruthDoT(Character, Stats, 5f);
skills[DamageAbility.Judgement] = new JudgementOfTruth(Character, Stats, 5f);
break;
default:
skills[DamageAbility.Seal] = new NullSeal(Character, Stats);
skills[DamageAbility.SealDot] = new NullSealDoT(Character, Stats);
skills[DamageAbility.Judgement] = new NullJudgement(Character, Stats);
break;
}
#endregion
CalcRotation();
}
public TemplarsVerdict(Character character, StatsRetri stats) : base("Templar's Verdict", character, stats, AbilityType.Melee, DamageType.Physical)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
CT.AbilityCritCorr = Talents.ArbiterOfTheLight * PaladinConstants.ARBITER_OF_THE_LIGHT;
AbilityDamageMulitplier[Multiplier.Talents] = (1f + PaladinConstants.CRUSADE * Talents.Crusade);
AbilityDamageMulitplier[Multiplier.Glyphs] = (1f + (Talents.GlyphOfTemplarsVerdict ? PaladinConstants.GLYPH_OF_TEMPLARS_VERDICT : .0f));
AbilityDamageMulitplier[Multiplier.Sets] = (1f + (Stats.T11_2P ? .1f : 0f));
AbilityDamage = AbilityHelper.WeaponDamage(Character, _stats.AttackPower) * PaladinConstants.TV_THREE_STK;
//Hand of Light
AddTrigger(new HandofLight(Character, Stats, AverageDamage));
}
public RotationCalculation(Character character, StatsRetri stats)
{
Character = character;
Stats = stats;
CalcOpts = character.CalculationOptions as CalculationOptionsRetribution;
dpChance = character.PaladinTalents.DivinePurpose * PaladinConstants.DP_CHANCE;
#region Initialization
casts[DamageAbility.Consecration] = 0f;
casts[DamageAbility.CrusaderStrike] = 0f;
casts[DamageAbility.Exorcism] = 0f;
casts[DamageAbility.Inquisition] = 0f;
casts[DamageAbility.HammerOfWrath] = 0f;
casts[DamageAbility.HolyWrath] = 0f;
casts[DamageAbility.Judgement] = 0f;
casts[DamageAbility.TemplarsVerdict] = 0f;
casts[DamageAbility.GoaK] = 0f;
skills[DamageAbility.CrusaderStrike] = new CrusaderStrike(Character, Stats);
skills[DamageAbility.TemplarsVerdict] = new TemplarsVerdict(Character, Stats);
skills[DamageAbility.White] = new White(Character, Stats);
skills[DamageAbility.Exorcism] = new Exorcism(Character, Stats, White.CT.ChanceToLand);
skills[DamageAbility.Inquisition] = new Inquisition(Character, Stats, CalcOpts.HPperInq);
skills[DamageAbility.HolyWrath] = new HolyWrath(Character, Stats);
skills[DamageAbility.HammerOfWrath] = new HammerOfWrath(Character, Stats);
skills[DamageAbility.Consecration] = new Consecration(Character, Stats);
skills[DamageAbility.GoaK] = new GuardianOfTheAncientKings(Character, Stats);
skills[DamageAbility.SoC] = new SealOfCommand(Character, Stats);
switch (CalcOpts.Seal)
{
case SealOf.Righteousness:
skills[DamageAbility.Seal] = new SealOfRighteousness(Character, Stats);
skills[DamageAbility.SealDot] = new NullSealDoT(Character, Stats);
skills[DamageAbility.Judgement] = new JudgementOfRighteousness(Character, Stats);
break;
case SealOf.Truth:
skills[DamageAbility.Seal] = new SealOfTruth(Character, Stats);
skills[DamageAbility.SealDot] = new SealOfTruthDoT(Character, Stats, 5f);
skills[DamageAbility.Judgement] = new JudgementOfTruth(Character, Stats, 5f);
break;
default:
skills[DamageAbility.Seal] = new NullSeal(Character, Stats);
skills[DamageAbility.SealDot] = new NullSealDoT(Character, Stats);
skills[DamageAbility.Judgement] = new NullJudgement(Character, Stats);
break;
}
#endregion
CalcRotation();
}
public CrusaderStrike(Character character, StatsRetri stats) : base("Crusader Strike", character, stats, AbilityType.Melee, DamageType.Physical, true)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
CT.AbilityCritCorr = Talents.RuleOfLaw * PaladinConstants.RULE_OF_LAW +
(Talents.GlyphOfCrusaderStrike ? PaladinConstants.GLYPH_OF_CRUSADER_STRIKE : 0);
AbilityDamageMulitplier[Multiplier.Talents] = (1f + PaladinConstants.CRUSADE * Talents.Crusade);
AbilityDamageMulitplier[Multiplier.Sets] = (1f + Stats.BonusDamageMultiplierCrusaderStrike);
Cooldown = PaladinConstants.CS_COOLDOWN / (Talents.SanctityOfBattle > 0 ? (1f + _stats.SpellHaste) : 1f);
AbilityDamage = AbilityHelper.WeaponDamage(_character, _stats.AttackPower, true) * PaladinConstants.CS_DMG_BONUS;
if (_stats.T12_2P)
{
MagicDamage spell = new MagicDamage("T12 2P Bonus", _character, new StatsRetri(), DamageType.Fire, true);
spell.CT.CanCrit = false;
spell.CT.CanMiss = false;
spell.AbilityDamage = AverageDamage * .15f;
AddTrigger(spell);
}
//Hand of Light
AddTrigger(new HandofLight(Character, Stats, AverageDamage));
_CycleTime = GCD * 2f + (1.5f / (1 + Stats.SpellHaste) + Latency);
}
public SealOfTruth(Character character, StatsRetri stats) : base("Seal of Truth", character, stats, AbilityType.Melee)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
CT.CanMiss = false;
AbilityDamage = AbilityHelper.WeaponDamage(_character, _stats.AttackPower) * PaladinConstants.SOT_SEAL_COEFF;
}
public StatsRetri GetCharacterStats(Character character, Item additionalItem, bool computeAverageStats)
{
PaladinTalents talents = character.PaladinTalents;
CalculationOptionsRetribution calcOpts = character.CalculationOptions as CalculationOptionsRetribution;
StatsRetri stats = new StatsRetri();
stats.Accumulate(BaseStats.GetBaseStats(character.Level, CharacterClass.Paladin, character.Race)); //Race
stats.Accumulate(GetItemStats(character, additionalItem)); //Items
stats.Accumulate(GetBuffsStats(character, calcOpts)); //Buffs
// Adjust expertise for racial passive
stats.Expertise += BaseStats.GetRacialExpertise(character, ItemSlot.MainHand);
// Judgements of the pure (Flat because it has nearly always a 100% chance.
stats.PhysicalHaste += PaladinConstants.JUDGEMENTS_OF_THE_PURE * talents.JudgementsOfThePure;
stats.SpellHaste += PaladinConstants.JUDGEMENTS_OF_THE_PURE * talents.JudgementsOfThePure;
//Sets
stats.SetSets(character);
// If wanted, Average out any Proc and OnUse effects into the stats
if (computeAverageStats)
{
StatsRetri statsTmp = stats.Clone();
ConvertRatings(statsTmp, talents, character);// Convert ratings so we have right value for haste, weaponspeed and talents etc.
RotationCalculation rot = CreateRotation(character, statsTmp);
Dictionary<Trigger, float> triggerIntervals = new Dictionary<Trigger, float>();
Dictionary<Trigger, float> triggerChances = new Dictionary<Trigger, float>();
CalculateTriggers(triggerIntervals, triggerChances, rot);
//Talent special effects
//GoaK Strength
stats.AddSpecialEffect(_GoakSE);
// Average out proc effects, and add to global stats.
Stats statsAverage = new Stats();
foreach (SpecialEffect effect in stats.SpecialEffects())
statsAverage.Accumulate(effect.GetAverageStats(triggerIntervals, triggerChances, AbilityHelper.BaseWeaponSpeed(character), character.BossOptions.BerserkTimer));
stats.Accumulate(statsAverage);
}
// No negative values (from possible charts)
if (stats.Strength < 0)
stats.Strength = 0;
if (stats.Agility < 0)
stats.Agility = 0;
if (stats.AttackPower < 0)
stats.AttackPower = 0;
if (stats.ExpertiseRating < 0)
stats.ExpertiseRating = 0;
if (stats.HitRating < 0)
stats.HitRating = 0;
if (stats.CritRating < 0)
stats.CritRating = 0;
if (stats.HasteRating < 0)
stats.HasteRating = 0;
if (stats.SpellPower < 0)
stats.SpellPower = 0;
if (stats.MasteryRating < 0)
stats.MasteryRating = 0;
// ConvertRatings needs to be done AFTER accounting for the averaged stats, since stat multipliers
// should affect the averaged stats also.
ConvertRatings(stats, talents, character);
return stats;
}
public RotationCalculation CreateRotation(Character character, StatsRetri stats)
{
return new RotationCalculation(character, stats);
}
public Inquisition(Character character, StatsRetri stats, int hp) : base("Inquisition", character, stats, AbilityType.Spell, DamageType.Holy)
{
HP = hp;
Cooldown = Duration;
}
public GuardianOfTheAncientKingsFinal(Character character, StatsRetri stats) : base("Ancient Fury", character, stats, AbilityType.Spell, DamageType.Holy, false)
{
CT = new BaseSpellCombatTable(character.BossOptions, _stats, Attacktype.Spell);
AbilityDamage = (PaladinConstants.AF_BASE_DMG * 20f) +
PaladinConstants.AF_COEFF_AP * _stats.AttackPower;
}
public JudgementOfRighteousness(Character character, StatsRetri stats) : base("Judgement of Righteousness", character, stats)
{
AbilityDamage += _stats.SpellPower * PaladinConstants.JOR_COEFF_SP +
_stats.AttackPower * PaladinConstants.JOR_COEFF_AP;
}
public SealOfCommand(Character character, StatsRetri stats) : base("Seal of Command", character, stats, AbilityType.Melee, DamageType.Holy, false)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
AbilityDamageMulitplier[Multiplier.Others] = (1f + PaladinConstants.TWO_H_SPEC);
AbilityDamage = (Talents.SealsOfCommand > 0 ? AbilityHelper.WeaponDamage(_character, _stats.AttackPower) * PaladinConstants.SOC_COEFF : 0f);
}
public Seal(string name, Character character, StatsRetri stats, AbilityType abilityType) : base(name, character, stats, abilityType, DamageType.Holy, false)
{
AbilityDamageMulitplier[Multiplier.Talents] = (1f + PaladinConstants.SEALS_OF_THE_PURE * Talents.SealsOfThePure);
AbilityDamageMulitplier[Multiplier.Others] = (1f + PaladinConstants.TWO_H_SPEC);
}
public NullJudgement(Character character, StatsRetri stats) : base("Judgement", character, stats)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.Ranged);
AbilityDamage = 0;
}
public NullSealDoT(Character character, StatsRetri stats) : base("Seal Dot", character, stats, AbilityType.Melee, DamageType.Holy)
{
CT = new BasePhysicalYellowCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
AbilityDamage = 0;
}
public White(Character character, StatsRetri stats) : base("Autoattack", character, stats, AbilityType.Melee, DamageType.Physical, false)
{
CT = new BasePhysicalWhiteCombatTable(Character.BossOptions, _stats, Attacktype.MeleeMH);
AbilityDamage = AbilityHelper.WeaponDamage(_character, _stats.AttackPower);
}