/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal static bool ItemRulesPickupValidation(PickupItem item)
{
if (StashRule == null)
StashRule = new Interpreter();
Interpreter.InterpreterAction action = StashRule.checkPickUpItem(item, ItemEvaluationType.PickUp);
switch (action)
{
case Interpreter.InterpreterAction.PICKUP:
return true;
case Interpreter.InterpreterAction.IGNORE:
return false;
}
// TODO: remove if tested
if (item.Quality > ItemQuality.Superior)
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "Item Rules doesn't handle {0} of type {1} and quality {2}!", item.Name, item.DBItemType, item.Quality);
return PickupItemValidation(item);
}
internal void AppendDroppedItem(PickupItem item)
{
bool pickupItem;
CacheData.PickupItem.TryGetValue(item.RActorGUID, out pickupItem);
StringBuilder sb = new StringBuilder();
sb.Append(FormatCSVField(item.ActorSNO));
sb.Append(FormatCSVField(item.BalanceID));
sb.Append(FormatCSVField(item.Name));
sb.Append(FormatCSVField(item.InternalName));
sb.Append(FormatCSVField(item.DBBaseType.ToString()));
sb.Append(FormatCSVField(item.DBItemType.ToString()));
sb.Append(FormatCSVField(item.TBaseType.ToString()));
sb.Append(FormatCSVField(item.TType.ToString()));
sb.Append(FormatCSVField(item.Quality.ToString()));
sb.Append(FormatCSVField(item.Level));
sb.Append(FormatCSVField(pickupItem));
sb.Append("\n");
_logItemQueue.Enqueue(sb.ToString());
}
internal void AppendDroppedItem(PickupItem item)
{
bool pickupItem;
CacheData.PickupItem.TryGetValue(item.RActorGUID, out pickupItem);
StringBuilder sb = new StringBuilder();
sb.Append(FormatCSVField(item.ActorSNO));
sb.Append(FormatCSVField(item.BalanceID));
sb.Append(FormatCSVField(item.Name));
sb.Append(FormatCSVField(item.InternalName));
sb.Append(FormatCSVField(item.DBBaseType.ToString()));
sb.Append(FormatCSVField(item.DBItemType.ToString()));
sb.Append(FormatCSVField(item.TBaseType.ToString()));
sb.Append(FormatCSVField(item.TType.ToString()));
sb.Append(FormatCSVField(item.Quality.ToString()));
sb.Append(FormatCSVField(item.Level));
sb.Append(FormatCSVField(pickupItem));
sb.Append("\n");
_logItemQueue.Enqueue(sb.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="level"></param>
/// <param name="itemQuality"></param>
/// <param name="itemBaseType"></param>
/// <param name="itemType"></param>
/// <param name="isOneHand"></param>
/// <param name="isTwoHand"></param>
/// <param name="gameBalanceId"></param>
private void fillPickupDic(PickupItem item)
{
object result;
itemDic = new Dictionary<string, object>();
// add log unique key
itemDic.Add("[KEY]", item.DynamicID.ToString());
// - BASETYPE ---------------------------------------------------------//
itemDic.Add("[BASETYPE]", item.DBBaseType.ToString());
// - TYPE -------------------------------------------------------------//
/// TODO remove this check if it isnt necessary anymore
if (item.DBItemType == ItemType.Unknown && (item.Name.Contains("Plan") || item.Name.Contains("Design")))
{
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "There are still buggy itemType infos for craftingPlan around {0} has itemType = {1}", item.Name, item.DBItemType);
result = ItemType.CraftingPlan.ToString();
}
else result = item.DBItemType.ToString();
itemDic.Add("[TYPE]", result);
// - QUALITY -------------------------------------------------------//
itemDic.Add("[QUALITY]", Regex.Replace(item.Quality.ToString(), @"[\d-]", string.Empty));
itemDic.Add("[D3QUALITY]", item.Quality.ToString());
// - ROLL ----------------------------------------------------------//
float roll;
if (float.TryParse(Regex.Replace(item.Quality.ToString(), @"[^\d]", string.Empty), out roll))
itemDic.Add("[ROLL]", roll);
else
itemDic.Add("[ROLL]", 0f);
// - NAME -------------------------------------------------------------//
itemDic.Add("[NAME]", item.Name.ToString().Replace(" ", ""));
// - LEVEL ------------------------------------------------------------//
itemDic.Add("[LEVEL]", (float)item.Level);
itemDic.Add("[ONEHAND]", item.IsOneHand);
itemDic.Add("[TWOHAND]", item.IsTwoHand);
itemDic.Add("[UNIDENT]", (bool)true);
itemDic.Add("[INTNAME]", item.InternalName);
itemDic.Add("[ITEMID]", item.BalanceID.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkPickUpItem(PickupItem item, ItemEvaluationType evaluationType)
{
fillPickupDic(item);
return checkItem(evaluationType);
}
public virtual bool Equals(PickupItem other)
{
return(DynamicID == other.DynamicID || GetHashCode() == other.GetHashCode());
}
private static bool RefreshItem()
{
using (new PerformanceLogger("RefreshItem"))
{
bool logNewItem;
bool AddToCache;
var diaItem = c_diaObject as DiaItem;
if (diaItem == null)
return false;
if (diaItem.CommonData == null)
return false;
if (!diaItem.IsValid)
return false;
if (!diaItem.CommonData.IsValid)
return false;
c_ItemQuality = diaItem.CommonData.ItemQualityLevel;
((DiaItem)c_diaObject).CommonData.GetAttribute<int>(ActorAttributeType.ItemQualityLevelIdentified);
c_ItemDisplayName = diaItem.CommonData.Name;
CurrentCacheObject.DynamicID = c_diaObject.CommonData.DynamicId;
CurrentCacheObject.GameBalanceID = c_diaObject.CommonData.GameBalanceId;
c_ItemLevel = diaItem.CommonData.Level;
c_DBItemBaseType = diaItem.CommonData.ItemBaseType;
c_DBItemType = diaItem.CommonData.ItemType;
c_IsOneHandedItem = diaItem.CommonData.IsOneHand;
c_IsTwoHandedItem = diaItem.CommonData.IsTwoHand;
c_item_tFollowerType = diaItem.CommonData.FollowerSpecialType;
// Calculate item type
if(_cItemTinityItemType == TrinityItemType.Unknown)
_cItemTinityItemType = TrinityItemManager.DetermineItemType(CurrentCacheObject.InternalName, c_DBItemType, c_item_tFollowerType);
// And temporarily store the base type
TrinityItemBaseType itemBaseType = TrinityItemManager.DetermineBaseType(_cItemTinityItemType);
// Compute item quality from item link
if (!CacheData.ItemLinkQuality.TryGetValue(CurrentCacheObject.ACDGuid, out c_ItemQuality))
{
c_ItemQuality = diaItem.CommonData.GetItemQuality();
CacheData.ItemLinkQuality.Add(CurrentCacheObject.ACDGuid, c_ItemQuality);
}
if (itemBaseType == TrinityItemBaseType.Gem)
c_ItemLevel = (int)diaItem.CommonData.GemQuality;
CurrentCacheObject.ObjectHash = HashGenerator.GenerateItemHash(
CurrentCacheObject.Position,
CurrentCacheObject.ActorSNO,
CurrentCacheObject.InternalName,
Player.WorldID,
c_ItemQuality,
c_ItemLevel);
try
{
c_IsAncient = c_ItemQuality == ItemQuality.Legendary && diaItem.CommonData.GetAttribute<int>(ActorAttributeType.AncientRank) > 0;
}
catch {}
float range = 0f;
// no range check on Legendaries
if (c_ItemQuality < ItemQuality.Legendary || _cItemTinityItemType == TrinityItemType.ProgressionGlobe || _cItemTinityItemType == TrinityItemType.HoradricRelic)
{
if (c_ItemQuality >= ItemQuality.Rare4)
range = CurrentBotLootRange;
if (_keepLootRadiusExtendedForSeconds > 0)
range += 90f;
if (CurrentCacheObject.Distance > (CurrentBotLootRange + range))
{
c_IgnoreSubStep = "OutOfRange";
// return here to save CPU on reading unncessary attributes for out of range items;
return false;
}
}
var pickupItem = new PickupItem
{
Name = c_ItemDisplayName,
InternalName = CurrentCacheObject.InternalName,
Level = c_ItemLevel,
Quality = c_ItemQuality,
BalanceID = CurrentCacheObject.GameBalanceID,
DBBaseType = c_DBItemBaseType,
DBItemType = c_DBItemType,
TBaseType = itemBaseType,
TType = _cItemTinityItemType,
IsOneHand = c_IsOneHandedItem,
IsTwoHand = c_IsTwoHandedItem,
ItemFollowerType = c_item_tFollowerType,
DynamicID = CurrentCacheObject.DynamicID,
Position = CurrentCacheObject.Position,
ActorSNO = CurrentCacheObject.ActorSNO,
ACDGuid = CurrentCacheObject.ACDGuid,
RActorGUID = CurrentCacheObject.RActorGuid,
};
// Blood Shards == HoradricRelic
if (_cItemTinityItemType == TrinityItemType.HoradricRelic && ZetaDia.CPlayer.BloodshardCount >= Player.MaxBloodShards)
{
return false;
}
// Treat all globes as a yes
if (_cItemTinityItemType == TrinityItemType.HealthGlobe)
{
CurrentCacheObject.Type = TrinityObjectType.HealthGlobe;
return true;
}
// Treat all globes as a yes
if (_cItemTinityItemType == TrinityItemType.PowerGlobe)
{
CurrentCacheObject.Type = TrinityObjectType.PowerGlobe;
return true;
}
// Treat all globes as a yes
if (_cItemTinityItemType == TrinityItemType.ProgressionGlobe)
{
CurrentCacheObject.Type = TrinityObjectType.ProgressionGlobe;
return true;
}
// Item stats
logNewItem = RefreshItemStats(itemBaseType);
// Get whether or not we want this item, cached if possible
if (!CacheData.PickupItem.TryGetValue(CurrentCacheObject.RActorGuid, out AddToCache))
{
if (pickupItem.IsTwoHand && Settings.Loot.Pickup.IgnoreTwoHandedWeapons && c_ItemQuality < ItemQuality.Legendary)
{
AddToCache = false;
}
else if (Settings.Loot.ItemFilterMode == ItemFilterMode.DemonBuddy)
{
AddToCache = ItemManager.Current.ShouldPickUpItem((ACDItem)c_diaObject.CommonData);
}
else if (Settings.Loot.ItemFilterMode == ItemFilterMode.TrinityWithItemRules)
{
AddToCache = TrinityItemManager.ItemRulesPickupValidation(pickupItem);
}
else // Trinity Scoring Only
{
AddToCache = TrinityItemManager.PickupItemValidation(pickupItem);
}
// Pickup low level enabled, and we're a low level
if (!AddToCache && Settings.Loot.Pickup.PickupLowLevel && Player.Level <= 10)
{
AddToCache = TrinityItemManager.PickupItemValidation(pickupItem);
}
// Ignore if item has existed before in this location
if (Settings.Loot.TownRun.DropLegendaryInTown)
{
if (!CacheData.DroppedItems.Any(i => i.Equals(pickupItem)))
{
CacheData.DroppedItems.Add(pickupItem);
AddToCache = true;
}
else
{
Logger.LogDebug("Ignoring Dropped Item = ItemPosition={0} Hashcode={1} DynId={2}", pickupItem.Position, pickupItem.GetHashCode(), pickupItem.DynamicID);
AddToCache = false;
}
}
CacheData.PickupItem.Add(CurrentCacheObject.RActorGuid, AddToCache);
}
if (AddToCache && ForceVendorRunASAP)
c_IgnoreSubStep = "ForcedVendoring";
// Didn't pass pickup rules, so ignore it
if (!AddToCache && c_IgnoreSubStep == String.Empty)
c_IgnoreSubStep = "NoMatchingRule";
if (Settings.Advanced.LogDroppedItems && logNewItem && _cItemTinityItemType != TrinityItemType.HealthGlobe && _cItemTinityItemType != TrinityItemType.HealthPotion && _cItemTinityItemType != TrinityItemType.PowerGlobe && _cItemTinityItemType != TrinityItemType.ProgressionGlobe)
//LogDroppedItem();
ItemDroppedAppender.Instance.AppendDroppedItem(pickupItem);
return AddToCache;
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal static bool PickupItemValidation(PickupItem item)
{
// Calculate item types and base types etc.
GItemType itemType = DetermineItemType(item.InternalName, item.DBItemType, item.ItemFollowerType);
GItemBaseType baseType = DetermineBaseType(itemType);
// Pickup Ramaladni's Gift
if (itemType == GItemType.ConsumableAddSockets)
{
return true;
}
// Tiered Rift Keys
if (itemType == GItemType.TieredLootrunKey)
{
return true;
}
// Pickup Legendary potions
if (itemType == GItemType.HealthPotion && item.Quality >= ItemQuality.Legendary)
{
return true;
}
if (itemType == GItemType.InfernalKey)
{
return Settings.Loot.Pickup.InfernalKeys;
}
// Rift Keystone Fragments == LootRunkey
if (itemType == GItemType.LootRunKey)
{
return Settings.Loot.Pickup.LootRunKey;
}
// Blood Shards == HoradricRelic
if (itemType == GItemType.HoradricRelic && ZetaDia.CPlayer.BloodshardCount < 500)
{
return Settings.Loot.Pickup.BloodShards;
}
if (itemType == GItemType.CraftingMaterial && (item.ACDItem.GetTrinityItemQuality() < Settings.Loot.Pickup.MiscItemQuality || !Settings.Loot.Pickup.CraftMaterials))
{
return false;
}
// Plans
if (item.InternalName.ToLower().StartsWith("craftingplan_smith") && (item.ACDItem.GetTrinityItemQuality() < Settings.Loot.Pickup.MiscItemQuality || !Settings.Loot.Pickup.Plans))
{
return false;
}
// Designs
if (item.InternalName.ToLower().StartsWith("craftingplan_jeweler") && (item.ACDItem.GetTrinityItemQuality() < Settings.Loot.Pickup.MiscItemQuality || !Settings.Loot.Pickup.Designs))
{
return false;
}
// Always pickup Legendary plans
if (itemType == GItemType.CraftingPlan && item.Quality >= ItemQuality.Legendary && Settings.Loot.Pickup.LegendaryPlans)
{
return true;
}
// If it's legendary, we always want it *IF* it's level is right
if (item.Quality >= ItemQuality.Legendary)
{
return (Settings.Loot.Pickup.LegendaryLevel > 0 && (item.Level >= Settings.Loot.Pickup.LegendaryLevel || Settings.Loot.Pickup.LegendaryLevel == 1));
}
if (item.IsUpgrade && Settings.Loot.Pickup.PickupUpgrades)
{
return true;
}
switch (baseType)
{
case GItemBaseType.WeaponTwoHand:
case GItemBaseType.WeaponOneHand:
case GItemBaseType.WeaponRange:
return CheckLevelRequirements(item.Level, item.Quality, Settings.Loot.Pickup.WeaponBlueLevel, Settings.Loot.Pickup.WeaponYellowLevel);
case GItemBaseType.Armor:
case GItemBaseType.Offhand:
return CheckLevelRequirements(item.Level, item.Quality, Settings.Loot.Pickup.ArmorBlueLevel, Settings.Loot.Pickup.ArmorYellowLevel);
case GItemBaseType.Jewelry:
return CheckLevelRequirements(item.Level, item.Quality, Settings.Loot.Pickup.JewelryBlueLevel, Settings.Loot.Pickup.JewelryYellowLevel);
case GItemBaseType.FollowerItem:
if (item.Quality >= ItemQuality.Legendary)
{
return true;
}
if (item.Quality >= ItemQuality.Magic1 && item.Quality <= ItemQuality.Magic3 && Settings.Loot.Pickup.PickupBlueFollowerItems)
return true;
if (item.Quality >= ItemQuality.Rare4 && item.Quality <= ItemQuality.Rare6 && Settings.Loot.Pickup.PickupYellowFollowerItems)
return true;
// not matched above, ignore it
return false;
case GItemBaseType.Gem:
if (item.Level < Settings.Loot.Pickup.GemLevel ||
(itemType == GItemType.Ruby && !Settings.Loot.Pickup.GemType.HasFlag(TrinityGemType.Ruby)) ||
(itemType == GItemType.Emerald && !Settings.Loot.Pickup.GemType.HasFlag(TrinityGemType.Emerald)) ||
(itemType == GItemType.Amethyst && !Settings.Loot.Pickup.GemType.HasFlag(TrinityGemType.Amethyst)) ||
(itemType == GItemType.Topaz && !Settings.Loot.Pickup.GemType.HasFlag(TrinityGemType.Topaz)) ||
(itemType == GItemType.Diamond && !Settings.Loot.Pickup.GemType.HasFlag(TrinityGemType.Diamond)))
{
return false;
}
break;
case GItemBaseType.Misc:
// Potion filtering
if (itemType == GItemType.HealthPotion && item.Quality < ItemQuality.Legendary)
{
int potionsInBackPack = ZetaDia.Me.Inventory.Backpack.Where(p => p.ItemType == ItemType.Potion).Sum(p => p.ItemStackQuantity);
if (potionsInBackPack >= Settings.Loot.Pickup.PotionCount)
return false;
else
return true;
}
break;
case GItemBaseType.HealthGlobe:
return true;
case GItemBaseType.ProgressionGlobe:
return true;
case GItemBaseType.Unknown:
return false;
default:
return false;
}
// Didn't cancel it, so default to true!
return true;
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal static bool IdentifyItemValidation(PickupItem item)
{
if (Trinity.Settings.Loot.TownRun.KeepLegendaryUnid)
return false;
else
return true;
}
internal static bool ItemRulesIdentifyValidation(ACDItem item)
{
ItemEvents.ResetTownRun();
PickupItem pickupItem = new PickupItem(
item.Name,
item.InternalName,
item.Level,
item.ItemQualityLevel,
item.GameBalanceId,
item.ItemBaseType,
item.ItemType,
item.IsOneHand,
item.IsTwoHand,
item.FollowerSpecialType,
item.ACDGuid,
item.DynamicId);
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation,
"Incoming Identification Request: {0}, {1}, {2}, {3}, {4}",
pickupItem.Quality, pickupItem.Level, pickupItem.DBBaseType,
pickupItem.DBItemType, pickupItem.IsOneHand ? "1H" : pickupItem.IsTwoHand ? "2H" : "NH");
if (Trinity.StashRule != null)
{
// using ItemEvaluationType.Identify isn't available so we are abusing Sell for that manner
Interpreter.InterpreterAction action = Trinity.StashRule.checkPickUpItem(pickupItem, ItemEvaluationType.Sell);
Logger.Log(TrinityLogLevel.Debug, LogCategory.ItemValuation, "Action is: {0}", action);
switch (action)
{
case Interpreter.InterpreterAction.IDENTIFY:
return true;
case Interpreter.InterpreterAction.UNIDENT:
return false;
default:
Logger.Log(TrinityLogLevel.Info, LogCategory.ScriptRule, "Trinity, item is unhandled by ItemRules (Identification)!");
return IdentifyItemValidation(pickupItem);
}
}
else
return IdentifyItemValidation(pickupItem);
}
public virtual bool Equals(PickupItem other)
{
return DynamicID == other.DynamicID || GetHashCode() == other.GetHashCode();
}
