public void LoadItemsBySlot(CharacterSlot slot)
{
if (_characterSlot != slot)
{
_characterSlot = slot;
List <ComparisonCalculationBase> itemCalculations = new List <ComparisonCalculationBase>();
if ((int)slot >= 0 && (int)slot <= 20)
{
if (this.Character != null)
{
bool seenEquippedItem = Character[slot] == null;
foreach (ItemInstance item in Character.GetRelevantItemInstances(slot))
{
if (!seenEquippedItem && Character[slot].Equals(item))
{
seenEquippedItem = true;
}
if (item.Item.FitsInSlot(slot, Character))
{
itemCalculations.Add(Calculations.GetItemCalculations(item, this.Character, slot));
}
}
if (!seenEquippedItem)
{
itemCalculations.Add(Calculations.GetItemCalculations(Character[slot], this.Character, slot));
}
}
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 = this.Character[slot] == null;
itemCalculations.Add(emptyCalcs);
}
else
{
if (this.Character != null)
{
bool seenEquippedItem = false;
if (_button != null && _button.SelectedItem == null)
{
seenEquippedItem = true;
}
foreach (Item item in Character.GetRelevantItems(slot))
{
if (!seenEquippedItem && _button != null && item.Equals(_button.SelectedItem))
{
seenEquippedItem = true;
}
if (item.FitsInSlot(slot, Character))
{
if (slot == CharacterSlot.Gems)
{
AddGemToItemCalculations(itemCalculations, item);
}
else
{
itemCalculations.Add(Calculations.GetItemCalculations(item, this.Character, slot));
}
}
}
if (!seenEquippedItem && _button != null && _button.SelectedItem != null)
{
itemCalculations.Add(Calculations.GetItemCalculations(_button.SelectedItem, this.Character, slot));
}
}
ComparisonCalculationBase emptyCalcs = Calculations.CreateNewComparisonCalculation();
emptyCalcs.Name = "Empty";
emptyCalcs.Item = new Item();
emptyCalcs.Item.Name = "Empty";
emptyCalcs.ItemInstance = new ItemInstance();
emptyCalcs.ItemInstance.Id = -1;
if (_button != null && _button.SelectedItem != null)
{
emptyCalcs.Equipped = _button.SelectedItem == null;
}
else
{
emptyCalcs.Equipped = false;
}
itemCalculations.Add(emptyCalcs);
}
itemCalculations.Sort(new System.Comparison <ComparisonCalculationBase>(CompareItemCalculations));
Dictionary <int, int> countItem = new Dictionary <int, int>();
List <ComparisonCalculationBase> filteredItemCalculations = new List <ComparisonCalculationBase>();
for (int i = itemCalculations.Count - 1; i >= 0; i--)
//foreach (ComparisonCalculationBase itemCalculation in itemCalculations)
{
ComparisonCalculationBase itemCalculation = itemCalculations[i];
int itemId = (itemCalculation.ItemInstance == null ? itemCalculation.Item.Id : itemCalculation.ItemInstance.Id);
if (!countItem.ContainsKey(itemId))
{
countItem.Add(itemId, 0);
}
if (countItem[itemId]++ < Properties.GeneralSettings.Default.CountGemmingsShown ||
itemCalculation.Equipped || itemCalculation.ItemInstance.ForceDisplay)
{
filteredItemCalculations.Add(itemCalculation);
}
}
ItemCalculations = filteredItemCalculations.ToArray();
}
}
void _optimizer_EvaluateUpgradeCompleted(object sender, EvaluateUpgradeCompletedEventArgs e)
{
switch (currentOperation)
{
case AsyncOperation.BuildUpgradeList:
upgradeListEnumerator.Current.Value += e.UpgradeValue * CurrentBatchCharacter.Weight;
upgradeListEnumerator.Current.ValueList.Add(e.UpgradeValue);
if (upgradeListEnumerator.MoveNext())
{
EvaluateUpgradeCurrentBatchCharacter(false);
}
else
{
do
{
batchIndex++;
} while (batchIndex < BatchCharacterList.Count && CurrentBatchCharacter.Character == null);
if (batchIndex < BatchCharacterList.Count)
{
upgradeListEnumerator = GetUpgradeListEnumerator();
upgradeListEnumerator.MoveNext();
EvaluateUpgradeCurrentBatchCharacter(true);
}
else
{
currentOperation = AsyncOperation.None;
buttonCancel.Enabled = false;
statusLabel.Text = "";
statusProgressBar.Value = 0;
float totalValue = 0f;
foreach (BatchCharacter batchCharacter in BatchCharacterList)
{
if (batchCharacter.Character != null)
{
totalValue += batchCharacter.Weight;
}
}
Dictionary <Character.CharacterSlot, List <ComparisonCalculationBase> > upgrades = new Dictionary <Character.CharacterSlot, List <ComparisonCalculationBase> >();
foreach (var kvp in upgradeList)
{
Dictionary <int, UpgradeEntry> filtered = new Dictionary <int, UpgradeEntry>();
foreach (UpgradeEntry entry in kvp.Value.Values)
{
UpgradeEntry existingEntry;
filtered.TryGetValue(entry.Item.Id, out existingEntry);
if (entry.Value > 0 && (existingEntry == null || entry.Value > existingEntry.Value))
{
filtered[entry.Item.Id] = entry;
}
}
upgrades[kvp.Key] = new List <ComparisonCalculationBase>();
foreach (UpgradeEntry entry in filtered.Values)
{
ComparisonCalculationBase itemCalc = Calculations.CreateNewComparisonCalculation();
itemCalc.Item = entry.Item;
itemCalc.Enchant = entry.Enchant;
itemCalc.Character = null;
itemCalc.Name = entry.Item.Name;
itemCalc.Equipped = false;
itemCalc.OverallPoints = entry.Value / totalValue;
itemCalc.SubPoints = entry.ValueList.ToArray();
upgrades[kvp.Key].Add(itemCalc);
}
}
List <string> customSubpoints = new List <string>();
foreach (BatchCharacter batchCharacter in BatchCharacterList)
{
customSubpoints.Add(batchCharacter.Name);
}
FormUpgradeComparison.Instance.LoadData(formMain.Character, upgrades, customSubpoints.ToArray());
FormUpgradeComparison.Instance.Show();
}
}
break;
}
}
/// <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 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;
}
