public void LoadCurrentGearEnchantsBuffs(CharacterCalculationsBase currentCalculations) { List <ComparisonCalculationBase> itemCalculations = new List <ComparisonCalculationBase>(); if (Character != null) { foreach (CharacterSlot slot in Enum.GetValues(typeof(CharacterSlot))) { if (Character[slot] != null) { itemCalculations.Add(Calculations.GetItemCalculations(Character[slot], Character, slot)); } } foreach (ComparisonCalculationBase calc in Calculations.GetEnchantCalculations(ItemSlot.None, Character, currentCalculations, true)) { itemCalculations.Add(calc); } foreach (ComparisonCalculationBase calc in Calculations.GetBuffCalculations(Character, currentCalculations, "Current")) { itemCalculations.Add(calc); } } comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.ItemCalculations = itemCalculations.ToArray(); comparisonGraph1.EquipSlot = CharacterSlot.None; _characterSlot = CharacterSlot.None; }
private float[] BuildGraphData(Character character, out float minY, out float maxY, out string[] rotations) { minY = float.MaxValue; maxY = 0f; float[] overallData = new float[(MaximumX - MinimumX) * GranularityX + 1]; rotations = new string[overallData.Length]; Item itemStats = new Item() { Stats = new Stats() }; PropertyInfo propertyX = typeof(Stats).GetProperty(StatX); float y, x; for (int i = 0; i < overallData.Length; i++) { try { x = MinimumX + (float)i / (float)GranularityX; propertyX.SetValue(itemStats.Stats, x, null); CharacterCalculationsBase calcs = Calculations.GetCharacterCalculations(character, itemStats, false, true, false); y = calcs.OverallPoints; //rotations[i] = calcs.GetCharacterDisplayCalculationValues()["Optimal Rotation"]; overallData[i] = y; minY = Math.Min(minY, y); maxY = Math.Max(maxY, y); } catch (Exception ex) { ex.ToString(); } } return(overallData); }
public void UpdateStatsGraph(Character character, Stats[] statsList, Color[] colors, int scale, string explanatoryText, string calculation) { CharacterCalculationsBase baseCalc = Calculations.GetCharacterCalculations(character); float baseFigure = GetCalculationValue(baseCalc, calculation); if (statsList.Length == 0 || statsList.Length > colors.Length) { return; // more than 12 elements for the array would run out of colours } Point[][] points = new Point[statsList.Length][]; Chart.Series.Clear(); for (int index = 0; index < statsList.Length; index++) { Stats newStats = new Stats(); points[index] = new Point[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 Point(count, dpsChange); } Style dataPointStyle = new Style(typeof(LineDataPoint)); dataPointStyle.Setters.Add(new Setter(DataPoint.TemplateProperty, Resources["InvisibleDataPointTemplate"])); dataPointStyle.Setters.Add(new Setter(DataPoint.BackgroundProperty, new SolidColorBrush(colors[index]))); Chart.Series.Add(new LineSeries() { Title = statsList[index].ToString(), ItemsSource = points[index], IndependentValuePath = "X", DependentValuePath = "Y", DataPointStyle = dataPointStyle, }); } Chart.Axes.Clear(); Chart.Axes.Add(new LinearAxis() { Orientation = AxisOrientation.X, Title = "Stat Change", ShowGridLines = true, }); Chart.Axes.Add(new LinearAxis() { Orientation = AxisOrientation.Y, Title = calculation, ShowGridLines = true, }); orgDataDirty = true; }
public void LoadEnchantsBySlot(Item.ItemSlot slot, CharacterCalculationsBase currentCalculations) { if (Items != null && Character != null) { comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.ItemCalculations = Calculations.GetEnchantCalculations(slot, Character, currentCalculations).ToArray(); comparisonGraph1.EquipSlot = Character.CharacterSlot.None; } }
public void LoadBuffs(CharacterCalculationsBase currentCalculations, Buff.BuffType buffType, bool activeOnly) { if (Items != null && Character != null) { comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.ItemCalculations = Calculations.GetBuffCalculations(Character, currentCalculations, buffType, activeOnly).ToArray(); comparisonGraph1.EquipSlot = Character.CharacterSlot.None; } }
public void LoadBuffs(CharacterCalculationsBase currentCalculations, string filter) { if (Character != null) { comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.ItemCalculations = Calculations.GetBuffCalculations(Character, currentCalculations, filter).ToArray(); comparisonGraph1.EquipSlot = CharacterSlot.None; _characterSlot = CharacterSlot.None; } }
public void UpdateCalculations(object sender, EventArgs e) { _currentCalculations = null; foreach (ComparisonSetControl csc in comparisonSets) { csc.CurrentCalculations = null; } if (Character != null) { UpdateGraph(this, EventArgs.Empty); } }
public void LoadTalentSpecs(TalentPicker picker) { List <ComparisonCalculationBase> talentCalculations = new List <ComparisonCalculationBase>(); if (Character != null) { Character baseChar = Character.Clone(); switch (baseChar.Class) { case CharacterClass.Warrior: baseChar.WarriorTalents = new WarriorTalents(); break; case CharacterClass.Paladin: baseChar.PaladinTalents = new PaladinTalents(); break; case CharacterClass.Hunter: baseChar.HunterTalents = new HunterTalents(); break; case CharacterClass.Rogue: baseChar.RogueTalents = new RogueTalents(); break; case CharacterClass.Priest: baseChar.PriestTalents = new PriestTalents(); break; case CharacterClass.Shaman: baseChar.ShamanTalents = new ShamanTalents(); break; case CharacterClass.Mage: baseChar.MageTalents = new MageTalents(); break; case CharacterClass.Warlock: baseChar.WarlockTalents = new WarlockTalents(); break; case CharacterClass.Druid: baseChar.DruidTalents = new DruidTalents(); break; case CharacterClass.DeathKnight: baseChar.DeathKnightTalents = new DeathKnightTalents(); break; default: baseChar.DruidTalents = new DruidTalents(); break; } CharacterCalculationsBase baseCalc = Calculations.GetCharacterCalculations(baseChar, null, false, true, false); ComparisonCalculationBase compare; Character newChar; foreach (SavedTalentSpec spec in picker.SpecsFor(Character.Class)) { newChar = Character.Clone(); newChar.CurrentTalents = spec.TalentSpec(); compare = Calculations.GetCharacterComparisonCalculations(baseCalc, newChar, spec.ToString(), spec == picker.CurrentSpec()); compare.Item = null; talentCalculations.Add(compare); } } comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.ItemCalculations = talentCalculations.ToArray(); comparisonGraph1.EquipSlot = CharacterSlot.None; _characterSlot = CharacterSlot.None; }
public void UpdateCalculations(object sender, EventArgs e) { _compositeCharacter = null; _currentCalculations = null; if (CompositeCharacter != null) { FormItemSelection.Character = CompositeCharacter; _currentCalculations = Calculations.GetCharacterCalculations(CompositeCharacter, null, true, true, true); FormItemSelection.CurrentCalculations = _currentCalculations; if (CalculationsInvalidated != null) { CalculationsInvalidated(this, EventArgs.Empty); } } }
public virtual List <ComparisonCalculationBase> GetEnchantCalculations(Item.ItemSlot slot, Character character, CharacterCalculationsBase currentCalcs) { ClearCache(); List <ComparisonCalculationBase> enchantCalcs = new List <ComparisonCalculationBase>(); CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; foreach (Enchant enchant in Enchant.FindEnchants(slot)) { //if (enchantCalcs.ContainsKey(enchant.Id)) continue; bool isEquipped = character.GetEnchantBySlot(enchant.Slot) == enchant; if (isEquipped) { calcsEquipped = currentCalcs; Character charUnequipped = character.Clone(); charUnequipped.SetEnchantBySlot(enchant.Slot, null); calcsUnequipped = GetCharacterCalculations(charUnequipped); } else { Character charUnequipped = character.Clone(); Character charEquipped = character.Clone(); charUnequipped.SetEnchantBySlot(enchant.Slot, null); charEquipped.SetEnchantBySlot(enchant.Slot, enchant); calcsUnequipped = GetCharacterCalculations(charUnequipped); calcsEquipped = GetCharacterCalculations(charEquipped); } ComparisonCalculationBase enchantCalc = CreateNewComparisonCalculation(); enchantCalc.Name = enchant.Name; enchantCalc.Item = new Item(enchant.Name, Item.ItemQuality.Temp, Item.ItemType.None, -1 * (enchant.Id + (10000 * (int)enchant.Slot)), null, Item.ItemSlot.None, null, false, enchant.Stats, new Sockets(), 0, 0, 0, 0, 0, Item.ItemDamageType.Physical, 0, null); enchantCalc.Item.Name = enchant.Name; enchantCalc.Item.Stats = enchant.Stats; enchantCalc.Equipped = isEquipped; enchantCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } enchantCalc.SubPoints = subPoints; enchantCalcs.Add(enchantCalc); } return(enchantCalcs); }
public void SetCalculations(CharacterCalculationsBase characterCalculations) { foreach (KeyValuePair <string, string> kvp in characterCalculations.GetCharacterDisplayCalculationValues()) { string[] valueSplit = kvp.Value.Split('*'); string value = valueSplit[0]; if (valueSplit.Length > 1) { ValueLabels[kvp.Key].Text = value + " *"; ValueLabels[kvp.Key].ToolTipText = valueSplit[1]; } else { ValueLabels[kvp.Key].Text = value; } } }
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 static List<ComparisonCalculationBase> GetBuffCalculations(Character character, CharacterCalculationsBase currentCalcs, string filter) { return Instance.GetBuffCalculations(character, currentCalcs, filter); }
private void AsyncCalculationStart(CharacterCalculationsBase calculations, AsyncOperation asyncCalculation) { Dictionary<string, string> result = calculations.GetAsynchronousCharacterDisplayCalculationValues(); asyncCalculation.PostOperationCompleted(asyncCalculationCompleted, new AsyncCalculationResult() { Calculations = calculations, DisplayCalculationValues = result }); }
/// <summary> /// Direct Upgrades /// </summary> /// <param name="currentCalculations"></param> /// <param name="divideByCost">When true it only includes items with positive cost and shows upgrade value / cost</param> public void LoadAvailableGear(CharacterCalculationsBase currentCalculations, bool divideByCost) { List <ComparisonCalculationBase> itemCalculations = new List <ComparisonCalculationBase>(); SortedList <ItemSlot, CharacterSlot> slotMap = new SortedList <ItemSlot, CharacterSlot>(); if (Character != null) { SortedList <string, ItemInstance> items = new SortedList <string, ItemInstance>(); float Finger1 = (Character[CharacterSlot.Finger1] == null ? 0 : Calculations.GetItemCalculations( Character[CharacterSlot.Finger1], Character, CharacterSlot.Finger1).OverallPoints); float Finger2 = (Character[CharacterSlot.Finger2] == null ? 0 : Calculations.GetItemCalculations( Character[CharacterSlot.Finger2], Character, CharacterSlot.Finger2).OverallPoints); float Trinket1 = (Character[CharacterSlot.Trinket1] == null ? 0 : Calculations.GetItemCalculations( Character[CharacterSlot.Trinket1], Character, CharacterSlot.Trinket1).OverallPoints); float Trinket2 = (Character[CharacterSlot.Trinket2] == null ? 0 : Calculations.GetItemCalculations( Character[CharacterSlot.Trinket2], Character, CharacterSlot.Trinket2).OverallPoints); if (Finger2 < Finger1) { slotMap[ItemSlot.Finger] = CharacterSlot.Finger2; } if (Trinket2 < Trinket1) { slotMap[ItemSlot.Trinket] = CharacterSlot.Trinket2; } float MainHand = (Character[CharacterSlot.MainHand] == null ? 0 : Calculations.GetItemCalculations( Character[CharacterSlot.MainHand], Character, CharacterSlot.MainHand).OverallPoints); float OffHand = (Character[CharacterSlot.OffHand] == null ? 0 : Calculations.GetItemCalculations( Character[CharacterSlot.OffHand], Character, CharacterSlot.OffHand).OverallPoints); if (MainHand > OffHand) { slotMap[ItemSlot.OneHand] = CharacterSlot.OffHand; } foreach (KeyValuePair <ItemSlot, CharacterSlot> kvp in Item.DefaultSlotMap) { try { ItemSlot iSlot = kvp.Key; CharacterSlot slot; if (slotMap.ContainsKey(iSlot)) { slot = slotMap[iSlot]; } else { slot = kvp.Value; } if (slot != CharacterSlot.None) { ComparisonCalculationBase slotCalc; ItemInstance currentItem = Character[slot]; if (currentItem == null) { slotCalc = Calculations.CreateNewComparisonCalculation(); } else { slotCalc = Calculations.GetItemCalculations(currentItem, Character, slot); } foreach (ItemInstance item in Character.GetRelevantItemInstances(slot)) { if (!items.ContainsKey(item.GemmedId) && (currentItem == null || currentItem.GemmedId != item.GemmedId)) { if (currentItem != null && currentItem.Item.Unique) { CharacterSlot otherSlot = CharacterSlot.None; switch (slot) { case CharacterSlot.Finger1: otherSlot = CharacterSlot.Finger2; break; case CharacterSlot.Finger2: otherSlot = CharacterSlot.Finger1; break; case CharacterSlot.Trinket1: otherSlot = CharacterSlot.Trinket2; break; case CharacterSlot.Trinket2: otherSlot = CharacterSlot.Trinket1; break; case CharacterSlot.MainHand: otherSlot = CharacterSlot.OffHand; break; case CharacterSlot.OffHand: otherSlot = CharacterSlot.MainHand; break; } if (otherSlot != CharacterSlot.None && Character[otherSlot] != null && (Character[otherSlot].Id == item.Id || (item.Item.UniqueId != null && item.Item.UniqueId.Contains(Character[otherSlot].Id)))) { continue; } } if (!divideByCost || item.Item.Cost > 0.0f) { ComparisonCalculationBase itemCalc = Calculations.GetItemCalculations(item, Character, slot); //bool include = false; //for (int i = 0; i < itemCalc.SubPoints.Length; i++) //{ // itemCalc.SubPoints[i] -= slotCalc.SubPoints[i]; // include |= itemCalc.SubPoints[i] > 0; //} //itemCalc.OverallPoints -= slotCalc.OverallPoints; //if ( itemCalc.OverallPoints > 0) //{ // itemCalculations.Add(itemCalc); //} float difference = itemCalc.OverallPoints - slotCalc.OverallPoints; if (difference > 0) { itemCalc.SubPoints = new float[itemCalc.SubPoints.Length]; if (divideByCost) { itemCalc.OverallPoints = difference / item.Item.Cost; } else { itemCalc.OverallPoints = difference; } itemCalculations.Add(itemCalc); } } items[item.GemmedId] = item; } } } } catch (Exception) { } } } comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.DisplayMode = ComparisonGraph.GraphDisplayMode.Overall; comparisonGraph1.ItemCalculations = FilterTopXGemmings(itemCalculations); comparisonGraph1.EquipSlot = CharacterSlot.AutoSelect; comparisonGraph1.SlotMap = slotMap; _characterSlot = CharacterSlot.None; }
public virtual List<ComparisonCalculationBase> GetEnchantCalculations(ItemSlot slot, Character character, CharacterCalculationsBase currentCalcs, bool equippedOnly, bool forceSlotName=false) { ClearCache(); List<ComparisonCalculationBase> enchantCalcs = new List<ComparisonCalculationBase>(); CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; // only need to get unequipped value once not every time around the loop Character charUnequipped = character.Clone(); charUnequipped.SetEnchantBySlot(slot, null); calcsUnequipped = GetCharacterCalculations(charUnequipped, null, false, false, false); foreach (Enchant enchant in Enchant.FindEnchants(slot, character)) { bool isEquipped = character.GetEnchantBySlot(slot) == enchant; if (equippedOnly && !isEquipped) continue; Character charEquipped = character.Clone(); charEquipped.SetEnchantBySlot(slot, enchant); calcsEquipped = GetCharacterCalculations(charEquipped, null, false, false, false); ComparisonCalculationBase enchantCalc = CreateNewComparisonCalculation(); enchantCalc.Name = forceSlotName || equippedOnly ? string.Format("{0} ({1})", enchant.Name, slot) : enchant.Name; enchantCalc.Item = new Item(enchant.Name, ItemQuality.Temp, ItemType.None, -1 * (enchant.Id + ((int)AvailableItemIDModifiers.Enchants * (int)enchant.Slot)), null, ItemSlot.None, null, false, enchant.Stats, null, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, null); enchantCalc.Item.Name = forceSlotName || equippedOnly ? string.Format("{0} ({1})", enchant.Name, slot) : enchant.Name; enchantCalc.Item.Stats = enchant.Stats; enchantCalc.Equipped = isEquipped; enchantCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } enchantCalc.SubPoints = subPoints; enchantCalc.ImageSource = enchant.IconSource; enchantCalcs.Add(enchantCalc); if (equippedOnly && isEquipped) break; } return enchantCalcs; }
public virtual ComparisonCalculationBase GetItemSetCalculations(ItemSet itemset, Character character) { bool useCache = character == _cachedCharacter; Character characterWithAllSlotsEmpty = null; if (!useCache) characterWithAllSlotsEmpty = character.Clone(); Character characterWithNewItemSet = character.Clone(); if (!useCache) { foreach (CharacterSlot cs in Character.EquippableCharacterSlots) { characterWithAllSlotsEmpty[cs] = null; } } foreach (CharacterSlot cs in Character.EquippableCharacterSlots) { characterWithNewItemSet[cs] = itemset[cs]; } CharacterCalculationsBase characterStatsWithAllSlotsEmpty; if (useCache && _cachedCharacterStatsWithAllSlotsEmpty != null) characterStatsWithAllSlotsEmpty = _cachedCharacterStatsWithAllSlotsEmpty; else { characterStatsWithAllSlotsEmpty = GetCharacterCalculations(characterWithAllSlotsEmpty, null, false, false, false); _cachedCharacter = character; _cachedCharacterStatsWithAllSlotsEmpty = characterStatsWithAllSlotsEmpty; } CharacterCalculationsBase characterStatsWithNewItemSet = GetCharacterCalculations(characterWithNewItemSet, null, false, false, false); ComparisonCalculationBase itemSetCalc = CreateNewComparisonCalculation(); itemSetCalc.ItemInstance = null; itemSetCalc.Item = null; itemSetCalc.Name = itemset.Name != null ? itemset.Name : string.Empty; //itemSetCalc.Description = itemset.ListAsDesc; itemSetCalc.ItemSet = itemset; itemSetCalc.Equipped = true; foreach (CharacterSlot cs in Character.EquippableCharacterSlots) { if (character[cs] != itemset[cs]) { itemSetCalc.Equipped = false; break; } } itemSetCalc.OverallPoints = characterStatsWithNewItemSet.OverallPoints - characterStatsWithAllSlotsEmpty.OverallPoints; float[] subPoints = new float[characterStatsWithNewItemSet.SubPoints.Length]; for (int i = 0; i < characterStatsWithNewItemSet.SubPoints.Length; i++) { subPoints[i] = characterStatsWithNewItemSet.SubPoints[i] - characterStatsWithAllSlotsEmpty.SubPoints[i]; } itemSetCalc.SubPoints = subPoints; characterStatsWithNewItemSet.ToString(); return itemSetCalc; }
public virtual ComparisonCalculationBase GetItemCalculations(ItemInstance item, Character character, CharacterSlot slot) { // Check if the last iteration has the same character and is in the same slot. // If it is, we'll use the same characterWithSlotEmpty to save processing time bool useCache = character == _cachedCharacter && slot == _cachedSlot; Character characterWithSlotEmpty = null; if (!useCache) characterWithSlotEmpty = character.Clone(); Character characterWithNewItem = character.Clone(); if (slot != CharacterSlot.Metas && slot != CharacterSlot.Gems && slot != CharacterSlot.Cogwheels && slot != CharacterSlot.Hydraulics) { // Show Relative to Equipped makes the Base version character with the original item value 0 // and every other calc relative to that if (!useCache) characterWithSlotEmpty[slot] = (Properties.GeneralSettings.Default.ShowRelativeToEquipped && character[slot] != null ? character[slot].Clone() : null); characterWithNewItem[slot] = item; } CharacterCalculationsBase characterStatsWithSlotEmpty; if (useCache && _cachedCharacterStatsWithSlotEmpty != null) characterStatsWithSlotEmpty = _cachedCharacterStatsWithSlotEmpty; else { characterStatsWithSlotEmpty = GetCharacterCalculations(characterWithSlotEmpty, null, false, false, false); _cachedCharacter = character; _cachedSlot = slot; _cachedCharacterStatsWithSlotEmpty = characterStatsWithSlotEmpty; } CharacterCalculationsBase characterStatsWithNewItem = GetCharacterCalculations(characterWithNewItem, null, false, false, false); ComparisonCalculationBase itemCalc = CreateNewComparisonCalculation(); itemCalc.ItemInstance = item; itemCalc.Item = item.Item; itemCalc.Name = item.Name; itemCalc.Equipped = character[slot] == item; itemCalc.OverallPoints = characterStatsWithNewItem.OverallPoints - characterStatsWithSlotEmpty.OverallPoints; float[] subPoints = new float[characterStatsWithNewItem.SubPoints.Length]; for (int i = 0; i < characterStatsWithNewItem.SubPoints.Length; i++) { subPoints[i] = characterStatsWithNewItem.SubPoints[i] - characterStatsWithSlotEmpty.SubPoints[i]; } itemCalc.SubPoints = subPoints; characterStatsWithNewItem.ToString(); return itemCalc; }
public static ComparisonCalculationBase GetCharacterComparisonCalculations(CharacterCalculationsBase baseCalculations, CharacterCalculationsBase newCalculation, string name, bool equipped, bool partequipped) { return Instance.GetCharacterComparisonCalculations(baseCalculations, newCalculation, name, equipped, partequipped); }
public virtual List<ComparisonCalculationBase> GetReforgeCalculations(CharacterSlot slot, Character character, CharacterCalculationsBase currentCalcs, bool equippedOnly) { ClearCache(); List<ComparisonCalculationBase> reforgeCalcs = new List<ComparisonCalculationBase>(); if (!equippedOnly) { CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; // only need to get unequipped value once not every time around the loop Character charUnequipped = character.Clone(); charUnequipped.SetReforgingBySlot(slot, null); calcsUnequipped = GetCharacterCalculations(charUnequipped, null, false, false, false); Item toReforge = character[slot] != null ? character[slot].Item : null; int toReforgeSuffix = character[slot] != null ? character[slot].RandomSuffixId : 0; if (toReforge == null) return reforgeCalcs; List<Reforging> possibleReforges = GetReforgingOptions(toReforge, toReforgeSuffix); foreach (Reforging reforge in possibleReforges) { Reforging origReforge = character.GetReforgingBySlot(slot); int id1 = origReforge != null ? origReforge.Id : 0; int id2 = reforge != null ? reforge.Id : 0; bool isEquipped = id1 == id2; Character charEquipped = character.Clone(); charEquipped.SetReforgingBySlot(slot, reforge); calcsEquipped = GetCharacterCalculations(charEquipped, null, false, false, false); ComparisonCalculationBase reforgeCalc = CreateNewComparisonCalculation(); if (reforge != null) { reforgeCalc.Name = reforge.ToString(); reforgeCalc.Item = new Item(reforge.ToString(), ItemQuality.Temp, ItemType.None, -(int)AvailableItemIDModifiers.Reforges - reforge.Id, null, ItemSlot.None, null, false, new Stats(), null, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, null); reforgeCalc.Item.Stats._rawAdditiveData[(int)reforge.ReforgeFrom] -= reforge.ReforgeAmount; reforgeCalc.Item.Stats._rawAdditiveData[(int)reforge.ReforgeTo] += reforge.ReforgeAmount; } else { reforgeCalc.Name = "Not Reforged"; reforgeCalc.Item = new Item("Not Reforged", ItemQuality.Temp, ItemType.None, -(int)AvailableItemIDModifiers.Reforges, null, ItemSlot.None, null, false, new Stats(), null, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, null); } reforgeCalc.Equipped = isEquipped; reforgeCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } reforgeCalc.SubPoints = subPoints; reforgeCalcs.Add(reforgeCalc); } } else { CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; // only need to get unequipped value once not every time around the loop Character charUnequipped = character.Clone(); charUnequipped.SetReforgingBySlot(slot, null); calcsUnequipped = GetCharacterCalculations(charUnequipped, null, false, false, false); Item toReforge = character[slot] != null ? character[slot].Item : null; if (toReforge == null) return reforgeCalcs; Reforging reforge = character[slot].Reforging; Reforging origReforge = character.GetReforgingBySlot(slot); bool isEquipped = true; Character charEquipped = character; calcsEquipped = GetCharacterCalculations(charEquipped, null, false, false, false); ComparisonCalculationBase reforgeCalc = CreateNewComparisonCalculation(); if (reforge != null) { reforgeCalc.Name = reforge.ToString(); reforgeCalc.Item = new Item(reforge.ToString(), ItemQuality.Temp, ItemType.None, -(int)AvailableItemIDModifiers.Reforges - reforge.Id, null, ItemSlot.None, null, false, new Stats(), null, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, null); reforgeCalc.Item.Stats._rawAdditiveData[(int)reforge.ReforgeFrom] -= reforge.ReforgeAmount; reforgeCalc.Item.Stats._rawAdditiveData[(int)reforge.ReforgeTo] += reforge.ReforgeAmount; } else { reforgeCalc.Name = "Not Reforged"; reforgeCalc.Item = new Item("Not Reforged", ItemQuality.Temp, ItemType.None, -(int)AvailableItemIDModifiers.Reforges, null, ItemSlot.None, null, false, new Stats(), null, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, null); } reforgeCalc.Equipped = isEquipped; reforgeCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } reforgeCalc.SubPoints = subPoints; reforgeCalcs.Add(reforgeCalc); } return reforgeCalcs; }
public virtual ComparisonCalculationBase GetBossCalculations(BossHandler boss, BossHandler easy, Character character, CharacterCalculationsBase currentCalcs) { ClearCache(); CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; // only need to get unequipped value once not every time around the loop Character charUnequipped = character.Clone(); charUnequipped.BossOptions = BossOptions.CloneBossHandler(easy); calcsUnequipped = GetCharacterCalculations(charUnequipped, null, false, false, false); // bool isEquipped = false; Character charEquipped = character.Clone(); charUnequipped.BossOptions = BossOptions.CloneBossHandler(boss); calcsEquipped = GetCharacterCalculations(charEquipped, null, false, false, false); ComparisonCalculationBase bossCalc = CreateNewComparisonCalculation(); bossCalc.Name = boss.Name + " (" + boss.ContentString + ")"; bossCalc.Item = new Item(boss.Name + " (" + boss.ContentString + ")", ItemQuality.Temp, ItemType.None, boss.GetHashCode(), null, ItemSlot.None, null, false, new Stats(), null, ItemSlot.None, ItemSlot.None, ItemSlot.None, 0, 0, ItemDamageType.Physical, 0, null); bossCalc.Equipped = isEquipped; bossCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } bossCalc.SubPoints = subPoints; //bossCalc.ImageSource = boss.IconSource; // return bossCalc; }
public virtual List <ComparisonCalculationBase> GetBuffCalculations(Character character, CharacterCalculationsBase currentCalcs, Buff.BuffType buffType, bool activeOnly) { ClearCache(); List <ComparisonCalculationBase> buffCalcs = new List <ComparisonCalculationBase>(); CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; Character charAutoActivated = character.Clone(); foreach (Buff autoBuff in currentCalcs.AutoActivatedBuffs) { if (!charAutoActivated.ActiveBuffs.Contains(autoBuff)) { charAutoActivated.ActiveBuffs.Add(autoBuff); RemoveConflictingBuffs(charAutoActivated.ActiveBuffs, autoBuff); } } charAutoActivated.DisableBuffAutoActivation = true; foreach (Buff buff in Buff.GetBuffsByType(buffType)) { if (!activeOnly || charAutoActivated.ActiveBuffs.Contains(buff)) { Character charUnequipped = charAutoActivated.Clone(); Character charEquipped = charAutoActivated.Clone(); charUnequipped.DisableBuffAutoActivation = true; charEquipped.DisableBuffAutoActivation = true; if (charUnequipped.ActiveBuffs.Contains(buff)) { charUnequipped.ActiveBuffs.Remove(buff); } if (string.IsNullOrEmpty(buff.RequiredBuff)) { //if (charUnequipped.ActiveBuffs.Contains("Improved " + buff.Name)) // charUnequipped.ActiveBuffs.Remove("Improved " + buff.Name); charUnequipped.ActiveBuffs.RemoveAll(x => x.Name == "Improved " + buff.Name); } else { //if (charUnequipped.ActiveBuffs.Contains(buff.RequiredBuff)) // charUnequipped.ActiveBuffs.Remove(buff.RequiredBuff); charUnequipped.ActiveBuffs.RemoveAll(x => x.Name == buff.RequiredBuff); } if (!charEquipped.ActiveBuffs.Contains(buff)) { charEquipped.ActiveBuffs.Add(buff); } if (string.IsNullOrEmpty(buff.RequiredBuff)) { //if (charEquipped.ActiveBuffs.Contains("Improved " + buff.Name)) // charEquipped.ActiveBuffs.Remove("Improved " + buff.Name); charEquipped.ActiveBuffs.RemoveAll(x => x.Name == "Improved " + buff.Name); } else { //if (!charEquipped.ActiveBuffs.Contains(buff.RequiredBuff)) // charEquipped.ActiveBuffs.Add(buff.RequiredBuff); Buff requiredBuff = Buff.GetBuffByName(buff.RequiredBuff); if (!charEquipped.ActiveBuffs.Contains(requiredBuff)) { charEquipped.ActiveBuffs.Add(requiredBuff); } } RemoveConflictingBuffs(charEquipped.ActiveBuffs, buff); RemoveConflictingBuffs(charUnequipped.ActiveBuffs, buff); calcsUnequipped = GetCharacterCalculations(charUnequipped); calcsEquipped = GetCharacterCalculations(charEquipped); ComparisonCalculationBase buffCalc = CreateNewComparisonCalculation(); buffCalc.Name = buff.Name; buffCalc.Item = new Item() { Name = buff.Name, Stats = buff.Stats, Quality = Item.ItemQuality.Temp }; buffCalc.Equipped = charAutoActivated.ActiveBuffs.Contains(buff); buffCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } buffCalc.SubPoints = subPoints; buffCalcs.Add(buffCalc); } } return(buffCalcs); }
public void UpdateScalingGraph(Character character, Stats[] statsList, Stats baseStat, bool requiresReferenceCalculations, Color[] colors, int scale, string explanatoryText, string calculation) { CharacterCalculationsBase baseCalc = Calculations.GetCharacterCalculations(character); if (statsList.Length == 0 || statsList.Length > colors.Length) { return; // more than 12 elements for the array would run out of colours } Point[][] points = new Point[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 Point[2 * scale + 1]; } float unit = 1f; var bp = baseStat.Values(x => x > 0); foreach (var kvp in bp) { unit = kvp.Value; } Chart.Series.Clear(); 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 Point(count * unit, dpsChange); } } for (int index = 0; index < statsList.Length; index++) { Style dataPointStyle = new Style(typeof(LineDataPoint)); dataPointStyle.Setters.Add(new Setter(DataPoint.TemplateProperty, Resources["InvisibleDataPointTemplate"])); dataPointStyle.Setters.Add(new Setter(DataPoint.BackgroundProperty, new SolidColorBrush(colors[index]))); Chart.Series.Add(new LineSeries() { Title = statsList[index].ToString(), ItemsSource = points[index], IndependentValuePath = "X", DependentValuePath = "Y", DataPointStyle = dataPointStyle, }); } Chart.Axes.Clear(); Chart.Axes.Add(new LinearAxis() { Orientation = AxisOrientation.X, Title = "Stat Change", ShowGridLines = true, }); Chart.Axes.Add(new LinearAxis() { Orientation = AxisOrientation.Y, Title = calculation, ShowGridLines = true, }); // restore reference calculation if (requiresReferenceCalculations) { Stats newStats = new Stats(); Item item = new Item() { Stats = newStats }; Calculations.GetCharacterCalculations(character, item, true, false, false); } orgDataDirty = true; }
public void UpdateDisplayCalculationValues(Dictionary<string, string> displayCalculationValues, CharacterCalculationsBase _calculatedStats) { CalculationDisplay.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; }
public static List<ComparisonCalculationBase> GetSetBonusCalculations(Character character, CharacterCalculationsBase currentCalcs) { return Instance.GetSetBonusCalculations(character, currentCalcs); }
public static ComparisonCalculationBase GetCharacterComparisonCalculations(CharacterCalculationsBase calculations, string name, bool equipped) { return Instance.GetCharacterComparisonCalculations(calculations, name, equipped); }
public virtual ComparisonCalculationBase GetItemCalculations(Item item, Character character, Character.CharacterSlot slot) { bool useCache = character == _cachedCharacter && slot == _cachedSlot; Character characterWithSlotEmpty = null; if (!useCache) { characterWithSlotEmpty = character.Clone(); } Character characterWithNewItem = character.Clone(); if (slot != Character.CharacterSlot.Metas && slot != Character.CharacterSlot.Gems) { if (!useCache) { characterWithSlotEmpty[slot] = null; } characterWithNewItem[slot] = item; } CharacterCalculationsBase characterStatsWithSlotEmpty; if (useCache) { characterStatsWithSlotEmpty = _cachedCharacterStatsWithSlotEmpty; } else { characterStatsWithSlotEmpty = GetCharacterCalculations(characterWithSlotEmpty); _cachedCharacter = character; _cachedSlot = slot; _cachedCharacterStatsWithSlotEmpty = characterStatsWithSlotEmpty; } Item additionalItem = null; if (item.FitsInSlot(Character.CharacterSlot.Gems) || item.FitsInSlot(Character.CharacterSlot.Metas)) { additionalItem = item; } CharacterCalculationsBase characterStatsWithNewItem = GetCharacterCalculations(characterWithNewItem, additionalItem); ComparisonCalculationBase itemCalc = CreateNewComparisonCalculation(); itemCalc.Item = item; itemCalc.Name = item.Name; itemCalc.Equipped = character[slot] == item; itemCalc.OverallPoints = characterStatsWithNewItem.OverallPoints - characterStatsWithSlotEmpty.OverallPoints; float[] subPoints = new float[characterStatsWithNewItem.SubPoints.Length]; for (int i = 0; i < characterStatsWithNewItem.SubPoints.Length; i++) { subPoints[i] = characterStatsWithNewItem.SubPoints[i] - characterStatsWithSlotEmpty.SubPoints[i]; } itemCalc.SubPoints = subPoints; characterStatsWithNewItem.ToString(); return(itemCalc); }
public virtual void ClearCache() { _cachedCharacterStatsWithSlotEmpty = null; _cachedCharacterStatsWithGemSlotEmpty = null; _cachedCharacterStatsWithAllSlotsEmpty = null; _cachedCharacter = null; _cachedSlot = CharacterSlot.Shirt; _cachedGemIndex = 0; }
public static List <ComparisonCalculationBase> GetBuffCalculations(Character character, CharacterCalculationsBase currentCalcs, Buff.BuffType buffType, bool activeOnly) { return(Instance.GetBuffCalculations(character, currentCalcs, buffType, activeOnly)); }
public virtual ComparisonCalculationBase GetItemGemCalculations(Item gem, Character character, CharacterSlot slot, int gemIndex) { if (gemIndex == 0) { return GetItemCalculations(gem, character, CharacterSlot.Gems); } bool useCache = character == _cachedCharacter && slot == _cachedSlot && gemIndex == _cachedGemIndex; Character characterWithGemSlotEmpty = null; if (!useCache) characterWithGemSlotEmpty = character.Clone(); Character characterWithNewGem = character.Clone(); if (!useCache) { ItemInstance emptyItemInstance = characterWithGemSlotEmpty[slot]; if (emptyItemInstance != null) { emptyItemInstance = emptyItemInstance.Clone(); emptyItemInstance.SetGem(gemIndex, null); characterWithGemSlotEmpty[slot] = emptyItemInstance; } } ItemInstance newItemInstance = characterWithNewGem[slot]; if (newItemInstance != null) { newItemInstance = newItemInstance.Clone(); newItemInstance.SetGem(gemIndex, gem); characterWithNewGem[slot] = newItemInstance; } CharacterCalculationsBase characterStatsWithGemSlotEmpty; if (useCache && _cachedCharacterStatsWithGemSlotEmpty != null) characterStatsWithGemSlotEmpty = _cachedCharacterStatsWithGemSlotEmpty; else { characterStatsWithGemSlotEmpty = GetCharacterCalculations(characterWithGemSlotEmpty, null, false, false, false); _cachedCharacter = character; _cachedSlot = slot; _cachedGemIndex = gemIndex; _cachedCharacterStatsWithGemSlotEmpty = characterStatsWithGemSlotEmpty; } CharacterCalculationsBase characterStatsWithNewGem = GetCharacterCalculations(characterWithNewGem, (Properties.GeneralSettings.Default.ShowRelativeToEquipped ? character[slot].Item : null), false, false, false); ComparisonCalculationBase itemCalc = CreateNewComparisonCalculation(); itemCalc.Item = gem; itemCalc.Name = gem != null ? gem.Name : string.Empty; itemCalc.Equipped = (character[slot] != null && character[slot].GetGem(gemIndex) == gem); itemCalc.OverallPoints = characterStatsWithNewGem.OverallPoints - characterStatsWithGemSlotEmpty.OverallPoints; float[] subPoints = new float[characterStatsWithNewGem.SubPoints.Length]; for (int i = 0; i < characterStatsWithNewGem.SubPoints.Length; i++) { subPoints[i] = characterStatsWithNewGem.SubPoints[i] - characterStatsWithGemSlotEmpty.SubPoints[i]; } itemCalc.SubPoints = subPoints; characterStatsWithNewGem.ToString(); return itemCalc; }
public static ComparisonCalculationBase GetBossCalculations(BossHandler boss, BossHandler easy, Character character, CharacterCalculationsBase currentCalcs) { return Instance.GetBossCalculations(boss, easy, character, currentCalcs); }
public virtual ComparisonCalculationBase GetItemCalculations(Item additionalItem, Character character, CharacterSlot slot) { bool useCache = character == _cachedCharacter && slot == _cachedSlot; Character characterWithSlotEmpty = null; if (!useCache) characterWithSlotEmpty = character.Clone(); Character characterWithNewItem = character.Clone(); CharacterCalculationsBase characterStatsWithSlotEmpty; if (useCache) characterStatsWithSlotEmpty = _cachedCharacterStatsWithSlotEmpty; else { characterStatsWithSlotEmpty = GetCharacterCalculations(characterWithSlotEmpty, null, false, false, false); _cachedCharacter = character; _cachedSlot = slot; _cachedCharacterStatsWithSlotEmpty = characterStatsWithSlotEmpty; } CharacterCalculationsBase characterStatsWithNewItem = GetCharacterCalculations(characterWithNewItem, additionalItem, false, false, false); ComparisonCalculationBase itemCalc = CreateNewComparisonCalculation(); itemCalc.Item = additionalItem; itemCalc.Name = additionalItem.Name; itemCalc.Equipped = false; itemCalc.ImageSource = additionalItem.IconPath; itemCalc.OverallPoints = characterStatsWithNewItem.OverallPoints - characterStatsWithSlotEmpty.OverallPoints; float[] subPoints = new float[characterStatsWithNewItem.SubPoints.Length]; for (int i = 0; i < characterStatsWithNewItem.SubPoints.Length; i++) { subPoints[i] = characterStatsWithNewItem.SubPoints[i] - characterStatsWithSlotEmpty.SubPoints[i]; } itemCalc.SubPoints = subPoints; characterStatsWithNewItem.ToString(); return itemCalc; }
public static List<ComparisonCalculationBase> GetTinkeringCalculations(ItemSlot slot, Character character, CharacterCalculationsBase currentCalcs, bool equippedOnly, bool forceSlotName = false) { return Instance.GetTinkeringCalculations(slot, character, currentCalcs, equippedOnly, forceSlotName); }
public virtual void ClearCache() { _cachedCharacterStatsWithSlotEmpty = null; _cachedCharacter = null; _cachedSlot = Character.CharacterSlot.Shirt; }
public static List<ComparisonCalculationBase> GetReforgeCalculations(CharacterSlot slot, Character character, CharacterCalculationsBase currentCalcs, bool equippedOnly) { return Instance.GetReforgeCalculations(slot, character, currentCalcs, equippedOnly); }
public virtual List<ComparisonCalculationBase> GetSetBonusCalculations(Character character, CharacterCalculationsBase currentCalcs) { ClearCache(); List<ComparisonCalculationBase> buffCalcs = new List<ComparisonCalculationBase>(); CharacterCalculationsBase calcsEquipped = null; CharacterCalculationsBase calcsUnequipped = null; Character charAutoActivated = character.Clone(); foreach (Buff autoBuff in currentCalcs.AutoActivatedBuffs) { if (!charAutoActivated.ActiveBuffs.Contains(autoBuff)) { charAutoActivated.ActiveBuffsAdd(autoBuff); RemoveConflictingBuffs(charAutoActivated.ActiveBuffs, autoBuff); } } charAutoActivated.DisableBuffAutoActivation = true; string filter = "Set Bonuses"; string[] multiFilter = filter.Split('|'); List<Buff> relevantBuffs = new List<Buff>(); Buff.cachedClass = character.Class; Buff.cachedPriProf = character.PrimaryProfession; Buff.cachedSecProf = character.SecondaryProfession; foreach (Buff buff in Buff.RelevantBuffs) { bool isinMultiFilter = false; if (multiFilter.Length > 0) { foreach (string mFilter in multiFilter) { if (buff.Group.Equals(mFilter, StringComparison.CurrentCultureIgnoreCase)) { isinMultiFilter = true; break; } } } if (filter == null || filter == "All" || filter == "Current" || buff.Group.Equals(filter, StringComparison.CurrentCultureIgnoreCase) || isinMultiFilter) { relevantBuffs.Add(buff); foreach (Buff imp in buff.Improvements) { if (Calculations.Instance.IsBuffRelevant(imp, character)) { relevantBuffs.Add(imp); } } } } foreach (Buff buff in relevantBuffs) { if (!"Current".Equals(filter, StringComparison.CurrentCultureIgnoreCase) || charAutoActivated.ActiveBuffs.Contains(buff)) { Character charUnequipped = charAutoActivated.Clone(); Character charEquipped = charAutoActivated.Clone(); charUnequipped.DisableBuffAutoActivation = true; charEquipped.DisableBuffAutoActivation = true; // find next lower set bonus count int maxCount = 0; foreach (Buff lowerSetBonus in relevantBuffs) { if (lowerSetBonus.SetName == buff.SetName && lowerSetBonus.SetThreshold < buff.SetThreshold) { if (lowerSetBonus.SetThreshold > maxCount) { maxCount = lowerSetBonus.SetThreshold; } } } charUnequipped.SetBonusCount[buff.SetName] = maxCount; charEquipped.SetBonusCount[buff.SetName] = buff.SetThreshold; RemoveConflictingBuffs(charEquipped.ActiveBuffs, buff); RemoveConflictingBuffs(charUnequipped.ActiveBuffs, buff); calcsUnequipped = GetCharacterCalculations(charUnequipped, null, false, false, false); calcsEquipped = GetCharacterCalculations(charEquipped, null, false, false, false); ComparisonCalculationBase buffCalc = CreateNewComparisonCalculation(); buffCalc.Name = buff.Name; buffCalc.Item = new Item() { Name = buff.Name, Stats = buff.Stats, Quality = ItemQuality.Temp }; buffCalc.Equipped = charAutoActivated.ActiveBuffs.Contains(buff); if (!buffCalc.Equipped && buff.ConflictingBuffs.Count > 0 && buff.ConflictingBuffs[0] != null) { bool hasConflictingMatch = false; foreach (String cb in buff.ConflictingBuffs) { foreach (Buff b in character.ActiveBuffs) { if (b.Name != buff.Name && b.ConflictingBuffs.Contains(cb)) { hasConflictingMatch = true; break; } } } buffCalc.PartEquipped = hasConflictingMatch; } buffCalc.OverallPoints = calcsEquipped.OverallPoints - calcsUnequipped.OverallPoints; float[] subPoints = new float[calcsEquipped.SubPoints.Length]; for (int i = 0; i < calcsEquipped.SubPoints.Length; i++) { subPoints[i] = calcsEquipped.SubPoints[i] - calcsUnequipped.SubPoints[i]; } buffCalc.SubPoints = subPoints; buffCalcs.Add(buffCalc); } } return buffCalcs; }
public void LoadAvailableGear(CharacterCalculationsBase currentCalculations) { List <ComparisonCalculationBase> itemCalculations = new List <ComparisonCalculationBase>(); SortedList <Item.ItemSlot, Character.CharacterSlot> slotMap = new SortedList <Item.ItemSlot, Character.CharacterSlot>(); if (Items != null && Character != null) { SortedList <string, Item> items = new SortedList <string, Item>(); float Finger1 = (Character[Character.CharacterSlot.Finger1] == null ? 0 : Calculations.GetItemCalculations( Character[Character.CharacterSlot.Finger1], Character, Character.CharacterSlot.Finger1).OverallPoints); float Finger2 = (Character[Character.CharacterSlot.Finger2] == null ? 0 : Calculations.GetItemCalculations( Character[Character.CharacterSlot.Finger2], Character, Character.CharacterSlot.Finger2).OverallPoints); float Trinket1 = (Character[Character.CharacterSlot.Trinket1] == null ? 0 : Calculations.GetItemCalculations( Character[Character.CharacterSlot.Trinket1], Character, Character.CharacterSlot.Trinket1).OverallPoints); float Trinket2 = (Character[Character.CharacterSlot.Trinket2] == null ? 0 : Calculations.GetItemCalculations( Character[Character.CharacterSlot.Trinket2], Character, Character.CharacterSlot.Trinket2).OverallPoints); if (Finger2 < Finger1) { slotMap[Item.ItemSlot.Finger] = Character.CharacterSlot.Finger2; } if (Trinket2 < Trinket1) { slotMap[Item.ItemSlot.Trinket] = Character.CharacterSlot.Trinket2; } float MainHand = (Character[Character.CharacterSlot.MainHand] == null ? 0 : Calculations.GetItemCalculations( Character[Character.CharacterSlot.MainHand], Character, Character.CharacterSlot.MainHand).OverallPoints); float OffHand = (Character[Character.CharacterSlot.OffHand] == null ? 0 : Calculations.GetItemCalculations( Character[Character.CharacterSlot.OffHand], Character, Character.CharacterSlot.OffHand).OverallPoints); if (MainHand > OffHand) { slotMap[Item.ItemSlot.OneHand] = Character.CharacterSlot.OffHand; } foreach (Item relevantItem in ItemCache.RelevantItems) { try { Item.ItemSlot iSlot = relevantItem.Slot; Character.CharacterSlot slot; if (slotMap.ContainsKey(iSlot)) { slot = slotMap[iSlot]; } else { slot = Item.DefaultSlotMap[iSlot]; } if (slot != Character.CharacterSlot.None) { ComparisonCalculationBase slotCalc; Item currentItem = Character[slot]; if (currentItem == null) { slotCalc = Calculations.CreateNewComparisonCalculation(); } else { slotCalc = Calculations.GetItemCalculations(currentItem, Character, slot); } foreach (Item item in ItemCache.Instance.FindAllItemsById(relevantItem.Id)) { if (!items.ContainsKey(item.GemmedId) && (currentItem == null || currentItem.GemmedId != item.GemmedId)) { if (currentItem != null && currentItem.Unique) { Character.CharacterSlot otherSlot = Character.CharacterSlot.None; switch (slot) { case Character.CharacterSlot.Finger1: otherSlot = Character.CharacterSlot.Finger2; break; case Character.CharacterSlot.Finger2: otherSlot = Character.CharacterSlot.Finger1; break; case Character.CharacterSlot.Trinket1: otherSlot = Character.CharacterSlot.Trinket2; break; case Character.CharacterSlot.Trinket2: otherSlot = Character.CharacterSlot.Trinket1; break; case Character.CharacterSlot.MainHand: otherSlot = Character.CharacterSlot.OffHand; break; case Character.CharacterSlot.OffHand: otherSlot = Character.CharacterSlot.MainHand; break; } if (otherSlot != Character.CharacterSlot.None && Character[otherSlot] != null && Character[otherSlot].Id == item.Id) { continue; } } ComparisonCalculationBase itemCalc = Calculations.GetItemCalculations(item, Character, slot); bool include = false; for (int i = 0; i < itemCalc.SubPoints.Length; i++) { itemCalc.SubPoints[i] -= slotCalc.SubPoints[i]; include |= itemCalc.SubPoints[i] > 0; } itemCalc.OverallPoints -= slotCalc.OverallPoints; if (itemCalc.OverallPoints > 0) { itemCalculations.Add(itemCalc); } items[item.GemmedId] = item; } } } } catch (Exception) { } } } comparisonGraph1.RoundValues = true; comparisonGraph1.CustomRendered = false; comparisonGraph1.DisplayMode = ComparisonGraph.GraphDisplayMode.Overall; comparisonGraph1.ItemCalculations = itemCalculations.ToArray(); comparisonGraph1.EquipSlot = Character.CharacterSlot.AutoSelect; comparisonGraph1.SlotMap = slotMap; }
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 virtual ComparisonCalculationBase GetCharacterComparisonCalculations(CharacterCalculationsBase baseCalculations, Character character, string name, bool equipped) { CharacterCalculationsBase characterCalculations = GetCharacterCalculations(character, null, false, true, false); ComparisonCalculationBase comparisonCalculations = CreateNewComparisonCalculation(); comparisonCalculations.Name = name; comparisonCalculations.Item = new Item() { Name = name }; comparisonCalculations.Equipped = equipped; comparisonCalculations.OverallPoints = characterCalculations.OverallPoints - baseCalculations.OverallPoints; float[] subPoints = new float[characterCalculations.SubPoints.Length]; for (int i = 0; i < characterCalculations.SubPoints.Length; i++) { subPoints[i] = characterCalculations.SubPoints[i] - baseCalculations.SubPoints[i]; } comparisonCalculations.SubPoints = subPoints; return comparisonCalculations; }
public virtual ComparisonCalculationBase GetCharacterComparisonCalculations(CharacterCalculationsBase baseCalculation, CharacterCalculationsBase newCalculation, string name, bool equipped, bool partequipped) { ComparisonCalculationBase comparisonCalculations = CreateNewComparisonCalculation(); comparisonCalculations.Name = name; comparisonCalculations.Item = new Item() { Name = name }; comparisonCalculations.Equipped = equipped; comparisonCalculations.PartEquipped = partequipped; comparisonCalculations.OverallPoints = newCalculation.OverallPoints - baseCalculation.OverallPoints; float[] subPoints = new float[newCalculation.SubPoints.Length]; for (int i = 0; i < newCalculation.SubPoints.Length; i++) { subPoints[i] = newCalculation.SubPoints[i] - baseCalculation.SubPoints[i]; } comparisonCalculations.SubPoints = subPoints; return comparisonCalculations; }
public static List <ComparisonCalculationBase> GetEnchantCalculations(Item.ItemSlot slot, Character character, CharacterCalculationsBase currentCalcs) { return(Instance.GetEnchantCalculations(slot, character, currentCalcs)); }