private CharacterCalculationsTankDK GetCharacterCalculations(TankDKChar TDK, StatsDK stats, Rotation rot, bool isBurstCalc, bool needsDisplayCalcs)
{
CharacterCalculationsTankDK calcs = new CharacterCalculationsTankDK();
// Level differences.
int iLevelDiff = Math.Max(TDK.bo.Level - TDK.Char.Level, 0);
float fChanceToGetHit = 1f - Math.Min(1f, stats.Miss + stats.Dodge + stats.EffectiveParry);
float ArmorDamageReduction = (float)StatConversion.GetArmorDamageReduction(TDK.bo.Level, stats.Armor, 0f, 0f);
#region **** Setup Fight parameters ****
// Get the values of each type of damage in %.
// So first we get each type of damage in the same units: DPS.
// Get the total DPS.
float[] fCurrentDTPS = new float[3];
fCurrentDTPS[(int)SurvivalSub.Physical] = 0f;
fCurrentDTPS[(int)SurvivalSub.Bleed] = 0f;
fCurrentDTPS[(int)SurvivalSub.Magic] = 0f;
float[] fCurrentDmgBiggestHit = new float[3];
fCurrentDmgBiggestHit[(int)SurvivalSub.Physical] = 0f;
fCurrentDmgBiggestHit[(int)SurvivalSub.Bleed] = 0f;
fCurrentDmgBiggestHit[(int)SurvivalSub.Magic] = 0f;
float[] fCurrentDTPSPerc = new float[3];
fCurrentDTPSPerc[(int)SurvivalSub.Physical] = 1f;
fCurrentDTPSPerc[(int)SurvivalSub.Bleed] = 0f;
fCurrentDTPSPerc[(int)SurvivalSub.Magic] = 0f;
float fTotalDTPS = 0;
float fAvoidanceTotal = 1f - fChanceToGetHit;
// We want to start getting the Boss Handler stuff going on.
// Setup initial Boss data.
// How much of what kind of damage does this boss deal with?
#region ** Incoming Boss Dam **
// Let's make sure this is even valid
float DPHit = 0;
float DPTick = 0;
switch (TDK.calcOpts.PlayerRole)
{
case 0:
TDK.role = PLAYER_ROLES.MainTank;
break;
case 1:
TDK.role = PLAYER_ROLES.OffTank;
break;
case 2:
TDK.role = PLAYER_ROLES.TertiaryTank;
break;
default:
TDK.role = PLAYER_ROLES.MainTank;
break;
}
TDK.role = PLAYER_ROLES.MainTank;
foreach (Attack a in TDK.bo.Attacks)
{
// PlayerRole on calcOpts is MT=0, OT=1, TT=2, Any Tank = 3
// Any Tank means it should be affected by anything that affects a tanking role
if (a.AffectsRole[PLAYER_ROLES.MainTank] && (TDK.calcOpts.PlayerRole == 0 || TDK.calcOpts.PlayerRole == 3)
|| a.AffectsRole[PLAYER_ROLES.OffTank] && (TDK.calcOpts.PlayerRole == 1 || TDK.calcOpts.PlayerRole == 3)
|| a.AffectsRole[PLAYER_ROLES.TertiaryTank] && (TDK.calcOpts.PlayerRole == 2 || TDK.calcOpts.PlayerRole == 3))
{
// TODO: Figure out a way to get the phase changes handled.
DPHit = a.DamagePerHit;
DPTick = a.DamagePerTick;
if (a.DamageIsPerc)
{
#if DEBUG
if ((a.DamagePerHit >= 1f) || (a.DamagePerTick >= 1f))
throw new Exception("Percentage Damage is >= 100%.");
#endif
DPHit = a.DamagePerHit * stats.Health;
DPTick = a.DamagePerTick * stats.Health;
}
// Bleeds vs Magic vs Physical
if (a.DamageType == ItemDamageType.Physical)
{
// Bleed or Physical
// Need to figure out how to determine bleed vs. physical hits.
// Also need to balance out the physical hits and balance the hit rate.
// JOTHAY NOTE: Bleeds are DoTs
if (a.IsDoT) {
fCurrentDTPS[(int)SurvivalSub.Bleed] += GetDPS(DPHit, a.AttackSpeed) + GetDPS(DPTick, a.TickInterval);
if (fCurrentDmgBiggestHit[(int)SurvivalSub.Bleed] < DPHit + (DPTick * a.NumTicks))
fCurrentDmgBiggestHit[(int)SurvivalSub.Bleed] = DPHit + (DPTick * a.NumTicks);
}
else
{
fCurrentDTPS[(int)SurvivalSub.Physical] += GetDPS(DPHit, a.AttackSpeed);
if (fCurrentDmgBiggestHit[(int)SurvivalSub.Physical] < DPHit)
fCurrentDmgBiggestHit[(int)SurvivalSub.Physical] = DPHit;
}
}
else
{
// Magic now covering magical dots.
fCurrentDTPS[(int)SurvivalSub.Magic] += GetDPS(DPHit, a.AttackSpeed) + GetDPS(DPTick, a.TickInterval);
if (fCurrentDmgBiggestHit[(int)SurvivalSub.Magic] < DPHit + (DPTick * a.NumTicks))
fCurrentDmgBiggestHit[(int)SurvivalSub.Magic] = DPHit + (DPTick * a.NumTicks);
}
}
}
fTotalDTPS += fCurrentDTPS[(int)SurvivalSub.Physical];
fTotalDTPS += fCurrentDTPS[(int)SurvivalSub.Bleed];
fTotalDTPS += fCurrentDTPS[(int)SurvivalSub.Magic];
if (fTotalDTPS > 0)
{
fCurrentDTPSPerc[(int)SurvivalSub.Physical] = fCurrentDTPS[(int)SurvivalSub.Physical] / fTotalDTPS;
fCurrentDTPSPerc[(int)SurvivalSub.Bleed] = fCurrentDTPS[(int)SurvivalSub.Bleed] / fTotalDTPS;
fCurrentDTPSPerc[(int)SurvivalSub.Magic] = fCurrentDTPS[(int)SurvivalSub.Magic] / fTotalDTPS;
}
#endregion
// Set the Fight Duration to no larger than the Berserk Timer
// Question: What is the units for Berserk & Speed Timer? MS/S/M?
#endregion
#region ***** Survival Rating *****
// Magical damage:
// if there is a max resistance, then it's likely they are stacking for that resistance. So factor in that Max resistance.
float fMaxResist = Math.Max(stats.ArcaneResistance, stats.FireResistance);
fMaxResist = Math.Max(fMaxResist, stats.FrostResistance);
fMaxResist = Math.Max(fMaxResist, stats.NatureResistance);
fMaxResist = Math.Max(fMaxResist, stats.ShadowResistance);
float fMagicDR = StatConversion.GetAverageResistance(TDK.bo.Level, TDK.Char.Level, fMaxResist, 0f);
calcs.MagicDamageReduction = fMagicDR;
float[] SurvivalResults = new float [EnumHelper.GetCount(typeof(SurvivalSub))];
SurvivalResults = GetSurvival(ref TDK, stats, fCurrentDTPSPerc, ArmorDamageReduction, fMagicDR);
calcs.ArmorDamageReduction = ArmorDamageReduction;
calcs.PhysicalSurvival = SoftCapSurvival(TDK, fCurrentDmgBiggestHit[(int)SurvivalSub.Physical], SurvivalResults[(int)SurvivalSub.Physical], isBurstCalc);
calcs.BleedSurvival = SoftCapSurvival(TDK, fCurrentDmgBiggestHit[(int)SurvivalSub.Bleed], SurvivalResults[(int)SurvivalSub.Bleed], isBurstCalc);
calcs.MagicSurvival = SoftCapSurvival(TDK, fCurrentDmgBiggestHit[(int)SurvivalSub.Magic], SurvivalResults[(int)SurvivalSub.Magic], isBurstCalc);
calcs.HitsToSurvive = TDK.calcOpts.HitsToSurvive;
#endregion
#region ***** Threat Rating *****
rot.TotalDamage += (int)(stats.FireDamage * (1 + stats.BonusFireDamageMultiplier) * rot.CurRotationDuration);
rot.TotalThreat += (int)(stats.FireDamage * (1 + stats.BonusFireDamageMultiplier) * rot.CurRotationDuration) * 2;
calcs.RotationTime = rot.CurRotationDuration; // Display the rot in secs.
calcs.Threat = rot.m_TPS;
calcs.DPS = rot.m_DPS;
calcs.Blood = rot.m_BloodRunes;
calcs.Frost = rot.m_FrostRunes;
calcs.Unholy = rot.m_UnholyRunes;
calcs.Death = rot.m_DeathRunes;
calcs.RP = rot.m_RunicPower;
calcs.TotalThreat = (int)rot.TotalThreat;
calcs.ThreatWeight = TDK.calcOpts.ThreatWeight;
if (needsDisplayCalcs)
{
TDK.calcOpts.szRotReport = rot.ReportRotation();
}
#endregion
#region ***** Mitigation Rating *****
float[] fCurrentDTPSNoAvoid = new float[3];
fCurrentDTPSNoAvoid = fCurrentDTPS.Clone() as float[];
float[] fCurrentMitigation = GetMitigation(ref TDK, stats, rot, (stats.CritChanceReduction / .06f), ArmorDamageReduction, fCurrentDTPS, fMagicDR);
calcs.ArmorMitigation = fCurrentMitigation[(int)MitigationSub.Armor];
calcs.AvoidanceMitigation = fCurrentMitigation[(int)MitigationSub.Avoidance];
calcs.CritMitigation = fCurrentMitigation[(int)MitigationSub.Crit];
calcs.DamageTakenMitigation = fCurrentMitigation[(int)MitigationSub.DamageReduction];
calcs.DamageTakenMitigation += fCurrentMitigation[(int)MitigationSub.Haste];
calcs.HealsMitigation = fCurrentMitigation[(int)MitigationSub.Heals];
calcs.ImpedenceMitigation = fCurrentMitigation[(int)MitigationSub.Impedences];
calcs.MagicDamageReductedByAmount = fCurrentMitigation[(int)MitigationSub.AMS];
calcs.MagicDamageReductedByAmount += fCurrentMitigation[(int)MitigationSub.Magic];
calcs.Crit = (.06f - stats.CritChanceReduction);
calcs.DTPS = 0;
calcs.DTPSNoAvoidance = 0;
foreach (float f in fCurrentDTPS)
{
// These are sometimes coming back as negative.
// Assuming we are just 100% absorbing the attack, no damage
if (f > 0) { calcs.DTPS += f; }
}
if (TDK.calcOpts.b_RecoveryInclAvoidance == false)
{
GetMitigation(ref TDK, stats, rot, (stats.CritChanceReduction / .06f), ArmorDamageReduction, fCurrentDTPSNoAvoid, fMagicDR, false);
foreach (float f in fCurrentDTPSNoAvoid)
{
// These are sometimes coming back as negative.
// Assuming we are just 100% absorbing the attack, no damage
if (f > 0) { calcs.DTPSNoAvoidance += f; }
}
}
// Have to ensure we don't divide by 0
calcs.Mitigation = StatConversion.MitigationScaler / (Math.Max(1f, calcs.DTPS) / fTotalDTPS);
#endregion
return calcs;
}
/// <summary>
/// GetCharacterCalculations is the primary method of each model, where a majority of the calculations
/// and formulae will be used. GetCharacterCalculations should call GetCharacterStats(), and based on
/// those total stats for the character, and any calculationoptions on the character, perform all the
/// calculations required to come up with the final calculations defined in
/// CharacterDisplayCalculationLabels, including an Overall rating, and all Sub ratings defined in
/// SubPointNameColors.
/// </summary>
/// <param name="character">The character to perform calculations for.</param>
/// <param name="additionalItem">An additional item to treat the character as wearing.
/// This is used for gems, which don't have a slot on the character to fit in, so are just
/// added onto the character, in order to get gem calculations.</param>
/// <returns>A custom CharacterCalculations object which inherits from CharacterCalculationsBase,
/// containing all of the final calculations defined in CharacterDisplayCalculationLabels. See
/// CharacterCalculationsBase comments for more details.</returns>
public override CharacterCalculationsBase GetCharacterCalculations(Character character, Item additionalItem, bool referenceCalculation, bool significantChange, bool needsDisplayCalculations)
{
// First things first, we need to ensure that we aren't using bad data
CharacterCalculationsDPSDK calc = new CharacterCalculationsDPSDK();
if (character == null) { return calc; }
CalculationOptionsDPSDK calcOpts = character.CalculationOptions as CalculationOptionsDPSDK;
if (calcOpts == null) { return calc; }
//
StatsDK stats = new StatsDK();
DeathKnightTalents talents = character.DeathKnightTalents;
// Setup initial Boss data.
// Get Boss from BossOptions data.
BossOptions hBossOptions = character.BossOptions;
if (hBossOptions == null) hBossOptions = new BossOptions();
int targetLevel = hBossOptions.Level;
stats = GetCharacterStats(character, additionalItem) as StatsDK;
calc.BasicStats = stats.Clone() as StatsDK;
ApplyRatings(calc.BasicStats);
DKCombatTable combatTable = new DKCombatTable(character, calc.BasicStats, calc, calcOpts, hBossOptions);
if (needsDisplayCalculations) combatTable.PostAbilitiesSingleUse(false);
Rotation rot = new Rotation(combatTable);
Rotation.Type RotT = rot.GetRotationType(character.DeathKnightTalents);
// TODO: Fix this so we're not using pre-set rotations/priorities.
if (RotT == Rotation.Type.Frost)
rot.PRE_Frost();
else if (RotT == Rotation.Type.Unholy)
rot.PRE_Unholy();
else if (RotT == Rotation.Type.Blood)
rot.PRE_BloodDiseased();
else
rot.Solver();
//TODO: This may need to be handled special since it's to update stats.
AccumulateSpecialEffectStats(stats, character, calcOpts, combatTable, rot); // Now add in the special effects.
ApplyRatings(stats);
#region Cinderglacier
if (stats.CinderglacierProc > 0)
{
// How many frost & shadow abilities do we have per min.?
float CGabs = ((rot.m_FrostSpecials + rot.m_ShadowSpecials) / rot.CurRotationDuration) * 60f;
float effCG = 0;
if (CGabs > 0)
// Since 3 of those abilities get the 20% buff
// Get the effective ammount of CinderGlacier that would be applied across each ability.
// it is a proc after all.
effCG = 3 / CGabs;
stats.BonusFrostDamageMultiplier += (.2f * effCG);
stats.BonusShadowDamageMultiplier += (.2f * effCG);
}
#endregion
// refresh w/ updated stats.
combatTable = new DKCombatTable(character, stats, calc, calcOpts, hBossOptions);
combatTable.PostAbilitiesSingleUse(false);
rot = new Rotation(combatTable);
RotT = rot.GetRotationType(character.DeathKnightTalents);
// TODO: Fix this so we're not using pre-set rotations.
if (RotT == Rotation.Type.Frost)
rot.PRE_Frost();
else if (RotT == Rotation.Type.Unholy)
rot.PRE_Unholy();
else if (RotT == Rotation.Type.Blood)
rot.PRE_BloodDiseased();
else
rot.Solver();
#region Pet Handling
// For UH, this is valid. For Frost/Blood, we need to have this be 1/3 of the value since it has an uptime of 1 min for every 3.
float ghouluptime = 1f;
calc.dpsSub[(int)DKability.Gargoyle] = 0;
if (RotT != Rotation.Type.Unholy) ghouluptime = 1f / 3f;
else
{
// Unholy will also have gargoyles.
Pet Gar = new Gargoyle(stats, talents, hBossOptions, calcOpts.presence);
float garuptime = .5f/3f;
calc.dpsSub[(int)DKability.Gargoyle] = Gar.DPS * garuptime;
calc.damSub[(int)DKability.Gargoyle] = Gar.DPS * 30f; // Duration 30 seconds.
}
Pet ghoul = new Ghoul(stats, talents, hBossOptions, calcOpts.presence);
calc.dpsSub[(int)DKability.Ghoul] = ghoul.DPS * ghouluptime;
calc.damSub[(int)DKability.Ghoul] = ghoul.DPS * 60f; // Duration 1 min.
#endregion
// Stats as Fire damage additive value proc.
if (stats.ArcaneDamage > 1) calc.dpsSub[(int)DKability.OtherArcane] += stats.ArcaneDamage;
if (stats.FireDamage > 1) calc.dpsSub[(int)DKability.OtherFire] += stats.FireDamage;
if (stats.FrostDamage > 1) calc.dpsSub[(int)DKability.OtherFrost] += stats.FrostDamage;
if (stats.HolyDamage > 1) calc.dpsSub[(int)DKability.OtherHoly] += stats.HolyDamage;
if (stats.NatureDamage > 1) calc.dpsSub[(int)DKability.OtherNature] += stats.NatureDamage;
if (stats.ShadowDamage > 1) calc.dpsSub[(int)DKability.OtherShadow] += stats.ShadowDamage;
// Fire Dam Multiplier.
calc.RotationTime = rot.CurRotationDuration;
calc.Blood = rot.m_BloodRunes;
calc.Frost = rot.m_FrostRunes;
calc.Unholy = rot.m_UnholyRunes;
calc.Death = rot.m_DeathRunes;
calc.RP = rot.m_RunicPower;
calc.FreeRERunes = rot.m_FreeRunesFromRE;
calc.EffectiveArmor = stats.Armor;
calc.OverallPoints = calc.DPSPoints = rot.m_DPS
// Add in supplemental damage from other sources
+ calc.dpsSub[(int)DKability.Ghoul]
+ calc.dpsSub[(int)DKability.Gargoyle]
+ calc.dpsSub[(int)DKability.OtherArcane] + calc.dpsSub[(int)DKability.OtherFire] + calc.dpsSub[(int)DKability.OtherFrost] + calc.dpsSub[(int)DKability.OtherHoly] + calc.dpsSub[(int)DKability.OtherNature] + calc.dpsSub[(int)DKability.OtherShadow];
if (needsDisplayCalculations)
{
AbilityDK_Base a = rot.GetAbilityOfType(DKability.White);
if (rot.ml_Rot.Count > 1)
{
AbilityDK_Base b;
b = rot.GetAbilityOfType(DKability.ScourgeStrike);
if (b == null) b = rot.GetAbilityOfType(DKability.FrostStrike);
if (b == null) b = rot.GetAbilityOfType(DKability.DeathStrike);
calc.YellowHitChance = b.HitChance;
}
calc.WhiteHitChance = (a == null ? 0 : a.HitChance + a.CritChance + .23f); // + glancing
calc.MHWeaponDPS = (a == null ? 0 : rot.GetAbilityOfType(DKability.White).DPS);
if (null != combatTable.MH)
{
calc.MHWeaponDamage = combatTable.MH.damage;
calc.MHAttackSpeed = combatTable.MH.hastedSpeed;
calc.DodgedAttacks = combatTable.MH.chanceDodged;
calc.AvoidedAttacks = combatTable.MH.chanceDodged;
if (!hBossOptions.InBack)
calc.AvoidedAttacks += combatTable.MH.chanceParried;
calc.MissedAttacks = combatTable.MH.chanceMissed;
}
if (null != combatTable.OH)
{
a = rot.GetAbilityOfType(DKability.WhiteOH);
calc.OHWeaponDPS = (a == null ? 0 : rot.GetAbilityOfType(DKability.WhiteOH).DPS);
calc.OHWeaponDamage = combatTable.OH.damage;
calc.OHAttackSpeed = combatTable.OH.hastedSpeed;
}
calcOpts.szRotReport = rot.ReportRotation();
calc.m_RuneCD = (float)rot.m_SingleRuneCD / 1000;
calc.DPSBreakdown(rot);
}
return calc;
}