internal void AppendItem(CachedACDItem item, string action)
{
StringBuilder sb = new StringBuilder();
sb.Append(FormatCSVField(item.AcdItem.ActorSNO));
sb.Append(FormatCSVField(item.RealName));
if (item.Quality >= ItemQuality.Legendary || item.DBBaseType == ItemBaseType.Misc)
{
sb.Append(FormatCSVField(GetCleanName(item.InternalName)));
}
else
{
sb.Append(FormatCSVField(item.Quality + " " + item.DBBaseType));
}
sb.Append(FormatCSVField(item.DBBaseType.ToString()));
sb.Append(FormatCSVField(item.DBItemType.ToString()));
sb.Append(FormatCSVField(item.TrinityItemBaseType.ToString()));
sb.Append(FormatCSVField(item.TrinityItemType.ToString()));
sb.Append(FormatCSVField(item.Quality.ToString()));
sb.Append(FormatCSVField(item.Level));
sb.Append(FormatCSVField(action));
var stats = item.AcdItem.Stats.ToString();
stats = stats.Replace("\r\n\t", " ").Replace(" - ", ": ").Trim(new[] { '\r', '\n', '\t', ' ' });
sb.Append(FormatCSVField(stats));
sb.Append("\n");
_logItemQueue.Enqueue(sb.ToString());
}
internal static void TrinityOnItemSold(object sender, ItemEventArgs e)
{
ResetTownRun();
try
{
ACDItem i = e.Item;
if (i == null || !i.IsValid || i.IsDisposed)
{
return;
}
var cachedItem = CachedACDItem.GetCachedItem(i);
switch (i.ItemBaseType)
{
case ItemBaseType.Gem:
case ItemBaseType.Misc:
break;
default:
TownRun.LogJunkItems(cachedItem, cachedItem.TrinityItemBaseType, cachedItem.TrinityItemType, ItemValuation.ValueThisItem(cachedItem, cachedItem.TrinityItemType));
break;
}
}
catch (Exception ex)
{
if (ex is CoroutineStoppedException)
{
throw;
}
}
}
internal void AppendItem(CachedACDItem item, string action)
{
StringBuilder sb = new StringBuilder();
sb.Append(FormatCSVField(item.AcdItem.ActorSNO));
sb.Append(FormatCSVField(item.RealName));
if (item.Quality >= ItemQuality.Legendary || item.DBBaseType == ItemBaseType.Misc)
sb.Append(FormatCSVField(GetCleanName(item.InternalName)));
else
sb.Append(FormatCSVField(item.Quality + " " + item.DBBaseType));
sb.Append(FormatCSVField(item.DBBaseType.ToString()));
sb.Append(FormatCSVField(item.DBItemType.ToString()));
sb.Append(FormatCSVField(item.TrinityItemBaseType.ToString()));
sb.Append(FormatCSVField(item.TrinityItemType.ToString()));
sb.Append(FormatCSVField(item.Quality.ToString()));
sb.Append(FormatCSVField(item.Level));
sb.Append(FormatCSVField(action));
var stats = item.AcdItem.Stats.ToString();
stats = stats.Replace("\r\n\t", " ").Replace(" - ", ": ").Trim(new[] { '\r', '\n', '\t', ' ' });
sb.Append(FormatCSVField(stats));
sb.Append("\n");
_logItemQueue.Enqueue(sb.ToString());
}
internal static bool ShouldStashItem(CachedACDItem cItem)
{
if (cItem.AcdItem != null && cItem.AcdItem.IsValid)
{
bool result = false;
var item = new Item(cItem.AcdItem);
var wrappedItem = new ItemWrapper(cItem.AcdItem);
if (Trinity.Settings.Loot.ItemRank.AncientItemsOnly && wrappedItem.IsEquipment && !cItem.IsAncient)
{
result = false;
}
else if (Trinity.Settings.Loot.ItemRank.RequireSocketsOnJewelry && wrappedItem.IsJewelry && cItem.AcdItem.NumSockets != 0)
{
result = false;
}
else
{
result = ShouldStashItem(item);
}
string action = result ? "KEEP" : "TRASH";
Logger.Log(LogCategory.ItemValuation, "Ranked Item - {0} - {1}", action, item.Name);
return(result);
}
return(false);
}
internal static bool ShouldStashItem(Item referenceItem, CachedACDItem cItem, bool test = false)
{
Item item;
if (!Legendary.Items.TryGetValue(cItem.AcdItem.ActorSNO, out item))
{
Logger.LogDebug(" >> Unknown Item {0} {1} - Auto-keeping", cItem.RealName, cItem.AcdItem.ActorSNO);
return true;
}
if (cItem.AcdItem.IsCrafted)
{
Logger.LogDebug(" >> Crafted Item {0} {1} - Auto-keeping", cItem.RealName, cItem.AcdItem.ActorSNO);
return true;
}
var itemSetting = Trinity.Settings.Loot.ItemList.SelectedItems.FirstOrDefault(i => referenceItem.Id == i.Id);
if (itemSetting != null)
{
Logger.LogDebug(" >> {0} ({2}) is a Selected ListItem with {1} rules.", cItem.RealName, itemSetting.Rules.Count, cItem.AcdItem.ActorSNO);
if (itemSetting.RequiredRules.Any())
Logger.LogDebug(" >> {0} required rules:", itemSetting.RequiredRules.Count);
// If any of the required rules are false, trash.
foreach (var itemRule in itemSetting.RequiredRules)
{
if (!EvaluateRule(itemRule, cItem))
return false;
}
if (!itemSetting.OptionalRules.Any())
return true;
Logger.LogDebug(" >> {1}/{0} optional rules:", itemSetting.OptionalRules.Count, itemSetting.Ops);
// X optional rules must be true. in test mode evaluate all rules
var trueOptionals = 0;
foreach (var itemRule in itemSetting.OptionalRules)
{
if (EvaluateRule(itemRule, cItem))
trueOptionals++;
if (trueOptionals >= itemSetting.Ops && !test)
return true;
}
if (trueOptionals >= itemSetting.Ops && test)
return true;
return false;
}
Logger.LogDebug(" >> Unselected ListItem {0} {1}", cItem.RealName, cItem.AcdItem.ActorSNO);
return false;
}
/// <summary>
/// Determines if we should salvage an item
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private static bool TrinitySalvage(ACDItem item)
{
CachedACDItem cItem = CachedACDItem.GetCachedItem(item);
if (cItem.AcdItem.IsVendorBought)
{
return(false);
}
// Vanity Items
if (DataDictionary.VanityItems.Any(i => item.InternalName.StartsWith(i)))
{
return(false);
}
GItemType trinityItemType = Trinity.DetermineItemType(cItem.InternalName, cItem.DBItemType, cItem.FollowerType);
GItemBaseType trinityItemBaseType = Trinity.DetermineBaseType(trinityItemType);
// Take Salvage Option corresponding to ItemLevel
SalvageOption salvageOption = GetSalvageOption(cItem.Quality);
// Stashing Whites
if (Trinity.Settings.Loot.TownRun.StashWhites && cItem.Quality < ItemQuality.Magic1)
{
return(false);
}
// Stashing Blues
if (Trinity.Settings.Loot.TownRun.StashBlues && cItem.Quality > ItemQuality.Superior && cItem.Quality < ItemQuality.Rare4)
{
return(false);
}
switch (trinityItemBaseType)
{
case GItemBaseType.WeaponRange:
case GItemBaseType.WeaponOneHand:
case GItemBaseType.WeaponTwoHand:
case GItemBaseType.Armor:
case GItemBaseType.Offhand:
return(salvageOption == SalvageOption.Salvage);
case GItemBaseType.Jewelry:
return(salvageOption == SalvageOption.Salvage);
case GItemBaseType.FollowerItem:
return(salvageOption == SalvageOption.Salvage);
case GItemBaseType.Gem:
case GItemBaseType.Misc:
case GItemBaseType.Unknown:
return(false);
default:
return(false);
}
}
public override bool ShouldSellItem(ACDItem item)
{
bool action = ShouldSellItem(item, ItemEvaluationType.Sell);
if (action)
{
ItemStashSellAppender.Instance.AppendItem(CachedACDItem.GetCachedItem(item), "Sell");
}
return(action);
}
internal static bool ShouldStashItem(CachedACDItem cItem, bool test = false)
{
if (cItem.AcdItem != null && cItem.AcdItem.IsValid)
{
var item = Legendary.GetItemByACD(cItem.AcdItem);
if (item == null)
{
Logger.Log(TrinityLogLevel.Info, " >> Unknown Item {0} {1} - Auto-keeping", cItem.RealName, cItem.ActorSNO);
return(true);
}
return(ShouldStashItem(item, cItem, test));;
}
return(false);
}
internal static bool ShouldStashItem(CachedACDItem cItem, bool test = false)
{
if (cItem.AcdItem != null && cItem.AcdItem.IsValid)
{
var item = Legendary.GetItemByACD(cItem.AcdItem);
if (item == null)
{
Logger.Log(TrinityLogLevel.Info, " >> Unknown Item {0} {1} - Auto-keeping", cItem.RealName, cItem.ActorSNO);
return true;
}
return ShouldStashItem(item, cItem, test); ;
}
return false;
}
internal static bool ShouldStashItem(CachedACDItem cItem)
{
if (cItem.AcdItem != null && cItem.AcdItem.IsValid)
{
bool result = false;
var item = new Item(cItem.AcdItem);
var wrappedItem = new ItemWrapper(cItem.AcdItem);
result = ShouldStashItem(item, cItem);
string action = result ? "KEEP" : "TRASH";
return result;
}
return false;
}
/// <summary>
/// Log the rubbish junk items we salvaged or sold
/// </summary>
internal static void LogJunkItems(CachedACDItem acdItem, TrinityItemBaseType itemBaseType, TrinityItemType itemType, double itemValue)
{
FileStream logStream = null;
try
{
string filePath = Path.Combine(FileManager.LoggingPath, "JunkLog - " + Trinity.Player.ActorClass + ".log");
logStream = File.Open(filePath, FileMode.Append, FileAccess.Write, FileShare.Read);
using (var logWriter = new StreamWriter(logStream))
{
if (!_loggedJunkThisStash)
{
_loggedJunkThisStash = true;
logWriter.WriteLine(DateTime.Now + ":");
logWriter.WriteLine("====================");
}
string isLegendaryItem = "";
if (acdItem.Quality >= ItemQuality.Legendary)
{
isLegendaryItem = " {legendary item}";
}
logWriter.WriteLine(itemBaseType + " - " + itemType + " '" + acdItem.RealName + "'. Score = " + itemValue.ToString("0") + isLegendaryItem);
if (JunkItemStatString != "")
{
logWriter.WriteLine(" " + JunkItemStatString);
}
else
{
logWriter.WriteLine(" (no scorable attributes)");
}
logWriter.WriteLine("");
}
logStream.Close();
}
catch (IOException)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "Fatal Error: File access error for junk log file.");
if (logStream != null)
{
logStream.Close();
}
}
}
public bool ShouldSellItem(ACDItem item, ItemEvaluationType evaluationType)
{
ItemEvents.ResetTownRun();
CachedACDItem cItem = CachedACDItem.GetCachedItem(item);
if (Current.ItemIsProtected(cItem.AcdItem))
{
return(false);
}
if (Trinity.Settings.Loot.ItemFilterMode == ItemFilterMode.DemonBuddy)
{
return(Current.ShouldSellItem(item));
}
if (Trinity.Settings.Loot.ItemFilterMode == ItemFilterMode.TrinityWithItemRules)
{
return(ItemRulesSalvageSell(item, evaluationType));
}
return(TrinitySell(item));
}
public static void ItemListTest()
{
Logger.Log("Starting ItemList Backpack Test");
var backpackItems = ZetaDia.Me.Inventory.Backpack.ToList();
var total = backpackItems.Count;
var stashCount = 0;
foreach (var acdItem in backpackItems)
{
Logger.Log("{0} ActorSNO={1} GameBalanceId={2}", acdItem.Name, acdItem.ActorSNO, acdItem.GameBalanceId);
var cItem = CachedACDItem.GetCachedItem(acdItem);
if (ItemList.ShouldStashItem(cItem, true))
{
stashCount++;
}
}
Logger.Log("Finished ItemList Backpack Test");
Logger.Log("Finished - Stash {0} / {1}", stashCount, total);
}
internal static bool EvaluateRule(LRule itemRule, CachedACDItem cItem)
{
return(EvaluateRule(cItem, itemRule.ItemProperty, itemRule.Value, itemRule.Variant, itemRule.RuleType));
}
/// <summary>
/// Log the rubbish junk items we salvaged or sold
/// </summary>
internal static void LogJunkItems(CachedACDItem acdItem, TrinityItemBaseType itemBaseType, TrinityItemType itemType, double itemValue)
{
FileStream logStream = null;
try
{
string filePath = Path.Combine(FileManager.LoggingPath, "JunkLog - " + Trinity.Player.ActorClass + ".log");
logStream = File.Open(filePath, FileMode.Append, FileAccess.Write, FileShare.Read);
using (var logWriter = new StreamWriter(logStream))
{
if (!_loggedJunkThisStash)
{
_loggedJunkThisStash = true;
logWriter.WriteLine(DateTime.Now + ":");
logWriter.WriteLine("====================");
}
string isLegendaryItem = "";
if (acdItem.Quality >= ItemQuality.Legendary)
isLegendaryItem = " {legendary item}";
logWriter.WriteLine(itemBaseType + " - " + itemType + " '" + acdItem.RealName + "'. Score = " + itemValue.ToString("0") + isLegendaryItem);
if (JunkItemStatString != "")
logWriter.WriteLine(" " + JunkItemStatString);
else
logWriter.WriteLine(" (no scorable attributes)");
logWriter.WriteLine("");
}
logStream.Close();
}
catch (IOException)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "Fatal Error: File access error for junk log file.");
if (logStream != null)
logStream.Close();
}
}
/// <summary>
/// Log the nice items we found and stashed
/// </summary>
internal static void LogGoodItems(CachedACDItem acdItem, TrinityItemBaseType itemBaseType, TrinityItemType itemType, double itemValue)
{
FileStream logStream = null;
try
{
string filePath = Path.Combine(FileManager.LoggingPath, "StashLog - " + Trinity.Player.ActorClass + ".log");
logStream = File.Open(filePath, FileMode.Append, FileAccess.Write, FileShare.Read);
//TODO : Change File Log writing
using (var logWriter = new StreamWriter(logStream))
{
if (!_loggedAnythingThisStash)
{
_loggedAnythingThisStash = true;
logWriter.WriteLine(DateTime.Now + ":");
logWriter.WriteLine("====================");
}
string sLegendaryString = "";
bool shouldSendNotifications = false;
if (acdItem.Quality >= ItemQuality.Legendary)
{
if (!Trinity.Settings.Notification.LegendaryScoring)
shouldSendNotifications = true;
else if (Trinity.Settings.Notification.LegendaryScoring && ItemValuation.CheckScoreForNotification(itemBaseType, itemValue))
shouldSendNotifications = true;
if (shouldSendNotifications)
NotificationManager.AddNotificationToQueue(acdItem.RealName + " [" + itemType +
"] (Score=" + itemValue + ". " + acdItem.AcdItem.Stats + ")",
ZetaDia.Service.Hero.Name + " new legendary!", ProwlNotificationPriority.Emergency);
sLegendaryString = " {legendary item}";
// Change made by bombastic
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+=+=+=+=+=+=+=+=+ LEGENDARY FOUND +=+=+=+=+=+=+=+=+");
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+ Name: {0} ({1})", acdItem.RealName, itemType);
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+ Score: {0:0}", itemValue);
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+ Attributes: {0}", acdItem.AcdItem.Stats.ToString());
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+");
}
else
{
// Check for non-legendary notifications
shouldSendNotifications = ItemValuation.CheckScoreForNotification(itemBaseType, itemValue);
if (shouldSendNotifications)
NotificationManager.AddNotificationToQueue(acdItem.RealName + " [" + itemType + "] (Score=" + itemValue + ". " + acdItem.AcdItem.Stats + ")",
ZetaDia.Service.Hero.BattleTagName + " new item!", ProwlNotificationPriority.Normal);
}
if (shouldSendNotifications)
{
NotificationManager.EmailMessage.AppendLine(itemBaseType + " - " + itemType + " '" + acdItem.RealName + "'. Score = " + Math.Round(itemValue) + sLegendaryString)
.AppendLine(" " + acdItem.AcdItem.Stats)
.AppendLine();
}
logWriter.WriteLine(itemBaseType + " - " + itemType + " '" + acdItem.RealName + "'. Score = " + Math.Round(itemValue) + sLegendaryString);
logWriter.WriteLine(" " + acdItem.AcdItem.Stats);
logWriter.WriteLine("");
}
logStream.Close();
}
catch (IOException)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "Fatal Error: File access error for stash log file.");
if (logStream != null)
logStream.Close();
}
}
internal static bool ShouldStashItem(Item referenceItem, CachedACDItem cItem, bool test = false)
{
var id = referenceItem.Id;
var logLevel = test ? TrinityLogLevel.Info : TrinityLogLevel.Debug;
if (cItem.AcdItem.IsCrafted)
{
Logger.Log(logLevel, " >> Crafted Item {0} {1} - Auto-keeping", cItem.RealName, id);
return true;
}
if (test)
{
var props = ItemDataUtils.GetPropertiesForItem(referenceItem);
Logger.LogVerbose("------- Starting Test of {0} supported properties for {1} against max value", props.Count, cItem.RealName);
foreach (var prop in props)
{
var range = ItemDataUtils.GetItemStatRange(referenceItem, prop);
EvaluateRule(cItem, prop, range.AncientMax, 0);
}
Logger.LogVerbose("------- Finished Test for {0} against max value", cItem.RealName);
}
var itemSetting = Trinity.Settings.Loot.ItemList.SelectedItems.FirstOrDefault(i => referenceItem.Id == i.Id);
if (itemSetting != null)
{
Logger.Log(logLevel, " >> {0} ({2}) is a Selected ListItem with {1} rules.", cItem.RealName, itemSetting.Rules.Count, id);
if (itemSetting.RequiredRules.Any())
Logger.Log(logLevel, " >> {0} required rules:", itemSetting.RequiredRules.Count);
// If any of the required rules are false, trash.
foreach (var itemRule in itemSetting.RequiredRules)
{
if (!EvaluateRule(itemRule, cItem))
return false;
}
if (!itemSetting.OptionalRules.Any())
return true;
Logger.Log(logLevel, " >> {1}/{0} optional rules:", itemSetting.OptionalRules.Count, itemSetting.Ops);
// X optional rules must be true. in test mode evaluate all rules
var trueOptionals = 0;
foreach (var itemRule in itemSetting.OptionalRules)
{
if (EvaluateRule(itemRule, cItem))
trueOptionals++;
if (trueOptionals >= itemSetting.Ops && !test)
return true;
}
if (trueOptionals >= itemSetting.Ops && test)
return true;
return false;
}
Logger.Log(logLevel, " >> Unselected ListItem {0} {1}", cItem.RealName, id);
return false;
}
private static bool EvaluateRule(CachedACDItem cItem, ItemProperty prop, double value, int variant, RuleType type = RuleType.Test)
{
var result = false;
string friendlyVariant = string.Empty;
double itemValue = 0;
double ruleValue = 0;
switch (prop)
{
case ItemProperty.Ancient:
itemValue = cItem.IsAncient ? 1 : 0;
ruleValue = value;
result = cItem.IsAncient == (value == 1);
break;
case ItemProperty.PrimaryStat:
itemValue = ItemDataUtils.GetMainStatValue(cItem.AcdItem);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitChance:
itemValue = cItem.CritPercent;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitDamage:
itemValue = cItem.CritDamagePercent;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.AttackSpeed:
itemValue = ItemDataUtils.GetAttackSpeed(cItem.AcdItem);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ResourceCost:
itemValue = Math.Round(cItem.AcdItem.Stats.ResourceCostReductionPercent, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Cooldown:
itemValue = Math.Round(cItem.AcdItem.Stats.PowerCooldownReductionPercent, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ResistAll:
itemValue = cItem.AcdItem.Stats.ResistAll;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Sockets:
itemValue = cItem.AcdItem.Stats.Sockets;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Vitality:
itemValue = cItem.AcdItem.Stats.Vitality;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.AreaDamage:
itemValue = cItem.AcdItem.Stats.OnHitAreaDamageProcChance;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.FireSkills:
itemValue = cItem.AcdItem.Stats.FireSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ColdSkills:
itemValue = cItem.AcdItem.Stats.ColdSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LightningSkills:
itemValue = cItem.AcdItem.Stats.LightningSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ArcaneSkills:
itemValue = cItem.AcdItem.Stats.ArcaneSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.HolySkills:
itemValue = cItem.AcdItem.Stats.HolySkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PoisonSkills:
itemValue = cItem.AcdItem.Stats.PosionSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PhysicalSkills:
itemValue = cItem.AcdItem.Stats.PhysicalSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.DamageAgainstElites:
itemValue = Math.Round(cItem.AcdItem.Stats.DamagePercentBonusVsElites, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.DamageFromElites:
itemValue = Math.Round(cItem.AcdItem.Stats.DamagePercentReductionFromElites, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.BaseMaxDamage:
itemValue = ItemDataUtils.GetMaxBaseDamage(cItem.AcdItem);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.SkillDamage:
var skillId = variant;
var skill = ItemDataUtils.GetSkillsForItemType(cItem.TrinityItemType, Trinity.Player.ActorClass).FirstOrDefault(s => s.Id == skillId);
if (skill != null)
{
friendlyVariant = skill.Name;
itemValue = cItem.AcdItem.SkillDamagePercent(skill.SNOPower);
}
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ElementalDamage:
var elementId = variant;
var element = (Element)elementId;
if (element != Element.Unknown)
{
friendlyVariant = ((EnumValue<Element>)element).Name;
itemValue = Math.Round(ItemDataUtils.GetElementalDamage(cItem.AcdItem, element), MidpointRounding.AwayFromZero);
}
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PercentDamage:
itemValue = Math.Round(cItem.AcdItem.WeaponDamagePercent(), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitsGrantArcane:
itemValue = Math.Round(cItem.ArcaneOnCrit, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Armor:
itemValue = Math.Round(cItem.Armor, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ChanceToBlock:
itemValue = Math.Round(cItem.BlockChance, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.HatredRegen:
itemValue = Math.Round(cItem.HatredRegen, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePercent:
itemValue = Math.Round(cItem.LifePercent, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerHit:
itemValue = Math.Round(cItem.LifeOnHit, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.RegenerateLifePerSecond:
itemValue = Math.Round(cItem.AcdItem.Stats.HealthPerSecond, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ManaRegen:
itemValue = Math.Round(cItem.AcdItem.Stats.ManaRegen, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.MovementSpeed:
itemValue = Math.Round(cItem.AcdItem.Stats.MovementSpeed, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.SpiritRegen:
itemValue = Math.Round(cItem.AcdItem.Stats.SpiritRegen, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.WrathRegen:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute<float>(ActorAttributeType.ResourceRegenPerSecondFaith), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerFury:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute<float>(ActorAttributeType.SpendingResourceHealsPercentFury), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerSpirit:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute<float>(ActorAttributeType.SpendingResourceHealsPercentSpirit), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerWrath:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute<float>(ActorAttributeType.SpendingResourceHealsPercentFaith), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
}
Logger.LogVerbose(" >> Evaluated {0} -- {1} {5} Type={6} (Item: {2} -v- Rule: {3}) = {4}",
cItem.RealName,
prop.ToString().AddSpacesToSentence(),
itemValue,
ruleValue,
result,
friendlyVariant,
type);
return result;
}
/// <summary>
/// Force Notification on Items
/// </summary>
internal static void LogGoodItems(CachedACDItem acdItem, GItemBaseType itemBaseType, GItemType itemType)
{
string nameAndCount = acdItem.RealName;
if (acdItem.ItemStackQuantity > 1)
{
nameAndCount = string.Format("{0}, Count {1}", nameAndCount, acdItem.ItemStackQuantity);
}
NotificationManager.AddNotificationToQueue(nameAndCount,
ZetaDia.Service.Hero.Name + " new item!", ProwlNotificationPriority.Emergency);
NotificationManager.EmailMessage.AppendLine(itemBaseType.ToString() + " - " + itemType.ToString() + " '" + nameAndCount + "'.")
.AppendLine();
}
/// <summary>
/// Log the nice items we found and stashed
/// </summary>
internal static void LogGoodItems(CachedACDItem acdItem, TrinityItemBaseType itemBaseType, TrinityItemType itemType, double itemValue)
{
FileStream logStream = null;
try
{
string filePath = Path.Combine(FileManager.LoggingPath, "StashLog - " + Trinity.Player.ActorClass + ".log");
logStream = File.Open(filePath, FileMode.Append, FileAccess.Write, FileShare.Read);
//TODO : Change File Log writing
using (var logWriter = new StreamWriter(logStream))
{
if (!_loggedAnythingThisStash)
{
_loggedAnythingThisStash = true;
logWriter.WriteLine(DateTime.Now + ":");
logWriter.WriteLine("====================");
}
string sLegendaryString = "";
bool shouldSendNotifications = false;
if (acdItem.Quality >= ItemQuality.Legendary)
{
if (!Trinity.Settings.Notification.LegendaryScoring)
{
shouldSendNotifications = true;
}
else if (Trinity.Settings.Notification.LegendaryScoring && ItemValuation.CheckScoreForNotification(itemBaseType, itemValue))
{
shouldSendNotifications = true;
}
if (shouldSendNotifications)
{
NotificationManager.AddNotificationToQueue(acdItem.RealName + " [" + itemType +
"] (Score=" + itemValue + ". " + acdItem.AcdItem.Stats + ")",
ZetaDia.Service.Hero.Name + " new legendary!", ProwlNotificationPriority.Emergency);
}
sLegendaryString = " {legendary item}";
// Change made by bombastic
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+=+=+=+=+=+=+=+=+ LEGENDARY FOUND +=+=+=+=+=+=+=+=+");
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+ Name: {0} ({1})", acdItem.RealName, itemType);
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+ Score: {0:0}", itemValue);
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+ Attributes: {0}", acdItem.AcdItem.Stats.ToString());
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+");
}
else
{
// Check for non-legendary notifications
shouldSendNotifications = ItemValuation.CheckScoreForNotification(itemBaseType, itemValue);
if (shouldSendNotifications)
{
NotificationManager.AddNotificationToQueue(acdItem.RealName + " [" + itemType + "] (Score=" + itemValue + ". " + acdItem.AcdItem.Stats + ")",
ZetaDia.Service.Hero.BattleTagName + " new item!", ProwlNotificationPriority.Normal);
}
}
if (shouldSendNotifications)
{
NotificationManager.EmailMessage.AppendLine(itemBaseType + " - " + itemType + " '" + acdItem.RealName + "'. Score = " + Math.Round(itemValue) + sLegendaryString)
.AppendLine(" " + acdItem.AcdItem.Stats)
.AppendLine();
}
logWriter.WriteLine(itemBaseType + " - " + itemType + " '" + acdItem.RealName + "'. Score = " + Math.Round(itemValue) + sLegendaryString);
logWriter.WriteLine(" " + acdItem.AcdItem.Stats);
logWriter.WriteLine("");
}
logStream.Close();
}
catch (IOException)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "Fatal Error: File access error for stash log file.");
if (logStream != null)
{
logStream.Close();
}
}
}
internal static bool ShouldStashItem(Item referenceItem, CachedACDItem cItem, bool test = false)
{
var id = referenceItem.Id;
var logLevel = test ? TrinityLogLevel.Info : TrinityLogLevel.Debug;
if (cItem.AcdItem.IsCrafted)
{
Logger.Log(logLevel, " >> Crafted Item {0} {1} - Auto-keeping", cItem.RealName, id);
return(true);
}
if (test)
{
var props = ItemDataUtils.GetPropertiesForItem(referenceItem);
Logger.LogVerbose("------- Starting Test of {0} supported properties for {1} against max value", props.Count, cItem.RealName);
foreach (var prop in props)
{
var range = ItemDataUtils.GetItemStatRange(referenceItem, prop);
EvaluateRule(cItem, prop, range.AncientMax, 0);
}
Logger.LogVerbose("------- Finished Test for {0} against max value", cItem.RealName);
}
var itemSetting = Trinity.Settings.Loot.ItemList.SelectedItems.FirstOrDefault(i => referenceItem.Id == i.Id);
if (itemSetting != null)
{
Logger.Log(logLevel, " >> {0} ({2}) is a Selected ListItem with {1} rules.", cItem.RealName, itemSetting.Rules.Count, id);
if (itemSetting.RequiredRules.Any())
{
Logger.Log(logLevel, " >> {0} required rules:", itemSetting.RequiredRules.Count);
}
// If any of the required rules are false, trash.
foreach (var itemRule in itemSetting.RequiredRules)
{
if (!EvaluateRule(itemRule, cItem))
{
return(false);
}
}
if (!itemSetting.OptionalRules.Any())
{
return(true);
}
Logger.Log(logLevel, " >> {1}/{0} optional rules:", itemSetting.OptionalRules.Count, itemSetting.Ops);
// X optional rules must be true. in test mode evaluate all rules
var trueOptionals = 0;
foreach (var itemRule in itemSetting.OptionalRules)
{
if (EvaluateRule(itemRule, cItem))
{
trueOptionals++;
}
if (trueOptionals >= itemSetting.Ops && !test)
{
return(true);
}
}
if (trueOptionals >= itemSetting.Ops && test)
{
return(true);
}
return(false);
}
Logger.Log(logLevel, " >> Unselected ListItem {0} {1}", cItem.RealName, id);
return(false);
}
private static bool EvaluateRule(LRule itemRule, CachedACDItem cItem)
{
var result = false;
string friendlyVariant = string.Empty;
double itemValue = 0;
double ruleValue = 0;
switch (itemRule.ItemProperty)
{
case ItemProperty.Ancient:
itemValue = cItem.IsAncient ? 1 : 0;
ruleValue = itemRule.Value;
result = cItem.IsAncient == (itemRule.Value == 1);
break;
case ItemProperty.PrimaryStat:
itemValue = ItemDataUtils.GetMainStatValue(cItem.AcdItem);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitChance:
itemValue = cItem.CritPercent;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitDamage:
itemValue = cItem.CritDamagePercent;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.AttackSpeed:
itemValue = ItemDataUtils.GetAttackSpeed(cItem.AcdItem);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ResourceCost:
itemValue = Math.Round(cItem.AcdItem.Stats.ResourceCostReductionPercent, MidpointRounding.AwayFromZero);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Cooldown:
itemValue = Math.Round(cItem.AcdItem.Stats.PowerCooldownReductionPercent, MidpointRounding.AwayFromZero);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ResistAll:
itemValue = cItem.AcdItem.Stats.ResistAll;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Sockets:
itemValue = cItem.AcdItem.Stats.Sockets;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Vitality:
itemValue = cItem.AcdItem.Stats.Vitality;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.FireSkills:
itemValue = cItem.AcdItem.Stats.FireSkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ColdSkills:
itemValue = cItem.AcdItem.Stats.ColdSkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LightningSkills:
itemValue = cItem.AcdItem.Stats.LightningSkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ArcaneSkills:
itemValue = cItem.AcdItem.Stats.ArcaneSkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.HolySkills:
itemValue = cItem.AcdItem.Stats.HolySkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PoisonSkills:
itemValue = cItem.AcdItem.Stats.PosionSkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PhysicalSkills:
itemValue = cItem.AcdItem.Stats.PhysicalSkillDamagePercentBonus;
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.DamageAgainstElites:
itemValue = Math.Round(cItem.AcdItem.Stats.DamagePercentBonusVsElites, MidpointRounding.AwayFromZero);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.DamageFromElites:
itemValue = Math.Round(cItem.AcdItem.Stats.DamagePercentReductionFromElites, MidpointRounding.AwayFromZero);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.BaseMaxDamage:
itemValue = ItemDataUtils.GetMaxBaseDamage(cItem.AcdItem);
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.SkillDamage:
var skillId = itemRule.Variant;
var skill = ItemDataUtils.GetSkillsForItemType(cItem.TrinityItemType, Trinity.Player.ActorClass).FirstOrDefault(s => s.Id == skillId);
if (skill != null)
{
friendlyVariant = skill.Name;
itemValue = cItem.AcdItem.SkillDamagePercent(skill.SNOPower);
}
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ElementalDamage:
var elementId = itemRule.Variant;
var element = (Element)elementId;
if (element != Element.Unknown)
{
friendlyVariant = ((EnumValue<Element>)element).Name;
itemValue = Math.Round(ItemDataUtils.GetElementalDamage(cItem.AcdItem, element), MidpointRounding.AwayFromZero);
}
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PercentDamage:
itemValue = cItem.AcdItem.WeaponDamagePercent();
ruleValue = itemRule.Value;
result = itemValue >= ruleValue;
break;
}
Logger.LogVerbose(" >> Evaluated {0} -- {1} {5} Type={6} (Item: {2} -v- Rule: {3}) = {4}",
cItem.RealName,
itemRule.ItemProperty.ToString().AddSpacesToSentence(),
itemValue,
ruleValue,
result,
friendlyVariant,
itemRule.RuleType);
return result;
}
/// <summary>
/// Determines if we should Sell an Item
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private static bool TrinitySell(ACDItem item)
{
CachedACDItem cItem = CachedACDItem.GetCachedItem(item);
// Vanity Items
if (DataDictionary.VanityItems.Any(i => item.InternalName.StartsWith(i)))
{
return(false);
}
switch (cItem.TrinityItemBaseType)
{
case GItemBaseType.WeaponRange:
case GItemBaseType.WeaponOneHand:
case GItemBaseType.WeaponTwoHand:
case GItemBaseType.Armor:
case GItemBaseType.Offhand:
case GItemBaseType.Jewelry:
case GItemBaseType.FollowerItem:
return(true);
case GItemBaseType.Gem:
case GItemBaseType.Misc:
if (cItem.TrinityItemType == GItemType.HealthPotion && Trinity.Settings.Loot.TownRun.SellExtraPotions)
{
// Never sell our precious legendary potions!
if (cItem.AcdItem.ItemQualityLevel >= ItemQuality.Legendary)
{
return(false);
}
bool hasLegendaryPotion = ZetaDia.Me.Inventory.Backpack.Any(i => i.ItemType == ItemType.Potion && i.ItemQualityLevel >= ItemQuality.Legendary);
// If we have a legendary potion, sell regular potions
if (hasLegendaryPotion && cItem.AcdItem.ItemQualityLevel <= ItemQuality.Legendary)
{
return(true);
}
// If we have more than 1 stack of potions
// Keep the largest stack until we only have 1 stack
int potionStacks = ZetaDia.Me.Inventory.Backpack.Count(i => i.ItemType == ItemType.Potion);
if (potionStacks > 1)
{
// Keep only the highest stack
ACDItem acdItem = ZetaDia.Me.Inventory.Backpack
.Where(i => i.ItemType == ItemType.Potion && i.ItemQualityLevel == ItemQuality.Normal)
.OrderBy(i => i.ItemStackQuantity)
.FirstOrDefault();
if (acdItem != null && cItem.AcdItem.ACDGuid == acdItem.ACDGuid)
{
return(true);
}
}
}
if (cItem.TrinityItemType == GItemType.CraftingPlan)
{
return(true);
}
return(false);
case GItemBaseType.Unknown:
return(false);
}
return(false);
}
private static bool EvaluateRule(CachedACDItem cItem, ItemProperty prop, double value, int variant, RuleType type = RuleType.Test)
{
var result = false;
string friendlyVariant = string.Empty;
double itemValue = 0;
double ruleValue = 0;
switch (prop)
{
case ItemProperty.Ancient:
itemValue = cItem.IsAncient ? 1 : 0;
ruleValue = value;
result = cItem.IsAncient == (value == 1);
break;
case ItemProperty.PrimaryStat:
itemValue = ItemDataUtils.GetMainStatValue(cItem.AcdItem);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitChance:
itemValue = cItem.CritPercent;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitDamage:
itemValue = cItem.CritDamagePercent;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.AttackSpeed:
itemValue = ItemDataUtils.GetAttackSpeed(cItem.AcdItem);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ResourceCost:
itemValue = Math.Round(cItem.AcdItem.Stats.ResourceCostReductionPercent, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Cooldown:
itemValue = Math.Round(cItem.AcdItem.Stats.PowerCooldownReductionPercent, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ResistAll:
itemValue = cItem.AcdItem.Stats.ResistAll;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Sockets:
itemValue = cItem.AcdItem.Stats.Sockets;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Vitality:
itemValue = cItem.AcdItem.Stats.Vitality;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.AreaDamage:
itemValue = cItem.AcdItem.Stats.OnHitAreaDamageProcChance;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.FireSkills:
itemValue = cItem.AcdItem.Stats.FireSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ColdSkills:
itemValue = cItem.AcdItem.Stats.ColdSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LightningSkills:
itemValue = cItem.AcdItem.Stats.LightningSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ArcaneSkills:
itemValue = cItem.AcdItem.Stats.ArcaneSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.HolySkills:
itemValue = cItem.AcdItem.Stats.HolySkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PoisonSkills:
itemValue = cItem.AcdItem.Stats.PosionSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PhysicalSkills:
itemValue = cItem.AcdItem.Stats.PhysicalSkillDamagePercentBonus;
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.DamageAgainstElites:
itemValue = Math.Round(cItem.AcdItem.Stats.DamagePercentBonusVsElites, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.DamageFromElites:
itemValue = Math.Round(cItem.AcdItem.Stats.DamagePercentReductionFromElites, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.BaseMaxDamage:
itemValue = ItemDataUtils.GetMaxBaseDamage(cItem.AcdItem);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.SkillDamage:
var skillId = variant;
var skill = ItemDataUtils.GetSkillsForItemType(cItem.TrinityItemType, Trinity.Player.ActorClass).FirstOrDefault(s => s.Id == skillId);
if (skill != null)
{
friendlyVariant = skill.Name;
itemValue = cItem.AcdItem.SkillDamagePercent(skill.SNOPower);
}
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ElementalDamage:
var elementId = variant;
var element = (Element)elementId;
if (element != Element.Unknown)
{
friendlyVariant = ((EnumValue <Element>)element).Name;
itemValue = Math.Round(ItemDataUtils.GetElementalDamage(cItem.AcdItem, element), MidpointRounding.AwayFromZero);
}
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.PercentDamage:
itemValue = Math.Round(cItem.AcdItem.WeaponDamagePercent(), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.CriticalHitsGrantArcane:
itemValue = Math.Round(cItem.ArcaneOnCrit, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.Armor:
itemValue = Math.Round(cItem.Armor, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ChanceToBlock:
itemValue = Math.Round(cItem.BlockChance, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.HatredRegen:
itemValue = Math.Round(cItem.HatredRegen, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePercent:
itemValue = Math.Round(cItem.LifePercent, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerHit:
itemValue = Math.Round(cItem.LifeOnHit, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.RegenerateLifePerSecond:
itemValue = Math.Round(cItem.AcdItem.Stats.HealthPerSecond, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.ManaRegen:
itemValue = Math.Round(cItem.AcdItem.Stats.ManaRegen, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.MovementSpeed:
itemValue = Math.Round(cItem.AcdItem.Stats.MovementSpeed, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.SpiritRegen:
itemValue = Math.Round(cItem.AcdItem.Stats.SpiritRegen, MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.WrathRegen:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute <float>(ActorAttributeType.ResourceRegenPerSecondFaith), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerFury:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute <float>(ActorAttributeType.SpendingResourceHealsPercentFury), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerSpirit:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute <float>(ActorAttributeType.SpendingResourceHealsPercentSpirit), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
case ItemProperty.LifePerWrath:
itemValue = Math.Round((double)cItem.AcdItem.GetAttribute <float>(ActorAttributeType.SpendingResourceHealsPercentFaith), MidpointRounding.AwayFromZero);
ruleValue = value;
result = itemValue >= ruleValue;
break;
}
Logger.LogVerbose(" >> Evaluated {0} -- {1} {5} Type={6} (Item: {2} -v- Rule: {3}) = {4}",
cItem.RealName,
prop.ToString().AddSpacesToSentence(),
itemValue,
ruleValue,
result,
friendlyVariant,
type);
return(result);
}
internal static bool EvaluateRule(LRule itemRule, CachedACDItem cItem)
{
return EvaluateRule(cItem, itemRule.ItemProperty, itemRule.Value, itemRule.Variant, itemRule.RuleType);
}
public bool ShouldStashItem(ACDItem item, ItemEvaluationType evaluationType)
{
ItemEvents.ResetTownRun();
if (Current.ItemIsProtected(item))
{
return(false);
}
// Vanity Items
if (DataDictionary.VanityItems.Any(i => item.InternalName.StartsWith(i)))
{
return(false);
}
if (Trinity.Settings.Loot.ItemFilterMode == ItemFilterMode.DemonBuddy)
{
return(Current.ShouldStashItem(item));
}
CachedACDItem cItem = CachedACDItem.GetCachedItem(item);
// Now look for Misc items we might want to keep
GItemType tItemType = cItem.TrinityItemType; // DetermineItemType(cItem.InternalName, cItem.DBItemType, cItem.FollowerType);
GItemBaseType tBaseType = cItem.TrinityItemBaseType; // DetermineBaseType(trinityItemType);
bool isEquipment = (tBaseType == GItemBaseType.Armor ||
tBaseType == GItemBaseType.Jewelry ||
tBaseType == GItemBaseType.Offhand ||
tBaseType == GItemBaseType.WeaponOneHand ||
tBaseType == GItemBaseType.WeaponRange ||
tBaseType == GItemBaseType.WeaponTwoHand);
if (cItem.TrinityItemType == GItemType.HoradricCache && Trinity.Settings.Loot.TownRun.OpenHoradricCaches)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] = (ignoring Horadric Cache)", cItem.RealName, cItem.InternalName);
return(false);
}
// Stash all unidentified items - assume we want to keep them since we are using an identifier over-ride
if (cItem.IsUnidentified)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] = (autokeep unidentified items)", cItem.RealName, cItem.InternalName);
}
return(true);
}
if (tItemType == GItemType.StaffOfHerding)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep staff of herding)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
if (tItemType == GItemType.CraftingMaterial)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep craft materials)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
if (tItemType == GItemType.Emerald || tItemType == GItemType.Amethyst || tItemType == GItemType.Topaz || tItemType == GItemType.Ruby || tItemType == GItemType.Diamond)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep gems)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
if (tItemType == GItemType.CraftTome)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep tomes)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
if (tItemType == GItemType.InfernalKey)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep infernal key)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
if (tItemType == GItemType.HealthPotion)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (ignoring potions)", cItem.RealName, cItem.InternalName, tItemType);
}
return(false);
}
if (tItemType == GItemType.CraftingPlan && cItem.Quality >= ItemQuality.Legendary)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep legendary plans)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
if (Trinity.Settings.Loot.ItemFilterMode == ItemFilterMode.TrinityWithItemRules)
{
Interpreter.InterpreterAction action = Trinity.StashRule.checkItem(item, evaluationType);
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (" + action + ")", cItem.AcdItem.Name, cItem.AcdItem.InternalName, cItem.AcdItem.ItemType);
}
switch (action)
{
case Interpreter.InterpreterAction.KEEP:
return(true);
case Interpreter.InterpreterAction.TRASH:
return(false);
case Interpreter.InterpreterAction.SCORE:
break;
}
}
if (tItemType == GItemType.CraftingPlan)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep plans)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
// Stashing Whites, auto-keep
if (Trinity.Settings.Loot.TownRun.StashWhites && isEquipment && cItem.Quality <= ItemQuality.Superior)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (stashing whites)", cItem.RealName, cItem.InternalName, tItemType);
return(true);
}
// Else auto-trash
if (cItem.Quality <= ItemQuality.Superior && (isEquipment || cItem.TrinityItemBaseType == GItemBaseType.FollowerItem))
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (trash whites)", cItem.RealName, cItem.InternalName, tItemType);
return(false);
}
// Stashing blues, auto-keep
if (Trinity.Settings.Loot.TownRun.StashBlues && isEquipment && cItem.Quality >= ItemQuality.Magic1 && cItem.Quality <= ItemQuality.Magic3)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (stashing blues)", cItem.RealName, cItem.InternalName, tItemType);
return(true);
}
// Else auto trash
if (cItem.Quality >= ItemQuality.Magic1 && cItem.Quality <= ItemQuality.Magic3 && (isEquipment || cItem.TrinityItemBaseType == GItemBaseType.FollowerItem))
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (trashing blues)", cItem.RealName, cItem.InternalName, tItemType);
return(false);
}
// Force salvage Rares
if (Trinity.Settings.Loot.TownRun.ForceSalvageRares && cItem.Quality >= ItemQuality.Rare4 && cItem.Quality <= ItemQuality.Rare6 && (isEquipment || cItem.TrinityItemBaseType == GItemBaseType.FollowerItem))
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (force salvage rare)", cItem.RealName, cItem.InternalName, tItemType);
return(false);
}
if (cItem.Quality >= ItemQuality.Legendary)
{
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep legendaries)", cItem.RealName, cItem.InternalName, tItemType);
}
return(true);
}
// Ok now try to do some decent item scoring based on item types
double iNeedScore = Trinity.ScoreNeeded(item.ItemBaseType);
double iMyScore = ItemValuation.ValueThisItem(cItem, tItemType);
if (evaluationType == ItemEvaluationType.Keep)
{
Logger.Log(TrinityLogLevel.Verbose, LogCategory.ItemValuation, "{0} [{1}] [{2}] = {3}", cItem.RealName, cItem.InternalName, tItemType, iMyScore);
}
if (iMyScore >= iNeedScore)
{
return(true);
}
// If we reached this point, then we found no reason to keep the item!
return(false);
}
internal static bool ShouldSellItem(CachedACDItem cItem)
{
return TrinityItemManager.TrinitySell(cItem);
}
public static async Task <bool> CleanTask()
{
try
{
if (!ZetaDia.IsInGame)
{
return(false);
}
if (ZetaDia.IsLoadingWorld)
{
return(false);
}
if (!ZetaDia.Me.IsFullyValid())
{
return(false);
}
if (ZetaDia.Me.IsParticipatingInTieredLootRun)
{
Logger.LogNormal("Cannot clean stash while in trial/greater rift");
RemoveBehavior("Cannot clean stash while in trial/greater rift");
return(false);
}
if (TrinityItemManager.FindValidBackpackLocation(true) == new Vector2(-1, -1))
{
Trinity.ForceVendorRunASAP = true;
return(false);
}
if (!await TrinityCoroutines.Common.ReturnToStashTask())
{
_isFinished = true;
return(false);
}
if (GameUI.IsElementVisible(GameUI.StashDialogMainPage))
{
Logger.Log("Cleaning stash...");
foreach (var item in ZetaDia.Me.Inventory.StashItems.Where(i => i.ACDGuid != 0 && i.IsValid).ToList())
{
CachedACDItem cItem = CachedACDItem.GetCachedItem(item);
// Don't take potions from the stash
if (cItem.TrinityItemType == TrinityItemType.HealthPotion)
{
continue;
}
try
{
if (!ItemManager.Current.ShouldStashItem(item))
{
Logger.Log("Removing {0} from stash", item.Name);
ZetaDia.Me.Inventory.QuickWithdraw(item);
await Coroutine.Sleep(ItemMovementDelay);
await Coroutine.Yield();
if (TrinityItemManager.FindValidBackpackLocation(true) == new Vector2(-1, -1))
{
Trinity.ForceVendorRunASAP = true;
return(false);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
}
_isFinished = true;
Trinity.ForceVendorRunASAP = true;
Logger.Log("Waiting 5 seconds...");
BotMain.StatusText = "Waiting 5 seconds...";
await Coroutine.Sleep(5000);
if (TrinityCoroutines.Common.StartedOutOfTown && ZetaDia.IsInTown)
{
await CommonBehaviors.TakeTownPortalBack().ExecuteCoroutine();
}
}
if (_isFinished)
{
RemoveBehavior("finished!");
}
return(true);
}
catch (Exception ex)
{
_isFinished = true;
Logger.LogError(ex.ToString());
return(false);
}
}
