private void calculateTalents(DruidTalents druidTalents, CalculationOptionsTree calcOpts)
{
extraTicks += 1 * druidTalents.NaturesSplendor;
manaCostModifier *= 1 - 0.2f * druidTalents.TreeOfLife - 0.03f * druidTalents.Moonglow;
// 6% chance to get Omen of Clarity...
manaCostModifier *= 1 - 0.06f * druidTalents.OmenOfClarity;
periodicTickModifier *=
(1 + 0.01f * druidTalents.Genesis +
0.05f * druidTalents.ImprovedRejuvenation +
0.02f * druidTalents.GiftOfNature) *
(1 + 0.02f * druidTalents.MasterShapeshifter * druidTalents.TreeOfLife) *
(1 + 0.06f * druidTalents.TreeOfLife);
coefHoT *=
(1 + 0.04f * druidTalents.EmpoweredRejuvenation) *
(1 + 0.01f * druidTalents.Genesis +
0.05f * druidTalents.ImprovedRejuvenation +
0.02f * druidTalents.GiftOfNature) *
(1 + 0.02f * druidTalents.MasterShapeshifter * druidTalents.TreeOfLife) *
(1 + 0.06f * druidTalents.TreeOfLife);
#region Glyph of Rapid Rejuvenation
if (druidTalents.GlyphOfRapidRejuvenation)
{
hasteTicks = true;
}
#endregion
}
public TreeStats(Character character, Stats stats, KeyValuePair <double, SpecialEffect>[] hasteProcs, double treeOfLifeUptime)
{
CalculationOptionsTree opts = character.CalculationOptions as CalculationOptionsTree;
bool Restoration = (opts != null) ? opts.Restoration : true;
Haste = new HasteStats(stats, hasteProcs);
SpellCrit = StatConversion.GetSpellCritFromIntellect(stats.Intellect) + StatConversion.GetSpellCritFromRating(stats.CritRating) + stats.SpellCrit;
SpellPower = (float)(stats.SpellPower + Math.Max(0f, stats.Intellect - 10));
// TODO: does nurturing instinct actually work like this?
SpellPower += character.DruidTalents.NurturingInstinct * 0.5 * stats.Agility;
SpellPower *= (1 + stats.BonusSpellPowerMultiplier);
TreeOfLifeUptime = treeOfLifeUptime;
double mastery = 8.0f + StatConversion.GetMasteryFromRating(stats.MasteryRating);
if (Restoration)
{
Harmony = mastery * 0.0125f;
}
SpellsManaCostReduction = stats.SpellsManaCostReduction + stats.NatureSpellsManaCostReduction;
BonusCritHealMultiplier = stats.BonusCritHealMultiplier;
PassiveDirectHealBonus = (Restoration ? 1.25f : 1.0f) + Harmony;
PassivePeriodicHealBonus = (Restoration ? 1.25f : 1.0f) + opts.HarmonyPeriodicRate * Harmony + 0.02f * character.DruidTalents.Genesis;
DirectHealMultiplier = (1 + stats.BonusHealingDoneMultiplier) * (1.0f + character.DruidTalents.MasterShapeshifter * 0.04f) * (1 + TreeOfLifeUptime * 0.15f);
PeriodicHealMultiplier = DirectHealMultiplier * (1 + stats.BonusPeriodicHealingMultiplier);
SpellsManaCostMultiplier = 1 - stats.ManaCostReductionMultiplier;
Healed = stats.Healed + stats.HealedPerSP * SpellPower;
}
private void cmbSpellNum_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
int selIx = int.Parse(cmbSpellNum.Text) - 1; // arrays are zero-based
loading = true; // disable updates while changing the spell listBox
spellList.ClearSelected();
if (calcOpts.availableSpells[selIx] != null)
{
foreach (String s in calcOpts.availableSpells[selIx])
{
int ix = spellList.FindStringExact(s);
if (ix != -1)
{
spellList.SetSelected(ix, true);
}
}
}
loading = false;
}
}
private void ParseTalentsRejuvenation(Character character, Stats stats)
{
CalculationOptionsTree calcOpts = character.CalculationOptions as CalculationOptionsTree;
HealMultiplier += 0.05f * calcOpts.ImprovedRejuvenation;
Cost = (int)(Cost * (1f - 0.03f * calcOpts.Moonglow));
}
public HealingTouch(Character character, Stats calculatedStats)
{
CalculationOptionsTree calcOpts = (CalculationOptionsTree)character.CalculationOptions;
#region Base Values
castTimeBeforeHaste = 3f;
coefDH = 1.62f;
minHeal = 3750f;
maxHeal = 4428f;
#endregion
calculateTalents(character.DruidTalents, calcOpts);
#region Glyph of Healing Touch
if (character.DruidTalents.GlyphOfHealingTouch)
{
castTimeBeforeHaste -= 1.5f;
manaCostModifier *= 1 - 0.25f;
minHeal *= 1 - 0.5f;
maxHeal *= 1 - 0.5f;
coefDH *= 1 - 0.5f;
}
#endregion
applyStats(calculatedStats);
}
private void ParseTalentsRegrowth(Character character, Stats stats)
{
CalculationOptionsTree calcOpts = character.CalculationOptions as CalculationOptionsTree;
CritPercent += 10 * calcOpts.ImprovedRegrowth;
Cost = (int)(Cost * (1f - 0.03f * calcOpts.Moonglow));
}
protected void ParseTalents(Character character, Stats stats)
{
CritPercent = BaseCritPercent;
CastTime = BaseCastTime;
Range = BaseRange;
_character = character;
CalculationOptionsTree calcOpts = character.CalculationOptions as CalculationOptionsTree;
PeriodicTicks = BasePeriodicTicks;
HoTMultiplier += 0.04f * calcOpts.EmpoweredRejuvenation;
HealMultiplier += 0.02f * calcOpts.GiftOfNature;
if (ToLAura)
{
Healing += stats.TreeOfLifeAura;
}
// The value of average healing for a tree can be debated - passive healing is generally a lot better
// since you won't have any trouble refreshing HoTs when the buff runs out
Healing += stats.AverageHeal * calcOpts.AverageHealingScaling;
if (BasePeriodicTicks > 0 && calcOpts.TreeOfLife == 1)
{
Cost = Convert.ToInt32(Cost * 0.8f);
}
CastTime = BaseCastTime;
if (CastTime < 1.5f)
{
CastTime = 1.5f;
}
}
private void spellList_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
int selIx = int.Parse(cmbSpellNum.Text) - 1; // arrays are zero-based
if (spellList.SelectedItems.Count == 0)
{
return;
}
String[] spells = new String[spellList.SelectedItems.Count];
for (int i = 0; i < spells.Length; i++)
{
spells[i] = spellList.SelectedItems[i].ToString();
}
calcOpts.availableSpells[selIx] = spells;
Character.OnItemsChanged();
}
}
private void calculateTalents(DruidTalents druidTalents, CalculationOptionsTree calcOpts)
{
manaCostModifier *= 1 - (druidTalents.Moonglow * 0.03f + druidTalents.TranquilSpirit * 0.02f);
castTimeBeforeHaste -= 0.1f * druidTalents.Naturalist;
extraCritPercent += 2f * druidTalents.NaturesMajesty;
//Living Seed, 30% seed, 33% * points spend (1/3)
extraCritModifier = 0.1f * druidTalents.LivingSeed * calcOpts.Current.LivingSeedEfficiency / 100f;
// 6% chance to get Omen of Clarity...
manaCostModifier *= 1 - 0.06f * druidTalents.OmenOfClarity;
minHeal *=
(1f + 0.02f * druidTalents.GiftOfNature) *
(1f + 0.02f * druidTalents.MasterShapeshifter * druidTalents.TreeOfLife) *
(1f + 0.06f * druidTalents.TreeOfLife);
maxHeal *=
(1f + 0.02f * druidTalents.GiftOfNature) *
(1f + 0.02f * druidTalents.MasterShapeshifter * druidTalents.TreeOfLife) *
(1f + 0.06f * druidTalents.TreeOfLife);
coefDH += (0.2f * druidTalents.EmpoweredTouch); // ET is additive from http://elitistjerks.com/f73/t37038-restoration_glyphs/p8/#post1240879
coefDH *=
(1f + 0.02f * druidTalents.GiftOfNature) *
(1f + 0.02f * druidTalents.MasterShapeshifter * druidTalents.TreeOfLife) *
(1f + 0.06f * druidTalents.TreeOfLife);
}
public override Stats GetCharacterStats(Character character, Item additionalItem)
{
CalculationOptionsTree calcOpts = character.CalculationOptions as CalculationOptionsTree;
Stats statsRace = character.Race == Character.CharacterRace.NightElf ?
new Stats()
{
Health = 3434f,
Mana = 2470f,
Stamina = 82f,
Agility = 75f,
Intellect = 120f,
Spirit = 133f,
BonusAgilityMultiplier = 0.01f * calcOpts.SotF,
BonusIntellectMultiplier = 0.01f * calcOpts.SotF,
BonusSpiritMultiplier = 0.01f * calcOpts.SotF,
BonusStaminaMultiplier = 0.01f * calcOpts.SotF,
BonusStrengthMultiplier = 0.01f * calcOpts.SotF,
} :
new Stats()
{
Health = 3434f,
Mana = 2370f,
Stamina = 85f,
Agility = 64.5f,
Intellect = 115f,
Spirit = 135f,
BonusHealthMultiplier = 0.05f,
BonusAgilityMultiplier = 0.01f * calcOpts.SotF,
BonusIntellectMultiplier = 0.01f * calcOpts.SotF,
BonusSpiritMultiplier = 0.01f * calcOpts.SotF,
BonusStaminaMultiplier = 0.01f * calcOpts.SotF,
BonusStrengthMultiplier = 0.01f * calcOpts.SotF,
};
Stats statsBaseGear = GetItemStats(character, additionalItem);
Stats statsEnchants = GetEnchantsStats(character);
Stats statsBuffs = GetBuffsStats(character.ActiveBuffs);
Stats statsTotal = statsBaseGear + statsEnchants + statsBuffs + statsRace;
statsTotal.Agility = (float)Math.Floor((statsTotal.Agility) * (1 + statsTotal.BonusAgilityMultiplier));
statsTotal.Stamina = (float)Math.Floor((statsTotal.Stamina) * (1 + statsTotal.BonusStaminaMultiplier));
statsTotal.Intellect = (float)Math.Floor((statsTotal.Intellect) * (1 + statsTotal.BonusIntellectMultiplier));
statsTotal.Intellect = (float)Math.Round((statsTotal.Intellect) * (1 + calcOpts.HotW * 0.04f));
statsTotal.Spirit = (float)Math.Floor((statsTotal.Spirit) * (1 + statsTotal.BonusSpiritMultiplier));
statsTotal.Spirit = (float)Math.Floor((statsTotal.Spirit) * (1 + calcOpts.LivingSpirit * 0.05f));
float lunarGuidance = (calcOpts.LunarGuidance == 3 ? 0.25f : calcOpts.LunarGuidance * 0.08f);
statsTotal.SpellDamageRating = (float)Math.Round(statsTotal.SpellDamageRating + statsTotal.Intellect * lunarGuidance);
statsTotal.Healing = (float)Math.Round(statsTotal.Healing + (statsTotal.SpellDamageFromSpiritPercentage * statsTotal.Spirit) + (statsTotal.Intellect * lunarGuidance) + (calcOpts.NurturingInstinct * 0.5f * statsTotal.Agility));
statsTotal.Mana = statsTotal.Mana + ((statsTotal.Intellect - 20f) * 15f + 20f);
statsTotal.Health = (float)Math.Round(((statsTotal.Health + (statsTotal.Stamina * 10f)) * (character.Race == Character.CharacterRace.Tauren ? 1.05f : 1f)));
statsTotal.Mp5 += (float)Math.Floor(statsTotal.Intellect * (calcOpts.Dreamstate > 0 ? calcOpts.Dreamstate * 0.03f + 0.01f : 0f));
return(statsTotal);
}
private void ParseTalentsHT(Character character, Stats stats)
{
CalculationOptionsTree calcOpts = character.CalculationOptions as CalculationOptionsTree;
BaseCastTime -= 0.1f * calcOpts.Naturalist;
Cost = (int)(Cost * (1f - 0.02f * calcOpts.TranquilSpirit) * (1f - 0.03f * calcOpts.Moonglow));
// TODO: See if the T6 4-piece bonus applies here or if it needs to be modeled in a different way
DirectHealingBonusMultiplier += 0.1f * calcOpts.EmpoweredTouch + stats.BonusHealingTouchMultiplier;
}
public override ICalculationOptionBase DeserializeDataObject(string xml)
{
System.Xml.Serialization.XmlSerializer serializer =
new System.Xml.Serialization.XmlSerializer(typeof(CalculationOptionsTree));
System.IO.StringReader reader = new System.IO.StringReader(xml);
CalculationOptionsTree calcOpts = serializer.Deserialize(reader) as CalculationOptionsTree;
return(calcOpts);
}
private void upDownTargetHealth_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.TargetHealth = (float)upDownTargetHealth.Value;
Character.OnItemsChanged();
}
}
private void cmbLength_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.FightLength = (float)cmbLength.Value;
Character.OnItemsChanged();
}
}
private void upDownSurvScalingBelow_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.SurvScalingBelow = (float)upDownSurvScalingBelow.Value;
Character.OnItemsChanged();
}
}
private void upDownInnervate_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.InnervateDelay = (float)upDownInnervate.Value;
Character.OnItemsChanged();
}
}
private void cmbManaTime_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.ManaPotDelay = (float)cmbManaTime.Value;
Character.OnItemsChanged();
}
}
public TreeSolver(Character character, CharacterCalculationsTree calc)
{
this.character = character;
this.calc = calc;
this.opts = (CalculationOptionsTree)character.CalculationOptions;
if (opts == null)
opts = new CalculationOptionsTree();
compute();
}
private void cmbNumCyclesPerRotation_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.NumCyclesPerRotation = int.Parse(cmbNumCyclesPerRotation.Text);
Character.OnItemsChanged();
}
}
private void shattAldor_CheckedChanged(object sender, EventArgs e)
{
if (!loading && shattAldor.Checked)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.ShattrathFaction = "Aldor";
Character.OnItemsChanged();
}
}
private void upDownAvgHeal_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.AverageHealingScaling = (float)upDownAvgHeal.Value;
Character.OnItemsChanged();
}
}
private void upDownMaxCycleDuration_ValueChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.MaxCycleDuration = (float)upDownMaxCycleDuration.Value;
Character.OnItemsChanged();
}
}
private void chkInnervate_CheckedChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
calcOpts.InnervateSelf = chkInnervate.Checked;
Character.OnItemsChanged();
}
}
public void LoadCalculationOptions()
{
_loadingCalculationOptions = true;
if (Character.CalculationOptions == null)
{
Character.CalculationOptions = new CalculationOptionsTree();
}
calcOpts = Character.CalculationOptions as CalculationOptionsTree;
// Model Specific Code
//
_loadingCalculationOptions = false;
}
private void cmbImprovedRegrowth_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.ImprovedRegrowth = int.Parse(cmbImprovedRegrowth.Text);
}
catch { }
Character.OnItemsChanged();
}
}
private void cmbManaAmt_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.ManaPotAmt = float.Parse(cmbManaAmt.Text);
}
catch { }
Character.OnItemsChanged();
}
}
private void cmbGiftOfNature_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.GiftOfNature = int.Parse(cmbGiftOfNature.Text);
}
catch { }
Character.OnItemsChanged();
}
}
private void cmbLivingSpirit_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.LivingSpirit = int.Parse(cmbLivingSpirit.Text);
}
catch { }
Character.OnItemsChanged();
}
}
private void cmbSurvivalOfTheFittest_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.SotF = int.Parse(cmbSurvivalOfTheFittest.Text);
}
catch { }
Character.OnItemsChanged();
}
}
private void cmbHeartOfTheWild_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.HotW = int.Parse(cmbHeartOfTheWild.Text);
}
catch { }
Character.OnItemsChanged();
}
}
private void cmbEmpoweredTouch_SelectedIndexChanged(object sender, EventArgs e)
{
if (!loading)
{
CalculationOptionsTree calcOpts = Character.CalculationOptions as CalculationOptionsTree;
try
{
calcOpts.EmpoweredTouch = int.Parse(cmbEmpoweredTouch.Text);
}
catch { }
Character.OnItemsChanged();
}
}
public Stats GetBuffsStats(Character character, CalculationOptionsTree calcOpts)
{
List<Buff> removedBuffs = new List<Buff>();
List<Buff> addedBuffs = new List<Buff>();
Stats statsBuffs = GetBuffsStats(character.ActiveBuffs, character.SetBonusCount);
foreach (Buff b in removedBuffs)
{
character.ActiveBuffsAdd(b);
}
foreach (Buff b in addedBuffs)
{
character.ActiveBuffs.Remove(b);
}
return statsBuffs;
}
public override Stats GetCharacterStats(Character character, Item additionalItem)
{
CalculationOptionsTree opts = character.CalculationOptions as CalculationOptionsTree;
if (opts == null)
opts = new CalculationOptionsTree();
Stats stats = new Stats();
Stats statsBase = BaseStats.GetBaseStats(character.Level, character.Class, character.Race);
stats.Accumulate(statsBase);
stats.BaseAgility = statsBase.Agility;
// Get the gear/enchants/buffs stats loaded in
stats.Accumulate(GetItemStats(character, additionalItem));
stats.Accumulate(GetBuffsStats(character, opts));
// Talented bonus multipliers
Stats statsTalents = new Stats()
{
BonusIntellectMultiplier = (1 + 0.02f * character.DruidTalents.HeartOfTheWild) * (Character.ValidateArmorSpecialization(character, ItemType.Leather) ? 1.05f : 1f) - 1f,
BonusManaMultiplier = 0.05f * character.DruidTalents.Furor,
ManaCostReductionMultiplier = character.DruidTalents.Moonglow * 0.03f,
SpellCrit = 0.02f * character.DruidTalents.NaturesMajesty
};
stats.Accumulate(statsTalents);
FinalizeStats(stats, stats);
// Derived stats: Health, mana pool, armor
stats.Health = (float)Math.Round(stats.Health + StatConversion.GetHealthFromStamina(stats.Stamina));
stats.Health = (float)Math.Floor(stats.Health * (1f + stats.BonusHealthMultiplier));
stats.Mana = (float)Math.Round(stats.Mana + StatConversion.GetManaFromIntellect(stats.Intellect));
stats.Mana = (float)Math.Floor(stats.Mana * (1f + stats.BonusManaMultiplier));
// Armor
stats.Armor = stats.Armor * (1f + stats.BaseArmorMultiplier);
stats.BonusArmor = stats.BonusArmor * (1f + stats.BonusArmorMultiplier);
stats.Armor += stats.BonusArmor;
stats.Armor = (float)Math.Round(stats.Armor);
int T13Count;
character.SetBonusCount.TryGetValue("Deep Earth Vestments", out T13Count);
if (character.DruidTalents.NaturesGrace > 0)
stats.AddSpecialEffect(NaturesGrace[character.DruidTalents.NaturesGrace]);
if (character.DruidTalents.TreeOfLife > 0)
stats.AddSpecialEffect(TreeOfLife[character.DruidTalents.NaturalShapeshifter]);
if (T13Count >= 2)
stats.AddSpecialEffect(T13InnervateManaCostReduction);
return stats;
}
public void LoadCalculationOptions()
{
_loadingCalculationOptions = true;
if (Character.CalculationOptions == null) Character.CalculationOptions = new CalculationOptionsTree();
calcOpts = Character.CalculationOptions as CalculationOptionsTree;
// Model Specific Code
//
_loadingCalculationOptions = false;
}