public ItemAttributesFromLevel(Hero hero)
{
switch (hero.HeroClass)
{
case HeroClass.Monk:
case HeroClass.DemonHunter:
dexterityItem = new ItemValueRange(7 + 3 * hero.Level);
intelligenceItem = new ItemValueRange(7 + 1 * hero.Level);
strengthItem = new ItemValueRange(7 + 1 * hero.Level);
break;
case HeroClass.WitchDoctor:
case HeroClass.Wizard:
dexterityItem = new ItemValueRange(7 + 1 * hero.Level);
intelligenceItem = new ItemValueRange(7 + 3 * hero.Level);
strengthItem = new ItemValueRange(7 + 1 * hero.Level);
break;
case HeroClass.Barbarian:
case HeroClass.Crusader:
dexterityItem = new ItemValueRange(7 + 1 * hero.Level);
intelligenceItem = new ItemValueRange(7 + 1 * hero.Level);
strengthItem = new ItemValueRange(7 + 3 * hero.Level);
break;
}
vitalityItem = new ItemValueRange(7 + 2 * hero.Level);
critDamagePercent = new ItemValueRange(0.5);
critPercentBonusCapped = new ItemValueRange(0.05);
}
public void ConstructorMinMax()
{
var valueRange = new ItemValueRange(1, 2);
Assert.AreEqual(1, valueRange.Min);
Assert.AreEqual(2, valueRange.Max);
}
public static ItemAttributes operator -(ItemAttributes left, ItemAttributes right)
{
var target = new ItemAttributes(left);
var type = target.GetType();
foreach (var fieldInfo in type.GetTypeInfo().DeclaredFields)
{
if (fieldInfo.Name != "UnmanagedAttributes" && fieldInfo.GetValue(right) != null)
{
var targetValueRange = (ItemValueRange)fieldInfo.GetValue(target);
var rightValueRange = (ItemValueRange)fieldInfo.GetValue(right);
if (targetValueRange == null)
{
targetValueRange = new ItemValueRange();
}
targetValueRange -= rightValueRange;
if (targetValueRange.Min == 0 && targetValueRange.Max == 0)
{
targetValueRange = null;
}
fieldInfo.SetValue(target, targetValueRange - rightValueRange);
}
}
return(target);
}
public ItemAttributesFromLevel(Follower follower, HeroClass heroClass)
{
switch (heroClass)
{
case HeroClass.ScoundrelFollower:
dexterityItem = new ItemValueRange(8 + 3 * follower.Level);
intelligenceItem = new ItemValueRange(8 + 1 * follower.Level);
strengthItem = new ItemValueRange(9 + 1 * follower.Level);
vitalityItem = new ItemValueRange(7 + 2 * follower.Level);
break;
case HeroClass.EnchantressFollower:
dexterityItem = new ItemValueRange(9 + 1 * follower.Level);
intelligenceItem = new ItemValueRange(5 + 3 * follower.Level);
strengthItem = new ItemValueRange(9 + 1 * follower.Level);
vitalityItem = new ItemValueRange(7 + 2 * follower.Level);
break;
case HeroClass.TemplarFollower:
dexterityItem = new ItemValueRange(8 + 1 * follower.Level);
intelligenceItem = new ItemValueRange(10 + 1 * follower.Level);
strengthItem = new ItemValueRange(7 + 3 * follower.Level);
vitalityItem = new ItemValueRange(9 + 2 * follower.Level);
break;
}
critDamagePercent = new ItemValueRange(0.5);
}
public void ConstructorMinMax()
{
var valueRange = new ItemValueRange(1, 2);
Assert.AreEqual(1, valueRange.Min);
Assert.AreEqual(2, valueRange.Max);
}
public void ConstructorCopy()
{
var valueRange = new ItemValueRange(left);
Assert.AreEqual(left.Min, valueRange.Min);
Assert.AreEqual(left.Max, valueRange.Max);
}
public void Constructor()
{
var valueRange = new ItemValueRange();
Assert.AreEqual(0, valueRange.Min);
Assert.AreEqual(0, valueRange.Max);
}
public void Constructor()
{
var valueRange = new ItemValueRange();
Assert.AreEqual(0, valueRange.Min);
Assert.AreEqual(0, valueRange.Max);
}
public void ConstructorCopy()
{
var valueRange = new ItemValueRange(left);
Assert.AreEqual(left.Min, valueRange.Min);
Assert.AreEqual(left.Max, valueRange.Max);
}
/// <summary>
/// Creates a new <see cref="ItemValueRange"/> instance by copying fields of <paramref name="valueRange"/> (deep copy).
/// </summary>
/// <param name="valueRange"></param>
public ItemValueRange(ItemValueRange valueRange)
{
if (valueRange != null)
{
Min = valueRange.Min;
Max = valueRange.Max;
}
}
/// <summary>
/// Creates a new <see cref="ItemValueRange"/> instance by copying fields of <paramref name="valueRange"/> (deep copy).
/// </summary>
/// <param name="valueRange"></param>
public ItemValueRange(ItemValueRange valueRange)
{
if (valueRange != null)
{
Min = valueRange.Min;
Max = valueRange.Max;
}
}
/// <inheritdoc cref="Equals(object)" />
public bool Equals(ItemValueRange value)
{
if (value == null)
{
return(false);
}
return(Math.Abs(Min - value.Min) < Tolerance && Math.Abs(Max - value.Max) < Tolerance);
}
public static void SumIntoLeftOperand(ItemValueRange left, ItemValueRange right)
{
if (right == null)
{
return;
}
left.Min += right.Min;
left.Max += right.Max;
}
public static void SumAsPercentOnRemainingIntoLeftOperand(ItemValueRange left, ItemValueRange right)
{
if (right == null)
{
return;
}
left.Min = 1 - (1 - left.Min) * (1 - right.Min);
left.Max = 1 - (1 - left.Max) * (1 - right.Max);
}
private static void PopulateData(Control textBox, ItemValueRange itemValueRange)
{
if (itemValueRange != null && itemValueRange.Min != 0)
{
textBox.Text = itemValueRange.Min.ToString();
}
else
{
textBox.Text = String.Empty;
}
}
public static ItemValueRange SumAsPercentOnRemaining(this IEnumerable<ItemValueRange> itemValueRanges)
{
var target = new ItemValueRange();
foreach (var attr in itemValueRanges.Where(i => i != null))
{
ItemValueRange.SumAsPercentOnRemainingIntoLeftOperand(target, attr);
}
return target;
}
private static void PopulateDataPercent(Control textBox, ItemValueRange itemValueRange)
{
if (itemValueRange != null && itemValueRange.Min != 0)
{
textBox.Text = (100 * itemValueRange.Min).ToString("N1");
}
else
{
textBox.Text = String.Empty;
}
}
/// <summary>
/// Sums up <paramref name="right"/> operand into <paramref name="left"/> operand.
/// <paramref name="left"/> is updated by this method (used as a memory and speed optimization of <c>left = left + right</c>).
/// </summary>
/// <param name="left">Left operand of the addition, can't be <c>null</c>.</param>
/// <param name="right">Right operand of the addition, can be <c>null</c>.</param>
public static void SumIntoLeftOperand(ItemAttributes left, ItemAttributes right)
{
if (right == null)
{
return;
}
var typeInfo = left.GetType().GetTypeInfo();
var targetType = typeof(ItemValueRange);
// TODO: find a better way to handle this particular case...
var powerCooldownReductionPercentAll = left.powerCooldownReductionPercentAll;
foreach (var fieldInfo in typeInfo.DeclaredFields)
{
if (fieldInfo.FieldType == targetType)
{
var rightValue = fieldInfo.GetValue(right);
if (rightValue != null)
{
var leftValueRange = (ItemValueRange)fieldInfo.GetValue(left);
var rightValueRange = (ItemValueRange)rightValue;
if (leftValueRange == null)
{
fieldInfo.SetValue(left, new ItemValueRange(rightValueRange));
}
else
{
fieldInfo.SetValue(left, leftValueRange + rightValueRange);
}
}
}
}
// TODO: find a better way to handle this particular case...
if (powerCooldownReductionPercentAll != null)
{
left.powerCooldownReductionPercentAll = powerCooldownReductionPercentAll;
ItemValueRange.SumAsPercentOnRemainingIntoLeftOperand(left.powerCooldownReductionPercentAll, right.powerCooldownReductionPercentAll);
}
}
private static void PopulateCalculatedDataPercent(Control textBox, ItemValueRange itemValueRange)
{
if (itemValueRange != null && itemValueRange.Min != 0)
{
textBox.Text = (100 * itemValueRange.Min).ToString();
}
}
/// <summary>
/// Sets the value of an attribute of an item given the attribute's name
/// </summary>
/// <param name="item">Source item</param>
/// <param name="fieldName">Name of the attribute to retrieve</param>
/// <param name="value">Value to set</param>
public static Item SetAttributeByName(this Item item, String fieldName, ItemValueRange value)
{
typeof(ItemAttributes).GetTypeInfo().GetDeclaredField(fieldName).SetValue(item.AttributesRaw, value);
return item;
}
public static ItemValueRange GetWeaponAttackPerSecond(this Item item, ItemValueRange increaseFromOtherItems)
{
return item.AttributesRaw.GetWeaponAttackPerSecond(increaseFromOtherItems);
}
private void GuiDoCalculationsForFollower()
{
// Retrieve follower from the GUI
var follower = GetEditedFollower();
// Retrieve worn items from the GUI
var items = new List<Item>
{
guiItemChoiceSpecial.Tag as Item,
guiItemChoiceLeftFinger.Tag as Item,
guiItemChoiceNeck.Tag as Item,
guiItemChoiceRightFinger.Tag as Item,
guiSetBonusEditor.GetEditedItem()
};
items = items.Where(i => i != null)
.Select(i => i.DeepClone())
.ToList();
var mainHand = (guiItemChoiceMainHand.Tag as Item).DeepClone();
var offHand = (guiItemChoiceOffHand.Tag as Item).DeepClone();
var heroClass = (HeroClass)Enum.Parse(typeof(HeroClass), (String)(guiHeroClass.SelectedItem));
var d3Calculator = new D3Calculator(follower, heroClass, mainHand, offHand, items.ToArray());
// Retrieve used skills from the GUI
var passiveSkills = new List<ID3SkillModifier>();
// Some buffs are applied after passives skills: followers skills and active skills
var activeSkills = new List<ID3SkillModifier>();
// Followers
if (guiSkillAnatomy.Checked)
{
activeSkills.Add(new Anatomy());
}
if (guiSkillFocusedMind.Checked)
{
activeSkills.Add(new FocusedMind());
}
if (guiSkillPoweredArmor.Checked)
{
activeSkills.Add(new PoweredArmor());
}
calculatedDps = d3Calculator.GetHeroDps(passiveSkills, activeSkills);
guiCalculatedDPS.Text = calculatedDps.Min.ToString();
UpdateItemsSummary(d3Calculator);
UpdateCalculationResults(d3Calculator);
DoActionOnCalculatedControls(UpdateResultControlColor);
}
public static void SumAsPercentOnRemainingIntoLeftOperand(ItemValueRange left, ItemValueRange right)
{
if (right == null)
{
return;
}
left.Min = 1 - (1 - left.Min) * (1 - right.Min);
left.Max = 1 - (1 - left.Max) * (1 - right.Max);
}
/// <inheritdoc cref="Equals(object)" />
public bool Equals(ItemValueRange value)
{
if (value == null)
{
return false;
}
return Math.Abs(Min - value.Min) < Tolerance && Math.Abs(Max - value.Max) < Tolerance;
}
private View CreateRowView(List<string> labels, Field[] fields, Field selected, ItemValueRange value)
{
var rowView = CreateRowView(labels, fields);
rowView.Tag = new JavaLangObject<Field>(selected);
var index = 0;
for (; index < fields.Length; index++)
{
if (fields[index].Id == selected.Id)
{
break;
}
}
if (index != fields.Length)
{
rowView.FindViewById<Spinner>(Resource.Id.attributeName)
.SetSelection(index);
rowView.FindViewById<EditText>(Resource.Id.attributeValue)
.Text = value.Min.ToString();
}
return rowView;
}
public AttributeElementaryDamageListItem(int resource, ItemValueRange increase, double dps)
: base(resource, String.Format("{0:0.00} % ( {1:N2} )", 100 * increase.Min, dps * (1 + increase.Min)))
{
}
/// <summary>
/// Sets the value of an attribute of an ItemAttributes given the attribute's name
/// </summary>
/// <param name="itemAttributes">Source attributes</param>
/// <param name="fieldName">Name of the attribute to retrieve</param>
/// <param name="value">Value to set</param>
public static ItemAttributes SetAttributeByName(this ItemAttributes itemAttributes, string fieldName, ItemValueRange value)
{
ItemAttributesTypeInfo.GetDeclaredField(fieldName).SetValue(itemAttributes, value);
return itemAttributes;
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="attributeName">Name of the attribute that will receive the bonus (a field name of <see cref="ItemAttributes"/>).</param>
/// <param name="bonusPerPoint">Bonus increment for each paragon point.</param>
/// <param name="maxPoints">Max paragon point in this entry (0 for infinite).</param>
public ParagonBonus(string attributeName, ItemValueRange bonusPerPoint, int maxPoints)
{
AttributeName = attributeName;
BonusPerPoint = bonusPerPoint;
MaxPoints = maxPoints;
}
private void GuiDoCalculationsForHero()
{
// Retrieve hero from the GUI
var hero = GetEditedHero();
heroLevel = hero.Level;
// Retrieve worn items from the GUI
var items = new List<Item>
{
guiItemChoiceBracers.Tag as Item,
guiItemChoiceFeet.Tag as Item,
guiItemChoiceHands.Tag as Item,
guiItemChoiceHead.Tag as Item,
guiItemChoiceLeftFinger.Tag as Item,
guiItemChoiceLegs.Tag as Item,
guiItemChoiceNeck.Tag as Item,
guiItemChoiceRightFinger.Tag as Item,
guiItemChoiceShoulders.Tag as Item,
guiItemChoiceTorso.Tag as Item,
guiItemChoiceWaist.Tag as Item,
guiSetBonusEditor.GetEditedItem()
};
items = items.Where(i => i != null)
.Select(i => i.DeepClone())
.ToList();
var mainHand = (guiItemChoiceMainHand.Tag as Item).DeepClone();
var offHand = (guiItemChoiceOffHand.Tag as Item).DeepClone();
var d3Calculator = new D3Calculator(hero, mainHand, offHand, items.ToArray());
// Retrieve used skills from the GUI
var passiveSkills = passiveCheckBoxes
.Where(p => p.Checked)
.Select(checkBox => PassiveSkillModifierFactory.GetFromSlug(checkBox.Tag as string))
.ToList();
// Some buffs are applied after passives skills: followers skills and active skills
var activeSkills = new List<ID3SkillModifier>();
// Barbarian active skills
AddActiveSkillIfChecked(activeSkills, guiSkillWarCry_Invigorate, typeof(WarCry_Invigorate));
// Demon Hunter active skills
AddActiveSkillIfChecked(activeSkills, guiSkillCompanion_BoarCompanion, typeof(Companion_BoarCompanion));
// Monk active skills
AddActiveSkillIfChecked(activeSkills, guiSkillMantraOfHealing_TimeOfNeed, typeof(MantraOfHealing_TimeOfNeed));
AddActiveSkillIfChecked(activeSkills, guiSkillMantraOfEvasion_HardTarget, typeof(MantraOfEvasion_HardTarget));
AddActiveSkillIfChecked(activeSkills, guiSkillMantraOfRetribution_Transgression, typeof(MantraOfRetribution_Transgression));
AddActiveSkillIfChecked(activeSkills, guiSkillMysticAlly_EarthAlly, typeof(MysticAlly_EarthAlly));
AddActiveSkillIfChecked(activeSkills, guiSkillMysticAlly_FireAlly, typeof(MysticAlly_FireAlly));
// Witch Doctor active skills
// Wizard skills
// Followers
AddActiveSkillIfChecked(activeSkills, guiSkillAnatomy, typeof(Anatomy));
AddActiveSkillIfChecked(activeSkills, guiSkillFocusedMind, typeof(FocusedMind));
AddActiveSkillIfChecked(activeSkills, guiSkillPoweredArmor, typeof(PoweredArmor));
calculatedDps = d3Calculator.GetHeroDps(passiveSkills, activeSkills);
UpdateItemsSummary(d3Calculator);
UpdateCalculationResults(d3Calculator);
DoActionOnCalculatedControls(UpdateResultControlColor);
}
public AttributeListItem(int id, ItemValueRange value)
: this(Application.Context.Resources.GetString(id), value)
{
}
/// <summary>
/// Computes weapon attack speed.
/// </summary>
/// <param name="weaponAttr">Attributes of used weapon.</param>
/// <param name="increaseFromOtherItems">Increase Attack Speed from items other than the weapon.</param>
/// <returns></returns>
public static ItemValueRange GetWeaponAttackPerSecond(this ItemAttributes weaponAttr, ItemValueRange increaseFromOtherItems)
{
var weaponAttackSpeed = weaponAttr.attacksPerSecondItem;
weaponAttackSpeed *= 1 + weaponAttr.attacksPerSecondItemPercent + increaseFromOtherItems;
return weaponAttackSpeed;
}
public AttributeListItem(String name, ItemValueRange value)
{
Name = name;
Value = value.Min.ToString("N2");
}
private static void UpdateNodeText(TreeNode node, ItemValueRange d3Object)
{
node.Text += $" >> [ {d3Object.Min} - {d3Object.Max}]";
}
public DamageMultiplier(double multiplier)
{
this.multiplier = new ItemValueRange(multiplier);
}
public AttributePercentListItem(String name, ItemValueRange value) :
base(name, String.Format("{0:0.00} %", 100 * value.Min))
{
}
public static void SumIntoLeftOperand(ItemValueRange left, ItemValueRange right)
{
if (right == null)
{
return;
}
left.Min += right.Min;
left.Max += right.Max;
}
private static void UpdateNodeText(TreeNode node, ItemValueRange d3Object)
{
node.Text += " >> [ " + d3Object.Min + " - " + d3Object.Max + "]";
}
public static ItemAttributes operator *(ItemAttributes left, ItemAttributes right)
{
var target = new ItemAttributes(left);
var type = target.GetType();
foreach (var fieldInfo in type.GetTypeInfo().DeclaredFields)
{
if (fieldInfo.Name != "UnmanagedAttributes" && fieldInfo.GetValue(right) != null)
{
var targetValueRange = (ItemValueRange)fieldInfo.GetValue(target);
var rightValueRange = (ItemValueRange)fieldInfo.GetValue(right);
if (targetValueRange == null)
{
targetValueRange = new ItemValueRange(1);
}
fieldInfo.SetValue(target, targetValueRange * rightValueRange);
}
}
return target;
}
private static void PopulateCalculatedData(Control textBox, ItemValueRange itemValueRange)
{
if (itemValueRange != null && !itemValueRange.IsZero())
{
var round = Math.Round(itemValueRange.Min);
if (Math.Abs(itemValueRange.Min - round) < 0.0001)
{
textBox.Text = itemValueRange.Min.ToString("N0");
}
else
{
textBox.Text = itemValueRange.Min.ToString("N2");
}
}
}
