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); } }