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); }