public override void UpdateSpell()
{
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines));
base.UpdateSpell();
DirectHealCalcs();
}
public override void UpdateSpell()
{
float shieldBonus = (1f + PriestInformation.GetImprovedPowerWordShield(character.PriestTalents.ImprovedPowerWordShield))
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines))
* (1f + stats.ShieldDiscipline);
float spellPowerBonus = stats.SpellPower * BaseDirectCoefficient;
base.UpdateSpell();
Cooldown = BaseCooldown - PriestInformation.GetSoulWarding(character.PriestTalents.SoulWarding);
AbsorbMinHit = AbsorbMaxHit = AbsorbAvgHit = (BaseDirectValue + spellPowerBonus) * shieldBonus;
if (character.PriestTalents.GlyphofPowerWordShield)
{
DirectHealMinHit = DirectHealMaxHit = DirectHealAvgHit = AbsorbAvgHit * 0.2f;
DirectHealMinCrit = DirectHealMaxCrit = DirectHealAvgCrit = AbsorbAvgHit * 0.2f * CritMultiplier;
DirectHealAvg = DirectHealAvgHit * (1f - CritChance) + DirectHealAvgCrit * CritChance;
HasDirectHeal = true;
if (stats.PriestSpec == ePriestSpec.Spec_Disc)
{
DivineAegis();
}
else if (stats.PriestSpec == ePriestSpec.Spec_Holy)
{
EchoOfLight();
}
}
AbsorbAvg = AbsorbAvgHit + AbsorbAvgCrit * CritChance;
}
public override void UpdateSpell()
{
float td = (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines));
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* td;
base.UpdateSpell();
DirectHealCalcs();
if (stats.PriestSpec == ePriestSpec.Spec_Disc)
{ // Prayer of Healing has Absorbs for Hit and Crit
float da = PriestInformation.GetDivineAegis(character.PriestTalents.DivineAegis) * (1f + stats.ShieldDiscipline);
AbsorbMinHit = DirectHealMinHit * da;
AbsorbMaxHit = DirectHealMaxHit * da;
AbsorbAvgHit = DirectHealAvgHit * da;
AbsorbMinCrit *= 2;
AbsorbMaxCrit *= 2;
AbsorbAvgCrit *= 2;
AbsorbAvg = AbsorbAvgHit * (1f - CritChance) + AbsorbAvgCrit * CritChance;
}
if (character.PriestTalents.GlyphofPrayerofHealing)
{
OverTimeTicks = 2;
OverTimeTickPeriod = 3;
OverTimeDuration = OverTimeTicks * OverTimeTickPeriod;
OverTimeHealHit = DirectHealAvgHit * 0.2f * td;
OverTimeHealCrit = DirectHealAvgCrit * 0.2f * td;
OverTimeHealAvg = OverTimeHealHit * (1f - CritChance) + OverTimeHealCrit * CritChance;
HasOverTimeHeal = true;
}
}
//
// PWS, Penance_BT, PROH_BT, PWS, PROH_BT, PWS, PROH_BT, GH, GH
public override void Solve()
{
float graceBonus = PriestInformation.GetGrace(character.PriestTalents.Grace) * 3;
float borrowedTime = PriestInformation.GetBorrowedTime(character.PriestTalents.BorrowedTime);
float renewedHope = PriestInformation.GetRenewedHope(character.PriestTalents.RenewedHope);
StatsPriest statsGR = new StatsPriest()
{
BonusHealingDoneMultiplier = graceBonus
};
statsGR.Accumulate(stats);
StatsPriest statsBTGR = new StatsPriest()
{
SpellHaste = borrowedTime, BonusHealingDoneMultiplier = graceBonus
};
statsBTGR.Accumulate(stats);
StatsPriest statsRHGR = new StatsPriest()
{
SpellCrit = renewedHope, BonusHealingDoneMultiplier = graceBonus
};
statsRHGR.Accumulate(stats);
StatsPriest statsBTRHGR = new StatsPriest()
{
SpellHaste = borrowedTime, SpellCrit = renewedHope, BonusHealingDoneMultiplier = graceBonus
};
statsBTRHGR.Accumulate(stats);
// BT = Borrowed Time, RH = Renewed Hope, GR = Grace
SpellPowerWordShield pwsGR = new SpellPowerWordShield(character, statsGR);
SpellPenance penanceBTGRRH = new SpellPenance(character, statsBTRHGR);
SpellGreaterHeal ghBTGRRH = new SpellGreaterHeal(character, statsBTRHGR);
SpellGreaterHeal ghGTRH = new SpellGreaterHeal(character, statsRHGR);
SpellPrayerOfHealing prohBTGR = new SpellPrayerOfHealing(character, statsBTGR, 3);
castSequence.Add(pwsGR);
castSequence.Add(penanceBTGRRH);
castSequence.Add(prohBTGR);
castSequence.Add(ghGTRH);
castSequence.Add(pwsGR);
castSequence.Add(prohBTGR);
castSequence.Add(ghGTRH);
castSequence.Add(pwsGR);
castSequence.Add(prohBTGR);
DoCalcs();
if (verbose)
{
Name += "\n\nThree tank healing, keeping Grace up on 3 targets, using Prayer of Healing as filler.";
}
}
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);
}
protected void DivineAegis()
{
float da = PriestInformation.GetDivineAegis(character.PriestTalents.DivineAegis) * (1f + stats.ShieldDiscipline);
AbsorbMinCrit = DirectHealMinCrit * da;
AbsorbMaxCrit = DirectHealMaxCrit * da;
AbsorbAvgCrit = DirectHealAvgCrit * da;
AbsorbAvg = AbsorbAvgHit * (1f - CritChance) + AbsorbAvgCrit * CritChance;
HasAbsorb = true;
}
public override void UpdateSpell()
{
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines));
base.UpdateSpell();
Cooldown = BaseCooldown - (character.PriestTalents.GlyphofPenance ? 2f : 0f);
float spellPowerBonus = stats.SpellPower * BaseDirectCoefficient;
DirectHealCalcs();
}
public override void UpdateSpell()
{
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines));
if (character.PriestTalents.GlyphofPrayerOfMending && Targets == 1)
{
healBonus *= 1.6f;
}
base.UpdateSpell();
Cooldown = BaseCooldown;
DirectHealCalcs();
}
public SpellGreaterHeal(Character character, StatsPriest stats)
{
Name = "Greater Heal";
BaseDirectValue = 9.56400012969971f * BaseScalar85;
BaseDirectCoefficient = 0.967f;
BaseDirectVariation = 0.15f;
BaseCastTime = 3.0f - PriestInformation.GetDivineFury(character.PriestTalents.DivineFury);
BaseManaCost = 0.27f;
SetPriestInformation(character, stats);
}
public SpellHeal(Character character, StatsPriest stats)
{
Name = "Heal";
BaseDirectValue = 3.58699989318848f * BaseScalar85;
BaseDirectCoefficient = 0.362f;
BaseDirectVariation = 0.15f;
BaseCastTime = 3.0f - PriestInformation.GetDivineFury(character.PriestTalents.DivineFury);
BaseManaCost = 0.09f;
SetPriestInformation(character, stats);
}
public override void UpdateSpell()
{
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines));
base.UpdateSpell();
Cooldown = BaseCooldown;
float haste = (1f + stats.SpellHaste);
OverTimeTickPeriod = BaseOverTimeTickPeriod / haste;
// You get k more ticks for a hot/dot that has m ticks at 0% haste if your haste is higher than (2k-1)/2m.
OverTimeTicks = (float)Math.Floor(BaseOverTimeTicks * haste + 0.5f);
OverTimeDuration = OverTimeTickPeriod * OverTimeTicks;
DirectHealCalcs();
}
public override void UpdateSpell()
{
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines))
* (1f + PriestInformation.GetImprovedRenew(character.PriestTalents.ImprovedRenew))
* (character.PriestTalents.GlyphofRenew ? 1.1f : 1.0f);
base.UpdateSpell();
float spellPowerBonus = stats.SpellPower * BaseOverTimeCoefficient;
OverTimeHealHit = (BaseOverTimeValue + spellPowerBonus) * healBonus;
OverTimeHealCrit = OverTimeHealHit * CritMultiplier;
OverTimeHealAvg = OverTimeHealHit * (1f - CritChance) + OverTimeHealCrit * CritChance;
float haste = (1f + stats.SpellHaste);
OverTimeTickPeriod = BaseOverTimeTickPeriod / haste;
// You get k more ticks for a hot/dot that has m ticks at 0% haste if your haste is higher than (2k-1)/2m.
OverTimeTicks = (float)Math.Floor(BaseOverTimeTicks * haste + 0.5f);
OverTimeDuration = OverTimeTickPeriod * OverTimeTicks;
HasOverTimeHeal = true;
if (character.PriestTalents.DivineAegis > 0)
{
float da = PriestInformation.GetDivineAegis(character.PriestTalents.DivineAegis) * (1f + stats.ShieldDiscipline);
AbsorbMinCrit = AbsorbMaxCrit = AbsorbAvgCrit = OverTimeHealCrit * da;
AbsorbAvg = AbsorbAvgHit * (1f - CritChance) + AbsorbAvgCrit * CritChance;
HasAbsorb = true;
}
if (character.PriestTalents.DivineTouch > 0)
{
DirectHealMinHit = DirectHealMaxHit = DirectHealAvgHit = OverTimeHealHit * OverTimeTicks;
DirectHealMinCrit = DirectHealMaxCrit = DirectHealAvgCrit = OverTimeHealCrit * OverTimeTicks;
DirectHealAvg = DirectHealAvgHit * (1f - CritChance) + DirectHealAvgCrit * CritChance;
HasDirectHeal = true;
if (stats.PriestSpec == ePriestSpec.Spec_Disc)
{
DivineAegis();
}
else if (stats.PriestSpec == ePriestSpec.Spec_Holy)
{
EchoOfLight();
}
}
}
public override void UpdateSpell()
{
healBonus = (1f + stats.BonusHealingDoneMultiplier)
* (1f + PriestInformation.GetTwinDisciplines(character.PriestTalents.TwinDisciplines));
base.UpdateSpell();
Cooldown = BaseCooldown;
float spellPowerBonus = stats.SpellPower * BaseOverTimeCoefficient;
OverTimeHealHit = (BaseOverTimeValue + spellPowerBonus) * healBonus;
OverTimeHealCrit = OverTimeHealHit * CritMultiplier;
OverTimeHealAvg = OverTimeHealHit * (1f - CritChance) + OverTimeHealCrit * CritChance;
float haste = (1f + stats.SpellHaste);
OverTimeTickPeriod = BaseOverTimeTickPeriod / haste;
// You get k more ticks for a hot/dot that has m ticks at 0% haste if your haste is higher than (2k-1)/2m.
OverTimeTicks = (float)Math.Floor(BaseOverTimeTicks * haste + 0.5f);
OverTimeDuration = OverTimeTickPeriod * OverTimeTicks;
HasOverTimeHeal = true;
}
// PWS
// ProH_BT
public override void Solve()
{
float borrowedTime = PriestInformation.GetBorrowedTime(character.PriestTalents.BorrowedTime);
StatsPriest statsBT = new StatsPriest()
{
SpellHaste = borrowedTime
};
statsBT.Accumulate(stats);
castSequence.Clear();
castSequence.Add(new SpellPowerWordShield(character, stats));
castSequence.Add(new SpellPrayerOfHealing(character, statsBT));
DoCalcs();
if (verbose)
{
Name += "\nCasting Power Word: Shield and then Prayer of Healing, repeat.";
}
}
public virtual void UpdateSpell()
{
HasDirectDamage = false; HasDirectHeal = false; HasAbsorb = false; HasOverTimeDamage = false; HasOverTimeHeal = false;
float hc = 1f / (1f + stats.SpellHaste);
IsInstant = BaseCastTime == 0f;
if (IsInstant)
{
CastTime = 0f;
}
else
{
CastTime = Math.Max(1f, BaseCastTime * hc);
}
GlobalCooldown = Math.Max(1f, BaseGlobalCooldown * hc);
CritChance = stats.SpellCrit;
CritMultiplier = 1.5f * (1f + stats.BonusCritHealMultiplier);
ManaCost = BaseManaCost * BaseStats.GetBaseStats(character).Mana; // priestInformation.BaseMana;
if (IsInstant)
{
ManaCost *= PriestInformation.GetMentalAgility(character.PriestTalents.MentalAgility);
}
}
private float CalcShadowfiend(float mana)
{ // 3% mana every hit, 15s dura
// FIXME: 2s swing timer = 7.5 ~ 8 swings = 8*3 = 24% mana. Assume hasted by haste.
float casts = (float)Math.Floor((bossOptions.BerserkTimer - 30f) / (60f * 5f - PriestInformation.GetVeiledShadows(character.PriestTalents.VeiledShadows))) + 1f;
return(mana * (0.03f * 8f) * casts / bossOptions.BerserkTimer * (1f + calcOpts.Shadowfiend / 100f));
}
private float CalcRapture(float mana)
{
return(mana * PriestInformation.GetRapture(character.PriestTalents.Rapture) / calcOpts.Rapture);
}
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);
}