private void CopyButtonClick(object sender, RoutedEventArgs e)
{
if (EquipList.SelectedItem == null)
{
return;
}
UniqueBase temp = Helpers.DeepClone((UniqueBase)EquipList.SelectedItem);
Uniques.Add(temp);
foreach (AffixBase b in temp.FixedUniqueAffixes)
{
b.AffixBonuses.CollectionChanged += b.RaiseListStringChanged;
b.AffixBonuses.CollectionChanged += temp.RaisePropertyAffixString;
foreach (AffixBonus bonus in b.AffixBonuses)
{
bonus.PropertyChanged += b.RaiseListStringChanged_;
bonus.PropertyChanged += temp.RaisePropertyAffixString_;
}
}
foreach (AffixBase b in temp.RandomUniqueAffixes)
{
b.AffixBonuses.CollectionChanged += b.RaiseListStringChanged;
b.AffixBonuses.CollectionChanged += temp.RaisePropertyAffixString;
foreach (AffixBonus bonus in b.AffixBonuses)
{
bonus.PropertyChanged += b.RaiseListStringChanged_;
bonus.PropertyChanged += temp.RaisePropertyAffixString_;
}
}
}
public string[] GetLocalizationText(UniqueBase unique)
{
string stringId = unique.idName;
string[] output = new string[2];
if (uniqueLocalizationData.TryGetValue("unique." + stringId, out string value))
{
if (value == "")
{
output[0] = stringId;
}
else
{
output[0] = value;
}
}
else
{
output[0] = stringId;
}
if (uniqueLocalizationData.TryGetValue("unique." + stringId + ".text", out string desc))
{
output[1] = desc;
}
return(output);
}
private void CalculateWeaponDps(UniqueBase unique, Dictionary <BonusType, StatBonus> maxStatBonuses)
{
Dictionary <ElementType, DamageStore> weaponDamage = new Dictionary <ElementType, DamageStore>();
foreach (ElementType element in Enum.GetValues(typeof(ElementType)))
{
weaponDamage[element] = new DamageStore(0, 0);
}
weaponDamage[0].Min = CalculateStat(unique.MinDamage, maxStatBonuses, BonusType.LOCAL_PHYSICAL_DAMAGE_MIN);
weaponDamage[0].Max = CalculateStat(unique.MaxDamage, maxStatBonuses, BonusType.LOCAL_PHYSICAL_DAMAGE_MAX);
weaponDamage[0].Min = CalculateStat(weaponDamage[0].Min, maxStatBonuses, BonusType.LOCAL_PHYSICAL_DAMAGE);
weaponDamage[0].Max = CalculateStat(weaponDamage[0].Max, maxStatBonuses, BonusType.LOCAL_PHYSICAL_DAMAGE);
weaponDamage[ElementType.FIRE].Min = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_FIRE_DAMAGE_MIN);
weaponDamage[ElementType.FIRE].Max = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_FIRE_DAMAGE_MAX);
weaponDamage[ElementType.FIRE].Min = CalculateStat(weaponDamage[ElementType.FIRE].Min, maxStatBonuses, BonusType.LOCAL_FIRE_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.FIRE].Max = CalculateStat(weaponDamage[ElementType.FIRE].Max, maxStatBonuses, BonusType.LOCAL_FIRE_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.COLD].Min = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_COLD_DAMAGE_MIN);
weaponDamage[ElementType.COLD].Max = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_COLD_DAMAGE_MAX);
weaponDamage[ElementType.COLD].Min = CalculateStat(weaponDamage[ElementType.COLD].Min, maxStatBonuses, BonusType.LOCAL_COLD_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.COLD].Max = CalculateStat(weaponDamage[ElementType.COLD].Max, maxStatBonuses, BonusType.LOCAL_COLD_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.LIGHTNING].Min = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_LIGHTNING_DAMAGE_MIN);
weaponDamage[ElementType.LIGHTNING].Max = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_LIGHTNING_DAMAGE_MAX);
weaponDamage[ElementType.LIGHTNING].Min = CalculateStat(weaponDamage[ElementType.LIGHTNING].Min, maxStatBonuses, BonusType.LOCAL_LIGHTNING_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.LIGHTNING].Max = CalculateStat(weaponDamage[ElementType.LIGHTNING].Max, maxStatBonuses, BonusType.LOCAL_LIGHTNING_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.EARTH].Min = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_EARTH_DAMAGE_MIN);
weaponDamage[ElementType.EARTH].Max = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_EARTH_DAMAGE_MAX);
weaponDamage[ElementType.EARTH].Min = CalculateStat(weaponDamage[ElementType.EARTH].Min, maxStatBonuses, BonusType.LOCAL_EARTH_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.EARTH].Max = CalculateStat(weaponDamage[ElementType.EARTH].Max, maxStatBonuses, BonusType.LOCAL_EARTH_DAMAGE, BonusType.LOCAL_ELEMENTAL_DAMAGE);
weaponDamage[ElementType.DIVINE].Min = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_DIVINE_DAMAGE_MIN);
weaponDamage[ElementType.DIVINE].Max = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_DIVINE_DAMAGE_MAX);
weaponDamage[ElementType.DIVINE].Min = CalculateStat(weaponDamage[ElementType.DIVINE].Min, maxStatBonuses, BonusType.LOCAL_DIVINE_DAMAGE, BonusType.LOCAL_PRIMORDIAL_DAMAGE);
weaponDamage[ElementType.DIVINE].Max = CalculateStat(weaponDamage[ElementType.DIVINE].Max, maxStatBonuses, BonusType.LOCAL_DIVINE_DAMAGE, BonusType.LOCAL_PRIMORDIAL_DAMAGE);
weaponDamage[ElementType.VOID].Min = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_VOID_DAMAGE_MIN);
weaponDamage[ElementType.VOID].Max = CalculateStat(0, maxStatBonuses, BonusType.LOCAL_VOID_DAMAGE_MAX);
weaponDamage[ElementType.VOID].Min = CalculateStat(weaponDamage[ElementType.VOID].Min, maxStatBonuses, BonusType.LOCAL_VOID_DAMAGE, BonusType.LOCAL_PRIMORDIAL_DAMAGE);
weaponDamage[ElementType.VOID].Max = CalculateStat(weaponDamage[ElementType.VOID].Max, maxStatBonuses, BonusType.LOCAL_VOID_DAMAGE, BonusType.LOCAL_PRIMORDIAL_DAMAGE);
float AttackSpeed = CalculateStat(unique.AttackSpeed, maxStatBonuses, BonusType.LOCAL_ATTACK_SPEED);
float pDps = (weaponDamage[0].Min + weaponDamage[0].Max) / 2f * AttackSpeed;
int eMin = weaponDamage[ElementType.FIRE].Min + weaponDamage[ElementType.COLD].Min + weaponDamage[ElementType.LIGHTNING].Min + weaponDamage[ElementType.EARTH].Min;
int eMax = weaponDamage[ElementType.FIRE].Max + weaponDamage[ElementType.COLD].Max + weaponDamage[ElementType.LIGHTNING].Max + weaponDamage[ElementType.EARTH].Max;
float eDps = (eMin + eMax) / 2f * AttackSpeed;
int aMin = weaponDamage[ElementType.DIVINE].Min + weaponDamage[ElementType.VOID].Min;
int aMax = weaponDamage[ElementType.DIVINE].Max + weaponDamage[ElementType.VOID].Max;
float aDps = (aMin + aMax) / 2f * AttackSpeed;
pDpsLabel.Content = "pDps: " + pDps;
eDpsLabel.Content = "eDps: " + eDps;
aDpsLabel.Content = "aDps: " + aDps;
}
public void LoadEquipmentData()
{
if (equipDict == null)
{
equipDict = new Dictionary <Guid, EquipSaveData>();
}
else
{
equipDict.Clear();
}
GameManager.Instance.PlayerStats.ClearEquipmentInventory();
foreach (EquipSaveData equipData in equipList)
{
Equipment equipment = null;
if (equipData.rarity == RarityType.UNIQUE)
{
equipment = Equipment.CreateUniqueFromBase(equipData.baseId, equipData.ilvl, equipData.uniqueVersion);
}
else
{
equipment = Equipment.CreateEquipmentFromBase(equipData.baseId, equipData.ilvl);
}
if (equipment == null)
{
continue;
}
GameManager.Instance.PlayerStats.AddEquipmentToInventory(equipment);
equipment.SetId(equipData.id);
equipment.Name = equipData.name;
equipment.SetRarity(equipData.rarity);
if (equipData.rarity == RarityType.UNIQUE)
{
UniqueBase uniqueBase = equipment.Base as UniqueBase;
if (uniqueBase.uniqueVersion == equipData.uniqueVersion)
{
for (int i = 0; i < uniqueBase.fixedUniqueAffixes.Count; i++)
{
AffixBase affixBase = uniqueBase.fixedUniqueAffixes[i];
equipment.prefixes.Add(new Affix(affixBase, equipData.prefixes[i].affixValues, equipData.prefixes[i].triggerValues, false, false));
}
}
}
else
{
LoadEquipmentAffixes(equipData, equipment);
}
equipment.UpdateItemStats();
equipDict.Add(equipData.id, equipData);
}
}
private void ReloadLocalization_Click(object sender, RoutedEventArgs e)
{
Localization.LoadStrings();
if (UniqueItemEditor.EquipList.SelectedItem != null)
{
UniqueBase u = UniqueItemEditor.EquipList.SelectedItem as UniqueBase;
u.RaisePropertyAffixString_(null, null);
}
}
public static Equipment CreateRandomUnique(int ilvl, GroupType?group = null)
{
UniqueBase uniqueBase = ResourceManager.Instance.GetRandomUniqueBase(ilvl, group);
if (uniqueBase == null)
{
return(null);
}
return(CreateUniqueFromBase(uniqueBase, ilvl));
}
private void AddButtonClick(object sender, RoutedEventArgs e)
{
UniqueBase temp = new UniqueBase
{
IdName = "UNTITLED NEW",
InnateAffixId = null
};
Uniques.Add(temp);
}
private void SortRandomAffixes()
{
if (EquipList.SelectedItem == null)
{
return;
}
UniqueBase uniqueBase = EquipList.SelectedItem as UniqueBase;
for (int i = 0; i < uniqueBase.RandomUniqueAffixes.Count; i++)
{
uniqueBase.RandomUniqueAffixes[i].IdName = uniqueBase.IdName + "R" + i;
}
uniqueBase.RaisePropertyAffixString_(null, null);
}
private void RandomRemoveButtonClick(object sender, RoutedEventArgs e)
{
if (EquipList.SelectedItem == null)
{
return;
}
if (RandomAffixesList.SelectedItem == null)
{
return;
}
UniqueBase uniqueBase = EquipList.SelectedItem as UniqueBase;
uniqueBase.RandomUniqueAffixes.Remove(RandomAffixesList.SelectedItem as AffixBase);
SortRandomAffixes();
}
public static Equipment CreateUniqueFromBase(UniqueBase uniqueBase, int ilvl)
{
Equipment e = CreateEquipmentFromBase(uniqueBase, ilvl);
if (e == null)
{
return(null);
}
e.Rarity = RarityType.UNIQUE;
foreach (AffixBase affixBase in uniqueBase.fixedUniqueAffixes)
{
e.prefixes.Add(new Affix(affixBase));
}
e.UpdateItemStats();
return(e);
}
private void RandomAddButtonClick(object sender, RoutedEventArgs e)
{
if (EquipList.SelectedItem == null)
{
return;
}
UniqueBase uniqueBase = EquipList.SelectedItem as UniqueBase;
AffixBase temp = new AffixBase
{
IdName = uniqueBase.IdName + "R" + uniqueBase.RandomUniqueAffixes.Count,
AffixType = AffixType.UNIQUE
};
AddPropertyListeners(uniqueBase, temp);
uniqueBase.RandomUniqueAffixes.Add(temp);
SortRandomAffixes();
}
public static Equipment CreateUniqueFromBase(string uniqueId, int ilvl, int uniqueVersion)
{
UniqueBase uniqueBase = ResourceManager.Instance.GetUniqueBase(uniqueId);
if (uniqueBase == null)
{
return(null);
}
if (uniqueVersion == uniqueBase.uniqueVersion)
{
Equipment e = CreateEquipmentFromBase(uniqueBase, ilvl);
e.Rarity = RarityType.UNIQUE;
return(e);
}
else
{
return(CreateUniqueFromBase(uniqueBase, ilvl));
}
}
private void RandomCopyButtonClick(object sender, RoutedEventArgs e)
{
if (EquipList.SelectedItem == null)
{
return;
}
if (RandomAffixesList.SelectedItem == null)
{
return;
}
UniqueBase uniqueBase = EquipList.SelectedItem as UniqueBase;
AffixBase temp = Helpers.DeepClone((AffixBase)RandomAffixesList.SelectedItem);
temp.IdName = uniqueBase.IdName + "R" + uniqueBase.RandomUniqueAffixes.Count;
AddPropertyListeners(uniqueBase, temp);
uniqueBase.RandomUniqueAffixes.Add(temp);
SortRandomAffixes();
}
public void SaveEquipmentData(Equipment equipItem)
{
EquipSaveData equipData;
if (!equipDict.ContainsKey(equipItem.Id))
{
equipData = new EquipSaveData
{
id = equipItem.Id,
baseId = equipItem.Base.idName,
ilvl = (byte)equipItem.ItemLevel
};
equipDict[equipItem.Id] = equipData;
equipList.Add(equipData);
}
else
{
equipData = equipDict[equipItem.Id];
}
equipData.name = equipItem.Name;
equipData.rarity = equipItem.Rarity;
if (equipItem.Rarity == RarityType.UNIQUE)
{
UniqueBase uniqueBase = equipItem.Base as UniqueBase;
equipData.uniqueVersion = (byte)uniqueBase.uniqueVersion;
}
equipData.prefixes.Clear();
foreach (Affix affix in equipItem.prefixes)
{
equipData.prefixes.Add(new AffixSaveData(affix.Base.idName, affix.GetAffixValues(), affix.GetEffectValues(), affix.IsCrafted, affix.IsLocked));
}
equipData.suffixes.Clear();
foreach (Affix affix in equipItem.suffixes)
{
equipData.suffixes.Add(new AffixSaveData(affix.Base.idName, affix.GetAffixValues(), affix.GetEffectValues(), affix.IsCrafted, affix.IsLocked));
}
}
private void RandomAffixesList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (EquipList.SelectedItem == null)
{
return;
}
ListView listView = sender as ListView;
if (listView.SelectedItem == null)
{
return;
}
BonusPropGrid.SelectedAffix = listView.SelectedItem as AffixBase;
UniqueBase unique = EquipList.SelectedItem as UniqueBase;
Dictionary <BonusType, StatBonus> maxStatBonuses = new Dictionary <BonusType, StatBonus>();
Dictionary <BonusType, StatBonus> minStatBonuses = new Dictionary <BonusType, StatBonus>();
foreach (AffixBase x in unique.FixedUniqueAffixes)
{
foreach (AffixBonus y in x.AffixBonuses)
{
if (!maxStatBonuses.ContainsKey(y.BonusType))
{
maxStatBonuses.Add(y.BonusType, new StatBonus());
minStatBonuses.Add(y.BonusType, new StatBonus());
}
maxStatBonuses[y.BonusType].AddBonus(y.ModifyType, y.MaxValue);
minStatBonuses[y.BonusType].AddBonus(y.ModifyType, y.MinValue);
}
}
CalculateWeaponDps(unique, maxStatBonuses);
}
public override int GetItemValue()
{
float affixValueMultiplier = 1;
float rollValue;
int actualAffixCount;
if (Rarity != RarityType.UNIQUE)
{
foreach (Affix affix in GetAllAffixes())
{
if (affix.AffixType == AffixType.INNATE)
{
continue;
}
int weightValue = 0;
foreach (var weight in affix.Base.spawnWeight)
{
if (GetGroupTypes().Contains(weight.type))
{
weightValue = weight.weight;
break;
}
}
float weightModifier;
if (weightValue > 0)
{
weightModifier = 1000f / weightValue;
}
else
{
weightModifier = 5f;
}
affixValueMultiplier += weightModifier;
if (affix.Base.affixBonuses.Count == 0)
{
continue;
}
rollValue = 0;
for (int i = 0; i < affix.Base.affixBonuses.Count; i++)
{
//UnityEngine.Debug.Log(affix.Base.idName + " " + +rollValueMultiplier + " " + affix.GetAffixValue(i) + " " + affix.Base.affixBonuses[i].minValue);
float valueDifference = affix.Base.affixBonuses[i].maxValue - affix.Base.affixBonuses[i].minValue;
if (valueDifference == 0)
{
rollValue += 0.7f;
continue;
}
rollValue += (affix.GetAffixValue(i) - affix.Base.affixBonuses[i].minValue) / valueDifference * 0.7f;
}
rollValue /= affix.Base.affixBonuses.Count;
affixValueMultiplier += rollValue;
}
}
else
{
UniqueBase uniqueBase = Base as UniqueBase;
float rollValueMultiplier = 0f;
actualAffixCount = 0;
foreach (Affix affix in GetAllAffixes())
{
if (affix.Base.affixBonuses.Count == 0)
{
continue;
}
rollValue = 0;
for (int i = 0; i < affix.Base.affixBonuses.Count; i++)
{
//UnityEngine.Debug.Log(affix.Base.idName + " " + +rollValueMultiplier + " " + affix.GetAffixValue(i) + " " + affix.Base.affixBonuses[i].minValue);
float valueDifference = affix.Base.affixBonuses[i].maxValue - affix.Base.affixBonuses[i].minValue;
if (valueDifference == 0)
{
rollValue += 0.5f;
continue;
}
rollValue += (affix.GetAffixValue(i) - affix.Base.affixBonuses[i].minValue) / valueDifference;
}
rollValueMultiplier += rollValue / affix.Base.affixBonuses.Count;
actualAffixCount++;
}
rollValueMultiplier = 1 + rollValueMultiplier / actualAffixCount;
if (uniqueBase.spawnWeight == 0)
{
affixValueMultiplier = 500f * rollValueMultiplier;
}
else
{
affixValueMultiplier = Math.Min((1000f / uniqueBase.spawnWeight) * (uniqueBase.dropLevel / 100f) * 50f * rollValueMultiplier, 500f);
}
}
return(Math.Max((int)(affixValueMultiplier * ItemLevel * 1.5f), 1));
}
private static void AddPropertyListeners(UniqueBase uniqueBase, AffixBase temp)
{
temp.AffixBonuses.CollectionChanged += temp.RaiseListStringChanged;
temp.AffixBonuses.CollectionChanged += uniqueBase.RaisePropertyAffixString;
}
