private bool ItemRulesSalvageSell(ACDItem item, ItemEvaluationType evaluationType)
{
ItemEvents.ResetTownRun();
if (!item.IsPotion)
{
Logger.Log(TrinityLogLevel.Info, LogCategory.ItemValuation,
"Incoming {0} Request: {1}, {2}, {3}, {4}, {5}",
evaluationType, item.ItemQualityLevel, item.Level, item.ItemBaseType,
item.ItemType, item.IsOneHand ? "1H" : item.IsTwoHand ? "2H" : "NH");
}
Interpreter.InterpreterAction action = Trinity.StashRule.checkItem(item, ItemEvaluationType.Salvage);
switch (action)
{
case Interpreter.InterpreterAction.SALVAGE:
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0}: {1}", evaluationType, (evaluationType == ItemEvaluationType.Salvage));
return(evaluationType == ItemEvaluationType.Salvage);
case Interpreter.InterpreterAction.SELL:
Logger.Log(TrinityLogLevel.Info, LogCategory.UserInformation, "{0}: {1}", evaluationType, (evaluationType == ItemEvaluationType.Sell));
return(evaluationType == ItemEvaluationType.Sell);
default:
Logger.Log(TrinityLogLevel.Info, LogCategory.ScriptRule, "Trinity, item is unhandled by ItemRules (SalvageSell)!");
switch (evaluationType)
{
case ItemEvaluationType.Salvage:
return(TrinitySalvage(item));
default:
return(TrinitySell(item));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkItem(ACDItem item, ItemEvaluationType evaluationType)
{
try
{
fillDic(item);
return(checkItem(evaluationType));
}
catch (Exception ex)
{
Logger.Log("Exception in checkItem: {0} item: {1}/{2} eval type: {3}", ex, item.Name, item.InternalName, evaluationType);
switch (evaluationType)
{
case ItemEvaluationType.Keep:
return(InterpreterAction.KEEP);
case ItemEvaluationType.PickUp:
return(InterpreterAction.PICKUP);
case ItemEvaluationType.Salvage:
return(InterpreterAction.KEEP);
case ItemEvaluationType.Sell:
return(InterpreterAction.KEEP);
default:
return(InterpreterAction.NULL);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InterpreterAction checkItem(ACDItem item, ItemEvaluationType evaluationType)
{
try
{
fillDic(item);
return(checkItem(evaluationType));
}
catch (Exception ex)
{
FunkyTownRunPlugin.DBLog.InfoFormat("Exception in checkItem: {0} item: {1} eval type: {2}", ex, item.InternalName, evaluationType);
switch (evaluationType)
{
case ItemEvaluationType.Keep:
return(InterpreterAction.KEEP);
case ItemEvaluationType.PickUp:
return(InterpreterAction.PICKUP);
case ItemEvaluationType.Salvage:
return(InterpreterAction.KEEP);
case ItemEvaluationType.Sell:
return(InterpreterAction.KEEP);
default:
return(InterpreterAction.NULL);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="pickUp"></param>
/// <param name="validRule"></param>
/// <param name="action"></param>
private void logOut(ItemEvaluationType evaluationType, string validRule, InterpreterAction action)
{
// return if we have a evaluationtype sell or salvage
if (evaluationType == ItemEvaluationType.Salvage || evaluationType == ItemEvaluationType.Sell)
{
return;
}
string logString = getFullItem() + validRule;
TrinityItemQuality quality = getTrinityItemQualityFromString(itemDic["[QUALITY]"]);
switch (action)
{
case InterpreterAction.PICKUP:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.IGNORE:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.KEEP:
if (quality >= logKeepQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.TRASH:
if (quality >= logKeepQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.SCORE:
if (quality >= logKeepQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.NULL:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
}
}
public bool ShouldDrop(TrinityItem item, ItemEvaluationType scheduledAction)
{
if (item.IsProtected() || item.IsAccountBound)
{
return(false);
}
if (item.IsGem || item.IsCraftingReagent || item.TrinityItemType == TrinityItemType.CraftingPlan)
{
return(false);
}
if (!item.IsUnidentified && (item.IsPotion || item.RawItemType == RawItemType.GeneralUtility || item.IsMiscItem))
{
return(false);
}
if (item.ItemQualityLevel >= ItemQuality.Legendary)
{
if (Core.Settings.Items.DropInTownMode == DropInTownOption.All)
{
Core.Logger.Verbose($"Should Drop {item.Name} - Setting='{Core.Settings.Items.DropInTownMode}'");
return(true);
}
switch (scheduledAction)
{
case ItemEvaluationType.Keep:
if (Core.Settings.Items.DropInTownMode == DropInTownOption.Keep)
{
Core.Logger.Verbose($"Should Drop {item.Name} - Setting='{Core.Settings.Items.DropInTownMode}' and item is scheduled for {scheduledAction}");
return(true);
}
break;
case ItemEvaluationType.Salvage:
case ItemEvaluationType.Sell:
if (Core.Settings.Items.DropInTownMode == DropInTownOption.Vendor)
{
Core.Logger.Verbose($"Should Drop {item.Name} - Setting='{Core.Settings.Items.DropInTownMode}' and item is scheduled for {scheduledAction}");
return(true);
}
break;
}
}
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);
}
}
public bool ShouldSellItem(ACDItem item, ItemEvaluationType evaluationType)
{
GilesCachedACDItem cItem = GilesCachedACDItem.GetCachedItem(item);
//if (ShouldStashItem(item, evaluationType))
// return false;
//if (ShouldSalvageItem(item, evaluationType))
// return false;
if (ItemManager.Current.ItemIsProtected(cItem.AcdItem))
{
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.CraftingPlan)
{
return(true);
}
else
{
return(false);
}
case GItemBaseType.Unknown:
return(false);
}
// Switch giles base item type
return(false);
}
public bool ShouldSalvageItem(ACDItem item, ItemEvaluationType evaluationType)
{
ItemEvents.ResetTownRun();
if (Current.ItemIsProtected(item))
{
return(false);
}
if (Trinity.Settings.Loot.ItemFilterMode == ItemFilterMode.DemonBuddy)
{
return(Current.ShouldSalvageItem(item));
}
if (Trinity.Settings.Loot.ItemFilterMode == ItemFilterMode.TrinityWithItemRules)
{
return(ItemRulesSalvageSell(item, evaluationType));
}
return(TrinitySalvage(item));
}
public override bool EvaluateItem(ACDItem item, ItemEvaluationType evaluationType)
{
if (Trinity.Settings.Loot.ItemFilterMode != ItemFilterMode.DemonBuddy)
{
Current.EvaluateItem(item, evaluationType);
}
else
{
switch (evaluationType)
{
case ItemEvaluationType.Keep:
return(ShouldStashItem(item));
case ItemEvaluationType.Salvage:
return(ShouldSalvageItem(item));
case ItemEvaluationType.Sell:
return(ShouldSellItem(item));
}
}
return(false);
}
/// <summary>
///
/// </summary>
public InterpreterAction checkPickUpItem(int dynamicID, ItemType itemtype, string name, string internalname, ItemQuality quality, int level, bool onehanded, bool twohanded, int balanceid, ItemEvaluationType evaluationType)
{
fillPickupDic(dynamicID, itemtype, name, internalname, quality, level, onehanded, twohanded, balanceid);
return(checkItem(evaluationType));
}
/// <summary>
///
/// </summary>
/// <param name="pickUp"></param>
/// <param name="validRule"></param>
/// <param name="action"></param>
private void logOut(ItemEvaluationType evaluationType, string validRule, InterpreterAction action)
{
string logString = getFullItem() + validRule;
TrinityItemQuality quality = TrinityItemQuality.Unknown;
if (itemDic.ContainsKey("[QUALITY]"))
quality = getTrinityItemQualityFromString(itemDic["[QUALITY]"]);
switch (action)
{
case InterpreterAction.PICKUP:
if (quality >= logPickQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.IGNORE:
if (quality >= logPickQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.IDENTIFY:
//if (quality >= logPickQuality)
// logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.UNIDENT:
if (quality >= logPickQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.KEEP:
if (quality >= logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.TRASH:
if (quality >= logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.SCORE:
if (quality >= logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.SALVAGE:
//if (quality >= logKeepQuality)
// logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.SELL:
//if (quality >= logKeepQuality)
// logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.NULL:
if (quality >= logPickQuality)
logOut(logString, action, LogType.LOG);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkPickUpItem(PickupItem item, ItemEvaluationType evaluationType)
{
fillPickupDic(item);
return(checkItem(evaluationType));
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkItem(ACDItem item, ItemEvaluationType evaluationType)
{
try
{
fillDic(item);
return checkItem(evaluationType);
}
catch (Exception ex)
{
Logger.Log("Exception in checkItem: {0} item: {1}/{2} eval type: {3}", ex, item.Name, item.InternalName, evaluationType);
switch (evaluationType)
{
case ItemEvaluationType.Keep:
return InterpreterAction.KEEP;
case ItemEvaluationType.PickUp:
return InterpreterAction.PICKUP;
case ItemEvaluationType.Salvage:
return InterpreterAction.KEEP;
case ItemEvaluationType.Sell:
return InterpreterAction.KEEP;
default:
return InterpreterAction.NULL;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InterpreterAction checkItem(ItemEvaluationType evaluationType)
{
InterpreterAction action = InterpreterAction.NULL;
InterpreterAction defaultAction = InterpreterAction.NULL;
string validRule = "";
ArrayList rules = null;
switch (evaluationType)
{
case ItemEvaluationType.PickUp:
defaultAction = InterpreterAction.PICKUP;
rules = pickUpRuleSet;
break;
case ItemEvaluationType.Sell:
defaultAction = InterpreterAction.IDENTIFY;
rules = identifyRuleSet;
break;
case ItemEvaluationType.Keep:
defaultAction = InterpreterAction.KEEP;
rules = keepRuleSet;
break;
case ItemEvaluationType.Salvage:
defaultAction = InterpreterAction.SALVAGE;
rules = salvageSellRuleSet;
break;
default:
defaultAction = InterpreterAction.NULL;
rules = null;
break;
}
foreach (string str in rules)
{
ParseErrors parseErrors = null;
InterpreterAction tempAction = defaultAction;
string[] strings = str.Split(new string[] { assign }, StringSplitOptions.None);
if (strings.Count() > 1)
tempAction = getInterpreterAction(strings[1]);
try
{
if (evaluate(strings[0], out parseErrors))
{
validRule = str;
action = tempAction;
if (parseErrors.Count > 0)
logOut("Have errors with out a catch!"
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem(), InterpreterAction.NULL, LogType.ERROR);
break;
}
}
catch (Exception e)
{
logOut(e.Message
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem()
+ SEP + e.ToString()
, InterpreterAction.NULL, LogType.ERROR);
}
if (parseErrors != null && parseErrors.Count > 0)
{
if (parseErrors.Count > 0)
logOut("Have errors in rule! "
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem(), InterpreterAction.NULL, LogType.ERROR);
}
}
logOut(evaluationType, validRule, action);
return action;
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InterpreterAction checkItem(ItemEvaluationType evaluationType)
{
InterpreterAction action = InterpreterAction.NULL;
string validRule = "";
ArrayList rules;
if (evaluationType == ItemEvaluationType.PickUp)
{
rules = pickUpRuleSet;
}
else
{
rules = ruleSet;
}
foreach (string str in rules)
{
ParseErrors parseErrors = null;
// default configuration for positive rules is pickup and keep
InterpreterAction tempAction;
if (evaluationType == ItemEvaluationType.PickUp)
{
tempAction = InterpreterAction.PICKUP;
}
else
{
tempAction = InterpreterAction.KEEP;
}
string[] strings = str.Split(new string[] { assign }, StringSplitOptions.None);
if (strings.Count() > 1)
{
tempAction = getInterpreterAction(strings[1]);
}
try
{
if (evaluate(strings[0], out parseErrors))
{
validRule = str;
action = tempAction;
if (parseErrors.Count > 0)
{
logOut("Have errors with out a catch!"
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem(), InterpreterAction.NULL, LogType.ERROR);
}
break;
}
} catch (Exception e)
{
logOut(e.Message
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem(), InterpreterAction.NULL, LogType.ERROR);
}
}
logOut(evaluationType, validRule, action);
return(action);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkPickUpItem(PickupItem item, ItemEvaluationType evaluationType)
{
fillPickupDic(item);
return checkItem(evaluationType);
}
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);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkItem(ACDItem item, ItemEvaluationType evaluationType)
{
fillDic(item);
return(checkItem(evaluationType));
}
public override bool EvaluateItem(ACDItem item, ItemEvaluationType evaluationType) => false;
/// <summary>
///
/// </summary>
public InterpreterAction checkPickUpItem(int dynamicID, ItemType itemtype, string name, string internalname, ItemQuality quality, int level, bool onehanded, bool twohanded, int balanceid, ItemEvaluationType evaluationType)
{
fillPickupDic(dynamicID,itemtype,name,internalname,quality,level,onehanded,twohanded,balanceid);
return checkItem(evaluationType);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InterpreterAction checkItem(ItemEvaluationType evaluationType)
{
InterpreterAction action=InterpreterAction.NULL;
string validRule="";
ArrayList rules;
if (evaluationType==ItemEvaluationType.PickUp) rules=pickUpRuleSet;
else rules=ruleSet;
foreach (string str in rules)
{
ParseErrors parseErrors=null;
// default configuration for positive rules is pickup and keep
InterpreterAction tempAction;
if (evaluationType==ItemEvaluationType.PickUp) tempAction=InterpreterAction.PICKUP;
else tempAction=InterpreterAction.KEEP;
string[] strings=str.Split(new string[] { assign }, StringSplitOptions.None);
if (strings.Count()>1)
tempAction=getInterpreterAction(strings[1]);
try
{
if (evaluate(strings[0], out parseErrors))
{
validRule=str;
action=tempAction;
if (parseErrors.Count>0)
logOut("Have errors with out a catch!"
+SEP+"last use rule: "+str
+SEP+getParseErrors(parseErrors)
+SEP+getFullItem(), InterpreterAction.NULL, LogType.ERROR);
break;
}
} catch (Exception e)
{
logOut(e.Message
+SEP+"last use rule: "+str
+SEP+getParseErrors(parseErrors)
+SEP+getFullItem(), InterpreterAction.NULL, LogType.ERROR);
}
}
logOut(evaluationType, validRule, action);
return action;
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InterpreterAction checkItem(ItemEvaluationType evaluationType)
{
InterpreterAction action = InterpreterAction.NULL;
InterpreterAction defaultAction = InterpreterAction.NULL;
string validRule = "";
ArrayList rules = null;
switch (evaluationType)
{
case ItemEvaluationType.PickUp:
defaultAction = InterpreterAction.PICKUP;
rules = pickUpRuleSet;
break;
case ItemEvaluationType.Sell:
defaultAction = InterpreterAction.IDENTIFY;
rules = identifyRuleSet;
break;
case ItemEvaluationType.Keep:
defaultAction = InterpreterAction.KEEP;
rules = keepRuleSet;
break;
case ItemEvaluationType.Salvage:
defaultAction = InterpreterAction.SALVAGE;
rules = salvageSellRuleSet;
break;
default:
defaultAction = InterpreterAction.NULL;
rules = null;
break;
}
foreach (string str in rules)
{
ParseErrors parseErrors = null;
InterpreterAction tempAction = defaultAction;
string[] strings = str.Split(new string[] { assign }, StringSplitOptions.None);
if (strings.Count() > 1)
{
tempAction = getInterpreterAction(strings[1]);
}
try
{
if (evaluate(strings[0], out parseErrors))
{
validRule = str;
action = tempAction;
if (parseErrors.Count > 0)
{
logOut("Have errors with out a catch!"
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem(), InterpreterAction.NULL, LogType.ERROR);
}
break;
}
}
catch (Exception e)
{
logOut(e.Message
+ SEP + "last use rule: " + str
+ SEP + getParseErrors(parseErrors)
+ SEP + getFullItem()
+ SEP + e.ToString()
, InterpreterAction.NULL, LogType.ERROR);
}
}
logOut(evaluationType, validRule, action);
return(action);
}
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);
}
/// <summary>
///
/// </summary>
/// <param name="pickUp"></param>
/// <param name="validRule"></param>
/// <param name="action"></param>
private void logOut(ItemEvaluationType evaluationType, string validRule, InterpreterAction action)
{
// return if we have a evaluationtype sell or salvage
if (evaluationType==ItemEvaluationType.Salvage||evaluationType==ItemEvaluationType.Sell)
return;
string logString=getFullItem()+validRule;
TrinityItemQuality quality=getTrinityItemQualityFromString(itemDic["[QUALITY]"]);
switch (action)
{
case InterpreterAction.PICKUP:
if (quality>=logPickQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.IGNORE:
if (quality>=logPickQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.KEEP:
if (quality>=logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.TRASH:
if (quality>=logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.SCORE:
if (quality>=logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.SALVAGE:
if (quality>=logKeepQuality)
logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.NULL:
if (quality>=logPickQuality)
logOut(logString, action, LogType.LOG);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
internal InterpreterAction checkItem(ACDItem item, ItemEvaluationType evaluationType)
{
fillDic(item);
return checkItem(evaluationType);
}
/// <summary>
///
/// </summary>
/// <param name="pickUp"></param>
/// <param name="validRule"></param>
/// <param name="action"></param>
private void logOut(ItemEvaluationType evaluationType, string validRule, InterpreterAction action)
{
string logString = getFullItem() + validRule;
TrinityItemQuality quality = TrinityItemQuality.Unknown;
if (itemDic.ContainsKey("[QUALITY]"))
{
quality = getTrinityItemQualityFromString(itemDic["[QUALITY]"]);
}
switch (action)
{
case InterpreterAction.PICKUP:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.IGNORE:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.IDENTIFY:
//if (quality >= logPickQuality)
// logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.UNIDENT:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.KEEP:
if (quality >= logKeepQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.TRASH:
if (quality >= logKeepQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.SCORE:
if (quality >= logKeepQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
case InterpreterAction.SALVAGE:
//if (quality >= logKeepQuality)
// logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.SELL:
//if (quality >= logKeepQuality)
// logOut(logString, action, LogType.LOG);
break;
case InterpreterAction.NULL:
if (quality >= logPickQuality)
{
logOut(logString, action, LogType.LOG);
}
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public InterpreterAction checkItem(ACDItem item, ItemEvaluationType evaluationType)
{
try
{
fillDic(item);
return checkItem(evaluationType);
}
catch (Exception ex)
{
FunkyTownRunPlugin.DBLog.InfoFormat("Exception in checkItem: {0} item: {1} eval type: {2}", ex, item.InternalName, evaluationType);
switch (evaluationType)
{
case ItemEvaluationType.Keep:
return InterpreterAction.KEEP;
case ItemEvaluationType.PickUp:
return InterpreterAction.PICKUP;
case ItemEvaluationType.Salvage:
return InterpreterAction.KEEP;
case ItemEvaluationType.Sell:
return InterpreterAction.KEEP;
default:
return InterpreterAction.NULL;
}
}
}
