private double computeHastedCastTimeRaw(double timeMS)
{
double hastedTimeMS = 0;
int n = HasteProcUptimes.Length;
int maxmask = 1 << n;
for (int i = 0; i < maxmask; ++i)
{
int hasteRating = 0;
double hasteFactor = (1 + Haste);
double fraction = 1.0;
for (int j = 0; j < n; ++j)
{
if ((i & (1 << j)) != 0)
{
hasteRating += HasteProcRatings[j];
hasteFactor *= HasteProcMultipliers[j];
fraction *= HasteProcUptimes[j];
}
else
{
fraction *= 1 - HasteProcUptimes[j];
}
}
double hasteRatingMult = 1.0f + StatConversion.GetSpellHasteFromRating((float)(HasteRating + hasteRating));
hasteFactor *= hasteRatingMult;
hastedTimeMS += fraction * Math.Max(timeMS / hasteFactor, 1000);
}
return(hastedTimeMS / 1000.0);
}
public static float CalcSpellHaste(Stats stats)
{
return((1f + stats.SpellHaste)
* (1f
+ StatConversion.GetSpellHasteFromRating(
stats.HasteRating)));
}
public virtual void Initialize(ISpellArgs args)
{
float Speed = (1f + args.Stats.SpellHaste) * (1f + StatConversion.GetSpellHasteFromRating(args.Stats.HasteRating));
gcd = (float)Math.Round(gcd / Speed, 4);
castTime = (float)Math.Round(castTime / Speed, 4);
latencyGcd = args.LatencyGCD;
latencyCast = args.LatencyCast;
critModifier += .2f * args.Talents.ElementalFury;
critModifier *= (float)Math.Round(1.5f * (1f + args.Stats.BonusSpellCritMultiplier) - 1f, 6);
dotCritModifier += .2f * args.Talents.ElementalFury;
dotCritModifier *= (float)Math.Round(1.5f * (1f + args.Stats.BonusSpellCritMultiplier) - 1f, 6);
//critModifier += 1f;
spellPower += args.Stats.SpellPower;
crit += args.Stats.SpellCrit;
missChance -= args.Stats.SpellHit;
totalCoef *= 1 + args.Stats.BonusDamageMultiplier; //ret + bm buff
if (missChance < 0)
{
missChance = 0;
}
manaCost = (float)Math.Floor(manaCost);
//base resistance by level
totalCoef *= 1f - StatConversion.GetAverageResistance(80, 83, 0, 0);
}
public virtual void applyStats(Stats stats)
{
speed = (1 + StatConversion.GetSpellHasteFromRating(stats.HasteRating)) * (1 + stats.SpellHaste);
critModifier = 1.5f * (1f + stats.BonusCritHealMultiplier);
healModifier = (1f + stats.BonusHealingDoneMultiplier);
extraHealing = stats.BonusHealingReceived;
applyHaste();
}
public override Stats GetCharacterStats(Character character, Item additionalItem)
{
CalculationOptionsHealPriest calcOpts = character.CalculationOptions as CalculationOptionsHealPriest;
StatsPriest statsTotal = new StatsPriest()
{
SpellHaste = PriestInformation.GetDarkness(character.PriestTalents.Darkness),
InnerFire = true,
BonusIntellectMultiplier = 0.05f, // Cloth bonus.
PriestSpec = PriestSpec.GetPriestSpec(character.PriestTalents),
};
if (statsTotal.PriestSpec == ePriestSpec.Spec_Disc)
{
statsTotal.SpellCombatManaRegeneration = 0.5f;
statsTotal.BonusIntellectMultiplier = 0.15f;
}
else if (statsTotal.PriestSpec == ePriestSpec.Spec_Holy)
{
statsTotal.SpellCombatManaRegeneration = 0.5f + PriestInformation.GetHolyConcentration(character.PriestTalents.HolyConcentration);
statsTotal.BonusHealingDoneMultiplier = 0.15f;
}
else if (statsTotal.PriestSpec == ePriestSpec.Spec_ERROR)
{
throw new Exception("Unpossible Talent Spec!");
}
statsTotal.Accumulate(BaseStats.GetBaseStats(character));
statsTotal.Accumulate(GetItemStats(character, additionalItem));
statsTotal.Accumulate(GetBuffsStats(character, calcOpts));
statsTotal.Stamina = (float)Math.Floor((statsTotal.Stamina) * (1 + statsTotal.BonusStaminaMultiplier));
statsTotal.Intellect = (float)Math.Floor((statsTotal.Intellect) * (1 + statsTotal.BonusIntellectMultiplier));
statsTotal.Spirit = (float)Math.Floor((statsTotal.Spirit) * (1 + statsTotal.BonusSpiritMultiplier));
statsTotal.SpellPower += (statsTotal.InnerFire ? PriestInformation.GetInnerFireSpellPowerBonus(character) : 0) + (statsTotal.Intellect - 10);
statsTotal.SpellPower *= (1f + statsTotal.BonusSpellPowerMultiplier);
statsTotal.Mana += StatConversion.GetManaFromIntellect(statsTotal.Intellect);
statsTotal.Mana *= (1f + statsTotal.BonusManaMultiplier);
statsTotal.Health += StatConversion.GetHealthFromStamina(statsTotal.Stamina);
statsTotal.Health = (float)Math.Floor(statsTotal.Health * (1f + statsTotal.BonusHealthMultiplier));
statsTotal.SpellCrit += StatConversion.GetSpellCritFromIntellect(statsTotal.Intellect)
+ StatConversion.GetSpellCritFromRating(statsTotal.CritRating);
statsTotal.SpellHaste = (1f + statsTotal.SpellHaste) * (1f + StatConversion.GetSpellHasteFromRating(statsTotal.HasteRating)) - 1f;
statsTotal.Armor *= (1 + (statsTotal.InnerFire ? PriestInformation.GetInnerFireArmorBonus(character) : 0));
if (statsTotal.PriestSpec == ePriestSpec.Spec_Disc)
{
statsTotal.ShieldDiscipline = (PriestInformation.DisciplineMasteryBase + StatConversion.GetMasteryFromRating(statsTotal.MasteryRating)) * PriestInformation.DisciplineMasteryEffect;
}
else if (statsTotal.PriestSpec == ePriestSpec.Spec_Holy)
{
statsTotal.EchoofLight = (PriestInformation.HolyMasteryBase + StatConversion.GetMasteryFromRating(statsTotal.MasteryRating)) * PriestInformation.HolyMasteryEffect;
}
return(statsTotal);
}
public void ApplyDotHaste(ISpellArgs args)
{
float Speed = (1f + args.Stats.SpellHaste) * (1f + StatConversion.GetSpellHasteFromRating(args.Stats.HasteRating));
periodicTickTime = (float)Math.Round(periodicTickTime / Speed, 4);
// Enough haste adds more ticks.
while (((periodicTicks + 1) * periodicTickTime) <= (baseDuration))
{
periodicTicks++;
}
}
protected override string ToStringDirectHeal()
{
float nonRatingHaste = (1f + stats.SpellHaste) / (1f + StatConversion.GetSpellHasteFromRating(stats.HasteRating));
// Check how much haste is needed to gain an additional tick.
float extraTickHaste = (OverTimeTicks + 0.5f) / BaseOverTimeTicks;
float extraHasteRating = (extraTickHaste / nonRatingHaste - 1f) / StatConversion.GetSpellHasteFromRating(1f) - stats.HasteRating;
return(String.Format("{0}\n{1} more Haste Rating needed for an additional tick.",
base.ToStringDirectHeal(),
extraHasteRating.ToString("0")));
}
public static float GetSpellHasteFromRating(float rating, int playerLevel)
{
if (playerLevel == 85)
{
return(StatConversion.GetSpellHasteFromRating(rating));
}
else
{
float[] scaling = { 32.789989471435547f, 43.056015014648438f, 56.539749145507812f, 74.275451660156250f, 97.527236938476562f };
return(rating / scaling[playerLevel - 80] * 0.01f);
}
}
public static float CalcSpellHaste(Stats stats, int playerLevel)
{
if (playerLevel == 85)
{
return((1f + stats.SpellHaste)
* (1f + StatConversion.GetSpellHasteFromRating(stats.HasteRating)));
}
else
{
return((1f + stats.SpellHaste)
* (1f + GetSpellHasteFromRating(stats.HasteRating, playerLevel)));
}
}
private void ConvertRatings(Stats stats, PaladinTalents talents, CalculationOptionsHealadin calcOpts)
{
stats.Stamina *= 1f + stats.BonusStaminaMultiplier;
// Intellect is used to calculate initial mana pool.
// To avoid temporary intellect from highest stat procs changing initial mana pool
// we track temporary intellect separatly in HighestStat property and combine it with intellect
// when needed.
// TODO: However this doesn't help to deal with pure temporary intellect procs (if there are any).
// NOTE: If we add highest stat to intellect after we calculate mana, the only visible change
// will be the displayed intellect for the character.
stats.Intellect *= (1f + stats.BonusIntellectMultiplier);
stats.HighestStat *= (1f + stats.BonusIntellectMultiplier);
stats.SpellCrit = stats.SpellCrit +
StatConversion.GetSpellCritFromIntellect(
stats.Intellect + stats.HighestStat,
CharacterClass.Paladin) +
StatConversion.GetSpellCritFromRating(stats.CritRating, CharacterClass.Paladin);
// I want to track haste before talent seperately, going to use RangedHaste for that.
// I plan to use this on the "Stats" page so I can report sources of haste seperatly
stats.RangedHaste = (1f + stats.SpellHaste) *
(1f + StatConversion.GetSpellHasteFromRating(stats.HasteRating, CharacterClass.Paladin))
- 1f;
// calculating physical haste for use in melee attacks, which will generate mana
// can also divide spellhaste / physicalhaste to get orignal value of spellhaste, which is from buffs as far as I can tell
stats.PhysicalHaste = (1f + talents.JudgementsOfThePure * 0.03f) *
(1f + talents.SpeedOfLight * 0.01f) *
(1f + StatConversion.GetSpellHasteFromRating(stats.HasteRating, CharacterClass.Paladin))
- 1f;
stats.SpellHaste = (1f + talents.JudgementsOfThePure * 0.03f) *
(1f + talents.SpeedOfLight * 0.01f) *
(1f + stats.SpellHaste) *
(1f + StatConversion.GetSpellHasteFromRating(stats.HasteRating, CharacterClass.Paladin))
- 1f;
// GetManaFromIntellect/GetHealthFromStamina account for the fact
// that the first 20 Int/Sta only give 1 Mana/Health each.
stats.Mana += StatConversion.GetManaFromIntellect(stats.Intellect, CharacterClass.Paladin) *
(1f + stats.BonusManaMultiplier);
stats.Health += StatConversion.GetHealthFromStamina(stats.Stamina, CharacterClass.Paladin);
stats.PhysicalHit += StatConversion.GetPhysicalHitFromRating(
stats.HitRating,
CharacterClass.Paladin);
}
public double ComputeTicks(double baseTickRateMS, double baseDurationMS, out double duration, out double tps)
{
//tickRateMS = 0;
double ticks = 0;
tps = 0;
duration = 0;
int n = HasteProcUptimes.Length;
int maxmask = 1 << n;
for (int i = 0; i < maxmask; ++i)
{
int hasteRating = 0;
double hasteFactor = (1 + Haste);
double fraction = 1.0;
for (int j = 0; j < n; ++j)
{
if ((i & (1 << j)) != 0)
{
hasteRating += HasteProcRatings[j];
hasteFactor *= HasteProcMultipliers[j];
fraction *= HasteProcUptimes[j];
}
else
{
fraction *= 1 - HasteProcUptimes[j];
}
}
// spell haste and physical haste are actually identically computed in Cataclysm
double hasteRatingMult = 1.0f + StatConversion.GetSpellHasteFromRating((float)(HasteRating + hasteRating));
hasteFactor *= hasteRatingMult;
double curTickRateMS = baseTickRateMS / hasteFactor;
double curTicks = (double)Math.Ceiling(baseDurationMS / (double)Math.Round(curTickRateMS) - 0.5f);
//tickRateMS += fraction * curTickRateMS;
ticks += fraction * curTicks;
tps += fraction * (1.0 / curTickRateMS);
duration += fraction * curTicks * curTickRateMS;
}
duration /= 1000.0;
tps *= 1000.0;
return(ticks);
}
/// <summary>
/// Initialize Spell based on ISpellArgs
/// </summary>
/// <param name="args"></param>
public virtual void Initialize(ISpellArgs args)
{
float Speed = (1f + args.Stats.SpellHaste) * (1f + StatConversion.GetSpellHasteFromRating(args.Stats.HasteRating));
gcd = (float)Math.Round(gcd / Speed, 4);
castTimeBase = (float)Math.Round(castTimeBase / Speed, 4);
latencyGcd = args.LatencyGCD;
latencyCast = args.LatencyCast;
critModifier *= (float)Math.Round(1.5f + args.Stats.BonusSpellCritDamageMultiplier, 6);
//critModifier += 1f;
spellPower += args.Stats.SpellPower;
crit += args.Stats.SpellCrit;
missChance -= args.Stats.SpellHit;
//totalCoef *= 1 + args.Stats.BonusDamageMultiplier; //ret + bm + arcane buff
if (missChance < 0)
{
missChance = 0;
}
manaCost = (float)Math.Floor(manaCost);
//TODO: base resistance by level depending on what bossis being battled
//totalCoef *= 1f - StatConversion.GetAverageResistance(85, 87, 0, 0);
}
private void ConvertRatings(Stats stats, PaladinTalents talents, CalculationOptionsHealadin calcOpts)
{
stats.Stamina *= 1f + stats.BonusStaminaMultiplier;
// Intellect is used to calculate initial mana pool.
// To avoid temporary intellect from highest stat procs changing initial mana pool
// we track temporary intellect separatly in HighestStat property and combine it with intellect
// when needed.
// TODO: However this doesn't help to deal with pure temporary intellect procs (if there are any).
// NOTE: If we add highest stat to intellect after we calculate mana, the only visible change
// will be the displayed intellect for the character.
stats.Intellect *= (1f + stats.BonusIntellectMultiplier) * (1f + talents.DivineIntellect * .02f);
stats.HighestStat *= (1f + stats.BonusIntellectMultiplier) * (1f + talents.DivineIntellect * .02f);
stats.SpellPower += 0.04f * (stats.Intellect + stats.HighestStat) * talents.HolyGuidance;
stats.SpellCrit = stats.SpellCrit +
StatConversion.GetSpellCritFromIntellect(
stats.Intellect + stats.HighestStat,
CharacterClass.Paladin) +
StatConversion.GetSpellCritFromRating(stats.CritRating, CharacterClass.Paladin) +
talents.SanctityOfBattle * .01f +
talents.Conviction * .01f;
stats.SpellHaste = (1f + talents.JudgementsOfThePure * (calcOpts.JotP ? .03f : 0f)) *
(1f + stats.SpellHaste) *
(1f + StatConversion.GetSpellHasteFromRating(stats.HasteRating, CharacterClass.Paladin))
- 1f;
// GetManaFromIntellect/GetHealthFromStamina account for the fact
// that the first 20 Int/Sta only give 1 Mana/Health each.
stats.Mana += StatConversion.GetManaFromIntellect(stats.Intellect, CharacterClass.Paladin) *
(1f + stats.BonusManaMultiplier);
stats.Health += StatConversion.GetHealthFromStamina(stats.Stamina, CharacterClass.Paladin);
stats.PhysicalHit += StatConversion.GetPhysicalHitFromRating(
stats.HitRating,
CharacterClass.Paladin);
}
public void UpdateCalcs(bool firstPass)
{
// talents
callOfThunder = .05f * _talents.CallOfThunder;
critMultiplierMelee = 2f * (1 + _stats.BonusCritMultiplier);
critMultiplierSpell = (1.5f + .1f * _character.ShamanTalents.ElementalFury) * (1 + _stats.BonusSpellCritMultiplier);
// Melee
float hitBonus = _stats.PhysicalHit + StatConversion.GetHitFromRating(_stats.HitRating) + 0.02f * _talents.DualWieldSpecialization;
expertiseBonusMH = GetDPRfromExp(_stats.Expertise + StatConversion.GetExpertiseFromRating(_stats.ExpertiseRating));
expertiseBonusOH = GetDPRfromExp(_stats.Expertise + StatConversion.GetExpertiseFromRating(_stats.ExpertiseRating));
// Need to modify expertiseBonusMH & OH if Orc and have racial bonus weapons
if (_character.Race == CharacterRace.Orc)
{
ItemType mhType = _character.MainHand == null ? ItemType.None : _character.MainHand.Type;
ItemType ohType = _character.OffHand == null ? ItemType.None : _character.OffHand.Type;
if (mhType == ItemType.OneHandAxe || mhType == ItemType.FistWeapon) // patch 3.2 includes fists
{
expertiseBonusMH += 0.0125f;
}
if (ohType == ItemType.OneHandAxe || ohType == ItemType.FistWeapon) // patch 3.2 includes fists
{
expertiseBonusOH += 0.0125f;
}
}
float meleeCritModifier = _stats.PhysicalCrit;
float baseMeleeCrit = StatConversion.GetCritFromRating(_stats.CritRating) +
StatConversion.GetCritFromAgility(_stats.Agility, _character.Class) + .01f * _talents.ThunderingStrikes;
chanceDodgeMH = Math.Max(0f, DodgeChanceCap - expertiseBonusMH);
chanceDodgeOH = Math.Max(0f, DodgeChanceCap - expertiseBonusOH);
float ParryChance = ParryChanceCap - expertiseBonusMH;
chanceParryMH = (float)Math.Max(0f, _calcOpts.InBack ? ParryChance * (1f - _calcOpts.InBackPerc / 100f) : ParryChance);
ParryChance = ParryChanceCap - expertiseBonusOH;
chanceParryOH = (float)Math.Max(0f, _calcOpts.InBack ? ParryChance * (1f - _calcOpts.InBackPerc / 100f) : ParryChance);
chanceWhiteMissMH = Math.Max(0f, WhiteHitCap - hitBonus) + chanceDodgeMH + chanceParryMH;
chanceWhiteMissOH = Math.Max(0f, WhiteHitCap - hitBonus) + chanceDodgeOH + chanceParryOH;
chanceYellowMissMH = Math.Max(0f, YellowHitCap - hitBonus) + chanceDodgeMH + chanceParryMH; // base miss 8% now
chanceYellowMissOH = Math.Max(0f, YellowHitCap - hitBonus) + chanceDodgeOH + chanceParryOH; // base miss 8% now
// SetCritValues((1 + _stats.BonusCritChance) * (baseMeleeCrit + meleeCritModifier) + .00005f); //fudge factor for rounding
SetCritValues(baseMeleeCrit + meleeCritModifier + .00005f); //fudge factor for rounding
// set two export values so that ED crit isn't included
exportMeleeCritMH = chanceWhiteCritMH + whiteCritDepression;
exportMeleeCritOH = chanceWhiteCritOH + whiteCritDepression;
// Spells
ftBonusCrit = 0f;
if (_calcOpts.MainhandImbue == "Flametongue")
{
ftBonusCrit += _talents.GlyphofFlametongueWeapon ? .02f : 0f;
}
if (_calcOpts.OffhandImbue == "Flametongue" && _talents.DualWield == 1)
{
ftBonusCrit += _talents.GlyphofFlametongueWeapon ? .02f : 0f;
}
float spellCritModifier = _stats.SpellCrit + _stats.SpellCritOnTarget + ftBonusCrit;
float hitBonusSpell = _stats.SpellHit + StatConversion.GetSpellHitFromRating(_stats.HitRating);
chanceSpellMiss = Math.Max(0f, SpellMissRate - hitBonusSpell);
overSpellHitCap = Math.Max(0f, hitBonusSpell - SpellMissRate);
float baseSpellCrit = StatConversion.GetSpellCritFromRating(_stats.CritRating) +
StatConversion.GetSpellCritFromIntellect(_stats.Intellect) + .01f * _talents.ThunderingStrikes;
//chanceSpellCrit = Math.Min(0.75f, (1 + _stats.BonusCritChance) * (baseSpellCrit + spellCritModifier) + .00005f); //fudge factor for rounding
chanceSpellCrit = Math.Min(0.75f, baseSpellCrit + spellCritModifier + .00005f); //fudge factor for rounding
float hasteBonus = StatConversion.GetHasteFromRating(_stats.HasteRating, _character.Class);
unhastedMHSpeed = _character.MainHand == null ? 3.0f : _character.MainHand.Item.Speed;
unhastedOHSpeed = _character.OffHand == null ? 3.0f : _character.OffHand.Item.Speed;
float baseHastedMHSpeed = unhastedMHSpeed / (1f + hasteBonus) / (1f + _stats.PhysicalHaste);
float baseHastedOHSpeed = unhastedOHSpeed / (1f + hasteBonus) / (1f + _stats.PhysicalHaste);
float chanceToProcWFPerHit = .2f + (_character.ShamanTalents.GlyphofWindfuryWeapon ? .02f : 0f);
//The Swing Loop
//This is where we figure out feedback systems -- WF, MW, ED, Flurry, etc.
//--------------
flurryUptime = 1f;
edUptime = 0f;
float stormstrikeSpeed = firstPass ? (_talents.Stormstrike == 1 ? 8f : 0f) : AbilityCooldown(EnhanceAbility.StormStrike);
float shockSpeed = firstPass ? BaseShockSpeed : AbilityCooldown(EnhanceAbility.EarthShock);
float lavaLashSpeed = firstPass ? (_talents.LavaLash == 1 ? 6f : 0f) : AbilityCooldown(EnhanceAbility.LavaLash);
float fireNovaSpeed = firstPass ? BaseFireNovaSpeed : AbilityCooldown(EnhanceAbility.FireNova);
if (_calcOpts.PriorityInUse(EnhanceAbility.MagmaTotem))
{
fireTotemUptime = firstPass ? 1.0f : 20f / AbilityCooldown(EnhanceAbility.MagmaTotem);
}
else if (_calcOpts.PriorityInUse(EnhanceAbility.SearingTotem))
{
fireTotemUptime = firstPass ? 1.0f : 60f / AbilityCooldown(EnhanceAbility.SearingTotem);
}
else if (_calcOpts.PriorityInUse(EnhanceAbility.RefreshTotems)) // if no Searing or Magma totem use refresh of Flametongue totem.
{
fireTotemUptime = firstPass ? 1.0f : 300f / AbilityCooldown(EnhanceAbility.RefreshTotems);
}
float mwPPM = 2 * _talents.MaelstromWeapon * (1 + _stats.Enhance4T8 * 0.2f);
float flurryHasteBonus = .06f * _talents.Flurry + _stats.Enhance4T7;
float edCritBonus = .03f * _talents.ElementalDevastation;
float staticShockChance = (.02f * _character.ShamanTalents.StaticShock + (_stats.Enhance2T9 == 1f ? 0.03f : 0f));
hitsPerSMHSS = 0f;
hitsPerSOHSS = 0f;
hitsPerSOH = 0f;
hitsPerSMH = 0f;
hitsPerSWF = 0f;
if (_talents.Stormstrike == 1)
{
hitsPerSMHSS = (1f - chanceYellowMissMH) / stormstrikeSpeed;
hitsPerSOHSS = _character.ShamanTalents.DualWield == 1 ? ((1f - 2 * chanceYellowMissOH) / stormstrikeSpeed) : 0f; //OH only swings if MH connects
}
hitsPerSLL = lavaLashSpeed == 0 ? 0f : (1f - chanceYellowMissOH) / lavaLashSpeed;
float swingsPerSMHMelee = 0f;
float swingsPerSOHMelee = 0f;
float wfProcsPerSecond = 0f;
float mwProcsPerSecond = 0f;
secondsToFiveStack = 10f;
float averageMeleeCritChance = (chanceWhiteCritMH + chanceWhiteCritOH + chanceYellowCritMH + chanceYellowCritOH) / 4f;
float averageMeleeHitChance = ((1f - chanceWhiteMissMH - chanceDodgeMH - chanceParryMH) + (1f - chanceWhiteMissOH - chanceDodgeOH - chanceParryOH)) / 2f;
float averageMeleeMissChance = (chanceWhiteMissMH + chanceWhiteMissOH) / 2f;
float whiteHitsPerSMH = 0f;
float whiteHitsPerSOH = 0f;
float moteHitsPerS = 0f;
float yellowHitsPerSMH = 0f;
float yellowHitsPerSOH = 0f;
float flameTongueHitsPerSecond = 0f;
for (int i = 0; i < 5; i++)
{
// float bonusHaste = (1f + (flurryUptime * flurryHasteBonus));
float bonusHaste = 1 / (1 - flurryUptime + flurryUptime / (1 + flurryHasteBonus)); // use time based not proc based flurryUptime
hastedMHSpeed = baseHastedMHSpeed / bonusHaste;
hastedOHSpeed = baseHastedOHSpeed / bonusHaste;
swingsPerSMHMelee = 1f / hastedMHSpeed;
swingsPerSOHMelee = (hastedOHSpeed == 0f) ? 0f : 1f / hastedOHSpeed;
whiteHitsPerSMH = ChanceWhiteHitMH * swingsPerSMHMelee;
whiteHitsPerSOH = ChanceWhiteHitOH * swingsPerSOHMelee;
moteHitsPerS = _stats.MoteOfAnger * 2 * AverageWhiteHitChance;
// Windfury model
if (_calcOpts.MainhandImbue == "Windfury")
{
float hitsThatProcWFPerS = whiteHitsPerSMH + hitsPerSMHSS;
if (_character.ShamanTalents.DualWield == 1)
{
hitsThatProcWFPerS += moteHitsPerS / 2; // half the hits will be OH and thus won't proc WF
}
else
{
hitsThatProcWFPerS += moteHitsPerS; // if no offhand then all motes will be MH weapon by definition
}
float maxExpectedWFPerFight = hitsThatProcWFPerS * chanceToProcWFPerHit * fightLength;
float ineligibleSeconds = maxExpectedWFPerFight * (3.25f - hastedMHSpeed);
float expectedWFPerFight = hitsThatProcWFPerS * chanceToProcWFPerHit * (fightLength - ineligibleSeconds);
wfProcsPerSecond = expectedWFPerFight / fightLength;
hitsPerSWF = 2f * wfProcsPerSecond * (1f - chanceYellowMissMH);
}
yellowHitsPerSMH = hitsPerSWF + hitsPerSMHSS;
yellowHitsPerSOH = hitsPerSOHSS + hitsPerSLL;
//Due to attack table, a white swing has the same chance to crit as a yellow hit
// Old Flurry calc changed 10 Nov 2009
// couldCritSwingsPerSecond = whiteHitsPerSMH + whiteHitsPerSOH + yellowHitsPerSMH + yellowHitsPerSOH;
// float swingsThatConsumeFlurryPerSecond = swingsPerSMHMelee + swingsPerSOHMelee;
// flurryUptime = 1f - (float)Math.Pow(1 - averageMeleeCritChance, (3 / swingsThatConsumeFlurryPerSecond) * couldCritSwingsPerSecond); // old formulae
flurryUptime = CalculateFlurryUptime(averageMeleeCritChance, averageMeleeHitChance, averageMeleeMissChance);
// Maelstrom Weapon time to 5 stacks calc
if (_character.ShamanTalents.DualWield == 1 && unhastedOHSpeed != 0f)
{
hitsPerSMH = whiteHitsPerSMH + yellowHitsPerSMH + moteHitsPerS / 2;
hitsPerSOH = whiteHitsPerSOH + yellowHitsPerSOH + moteHitsPerS / 2;
mwProcsPerSecond = (mwPPM / (60f / unhastedMHSpeed)) * hitsPerSMH + (mwPPM / (60f / unhastedOHSpeed)) * hitsPerSOH;
}
else
{
hitsPerSMH = whiteHitsPerSMH + yellowHitsPerSMH + moteHitsPerS;
hitsPerSOH = 0f;
mwProcsPerSecond = (mwPPM / (60f / unhastedMHSpeed)) * hitsPerSMH;
}
secondsToFiveStack = 5f / mwProcsPerSecond;
// Elemental Devastation Uptime calc
staticShocksPerSecond = (hitsPerSMH + hitsPerSOH) * staticShockChance;
flameTongueHitsPerSecond = (_calcOpts.MainhandImbue == "Flametongue" ? HitsPerSMH : 0f) +
((_calcOpts.OffhandImbue == "Flametongue" && _talents.DualWield == 1) ? HitsPerSOH : 0f);
spellAttacksPerSec = (1f / secondsToFiveStack + 1f / shockSpeed + 1f / fireNovaSpeed + staticShocksPerSecond) // + flameTongueHitsPerSecond)
* (1f - chanceSpellMiss);
float couldCritSpellsPerS = spellAttacksPerSec - staticShocksPerSecond; // LS procs from Static Shock cannot crit
edUptime = 1f - (float)Math.Pow(1 - chanceSpellCrit, 10 * couldCritSpellsPerS);
averageMeleeCritChance = (chanceWhiteCritMH + chanceWhiteCritOH + chanceYellowCritMH + chanceYellowCritOH) / 4f + edUptime * edCritBonus;
}
float yellowAttacksPerSecond = hitsPerSWF + hitsPerSMHSS;
if (_character.ShamanTalents.DualWield == 1 && unhastedMHSpeed != 0)
{
yellowAttacksPerSecond += hitsPerSOHSS;
}
// set output variables
edBonusCrit = edUptime * edCritBonus;
//SetCritValues((1 + _stats.BonusCritChance) * (baseMeleeCrit + meleeCritModifier) + edBonusCrit + .00005f); //fudge factor for rounding
SetCritValues(baseMeleeCrit + meleeCritModifier + edBonusCrit + .00005f); //fudge factor for rounding
meleeAttacksPerSec = hitsPerSMH + hitsPerSOH;
meleeCritsPerSec = (whiteHitsPerSMH * chanceWhiteCritMH) + (whiteHitsPerSOH * chanceWhiteCritOH) +
(yellowHitsPerSMH * chanceYellowCritMH) + (yellowHitsPerSOH * chanceYellowCritOH) +
(_stats.MoteOfAnger * 2 * AverageWhiteCritChance);
spellCritsPerSec = spellAttacksPerSec * ChanceSpellCrit;
spellCastsPerSec = spellAttacksPerSec;
spellMissesPerSec = spellAttacksPerSec * chanceSpellMiss;
chanceMeleeHit = meleeAttacksPerSec / (swingsPerSMHMelee + swingsPerSOHMelee + 2f * wfProcsPerSecond + .25f + 1f / 6f);
maxMana = _stats.Mana;
float spellhaste = _stats.SpellHaste + StatConversion.GetSpellHasteFromRating(_stats.HasteRating);
averageFSDotTime = 18f / (1f + spellhaste);
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
Stats baseStats = BaseStats.GetBaseStats(character);
dictValues.Add("Health", BasicStats.Health.ToString());
dictValues.Add("Stamina", BasicStats.Stamina.ToString());
float ResilienceCap = 0.15f, ResilienceFromRating = StatConversion.GetCritReductionFromResilience(1);
float Resilience = StatConversion.GetCritReductionFromResilience(BasicStats.Resilience);
dictValues.Add("Resilience", string.Format("{0}*-{1}% Damage from DoT and Mana Drains\n\r-{1}% Chance to be crit\r\n-{2}% Damage from Crits.\r\n{3}",
BasicStats.Resilience.ToString(),
(Resilience * 100f).ToString("0.00"),
(Resilience * 100f * 2.2f).ToString("0.00"),
(Resilience > ResilienceCap)?(string.Format("{0} rating above cap", ((float)Math.Floor((Resilience - ResilienceCap) / ResilienceFromRating)).ToString("0"))):(string.Format("{0} rating below cap", ((float)Math.Ceiling((ResilienceCap - Resilience) / ResilienceFromRating)).ToString("0")))));
dictValues.Add("Mana", BasicStats.Mana.ToString());
dictValues.Add("Intellect", BasicStats.Intellect.ToString());
dictValues.Add("Spirit", Math.Floor(BasicStats.Spirit).ToString("0"));
dictValues.Add("Spell Power", string.Format("{0}*{1} from Inner Fire",
Math.Floor(BasicStats.SpellPower).ToString("0"),
BasicStats.PriestInnerFire * CalculationsHealPriest.GetInnerFireSpellPowerBonus(character)));
//dictValues.Add("Healing", Math.Floor(BasicStats.SpellPower * 1.88f).ToString("0"));
dictValues.Add("In FSR MP5", string.Format("{0}*{1} from MP5\r\n{2} from Meditation\r\n{3} Outside FSR\r\n{4} OFSR w/MP5",
(BasicStats.Mp5 + RegenInFSR).ToString("0"),
BasicStats.Mp5.ToString("0"),
RegenInFSR.ToString("0"),
RegenOutFSR.ToString("0"),
(BasicStats.Mp5 + RegenOutFSR).ToString("0")));
dictValues.Add("Spell Crit", string.Format("{0}%*{1}% from Intellect\r\n{2}% from {6} Crit rating\r\n{3}% from Focused Will\r\n{4}% Class Base\r\n{5}% from Buffs",
(BasicStats.SpellCrit * 100f).ToString("0.00"), (StatConversion.GetSpellCritFromIntellect(BasicStats.Intellect) * 100f).ToString("0.00"), (StatConversion.GetSpellCritFromRating(BasicStats.CritRating) * 100f).ToString("0.00"), character.PriestTalents.FocusedWill.ToString("0"), (baseStats.SpellCrit * 100f).ToString("0.00"), (BasicStats.SpellCrit * 100f - baseStats.SpellCrit * 100f - StatConversion.GetSpellCritFromRating(BasicStats.CritRating) * 100f - StatConversion.GetSpellCritFromIntellect(BasicStats.Intellect) * 100f - character.PriestTalents.FocusedWill * 1f).ToString("0.00"), BasicStats.CritRating));
dictValues.Add("Healing Crit", string.Format("{0}%*{1} ({1}%) points in Holy Specialization\r\n{2} ({3}%) points in Renewed Hope",
((BasicStats.SpellCrit * 100f) + character.PriestTalents.HolySpecialization * 1f + character.PriestTalents.RenewedHope * 2f).ToString("0.00"),
character.PriestTalents.HolySpecialization, character.PriestTalents.RenewedHope, character.PriestTalents.RenewedHope * 2));
dictValues.Add("Spell Haste", string.Format("{0}%*{1}% from {2} Haste rating\r\n{3}% ({6}) points in Enlightenment\r\n{4}% from Buffs\r\n{5}s Global Cooldown",
(BasicStats.SpellHaste * 100f).ToString("0.00"), (StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating) * 100f).ToString("0.00"), BasicStats.HasteRating.ToString(), (character.PriestTalents.Enlightenment * 2).ToString("0"), (((1 + BasicStats.SpellHaste) / (1 + StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating)) / (1 + character.PriestTalents.Enlightenment * 0.02f) - 1) * 100f).ToString("0.00"), Math.Max(1.0f, 1.5f / (1 + BasicStats.SpellHaste)).ToString("0.00"), character.PriestTalents.Enlightenment));
dictValues.Add("Armor", string.Format("{0}*{1}% Damage Reduction.",
(BasicStats.Armor + BasicStats.BonusArmor).ToString("0"),
(StatConversion.GetArmorDamageReduction(80, (BasicStats.Armor + BasicStats.BonusArmor), 0f, 0f, 0f) * 100f).ToString("0.00")));
float[] Resistances =
{
0,
BasicStats.ArcaneResistance + BasicStats.ArcaneResistanceBuff,
BasicStats.FireResistance + BasicStats.FireResistanceBuff,
BasicStats.FrostResistance + BasicStats.FrostResistanceBuff,
BasicStats.NatureResistance + BasicStats.NatureResistanceBuff,
BasicStats.ShadowResistance + BasicStats.ShadowResistanceBuff,
};
string[] ResistanceNames =
{
"None",
"Arcane",
"Fire",
"Frost",
"Nature",
"Shadow",
};
string ResistanceString = "*Resistances:";
float MaxResist = Resistances[0];
int MaxResistIndex = 0;
float AvgResist = 0f;
for (int x = 1; x < Resistances.Length; x++)
{
AvgResist += Resistances[x];
if (Resistances[x] > MaxResist)
{
MaxResist = Resistances[x];
MaxResistIndex = x;
}
ResistanceString += string.Format("\r\n{0} : {1}", ResistanceNames[x], Resistances[x]);
}
AvgResist /= (Resistances.Length - 1);
if (AvgResist == 0)
{
ResistanceString = "None" + ResistanceString;
}
else
{
string ResistanceName = (MaxResist == AvgResist) ? "All" : ResistanceNames[MaxResistIndex];
ResistanceString = string.Format("{0} : {1}", ResistanceName, MaxResist.ToString("0")) + ResistanceString;
ResistanceString += string.Format("\r\n\r\nResist ({0}):", ResistanceName);
ResistanceString += string.Format("\r\n{0}", StatConversion.GetResistanceTableString(character.Level + 3, character.Level, MaxResist, 0));
}
dictValues.Add("Resistance", ResistanceString);
BaseSolver solver;
if ((character.CalculationOptions as CalculationOptionsHealPriest).Role == eRole.CUSTOM)
{
solver = new AdvancedSolver(BasicStats, character);
}
else
{
solver = new Solver(BasicStats, character);
}
solver.Calculate(this);
dictValues.Add("Role", string.Format("{0}*{1}", solver.Role, solver.ActionList));
dictValues.Add("Burst", string.Format("{0}", HPSBurstPoints.ToString("0")));
dictValues.Add("Sustained", string.Format("{0}", HPSSustainPoints.ToString("0")));
dictValues.Add("Renew", new Renew(BasicStats, character).ToString());
dictValues.Add("Flash Heal", new FlashHeal(BasicStats, character).ToString());
dictValues.Add("Greater Heal", new Heal(BasicStats, character).ToString());
dictValues.Add("PoH", new PrayerOfHealing(BasicStats, character).ToString());
dictValues.Add("Binding Heal", new BindingHeal(BasicStats, character).ToString());
dictValues.Add("Prayer of Mending", new PrayerOfMending(BasicStats, character).ToString());
dictValues.Add("Power Word Shield", new PowerWordShield(BasicStats, character).ToString());
dictValues.Add("Holy Nova", new HolyNova(BasicStats, character).ToString());
if (character.PriestTalents.CircleOfHealing > 0)
{
dictValues.Add("CoH", new CircleOfHealing(BasicStats, character).ToString());
}
else
{
dictValues.Add("CoH", "- *No required talents");
}
if (character.PriestTalents.Lightwell > 0)
{
dictValues.Add("Lightwell", new Lightwell(BasicStats, character).ToString());
}
else
{
dictValues.Add("Lightwell", "- *No required talents");
}
if (character.PriestTalents.Penance > 0)
{
dictValues.Add("Penance", new Penance(BasicStats, character).ToString());
}
else
{
dictValues.Add("Penance", "- *No required talents");
}
if (Race == CharacterRace.Draenei)
{
dictValues.Add("Gift of the Naaru", new GiftOfTheNaaru(BasicStats, character).ToString());
}
else
{
dictValues.Add("Gift of the Naaru", "-");
}
dictValues.Add("Divine Hymn", new DivineHymn(BasicStats, character).ToString());
dictValues.Add("Resurrection", new Resurrection(BasicStats, character).ToString());
return(dictValues);
}
public void UpdateCalcs(bool firstPass)
{
// talents
if (_calcOpts.PriorityInUse(EnhanceAbility.StormStrike))
{
stormstrikeBonusCrit = .25f * _talents.Stormstrike + (_talents.GlyphofStormstrike ? .1f : 0f);
}
else
{
stormstrikeBonusCrit = 0f;
}
//set bonus
enhance4T11 = 0f;
_character.SetBonusCount.TryGetValue("Battlegear of the Raging Elements", out setCount);
if (setCount >= 4)
{
enhance4T11 = 0.1f;
}
critMultiplierSpell = 1.5f * (1 + _stats.BonusSpellCritDamageMultiplier);
critMultiplierMelee = 2f * (1 + _stats.BonusCritDamageMultiplier);
// Melee
float hitBonus = _stats.PhysicalHit + StatConversion.GetHitFromRating(_stats.HitRating) + 0.06f; //DualWieldSpecialization
expertiseBonusMH = GetDPRfromExp(_stats.Expertise + StatConversion.GetExpertiseFromRating(_stats.ExpertiseRating) + BaseStats.GetRacialExpertise(_character, ItemSlot.MainHand));
expertiseBonusOH = GetDPRfromExp(_stats.Expertise + StatConversion.GetExpertiseFromRating(_stats.ExpertiseRating) + BaseStats.GetRacialExpertise(_character, ItemSlot.OffHand));
float meleeCritModifier = _stats.PhysicalCrit;
float baseMeleeCrit = StatConversion.GetCritFromRating(_stats.CritRating) +
StatConversion.GetCritFromAgility(_stats.Agility, _character.Class) + .01f * _talents.Acuity;
chanceDodgeMH = Math.Max(0f, DodgeChanceCap - expertiseBonusMH);
chanceDodgeOH = Math.Max(0f, DodgeChanceCap - expertiseBonusOH);
float ParryChance = ParryChanceCap - expertiseBonusMH;
//chanceParryMH = (float)Math.Max(0f, _bossOpts.InBack ? ParryChance * PecentageInfrontBoss : ParryChance);
ParryChance = ParryChanceCap - expertiseBonusOH;
//chanceParryOH = (float)Math.Max(0f, _bossOpts.InBack ? ParryChance * PecentageInfrontBoss : ParryChance);
chanceWhiteMissMH = Math.Max(0f, WhiteHitCap - hitBonus) + chanceDodgeMH + chanceParryMH;
chanceWhiteMissOH = Math.Max(0f, WhiteHitCap - hitBonus) + chanceDodgeOH + chanceParryOH;
chanceYellowMissMH = Math.Max(0f, YellowHitCap - hitBonus) + chanceDodgeMH + chanceParryMH; // base miss 8% now
chanceYellowMissOH = Math.Max(0f, YellowHitCap - hitBonus) + chanceDodgeOH + chanceParryOH; // base miss 8% now
// SetCritValues((1 + _stats.BonusCritChance) * (baseMeleeCrit + meleeCritModifier) + .00005f); //fudge factor for rounding
SetCritValues(baseMeleeCrit + meleeCritModifier + .00005f); //fudge factor for rounding
// set two export values so that ED crit isn't included
exportMeleeCritMH = chanceWhiteCritMH + whiteCritDepression;
exportMeleeCritOH = chanceWhiteCritOH + whiteCritDepression;
// Spells
ftBonusCrit = 0f;
if (_calcOpts.MainhandImbue == "Flametongue")
{
ftBonusCrit += _talents.GlyphofFlametongueWeapon ? .02f : 0f;
}
if (_calcOpts.OffhandImbue == "Flametongue")
{
ftBonusCrit += _talents.GlyphofFlametongueWeapon ? .02f : 0f;
}
if (baseStats == null)
{
baseStats = BaseStats.GetBaseStats(_character);
}
elemPrecMod = _talents.ElementalPrecision > 0 ? (_stats.Spirit - baseStats.Spirit) * (_talents.ElementalPrecision / 3f) : 0f;
float hitBonusSpell = _stats.SpellHit + StatConversion.GetSpellHitFromRating(_stats.HitRating + elemPrecMod);
chanceSpellMiss = Math.Max(0f, SpellMissRate - hitBonusSpell);
overSpellHitCap = Math.Max(0f, hitBonusSpell - SpellMissRate);
float spellCritModifier = _stats.SpellCrit + _stats.SpellCritOnTarget + ftBonusCrit;
float baseSpellCrit = StatConversion.GetSpellCritFromRating(_stats.CritRating) +
StatConversion.GetSpellCritFromIntellect(_stats.Intellect) + .01f * _talents.Acuity;
//chanceSpellCrit = Math.Min(0.75f, (1 + _stats.BonusCritChance) * (baseSpellCrit + spellCritModifier) + .00005f); //fudge factor for rounding
chanceSpellCrit = Math.Min(0.75f, baseSpellCrit + spellCritModifier + .00005f); //fudge factor for rounding
float hasteBonus = StatConversion.GetHasteFromRating(_stats.HasteRating, _character.Class);
unhastedMHSpeed = _character.MainHand == null ? 3.0f : _character.MainHand.Item.Speed;
unhastedOHSpeed = _character.OffHand == null ? 3.0f : _character.OffHand.Item.Speed;
float baseHastedMHSpeed = unhastedMHSpeed / (1f + hasteBonus) / (1f + _stats.PhysicalHaste);
float baseHastedOHSpeed = unhastedOHSpeed / (1f + hasteBonus) / (1f + _stats.PhysicalHaste);
float chanceToProcWFPerHit = .2f + (_character.ShamanTalents.GlyphofWindfuryWeapon ? .02f : 0f);
if (_bossOpts.MultiTargs && _bossOpts.Targets != null && _bossOpts.Targets.Count > 0)
{
foreach (TargetGroup tg in _bossOpts.Targets)
{
if (tg.Frequency <= 0 || tg.Chance <= 0)
{
continue; //bad one, skip it
}
float upTime = (tg.Frequency / fightLength * (tg.Duration / 1000f) * tg.Chance) / fightLength;
multiTargetMultiplier += (Math.Max(10, tg.NumTargs - (tg.NearBoss ? 0 : 1))) * upTime;
}
}
//The Swing Loop
//This is where we figure out feedback systems -- WF, MW, ED, Flurry, etc.
//--------------
flurryUptime = 1f;
uWUptime = 0f;
//uFUptime = 0f;
edUptime = 0f;
float stormstrikeSpeed = firstPass ? (_talents.Stormstrike == 1 ? 8f : 0f) : AbilityCooldown(EnhanceAbility.StormStrike);
float shockSpeed = firstPass ? BaseShockSpeed : AbilityCooldown(EnhanceAbility.EarthShock);
float lavaLashSpeed = firstPass ? 10f : AbilityCooldown(EnhanceAbility.LavaLash);
float fireNovaSpeed = firstPass ? BaseFireNovaSpeed : AbilityCooldown(EnhanceAbility.FireNova);
if (_calcOpts.PriorityInUse(EnhanceAbility.MagmaTotem))
{
fireTotemUptime = firstPass ? 1.0f : 60f / AbilityCooldown(EnhanceAbility.MagmaTotem);
}
else if (_calcOpts.PriorityInUse(EnhanceAbility.SearingTotem))
{
fireTotemUptime = firstPass ? 1.0f : 60f / AbilityCooldown(EnhanceAbility.SearingTotem);
}
else if (_calcOpts.PriorityInUse(EnhanceAbility.RefreshTotems)) // if no Searing or Magma totem use refresh of Flametongue totem.
{
fireTotemUptime = firstPass ? 1.0f : 300f / AbilityCooldown(EnhanceAbility.RefreshTotems);
}
float mwPPM = (10f / 3f) * _talents.MaelstromWeapon;
float flurryHasteBonus = .10f * _talents.Flurry;
float uWHasteBonus = .4f + .1f * _talents.ElementalWeapons;
float edCritBonus = .03f * _talents.ElementalDevastation;
float staticShockChance = .15f * _character.ShamanTalents.StaticShock;
hitsPerSMHSS = 0f;
hitsPerSOHSS = 0f;
hitsPerSOH = 0f;
hitsPerSMH = 0f;
hitsPerSWF = 0f;
if (_talents.Stormstrike == 1)
{
hitsPerSMHSS = (1f - chanceYellowMissMH) / stormstrikeSpeed;
hitsPerSOHSS = (1f - 2 * chanceYellowMissOH) / stormstrikeSpeed; //OH only swings if MH connect
}
hitsPerSLL = lavaLashSpeed == 0 ? 0f : (1f - chanceYellowMissOH) / lavaLashSpeed;
float swingsPerSMHMelee = 0f;
float swingsPerSOHMelee = 0f;
float wfProcsPerSecond = 0f;
float mwProcsPerSecond = 0f;
secondsToFiveStack = 10f;
float averageMeleeCritChance = (chanceWhiteCritMH + chanceWhiteCritOH + chanceYellowCritMH + chanceYellowCritOH) / 4f;
float averageMeleeHitChance = ((1f - chanceWhiteMissMH - chanceDodgeMH - chanceParryMH) + (1f - chanceWhiteMissOH - chanceDodgeOH - chanceParryOH)) / 2f;
float averageMeleeMissChance = (chanceWhiteMissMH + chanceWhiteMissOH) / 2f;
float whiteHitsPerSMH = 0f;
float whiteHitsPerSOH = 0f;
float moteHitsPerS = 0f;
float yellowHitsPerSMH = 0f;
float yellowHitsPerSOH = 0f;
float flameTongueHitsPerSecond = 0f;
for (int i = 0; i < 5; i++)
{
// float bonusHaste = (1f + (flurryUptime * flurryHasteBonus));
float bonusHaste = 1 / (1 - flurryUptime + flurryUptime / (1 + flurryHasteBonus)) / (1 - uWUptime + uWUptime / (1 + uWHasteBonus)); // use time based not proc based flurryUptime
hastedMHSpeed = baseHastedMHSpeed / bonusHaste;
hastedOHSpeed = baseHastedOHSpeed / bonusHaste;
swingsPerSMHMelee = 1f / hastedMHSpeed;
swingsPerSOHMelee = (hastedOHSpeed == 0f) ? 0f : 1f / hastedOHSpeed;
whiteHitsPerSMH = ChanceWhiteHitMH * swingsPerSMHMelee;
whiteHitsPerSOH = ChanceWhiteHitOH * swingsPerSOHMelee;
moteHitsPerS = _stats.MoteOfAnger * 2 * AverageWhiteHitChance;
// Windfury model
if (_calcOpts.MainhandImbue == "Windfury")
{
float hitsThatProcWFPerS = whiteHitsPerSMH + hitsPerSMHSS;
if (unhastedOHSpeed != 0f)
{
hitsThatProcWFPerS += moteHitsPerS / 2; // half the hits will be OH and thus won't proc WF
}
else
{
hitsThatProcWFPerS += moteHitsPerS; // if no offhand then all motes will be MH weapon by definition
}
float maxExpectedWFPerFight = hitsThatProcWFPerS * chanceToProcWFPerHit * fightLength;
float ineligibleSeconds = maxExpectedWFPerFight * (3.25f - hastedMHSpeed);
float expectedWFPerFight = hitsThatProcWFPerS * chanceToProcWFPerHit * (fightLength - ineligibleSeconds);
wfProcsPerSecond = expectedWFPerFight / fightLength;
hitsPerSWF = 3f * wfProcsPerSecond * (1f - chanceYellowMissMH);
}
yellowHitsPerSMH = hitsPerSWF + hitsPerSMHSS;
yellowHitsPerSOH = hitsPerSOHSS + hitsPerSLL;
//Due to attack table, a white swing has the same chance to crit as a yellow hit
// Old Flurry calc changed 10 Nov 2009
// couldCritSwingsPerSecond = whiteHitsPerSMH + whiteHitsPerSOH + yellowHitsPerSMH + yellowHitsPerSOH;
// float swingsThatConsumeFlurryPerSecond = swingsPerSMHMelee + swingsPerSOHMelee;
// flurryUptime = 1f - (float)Math.Pow(1 - averageMeleeCritChance, (3 / swingsThatConsumeFlurryPerSecond) * couldCritSwingsPerSecond); // old formulae
flurryUptime = CalculateFlurryUptime(averageMeleeCritChance, averageMeleeHitChance, averageMeleeMissChance);
//uWUptime = (float)Math.Max(12f / 15f, ??); //FIXME!!!!
uWUptime = 7.5f / 15f; //Temp Uptime until above line is fixed
// Maelstrom Weapon time to 5 stacks calc
if (unhastedOHSpeed != 0f)
{
hitsPerSMH = whiteHitsPerSMH + yellowHitsPerSMH + moteHitsPerS / 2;
hitsPerSOH = whiteHitsPerSOH + yellowHitsPerSOH + moteHitsPerS / 2;
mwProcsPerSecond = (mwPPM / (60f / unhastedMHSpeed)) * hitsPerSMH + (mwPPM / (60f / unhastedOHSpeed)) * hitsPerSOH;
}
else
{
hitsPerSMH = whiteHitsPerSMH + yellowHitsPerSMH + moteHitsPerS;
hitsPerSOH = 0f;
mwProcsPerSecond = (mwPPM / (60f / unhastedMHSpeed)) * hitsPerSMH;
}
secondsToFiveStack = 5f / mwProcsPerSecond;
// Elemental Devastation Uptime calc
staticShocksPerSecond = (hitsPerSLL + hitsPerSMHSS + hitsPerSOHSS) * staticShockChance;
flameTongueHitsPerSecond = (_calcOpts.MainhandImbue == "Flametongue" ? HitsPerSMH : 0f) +
((_calcOpts.OffhandImbue == "Flametongue") ? HitsPerSOH : 0f);
spellAttacksPerSec = (1f / secondsToFiveStack + 1f / shockSpeed + 1f / fireNovaSpeed + staticShocksPerSecond) // + flameTongueHitsPerSecond)
* (1f - chanceSpellMiss);
float couldCritSpellsPerS = spellAttacksPerSec;
edUptime = 1f - (float)Math.Pow(1 - chanceSpellCrit, 10 * couldCritSpellsPerS);
averageMeleeCritChance = (chanceWhiteCritMH + chanceWhiteCritOH + chanceYellowCritMH + chanceYellowCritOH) / 4f + edUptime * edCritBonus;
}
float yellowAttacksPerSecond = hitsPerSWF + hitsPerSMHSS;
if (unhastedMHSpeed != 0)
{
yellowAttacksPerSecond += hitsPerSOHSS;
}
// set output variables
edBonusCrit = edUptime * edCritBonus;
//SetCritValues((1 + _stats.BonusCritChance) * (baseMeleeCrit + meleeCritModifier) + edBonusCrit + .00005f); //fudge factor for rounding
SetCritValues(baseMeleeCrit + meleeCritModifier + edBonusCrit + .00005f); //fudge factor for rounding
meleeAttacksPerSec = hitsPerSMH + hitsPerSOH;
meleeCritsPerSec = (whiteHitsPerSMH * chanceWhiteCritMH) + (whiteHitsPerSOH * chanceWhiteCritOH) +
(yellowHitsPerSMH * chanceYellowCritMH) + (yellowHitsPerSOH * chanceYellowCritOH) +
(_stats.MoteOfAnger * 2 * AverageWhiteCritChance);
spellCritsPerSec = spellAttacksPerSec * ChanceSpellCrit;
spellCastsPerSec = spellAttacksPerSec;
spellMissesPerSec = spellAttacksPerSec * chanceSpellMiss;
chanceMeleeHit = meleeAttacksPerSec / (swingsPerSMHMelee + swingsPerSOHMelee + 2f * wfProcsPerSecond + .25f + 1f / 6f);
maxMana = _stats.Mana;
float spellhaste = _stats.SpellHaste + StatConversion.GetSpellHasteFromRating(_stats.HasteRating);
averageFSDotTime = _talents.GlyphofFlameShock ? 27f : 18f;
averageFSTickTime = 3f / (1f + spellhaste);
}
public void ApplyDotHaste(ISpellArgs args)
{
float Speed = (1f + args.Stats.SpellHaste) * (1f + StatConversion.GetSpellHasteFromRating(args.Stats.HasteRating));
periodicTickTime = (float)Math.Round(periodicTickTime / Speed, 4);
}
public ProcEffect(SpecialEffect effect)
{
this.Effect = effect;
// Damage procs - unified code handler
if (effect.Stats.ShadowDamage > 0 || effect.Stats.FireDamage > 0 || effect.Stats.FrostDamage > 0 ||
effect.Stats.NatureDamage > 0 || effect.Stats.HolyDamage > 0 || effect.Stats.ArcaneDamage > 0 ||
effect.Stats.HolySummonedDamage > 0)
{
CalculateDPS = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float fightLength, float sp, float sHi, float sc, float sHa)
{
SpecialEffect e = Effect;
float schoolModifier = 1 +
(effect.Stats.ShadowDamage > 0 ? c.BasicStats.BonusShadowDamageMultiplier : 0) +
(effect.Stats.FireDamage > 0 ? c.BasicStats.BonusFireDamageMultiplier : 0) +
(effect.Stats.FrostDamage > 0 ? c.BasicStats.BonusFrostDamageMultiplier : 0) +
(effect.Stats.NatureDamage > 0 ? c.BasicStats.BonusNatureDamageMultiplier : 0) +
(effect.Stats.HolyDamage > 0 ? c.BasicStats.BonusHolyDamageMultiplier : 0) +
(effect.Stats.ArcaneDamage > 0 ? c.BasicStats.BonusArcaneDamageMultiplier : 0);
float specialDamageModifier = schoolModifier;
float baseValue = e.Stats.ShadowDamage + e.Stats.FireDamage + e.Stats.FrostDamage + e.Stats.NatureDamage + e.Stats.HolyDamage + e.Stats.ArcaneDamage + e.Stats.HolySummonedDamage;
float triggerInterval = 0.0f, triggerChance = 1.0f;
switch (e.Trigger)
{
case Trigger.DoTTick:
triggerInterval = r.RotationData.Duration / r.RotationData.DotTicks;
break;
case Trigger.DamageSpellHit:
case Trigger.SpellHit:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
triggerChance = sHi;
break;
case Trigger.SpellCast:
case Trigger.DamageSpellCast:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
break;
case Trigger.SpellCrit:
case Trigger.DamageSpellCrit:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
triggerChance = sc * sHi;
break;
case Trigger.DamageDone:
case Trigger.DamageOrHealingDone:
triggerInterval = r.RotationData.Duration / (r.RotationData.CastCount + r.RotationData.DotTicks);
break;
case Trigger.Use:
break;
default:
return(0.0f);
}
float procsPerSecond = e.GetAverageProcsPerSecond(triggerInterval, triggerChance, 3.0f, fightLength * 60.0f);
return(baseValue * (e.Duration == 0 ? 1 : e.Duration) * specialDamageModifier * procsPerSecond);
};
}
if (effect.Stats.Mp5 > 0)
{
CalculateMP5 = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float fightLength, float sp, float sHi, float sc, float sHa)
{
SpecialEffect e = Effect;
float triggerInterval = 0.0f, triggerChance = 1.0f;
switch (e.Trigger)
{
case Trigger.DoTTick:
triggerInterval = r.RotationData.Duration / r.RotationData.DotTicks;
break;
case Trigger.DamageSpellHit:
case Trigger.SpellHit:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
triggerChance = sHi;
break;
case Trigger.SpellCast:
case Trigger.DamageSpellCast:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
break;
case Trigger.SpellCrit:
case Trigger.DamageSpellCrit:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
triggerChance = sc * sHi;
break;
case Trigger.DamageDone:
case Trigger.DamageOrHealingDone:
triggerInterval = r.RotationData.Duration / (r.RotationData.CastCount + r.RotationData.DotTicks);
break;
case Trigger.Use:
break;
default:
return(0.0f);
}
float procsPerSecond = e.GetAverageProcsPerSecond(triggerInterval, triggerChance, 3.0f, fightLength * 60f);
return((e.Stats.Mp5 / 5.0f * e.Duration) * procsPerSecond * 5.0f);
};
}
if (effect.Stats.ManaRestoreFromMaxManaPerSecond > 0)
{
CalculateMP5 = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float fightLength, float sp, float sHi, float sc, float sHa)
{
SpecialEffect e = Effect;
float triggerInterval = 0.0f, triggerChance = 1.0f;
switch (e.Trigger)
{
case Trigger.DoTTick:
triggerInterval = r.RotationData.Duration / r.RotationData.DotTicks;
break;
case Trigger.DamageSpellHit:
case Trigger.SpellHit:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
triggerChance = sHi;
break;
case Trigger.SpellCast:
case Trigger.DamageSpellCast:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
break;
case Trigger.SpellCrit:
case Trigger.DamageSpellCrit:
triggerInterval = r.RotationData.Duration / r.RotationData.CastCount;
triggerChance = sc * sHi;
break;
case Trigger.DamageDone:
case Trigger.DamageOrHealingDone:
triggerInterval = r.RotationData.Duration / (r.RotationData.CastCount + r.RotationData.DotTicks);
break;
case Trigger.Use:
break;
default:
return(0.0f);
}
float procsPerSecond = e.GetAverageProcsPerSecond(triggerInterval, triggerChance, 3.0f, fightLength * 60f);
return(e.Stats.ManaRestoreFromMaxManaPerSecond * c.BasicStats.Mana * e.Duration * procsPerSecond * 5.0f);
};
}
if (Effect.Stats._rawSpecialEffectDataSize == 0 &&
(Effect.Trigger == Trigger.DamageDone ||
Effect.Trigger == Trigger.DamageOrHealingDone ||
Effect.Trigger == Trigger.DamageSpellCast ||
Effect.Trigger == Trigger.DamageSpellCrit ||
Effect.Trigger == Trigger.DamageSpellHit ||
Effect.Trigger == Trigger.SpellCast ||
Effect.Trigger == Trigger.SpellCrit ||
Effect.Trigger == Trigger.SpellHit ||
Effect.Trigger == Trigger.SpellMiss ||
Effect.Trigger == Trigger.Use ||
Effect.Trigger == Trigger.MoonfireCast ||
Effect.Trigger == Trigger.InsectSwarmCast ||
Effect.Trigger == Trigger.InsectSwarmOrMoonfireCast ||
Effect.Trigger == Trigger.MoonfireTick ||
Effect.Trigger == Trigger.InsectSwarmTick ||
Effect.Trigger == Trigger.DoTTick) &&
(Effect.Stats.HasteRating > 0 ||
Effect.Stats.SpellHaste > 0))
{
Activate = delegate(Character ch, CharacterCalculationsMoonkin c, ref float sp, ref float sHi, ref float sc, ref float sHa, ref float m)
{
SpecialEffect e = Effect;
int maxStack = e.MaxStack;
Stats st = e.Stats;
float hasteRating = st.HasteRating;
float spellHaste = StatConversion.GetSpellHasteFromRating(hasteRating * maxStack);
spellHaste += st.SpellHaste;
//float highestStat = st.HighestStat;
if (spellHaste > 0)
{
sHa += spellHaste;
}
/*if (st.Intellect > 0 || highestStat > 0)
* {
* float procIntellect = (float)Math.Floor((1 + c.BasicStats.BonusIntellectMultiplier) * (st.Intellect + st.HighestStat));
* storedStats.SpellPower = (float)Math.Floor((1 + c.BasicStats.BonusSpellPowerMultiplier) * procIntellect);
* storedStats.SpellCrit = StatConversion.GetSpellCritFromIntellect(procIntellect);
* sp += storedStats.SpellPower;
* sc += storedStats.SpellCrit;
* }*/
};
Deactivate = delegate(Character ch, CharacterCalculationsMoonkin c, ref float sp, ref float sHi, ref float sc, ref float sHa, ref float m)
{
SpecialEffect e = Effect;
int maxStack = e.MaxStack;
Stats st = e.Stats;
float hasteRating = st.HasteRating;
float spellHaste = StatConversion.GetSpellHasteFromRating(hasteRating * maxStack);
spellHaste += st.SpellHaste;
//float highestStat = st.HighestStat;
if (spellHaste > 0)
{
sHa -= spellHaste;
}
/*if (st.Intellect > 0 || highestStat > 0)
* {
* sp -= storedStats.SpellPower;
* sc -= storedStats.SpellCrit;
* }*/
};
UpTime = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float fightLength, float sub35Percent)
{
float upTime = 0.0f;
float procTime = fightLength * 60.0f * (Effect.LimitedToExecutePhase ? sub35Percent : 1f);
switch (Effect.Trigger)
{
case Trigger.Use:
upTime = Effect.GetAverageUptime(0f, 1f, 3.0f, procTime);
break;
case Trigger.SpellHit:
case Trigger.DamageSpellHit:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / r.RotationData.CastCount, 1 - Math.Max(0, c.SpellHitCap - c.SpellHit), 3.0f, procTime);
break;
case Trigger.DamageSpellCrit:
case Trigger.SpellCrit:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / (r.RotationData.CastCount - r.RotationData.InsectSwarmCasts), c.SpellCrit, 3.0f, procTime);
break;
case Trigger.SpellCast:
case Trigger.DamageSpellCast:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / r.RotationData.CastCount, 1f, 3.0f, procTime);
break;
case Trigger.MoonfireCast:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / r.RotationData.MoonfireCasts, 1f, 3.0f, procTime);
break;
case Trigger.InsectSwarmCast:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / r.RotationData.InsectSwarmCasts, 1f, 3.0f, procTime);
break;
case Trigger.InsectSwarmOrMoonfireCast:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / (r.RotationData.MoonfireCasts + r.RotationData.InsectSwarmCasts), 1f, 3.0f, procTime);
break;
case Trigger.EclipseProc:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / 2f, 1f, 3.0f, procTime);
break;
case Trigger.MoonfireTick:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / r.RotationData.MoonfireTicks, 1f, 3.0f, procTime);
break;
case Trigger.InsectSwarmTick:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / r.RotationData.InsectSwarmTicks, 1f, 3.0f, procTime);
break;
case Trigger.DoTTick:
upTime = Effect.GetAverageUptime(r.RotationData.Duration / (r.RotationData.MoonfireTicks + r.RotationData.InsectSwarmTicks), 1f, 3.0f, procTime);
break;
case Trigger.DamageDone:
case Trigger.DamageOrHealingDone:
upTime = Effect.GetAverageUptime(((r.RotationData.Duration / r.RotationData.CastCount) + (r.RotationData.Duration / (r.RotationData.MoonfireTicks + r.RotationData.InsectSwarmTicks))) / 2.0f, 1f, 3.0f, procTime);
break;
default:
break;
}
return(upTime * (Effect.LimitedToExecutePhase ? sub35Percent : 1f));
};
}
}
private List <Ability> SetupAbilities()
{
List <Ability> abilities = new List <Ability>();
float convection = 1f - _talents.Convection * 0.02f;
float baseMana = BaseStats.GetBaseStats(_character).Mana;
float elementalFocus = (_talents.ElementalFocus == 1) ? .6f * _cs.ChanceSpellCrit : 1f;
float ESMana = _talents.ShamanisticFocus == 1 ? baseMana * 0.55f * 0.18f : baseMana * 0.18f; // 45% reduction if Shamanistic Focus
float FSMana = _talents.ShamanisticFocus == 1 ? baseMana * 0.55f * 0.17f : baseMana * 0.17f; // 45% reduction if Shamanistic Focus
float fireElementalCD = _talents.GlyphofFireElementalTotem ? 300f : 600f;
float gcd = Math.Max(1.0f, 1.5f / (1f + _stats.SpellHaste + StatConversion.GetSpellHasteFromRating(_stats.HasteRating)));
int priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.ShamanisticRage);
if (priority > 0 && _talents.ShamanisticRage == 1)
{
abilities.Add(new Ability(EnhanceAbility.ShamanisticRage, 60f, 1.5f, 0f, priority, false, true));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.FeralSpirits);
if (priority > 0 && _talents.FeralSpirit == 1)
{
abilities.Add(new Ability(EnhanceAbility.FeralSpirits, 180f, gcd, 0.12f * baseMana, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.LightningBolt);
if (priority > 0 && _talents.MaelstromWeapon > 0)
{
abilities.Add(new Ability(EnhanceAbility.LightningBolt, _cs.SecondsToFiveStack, gcd, 0.1f * baseMana * convection * elementalFocus, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.FlameShock);
if (priority > 0)
{
if (_talents.GlyphofShocking)
{
abilities.Add(new Ability(EnhanceAbility.FlameShock, _cs.AverageFSDotTime, 1.0f, FSMana * convection * elementalFocus, priority, false, false));
}
else
{
abilities.Add(new Ability(EnhanceAbility.FlameShock, _cs.AverageFSDotTime, gcd, FSMana * convection * elementalFocus, priority, false, false));
}
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.StormStrike);
if (priority > 0 && _talents.Stormstrike == 1)
{
abilities.Add(new Ability(EnhanceAbility.StormStrike, 8f, 1.5f, 0.08f * baseMana, priority, false, true));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.EarthShock);
if (priority > 0)
{
if (_talents.GlyphofShocking)
{
abilities.Add(new Ability(EnhanceAbility.EarthShock, _cs.BaseShockSpeed, 1.0f, ESMana * convection * elementalFocus, priority, false, false));
}
else
{
abilities.Add(new Ability(EnhanceAbility.EarthShock, _cs.BaseShockSpeed, gcd, ESMana * convection * elementalFocus, priority, false, false));
}
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.LavaLash);
if (priority > 0 && _talents.LavaLash == 1)
{
abilities.Add(new Ability(EnhanceAbility.LavaLash, 6f, 1.5f, 0.04f * baseMana, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.FireNova);
if (priority > 0)
{
abilities.Add(new Ability(EnhanceAbility.FireNova, _cs.BaseFireNovaSpeed, gcd, 0.22f * baseMana, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.FireElemental);
if (priority > 0 && _calcOpts.FireElemental)
{
abilities.Add(new Ability(EnhanceAbility.FireElemental, fireElementalCD, 1.0f, 0.23f * baseMana, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.MagmaTotem);
if (priority > 0 && _calcOpts.Magma)
{
abilities.Add(new Ability(EnhanceAbility.MagmaTotem, 20f, 1.0f, 0.27f * baseMana * elementalFocus, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.SearingTotem);
if (priority > 0 && !_calcOpts.Magma)
{
abilities.Add(new Ability(EnhanceAbility.SearingTotem, 60f, 1.0f, 0.07f * baseMana * elementalFocus, priority, false, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.LightningShield);
if (priority > 0 && _talents.StaticShock > 0)
{
abilities.Add(new Ability(EnhanceAbility.LightningShield, _cs.StaticShockAvDuration, gcd, 0f, priority, true, false));
}
priority = _calcOpts.GetAbilityPriorityValue(EnhanceAbility.RefreshTotems);
if (priority > 0)
{
abilities.Add(new Ability(EnhanceAbility.RefreshTotems, 300f, 1.0f, 0.24f * baseMana, _calcOpts.GetAbilityPriorityValue(EnhanceAbility.RefreshTotems), true, false)); // patch 3.2 takes just 1 second GCD to refresh totems.
}
abilities.Sort();
return(abilities);
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
Buff activeBuff;
string s;
Stats baseStats = BaseStats.GetBaseStats(Character);
#region General
dictValues["Health"] = BasicStats.Health.ToString("0");
dictValues["Mana"] = BasicStats.Mana.ToString("0");
dictValues["Item Level"] = String.Format("{0}*Lowest: {1}\nHighest: {2}", Character.AvgWornItemLevel.ToString("0"), Character.MinWornItemLevel.ToString("0"), Character.MaxWornItemLevel.ToString("0"));
dictValues["Speed"] = String.Format("{0}%*{0}% Run speed",
((1f + BasicStats.MovementSpeed) * 100f).ToString("0"));
#endregion
#region Attributes
dictValues["Strength"] = BasicStats.Strength.ToString();
dictValues["Agility"] = BasicStats.Agility.ToString();
dictValues["Stamina"] = BasicStats.Stamina.ToString();
dictValues["Intellect"] = BasicStats.Intellect.ToString();
dictValues["Spirit"] = BasicStats.Spirit.ToString();
#endregion
#region Spell
#region Spell Power
s = String.Empty;
float intPower = BasicStats.Intellect - 10;
if (BasicStats.InnerFire)
{
s += String.Format("\n{0} from Inner Fire", PriestInformation.GetInnerFireSpellPowerBonus(Character));
}
activeBuff = GetActiveBuffsByGroup("Spell Power");
if (activeBuff != null)
{
s += makeActiveBuffTextPercent(activeBuff, activeBuff.Stats.BonusSpellPowerMultiplier);
}
dictValues["Spell Power"] = String.Format("{0}*{1} from {2} Intellect{3}",
BasicStats.SpellPower.ToString("0"),
intPower.ToString("0"),
BasicStats.Intellect.ToString("0"),
s
);
#endregion
#region Haste
s = String.Empty;
if (Character.PriestTalents.Darkness > 0)
{
s += String.Format("\n{0}% from {1} points in Darkness", Character.PriestTalents.Darkness, Character.PriestTalents.Darkness);
}
activeBuff = GetActiveBuffsByGroup("Spell Haste");
if (activeBuff != null)
{
s += makeActiveBuffTextPercent(activeBuff, activeBuff.Stats.SpellHaste);
}
activeBuff = GetActiveBuffsByGroup("Dark Intent");
if (activeBuff != null)
{
s += makeActiveBuffTextPercent(activeBuff, activeBuff.Stats.SpellHaste);
}
dictValues["Haste"] = String.Format("{0}%*{1}% from {2} Haste Rating{3}",
(BasicStats.SpellHaste * 100f).ToString("0.00"),
(StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating) * 100f).ToString("0.00"), BasicStats.HasteRating.ToString("0"),
s
);
#endregion
dictValues["Hit"] = (BasicStats.SpellHit * 100f).ToString("0.00");
dictValues["Penetration"] = BasicStats.SpellPenetration.ToString("0");
#region Mana Regen
float manaRegen = StatConversion.GetSpiritRegenSec(BasicStats.Spirit, BasicStats.Intellect) * 5f;
s = String.Format("\n{0} Mana per 5 sec from Base Mana Regeneration", (baseStats.Mana * 0.05f).ToString("0"));
activeBuff = GetActiveBuffsByGroup("Mana Regeneration");
if (activeBuff != null)
{
s += makeActiveBuffText(activeBuff, activeBuff.Stats.Mp5);
}
dictValues["Mana Regen"] = String.Format("{0}*{1} from Spirit based regen{2}",
(manaRegen + BasicStats.Mp5).ToString("0"),
manaRegen.ToString("0"),
s
);
dictValues["Combat Regen"] = String.Format("{0}*{1} from Spirit based regen{2}",
(manaRegen * BasicStats.SpellCombatManaRegeneration + BasicStats.Mp5).ToString("0"),
(manaRegen * BasicStats.SpellCombatManaRegeneration).ToString("0"),
s
);
#endregion
#region Crit
s = String.Empty;
activeBuff = GetActiveBuffsByGroup("Critical Strike Chance");
if (activeBuff != null)
{
s += makeActiveBuffTextPercent(activeBuff, activeBuff.Stats.SpellCrit);
}
activeBuff = GetActiveBuffsByGroup("Focus Magic, Spell Critical Strike Chance");
if (activeBuff != null)
{
s += makeActiveBuffTextPercent(activeBuff, activeBuff.Stats.SpellCrit);
}
dictValues["Crit Chance"] = String.Format("{0}%*{1}% from {2} Crit Rating\n{3}% from {4} Intellect\n{5}% from Priest base{6}",
(BasicStats.SpellCrit * 100f).ToString("0.00"),
(StatConversion.GetSpellCritFromRating(BasicStats.CritRating) * 100f).ToString("0.00"), BasicStats.CritRating.ToString("0"),
(StatConversion.GetSpellCritFromIntellect(BasicStats.Intellect) * 100f).ToString("0.00"), BasicStats.Intellect.ToString("0"),
(baseStats.SpellCrit * 100f).ToString("0.00"),
s
);
#endregion
#region Mastery
s = string.Empty;
float masteryBase = 0, masteryBonus = 0;
if (BasicStats.PriestSpec == ePriestSpec.Spec_Disc)
{
masteryBase = PriestInformation.DisciplineMasteryBase;
masteryBonus = PriestInformation.DisciplineMasteryEffect * 100f;
s += String.Format("\n\nEach point of mastery increases the potency of Absorbs by an additional {0}%.", masteryBonus.ToString("0.00"));
}
else if (BasicStats.PriestSpec == ePriestSpec.Spec_Holy)
{
masteryBase = PriestInformation.HolyMasteryBase;
masteryBonus = PriestInformation.HolyMasteryEffect * 100f;
s += String.Format("\n\nEach point of mastery provides an additional {0}% healing over 6 sec.", masteryBonus.ToString("0.00"));
}
dictValues["Mastery"] = String.Format("{0}%*{1}% from {2} Mastery Rating\n{3}% from {4} Base Mastery{5}",
((StatConversion.GetMasteryFromRating(BasicStats.MasteryRating) + masteryBase) * masteryBonus).ToString("0.00"),
(StatConversion.GetMasteryFromRating(BasicStats.MasteryRating) * masteryBonus).ToString("0.00"), BasicStats.MasteryRating.ToString("0"),
(masteryBase * masteryBonus).ToString("0.00"), masteryBase.ToString("0"),
s
);
#endregion
#endregion
#region Defense
dictValues["Armor"] = String.Format("{0}*{1}% physical damage reduction from same level target",
BasicStats.Armor.ToString("0"),
(StatConversion.GetDamageReductionFromArmor(Character.Level, BasicStats.Armor) * 100f).ToString("0.00"));
dictValues["Dodge"] = String.Format("{0}%", (BasicStats.Dodge * 100f).ToString("0.00"));
dictValues["Resilience"] = String.Format("{0}*{1}% damage reduction on attacks from other players\n{2}% damage reduction from spells",
BasicStats.Resilience.ToString("0"),
(StatConversion.GetDamageReductionFromResilience(BasicStats.Resilience) * 100f).ToString("0.00"),
(Character.PriestTalents.InnerSanctum * 2f).ToString("0"));
#endregion
#region Resistance
string resistTxt = "{0}*PvP\n{1}\n\nBoss\n{2}";
string[] resistList = { "Arcane", "Fire", "Frost", "Nature", "Shadow" };
float[] resistances = { BasicStats.ArcaneResistance + BasicStats.ArcaneResistanceBuff,
BasicStats.FireResistance + BasicStats.FireResistanceBuff,
BasicStats.FrostResistance + BasicStats.FrostResistanceBuff,
BasicStats.NatureResistance + BasicStats.NatureResistanceBuff,
BasicStats.ShadowResistance + BasicStats.ShadowResistanceBuff };
for (int x = 0; x < resistList.Length; x++)
{
dictValues[resistList[x]] = String.Format(resistTxt,
resistances[x].ToString("0"),
StatConversion.GetResistanceTableString(Character.Level, Character.Level, resistances[x], 0f),
StatConversion.GetResistanceTableString(Character.Level + 3, Character.Level, resistances[x], 0f)
);
}
#endregion
#region Model
CalculationOptionsHealPriest calcOpts = Character.CalculationOptions as CalculationOptionsHealPriest;
if (calcOpts != null)
{
PriestSolver solver = PriestModels.GetModel(this, calcOpts, true);
solver.Solve();
List <string> reqs = solver.MeetsRequirements();
string disp;
if (reqs.Count > 0)
{
disp = String.Format("{0}\n\n{1}", solver.Name, String.Join("\n", reqs));
}
else
{
disp = solver.Name;
}
dictValues["Role"] = disp;
dictValues["Burst Goal"] = this.BurstGoal.ToString("0");
dictValues["Sust. Goal"] = this.SustainGoal.ToString("0");
dictValues["Mana Goal"] = this.ManaGoal.ToString("0");
dictValues["Burst"] = this.BurstPoints.ToString("0");
dictValues["Sustained"] = this.SustainPoints.ToString("0");
dictValues["Mana "] = this.ManaPoints.ToString("0");
}
#endregion
#region Holy Spells
SpellHeal spellHeal = new SpellHeal(Character, BasicStats);
dictValues["Heal"] = String.Format("{0}*{1}", spellHeal.HPS().ToString("0"), spellHeal.ToString());
SpellGreaterHeal spellGreaterHeal = new SpellGreaterHeal(Character, BasicStats);
dictValues["Greater Heal"] = String.Format("{0}*{1}", spellGreaterHeal.HPS().ToString("0"), spellGreaterHeal.ToString());
SpellFlashHeal spellFlashHeal = new SpellFlashHeal(Character, BasicStats);
dictValues["Flash Heal"] = String.Format("{0}*{1}", spellFlashHeal.HPS().ToString("0"), spellFlashHeal.ToString());
SpellBindingHeal spellBindingHeal = new SpellBindingHeal(Character, BasicStats);
dictValues["Binding Heal"] = String.Format("{0}*{1}", spellBindingHeal.HPS().ToString("0"), spellBindingHeal.ToString());
SpellRenew spellRenew = new SpellRenew(Character, BasicStats);
dictValues["Renew"] = String.Format("{0}*{1}", spellRenew.HPS().ToString("0"), spellRenew.ToString());
if (Character.PriestTalents.Lightwell > 0)
{
SpellLightwell spellLW = new SpellLightwell(Character, BasicStats);
dictValues["Lightwell"] = String.Format("{0}*{1}", spellLW.HPS().ToString("0"), spellLW.ToString());
}
else
{
dictValues["Lightwell"] = "N/A*You do not have the talent required.";
}
SpellPrayerOfHealing spellProH = new SpellPrayerOfHealing(Character, BasicStats);
dictValues["ProH"] = String.Format("{0}*{1}", spellProH.HPS().ToString("0"), spellProH.ToString());
SpellHolyNova spellHolyNova = new SpellHolyNova(Character, BasicStats);
dictValues["Holy Nova"] = String.Format("NYI*{1}", spellHolyNova.HPS().ToString("0"), spellHolyNova.ToString());
if (Character.PriestTalents.CircleOfHealing > 0)
{
SpellCircleOfHealing spellCoH = new SpellCircleOfHealing(Character, BasicStats);
dictValues["CoH"] = String.Format("{0}*{1}", spellCoH.HPS().ToString("0"), spellCoH.ToString());
}
else
{
dictValues["CoH"] = "N/A*You do not have the talent required.";
}
if (BasicStats.PriestSpec == ePriestSpec.Spec_Disc)
{
SpellPenance spellPenance = new SpellPenance(Character, BasicStats);
dictValues["Penance"] = String.Format("{0}*{1}", spellPenance.HPS().ToString("0"), spellPenance.ToString());
}
else
{
dictValues["Penance"] = "N/A*You do not have the correct Talent specialization.";
}
if (Character.PriestTalents.Revelations > 0)
{
SpellSerenity spellSerenity = new SpellSerenity(Character, BasicStats);
dictValues["HW Serenity"] = String.Format("{0}*{1}", spellSerenity.HPS().ToString("0"), spellSerenity.ToString());
SpellSanctuary spellSanctuary = new SpellSanctuary(Character, BasicStats);
dictValues["HW Sanctuary"] = String.Format("{0}*{1}", spellSanctuary.HPS().ToString("0"), spellSanctuary.ToString());
}
else
{
dictValues["HW Serenity"] = "N/A*You do not have the talent required.";
dictValues["HW Sanctuary"] = "N/A*You do not have the talent required.";
}
SpellPrayerOfMending spellProM = new SpellPrayerOfMending(Character, BasicStats, 1);
dictValues["ProM"] = String.Format("{0}*{1}", spellProM.HPS().ToString("0"), spellProM.ToString());
spellProM = new SpellPrayerOfMending(Character, BasicStats);
dictValues["ProM 5 Hits"] = String.Format("{0}*{1}", spellProM.HPS().ToString("0"), spellProM.ToString());
SpellPowerWordShield spellPWS = new SpellPowerWordShield(Character, BasicStats);
dictValues["PWS"] = String.Format("{0}*{1}", spellPWS.HPS().ToString("0"), spellPWS.ToString());
SpellDivineHymn spellDivineHymn = new SpellDivineHymn(Character, BasicStats);
dictValues["Divine Hymn"] = String.Format("{0}*{1}", spellDivineHymn.HPS().ToString("0"), spellDivineHymn.ToString());
if (Character.Race == CharacterRace.Draenei)
{
SpellGiftOfTheNaaru spellGoat = new SpellGiftOfTheNaaru(Character, BasicStats);
dictValues["Gift of the Naaru"] = String.Format("{0}*{1}", spellGoat.HPS().ToString("0"), spellGoat.ToString());
}
else
{
dictValues["Gift of the Naaru"] = "N/A*You are not a spacegoat!";
}
SpellResurrection spellResurrection = new SpellResurrection(Character, BasicStats);
dictValues["Resurrection"] = String.Format("{0}*{1}", spellResurrection.CastTime.ToString("0.00"), spellResurrection.ToString());
#endregion
#region Shadow Spells
#endregion
return(dictValues);
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> retVal = new Dictionary <string, string>();
retVal.Add("Health", baseStats.Health.ToString());
retVal.Add("Mana", baseStats.Mana.ToString());
retVal.Add("Armor", baseStats.Armor.ToString());
retVal.Add("Agility", baseStats.Agility.ToString());
retVal.Add("Stamina", baseStats.Stamina.ToString());
retVal.Add("Intellect", baseStats.Intellect.ToString());
retVal.Add("Spirit", baseStats.Spirit.ToString());
retVal.Add("Spell Power", SpellPower.ToString());
retVal.Add("Spell Hit", String.Format("{0:F}%*{1} Hit Rating, {2:F}% Hit From Gear, {3} Rating To Cap",
100 * SpellHit,
baseStats.HitRating,
100 * StatConversion.GetSpellHitFromRating(baseStats.HitRating),
StatConversion.GetRatingFromHit(Math.Max(0, 0.17f - SpellHit))));
retVal.Add("Spell Crit", String.Format("{0:F}%*{1} Crit Rating, {2:F}% Crit From Gear, {3:F}% Crit From Intellect",
100 * SpellCrit,
baseStats.CritRating,
100 * StatConversion.GetSpellCritFromRating(baseStats.CritRating),
100 * StatConversion.GetSpellCritFromIntellect(baseStats.Intellect)));
retVal.Add("Spell Haste", String.Format("{0:F}%*{1} Haste Rating, {2:F}% Haste From Gear",
100 * SpellHaste,
baseStats.HasteRating,
100 * StatConversion.GetSpellHasteFromRating(baseStats.HasteRating)));
retVal.Add("MP5 Not Casting", String.Format("{0:F0}", ManaRegen * 5.0f));
retVal.Add("MP5 While Casting", String.Format("{0:F0}", ManaRegen5SR * 5.0f));
retVal.Add("Total Score", String.Format("{0:F2}", SubPoints[0] + SubPoints[1]));
retVal.Add("Selected Rotation", SelectedRotation.Name);
retVal.Add("Selected DPS", String.Format("{0:F2}", SelectedRotation.RotationData.DPS));
retVal.Add("Selected Time To OOM", String.Format(SelectedRotation.RotationData.TimeToOOM > new TimeSpan(0, 0, 0) ? "{0} m {1} s" : "Not during fight", SelectedRotation.RotationData.TimeToOOM.Minutes, SelectedRotation.RotationData.TimeToOOM.Seconds));
retVal.Add("Selected Cycle Length", String.Format("{0:F1} s", SelectedRotation.Duration));
StringBuilder sb = new StringBuilder("*");
float rotationDamage = SelectedRotation.RotationData.DPS * SelectedRotation.Duration;
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starfire", 100 * SelectedRotation.StarfireAvgHit * SelectedRotation.StarfireCount / rotationDamage,
SelectedRotation.StarfireAvgHit * SelectedRotation.StarfireCount,
SelectedRotation.StarfireCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Moonfire", 100 * (SelectedRotation.MoonfireAvgHit) * SelectedRotation.MoonfireCasts / rotationDamage,
(SelectedRotation.MoonfireAvgHit) * SelectedRotation.MoonfireCasts,
SelectedRotation.MoonfireCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Insect Swarm", 100 * SelectedRotation.InsectSwarmAvgHit * SelectedRotation.InsectSwarmCasts / rotationDamage,
SelectedRotation.InsectSwarmAvgHit * (SelectedRotation.InsectSwarmCasts),
SelectedRotation.InsectSwarmCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Wrath", 100 * SelectedRotation.WrathAvgHit * SelectedRotation.WrathCount / rotationDamage,
SelectedRotation.WrathAvgHit * SelectedRotation.WrathCount,
SelectedRotation.WrathCount));
retVal.Add("Selected Spell Breakdown", sb.ToString());
retVal.Add("Burst Rotation", BurstDPSRotation.Name);
retVal.Add("Burst DPS", String.Format("{0:F2}", BurstDPSRotation.RotationData.BurstDPS));
retVal.Add("Burst Time To OOM", String.Format(BurstDPSRotation.RotationData.TimeToOOM > new TimeSpan(0, 0, 0) ? "{0} m {1} s" : "Not during fight", BurstDPSRotation.RotationData.TimeToOOM.Minutes, BurstDPSRotation.RotationData.TimeToOOM.Seconds));
retVal.Add("Burst Cycle Length", String.Format("{0:F1} s", BurstDPSRotation.Duration));
sb = new StringBuilder("*");
rotationDamage = BurstDPSRotation.RotationData.DPS * BurstDPSRotation.Duration;
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starfire", 100 * BurstDPSRotation.StarfireAvgHit * BurstDPSRotation.StarfireCount / rotationDamage,
BurstDPSRotation.StarfireAvgHit * BurstDPSRotation.StarfireCount,
BurstDPSRotation.StarfireCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Moonfire", 100 * BurstDPSRotation.MoonfireAvgHit * SelectedRotation.MoonfireCasts / rotationDamage,
(BurstDPSRotation.MoonfireAvgHit) * BurstDPSRotation.MoonfireCasts,
BurstDPSRotation.MoonfireCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Insect Swarm", 100 * BurstDPSRotation.InsectSwarmAvgHit * BurstDPSRotation.InsectSwarmCasts / rotationDamage,
BurstDPSRotation.InsectSwarmAvgHit * BurstDPSRotation.InsectSwarmCasts,
BurstDPSRotation.InsectSwarmCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Wrath", 100 * BurstDPSRotation.WrathAvgHit * BurstDPSRotation.WrathCount / rotationDamage,
BurstDPSRotation.WrathAvgHit * BurstDPSRotation.WrathCount,
BurstDPSRotation.WrathCount));
retVal.Add("Burst Spell Breakdown", sb.ToString());
retVal.Add("Starfire", String.Format("{0:F2} dps*{1:F2} s avg\n{2:F2} s w/NG\n{3:F2}% max non-Eclipse\n{4:F2}% max Eclipse\n{5:F2} avg hit\n{6:F0} avg mana",
SelectedRotation.StarfireAvgHit / (SelectedRotation.StarfireAvgCast > 0 ? SelectedRotation.StarfireAvgCast : 1f),
SelectedRotation.StarfireAvgCast,
SelectedRotation.StarfireNGCastTime,
100 * SelectedRotation.StarfireNonEclipseCrit,
100 * SelectedRotation.StarfireEclipseCrit,
SelectedRotation.StarfireAvgHit,
SelectedRotation.StarfireManaCost));
retVal.Add("Wrath", String.Format("{0:F2} dps*{1:F2} s avg\n{2:F2} s w/NG\n{3:F2} avg hit\n{4:F0} avg mana",
SelectedRotation.WrathAvgHit / (SelectedRotation.WrathAvgCast > 0 ? SelectedRotation.WrathAvgCast : 1f),
SelectedRotation.WrathAvgCast,
SelectedRotation.WrathNGCastTime,
SelectedRotation.WrathAvgHit,
SelectedRotation.WrathManaCost));
retVal.Add("Moonfire", String.Format("{0:F2} dps*{1:F2} s avg\n{2:F2} avg hit\n{3:F0} avg mana",
SelectedRotation.MoonfireAvgHit / (SelectedRotation.MoonfireDuration > 0 ? SelectedRotation.MoonfireDuration : 1f),
SelectedRotation.MoonfireCastTime,
(SelectedRotation.MoonfireAvgHit),
SelectedRotation.MoonfireManaCost));
retVal.Add("Insect Swarm", String.Format("{0:F2} dps*{1:F2} s avg\n{2:F2} avg hit\n{3:F0} avg mana",
SelectedRotation.InsectSwarmAvgHit / (SelectedRotation.InsectSwarmDuration > 0 ? SelectedRotation.InsectSwarmDuration : 1f),
SelectedRotation.InsectSwarmCastTime,
SelectedRotation.InsectSwarmAvgHit,
SelectedRotation.InsectSwarmManaCost));
retVal.Add("Starfall", String.Format("{0:F2} dps*{1:F2} avg per cast\n{2:F2} avg per star\n{3:F0} avg mana",
SelectedRotation.StarfallDamage / 10.0f,
SelectedRotation.StarfallDamage,
SelectedRotation.StarfallDamage / (SelectedRotation.StarfallStars > 0 ? SelectedRotation.StarfallStars : 1f),
StarfallMana));
retVal.Add("Treants", String.Format("{0:F2} dps*{1:F2} avg per cast\n{2:F2} avg per tree",
TreantDamage / 30.0f, TreantDamage, TreantDamage / 3.0f));
return(retVal);
}
public override Stats GetCharacterStats(Character character, Item additionalItem)
{
PriestTalents talents = character.PriestTalents;
Stats statsTotal = new Stats();
Stats baseStats = BaseStats.GetBaseStats(character.Level, character.Class, character.Race);
Stats itemStats = GetItemStats(character, additionalItem);
Stats buffStats = GetBuffsStats(character, _calculationOptions);
// Get the gear/enchants/buffs stats loaded in
statsTotal.Accumulate(baseStats);
statsTotal.Accumulate(itemStats);
statsTotal.Accumulate(buffStats);
Stats statsTalents = new Stats()
{
// we can only wear items that are cloth so we always have our specialization, even naked.
BonusIntellectMultiplier = 0.05f,
BonusShadowDamageMultiplier = (1 + 0.02f * talents.TwinDisciplines) *
(1 + 0.02f * talents.TwistedFaith) *
(1 + 0.15f * talents.Shadowform) - 1,
BonusHolyDamageMultiplier = (1 + 0.02f * talents.TwinDisciplines) - 1,
// this is the shadow priest model so they must have 'Shadow Power'
BonusSpellPowerMultiplier = .15f,
};
statsTotal.Accumulate(statsTalents);
statsTotal.Stamina = (float)Math.Floor(statsTotal.Stamina * (1 + statsTotal.BonusStaminaMultiplier));
statsTotal.Intellect += (float)Math.Floor(itemStats.Intellect * statsTotal.BonusIntellectMultiplier);
statsTotal.Spirit = (float)Math.Round(statsTotal.Spirit * (1 + statsTotal.BonusSpiritMultiplier));
statsTotal.Health += (float)Math.Floor(StatConversion.GetHealthFromStamina(statsTotal.Stamina) * (1f + statsTotal.BonusHealthMultiplier));
statsTotal.Mana = (float)Math.Round(statsTotal.Mana + StatConversion.GetManaFromIntellect(statsTotal.Intellect));
statsTotal.Mana = (float)Math.Round(statsTotal.Mana * (1f + statsTotal.BonusManaMultiplier));
statsTotal.SpellPower += statsTotal.Intellect - 10;
float hasteFromRating = StatConversion.GetSpellHasteFromRating(statsTotal.HasteRating);
float talentedHaste = (1 + hasteFromRating) * (1 + talents.Darkness * .01f) - 1;
statsTotal.SpellHaste += character.Race == CharacterRace.Goblin ? talentedHaste * 1.01f : talentedHaste;
float baseBonus = (float)Math.Floor(baseStats.Spirit * statsTotal.BonusSpiritMultiplier);
float itemBonus = (float)Math.Floor(itemStats.Spirit * statsTotal.BonusSpiritMultiplier);
float spiritFromItemsAndEffects = baseBonus + itemBonus + itemStats.Spirit;
float hitRatingFromSpirit = (0.5f * talents.TwistedFaith) * Math.Max(0f, spiritFromItemsAndEffects);
statsTotal.HitRating += hitRatingFromSpirit;
statsTotal.SpellHit += StatConversion.GetSpellHitFromRating(statsTotal.HitRating);
// ignoring the base crit percentage here as the in-game tooltip says that the int -> crit conversion contains the base.
float critFromInt = StatConversion.GetSpellCritFromIntellect(statsTotal.Intellect) + 0.012375f;
float critFromRating = StatConversion.GetSpellCritFromRating(statsTotal.CritRating);
statsTotal.SpellCrit = character.Race == CharacterRace.Worgen ? (critFromInt + critFromRating) + .01f : (critFromInt + critFromRating);
// Armor
statsTotal.Armor = statsTotal.Armor * (1f + statsTotal.BaseArmorMultiplier);
statsTotal.BonusArmor = statsTotal.BonusArmor * (1f + statsTotal.BonusArmorMultiplier);
statsTotal.Armor += statsTotal.BonusArmor;
statsTotal.Armor = (float)Math.Round(statsTotal.Armor);
return(statsTotal);
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
dictValues.Add("Single Target Points", SingleTargetPoints.ToString());
dictValues.Add("Sustained Points", SustainedPoints.ToString());
dictValues.Add("Survival Points", SurvivalPoints.ToString());
dictValues.Add("Overall Points", OverallPoints.ToString());
dictValues.Add("Base Health", BasicStats.Health.ToString());
dictValues.Add("Base Armor", Math.Round(BasicStats.Armor, 0) + "*Reduces damage taken by " + Math.Round(StatConversion.GetArmorDamageReduction(83, BasicStats.Armor, 0, 0, 0) * 100.0f, 2) + "%");
dictValues.Add("Base Mana", BasicStats.Mana.ToString());
dictValues.Add("Base Stamina", BasicStats.Stamina.ToString());
dictValues.Add("Base Intellect", BasicStats.Intellect.ToString());
dictValues.Add("Base Spirit", BasicStats.Spirit.ToString());
dictValues.Add("Base Spell Power", (BasicStats.SpellPower).ToString() + "*" + BasicStats.Spirit * LocalCharacter.DruidTalents.ImprovedTreeOfLife * 0.05f + " from Improved Tree of Life");
dictValues.Add("Base Spell Crit", BasicStats.SpellCrit.ToString());
float speed_from_hr = (1f + StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating));
float speed_from_sh = (1f + BasicStats.SpellHaste);
float speed = speed_from_hr * speed_from_sh;
float hard = (1.5f / (1f * speed_from_sh) - 1) * StatConversion.RATING_PER_SPELLHASTE;
float untilcap = hard - BasicStats.HasteRating;
dictValues.Add("Base Spell Haste", Math.Round((speed - 1.0f) * 100.0f, 2) + "%*" + Math.Round((speed_from_sh - 1.0f) * 100.0f, 2) + "% from spell effects and talents\n" + Math.Round((speed_from_hr - 1.0f) * 100.0f, 2) + "% from " + BasicStats.HasteRating + " haste rating");
// Use Nourish cast time to equal normal GCD
Spell spell = new Nourish(LocalCharacter, BasicStats);
dictValues.Add("Base Global CD", Math.Round(spell.gcd, 2) + " sec*" + Math.Ceiling(untilcap).ToString() + " Haste Rating until hard gcd cap");
dictValues.Add("Health", CombatStats.Health.ToString());
dictValues.Add("Armor", Math.Round(CombatStats.Armor, 0) + "*Reduces damage taken by " + Math.Round(StatConversion.GetArmorDamageReduction(83, CombatStats.Armor, 0, 0, 0) * 100.0f, 2) + "%");
dictValues.Add("Mana", CombatStats.Mana.ToString());
dictValues.Add("Stamina", CombatStats.Stamina.ToString());
dictValues.Add("Intellect", CombatStats.Intellect.ToString());
dictValues.Add("Spirit", CombatStats.Spirit.ToString());
dictValues.Add("Spell Power", (CombatStats.SpellPower).ToString() + "*" + CombatStats.Spirit * LocalCharacter.DruidTalents.ImprovedTreeOfLife * 0.05f + " from Improved Tree of Life");
dictValues.Add("Spell Crit", CombatStats.SpellCrit.ToString());
speed_from_hr = (1f + StatConversion.GetSpellHasteFromRating(CombatStats.HasteRating));
speed_from_sh = (1f + CombatStats.SpellHaste);
speed = speed_from_hr * speed_from_sh;
hard = (1.5f / (1f * speed_from_sh) - 1) * StatConversion.RATING_PER_SPELLHASTE;
untilcap = hard - CombatStats.HasteRating;
dictValues.Add("Spell Haste", Math.Round((speed - 1.0f) * 100.0f, 2) + "%*" + Math.Round((speed_from_sh - 1.0f) * 100.0f, 2) + "% from spell effects and talents\n" + Math.Round((speed_from_hr - 1.0f) * 100.0f, 2) + "% from " + CombatStats.HasteRating + " haste rating");
// Use Nourish cast time to equal normal GCD
spell = Sustained.spellMix.nourish[0];
dictValues.Add("Global CD", Math.Round(spell.gcd, 2) + " sec*" + Math.Ceiling(untilcap).ToString() + " Haste Rating until soft gcd cap");
dictValues.Add("Total Time", Math.Round(Sustained.TotalTime, 2).ToString());
dictValues.Add("Time until OOM (unreduced)", Math.Round(Sustained.TimeToOOM_unreduced, 2).ToString());
dictValues.Add("Time until OOM", Math.Round(Sustained.TimeToOOM, 2).ToString());
dictValues.Add("Total healing done", Math.Round(Sustained.TotalTime * SustainedHPS, 2).ToString()); // Has extra component from procs
dictValues.Add("Sustained HPS", Math.Round(SustainedHPS, 2).ToString());
dictValues.Add("Single Target HPS", Math.Round(SingleTargetHPS, 2).ToString());
dictValues.Add("Mana regen per second", Math.Round(Sustained.ManaRegen, 2).ToString());
dictValues.Add("Mana from innervates", Math.Round(Sustained.InnervateMana, 2).ToString());
dictValues.Add("Average casts per minute", Math.Round(Sustained.spellMix.CastsPerMinute, 2).ToString());
dictValues.Add("Average crits per minute", Math.Round(Sustained.spellMix.CritsPerMinute, 2).ToString());
dictValues.Add("Average heals per minute", Math.Round(Sustained.spellMix.HealsPerMinute, 2).ToString());
dictValues.Add("Rejuvenation casts per minute", Math.Round(Sustained.spellMix.RejuvCPM, 2).ToString());
dictValues.Add("Rejuvenation average up", Math.Round(Sustained.spellMix.RejuvAvg, 2).ToString());
dictValues.Add("Regrowth casts per minute", Math.Round(Sustained.spellMix.RegrowthCPM, 2).ToString());
dictValues.Add("Regrowth average up", Math.Round(Sustained.spellMix.RegrowthAvg, 2).ToString());
dictValues.Add("Lifebloom (stack) casts per minute", Math.Round(Sustained.spellMix.LifebloomStackCPM, 2).ToString());
dictValues.Add("Lifebloom (stack) average up", Math.Round(Sustained.spellMix.LifebloomStackAvg, 2).ToString());
dictValues.Add("Lifebloom (stack) method", LifebloomMethod_ToString(3, Sustained.rotSettings.lifeBloomType));
dictValues.Add("Lifebloom casts per minute", Math.Round(Sustained.spellMix.LifebloomCPM, 2).ToString());
dictValues.Add("Lifebloom average up", Math.Round(Sustained.spellMix.LifebloomAvg, 2).ToString());
dictValues.Add("Nourish casts per minute", Math.Round(Sustained.spellMix.NourishCPM, 2).ToString());
//dictValues.Add("Healing Touch casts per minute", Math.Round(, 2).ToString());
dictValues.Add("Swiftmend casts per minute", Math.Round(Sustained.spellMix.SwiftmendCPM, 2).ToString());
dictValues.Add("Wild Growth casts per minute", Math.Round(Sustained.spellMix.WildGrowthCPM, 2).ToString());
dictValues.Add("Revitalize procs per minute", Math.Round(Sustained.spellMix.RevitalizeProcsPerMinute, 2).ToString());
dictValues.Add("RJ Heal per tick", Math.Round(Sustained.spellMix.rejuvenate.PeriodicTickwithCrit, 2).ToString());
dictValues.Add("RJ Tick time", Math.Round(Sustained.spellMix.rejuvenate.PeriodicTickTime, 2).ToString());
dictValues.Add("RJ HPS", Math.Round(Sustained.spellMix.rejuvenate.HPS, 2).ToString());
dictValues.Add("RJ HPM", Math.Round(Sustained.spellMix.rejuvenate.HPM, 2).ToString());
dictValues.Add("RJ HPCT", Math.Round(Sustained.spellMix.rejuvenate.HPCT, 2).ToString());
dictValues.Add("RG Heal", Sustained.spellMix.regrowth.ToString());
dictValues.Add("RG Tick", Math.Round(Sustained.spellMix.regrowth.PeriodicTickwithCrit, 2).ToString());
dictValues.Add("RG HPS", Math.Round(Sustained.spellMix.regrowth.HPS, 2).ToString());
dictValues.Add("RG HPS (HoT only)", Math.Round(Sustained.spellMix.regrowth.HPS_HOT, 2).ToString());
dictValues.Add("RG HPM", Math.Round(Sustained.spellMix.regrowth.HPM, 2).ToString());
dictValues.Add("RG HPCT", Math.Round(Sustained.spellMix.regrowth.HPCT, 2).ToString());
dictValues.Add("RG Heal (spam)", Sustained.spellMix.regrowthAgain.ToString());
dictValues.Add("RG HPS (spam)", Math.Round(Sustained.spellMix.regrowthAgain.HPCT_DH, 2).ToString());
dictValues.Add("RG HPM (spam)", Math.Round(Sustained.spellMix.regrowthAgain.HPM_DH, 2).ToString());
dictValues.Add("RG HPCT (spam)", Math.Round(Sustained.spellMix.regrowthAgain.HPCT_DH, 2).ToString());
dictValues.Add("LB Tick", Math.Round(Sustained.spellMix.lifebloom.PeriodicTick, 2).ToString());
dictValues.Add("LB Bloom Heal", Math.Round(Sustained.spellMix.lifebloom.AverageHealingwithCrit, 2).ToString());
dictValues.Add("LB HPS", Math.Round(Sustained.spellMix.lifebloom.HPS, 2).ToString());
dictValues.Add("LB HPS (HoT only)", Math.Round(Sustained.spellMix.lifebloom.HPS_HOT, 2).ToString());
dictValues.Add("LB HPM", Math.Round(Sustained.spellMix.lifebloom.HPM, 2).ToString());
dictValues.Add("LB HPCT", Math.Round(Sustained.spellMix.lifebloom.HPCT, 2).ToString());
dictValues.Add("LBx2 (fast stack) HPS", Math.Round(Sustained.spellMix.lifebloomFast2Stack.HPS, 2).ToString());
dictValues.Add("LBx2 (fast stack) HPM", Math.Round(Sustained.spellMix.lifebloomFast2Stack.HPM, 2).ToString());
dictValues.Add("LBx2 (fast stack) HPCT", Math.Round(Sustained.spellMix.lifebloomFast2Stack.HPCT, 2).ToString());
dictValues.Add("LBx3 (fast stack) HPS", Math.Round(Sustained.spellMix.lifebloomFastStack.HPS, 2).ToString());
dictValues.Add("LBx3 (fast stack) HPM", Math.Round(Sustained.spellMix.lifebloomFastStack.HPM, 2).ToString());
dictValues.Add("LBx3 (fast stack) HPCT", Math.Round(Sustained.spellMix.lifebloomFastStack.HPCT, 2).ToString());
dictValues.Add("LBx2 (slow stack) HPS", Math.Round(Sustained.spellMix.lifebloomSlow2Stack.HPS, 2).ToString());
dictValues.Add("LBx2 (slow stack) HPM", Math.Round(Sustained.spellMix.lifebloomSlow2Stack.HPM, 2).ToString());
dictValues.Add("LBx2 (slow stack) HPCT", Math.Round(Sustained.spellMix.lifebloomSlow2Stack.HPCT, 2).ToString());
dictValues.Add("LBx3 (slow stack) HPS", Math.Round(Sustained.spellMix.lifebloomSlowStack.HPS, 2).ToString());
dictValues.Add("LBx3 (slow stack) HPM", Math.Round(Sustained.spellMix.lifebloomSlowStack.HPM, 2).ToString());
dictValues.Add("LBx3 (slow stack) HPCT", Math.Round(Sustained.spellMix.lifebloomSlowStack.HPCT, 2).ToString());
dictValues.Add("LBx3 (rolling) Tick", Math.Round(Sustained.spellMix.lifebloomRollingStack.PeriodicTick, 2).ToString());
dictValues.Add("LBx3 (rolling) HPS", Math.Round(Sustained.spellMix.lifebloomRollingStack.HPS, 2).ToString());
dictValues.Add("LBx3 (rolling) HPM", Math.Round(Sustained.spellMix.lifebloomRollingStack.HPM, 2).ToString());
dictValues.Add("LBx3 (rolling) HPCT", Math.Round(Sustained.spellMix.lifebloomRollingStack.HPCT, 2).ToString());
dictValues.Add("HT Heal", Sustained.spellMix.healingTouch.ToString());
dictValues.Add("HT HPS", Math.Round(Sustained.spellMix.healingTouch.HPCT_DH, 2).ToString());
dictValues.Add("HT HPM", Math.Round(Sustained.spellMix.healingTouch.HPM_DH, 2).ToString());
dictValues.Add("HT HPCT", Math.Round(Sustained.spellMix.healingTouch.HPCT_DH, 2).ToString());
dictValues.Add("WG first Tick", Math.Round(Sustained.spellMix.wildGrowth.Tick[0], 2).ToString());
dictValues.Add("WG HPS(single target)", Math.Round(Sustained.spellMix.wildGrowth.HPS, 2).ToString());
dictValues.Add("WG HPM(single target)", Math.Round(Sustained.spellMix.wildGrowth.HPM, 2).ToString());
dictValues.Add("WG HPS(max)", Math.Round(Sustained.spellMix.wildGrowth.HPS * Sustained.spellMix.wildGrowth.maxTargets, 2).ToString());
dictValues.Add("WG HPM(max)", Math.Round(Sustained.spellMix.wildGrowth.HPM * Sustained.spellMix.wildGrowth.maxTargets, 2).ToString());
dictValues.Add("N Heal", Sustained.spellMix.nourish[0].ToString());
dictValues.Add("N HPM", Math.Round(Sustained.spellMix.nourish[0].HPM_DH, 2).ToString());
dictValues.Add("N HPS", Math.Round(Sustained.spellMix.nourish[0].HPCT_DH, 2).ToString());
dictValues.Add("N HPCT", Math.Round(Sustained.spellMix.nourish[0].HPCT_DH, 2).ToString());
dictValues.Add("N (1 HoT) Heal", Sustained.spellMix.nourish[1].ToString());
dictValues.Add("N (1 HoT) HPM", Math.Round(Sustained.spellMix.nourish[1].HPM_DH, 2).ToString());
dictValues.Add("N (1 HoT) HPS", Math.Round(Sustained.spellMix.nourish[1].HPCT_DH, 2).ToString());
dictValues.Add("N (1 HoT) HPCT", Math.Round(Sustained.spellMix.nourish[1].HPCT_DH, 2).ToString());
dictValues.Add("N (2 HoTs) Heal", Sustained.spellMix.nourish[2].ToString());
dictValues.Add("N (2 HoTs) HPM", Math.Round(Sustained.spellMix.nourish[2].HPM_DH, 2).ToString());
dictValues.Add("N (2 HoTs) HPS", Math.Round(Sustained.spellMix.nourish[2].HPCT_DH, 2).ToString());
dictValues.Add("N (2 HoTs) HPCT", Math.Round(Sustained.spellMix.nourish[2].HPCT_DH, 2).ToString());
dictValues.Add("N (3 HoTs) Heal", Sustained.spellMix.nourish[3].ToString());
dictValues.Add("N (3 HoTs) HPM", Math.Round(Sustained.spellMix.nourish[3].HPM_DH, 2).ToString());
dictValues.Add("N (3 HoTs) HPS", Math.Round(Sustained.spellMix.nourish[3].HPCT_DH, 2).ToString());
dictValues.Add("N (3 HoTs) HPCT", Math.Round(Sustained.spellMix.nourish[3].HPCT_DH, 2).ToString());
dictValues.Add("N (4 HoTs) Heal", Sustained.spellMix.nourish[4].ToString());
dictValues.Add("N (4 HoTs) HPM", Math.Round(Sustained.spellMix.nourish[4].HPM_DH, 2).ToString());
dictValues.Add("N (4 HoTs) HPS", Math.Round(Sustained.spellMix.nourish[4].HPCT_DH, 2).ToString());
dictValues.Add("N (4 HoTs) HPCT", Math.Round(Sustained.spellMix.nourish[4].HPCT_DH, 2).ToString());
Swiftmend swift = new Swiftmend(LocalCharacter, CombatStats, new Rejuvenation(LocalCharacter, CombatStats), null);
dictValues.Add("SM Rejuv Heal", swift.ToString());
dictValues.Add("SM Rejuv HPM", Math.Round(swift.HPM, 2).ToString());
dictValues.Add("SM Rejuv Lost Ticks", Math.Round(swift.rejuvTicksLost, 2).ToString());
swift = new Swiftmend(LocalCharacter, BasicStats, null, new Regrowth(LocalCharacter, BasicStats));
dictValues.Add("SM Regrowth Heal", swift.ToString());
dictValues.Add("SM Regrowth HPM", Math.Round(swift.HPM, 2).ToString());
dictValues.Add("SM Regrowth Lost Ticks", Math.Round(swift.regrowthTicksLost, 2).ToString());
swift = new Swiftmend(LocalCharacter, BasicStats, new Rejuvenation(LocalCharacter, BasicStats), new Regrowth(LocalCharacter, BasicStats));
dictValues.Add("SM Both Heal", swift.ToString());
dictValues.Add("SM Both HPM", Math.Round(swift.HPM, 2).ToString());
dictValues.Add("SM Both Rejuv Lost Ticks", Math.Round(swift.rejuvTicksLost, 2).ToString());
dictValues.Add("SM Both Regrowth Lost Ticks", Math.Round(swift.regrowthTicksLost, 2).ToString());
return(dictValues);
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
dictValues.Add("Health", BasicStats.Health.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Mana", BasicStats.Mana.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Attack Power", BasicStats.AttackPower.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Agility", BasicStats.Agility.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Strength", BasicStats.Strength.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Intellect", BasicStats.Intellect.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("White Hit", WhiteHit.ToString("F2", CultureInfo.InvariantCulture) + "%");
if (YellowHit < 100f && TotalExpertiseMH < 26)
{
float ratingRequired = (float)Math.Ceiling(4f * StatConversion.GetRatingFromExpertise(100f - YellowHit));
dictValues.Add("Yellow Hit", String.Format("{0}% (Under Cap)*You need {1} more expertise to cap specials (WF,SS)",
YellowHit.ToString("F2", CultureInfo.InvariantCulture),
ratingRequired.ToString("F0", CultureInfo.InvariantCulture)));
}
else
{
if (ParriedAttacks > 0)
{
float ratingRequired = (float)Math.Ceiling(4f * StatConversion.GetRatingFromExpertise(100f - YellowHit));
dictValues.Add("Yellow Hit", String.Format("{0}%*Being in front of boss allows your attacks to be parried\r\nYou would need {1} more expertise to cap specials (WF,SS)",
YellowHit.ToString("F2", CultureInfo.InvariantCulture),
ratingRequired.ToString("F0", CultureInfo.InvariantCulture)));
}
else
{
dictValues.Add("Yellow Hit", YellowHit.ToString("F2", CultureInfo.InvariantCulture) + "%");
}
}
if (OverSpellHitCap > 0.38f) // only warn if more than .38% over cap (equivalent to 10 hit rating)
{
dictValues.Add("Spell Hit", String.Format("{0}% (Over Cap)*Over Spell Hit Cap by {1}%",
SpellHit.ToString("F2", CultureInfo.InvariantCulture),
OverSpellHitCap.ToString("F2", CultureInfo.InvariantCulture)));
}
else
{
if (SpellHit < 100f)
{
float ratingRequired = (float)Math.Ceiling(StatConversion.GetRatingFromHit(1f - SpellHit / 100f));
dictValues.Add("Spell Hit", String.Format("{0}% (Under Cap)*You need {1} more hit rating to cap spells (ES, LB etc)",
SpellHit.ToString("F2", CultureInfo.InvariantCulture),
ratingRequired.ToString("F0", CultureInfo.InvariantCulture)));
}
else
{
dictValues.Add("Spell Hit", SpellHit.ToString("F2", CultureInfo.InvariantCulture) + "%");
}
}
if (OverMeleeCritCap > 0.21f) // only warn if more than .21% over cap (equivalent to 10 crit rating)
{
dictValues.Add("Melee Crit", String.Format("{0} (Over Cap)*Crit Rating {1} (+{2}% crit chance)\r\nOver Soft Cap by {3}%",
MeleeCrit.ToString("F2", CultureInfo.InvariantCulture) + "%",
BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetCritFromRating(BasicStats.CritRating) * 100f).ToString("F2", CultureInfo.InvariantCulture),
OverMeleeCritCap.ToString("F2", CultureInfo.InvariantCulture)));
}
else
{
dictValues.Add("Melee Crit", String.Format("{0}*Crit Rating {1} (+{2}% crit chance)",
MeleeCrit.ToString("F2", CultureInfo.InvariantCulture) + "%",
BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetCritFromRating(BasicStats.CritRating) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
}
dictValues.Add("Spell Crit", String.Format("{0}*Crit Rating {1} (+{2}% crit chance)",
SpellCrit.ToString("F2", CultureInfo.InvariantCulture) + "%",
BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetSpellCritFromRating(BasicStats.CritRating) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Spellpower", BasicStats.SpellPower.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Total Expertise", getExpertiseString());
dictValues.Add("Haste Rating", String.Format("{0}*{1}% Melee Haste\r\n{2}% Spell Haste",
BasicStats.HasteRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetHasteFromRating(BasicStats.HasteRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture),
(StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Hit Rating", String.Format("{0}*{1}% Melee Hit\r\n{2}% Spell Hit",
BasicStats.HitRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetHitFromRating(BasicStats.HitRating) * 100f).ToString("F2", CultureInfo.InvariantCulture),
(StatConversion.GetSpellHitFromRating(BasicStats.HitRating) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Armour Pen Rating", String.Format("{0}*{1}% Armour Penetration",
BasicStats.ArmorPenetrationRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetArmorPenetrationFromRating(BasicStats.ArmorPenetrationRating) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
float spellMiss = 100 - SpellHit;
dictValues.Add("Avoided Attacks", String.Format("{0}%*{1}% Boss Dodged\r\n{2}% Boss Parried\r\n{3}% Spell Misses\r\n{4}% White Misses",
AvoidedAttacks.ToString("F2", CultureInfo.InvariantCulture),
DodgedAttacks.ToString("F2", CultureInfo.InvariantCulture),
ParriedAttacks.ToString("F2", CultureInfo.InvariantCulture),
spellMiss.ToString("F2", CultureInfo.InvariantCulture),
MissedAttacks.ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Avg MH Speed", AvMHSpeed.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Avg OH Speed", AvOHSpeed.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Armor Mitigation", ArmorMitigation.ToString("F2", CultureInfo.InvariantCulture) + "%*Amount of physical damage lost due to boss armor");
dictValues.Add("ED Uptime", String.Format("{0}%*{1}% ED Bonus Crit",
EDUptime.ToString("F2", CultureInfo.InvariantCulture),
EDBonusCrit.ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Flurry Uptime", FlurryUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Avg Time to 5 Stack", String.Format("{0} sec*{1} PPM",
SecondsTo5Stack.ToString("F2", CultureInfo.InvariantCulture),
_MWPPM.ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("MH Enchant Uptime", MHEnchantUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("OH Enchant Uptime", OHEnchantUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Trinket 1 Uptime", Trinket1Uptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Trinket 2 Uptime", Trinket2Uptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Fire Totem Uptime", FireTotemUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Tier 10 2 pc Uptime", T10_2Uptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Tier 10 4 pc Uptime", T10_4Uptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("DPS Points", DPSPoints.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Survivability Points", SurvivabilityPoints.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Overall Points", OverallPoints.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("White Damage", dpsOutputFormat(SwingDamage, DPSPoints, true));
dictValues.Add("Windfury Attack", dpsOutputFormat(WindfuryAttack, DPSPoints, true));
dictValues.Add("Flametongue Attack", dpsOutputFormat(FlameTongueAttack, DPSPoints, false));
dictValues.Add("Lightning Bolt", dpsOutputFormat(LightningBolt, DPSPoints, false));
dictValues.Add("Earth Shock", dpsOutputFormat(EarthShock, DPSPoints, false));
dictValues.Add("Flame Shock", dpsOutputFormat(FlameShock, DPSPoints, false));
dictValues.Add("Searing/Magma Totem", dpsOutputFormat(SearingMagma, DPSPoints, false));
dictValues.Add("Stormstrike", dpsOutputFormat(Stormstrike, DPSPoints, true));
dictValues.Add("Spirit Wolf", dpsOutputFormat(SpiritWolf, DPSPoints, true));
dictValues.Add("Fire Nova", dpsOutputFormat(FireNova, DPSPoints, false));
dictValues.Add("Fire Elemental", FireElemental.getDPSOutput());
dictValues.Add("Lightning Shield", dpsOutputFormat(LightningShield, DPSPoints, false));
dictValues.Add("Lava Lash", dpsOutputFormat(LavaLash, DPSPoints, true));
dictValues.Add("Total DPS", DPSPoints.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Enhance Version", _version);
dictValues.Add("Status", String.Format("Enhance Model : DPS Points {0}, Survivability Points {1}, Overall Points {2}",
DPSPoints.ToString("F2", CultureInfo.InvariantCulture),
SurvivabilityPoints.ToString("F2", CultureInfo.InvariantCulture),
OverallPoints.ToString("F2", CultureInfo.InvariantCulture)));
return(dictValues);
}
public ProcEffect(SpecialEffect effect)
{
this.Effect = effect;
// Shadow damage procs - most widely varied at the current moment
if (effect.Stats.ShadowDamage > 0)
{
CalculateDPS = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float sp, float sHi, float sc, float sHa)
{
SpecialEffect e = Effect;
float specialDamageModifier = (1 + c.BasicStats.BonusSpellPowerMultiplier) * (1 + c.BasicStats.BonusShadowDamageMultiplier) * (1 + c.BasicStats.BonusDamageMultiplier);
float triggerInterval = 0.0f;
switch (e.Trigger)
{
case Trigger.DoTTick: // Extract
triggerInterval = r.Duration / r.DotTicks;
break;
case Trigger.SpellHit: // Pendulum
triggerInterval = r.Duration / r.CastCount;
break;
case Trigger.DamageDone: // DMC: Death
triggerInterval = r.Duration / (r.CastCount + r.DotTicks);
break;
case Trigger.DamageOrHealingDone: // DMC: Greatness
// Need to add Self-Heals
triggerInterval = r.Duration / (r.CastCount + r.DotTicks);
break;
default:
return(0.0f);
}
float procsPerSecond = e.GetAverageProcsPerSecond(triggerInterval, 1.0f, 3.0f, c.FightLength * 60.0f);
return(e.Stats.ShadowDamage * specialDamageModifier * procsPerSecond);
};
}
// Lightning Capacitor, Thunder Capacitor, Reign of the Unliving/Undead, Nibelung
else if (effect.Stats.NatureDamage > 0 || effect.Stats.FireDamage > 0 || effect.Stats.ValkyrDamage > 0)
{
if (effect.Stats.NatureDamage > 0)
{
CalculateDPS = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float sp, float sHi, float sc, float sHa)
{
float specialDamageModifier = (1 + c.BasicStats.BonusSpellPowerMultiplier) * (1 + c.BasicStats.BonusNatureDamageMultiplier) * (1 + c.BasicStats.BonusDamageMultiplier);
float procsPerSecond = Effect.GetAverageProcsPerSecond(r.Duration / (r.CastCount * sc), 1.0f, 3.0f, c.FightLength * 60.0f);
return(Effect.Stats.NatureDamage * specialDamageModifier * procsPerSecond);
};
}
else if (effect.Stats.FireDamage > 0)
{
CalculateDPS = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float sp, float sHi, float sc, float sHa)
{
float specialDamageModifier = (1 + c.BasicStats.BonusSpellPowerMultiplier) * (1 + c.BasicStats.BonusFireDamageMultiplier) * (1 + c.BasicStats.BonusDamageMultiplier);
float procsPerSecond = Effect.GetAverageProcsPerSecond(r.Duration / (r.CastCount * sc), 1.0f, 3.0f, c.FightLength * 60.0f);
return(Effect.Stats.FireDamage * specialDamageModifier * procsPerSecond);
};
}
else
{
CalculateDPS = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float sp, float sHi, float sc, float sHa)
{
float specialDamageModifier = (1 + c.BasicStats.BonusSpellPowerMultiplier) * (1 + c.BasicStats.BonusDamageMultiplier);
float procsPerSecond = Effect.GetAverageProcsPerSecond(r.Duration / (r.CastCount * sc), 1.0f, 3.0f, c.FightLength * 60.0f);
return(Effect.Stats.ValkyrDamage * specialDamageModifier * procsPerSecond);
};
}
}
else if (effect.Stats.Mp5 > 0)
{
CalculateMP5 = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float sp, float sHi, float sc, float sHa)
{
SpecialEffect e = Effect;
float procsPerSecond = e.GetAverageProcsPerSecond(r.Duration / r.CastCount, 1.0f, 3.0f, c.FightLength * 60f);
return((e.Stats.Mp5 / 5.0f * e.Duration) * procsPerSecond * 5.0f);
};
}
// Moonkin 4T8 set bonus (15% chance on IS tick to proc an instant-cast Starfire)
else if (effect.Stats.StarfireProc == 1)
{
CalculateDPS = delegate(SpellRotation r, CharacterCalculationsMoonkin c, float sp, float sHi, float sc, float sHa)
{
if (r.InsectSwarmTicks == 0)
{
return(0.0f);
}
Spell newSF = new Spell()
{
AllDamageModifier = r.Solver.Starfire.AllDamageModifier,
BaseCastTime = 1.5f,
BaseDamage = r.Solver.Starfire.BaseDamage,
BaseManaCost = r.Solver.Starfire.BaseManaCost,
CriticalChanceModifier = r.Solver.Starfire.CriticalChanceModifier,
CriticalDamageModifier = r.Solver.Starfire.CriticalDamageModifier,
DotEffect = null,
IdolExtraSpellPower = r.Solver.Starfire.IdolExtraSpellPower,
Name = r.Solver.Starfire.Name,
School = r.Solver.Starfire.School,
SpellDamageModifier = r.Solver.Starfire.SpellDamageModifier
};
r.DoSpecialStarfire(c, ref newSF, sp, sHi, sc, sHa);
float timeBetweenProcs = r.Solver.InsectSwarm.DotEffect.TickLength / Effect.Chance;
float replaceWrathWithSFDPS = (newSF.DamagePerHit / newSF.CastTime) - (r.Solver.Wrath.DamagePerHit / r.Solver.Wrath.CastTime);
float replaceSFWithSFDPS = (newSF.DamagePerHit / newSF.CastTime) - (r.Solver.Starfire.DamagePerHit / r.Solver.Starfire.CastTime);
return((replaceWrathWithSFDPS * (r.WrathCount / (r.WrathCount + r.StarfireCount)) +
replaceSFWithSFDPS * (r.StarfireCount / (r.WrathCount + r.StarfireCount)))
/ timeBetweenProcs);
};
}
else if (Effect.Stats._rawSpecialEffectDataSize == 0 &&
(Effect.Trigger == Trigger.DamageDone ||
Effect.Trigger == Trigger.DamageOrHealingDone ||
Effect.Trigger == Trigger.DamageSpellCast ||
Effect.Trigger == Trigger.DamageSpellCrit ||
Effect.Trigger == Trigger.DamageSpellHit ||
Effect.Trigger == Trigger.SpellCast ||
Effect.Trigger == Trigger.SpellCrit ||
Effect.Trigger == Trigger.SpellHit ||
Effect.Trigger == Trigger.SpellMiss ||
Effect.Trigger == Trigger.Use ||
Effect.Trigger == Trigger.MoonfireCast ||
Effect.Trigger == Trigger.InsectSwarmOrMoonfireTick ||
Effect.Trigger == Trigger.MoonfireTick ||
Effect.Trigger == Trigger.InsectSwarmTick ||
Effect.Trigger == Trigger.DoTTick) &&
(Effect.Stats.HasteRating > 0 ||
Effect.Stats.SpellHaste > 0 ||
Effect.Stats.CritRating > 0 ||
Effect.Stats.HighestStat > 0))
{
Activate = delegate(Character ch, CharacterCalculationsMoonkin c, ref float sp, ref float sHi, ref float sc, ref float sHa)
{
SpecialEffect e = Effect;
int maxStack = e.MaxStack;
Stats st = e.Stats;
float critRating = st.CritRating;
float spellCrit = StatConversion.GetSpellCritFromRating(critRating * maxStack);
float hasteRating = st.HasteRating;
float spellHaste = StatConversion.GetSpellHasteFromRating(hasteRating * maxStack);
spellHaste += st.SpellHaste;
float highestStat = st.HighestStat;
if (critRating > 0)
{
sc += spellCrit;
}
if (spellHaste > 0)
{
sHa += spellHaste;
}
if (highestStat > 0)
{
if (c.BasicStats.Spirit > c.BasicStats.Intellect)
{
Stats s = c.BasicStats.Clone();
s.Spirit += highestStat;
CharacterCalculationsMoonkin cNew = CalculationsMoonkin.GetInnerCharacterCalculations(ch, s, null);
storedStats.SpellPower = cNew.SpellPower - c.SpellPower;
sp += storedStats.SpellPower;
}
else
{
Stats s = c.BasicStats.Clone();
s.Intellect += highestStat;
CharacterCalculationsMoonkin cNew = CalculationsMoonkin.GetInnerCharacterCalculations(ch, s, null);
storedStats.SpellPower = cNew.SpellPower - c.SpellPower;
storedStats.SpellCrit = cNew.SpellCrit - c.SpellCrit;
sp += storedStats.SpellPower;
sc += storedStats.SpellCrit;
}
}
};
Deactivate = delegate(Character ch, CharacterCalculationsMoonkin c, ref float sp, ref float sHi, ref float sc, ref float sHa)
{
SpecialEffect e = Effect;
int maxStack = e.MaxStack;
Stats st = e.Stats;
float critRating = st.CritRating;
float spellCrit = StatConversion.GetSpellCritFromRating(critRating * maxStack);
float hasteRating = st.HasteRating;
float spellHaste = StatConversion.GetSpellHasteFromRating(hasteRating * maxStack);
spellHaste += st.SpellHaste;
float highestStat = st.HighestStat;
if (critRating > 0)
{
sc -= spellCrit;
}
if (spellHaste > 0)
{
sHa -= spellHaste;
}
if (highestStat > 0)
{
sp -= storedStats.SpellPower;
if (c.BasicStats.Intellect >= c.BasicStats.Spirit)
{
sc -= storedStats.SpellCrit;
}
}
};
UpTime = delegate(SpellRotation r, CharacterCalculationsMoonkin c)
{
float upTime = 0.0f;
switch (Effect.Trigger)
{
case Trigger.Use:
upTime = Effect.GetAverageUptime(0f, 1f);
break;
case Trigger.SpellHit:
case Trigger.DamageSpellHit:
upTime = Effect.GetAverageUptime(r.Duration / r.CastCount, r.Solver.GetSpellHit(c));
break;
case Trigger.DamageSpellCrit:
case Trigger.SpellCrit:
upTime = Effect.GetAverageUptime(r.Duration / (r.CastCount - (r.InsectSwarmTicks / r.Solver.InsectSwarm.DotEffect.NumberOfTicks)), c.SpellCrit);
break;
case Trigger.SpellCast:
case Trigger.DamageSpellCast:
upTime = Effect.GetAverageUptime(r.Duration / r.CastCount, 1f);
break;
case Trigger.MoonfireCast:
upTime = Effect.GetAverageUptime(r.Duration / r.MoonfireCasts, 1f);
break;
case Trigger.InsectSwarmOrMoonfireTick:
upTime = Effect.GetAverageUptime(r.Duration / (r.InsectSwarmTicks + r.MoonfireTicks), 1f);
break;
case Trigger.MoonfireTick:
upTime = Effect.GetAverageUptime(r.Duration / r.MoonfireTicks, 1f);
break;
case Trigger.InsectSwarmTick:
upTime = Effect.GetAverageUptime(r.Duration / r.InsectSwarmTicks, 1f);
break;
case Trigger.DoTTick:
upTime = Effect.GetAverageUptime(r.Duration / (r.MoonfireTicks + r.InsectSwarmTicks), 1f);
break;
case Trigger.DamageDone:
case Trigger.DamageOrHealingDone:
upTime = Effect.GetAverageUptime(((r.Duration / r.CastCount) + (r.Duration / (r.MoonfireTicks + r.InsectSwarmTicks))) / 2.0f, 1f);
break;
default:
break;
}
return(upTime);
};
}
}
GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues
= new Dictionary <string, string>();
dictValues.Add("Personal DPS", string.Format("{0:0}", PersonalDps));
dictValues.Add("Pet DPS", string.Format("{0:0}", PetDps));
dictValues.Add("Total DPS", string.Format("{0:0}", OverallPoints));
dictValues.Add(
"Health",
string.Format(
"{0:0.0}*{1:0.0} stamina",
CalcHealth(),
CalcStamina()));
dictValues.Add(
"Mana",
string.Format(
"{0:0.0}*{1:0.0} intellect",
CalcMana(),
CalcIntellect()));
dictValues.Add(
"Spirit", string.Format("{0:0.0}", CalcSpirit()));
dictValues.Add(
"Bonus Damage",
string.Format(
"{0:0.0}*{1:0.0}\tBefore Procs",
CalcSpellPower(),
StatUtils.CalcSpellPower(PreProcStats)));
#region Hit Rating
float onePercentOfHitRating
= (1 / StatConversion.GetSpellHitFromRating(1));
float hitFromRating
= StatConversion.GetSpellHitFromRating(Stats.HitRating);
float hitFromTalents = Talents.Suppression * 0.01f;
float hitFromBuffs
= (CalcSpellHit() - hitFromRating - hitFromTalents);
float targetHit = Options.GetBaseHitRate() / 100f;
float totalHit = targetHit + CalcSpellHit();
float missChance = totalHit > 1 ? 0 : (1 - totalHit);
dictValues.Add(
"Hit Rating",
string.Format(
"{0}*{1:0.00%} Hit Chance (max 100%) | {2:0.00%} Miss Chance \r\n\r\n"
+ "{3:0.00%}\t Base Hit Chance on a Level {4:0} target\r\n"
+ "{5:0.00%}\t from {6:0} Hit Rating [gear, food and/or flasks]\r\n"
+ "{7:0.00%}\t from Talent: Suppression\r\n"
+ "{8:0.00%}\t from Buffs: Racial and/or Spell Hit Chance Taken\r\n\r\n"
+ "You are {9} hit rating {10} the 446 hard cap [no hit from gear, talents or buffs]\r\n\r\n"
+ "Hit Rating soft caps:\r\n"
+ "420 - Heroic Presence\r\n"
+ "368 - Suppression\r\n"
+ "342 - Suppression and Heroic Presence\r\n"
+ "289 - Suppression, Improved Faerie Fire / Misery\r\n"
+ "263 - Suppression, Improved Faerie Fire / Misery and Heroic Presence",
Stats.HitRating,
totalHit,
missChance,
targetHit,
Options.TargetLevel,
hitFromRating,
Stats.HitRating,
hitFromTalents,
hitFromBuffs,
Math.Ceiling(
Math.Abs((totalHit - 1) * onePercentOfHitRating)),
(totalHit > 1) ? "above" : "below"));
#endregion
dictValues.Add(
"Crit Chance",
string.Format(
"{0:0.00%}*{1:0.00%}\tBefore Procs",
CalcSpellCrit(),
StatUtils.CalcSpellCrit(PreProcStats)));
dictValues.Add(
"Average Haste",
string.Format(
"{0:0.00}%*"
+ "{1:0.00}%\tfrom {2:0.0} Haste rating\r\n"
+ "{3:0.00}%\tfrom Buffs\r\n"
+ "{4:0.0}ish%\tfrom Procs\r\n"
+ "\r\n"
+ "{5:0.00}s\tGlobal Cooldown\r\n",
(AvgHaste - 1f) * 100f,
StatConversion.GetSpellHasteFromRating(Stats.HasteRating)
* 100f,
Stats.HasteRating,
Stats.SpellHaste * 100f,
(AvgHaste - StatUtils.CalcSpellHaste(PreProcStats)) * 100f,
Math.Max(1.0f, 1.5f / AvgHaste)));
// Pet Stats
if (Pet == null)
{
dictValues.Add("Pet Stamina", "-");
dictValues.Add("Pet Intellect", "-");
dictValues.Add("Pet Health", "-");
}
else
{
dictValues.Add(
"Pet Stamina",
string.Format("{0:0.0}", Pet.CalcStamina()));
dictValues.Add(
"Pet Intellect",
string.Format("{0:0.0}", Pet.CalcIntellect()));
dictValues.Add(
"Pet Health",
string.Format("{0:0.0}", Pet.CalcHealth()));
}
// Spell Stats
foreach (string spellName in Spell.ALL_SPELLS)
{
if (CastSpells.ContainsKey(spellName))
{
dictValues.Add(
spellName, CastSpells[spellName].GetToolTip());
}
else
{
dictValues.Add(spellName, "-");
}
}
return(dictValues);
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
dictValues.Add("DPS Points", DPS.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Survivability Points", Survivability.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Overall Points", OverallPoints.ToString("F2", CultureInfo.InvariantCulture));
dictValues.Add("Health", BasicStats.Health.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Mana", BasicStats.Mana.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Strength", String.Format("{0}*Increases Attack Power by {1}",
BasicStats.Strength.ToString("F0", CultureInfo.InvariantCulture),
(BasicStats.Strength - 10f).ToString("F0", CultureInfo.InvariantCulture)));
dictValues.Add("Agility", String.Format("{0}*Increases Attack Power by {1}\r\nIncreases Critical Hit chance by {2}%",
BasicStats.Agility.ToString("F0", CultureInfo.InvariantCulture),
((BasicStats.Agility * 2f) - 20f).ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetCritFromAgility(BasicStats.Agility, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Stamina", String.Format("{0}*Increase Health by {1}",
BasicStats.Stamina.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetHealthFromStamina(BasicStats.Stamina)).ToString("F0", CultureInfo.InvariantCulture)));
dictValues.Add("Intellect", String.Format("{0}*Increases Mana by {1}\r\nIncreases Spell Power by {2}\r\nIncreases Spell Critical Hit chance by {3}%",
BasicStats.Intellect.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetManaFromIntellect(BasicStats.Intellect)).ToString("F0", CultureInfo.InvariantCulture),
(BasicStats.Intellect - 10f).ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetSpellCritFromIntellect(BasicStats.Intellect, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Spirit", String.Format("{0}*Increases mana regeneration by {1} every 5 seconds while not casting",
BasicStats.Spirit.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetSpiritRegenSec(BasicStats.Spirit, BasicStats.Intellect) * 5f).ToString("F0", CultureInfo.InvariantCulture)));
dictValues.Add("Mastery", String.Format("{0}*Mastery rating of {1} adds {2} Mastery\r\nIncreases all Fire, Frost, and Nature Damage by {3}%.",
(8f + StatConversion.GetMasteryFromRating(BasicStats.MasteryRating)).ToString("F2", CultureInfo.InvariantCulture),
BasicStats.MasteryRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetMasteryFromRating(BasicStats.MasteryRating)).ToString("F2", CultureInfo.InvariantCulture),
((8f + StatConversion.GetMasteryFromRating(BasicStats.MasteryRating)) * 2.5f).ToString("F2", CultureInfo.InvariantCulture)));
//dictValues.Add("Damage"
//dictValues.Add("DPS"
dictValues.Add("Attack Power", BasicStats.AttackPower.ToString("F0", CultureInfo.InvariantCulture));
//dictValues.Add("Speed"
dictValues.Add("Melee Haste", String.Format("{0}%*Haste Rating of {1} adds {2}% Haste",
(StatConversion.GetHasteFromRating(BasicStats.HasteRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture),
BasicStats.HasteRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetHasteFromRating(BasicStats.HasteRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Melee Hit", String.Format("{0}%*Hit Rating of {1} adds {2}% Hit chance\r\n{3}% Draenei Hit Bonus",
(StatConversion.GetHitFromRating(BasicStats.HitRating) * 100f + DraeneiHitBonus * 100f).ToString("F2", CultureInfo.InvariantCulture),
BasicStats.HitRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetHitFromRating(BasicStats.HitRating) * 100f).ToString("F2", CultureInfo.InvariantCulture),
DraeneiHitBonus * 100f));
dictValues.Add("Melee Crit", String.Format("{0}%*Crit Rating of {1} adds {2}% Crit chance",
((StatConversion.GetCritFromRating(BasicStats.CritRating, CharacterClass.Shaman) * 100f) + (StatConversion.GetCritFromAgility(BasicStats.Agility, CharacterClass.Shaman) * 100f)).ToString("F2", CultureInfo.InvariantCulture),
BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetCritFromRating(BasicStats.CritRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Expertise", getExpertiseString());// String.Format("{0} / {1}*Reduces chance to be dodged or parried by {2}% / {3}%\r\nExpertise Rating of {4} adds {5} Expertise",
dictValues.Add("Spell Power", BasicStats.SpellPower.ToString("F0", CultureInfo.InvariantCulture));
dictValues.Add("Spell Haste", String.Format("{0}%*Haste Rating of {1} adds {2}% Haste",
(StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture),
BasicStats.HasteRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetSpellHasteFromRating(BasicStats.HasteRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Spell Hit", String.Format("{0}%*Hit Rating of {1} adds {2}% Hit chance\r\n{3}% Draenei Hit Bonus",
(StatConversion.GetSpellHitFromRating(BasicStats.HitRating + ElemPrecMod) * 100f + DraeneiHitBonus * 100f).ToString("F2", CultureInfo.InvariantCulture),
(BasicStats.HitRating + ElemPrecMod).ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetSpellHitFromRating(BasicStats.HitRating + ElemPrecMod) * 100f).ToString("F2", CultureInfo.InvariantCulture),
DraeneiHitBonus * 100f));
dictValues.Add("Spell Crit", String.Format("{0}%*Crit Rating of {1} adds {2}% Crit chance",
((StatConversion.GetSpellCritFromRating(BasicStats.CritRating, CharacterClass.Shaman) * 100f) + (StatConversion.GetSpellCritFromIntellect(BasicStats.Intellect, CharacterClass.Shaman) * 100f)).ToString("F2", CultureInfo.InvariantCulture),
BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
(StatConversion.GetSpellCritFromRating(BasicStats.CritRating, CharacterClass.Shaman) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Combat Regen", String.Format("{0}*{0} mana regenerated every 5 seconds while in combat",
BaseRegen.ToString("F0", CultureInfo.InvariantCulture)));
//dictValues.Add("Avg Agility", _attackPower.ToString("F0", CultureInfo.InvariantCulture));
//dictValues.Add("Avg Intellect"
//dictValues.Add("Avg Mastery"
//dictValues.Add("Avg Attack Power"
dictValues.Add("Avg Speed", String.Format("{0} / {1}", AvMHSpeed.ToString("F2", CultureInfo.InvariantCulture), AvOHSpeed.ToString("F2", CultureInfo.InvariantCulture)));
//dictValues.Add("Avg Melee Haste"
//dictValues.Add("Avg Melee Hit"
//dictValues.Add("Avg Melee Crit"
//dictValues.Add("Avg Expertise"
//dictValues.Add("Avg Spell Power"
//dictValues.Add("Avg Spell Haste"
//dictValues.Add("Avg Spell Hit"
//dictValues.Add("Avg Spell Crit"
dictValues.Add("Avg Combat Regen", ManaRegen.ToString("F0", CultureInfo.InvariantCulture));
/*dictValues.Add("White Hit", WhiteHit.ToString("F2", CultureInfo.InvariantCulture) + "%");
* if (YellowHit < 100f && TotalExpertiseMH < 26)
* {
* float ratingRequired = (float)Math.Ceiling(4f * StatConversion.GetRatingFromExpertise(100f - YellowHit));
* dictValues.Add("Yellow Hit", String.Format("{0}% (Under Cap)*You need {1} more expertise to cap specials (WF,SS)",
* YellowHit.ToString("F2", CultureInfo.InvariantCulture),
* ratingRequired.ToString("F0", CultureInfo.InvariantCulture)));
* }
* else
* {
* if (ParriedAttacks > 0)
* {
* float ratingRequired = (float)Math.Ceiling(4f * StatConversion.GetRatingFromExpertise(100f - YellowHit));
* dictValues.Add("Yellow Hit", String.Format("{0}%*Being in front of boss allows your attacks to be parried\r\nYou would need {1} more expertise to cap specials (WF,SS)",
* YellowHit.ToString("F2", CultureInfo.InvariantCulture),
* ratingRequired.ToString("F0", CultureInfo.InvariantCulture)));
* }
* else
* dictValues.Add("Yellow Hit", YellowHit.ToString("F2", CultureInfo.InvariantCulture) + "%");
* }
* if (OverSpellHitCap > 0.38f) // only warn if more than .38% over cap (equivalent to 10 hit rating)
* dictValues.Add("Spell Hit", String.Format("{0}% (Over Cap)*Over Spell Hit Cap by {1}%",
* SpellHit.ToString("F2", CultureInfo.InvariantCulture),
* OverSpellHitCap.ToString("F2", CultureInfo.InvariantCulture)));
* else
* {
* if (SpellHit < 100f)
* {
* float ratingRequired = (float)Math.Ceiling(StatConversion.GetRatingFromSpellHit(1f - SpellHit/100f));
* dictValues.Add("Spell Hit", String.Format("{0}% (Under Cap)*You need {1} more hit rating to cap spells (ES, LB etc)",
* SpellHit.ToString("F2", CultureInfo.InvariantCulture),
* ratingRequired.ToString("F0", CultureInfo.InvariantCulture)));
* }
* else
* dictValues.Add("Spell Hit", SpellHit.ToString("F2", CultureInfo.InvariantCulture) + "%");
* }*/
/*if (OverMeleeCritCap > 0.21f) // only warn if more than .21% over cap (equivalent to 10 crit rating)
* dictValues.Add("Melee Crit", String.Format("{0} (Over Cap)*Crit Rating {1} (+{2}% crit chance)\r\nOver Soft Cap by {3}%",
* MeleeCrit.ToString("F2", CultureInfo.InvariantCulture) + "%",
* BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
* (StatConversion.GetCritFromRating(BasicStats.CritRating) * 100f).ToString("F2", CultureInfo.InvariantCulture),
* OverMeleeCritCap.ToString("F2", CultureInfo.InvariantCulture)));
* else
* dictValues.Add("Melee Crit", String.Format("{0}*Crit Rating {1} (+{2}% crit chance)",
* MeleeCrit.ToString("F2", CultureInfo.InvariantCulture) + "%",
* BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
* (StatConversion.GetCritFromRating(BasicStats.CritRating) * 100f).ToString("F2", CultureInfo.InvariantCulture)));
*
* dictValues.Add("Spell Crit", String.Format("{0}*Crit Rating {1} (+{2}% crit chance)",
* SpellCrit.ToString("F2", CultureInfo.InvariantCulture) + "%",
* BasicStats.CritRating.ToString("F0", CultureInfo.InvariantCulture),
* (StatConversion.GetSpellCritFromRating(BasicStats.CritRating) * 100f).ToString("F2", CultureInfo.InvariantCulture)));*/
float spellMiss = 100 - SpellHit;
dictValues.Add("Avoided Attacks", String.Format("{0}%*{1}% Boss Dodged\r\n{2}% Boss Parried\r\n{3}% Spell Misses\r\n{4}% White Misses",
AvoidedAttacks.ToString("F2", CultureInfo.InvariantCulture),
DodgedAttacks.ToString("F2", CultureInfo.InvariantCulture),
ParriedAttacks.ToString("F2", CultureInfo.InvariantCulture),
spellMiss.ToString("F2", CultureInfo.InvariantCulture),
MissedAttacks.ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Armor Mitigation", ArmorMitigation.ToString("F2", CultureInfo.InvariantCulture) + "%*Amount of physical damage lost due to boss armor");
dictValues.Add("ED Uptime", String.Format("{0}%*{1}% ED Bonus Crit",
EDUptime.ToString("F2", CultureInfo.InvariantCulture),
EDBonusCrit.ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("Flurry Uptime", FlurryUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Avg Time to 5 Stack", String.Format("{0} sec*{1} PPM",
SecondsTo5Stack.ToString("F2", CultureInfo.InvariantCulture),
_MWPPM.ToString("F2", CultureInfo.InvariantCulture)));
dictValues.Add("MH Enchant Uptime", MHEnchantUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("OH Enchant Uptime", OHEnchantUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Trinket 1 Uptime", Trinket1Uptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Trinket 2 Uptime", Trinket2Uptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("Fire Totem Uptime", FireTotemUptime.ToString("F2", CultureInfo.InvariantCulture) + "%");
dictValues.Add("White Damage", dpsOutputFormat(SwingDamage, DPS, true));
dictValues.Add("Windfury Attack", dpsOutputFormat(WindfuryAttack, DPS, true));
dictValues.Add("Flametongue Attack", dpsOutputFormat(FlameTongueAttack, DPS, true));
dictValues.Add("Stormstrike", dpsOutputFormat(Stormstrike, DPS, true));
dictValues.Add("Lava Lash", dpsOutputFormat(LavaLash, DPS, true));
dictValues.Add("Searing/Magma Totem", dpsOutputFormat(SearingMagma, DPS, false));
dictValues.Add("Earth Shock", dpsOutputFormat(EarthShock, DPS, false));
dictValues.Add("Flame Shock", dpsOutputFormat(FlameShock, DPS, false));
dictValues.Add("Lightning Bolt", dpsOutputFormat(LightningBolt, DPS, false));
dictValues.Add("Unleash Wind", dpsOutputFormat(UnleashWind, DPS, true));
dictValues.Add("Unleash Flame", dpsOutputFormat(UnleashFlame, DPS, false));
dictValues.Add("Lightning Shield", dpsOutputFormat(LightningShield, DPS, false));
dictValues.Add("Chain Lightning", dpsOutputFormat(ChainLightning, DPS, false));
dictValues.Add("Fire Nova", dpsOutputFormat(FireNova, DPS, false));
dictValues.Add("Fire Elemental", FireElemental.getDPSOutput());
dictValues.Add("Spirit Wolf", dpsOutputFormat(SpiritWolf, DPS, true));
dictValues.Add("Other", dpsOutputFormat(Other, DPS, false));
dictValues.Add("Total DPS", DPS.ToString("F2", CultureInfo.InvariantCulture));
/*dictValues.Add("Status", String.Format("Enhance Model : DPS Points {0}, Survivability Points {1}, Overall Points {2}",
* DPS.ToString("F2", CultureInfo.InvariantCulture),
* Survivability.ToString("F2", CultureInfo.InvariantCulture),
* OverallPoints.ToString("F2", CultureInfo.InvariantCulture)));*/
return(dictValues);
}
private void CalcHasteAndManaProcs()
{
float nonProcHaste = StatUtils.CalcSpellHaste(PreProcStats);
if (Options.NoProcs)
{
WeightedStat staticHaste = new WeightedStat();
staticHaste.Chance = 1f;
staticHaste.Value = nonProcHaste;
Haste = new List <WeightedStat> {
staticHaste
};
AvgHaste = nonProcHaste;
return;
}
// the trigger rates are all guestimates at this point, since the
// real values depend on haste (which obviously has not been
// finalized yet)
Dictionary <int, float> periods
= new Dictionary <int, float>();
Dictionary <int, float> chances
= new Dictionary <int, float>();
float corruptionPeriod = 0f;
if (Options.GetActiveRotation().Contains("Corruption"))
{
corruptionPeriod = 3.1f;
if (Talents.GlyphQuickDecay)
{
corruptionPeriod /= nonProcHaste;
}
}
PopulateTriggers(
periods,
chances,
CalculationsWarlock.AVG_UNHASTED_CAST_TIME / nonProcHaste
+ Options.Latency,
1 / 1.5f,
corruptionPeriod,
1f);
// calculate the haste procs
Haste = new List <WeightedStat>();
WeightedStat[] percentages
= GetUptimes(
Stats,
periods,
chances,
s => s.SpellHaste,
(a, b, c, d, e, f, g, h)
=> SpecialEffect
.GetAverageCombinedUptimeCombinationsMultiplicative(
a, b, c, d, e, f, g, h));
WeightedStat[] ratings
= GetUptimes(
Stats,
periods,
chances,
s => s.HasteRating,
(a, b, c, d, e, f, g, h)
=> SpecialEffect.GetAverageCombinedUptimeCombinations(
a, b, c, d, e, f, g, h));
for (int p = percentages.Length, f = 0; --p >= 0;)
{
if (percentages[p].Chance == 0)
{
continue;
}
for (int r = ratings.Length; --r >= 0; ++f)
{
if (ratings[r].Chance == 0)
{
continue;
}
WeightedStat s = new WeightedStat();
s.Chance = percentages[p].Chance * ratings[r].Chance;
s.Value
= (1 + percentages[p].Value)
* (1 + StatConversion.GetSpellHasteFromRating(
ratings[r].Value + Stats.HasteRating))
* (1 + Stats.SpellHaste);
Haste.Add(s);
AvgHaste += s.Chance * s.Value;
}
}
// calculate mana procs
Stats procStats = new Stats();
foreach (SpecialEffect effect in Stats.SpecialEffects())
{
if (!periods.ContainsKey((int)effect.Trigger))
{
continue;
}
Stats proc = effect.GetAverageStats(
periods[(int)effect.Trigger],
chances[(int)effect.Trigger],
CalculationsWarlock.AVG_UNHASTED_CAST_TIME,
Options.Duration);
if (proc.ManaRestore > 0)
{
proc.ManaRestore *= Options.Duration;
}
procStats.Accumulate(proc);
}
Stats.Mana += procStats.Mana;
Stats.ManaRestore += procStats.ManaRestore;
Stats.ManaRestoreFromBaseManaPPM
+= procStats.ManaRestoreFromBaseManaPPM;
Stats.ManaRestoreFromMaxManaPerSecond
+= procStats.ManaRestoreFromMaxManaPerSecond;
Stats.Mp5 += procStats.Mp5;
}
public EnhSim(Character character, CalculationOptionsEnhance calcOpts, BossOptions bossOpts)
{
_character = character;
_calcOpts = calcOpts;
_bossOpts = bossOpts;
CalculationsEnhance ce = new CalculationsEnhance();
CharacterCalculationsEnhance calcs = ce.GetCharacterCalculations(character, null) as CharacterCalculationsEnhance;
Stats stats = calcs.EnhSimStats;
CombatStats cs = new CombatStats(character, stats, _calcOpts, bossOpts);
getSpecialsNames(character, stats);
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.AppendLine("##########################################");
sb.AppendLine("### Rawr.Enhance Data Export to EnhSim ###");
sb.AppendLine("##########################################");
sb.AppendLine();
sb.AppendLine("config_source rawr");
sb.AppendLine();
float MHSpeed = character.MainHand == null ? 3.0f : character.MainHand.Item.Speed;
float wdpsMH = character.MainHand == null ? 46.3f : character.MainHand.Item.DPS;
float OHSpeed = character.OffHand == null ? 3.0f : character.OffHand.Item.Speed;
float wdpsOH = character.OffHand == null ? 46.3f : character.OffHand.Item.DPS;
sb.AppendLine("race " + character.Race.ToString().ToLower());
sb.AppendLine("mh_speed " + MHSpeed.ToString("F1", CultureInfo.InvariantCulture));
sb.AppendLine("oh_speed " + OHSpeed.ToString("F1", CultureInfo.InvariantCulture));
sb.AppendLine("mh_dps " + wdpsMH.ToString("F1", CultureInfo.InvariantCulture));
sb.AppendLine("oh_dps " + wdpsOH.ToString("F1", CultureInfo.InvariantCulture));
sb.AppendLine("str " + stats.Strength.ToString("F0", CultureInfo.InvariantCulture));
sb.AppendLine("agi " + stats.Agility.ToString("F0", CultureInfo.InvariantCulture));
sb.AppendLine("int " + stats.Intellect.ToString("F0", CultureInfo.InvariantCulture));
sb.AppendLine("spi " + stats.Spirit.ToString("F0", CultureInfo.InvariantCulture));
sb.AppendLine("mastery_rating " + stats.MasteryRating.ToString("F0", CultureInfo.InvariantCulture));
float chanceCrit = cs.ExportMeleeCritMH * 100f;
sb.AppendLine("mh_crit " + chanceCrit.ToString("F2", CultureInfo.InvariantCulture));
chanceCrit = cs.ExportMeleeCritOH * 100f;
sb.AppendLine("oh_crit " + chanceCrit.ToString("F2", CultureInfo.InvariantCulture));
float hitBonus = StatConversion.GetHitFromRating(stats.HitRating) * 100f + 6f;
if (character.Race == CharacterRace.Draenei)
{
hitBonus += 1f;
}
sb.AppendLine("mh_hit " + hitBonus.ToString("F2", CultureInfo.InvariantCulture));
sb.AppendLine("oh_hit " + hitBonus.ToString("F2", CultureInfo.InvariantCulture));
sb.AppendLine("mh_expertise_rating " + stats.ExpertiseRating.ToString("F0", CultureInfo.InvariantCulture));
sb.AppendLine("oh_expertise_rating " + stats.ExpertiseRating.ToString("F0", CultureInfo.InvariantCulture));
float unleashedRage = 0f;
switch (character.ShamanTalents.UnleashedRage)
{
case 1: unleashedRage = .05f; break;
case 2: unleashedRage = .10f; break;
}
sb.AppendLine("ap " + (stats.AttackPower * (1f + unleashedRage)).ToString("F0", CultureInfo.InvariantCulture));
float hasteBonus = StatConversion.GetHasteFromRating(stats.HasteRating, CharacterClass.Shaman) * 100f;
sb.AppendLine("melee_haste " + hasteBonus.ToString("F2", CultureInfo.InvariantCulture));
float MQUnleashedRageSpellpower = stats.AttackPower * unleashedRage * 0.50f;
sb.AppendLine("spellpower " + (stats.SpellPower + MQUnleashedRageSpellpower).ToString("F0", CultureInfo.InvariantCulture));
float chanceSpellCrit = cs.DisplaySpellCrit * 100f;
sb.AppendLine("spell_crit " + chanceSpellCrit.ToString("F2", CultureInfo.InvariantCulture));
float elemPrec = character.ShamanTalents.ElementalPrecision > 0 ? (stats.Spirit - BaseStats.GetBaseStats(character).Spirit) * (character.ShamanTalents.ElementalPrecision / 3f) : 0f;
hitBonus = StatConversion.GetSpellHitFromRating(stats.HitRating + elemPrec) * 100f;
if (character.Race == CharacterRace.Draenei)
{
hitBonus += 1f;
}
sb.AppendLine("spell_hit " + hitBonus.ToString("F2", CultureInfo.InvariantCulture));
hasteBonus = StatConversion.GetSpellHasteFromRating(stats.HasteRating) * 100f;
sb.AppendLine("spell_haste " + hasteBonus.ToString("F2", CultureInfo.InvariantCulture));
sb.AppendLine("max_mana " + stats.Mana.ToString());
sb.AppendLine("mp5 " + stats.Mp5.ToString());
sb.AppendLine();
sb.AppendLine("mh_imbue " + _calcOpts.MainhandImbue.ToString().ToLower());
sb.AppendLine("oh_imbue " + _calcOpts.OffhandImbue.ToString().ToLower());
sb.AppendLine();
sb.AppendLine("mh_enchant " + _mhEnchant);
sb.AppendLine("oh_enchant " + _ohEnchant);
String weaponType = "-";
if (character.MainHand != null)
{
if (character.MainHand.Type == ItemType.OneHandAxe || character.MainHand.Type == ItemType.TwoHandAxe)
{
weaponType = "axe";
}
if (character.MainHand.Type == ItemType.FistWeapon)
{
weaponType = "fist";
}
if (character.MainHand.Type == ItemType.OneHandMace || character.MainHand.Type == ItemType.TwoHandMace)
{
weaponType = "mace";
}
}
sb.AppendLine("mh_weapon " + weaponType);
weaponType = "-";
if (character.OffHand != null)
{
if (character.OffHand.Type == ItemType.OneHandAxe)
{
weaponType = "axe";
}
if (character.OffHand.Type == ItemType.FistWeapon)
{
weaponType = "fist";
}
if (character.OffHand.Type == ItemType.OneHandMace)
{
weaponType = "mace";
}
}
sb.AppendLine("oh_weapon " + weaponType);
sb.AppendLine();
sb.AppendLine("trinket1 " + _trinket1name);
sb.AppendLine("trinket2 " + _trinket2name);
sb.AppendLine();
sb.AppendLine(getSetBonuses(character));
sb.AppendLine("metagem " + _metagem);
sb.AppendLine();
string glovesEnchant = character.HandsTinkering == null ? string.Empty : character.HandsTinkering.Name;
if (glovesEnchant == "Synapse Springs")
{
sb.AppendLine("gloves_enchant synapse_springs");
}
else if (glovesEnchant == "Tazik Shocker")
{
sb.AppendLine("gloves_enchant tazik_shocker");
}
else
{
sb.AppendLine("gloves_enchant -");
}
string cloakEnchant = character.BackEnchant == null ? string.Empty : character.BackEnchant.Name;
if (cloakEnchant == "Lightweave Embroidery")
{
sb.AppendLine("cloak_enchant lightweave_embroidery");
}
else if (cloakEnchant == "Swordguard Embroidery")
{
sb.AppendLine("cloak_enchant swordguard_embroidery");
}
else
{
sb.AppendLine("cloak_enchant -");
}
string weaponSetProc = "-";
if (character.MainHand != null && character.OffHand != null)
{
if (character.MainHand.Id == 63537 && character.OffHand.Id == 63538)
{
weaponSetProc = "agony_and_torment";
}
}
sb.AppendLine("weapon_set_proc " + weaponSetProc);
/*addGlyphs(character, sb);
* sb.AppendLine();
* sb.AppendLine("#############");
* sb.AppendLine("## Talents ##");
* sb.AppendLine("#############");
* sb.AppendLine("primary_talent enhancement");
* sb.AppendLine();
* sb.AppendLine("elemental_weapons " + character.ShamanTalents.ElementalWeapons + "/2");
* sb.AppendLine("focused_strikes " + character.ShamanTalents.FocusedStrikes + "/3");
* sb.AppendLine("improved_shields " + character.ShamanTalents.ImprovedShields + "/3");
* sb.AppendLine("elemental_devastation " + character.ShamanTalents.ElementalDevastation + "/3");
* sb.AppendLine("flurry " + character.ShamanTalents.Flurry + "/3");
* sb.AppendLine("static_shock " + character.ShamanTalents.StaticShock + "/3");
* sb.AppendLine("improved_fire_nova " + character.ShamanTalents.ImprovedFireNova + "/2");
* sb.AppendLine("searing_flames " + character.ShamanTalents.SearingFlames + "/3");
* sb.AppendLine("frozen_power " + character.ShamanTalents.FrozenPower + "/2");
* sb.AppendLine("shamanistic_rage " + character.ShamanTalents.ShamanisticRage + "/1");
* sb.AppendLine("unleashed_rage " + character.ShamanTalents.UnleashedRage + "/2");
* sb.AppendLine("maelstrom_weapon " + character.ShamanTalents.MaelstromWeapon + "/3");
* sb.AppendLine("improved_lava_lash " + character.ShamanTalents.ImprovedLavaLash + "/2");
* sb.AppendLine();
* //elemental talents in EnhSim have not been updated, so keep exporting old talent choices where appropriate.
* sb.AppendLine("convection " + character.ShamanTalents.Convection + "/2");
* sb.AppendLine("concussion " + character.ShamanTalents.Concussion + "/3");
* sb.AppendLine("call_of_flame " + character.ShamanTalents.CallOfFlame + "/2");
* sb.AppendLine("reverberation " + character.ShamanTalents.Reverberation + "/2");
* sb.AppendLine("elemental_precision " + character.ShamanTalents.ElementalPrecision + "/3");
* sb.AppendLine("elemental_focus " + character.ShamanTalents.ElementalFocus + "/1");
* sb.AppendLine("elemental_oath " + character.ShamanTalents.ElementalOath + "/2");
* sb.AppendLine("lava_flows " + character.ShamanTalents.LavaFlows + "/3");
* sb.AppendLine("storm_earth_and_fire " + "0" + "/3");
* sb.AppendLine("elemental_mastery " + character.ShamanTalents.ElementalMastery + "/1");
* sb.AppendLine("feedback " + character.ShamanTalents.Feedback + "/3");
* sb.AppendLine("lava_surge " + character.ShamanTalents.LavaSurge + "/2");
* sb.AppendLine();
*
* addBuffs(character, sb);
* // add extras
* sb.AppendLine();
* sb.AppendLine("combat_length " + (_bossOpts.BerserkTimer/60f).ToString("F2", CultureInfo.InvariantCulture));*/
_configText = sb.ToString();
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> retVal = new Dictionary <string, string>();
//
if (baseStats == null)
{
baseStats = new StatsMoonkin();
}
if (SelectedRotation == null)
{
SelectedRotation = new RotationData();
}
if (BurstRotation == null)
{
BurstRotation = new RotationData();
}
//
retVal.Add("Health", baseStats.Health.ToString());
retVal.Add("Mana", baseStats.Mana.ToString());
retVal.Add("Armor", baseStats.Armor.ToString());
retVal.Add("Agility", baseStats.Agility.ToString());
retVal.Add("Stamina", baseStats.Stamina.ToString());
retVal.Add("Intellect", baseStats.Intellect.ToString());
retVal.Add("Spirit", baseStats.Spirit.ToString());
retVal.Add("Spell Power", SpellPower.ToString());
float totalHitDelta = SpellHitCap - SpellHit;
retVal.Add("Spell Hit", String.Format("{0:F}%*{1} Hit Rating, {2:F}% Hit From Gear" + (totalHitDelta != 0 ? ", {3} Rating {4}" : ""),
100 * SpellHit,
baseStats.HitRating,
100 * StatConversion.GetSpellHitFromRating(baseStats.HitRating),
StatConversion.GetRatingFromHit(Math.Abs(totalHitDelta)),
totalHitDelta > 0 ? "To Cap" : "Over Cap"));
retVal.Add("Spell Crit", String.Format("{0:F}%*{1} Crit Rating, {2:F}% Crit From Gear, {3:F}% Crit From Intellect",
100 * SpellCrit,
baseStats.CritRating,
100 * StatConversion.GetSpellCritFromRating(baseStats.CritRating),
100 * StatConversion.GetSpellCritFromIntellect(baseStats.Intellect)));
retVal.Add("Spell Haste", String.Format("{0:F}%*{1} Haste Rating, {2:F}% Haste From Gear",
100 * SpellHaste,
baseStats.HasteRating,
100 * StatConversion.GetSpellHasteFromRating(baseStats.HasteRating)));
retVal.Add("Mastery", String.Format("{0:F}*{1:F} Eclipse %, {2} Rating",
Mastery,
Mastery * 2.0f,
baseStats.MasteryRating));
retVal.Add("Mana Regen", String.Format("{0:F0}", ManaRegen * 5.0f));
retVal.Add("Total Score", String.Format("{0:F2}", OverallPoints));
retVal.Add("Selected Rotation", String.Format("*{0}", SelectedRotation.Name));
retVal.Add("Selected DPS", String.Format("{0:F2}", SelectedRotation.SustainedDPS));
retVal.Add("Selected Time To OOM", String.Format(SelectedRotation.TimeToOOM > new TimeSpan(0, 0, 0) ? "{0} m {1} s" : "Not during fight", SelectedRotation.TimeToOOM.Minutes, SelectedRotation.TimeToOOM.Seconds));
retVal.Add("Selected Cycle Length", String.Format("{0:F1} s", SelectedRotation.Duration));
StringBuilder sb = new StringBuilder("*");
float rotationDamage = SelectedRotation.SustainedDPS * SelectedRotation.Duration;
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starfire", 100 * SelectedRotation.StarfireAvgHit * SelectedRotation.StarfireCount / rotationDamage,
SelectedRotation.StarfireAvgHit * SelectedRotation.StarfireCount,
SelectedRotation.StarfireCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Moonfire", 100 * (SelectedRotation.MoonfireAvgHit) * SelectedRotation.MoonfireCasts / rotationDamage,
(SelectedRotation.MoonfireAvgHit) * SelectedRotation.MoonfireCasts,
SelectedRotation.MoonfireCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Insect Swarm", 100 * SelectedRotation.InsectSwarmAvgHit * SelectedRotation.InsectSwarmCasts / rotationDamage,
SelectedRotation.InsectSwarmAvgHit * (SelectedRotation.InsectSwarmCasts),
SelectedRotation.InsectSwarmCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Wrath", 100 * SelectedRotation.WrathAvgHit * SelectedRotation.WrathCount / rotationDamage,
SelectedRotation.WrathAvgHit * SelectedRotation.WrathCount,
SelectedRotation.WrathCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starsurge", 100 * SelectedRotation.StarSurgeAvgHit * SelectedRotation.StarSurgeCount / rotationDamage,
SelectedRotation.StarSurgeAvgHit * SelectedRotation.StarSurgeCount,
SelectedRotation.StarSurgeCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starfall", 100 * SelectedRotation.StarfallDamage * SelectedRotation.StarfallCasts / rotationDamage,
SelectedRotation.StarfallDamage * SelectedRotation.StarfallCasts,
SelectedRotation.StarfallCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Wild Mushroom", 100 * SelectedRotation.MushroomDamage * SelectedRotation.MushroomCasts / rotationDamage,
SelectedRotation.MushroomDamage * SelectedRotation.MushroomCasts,
SelectedRotation.MushroomCasts));
retVal.Add("Selected Spell Breakdown", sb.ToString());
retVal.Add("Burst Rotation", String.Format("*{0}", BurstRotation.Name));
retVal.Add("Burst DPS", String.Format("{0:F2}", BurstRotation.BurstDPS));
retVal.Add("Burst Time To OOM", String.Format(BurstRotation.TimeToOOM > new TimeSpan(0, 0, 0) ? "{0} m {1} s" : "Not during fight", BurstRotation.TimeToOOM.Minutes, BurstRotation.TimeToOOM.Seconds));
retVal.Add("Burst Cycle Length", String.Format("{0:F1} s", BurstRotation.Duration));
sb = new StringBuilder("*");
rotationDamage = BurstRotation.BurstDPS * BurstRotation.Duration;
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starfire", 100 * BurstRotation.StarfireAvgHit * BurstRotation.StarfireCount / rotationDamage,
BurstRotation.StarfireAvgHit * BurstRotation.StarfireCount,
BurstRotation.StarfireCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Moonfire", 100 * (BurstRotation.MoonfireAvgHit) * BurstRotation.MoonfireCasts / rotationDamage,
(BurstRotation.MoonfireAvgHit) * BurstRotation.MoonfireCasts,
BurstRotation.MoonfireCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Insect Swarm", 100 * BurstRotation.InsectSwarmAvgHit * BurstRotation.InsectSwarmCasts / rotationDamage,
BurstRotation.InsectSwarmAvgHit * (BurstRotation.InsectSwarmCasts),
BurstRotation.InsectSwarmCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Wrath", 100 * BurstRotation.WrathAvgHit * BurstRotation.WrathCount / rotationDamage,
BurstRotation.WrathAvgHit * BurstRotation.WrathCount,
BurstRotation.WrathCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starsurge", 100 * BurstRotation.StarSurgeAvgHit * BurstRotation.StarSurgeCount / rotationDamage,
BurstRotation.StarSurgeAvgHit * BurstRotation.StarSurgeCount,
BurstRotation.StarSurgeCount));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Starfall", 100 * BurstRotation.StarfallDamage * BurstRotation.StarfallCasts / rotationDamage,
BurstRotation.StarfallDamage * BurstRotation.StarfallCasts,
BurstRotation.StarfallCasts));
sb.AppendLine(String.Format("{0}: {1:F2}%, {2:F2} damage, {3:F0} count", "Wild Mushroom", 100 * BurstRotation.MushroomDamage * BurstRotation.MushroomCasts / rotationDamage,
BurstRotation.MushroomDamage * BurstRotation.MushroomCasts,
BurstRotation.MushroomCasts));
retVal.Add("Burst Spell Breakdown", sb.ToString());
retVal.Add("Nature's Grace Uptime", String.Format("{0:F2}%", SelectedRotation.NaturesGraceUptime * 100));
retVal.Add("Solar Eclipse Uptime", String.Format("{0:F2}%", SelectedRotation.SolarUptime * 100));
retVal.Add("Lunar Eclipse Uptime", String.Format("{0:F2}%", SelectedRotation.LunarUptime * 100));
retVal.Add("Starfire", String.Format("{0:F2} dps*{1:F2} s avg\n {2:F2} avg hit\n{3:F0} avg energy",
SelectedRotation.StarfireAvgHit / (SelectedRotation.StarfireAvgCast > 0 ? SelectedRotation.StarfireAvgCast : 1f),
SelectedRotation.StarfireAvgCast,
SelectedRotation.StarfireAvgHit,
SelectedRotation.StarfireAvgEnergy));
retVal.Add("Wrath", String.Format("{0:F2} dps*{1:F2} s avg\n {2:F2} avg hit\n{3:F0} avg energy",
SelectedRotation.WrathAvgHit / (SelectedRotation.WrathAvgCast > 0 ? SelectedRotation.WrathAvgCast : 1f),
SelectedRotation.WrathAvgCast,
SelectedRotation.WrathAvgHit,
SelectedRotation.WrathAvgEnergy));
retVal.Add("Starsurge", String.Format("{0:F2} dps*{1:F2} s avg\n {2:F2} avg hit\n{3:F0} avg energy",
SelectedRotation.StarSurgeAvgHit / (SelectedRotation.StarSurgeAvgCast > 0 ? SelectedRotation.StarSurgeAvgCast : 1f),
SelectedRotation.StarSurgeAvgCast,
SelectedRotation.StarSurgeAvgHit,
SelectedRotation.StarSurgeAvgEnergy));
retVal.Add("Moonfire", String.Format("{0:F2} dps*{1:F2} s avg\n{2:F2} avg hit",
SelectedRotation.MoonfireAvgHit / (SelectedRotation.MoonfireDuration > 0 ? SelectedRotation.MoonfireDuration : 1f),
SelectedRotation.MoonfireAvgCast,
SelectedRotation.MoonfireAvgHit));
retVal.Add("Insect Swarm", String.Format("{0:F2} dps*{1:F2} s avg\n{2:F2} avg hit",
SelectedRotation.InsectSwarmAvgHit / (SelectedRotation.InsectSwarmDuration > 0 ? SelectedRotation.InsectSwarmDuration : 1f),
SelectedRotation.InsectSwarmAvgCast,
SelectedRotation.InsectSwarmAvgHit));
retVal.Add("Starfall", String.Format("{0:F2} dps*{1:F2} avg per cast\n{2:F2} avg per star",
SelectedRotation.StarfallDamage / 10.0f,
SelectedRotation.StarfallDamage,
SelectedRotation.StarfallDamage / (SelectedRotation.StarfallStars > 0 ? SelectedRotation.StarfallStars : 1f)));
retVal.Add("Treants", String.Format("{0:F2} dps*{1:F2} avg per cast\n{2:F2} avg per tree",
SelectedRotation.TreantDamage / 30.0f, SelectedRotation.TreantDamage, SelectedRotation.TreantDamage / 3.0f));
retVal.Add("Wild Mushroom", String.Format("{0:F2} dps*{1:F2} avg per cast\n{2:F2} avg per mushroom",
SelectedRotation.MushroomDamage / 10.0f,
SelectedRotation.MushroomDamage,
SelectedRotation.MushroomDamage / 3f));
return(retVal);
}