public void DPSDK_TrinketHang()
{
Stats StatTrink = new Stats();
StatTrink.AddSpecialEffect(new SpecialEffect(Trigger.MainHandHit, new Stats()
{
Strength = 300
}, 10, 0, .1f, 5));
StatTrink.MasteryRating = 500;
Item Trinket = new Item("testTrink", ItemQuality.Epic, ItemType.None, 10102, "icon.bmp", ItemSlot.Trinket, "", false,
StatTrink, StatTrink, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, "");
m_char.Trinket1 = new ItemInstance(Trinket, 0, null, null, null, new Enchant(), new Reforging(), new Tinkering());
// This bug was due to non-valid swing times.
m_char.MainHand = null;
Rawr.DPSDK.CalculationsDPSDK CalcDPSDK = new Rawr.DPSDK.CalculationsDPSDK();
CalculationOptionsDPSDK calcOpts = new CalculationOptionsDPSDK();
calcOpts.presence = Rawr.DK.Presence.Frost;
m_char.CalculationOptions = calcOpts;
this.testContextInstance.BeginTimer("GetCalc");
CharacterCalculationsBase calcs = CalcDPSDK.GetCharacterCalculations(m_char);
calcs.GetCharacterDisplayCalculationValues();
this.testContextInstance.EndTimer("GetCalc");
}
public DKCombatTable(Character c, StatsDK stats, CharacterCalculationsBase calcs, ICalculationOptionBase calcOpts, BossOptions bossOpts)
{
m_CState = new CombatState();
if (c != null)
{
m_CState.m_Char = c;
m_CState.m_Talents = c.DeathKnightTalents;
m_CState.m_Spec = CalculationsDPSDK.GetSpec(c.DeathKnightTalents);
}
m_CState.m_Stats = stats;
// TODO: Put in check here for null.
m_Calcs = calcs as CharacterCalculationsDPSDK;
m_Opts = calcOpts as CalculationOptionsDPSDK;
m_CState.m_Presence = Presence.Frost;
if (calcOpts != null && m_Opts == null)
{
//throw new Exception("Opts not converted properly.");
m_Opts = new CalculationOptionsDPSDK();
}
try { m_CState.m_Presence = m_Opts.presence; } catch { } // pass stay w/ default
m_BO = bossOpts;
if (m_BO == null)
{
m_BO = new BossOptions();
}
// JOTHAY TODO: Kind of an Ugly Hack to do this, but it will give them a value
m_CState.m_NumberOfTargets = m_BO.MultiTargs ? m_BO.DynamicCompiler_MultiTargs.GetAverageTargetGroupSize(m_BO.BerserkTimer) : 1f;
//
m_CState.m_bAttackingFromBehind = m_BO.InBack;
m_CState.fBossArmor = m_BO.Armor;
SetupExpertise(c);
}
public CharacterCalculationsBase GetCharacterCalculations(Character character, Item additionalItem, bool computeIncrementalSet)
{
CompiledCalculationOptions calculationOptions = new CompiledCalculationOptions(character);
CharacterCalculationsBase calc = GetCharacterCalculations(character, additionalItem, calculationOptions, null, computeIncrementalSet);
return(calc);
}
private void AsyncCalculationStart(CharacterCalculationsBase calculations, AsyncOperation asyncCalculation)
{
Dictionary <string, string> result = calculations.GetAsynchronousCharacterDisplayCalculationValues();
asyncCalculation.PostOperationCompleted(asyncCalculationCompleted, new AsyncCalculationResult()
{
Calculations = calculations, DisplayCalculationValues = result
});
}
public void TankDK_BuildAcceptance()
{
Rawr.TankDK.CalculationsTankDK CalcTankDK = new Rawr.TankDK.CalculationsTankDK();
CalculationOptionsTankDK calcOpts = new CalculationOptionsTankDK();
m_char.CalculationOptions = calcOpts;
this.testContextInstance.BeginTimer("GetCalc");
CharacterCalculationsBase calcs = CalcTankDK.GetCharacterCalculations(m_char);
calcs.GetCharacterDisplayCalculationValues();
this.testContextInstance.EndTimer("GetCalc");
}
public void DPSDK_BuildAcceptance()
{
Rawr.DPSDK.CalculationsDPSDK CalcDPSDK = new Rawr.DPSDK.CalculationsDPSDK();
CalculationOptionsDPSDK calcOpts = new CalculationOptionsDPSDK();
calcOpts.presence = Rawr.DK.Presence.Frost;
m_char.CalculationOptions = calcOpts;
this.testContextInstance.BeginTimer("GetCalc");
CharacterCalculationsBase calcs = CalcDPSDK.GetCharacterCalculations(m_char);
calcs.GetCharacterDisplayCalculationValues();
this.testContextInstance.EndTimer("GetCalc");
}
public void character_CalculationsInvalidated(object sender, EventArgs e)
{
#if DEBUG
DateTime start = DateTime.Now;
#endif
this.Cursor = Cursors.Wait;
if (asyncCalculation != null)
{
CharacterCalculationsBase oldCalcs = referenceCalculation;
referenceCalculation = null;
oldCalcs.CancelAsynchronousCharacterDisplayCalculation();
asyncCalculation = null;
}
//_unsavedChanges = true;
referenceCalculation = Calculations.GetCharacterCalculations(character, null, true, true, true);
CalculationDisplay.SetCalculations(referenceCalculation.GetCharacterDisplayCalculationValues());
UpdateDisplayCalculationValues(referenceCalculation.GetCharacterDisplayCalculationValues(), referenceCalculation);
if (Character.PrimaryProfession == Profession.Blacksmithing || Character.SecondaryProfession == Profession.Blacksmithing)
{
//HandBSCheck.IsChecked = true;
//WristBSCheck.IsChecked = true;
HandBSCheck.IsEnabled = true;
WristBSCheck.IsEnabled = true;
}
else
{
HandBSCheck.IsChecked = false;
WristBSCheck.IsChecked = false;
HandBSCheck.IsEnabled = false;
WristBSCheck.IsEnabled = false;
}
if (referenceCalculation.RequiresAsynchronousDisplayCalculation)
{
asyncCalculation = AsyncOperationManager.CreateOperation(null);
ThreadPool.QueueUserWorkItem(delegate
{
AsyncCalculationStart(referenceCalculation, asyncCalculation);
});
}
this.Cursor = Cursors.Arrow;
#if DEBUG
System.Diagnostics.Debug.WriteLine(string.Format("Finished MainPage CalculationsInvalidated: {0}ms", DateTime.Now.Subtract(start).TotalMilliseconds));
#endif
}
private static float GetCalculationValue(CharacterCalculationsBase calcs, string calculation)
{
if (calculation == null || calculation == "Overall Rating")
{
return(calcs.OverallPoints);
}
else
{
int index = 0;
foreach (string subPoint in Calculations.SubPointNameColors.Keys)
{
if (calculation.StartsWith(subPoint, StringComparison.Ordinal))
{
return(calcs.SubPoints[index]);
}
index++;
}
return(0f);
}
}
public void Test_EmptyCharacterXML()
{
string szFullPath;
int iCount = 0;
foreach (string szModel in EnumHelper.GetNames(typeof(Models)))
{
szFullPath = szBasePath + "~Test_Empty" + szModel + ".xml";
string szCharXML = System.IO.File.ReadAllText(szFullPath);
Character c = Character.LoadFromXml(szCharXML);
Assert.AreEqual(szModel, c.CurrentModel, true);
CharacterCalculationsBase CharCalcs = c.CurrentCalculations.GetCharacterCalculations(c, null, true, true, true);
Assert.IsNotNull(CharCalcs, szModel);
CharCalcs.GetCharacterDisplayCalculationValues();
Assert.IsTrue(CharCalcs.OverallPoints >= 0, szModel);
iCount++;
}
// Test to ensure all models run.
Assert.AreEqual(EnumHelper.GetCount(typeof(Models)), iCount, "ModelCount");
}
public void UpdateDisplayCalculationValues(Dictionary <string, string> displayCalculationValues, CharacterCalculationsBase _calculatedStats)
{
//calculationDisplay1.SetCalculations(displayCalculationValues);
string status;
if (!displayCalculationValues.TryGetValue("Status", out status))
{
int i = 0;
status = "Overall: " + Math.Round(_calculatedStats.OverallPoints);
foreach (KeyValuePair <string, Color> kvp in Calculations.SubPointNameColors)
{
status += ", " + kvp.Key + ": " + Math.Round(_calculatedStats.SubPoints[i]);
i++;
}
//status = "Rawr version " + typeof(Calculations).Assembly.GetName().Version.ToString();
}
StatusText.Text = status;
}
private void BuildListItems()
{
try
{
_buildingListItems = true;
if (Character == null)
{
return;
}
bool seenEquippedItem = (Character[Slot] == null);
List <ComparisonCalculationBase> itemCalculations = new List <ComparisonCalculationBase>();
if (IsEnchantList)
{
CharacterCalculationsBase current = Calculations.GetCharacterCalculations(Character);
if (Character != null && current != null)
{
itemCalculations = Calculations.GetEnchantCalculations(Item.GetItemSlotByCharacterSlot(Slot), Character, current, false);
}
}
else if (IsTinkeringList)
{
CharacterCalculationsBase current = Calculations.GetCharacterCalculations(Character);
if (Character != null && current != null)
{
itemCalculations = Calculations.GetTinkeringCalculations(Item.GetItemSlotByCharacterSlot(Slot), Character, current, false);
}
}
else if (IsReforgeList)
{
CharacterCalculationsBase current = Calculations.GetCharacterCalculations(Character);
if (Character != null && current != null)
{
itemCalculations = Calculations.GetReforgeCalculations(Slot, Character, current, false);
}
}
else if (IsCogwheelList)
{
Calculations.ClearCache();
List <Item> relevantItems = Character.GetRelevantItems(GemSlot);
foreach (Item item in relevantItems)
{
ComparisonCalculationBase itemCalc = Calculations.GetItemGemCalculations(item, Character, Slot, GemIndex);
if (SelectedItem != null && SelectedItem.Id == item.Id)
{
itemCalc.Equipped = true;
seenEquippedItem = true;
}
itemCalculations.Add(itemCalc);
}
if (!seenEquippedItem)
{
itemCalculations.Add(Calculations.GetItemGemCalculations(SelectedItem, Character, Slot, GemIndex));
}
}
else if (IsHydraulicList)
{
Calculations.ClearCache();
List <Item> relevantItems = Character.GetRelevantItems(GemSlot);
foreach (Item item in relevantItems)
{
ComparisonCalculationBase itemCalc = Calculations.GetItemGemCalculations(item, Character, Slot, GemIndex);
if (SelectedItem != null && SelectedItem.Id == item.Id)
{
itemCalc.Equipped = true;
seenEquippedItem = true;
}
itemCalculations.Add(itemCalc);
}
if (!seenEquippedItem)
{
itemCalculations.Add(Calculations.GetItemGemCalculations(SelectedItem, Character, Slot, GemIndex));
}
}
else if (IsGemList)
{
Calculations.ClearCache();
List <Item> relevantItems = Character.GetRelevantItems(GemSlot);
foreach (Item item in relevantItems)
{
ComparisonCalculationBase itemCalc = Calculations.GetItemGemCalculations(item, Character, Slot, GemIndex);
if (SelectedItem != null && SelectedItem.Id == item.Id)
{
itemCalc.Equipped = true;
seenEquippedItem = true;
}
itemCalculations.Add(itemCalc);
}
if (!seenEquippedItem)
{
itemCalculations.Add(Calculations.GetItemGemCalculations(SelectedItem, Character, Slot, GemIndex));
}
}
else
{
Calculations.ClearCache();
List <ItemInstance> relevantItemInstances = Character.GetRelevantItemInstances(Slot);
if (relevantItemInstances.Count > 0)
{
foreach (ItemInstance item in relevantItemInstances)
{
if (!seenEquippedItem && Character[Slot].Equals(item))
{
seenEquippedItem = true;
}
itemCalculations.Add(Calculations.GetItemCalculations((ItemInstance)item, Character, Slot));
}
}
if (!seenEquippedItem)
{
itemCalculations.Add(Calculations.GetItemCalculations(Character[Slot], Character, Slot));
}
}
float maxValue = itemCalculations.Count == 0 ? 100f : itemCalculations.Max(c => c.OverallPoints);
Items.Clear();
List <ItemListItem> itemListItems = new List <ItemListItem>();
ItemListItem selectedListItem = null;
int selectedEnchantId = 0, selectedReforgingId = 0, selectedTinkeringId = 0;
if (IsEnchantList)
{
Enchant selectedEnchant = Character.GetEnchantBySlot(Slot);
if (selectedEnchant != null)
{
selectedEnchantId = selectedEnchant.Id;
}
}
else if (IsTinkeringList)
{
Tinkering selectedTinkering = Character.GetTinkeringBySlot(Slot);
if (selectedTinkering != null)
{
selectedTinkeringId = selectedTinkering.Id;
}
}
else if (IsReforgeList)
{
Reforging selectedReforging = Character.GetReforgingBySlot(Slot);
if (selectedReforging != null)
{
selectedReforgingId = selectedReforging.Id;
}
}
else if (IsGemList)
{
ComparisonCalculationBase emptyCalcs = Calculations.CreateNewComparisonCalculation();
emptyCalcs.Name = "Empty";
emptyCalcs.Item = new Item();
emptyCalcs.Item.Name = "Empty";
emptyCalcs.Item.Id = -1;
emptyCalcs.Equipped = SelectedItem == null;
itemCalculations.Add(emptyCalcs);
}
else
{
ComparisonCalculationBase emptyCalcs = Calculations.CreateNewComparisonCalculation();
emptyCalcs.Name = "Empty";
emptyCalcs.Item = new Item();
emptyCalcs.Item.Name = "Empty";
emptyCalcs.ItemInstance = new ItemInstance();
emptyCalcs.ItemInstance.Id = -1;
emptyCalcs.Equipped = Character[Slot] == null;
itemCalculations.Add(emptyCalcs);
}
foreach (ComparisonCalculationBase calc in itemCalculations)
{
ItemListItem itemListItem = new ItemListItem(calc, maxValue, 344d);
itemListItems.Add(itemListItem);
if (IsEnchantList)
{
if (itemListItem.EnchantId == selectedEnchantId)
{
selectedListItem = itemListItem;
}
}
else if (IsTinkeringList)
{
if (itemListItem.TinkeringId == selectedTinkeringId)
{
selectedListItem = itemListItem;
}
}
else if (IsReforgeList)
{
if (itemListItem.ReforgeId == selectedReforgingId)
{
selectedListItem = itemListItem;
}
}
else if (IsGemList || IsHydraulicList || IsCogwheelList)
{
if (calc.Item == null)
{
if (SelectedItem == null)
{
selectedListItem = itemListItem;
}
}
else
{
if ((SelectedItem != null && calc.Item.Id == SelectedItem.Id) || (calc.Item.Id == -1 && SelectedItem == null))
{
selectedListItem = itemListItem;
}
}
}
else
{
if (calc.ItemInstance == Character[Slot] || (calc.ItemInstance.Id == -1 && Character[Slot] == null))
{
selectedListItem = itemListItem;
}
}
}
Items.AddRange(itemListItems);
listBoxItems.SelectedItem = selectedListItem;
listBoxItems.Focus();
IsPopulated = true;
}
finally
{
_buildingListItems = false;
}
}
public static void RenderStatsGraph(Graphics g, int graphWidth, int graphHeight, Character character, Stats[] statsList, Color[] colors, int scale, string explanatoryText, string calculation, Style style)
{
CharacterCalculationsBase baseCalc = Calculations.GetCharacterCalculations(character);
float baseFigure = GetCalculationValue(baseCalc, calculation);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
float graphOffset = graphWidth / 2.0f, graphStep = (graphWidth - 100) / 2.0f / scale;
if (statsList.Length == 0 || statsList.Length > colors.Length)
{
return; // more than 12 elements for the array would run out of colours
}
float minDpsChange = 0f, maxDpsChange = 0f;
PointF[][] points = new PointF[statsList.Length][];
for (int index = 0; index < statsList.Length; index++)
{
Stats newStats = new Stats();
points[index] = new PointF[2 * scale + 1];
newStats.Accumulate(statsList[index], -scale - 1);
for (int count = -scale; count <= scale; count++)
{
newStats.Accumulate(statsList[index]);
CharacterCalculationsBase currentCalc = Calculations.GetCharacterCalculations(character, new Item()
{
Stats = newStats
}, false, false, false);
float currentFigure = GetCalculationValue(currentCalc, calculation);
float dpsChange = currentFigure - baseFigure;
points[index][count + scale] = new PointF(graphOffset + count * graphStep, dpsChange);
if (dpsChange < minDpsChange)
{
minDpsChange = dpsChange;
}
if (dpsChange > maxDpsChange)
{
maxDpsChange = dpsChange;
}
}
}
float DpsVariance = maxDpsChange - minDpsChange;
if (DpsVariance == 0)
{
DpsVariance = 1;
}
for (int index = 0; index < statsList.Length; index++)
{
for (int count = -scale; count <= scale; count++)
{
points[index][count + scale].Y = (int)((maxDpsChange - points[index][count + scale].Y) * (graphHeight - 48) / DpsVariance) + 20;
}
Brush statBrush = new SolidBrush(colors[index]);
switch (style)
{
case Style.DpsWarr:
g.DrawLines(new Pen(statBrush, 3), points[index]);
break;
case Style.Mage:
g.DrawLines(new Pen(statBrush, 1), points[index]);
break;
}
}
RenderGrid(g, graphWidth, graphHeight, character, statsList, colors, scale, 1f, "F1", explanatoryText, calculation, style, minDpsChange, maxDpsChange, DpsVariance, true);
}
public static void RenderScalingGraph(Graphics g, int graphWidth, int graphHeight, Character character, Stats[] statsList, Stats baseStat, bool requiresReferenceCalculations, Color[] colors, int scale, string explanatoryText, string calculation, Style style)
{
CharacterCalculationsBase baseCalc = Calculations.GetCharacterCalculations(character);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
float graphOffset = graphWidth / 2.0f, graphStep = (graphWidth - 100) / 2.0f / scale;
if (statsList.Length == 0 || statsList.Length > colors.Length)
{
return; // more than 12 elements for the array would run out of colours
}
float minDpsChange = 0f, maxDpsChange = 0f;
PointF[][] points = new PointF[statsList.Length][];
// extract property data for relative stats calculations
KeyValuePair <PropertyInfo, float>[] properties = new KeyValuePair <PropertyInfo, float> [statsList.Length];
for (int index = 0; index < statsList.Length; index++)
{
var p = statsList[index].Values(x => x > 0);
foreach (var kvp in p)
{
properties[index] = kvp;
}
points[index] = new PointF[2 * scale + 1];
}
for (int count = -scale; count <= scale; count++)
{
Stats newStats = new Stats();
newStats.Accumulate(baseStat, count);
Item item = new Item()
{
Stats = newStats
};
if (requiresReferenceCalculations)
{
Calculations.GetCharacterCalculations(character, item, true, false, false);
}
for (int index = 0; index < statsList.Length; index++)
{
ComparisonCalculationBase currentCalc = CalculationsBase.GetRelativeStatValue(character, properties[index].Key, item, properties[index].Value);
float dpsChange = GetCalculationValue(currentCalc, calculation);
points[index][count + scale] = new PointF(graphOffset + count * graphStep, dpsChange);
if (dpsChange < minDpsChange)
{
minDpsChange = dpsChange;
}
if (dpsChange > maxDpsChange)
{
maxDpsChange = dpsChange;
}
}
}
// restore reference calculation
if (requiresReferenceCalculations)
{
Stats newStats = new Stats();
Item item = new Item()
{
Stats = newStats
};
Calculations.GetCharacterCalculations(character, item, true, false, false);
}
// increase the spread a bit to so that you can see if something is at the edges and straight
float DpsVariance = maxDpsChange - minDpsChange;
minDpsChange -= DpsVariance * 0.05f;
maxDpsChange += DpsVariance * 0.05f;
DpsVariance = maxDpsChange - minDpsChange;
if (DpsVariance == 0)
{
DpsVariance = 1;
}
for (int index = 0; index < statsList.Length; index++)
{
for (int count = -scale; count <= scale; count++)
{
points[index][count + scale].Y = (int)((maxDpsChange - points[index][count + scale].Y) * (graphHeight - 48) / DpsVariance) + 20;
}
Brush statBrush = new SolidBrush(colors[index]);
switch (style)
{
case Style.DpsWarr:
g.DrawLines(new Pen(statBrush, 3), points[index]);
break;
case Style.Mage:
g.DrawLines(new Pen(statBrush, 1), points[index]);
break;
}
}
float unit = 1f;
var bp = baseStat.Values(x => x > 0);
foreach (var kvp in bp)
{
unit = kvp.Value;
}
RenderGrid(g, graphWidth, graphHeight, character, statsList, colors, scale, unit, "F", explanatoryText, calculation, style, minDpsChange, maxDpsChange, DpsVariance, false);
}
public OptimizerResults(Character oldCharacter, Character newCharacter)
{
InitializeComponent();
CurrentCharacter = oldCharacter;
BestCharacter = newCharacter;
int rows = 0;
for (int i = 0; i < Character.OptimizableSlotCount; i++)
{
CharacterSlot slot = (CharacterSlot)i;
if ((oldCharacter[slot] == null && newCharacter[slot] != null) ||
(oldCharacter[slot] != null && !oldCharacter[slot].Equals(newCharacter[slot])))
{
//Testing if the ring/trinket items were just swapped and not actually different
if (slot == CharacterSlot.Finger1 || slot == CharacterSlot.Finger2)
{
ItemInstance old1 = oldCharacter[CharacterSlot.Finger1];
ItemInstance old2 = oldCharacter[CharacterSlot.Finger2];
ItemInstance new1 = newCharacter[CharacterSlot.Finger1];
ItemInstance new2 = newCharacter[CharacterSlot.Finger2];
if (((old1 == null && new2 == null) || (old1 != null && old1.Equals(new2))) &&
((old2 == null && new1 == null) || (old2 != null && old2.Equals(new1))))
{
continue;
}
}
else if (slot == CharacterSlot.Trinket1 || slot == CharacterSlot.Trinket2)
{
ItemInstance old1 = oldCharacter[CharacterSlot.Trinket1];
ItemInstance old2 = oldCharacter[CharacterSlot.Trinket2];
ItemInstance new1 = newCharacter[CharacterSlot.Trinket1];
ItemInstance new2 = newCharacter[CharacterSlot.Trinket2];
if (((old1 == null && new2 == null) || (old1 != null && old1.Equals(new2))) &&
((old2 == null && new1 == null) || (old2 != null && old2.Equals(new1))))
{
continue;
}
}
ItemGrid.RowDefinitions.Add(new RowDefinition()
{
Height = GridLength.Auto
});
if (oldCharacter[slot] != null)
{
ItemDisplay oldItem = new ItemDisplay(oldCharacter[slot]);
oldItem.Style = Resources["ItemDisplayStyle"] as Style;
ItemGrid.Children.Add(oldItem);
Grid.SetRow(oldItem, rows);
Grid.SetColumn(oldItem, 0);
}
if (newCharacter[slot] != null)
{
ItemDisplay newItem = new ItemDisplay(newCharacter[slot]);
newItem.Style = Resources["ItemDisplayStyle"] as Style;
ItemGrid.Children.Add(newItem);
Grid.SetRow(newItem, rows);
Grid.SetColumn(newItem, 1);
}
rows++;
}
}
CharacterCalculationsBase currentCalc = Calculations.GetCharacterCalculations(oldCharacter, null, false, true, true);
CurrentScoreLabel.Text = string.Format("Current: {0}", currentCalc.OverallPoints);
CurrentCalculations.SetCalculations(currentCalc.GetCharacterDisplayCalculationValues());
CharacterCalculationsBase optimizedCalc = Calculations.GetCharacterCalculations(newCharacter, null, false, true, true);
OptimizedScoreLabel.Text = string.Format("Optimized: {0}", optimizedCalc.OverallPoints);
OptimizedCalculations.SetCalculations(optimizedCalc.GetCharacterDisplayCalculationValues());
}
private static float GetCalculationValue(CharacterCalculationsBase calcs, string calculation)
{
if (calculation == null || calculation == "Overall Rating")
return calcs.OverallPoints;
else
{
int index = 0;
foreach (string subPoint in Calculations.SubPointNameColors.Keys)
{
if (calculation.StartsWith(subPoint, StringComparison.Ordinal))
return calcs.SubPoints[index];
index++;
}
return 0f;
}
}
public DKCombatTable(Character c, StatsDK stats, CharacterCalculationsBase calcs, ICalculationOptionBase calcOpts, BossOptions bossOpts)
{
m_CState = new CombatState();
if (c != null) {
m_CState.m_Char = c;
m_CState.m_Talents = c.DeathKnightTalents;
m_CState.m_Spec = CalculationsDPSDK.GetSpec(c.DeathKnightTalents);
}
m_CState.m_Stats = stats;
// TODO: Put in check here for null.
m_Calcs = calcs as CharacterCalculationsDPSDK;
m_Opts = calcOpts as CalculationOptionsDPSDK;
m_CState.m_Presence = Presence.Frost;
if (calcOpts != null && m_Opts == null) {
//throw new Exception("Opts not converted properly.");
m_Opts = new CalculationOptionsDPSDK();
}
try { m_CState.m_Presence = m_Opts.presence; } catch { } // pass stay w/ default
m_BO = bossOpts;
if (m_BO == null) { m_BO = new BossOptions(); }
// JOTHAY TODO: Kind of an Ugly Hack to do this, but it will give them a value
m_CState.m_NumberOfTargets = m_BO.MultiTargs ? m_BO.DynamicCompiler_MultiTargs.GetAverageTargetGroupSize(m_BO.BerserkTimer) : 1f;
//
m_CState.m_bAttackingFromBehind = m_BO.InBack;
m_CState.fBossArmor = m_BO.Armor;
SetupExpertise(c);
}
