/// <summary>
/// DetermineBaseType - Calculates a more generic, "basic" type of item
/// </summary>
/// <param name="itemType"></param>
/// <returns></returns>
internal static GItemBaseType DetermineBaseType(GItemType itemType)
{
GItemBaseType baseType = GItemBaseType.Unknown;
if (itemType == GItemType.Axe || itemType == GItemType.CeremonialKnife || itemType == GItemType.Dagger ||
itemType == GItemType.FistWeapon || itemType == GItemType.Mace || itemType == GItemType.MightyWeapon ||
itemType == GItemType.Spear || itemType == GItemType.Sword || itemType == GItemType.Wand)
{
baseType = GItemBaseType.WeaponOneHand;
}
else if (itemType == GItemType.TwoHandDaibo || itemType == GItemType.TwoHandMace ||
itemType == GItemType.TwoHandMighty || itemType == GItemType.TwoHandPolearm || itemType == GItemType.TwoHandStaff ||
itemType == GItemType.TwoHandSword || itemType == GItemType.TwoHandAxe)
{
baseType = GItemBaseType.WeaponTwoHand;
}
else if (itemType == GItemType.TwoHandCrossbow || itemType == GItemType.HandCrossbow || itemType == GItemType.TwoHandBow)
{
baseType = GItemBaseType.WeaponRange;
}
else if (itemType == GItemType.Mojo || itemType == GItemType.Orb ||
itemType == GItemType.Quiver || itemType == GItemType.Shield)
{
baseType = GItemBaseType.Offhand;
}
else if (itemType == GItemType.Boots || itemType == GItemType.Bracer || itemType == GItemType.Chest ||
itemType == GItemType.Cloak || itemType == GItemType.Gloves || itemType == GItemType.Helm ||
itemType == GItemType.Legs || itemType == GItemType.Shoulder || itemType == GItemType.SpiritStone ||
itemType == GItemType.VoodooMask || itemType == GItemType.WizardHat || itemType == GItemType.Belt ||
itemType == GItemType.MightyBelt)
{
baseType = GItemBaseType.Armor;
}
else if (itemType == GItemType.Amulet || itemType == GItemType.Ring)
{
baseType = GItemBaseType.Jewelry;
}
else if (itemType == GItemType.FollowerEnchantress || itemType == GItemType.FollowerScoundrel ||
itemType == GItemType.FollowerTemplar)
{
baseType = GItemBaseType.FollowerItem;
}
else if (itemType == GItemType.CraftingMaterial || itemType == GItemType.CraftTome ||
itemType == GItemType.SpecialItem || itemType == GItemType.CraftingPlan || itemType == GItemType.HealthPotion ||
itemType == GItemType.Dye || itemType == GItemType.StaffOfHerding || itemType == GItemType.InfernalKey)
{
baseType = GItemBaseType.Misc;
}
else if (itemType == GItemType.Ruby || itemType == GItemType.Emerald || itemType == GItemType.Topaz ||
itemType == GItemType.Amethyst)
{
baseType = GItemBaseType.Gem;
}
else if (itemType == GItemType.HealthGlobe)
{
baseType = GItemBaseType.HealthGlobe;
}
return(baseType);
}
/// <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 bool ShouldSalvageItem(ACDItem item, ItemEvaluationType evaluationType)
{
if (ItemManager.Current.ItemIsProtected(item))
{
return(false);
}
//if (ShouldStashItem(item, evaluationType))
// return false;
GilesCachedACDItem cItem = GilesCachedACDItem.GetCachedItem(item);
GItemType trinityItemType = GilesTrinity.DetermineItemType(cItem.InternalName, cItem.DBItemType, cItem.FollowerType);
GItemBaseType trinityItemBaseType = GilesTrinity.DetermineBaseType(trinityItemType);
// Take Salvage Option corresponding to ItemLevel
SalvageOption salvageOption = GetSalvageOption(cItem.Quality);
if (cItem.Quality >= ItemQuality.Legendary && salvageOption == SalvageOption.InfernoOnly && cItem.Level >= 60)
{
return(true);
}
switch (trinityItemBaseType)
{
case GItemBaseType.WeaponRange:
case GItemBaseType.WeaponOneHand:
case GItemBaseType.WeaponTwoHand:
case GItemBaseType.Armor:
case GItemBaseType.Offhand:
return((cItem.Level >= 61 && salvageOption == SalvageOption.InfernoOnly) || salvageOption == SalvageOption.All);
case GItemBaseType.Jewelry:
return((cItem.Level >= 59 && salvageOption == SalvageOption.InfernoOnly) || salvageOption == SalvageOption.All);
case GItemBaseType.FollowerItem:
return((cItem.Level >= 60 && salvageOption == SalvageOption.InfernoOnly) || salvageOption == SalvageOption.All);
case GItemBaseType.Gem:
case GItemBaseType.Misc:
case GItemBaseType.Unknown:
return(false);
default:
return(false);
}
}
/// <summary>
/// Log the rubbish junk items we salvaged or sold
/// </summary>
internal static void LogJunkItems(CachedACDItem acdItem, GItemBaseType itemBaseType, GItemType itemType, double itemValue)
{
FileStream LogStream = null;
try
{
string filePath = Path.Combine(FileManager.LoggingPath, "JunkLog - " + Trinity.Player.ActorClass.ToString() + ".log");
LogStream = File.Open(filePath, FileMode.Append, FileAccess.Write, FileShare.Read);
using (StreamWriter LogWriter = new StreamWriter(LogStream))
{
if (!_loggedJunkThisStash)
{
_loggedJunkThisStash = true;
LogWriter.WriteLine(DateTime.Now.ToString() + ":");
LogWriter.WriteLine("====================");
}
string isLegendaryItem = "";
if (acdItem.Quality >= ItemQuality.Legendary)
{
isLegendaryItem = " {legendary item}";
}
LogWriter.WriteLine(itemBaseType.ToString() + " - " + itemType.ToString() + " '" + 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();
}
}
}
private static bool RefreshItemStats(GItemBaseType tempbasetype)
{
bool isNewLogItem = false;
c_ItemMd5Hash = HashGenerator.GenerateItemHash(CurrentCacheObject.Position, CurrentCacheObject.ActorSNO, CurrentCacheObject.InternalName, CurrentWorldDynamicId, c_ItemQuality, c_ItemLevel);
if (!GenericCache.ContainsKey(c_ItemMd5Hash))
{
GenericCache.AddToCache(new GenericCacheObject(c_ItemMd5Hash, null, new TimeSpan(1, 0, 0)));
try
{
isNewLogItem = true;
if (tempbasetype == GItemBaseType.Armor || tempbasetype == GItemBaseType.WeaponOneHand || tempbasetype == GItemBaseType.WeaponTwoHand ||
tempbasetype == GItemBaseType.WeaponRange || tempbasetype == GItemBaseType.Jewelry || tempbasetype == GItemBaseType.FollowerItem ||
tempbasetype == GItemBaseType.Offhand)
{
try
{
int iThisQuality;
ItemsDroppedStats.Total++;
if (c_ItemQuality >= ItemQuality.Legendary)
{
iThisQuality = QUALITYORANGE;
}
else if (c_ItemQuality >= ItemQuality.Rare4)
{
iThisQuality = QUALITYYELLOW;
}
else if (c_ItemQuality >= ItemQuality.Magic1)
{
iThisQuality = QUALITYBLUE;
}
else
{
iThisQuality = QUALITYWHITE;
}
ItemsDroppedStats.TotalPerQuality[iThisQuality]++;
ItemsDroppedStats.TotalPerLevel[c_ItemLevel]++;
ItemsDroppedStats.TotalPerQPerL[iThisQuality, c_ItemLevel]++;
}
catch (Exception ex)
{
Logger.LogError("Error Refreshing Item Stats for Equippable Item: " + ex.ToString());
}
}
else if (tempbasetype == GItemBaseType.Gem)
{
try
{
int iThisGemType = 0;
ItemsDroppedStats.TotalGems++;
if (c_item_GItemType == GItemType.Topaz)
{
iThisGemType = GEMTOPAZ;
}
if (c_item_GItemType == GItemType.Ruby)
{
iThisGemType = GEMRUBY;
}
if (c_item_GItemType == GItemType.Emerald)
{
iThisGemType = GEMEMERALD;
}
if (c_item_GItemType == GItemType.Amethyst)
{
iThisGemType = GEMAMETHYST;
}
if (c_item_GItemType == GItemType.Diamond)
{
iThisGemType = GEMDIAMOND;
}
ItemsDroppedStats.GemsPerType[iThisGemType]++;
ItemsDroppedStats.GemsPerLevel[c_ItemLevel]++;
ItemsDroppedStats.GemsPerTPerL[iThisGemType, c_ItemLevel]++;
}
catch (Exception ex)
{
Logger.LogError("Error refreshing item stats for Gem: " + ex.ToString());
}
}
else if (c_item_GItemType == GItemType.InfernalKey)
{
try
{
ItemsDroppedStats.TotalInfernalKeys++;
}
catch (Exception ex)
{
Logger.LogError("Error refreshing item stats for InfernalKey: " + ex.ToString());
}
}
// See if we should update the stats file
if (DateTime.UtcNow.Subtract(ItemStatsLastPostedReport).TotalSeconds > 10)
{
try
{
ItemStatsLastPostedReport = DateTime.UtcNow;
OutputReport();
}
catch (Exception ex)
{
Logger.LogError("Error Calling OutputReport from RefreshItemStats " + ex.ToString());
}
}
}
catch (Exception ex)
{
Logger.LogError("Couldn't do Item Stats" + ex.ToString());
}
}
return(isNewLogItem);
}
private static bool RefreshItemStats(GItemBaseType tempbasetype)
{
bool isNewLogItem = false;
c_ItemMd5Hash = HashGenerator.GenerateItemHash(c_Position, c_ActorSNO, c_InternalName, CurrentWorldDynamicId, c_ItemQuality, c_ItemLevel);
if (!GenericCache.ContainsKey(c_ItemMd5Hash))
{
GenericCache.AddToCache(new GenericCacheObject(c_ItemMd5Hash, null, new TimeSpan(1, 0, 0)));
isNewLogItem = true;
if (tempbasetype == GItemBaseType.Armor || tempbasetype == GItemBaseType.WeaponOneHand || tempbasetype == GItemBaseType.WeaponTwoHand ||
tempbasetype == GItemBaseType.WeaponRange || tempbasetype == GItemBaseType.Jewelry || tempbasetype == GItemBaseType.FollowerItem ||
tempbasetype == GItemBaseType.Offhand)
{
int iThisQuality;
ItemsDroppedStats.Total++;
if (c_ItemQuality >= ItemQuality.Legendary)
{
iThisQuality = QUALITYORANGE;
}
else if (c_ItemQuality >= ItemQuality.Rare4)
{
iThisQuality = QUALITYYELLOW;
}
else if (c_ItemQuality >= ItemQuality.Magic1)
{
iThisQuality = QUALITYBLUE;
}
else
{
iThisQuality = QUALITYWHITE;
}
ItemsDroppedStats.TotalPerQuality[iThisQuality]++;
ItemsDroppedStats.TotalPerLevel[c_ItemLevel]++;
ItemsDroppedStats.TotalPerQPerL[iThisQuality, c_ItemLevel]++;
}
else if (tempbasetype == GItemBaseType.Gem)
{
int iThisGemType = 0;
ItemsDroppedStats.TotalGems++;
if (c_item_GItemType == GItemType.Topaz)
{
iThisGemType = GEMTOPAZ;
}
if (c_item_GItemType == GItemType.Ruby)
{
iThisGemType = GEMRUBY;
}
if (c_item_GItemType == GItemType.Emerald)
{
iThisGemType = GEMEMERALD;
}
if (c_item_GItemType == GItemType.Amethyst)
{
iThisGemType = GEMAMETHYST;
}
ItemsDroppedStats.GemsPerType[iThisGemType]++;
ItemsDroppedStats.GemsPerLevel[c_ItemLevel]++;
ItemsDroppedStats.GemsPerTPerL[iThisGemType, c_ItemLevel]++;
}
else if (c_item_GItemType == GItemType.HealthPotion)
{
ItemsDroppedStats.TotalPotions++;
ItemsDroppedStats.PotionsPerLevel[c_ItemLevel]++;
}
else if (c_item_GItemType == GItemType.InfernalKey)
{
ItemsDroppedStats.TotalInfernalKeys++;
}
// See if we should update the stats file
if (DateTime.Now.Subtract(ItemStatsLastPostedReport).TotalSeconds > 10)
{
ItemStatsLastPostedReport = DateTime.Now;
OutputReport();
}
}
return(isNewLogItem);
}
/// <summary>
/// Checks if score of item is suffisant for throw notification.
/// </summary>
public static bool CheckScoreForNotification(GItemBaseType itemBaseType, double itemValue)
{
switch (itemBaseType)
{
case GItemBaseType.WeaponOneHand:
case GItemBaseType.WeaponRange:
case GItemBaseType.WeaponTwoHand:
return (itemValue >= Settings.Notification.WeaponScore);
case GItemBaseType.Armor:
case GItemBaseType.Offhand:
return (itemValue >= Settings.Notification.ArmorScore);
case GItemBaseType.Jewelry:
return (itemValue >= Settings.Notification.JewelryScore);
}
return false;
}
/// <summary>
/// Log the nice items we found and stashed
/// </summary>
internal static void LogGoodItems(CachedACDItem acdItem, GItemBaseType itemBaseType, GItemType itemType, double itemValue)
{
FileStream LogStream = null;
try
{
string filePath = Path.Combine(FileManager.LoggingPath, "StashLog - " + Trinity.Player.ActorClass.ToString() + ".log");
LogStream = File.Open(filePath, FileMode.Append, FileAccess.Write, FileShare.Read);
//TODO : Change File Log writing
using (StreamWriter LogWriter = new StreamWriter(LogStream))
{
if (!_loggedAnythingThisStash)
{
_loggedAnythingThisStash = true;
LogWriter.WriteLine(DateTime.Now.ToString() + ":");
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 && Trinity.CheckScoreForNotification(itemBaseType, itemValue))
{
shouldSendNotifications = true;
}
if (shouldSendNotifications)
{
NotificationManager.AddNotificationToQueue(acdItem.RealName + " [" + itemType.ToString() +
"] (Score=" + itemValue.ToString() + ". " + ValueItemStatString + ")",
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}", ValueItemStatString);
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+");
}
else
{
// Check for non-legendary notifications
shouldSendNotifications = Trinity.CheckScoreForNotification(itemBaseType, itemValue);
if (shouldSendNotifications)
{
NotificationManager.AddNotificationToQueue(acdItem.RealName + " [" + itemType.ToString() + "] (Score=" + itemValue.ToString() + ". " + ValueItemStatString + ")", ZetaDia.Service.Hero.Name + " new item!", ProwlNotificationPriority.Emergency);
}
}
if (shouldSendNotifications)
{
NotificationManager.EmailMessage.AppendLine(itemBaseType.ToString() + " - " + itemType.ToString() + " '" + acdItem.RealName + "'. Score = " + Math.Round(itemValue).ToString() + sLegendaryString)
.AppendLine(" " + ValueItemStatString)
.AppendLine();
}
LogWriter.WriteLine(itemBaseType.ToString() + " - " + itemType.ToString() + " '" + acdItem.RealName + "'. Score = " + Math.Round(itemValue).ToString() + sLegendaryString);
LogWriter.WriteLine(" " + ValueItemStatString);
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();
}
}
}
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);
}
public bool ShouldStashItem(ACDItem item, ItemEvaluationType evaluationType)
{
if (ItemManager.Current.ItemIsProtected(item))
{
return(false);
}
GilesCachedACDItem cItem = GilesCachedACDItem.GetCachedItem(item);
// Now look for Misc items we might want to keep
GItemType trinityItemType = cItem.TrinityItemType; // DetermineItemType(cItem.InternalName, cItem.DBItemType, cItem.FollowerType);
GItemBaseType trinityBaseType = cItem.TrinityItemBaseType; // DetermineBaseType(trinityItemType);
if (trinityItemType == GItemType.StaffOfHerding)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep staff of herding)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.CraftingMaterial)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep craft materials)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.Emerald)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep gems)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.Amethyst)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep gems)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.Topaz)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep gems)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.Ruby)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep gems)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.CraftTome)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (autokeep tomes)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.InfernalKey)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep infernal key)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.HealthPotion)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.ItemValuation, "{0} [{1}] [{2}] = (ignoring potions)", cItem.RealName, cItem.InternalName, trinityItemType);
}
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)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.UserInformation, "{0} [{1}] = (autokeep unidentified items)", cItem.RealName, cItem.InternalName);
}
return(true);
}
if (GilesTrinity.Settings.Loot.ItemFilterMode == ItemFilterMode.TrinityWithItemRules)
{
Interpreter.InterpreterAction action = GilesTrinity.StashRule.checkItem(item, evaluationType);
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, 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;
}
}
// auto trash blue weapons/armor/jewlery
if ((item.ItemBaseType == ItemBaseType.Armor ||
item.ItemBaseType == ItemBaseType.Weapon ||
item.ItemBaseType == ItemBaseType.Jewelry) &&
item.ItemQualityLevel < ItemQuality.Rare4)
{
return(false);
}
if (cItem.Quality >= ItemQuality.Legendary)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep legendaries)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
if (trinityItemType == GItemType.CraftingPlan)
{
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Normal, LogCategory.UserInformation, "{0} [{1}] [{2}] = (autokeep plans)", cItem.RealName, cItem.InternalName, trinityItemType);
}
return(true);
}
// Ok now try to do some decent item scoring based on item types
double iNeedScore = GilesTrinity.ScoreNeeded(item.ItemBaseType);
double iMyScore = ItemValuation.ValueThisItem(cItem, trinityItemType);
if (evaluationType == ItemEvaluationType.Keep)
{
DbHelper.Log(TrinityLogLevel.Verbose, LogCategory.ItemValuation, "{0} [{1}] [{2}] = {3}", cItem.RealName, cItem.InternalName, trinityItemType, iMyScore);
}
if (iMyScore >= iNeedScore)
{
return(true);
}
// If we reached this point, then we found no reason to keep the item!
return(false);
}
private static bool RefreshGilesItem()
{
bool logNewItem = false;
bool AddToCache = false;
if (c_BalanceID == -1)
{
AddToCache = false;
c_IgnoreSubStep = "InvalidBalanceID";
}
DiaItem item = c_diaObject as DiaItem;
c_ItemQuality = item.CommonData.ItemQualityLevel;
// Ignore it if it's not in range yet - allow legendary items to have 15 feet extra beyond our profile max loot radius
float fExtraRange = 0f;
if (iKeepLootRadiusExtendedFor > 0)
{
fExtraRange = 90f;
}
if (c_ItemQuality >= ItemQuality.Rare4)
{
fExtraRange = CurrentBotLootRange;
}
if (c_ItemQuality >= ItemQuality.Legendary)
{
// always pickup
AddToCache = true;
}
if (c_CentreDistance > (CurrentBotLootRange + fExtraRange) && c_ItemQuality <= ItemQuality.Legendary)
{
c_IgnoreSubStep = "OutOfRange";
AddToCache = false;
// return here to save CPU on reading unncessary attributes for out of range items;
if (!AddToCache)
{
return(AddToCache);
}
}
c_ItemDisplayName = item.CommonData.Name;
c_GameBalanceID = item.CommonData.GameBalanceId;
c_ItemLevel = item.CommonData.Level;
c_DBItemBaseType = item.CommonData.ItemBaseType;
c_DBItemType = item.CommonData.ItemType;
c_IsOneHandedItem = item.CommonData.IsOneHand;
c_IsTwoHandedItem = item.CommonData.IsTwoHand;
c_item_tFollowerType = item.CommonData.FollowerSpecialType;
PickupItem pickupItem = new PickupItem()
{
Name = c_ItemDisplayName,
InternalName = c_InternalName,
Level = c_ItemLevel,
Quality = c_ItemQuality,
BalanceID = c_BalanceID,
DBBaseType = c_DBItemBaseType,
DBItemType = c_DBItemType,
IsOneHand = c_IsOneHandedItem,
IsTwoHand = c_IsTwoHandedItem,
ItemFollowerType = c_item_tFollowerType,
DynamicID = c_GameDynamicID,
Position = c_Position,
ActorSNO = c_ActorSNO
};
// Calculate custom Giles item type
c_item_GItemType = DetermineItemType(c_InternalName, c_DBItemType, c_item_tFollowerType);
// And temporarily store the base type
GItemBaseType itemBaseType = DetermineBaseType(c_item_GItemType);
// Treat all globes as a yes
if (c_item_GItemType == GItemType.HealthGlobe)
{
c_ObjectType = GObjectType.Globe;
// Create or alter this cached object type
dictGilesObjectTypeCache[c_RActorGuid] = c_ObjectType;
AddToCache = true;
}
// Item stats
logNewItem = RefreshItemStats(itemBaseType);
// Get whether or not we want this item, cached if possible
if (!dictGilesPickupItem.TryGetValue(c_RActorGuid, out AddToCache))
{
if (Settings.Loot.ItemFilterMode == global::GilesTrinity.Settings.Loot.ItemFilterMode.DemonBuddy)
{
AddToCache = ItemManager.Current.ShouldPickUpItem((ACDItem)c_CommonData);
}
else if (Settings.Loot.ItemFilterMode == global::GilesTrinity.Settings.Loot.ItemFilterMode.TrinityWithItemRules)
{
AddToCache = ItemRulesPickupValidation(pickupItem);
}
else
{
AddToCache = GilesPickupItemValidation(pickupItem);
}
dictGilesPickupItem.Add(c_RActorGuid, AddToCache);
}
// Using DB built-in item rules
if (AddToCache && ForceVendorRunASAP)
{
c_IgnoreSubStep = "ForcedVendoring";
}
if (!AddToCache)
{
// Check if there's a monster intersecting the path-line to this item
AddToCache = MosterObstacleInPathCacheObject(AddToCache);
}
// Didn't pass pickup rules, so ignore it
if (!AddToCache && c_IgnoreSubStep == String.Empty)
{
c_IgnoreSubStep = "NoMatchingRule";
}
if (Settings.Advanced.LogDroppedItems && logNewItem && c_DBItemType != ItemType.Unknown)
{
LogDroppedItem();
}
return(AddToCache);
}
/// <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();
}
