internal static void LogJunkItems(CacheACDItem thisgooditem, PluginBaseItemTypes thisPluginBaseItemTypes, PluginItemTypes thisPluginItemType)
{
FileStream LogStream = null;
string outputPath = FolderPaths.LoggingFolderPath + @"\JunkLog.log";
try
{
LogStream = File.Open(outputPath, FileMode.Append, FileAccess.Write, FileShare.Read);
using (StreamWriter LogWriter = new StreamWriter(LogStream))
{
if (!TownRunManager.bLoggedJunkThisStash)
{
TownRunManager.bLoggedJunkThisStash = true;
LogWriter.WriteLine(DateTime.Now.ToString() + ":");
LogWriter.WriteLine("====================");
}
string sLegendaryString = "";
if (thisgooditem.ThisQuality >= ItemQuality.Legendary)
{
sLegendaryString = " {legendary item}";
}
LogWriter.WriteLine(thisgooditem.ThisQuality.ToString() + " " + thisPluginItemType.ToString() + " '" + thisgooditem.ThisRealName + sLegendaryString);
LogWriter.Write(thisgooditem.ItemStatProperties.ReturnPrimaryStatString());
LogWriter.WriteLine("");
}
}
catch (IOException)
{
DBLog.Info("Fatal Error: File access error for junk log file.");
}
}
public DebugItemDataEntry(CacheACDItem item)
{
SNOID = item.SNO;
Name = FormatString(item.ThisRealName);
Type = item.ItemType;
Quality = (PluginItemQuality)Enum.Parse(typeof(PluginItemQuality), item.ThisQuality.ToString());
}
public static RunStatus InteractionClickBehavior(object ret)
{
if (FunkyGame.GameIsInvalid)
{
Logger.DBLog.InfoFormat("[Funky] Town Run Behavior Failed! (Not In Game/Invalid Actor/misc)");
return(RunStatus.Failure);
}
if (!UIElements.InventoryWindow.IsVisible)
{
Backpack.InventoryBackPackToggle(true);
return(RunStatus.Running);
}
//Interact with items..
if (InteractItems.Count > 0)
{
if (!TownRunItemLoopsTest(2.5))
{
return(RunStatus.Running);
}
CacheACDItem thisitem = InteractItems.FirstOrDefault();
if (thisitem != null)
{
ZetaDia.Me.Inventory.UseItem(thisitem.ThisDynamicID);
if (thisitem.ItemType == PluginItemTypes.HoradricCache && FunkyGame.CurrentStats != null)
{
//Bot.Game.CurrentGameStats.CurrentProfile.HoradricCacheOpened++;
FunkyGame.CurrentStats.CurrentProfile.HoradricCacheOpened++;
}
}
if (thisitem != null)
{
InteractItems.Remove(thisitem);
}
if (InteractItems.Count > 0)
{
return(RunStatus.Running);
}
}
//Add a long wait after interaction!
if (!TownRunItemLoopsTest(10))
{
return(RunStatus.Running);
}
//Reset so we can loot!
FunkyGame.Targeting.Cache.bFailedToLootLastItem = false;
Logger.DBLog.Info("Interaction Town Run Clicky Finished.");
return(RunStatus.Success);
}
public void CheckEntry(CacheACDItem entry)
{
var d = new DebugItemDataEntry(entry);
if (ItemsData.Entries.Contains(d))
{
return;
}
ItemsData.Entries.Add(d);
DebugData_Items.SerializeToXML(ItemsData);
}
public void SalvagedItemLog(CacheACDItem i)
{
if (i.ThisQuality == ItemQuality.Legendary)
{
Legendary.Salvaged++;
}
else if (i.ThisQuality > ItemQuality.Magic3)
{
Rare.Salvaged++;
}
else
{
Magical.Salvaged++;
}
}
private static void LogSalvagedItem(CacheACDItem item)
{
// Item log for cool stuff stashed
PluginItemTypes OriginalGilesItemType = ItemFunc.DetermineItemType(item);
PluginBaseItemTypes thisGilesBaseType = ItemFunc.DetermineBaseType(OriginalGilesItemType);
if (thisGilesBaseType == PluginBaseItemTypes.WeaponTwoHand || thisGilesBaseType == PluginBaseItemTypes.WeaponOneHand || thisGilesBaseType == PluginBaseItemTypes.WeaponRange ||
thisGilesBaseType == PluginBaseItemTypes.Armor || thisGilesBaseType == PluginBaseItemTypes.Jewelry || thisGilesBaseType == PluginBaseItemTypes.Offhand ||
thisGilesBaseType == PluginBaseItemTypes.FollowerItem)
{
FunkyTownRunPlugin.LogJunkItems(item, thisGilesBaseType, OriginalGilesItemType);
}
if (FunkyGame.CurrentStats != null)
{
FunkyGame.CurrentStats.CurrentProfile.LootTracker.SalvagedItemLog(item);
}
}
internal static bool SalvageValidation(CacheACDItem thisitem)
{
if (!thisitem.IsSalvagable)
{
return(false);
}
//Only Check items we can actually salvage!
if (thisitem.BaseItemType == PluginBaseItemTypes.FollowerItem || thisitem.BaseItemType == PluginBaseItemTypes.Armor ||
thisitem.BaseItemType == PluginBaseItemTypes.Jewelry || thisitem.BaseItemType == PluginBaseItemTypes.Offhand ||
thisitem.BaseItemType == PluginBaseItemTypes.WeaponOneHand || thisitem.BaseItemType == PluginBaseItemTypes.WeaponRange ||
thisitem.BaseItemType == PluginBaseItemTypes.WeaponTwoHand)
{
if (thisitem.ThisQuality == ItemQuality.Legendary)
{
if (FunkyTownRunPlugin.PluginSettings.SalvageLegendaryItemLevel > 0)
{
return(FunkyTownRunPlugin.PluginSettings.SalvageLegendaryItemLevel <= thisitem.ThisLevel);
}
}
else if (thisitem.ThisQuality == ItemQuality.Rare4 || thisitem.ThisQuality == ItemQuality.Rare5 || thisitem.ThisQuality == ItemQuality.Rare6)
{
if (FunkyTownRunPlugin.PluginSettings.SalvageRareItemLevel > 0)
{
return(FunkyTownRunPlugin.PluginSettings.SalvageRareItemLevel <= thisitem.ThisLevel);
}
}
else if (thisitem.ThisQuality == ItemQuality.Magic1 || thisitem.ThisQuality == ItemQuality.Magic2 || thisitem.ThisQuality == ItemQuality.Magic3)
{
if (FunkyTownRunPlugin.PluginSettings.SalvageMagicItemLevel > 0)
{
return(FunkyTownRunPlugin.PluginSettings.SalvageMagicItemLevel <= thisitem.ThisLevel);
}
}
else if (thisitem.ThisQuality == ItemQuality.Superior || thisitem.ThisQuality == ItemQuality.Inferior || thisitem.ThisQuality == ItemQuality.Normal)
{
if (FunkyTownRunPlugin.PluginSettings.SalvageWhiteItemLevel > 0)
{
return(FunkyTownRunPlugin.PluginSettings.SalvageWhiteItemLevel <= thisitem.ThisLevel);
}
}
}
// If we reached this point, then we found no reason to keep the item!
return(false);
}
private List <CacheACDItem> GetGemCacheACDItems()
{
List <CacheACDItem> Gems = new List <CacheACDItem>();
foreach (var gem in ZetaDia.Actors.GetActorsOfType <ACDItem>().Where(item => item.ItemType == ItemType.LegendaryGem))
{
var cItem = new CacheACDItem(gem);
//double SuccessRate = ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, cItem.LegendaryGemRank);
if (GRiftLevel - cItem.LegendaryGemRank == -7)
{
continue;
}
//if (SuccessRate < FunkyBaseExtension.Settings.AdventureMode.GemUpgradingMinimumSuccessRate) continue;
Gems.Add(new CacheACDItem(gem));
}
return(Gems);
}
public void SalvagedItemLog(CacheACDItem i)
{
if (i.ThisQuality == ItemQuality.Legendary)
{
//Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[3]++;
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Legendary.Salvaged++;
}
else if (i.ThisQuality > ItemQuality.Magic3)
{
// Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[2]++;
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Rare.Salvaged++;
}
else
{
// Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[1]++;
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Magical.Salvaged++;
}
}
private void btnRefreshCharacterInventory_Click(object sender, EventArgs e)
{
if (BotMain.IsRunning)
{
return;
}
cacheItems.Clear();
flowLayout_OutPut.Controls.Clear();
try
{
using (ZetaDia.Memory.SaveCacheState())
{
ZetaDia.Memory.DisableCache();
ZetaDia.Actors.Update();
flowLayout_OutPut.Controls.Add(new UserControlDebugEntry(
String.Format("Total Items Found {0}", ZetaDia.Me.Inventory.Backpack.Count())));
#region Character Inventory Items
foreach (var o in ZetaDia.Me.Inventory.Backpack)
{
try
{
CacheACDItem item = new CacheACDItem(o);
flowLayout_OutPut.Controls.Add(new UserControlDebugEntry(item.ToString()));
}
catch (Exception ex)
{
flowLayout_OutPut.Controls.Add(new UserControlDebugEntry(ex.Message));
}
}
#endregion
}
}
catch (Exception ex)
{
}
flowLayout_OutPut.Focus();
}
private static List <CacheACDItem> ReturnCurrentEquippedItems()
{
var returnItems = new List <CacheACDItem>();
try
{
using (ZetaDia.Memory.AcquireFrame())
{
ZetaDia.Actors.Update();
foreach (ACDItem item in ZetaDia.Me.Inventory.Equipped)
{
var thiscacheditem = new CacheACDItem(item);
returnItems.Add(thiscacheditem);
}
}
}
catch (Exception)
{
}
return(returnItems);
}
private List <CacheACDItem> GetGemCacheACDItems(List <int> Acdguids)
{
List <CacheACDItem> GemList = new List <CacheACDItem>();
foreach (var item in ZetaDia.Actors.GetActorsOfType <ACDItem>().Where(item => Acdguids.Contains(item.ACDGuid)))
{
CacheACDItem cItem = new CacheACDItem(item);
double SuccessRate = ItemFunc.GetLegendaryGemUpgradeChance(GRiftLevel, cItem.LegendaryGemRank);
if (GRiftLevel - cItem.LegendaryGemRank == -7)
{
continue;
}
if (SuccessRate < FunkyBaseExtension.Settings.AdventureMode.GemUpgradingMinimumSuccessRate)
{
continue;
}
//if (SuccessRate < FunkyBaseExtension.Settings.AdventureMode.GemUpgradingMinimumSuccessRate) continue;
GemList.Add(cItem);
}
return(GemList);
}
internal static void LogJunkItems(CacheACDItem thisgooditem, GilesBaseItemType thisgilesbaseitemtype, GilesItemType thisgilesitemtype, double ithisitemvalue)
{
FileStream LogStream = null;
try
{
LogStream = File.Open(LoggingFolderPath + LoggingPrefixString + " -- JunkLog.log", FileMode.Append, FileAccess.Write, FileShare.Read);
using (StreamWriter LogWriter = new StreamWriter(LogStream))
{
if (!TownRunManager.bLoggedJunkThisStash)
{
TownRunManager.bLoggedJunkThisStash = true;
LogWriter.WriteLine(DateTime.Now.ToString() + ":");
LogWriter.WriteLine("====================");
}
string sLegendaryString = "";
if (thisgooditem.ThisQuality >= ItemQuality.Legendary)
{
sLegendaryString = " {legendary item}";
}
LogWriter.WriteLine(thisgilesbaseitemtype.ToString() + " - " + thisgilesitemtype.ToString() + " '" + thisgooditem.ThisRealName + "'. Score = " + Math.Round(ithisitemvalue).ToString() + sLegendaryString);
if (!String.IsNullOrEmpty(TownRunManager.sJunkItemStatString))
{
LogWriter.WriteLine(" " + TownRunManager.sJunkItemStatString);
}
else
{
LogWriter.WriteLine(" (no scorable attributes)");
}
LogWriter.WriteLine("");
}
}
catch (IOException)
{
DBLog.Info("Fatal Error: File access error for junk log file.");
}
}
private ACDItem GetKeystoneItem()
{
IEnumerable <ACDItem> itemEnumerableSource = ZetaDia.Me.Inventory.Backpack;
List <CacheACDItem> items = new List <CacheACDItem>();
foreach (var i in itemEnumerableSource)
{
if (i.BaseAddress != IntPtr.Zero)
{
CacheACDItem cacheitem = new CacheACDItem(i);
items.Add(cacheitem);
}
}
if (KeyType == KeystoneType.Tiered)
{
if (!KeyStoneHighest)
{
items = items.OrderBy(i => i.KeystoneRank).ToList();
}
else
{
items = items.OrderByDescending(i => i.KeystoneRank).ToList();
}
}
foreach (var tempitem in items)
{
if (tempitem.ItemType == PluginItemTypes.KeyStone)
{
int tieredLevel = tempitem.KeystoneRank;
if (KeyType == KeystoneType.Fragment)
{
if (tieredLevel == -1)
{
return(tempitem.ACDItem);
}
continue;
}
if (KeyType == KeystoneType.Trial)
{
if (tieredLevel == 0)
{
return(tempitem.ACDItem);
}
continue;
}
if (KeyType == KeystoneType.Tiered)
{
if (tieredLevel > 0 && tieredLevel <= FunkyBaseExtension.Settings.AdventureMode.MaximumTieredRiftKeyAllowed)
{
return(tempitem.ACDItem);
}
}
}
}
return(null);
}
internal static RunStatus SellInteraction(object ret)
{
if (FunkyGame.GameIsInvalid)
{
ActionsChecked = false;
FunkyTownRunPlugin.DBLog.InfoFormat("[Funky] Town Run Behavior Failed! (Not In Game/Invalid Actor/misc)");
return(RunStatus.Failure);
}
BotMain.StatusText = "Town run: Vendor Routine Interaction";
if (!UIElements.VendorWindow.IsVisible)
{
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Town Run Vednor Behavior Failed! (Vendor Window not visible)");
return(RunStatus.Failure);
}
#region SellItem
if (townRunItemCache.SellItems.Count > 0)
{
BotMain.StatusText = "Town run: Vendor Routine Interaction Selling Items";
if (!Delay.Test())
{
return(RunStatus.Running);
}
CacheACDItem thisitem = townRunItemCache.SellItems.FirstOrDefault();
// Item log for cool stuff sold
if (thisitem != null)
{
PluginItemTypes OriginalPluginItemType = ItemFunc.DetermineItemType(thisitem);
PluginBaseItemTypes thisGilesBaseType = ItemFunc.DetermineBaseType(OriginalPluginItemType);
if (thisGilesBaseType == PluginBaseItemTypes.WeaponTwoHand || thisGilesBaseType == PluginBaseItemTypes.WeaponOneHand || thisGilesBaseType == PluginBaseItemTypes.WeaponRange ||
thisGilesBaseType == PluginBaseItemTypes.Armor || thisGilesBaseType == PluginBaseItemTypes.Jewelry || thisGilesBaseType == PluginBaseItemTypes.Offhand ||
thisGilesBaseType == PluginBaseItemTypes.FollowerItem)
{
FunkyTownRunPlugin.LogJunkItems(thisitem, thisGilesBaseType, OriginalPluginItemType);
}
//FunkyTownRunPlugin.TownRunStats.VendoredItemLog(thisitem);
if (FunkyGame.CurrentStats != null)
{
FunkyGame.CurrentStats.CurrentProfile.LootTracker.VendoredItemLog(thisitem);
}
ZetaDia.Me.Inventory.SellItem(thisitem.ACDItem);
}
if (thisitem != null)
{
townRunItemCache.SellItems.Remove(thisitem);
}
if (townRunItemCache.SellItems.Count > 0)
{
return(RunStatus.Running);
}
}
#endregion
#region BuyPotion
//Check if settings for potion buy is enabled, with less than 99 potions existing!
if (bBuyingPotions)
{
BotMain.StatusText = "Town run: Sell Routine Interaction Buying Potions";
if (PotionCount >= FunkyTownRunPlugin.PluginSettings.PotionsCount)
{
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Vendor Potion Buying Finished (Potion Count Greater Than Setting) Count {0} Setting {1}", PotionCount, FunkyTownRunPlugin.PluginSettings.PotionsCount);
bBuyingPotions = false;
return(RunStatus.Running);
}
//Obey the timer, so we don't buy 100 potions in 3 seconds.
if (!Delay.Test(1.5))
{
return(RunStatus.Running);
}
//Update Dynamic ID
if (PotionDynamicID == 0)
{
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Vendor Potion updating Dynamic ID!");
foreach (ACDItem item in ZetaDia.Me.Inventory.MerchantItems)
{
if (item.IsPotion)
{
PotionMerchantACDItem = item;
PotionDynamicID = item.DynamicId;
break;
}
}
//Check we found a potion..
if (PotionDynamicID == 0)
{
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Vendor Potion Buying Finished (Failed to find Potion Dynamic ID)");
bBuyingPotions = false;
}
else
{
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Vendor Buying Potion Dynamic ID {0}", PotionDynamicID);
}
return(RunStatus.Running);
}
//Check we have enough gold!
if (PotionMerchantACDItem.Gold > ZetaDia.CPlayer.Coinage)
{
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Vendor Potion Buying Finished (Not Enough Gold to buy Potions)");
bBuyingPotions = false;
return(RunStatus.Running);
}
FunkyTownRunPlugin.DBLog.DebugFormat("[Funky] Vendor Buying Potion!");
ZetaDia.Actors.Me.Inventory.BuyItem(PotionDynamicID);
//Update counter
PotionCount++;
return(RunStatus.Running);
}
#endregion
if (bNeedsEquipmentRepairs)
{
BotMain.StatusText = "Town run: Vendor Routine Interaction Repairing";
if (!Delay.Test())
{
return(RunStatus.Running);
}
//int playerCoinage = ZetaDia.Me.Inventory.Coinage;
//int repairCost = ZetaDia.Me.Inventory.GetRepairCost(false);
//if (playerCoinage > 0 && playerCoinage < repairCost)
//{
// FunkyTownRunPlugin.DBLog.InfoFormat("Emergency Stop: You need repairs but don't have enough money. Current Coinage {0} -- Repair Cost {1}", playerCoinage, repairCost);
// BotMain.Stop(false, "Not enough gold to repair item(s)!");
//}
ZetaDia.Me.Inventory.RepairEquippedItems();
bNeedsEquipmentRepairs = false;
}
return(RunStatus.Success);
}
} // Custom stashing routine
private bool BackpackStashAttempt(CacheACDItem item, out int[] XY)
{
XY = new[] { -1, -1 };
int iPlayerDynamicID = ZetaDia.Me.CommonData.DynamicId;
int iOriginalGameBalanceId = item.ThisBalanceID;
int iOriginalDynamicID = item.ThisDynamicID;
int iOriginalStackQuantity = (int)item.ThisItemStackQuantity;
string sOriginalItemName = item.ThisRealName;
string sOriginalInternalName = item.ThisInternalName;
PluginItemTypes OriginalPluginItemType = ItemFunc.DetermineItemType(item);
PluginBaseItemTypes thisGilesBaseType = ItemFunc.DetermineBaseType(OriginalPluginItemType);
bool bOriginalTwoSlot = item.IsTwoSlot;
bool bOriginalIsStackable = item.IsStackableItem;
int iAttempts;
if (_dictItemStashAttempted.TryGetValue(iOriginalDynamicID, out iAttempts))
{
Logger.DBLog.InfoFormat("GSError: Detected a duplicate stash attempt, DB item mis-read error, now forcing this item as a 2-slot item");
_dictItemStashAttempted[iOriginalDynamicID] = iAttempts + 1;
bOriginalTwoSlot = true;
bOriginalIsStackable = false;
if (iAttempts > 6)
{
Logger.DBLog.InfoFormat("GSError: Detected an item stash loop risk, now re-mapping stash treating everything as 2-slot and re-attempting");
// Array for what blocks are or are not blocked
for (int iRow = 0; iRow <= 5; iRow++)
{
for (int iColumn = 0; iColumn <= 9; iColumn++)
{
BackpackSlotBlocked[iColumn, iRow] = false;
}
}
// Block off the entire of any "protected stash pages"
foreach (InventorySquare iProtPage in CharacterSettings.Instance.ProtectedBagSlots)
{
BackpackSlotBlocked[iProtPage.Column, iProtPage.Row] = true;
}
// Map out all the items already in the stash
foreach (ACDItem tempitem in ZetaDia.Me.Inventory.Backpack)
{
if (tempitem.BaseAddress != IntPtr.Zero)
{
CacheACDItem tempCacheItem = new CacheACDItem(tempitem);
int inventoryRow = tempCacheItem.invRow;
int inventoryColumn = tempCacheItem.invCol;
// Mark this slot as not-free
BackpackSlotBlocked[inventoryColumn, inventoryRow] = true;
// Try and reliably find out if this is a two slot item or not
//BackpackSlotBlocked[inventoryColumn, inventoryRow + 1] = true;
if (inventoryRow != 5 && tempCacheItem.IsTwoSlot)
{
BackpackSlotBlocked[inventoryColumn, inventoryRow + 1] = true;
}
}
}
}
if (iAttempts > 15)
{
Logger.DBLog.InfoFormat("***************************");
Logger.DBLog.InfoFormat("GSError: Emergency Stop: No matter what we tried, we couldn't prevent an infinite stash loop. Sorry. Now stopping the bot.");
BotMain.Stop();
return(false);
}
}
else
{
_dictItemStashAttempted.Add(iOriginalDynamicID, 1);
}
// Safety incase it's not actually in the backpack anymore
/*if (item.InventorySlot != InventorySlot.PlayerBackpack)
* {
* FunkyTownRunPlugin.DBLog.InfoFormat("GSError: Diablo 3 memory read error, or item became invalid [StashAttempt-4]", true);
* return false;
* }*/
int iLeftoverStackQuantity;
int iPointX = -1;
int iPointY = -1;
// First check if we can top-up any already-existing stacks in the stash
if (bOriginalIsStackable)
{
foreach (ACDItem tempitem in ZetaDia.Me.Inventory.Backpack)
{
if (tempitem.BaseAddress == IntPtr.Zero)
{
Logger.DBLog.InfoFormat("GSError: Diablo 3 memory read error, or stash item became invalid [StashAttempt-5]");
return(false);
}
// Check if we combine the stacks, we won't overfill them
if ((tempitem.GameBalanceId == iOriginalGameBalanceId) && (tempitem.ItemStackQuantity < tempitem.MaxStackCount))
{
iLeftoverStackQuantity = (int)((tempitem.ItemStackQuantity + iOriginalStackQuantity) - tempitem.MaxStackCount);
iPointX = tempitem.InventoryColumn;
iPointY = tempitem.InventoryRow;
// Will we have leftovers?
if (iLeftoverStackQuantity <= 0)
{
goto FoundStashLocation;
}
goto HandleStackMovement;
}
}
HandleStackMovement:
if ((iPointX >= 0) && (iPointY >= 0))
{
ZetaDia.Me.Inventory.MoveItem(iOriginalDynamicID, iPlayerDynamicID, InventorySlot.BackpackItems, iPointX, iPointY);
}
}
iPointX = -1;
iPointY = -1;
// If it's a 2-square item, find a double-slot free
if (bOriginalTwoSlot)
{
for (int iRow = 0; iRow <= 5; iRow++)
{
bool bBottomPageRow = iRow == 5;
for (int iColumn = 0; iColumn <= 9; iColumn++)
{
// If nothing in the 1st row
if (!BackpackSlotBlocked[iColumn, iRow])
{
bool bNotEnoughSpace = false;
// Bottom row of a page = no room
if (bBottomPageRow)
{
bNotEnoughSpace = true;
}
// Already something in the stash in the 2nd row)
else if (BackpackSlotBlocked[iColumn, iRow + 1])
{
bNotEnoughSpace = true;
}
if (!bNotEnoughSpace)
{
iPointX = iColumn;
iPointY = iRow;
goto FoundStashLocation;
}
}
}
}
} // 2 slot item?
// Now deal with any leftover 1-slot items
else
{
// First we try and find somewhere "sensible"
for (int iRow = 0; iRow <= 5; iRow++)
{
bool bTopPageRow = iRow == 0;
bool bBottomPageRow = (iRow == 5);
for (int iColumn = 0; iColumn <= 9; iColumn++)
{
// Nothing in this slot
if (!BackpackSlotBlocked[iColumn, iRow])
{
bool bSensibleLocation = false;
if (!bTopPageRow && !bBottomPageRow)
{
// Something above and below this slot, or an odd-numbered row, so put something here
if ((BackpackSlotBlocked[iColumn, iRow + 1] && BackpackSlotBlocked[iColumn, iRow - 1]) ||
(iRow) % 2 != 0)
{
bSensibleLocation = true;
}
}
// Top page row with something directly underneath already blocking
else if (bTopPageRow)
{
if (BackpackSlotBlocked[iColumn, iRow + 1])
{
bSensibleLocation = true;
}
}
// Bottom page row with something directly over already blocking
else
{
bSensibleLocation = true;
}
// Sensible location? Yay, stash it here!
if (bSensibleLocation)
{
iPointX = iColumn;
iPointY = iRow;
// Keep looking for places if it's a stackable to try to stick it at the end
if (!bOriginalIsStackable)
{
goto FoundStashLocation;
}
}
}
}
}
// Didn't find a "sensible" place, let's try and force it in absolutely anywhere
if ((iPointX < 0) || (iPointY < 0))
{
for (int iRow = 0; iRow <= 5; iRow++)
{
for (int iColumn = 0; iColumn <= 9; iColumn++)
{
// Nothing in this spot, we're good!
if (!BackpackSlotBlocked[iColumn, iRow])
{
iPointX = iColumn;
iPointY = iRow;
// Keep looking for places if it's a stackable to try to stick it at the end
if (!bOriginalIsStackable)
{
goto FoundStashLocation;
}
}
}
}
}
}
FoundStashLocation:
if ((iPointX < 0) || (iPointY < 0))
{
Logger.DBLog.DebugFormat("Fatal Error: No valid stash location found for '" + sOriginalItemName + "' [" + sOriginalInternalName + " - " + OriginalPluginItemType.ToString() + "]");
Logger.DBLog.InfoFormat("***************************");
Logger.DBLog.InfoFormat("GSError: Emergency Stop: You need to stash an item but no valid space could be found. Stash is full? Stopping the bot to prevent infinite town-run loop.");
BotMain.Stop(true, "No Room To Stash!");
//ZetaDia.Service.Party.LeaveGame();
return(false);
}
// We have two valid points that are empty, move the object here!
BackpackSlotBlocked[iPointX, iPointY] = true;
if (bOriginalTwoSlot)
{
BackpackSlotBlocked[iPointX, iPointY + 1] = true;
}
XY = new[] { iPointX, iPointY };
return(true);
} // Custom stashing routine
public override bool GetConditionExec()
{
if (Itemsource == ItemSource.Stash)
{
foreach (ACDItem tempitem in ZetaDia.Me.Inventory.StashItems)
{
if (tempitem.BaseAddress != IntPtr.Zero)
{
CacheACDItem cacheItem = new CacheACDItem(tempitem);
if (cacheItem.ItemType != PluginItemTypes.KeyStone)
{
continue;
}
int tieredLevel = cacheItem.KeystoneRank;
if (Type == KeystoneType.Fragment)
{
if (tieredLevel == -1)
{
return(!NOT);
}
continue;
}
if (Type == KeystoneType.Trial)
{
if (tieredLevel == 0)
{
return(!NOT);
}
continue;
}
if (Type == KeystoneType.Tiered)
{
if (tieredLevel > 0 && tieredLevel <= FunkyBaseExtension.Settings.AdventureMode.MaximumTieredRiftKeyAllowed)
{
return(!NOT);
}
}
}
}
}
else
{
foreach (ACDItem tempitem in ZetaDia.Me.Inventory.Backpack)
{
if (tempitem.BaseAddress != IntPtr.Zero)
{
CacheACDItem cacheItem = new CacheACDItem(tempitem);
if (cacheItem.ItemType != PluginItemTypes.KeyStone)
{
continue;
}
int tieredLevel = cacheItem.KeystoneRank;
if (Type == KeystoneType.Fragment)
{
if (tieredLevel == -1)
{
return(!NOT);
}
continue;
}
if (Type == KeystoneType.Trial)
{
if (tieredLevel == 0)
{
return(!NOT);
}
continue;
}
if (Type == KeystoneType.Tiered)
{
if (tieredLevel > 0 && tieredLevel <= FunkyBaseExtension.Settings.AdventureMode.MaximumTieredRiftKeyAllowed)
{
return(!NOT);
}
}
}
}
}
return(NOT);
}
private void UpdateMovingItemList()
{
Logger.DBLog.DebugFormat("Updating Moving Items!");
IEnumerable <ACDItem> ItemEnumerableSource =
Itemsource == ItemSource.Stash ? ZetaDia.Me.Inventory.StashItems :
ZetaDia.Me.Inventory.Backpack;
List <CacheACDItem> Items = new List <CacheACDItem>();
foreach (var i in ItemEnumerableSource)
{
if (i.BaseAddress != IntPtr.Zero)
{
CacheACDItem cacheItem = new CacheACDItem(i);
Items.Add(cacheItem);
}
}
if (KeyType != KeystoneType.None)
{
if (!_keyStoneHighest)
{
Items = Items.OrderBy(i => i.KeystoneRank).ThenByDescending(i => i.ThisItemStackQuantity).ToList();
}
else
{
Items = Items.OrderByDescending(i => i.KeystoneRank).ThenByDescending(i => i.ThisItemStackQuantity).ToList();
}
}
foreach (var tempitem in Items)
{
if (KeyType != KeystoneType.None)
{
int tieredLevel = tempitem.KeystoneRank;
if (KeyType == KeystoneType.Fragment)
{
if (tieredLevel == -1)
{
MovingItemList.Add(tempitem);
if (!All)
{
break;
}
}
continue;
}
if (KeyType == KeystoneType.Trial)
{
if (tieredLevel == 0)
{
MovingItemList.Add(tempitem);
if (!All)
{
break;
}
}
continue;
}
if (KeyType == KeystoneType.Tiered)
{
if (tieredLevel > 0 && tieredLevel <= FunkyBaseExtension.Settings.AdventureMode.MaximumTieredRiftKeyAllowed)
{
MovingItemList.Add(tempitem);
if (!All)
{
break;
}
}
}
}
else if (tempitem.SNO == Sno)
{
MovingItemList.Add(tempitem);
if (!All)
{
break;
}
}
}
updatedItemList = true;
Logger.DBLog.InfoFormat("Found a total of {0} items to be moved!", MovingItemList.Count);
}
private bool MoveItems()
{
if (MovingItemList.Count > 0)
{
//Logger.DBLog.DebugFormat("Moving Items!");
if (!Delay.Test())
{
return(true);
}
CacheACDItem thisitem = MovingItemList.FirstOrDefault();
if (Itemsource == ItemSource.Backpack)
{
if (LastStashPoint[0] < 0 && LastStashPoint[1] < 0 && LastStashPage < 0)
{
bool bDidStashSucceed = StashAttempt(thisitem, out LastStashPoint, out LastStashPage);
if (!bDidStashSucceed)
{
Logger.DBLog.DebugFormat("There was an unknown error stashing an item.");
//if (OutOfGame.MuleBehavior) return RunStatus.Success;
}
else
{
return(true);
}
}
else
{
//We have a valid place to stash.. so lets check if stash page is currently open
if (ZetaDia.Me.Inventory.CurrentStashPage == LastStashPage)
{
//FunkyTownRunPlugin.TownRunStats.StashedItemLog(thisitem);
ZetaDia.Me.Inventory.MoveItem(thisitem.ThisDynamicID, ZetaDia.Me.CommonData.DynamicId, InventorySlot.SharedStash, LastStashPoint[0], LastStashPoint[1]);
LastStashPoint = new[] { -1, -1 };
LastStashPage = -1;
MovingItemList.Remove(thisitem);
if (MovingItemList.Count > 0)
{
return(true);
}
}
else
{
//Lets switch the current page..
ZetaDia.Me.Inventory.SwitchStashPage(LastStashPage);
return(true);
}
}
}
else
{
if (LastStashPoint[0] < 0 && LastStashPoint[1] < 0)
{
bool bDidStashSucceed = BackpackStashAttempt(thisitem, out LastStashPoint);
if (!bDidStashSucceed)
{
Logger.DBLog.DebugFormat("There was an unknown error stashing an item.");
}
else
{
return(true);
}
}
else
{
ZetaDia.Me.Inventory.MoveItem(thisitem.ThisDynamicID, ZetaDia.Me.CommonData.DynamicId, InventorySlot.BackpackItems, LastStashPoint[0], LastStashPoint[1]);
LastStashPoint = new[] { -1, -1 };
MovingItemList.Remove(thisitem);
if (MovingItemList.Count > 0)
{
return(true);
}
}
}
}
m_IsDone = true;
return(false);
}
// **********************************************************************************************
// ***** Nice smooth one-at-a-time salvaging replacement *****
// **********************************************************************************************
internal static RunStatus GilesOptimisedSalvage(object ret)
{
DiaUnit objBlacksmith = ZetaDia.Actors.GetActorsOfType <DiaUnit>(true).FirstOrDefault <DiaUnit>(u => u.IsSalvageShortcut);
Vector3 vectorPlayerPosition = ZetaDia.Me.Position;
Vector3 vectorSalvageLocation = new Vector3(0f, 0f, 0f);
if (objBlacksmith == null || objBlacksmith.Distance > 20f)
{
switch (ZetaDia.CurrentAct)
{
case Act.A1:
vectorSalvageLocation = new Vector3(2958.418f, 2823.037f, 24.04533f); break;
case Act.A2:
vectorSalvageLocation = new Vector3(289.6358f, 232.1146f, 0.1f); break;
case Act.A3:
case Act.A4:
vectorSalvageLocation = new Vector3(379.6096f, 415.6198f, 0.3321424f); break;
}
}
else
{
vectorSalvageLocation = objBlacksmith.Position;
}
Bot.NavigationCache.RefreshMovementCache();
//Wait until we are not moving
if (Bot.NavigationCache.IsMoving)
{
return(RunStatus.Running);
}
float iDistanceFromSell = Vector3.Distance(vectorPlayerPosition, vectorSalvageLocation);
//Out-Of-Range...
if (objBlacksmith == null || iDistanceFromSell > 12f) //|| !GilesCanRayCast(vectorPlayerPosition, vectorSalvageLocation, Zeta.Internals.SNO.NavCellFlags.AllowWalk))
{
//Use our click movement
Bot.NavigationCache.RefreshMovementCache();
//Wait until we are not moving to send click again..
if (Bot.NavigationCache.IsMoving)
{
return(RunStatus.Running);
}
Navigator.PlayerMover.MoveTowards(vectorSalvageLocation);
return(RunStatus.Running);
}
if (!UIElements.SalvageWindow.IsVisible)
{
objBlacksmith.Interact();
return(RunStatus.Running);
}
if (!UIElements.InventoryWindow.IsVisible)
{
Bot.Character.Data.BackPack.InventoryBackPackToggle(true);
return(RunStatus.Running);
}
iCurrentItemLoops++;
if (iCurrentItemLoops < iItemDelayLoopLimit * 1.15)
{
return(RunStatus.Running);
}
iCurrentItemLoops = 0;
RandomizeTheTimer();
if (Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSalvageItems.Count > 0)
{
CacheACDItem thisitem = Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSalvageItems.FirstOrDefault();
if (thisitem != null)
{
// Item log for cool stuff stashed
GilesItemType OriginalGilesItemType = Backpack.DetermineItemType(thisitem.ThisInternalName, thisitem.ThisDBItemType, thisitem.ThisFollowerType);
GilesBaseItemType thisGilesBaseType = Backpack.DetermineBaseType(OriginalGilesItemType);
if (thisGilesBaseType == GilesBaseItemType.WeaponTwoHand || thisGilesBaseType == GilesBaseItemType.WeaponOneHand || thisGilesBaseType == GilesBaseItemType.WeaponRange ||
thisGilesBaseType == GilesBaseItemType.Armor || thisGilesBaseType == GilesBaseItemType.Jewelry || thisGilesBaseType == GilesBaseItemType.Offhand ||
thisGilesBaseType == GilesBaseItemType.FollowerItem)
{
double iThisItemValue = Backpack.ValueThisItem(thisitem, OriginalGilesItemType);
Logger.LogJunkItems(thisitem, thisGilesBaseType, OriginalGilesItemType, iThisItemValue);
}
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.SalvagedItemLog(thisitem);
ZetaDia.Me.Inventory.SalvageItem(thisitem.ThisDynamicID);
}
Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSalvageItems.Remove(thisitem);
if (Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSalvageItems.Count > 0)
{
thisitem = Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSalvageItems.FirstOrDefault();
if (thisitem != null)
{
return(RunStatus.Running);
}
}
else
{
iCurrentItemLoops = 0;
return(RunStatus.Running);
}
}
bReachedSafety = false;
bCurrentlyMoving = false;
return(RunStatus.Success);
}
internal static bool StashValidation(CacheACDItem thisitem)
{
// Stash all unidentified items - assume we want to keep them since we are using an identifier over-ride
if (thisitem.IsUnidentified)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] = (autokeep unidentified items)");
return(true);
}
// Now look for Misc items we might want to keep
PluginItemTypes TrueItemType = ItemFunc.DetermineItemType(thisitem);
if (TrueItemType == PluginItemTypes.KeyStone)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep keystone fragments)");
return(true);
}
if (TrueItemType == PluginItemTypes.HoradricCache)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep cache)");
return(FunkyTownRunPlugin.PluginSettings.StashHoradricCache);
}
if (TrueItemType == PluginItemTypes.StaffOfHerding)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep staff of herding)");
return(true);
}
if (TrueItemType == PluginItemTypes.CraftingMaterial)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep craft materials)");
return(true);
}
if (TrueItemType == PluginItemTypes.CraftingPlan)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep plans)");
return(true);
}
if (TrueItemType == PluginItemTypes.Emerald)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep gems)");
return(true);
}
if (TrueItemType == PluginItemTypes.Amethyst)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep gems)");
return(true);
}
if (TrueItemType == PluginItemTypes.Topaz)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep gems)");
return(true);
}
if (TrueItemType == PluginItemTypes.Ruby)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep gems)");
return(true);
}
if (TrueItemType == PluginItemTypes.Diamond)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep gems)");
return(true);
}
if (TrueItemType == PluginItemTypes.LegendaryGem)
{
return(true);
}
if (TrueItemType == PluginItemTypes.RamaladnisGift)
{
return(true);
}
if (TrueItemType == PluginItemTypes.CraftTome)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep tomes)");
return(true);
}
if (TrueItemType == PluginItemTypes.InfernalKey)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep infernal key)");
return(true);
}
if (TrueItemType == PluginItemTypes.HealthPotion || TrueItemType == PluginItemTypes.LegendaryHealthPotion)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (ignoring potions)");
return(false);
}
if (thisitem.ThisQuality >= ItemQuality.Legendary)
{
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = (autokeep legendaries)");
return(true);
}
if (TrueItemType == PluginItemTypes.Dye)
{
return(true);
}
// Ok now try to do some decent item scoring based on item types
//double iNeedScore = ScoreNeeded(TrueItemType);
//double iMyScore = ValueThisItem(thisitem, TrueItemType);
//if (bOutputItemScores) FunkyTownRunPlugin.DBLog.InfoFormat(thisitem.ThisRealName + " [" + thisitem.ThisInternalName + "] [" + TrueItemType + "] = " + iMyScore);
//if (iMyScore >= iNeedScore) return true;
// If we reached this point, then we found no reason to keep the item!
return(false);
}
public void VendoredItemLog(CacheACDItem i)
{
//if (Bot.BotStatistics.ProfileStats.CurrentProfile==null)
//return;
switch (i.ACDItem.ItemType)
{
case ItemType.CraftingPage:
case ItemType.CraftingPlan:
case ItemType.CraftingReagent:
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Crafting.Vendored++;
// Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[(int)LootIndex.Crafting]++;
break;
case ItemType.Gem:
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Gems.Vendored++;
// Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[(int)LootIndex.Gem]++;
break;
case ItemType.Amulet:
case ItemType.Axe:
case ItemType.Belt:
case ItemType.Boots:
case ItemType.Bow:
case ItemType.Bracer:
case ItemType.CeremonialDagger:
case ItemType.Chest:
case ItemType.Cloak:
case ItemType.Crossbow:
case ItemType.Dagger:
case ItemType.Daibo:
case ItemType.FistWeapon:
case ItemType.FollowerSpecial:
case ItemType.Gloves:
case ItemType.HandCrossbow:
case ItemType.Helm:
case ItemType.Legs:
case ItemType.Mace:
case ItemType.MightyBelt:
case ItemType.MightyWeapon:
case ItemType.Mojo:
case ItemType.Orb:
case ItemType.Polearm:
case ItemType.Quiver:
case ItemType.Ring:
case ItemType.Shield:
case ItemType.Shoulder:
case ItemType.Spear:
case ItemType.SpiritStone:
case ItemType.Staff:
case ItemType.Sword:
case ItemType.VoodooMask:
case ItemType.Wand:
case ItemType.WizardHat:
if (i.ThisQuality == ItemQuality.Legendary)
{
//Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[3]++;
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Legendary.Vendored++;
}
else if (i.ThisQuality > ItemQuality.Magic3)
{
// Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[2]++;
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Rare.Vendored++;
}
else
{
// Bot.BotStatistics.ProfileStats.CurrentProfile.ItemStats.stashedItemTotals[1]++;
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.Magical.Vendored++;
}
break;
}
}
public void VendoredItemLog(CacheACDItem i)
{
switch (i.ACDItem.ItemType)
{
case ItemType.CraftingPage:
case ItemType.CraftingPlan:
case ItemType.CraftingReagent:
Crafting.Vendored++;
break;
case ItemType.Gem:
Gems.Vendored++;
break;
case ItemType.Amulet:
case ItemType.Axe:
case ItemType.Belt:
case ItemType.Boots:
case ItemType.Bow:
case ItemType.Bracer:
case ItemType.CeremonialDagger:
case ItemType.Chest:
case ItemType.Cloak:
case ItemType.Crossbow:
case ItemType.Dagger:
case ItemType.Daibo:
case ItemType.FistWeapon:
case ItemType.FollowerSpecial:
case ItemType.Gloves:
case ItemType.HandCrossbow:
case ItemType.Helm:
case ItemType.Legs:
case ItemType.Mace:
case ItemType.MightyBelt:
case ItemType.MightyWeapon:
case ItemType.Mojo:
case ItemType.Orb:
case ItemType.Polearm:
case ItemType.Quiver:
case ItemType.Ring:
case ItemType.Shield:
case ItemType.Shoulder:
case ItemType.Spear:
case ItemType.SpiritStone:
case ItemType.Staff:
case ItemType.Sword:
case ItemType.VoodooMask:
case ItemType.Wand:
case ItemType.WizardHat:
if (i.ThisQuality == ItemQuality.Legendary)
{
Legendary.Vendored++;
}
else if (i.ThisQuality > ItemQuality.Magic3)
{
Rare.Vendored++;
}
else
{
Magical.Vendored++;
}
break;
}
}
// **********************************************************************************************
// ***** Sell Routine replacement for smooth one-at-a-time item selling and handling *****
// **********************************************************************************************
internal static RunStatus GilesOptimisedSell(object ret)
{
string sVendorName = "";
switch (ZetaDia.CurrentAct)
{
case Act.A1:
sVendorName = "a1_uniquevendor_miner"; break;
case Act.A2:
sVendorName = "a2_uniquevendor_peddler"; break;
case Act.A3:
sVendorName = "a3_uniquevendor_collector"; break;
case Act.A4:
sVendorName = "a4_uniquevendor_collector"; break;
}
#region Navigation
DiaUnit objSellNavigation = ZetaDia.Actors.GetActorsOfType <DiaUnit>(true).FirstOrDefault <DiaUnit>(u => u.Name.ToLower().StartsWith(sVendorName));
Vector3 vectorPlayerPosition = ZetaDia.Me.Position;
Vector3 vectorSellLocation = new Vector3(0f, 0f, 0f);
if (objSellNavigation == null)
{
switch (ZetaDia.CurrentAct)
{
case Act.A1:
vectorSellLocation = new Vector3(2901.399f, 2809.826f, 24.04533f); break;
case Act.A2:
vectorSellLocation = new Vector3(295.2101f, 265.1436f, 0.1000002f); break;
case Act.A3:
case Act.A4:
vectorSellLocation = new Vector3(410.6073f, 355.8762f, 0.1000005f); break;
}
}
else
{
vectorSellLocation = objSellNavigation.Position;
}
float iDistanceFromSell = Vector3.Distance(vectorPlayerPosition, vectorSellLocation);
//Out-Of-Range...
if (objSellNavigation == null)
//!GilesCanRayCast(vectorPlayerPosition, vectorSellLocation, NavCellFlags.AllowWalk))
{
Logger.DBLog.InfoFormat("Vendor Obj is Null or Raycast Failed.. using Navigator to move!");
Navigator.PlayerMover.MoveTowards(vectorSellLocation);
return(RunStatus.Running);
}
if (iDistanceFromSell > 40f)
{
Navigator.MoveTo(vectorSellLocation, "Vendor", true);
//ZetaDia.Me.UsePower(SNOPower.Walk, vectorSellLocation, ZetaDia.Me.WorldDynamicId);
return(RunStatus.Running);
}
if (iDistanceFromSell > 7.5f && !UIElements.VendorWindow.IsValid)
{
//Use our click movement
Bot.NavigationCache.RefreshMovementCache();
//Wait until we are not moving to send click again..
if (Bot.NavigationCache.IsMoving)
{
return(RunStatus.Running);
}
objSellNavigation.Interact();
//ZetaDia.Me.UsePower(SNOPower.Axe_Operate_Gizmo, vectorSellLocation, ZetaDia.Me.WorldDynamicId, objSellNavigation.ACDGuid);
return(RunStatus.Running);
}
if (!UIElements.VendorWindow.IsVisible)
{
objSellNavigation.Interact();
return(RunStatus.Running);
}
if (!UIElements.InventoryWindow.IsVisible)
{
Bot.Character.Data.BackPack.InventoryBackPackToggle(true);
return(RunStatus.Running);
}
#endregion
#region SellItem
if (Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSellItems.Count > 0)
{
iCurrentItemLoops++;
if (iCurrentItemLoops < iItemDelayLoopLimit)
{
return(RunStatus.Running);
}
iCurrentItemLoops = 0;
RandomizeTheTimer();
CacheACDItem thisitem = Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSellItems.FirstOrDefault();
// Item log for cool stuff sold
if (thisitem != null)
{
GilesItemType OriginalGilesItemType = Backpack.DetermineItemType(thisitem.ThisInternalName, thisitem.ThisDBItemType, thisitem.ThisFollowerType);
GilesBaseItemType thisGilesBaseType = Backpack.DetermineBaseType(OriginalGilesItemType);
if (thisGilesBaseType == GilesBaseItemType.WeaponTwoHand || thisGilesBaseType == GilesBaseItemType.WeaponOneHand || thisGilesBaseType == GilesBaseItemType.WeaponRange ||
thisGilesBaseType == GilesBaseItemType.Armor || thisGilesBaseType == GilesBaseItemType.Jewelry || thisGilesBaseType == GilesBaseItemType.Offhand ||
thisGilesBaseType == GilesBaseItemType.FollowerItem)
{
double iThisItemValue = Backpack.ValueThisItem(thisitem, OriginalGilesItemType);
Logger.LogJunkItems(thisitem, thisGilesBaseType, OriginalGilesItemType, iThisItemValue);
}
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.VendoredItemLog(thisitem);
ZetaDia.Me.Inventory.SellItem(thisitem.ACDItem);
}
if (thisitem != null)
{
Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSellItems.Remove(thisitem);
}
if (Bot.Character.Data.BackPack.townRunCache.hashGilesCachedSellItems.Count > 0)
{
return(RunStatus.Running);
}
}
#endregion
#region BuyPotion
//Check if settings for potion buy is enabled, with less than 99 potions existing!
if (Bot.Settings.BuyPotionsDuringTownRun && Bot.Character.Data.iTotalPotions < Bot.Settings.Loot.MaximumHealthPotions &&
!PotionCheck)
{
//Obey the timer, so we don't buy 100 potions in 3 seconds.
iCurrentItemLoops++;
if (iCurrentItemLoops < iItemDelayLoopLimit)
{
return(RunStatus.Running);
}
iCurrentItemLoops = 0;
RandomizeTheTimer();
//Buy Potions
int BestPotionID = 0;
int LastHPValue = 0;
foreach (ACDItem item in ZetaDia.Me.Inventory.MerchantItems)
{
if (item.ItemType == ItemType.Potion && item.HitpointsGranted > LastHPValue &&
item.RequiredLevel <= Bot.Character.Data.iMyLevel &&
item.Gold < ZetaDia.Me.Inventory.Coinage)
{
LastHPValue = item.HitpointsGranted;
BestPotionID = item.DynamicId;
}
}
if (BestPotionID != 0)
{
ZetaDia.Me.Inventory.BuyItem(BestPotionID);
//Update counter
Bot.Character.Data.iTotalPotions++;
return(RunStatus.Running);
}
PotionCheck = true;
}
else
{
PotionCheck = true;
}
#endregion
if (bNeedsEquipmentRepairs)
{
iCurrentItemLoops++;
if (iCurrentItemLoops < iItemDelayLoopLimit)
{
return(RunStatus.Running);
}
iCurrentItemLoops = 0;
RandomizeTheTimer();
if (ZetaDia.Me.Inventory.Coinage < 40000)
{
Logger.DBLog.InfoFormat("Emergency Stop: You need repairs but don't have enough money. Stopping the bot to prevent infinite death loop.");
BotMain.Stop(false, "Not enough gold to repair item(s)!");
}
ZetaDia.Me.Inventory.RepairEquippedItems();
bNeedsEquipmentRepairs = false;
}
bCurrentlyMoving = false;
bReachedSafety = false;
return(RunStatus.Success);
}
internal static RunStatus StashItems(object ret)
{
if (FunkyGame.GameIsInvalid)
{
ActionsChecked = false;
FunkyTownRunPlugin.DBLog.InfoFormat("[Funky] Town Run Behavior Failed! (Not In Game/Invalid Actor/misc)");
return(RunStatus.Failure);
}
if (townRunItemCache.KeepItems.Count > 0)
{
if (!Delay.Test())
{
return(RunStatus.Running);
}
CacheACDItem thisitem = townRunItemCache.KeepItems.FirstOrDefault();
if (LastStashPoint[0] < 0 && LastStashPoint[1] < 0 && LastStashPage < 0)
{
bool bDidStashSucceed = GilesStashAttempt(thisitem, out LastStashPoint, out LastStashPage);
if (!bDidStashSucceed)
{
FunkyTownRunPlugin.DBLog.DebugFormat("There was an unknown error stashing an item.");
//if (OutOfGame.MuleBehavior) return RunStatus.Success;
}
else
{
return(RunStatus.Running);
}
}
else
{
//We have a valid place to stash.. so lets check if stash page is currently open
if (ZetaDia.Me.Inventory.CurrentStashPage == LastStashPage)
{
//FunkyTownRunPlugin.TownRunStats.StashedItemLog(thisitem);
if (FunkyGame.CurrentStats != null)
{
FunkyGame.CurrentStats.CurrentProfile.LootTracker.StashedItemLog(thisitem);
}
ZetaDia.Me.Inventory.MoveItem(thisitem.ThisDynamicID, ZetaDia.Me.CommonData.DynamicId, InventorySlot.SharedStash, LastStashPoint[0], LastStashPoint[1]);
LastStashPoint = new[] { -1, -1 };
LastStashPage = -1;
townRunItemCache.KeepItems.Remove(thisitem);
if (townRunItemCache.KeepItems.Count > 0)
{
return(RunStatus.Running);
}
}
else
{
//Lets switch the current page..
ZetaDia.Me.Inventory.SwitchStashPage(LastStashPage);
return(RunStatus.Running);
}
}
}
return(RunStatus.Success);
}
internal static RunStatus GilesOptimisedSalvage(object ret)
{
if (FunkyGame.GameIsInvalid)
{
ActionsChecked = false;
FunkyTownRunPlugin.DBLog.InfoFormat("[Funky] Town Run Behavior Failed! (Not In Game/Invalid Actor/misc)");
return(RunStatus.Failure);
}
DiaUnit objBlacksmith = ZetaDia.Actors.GetActorsOfType <DiaUnit>(true).FirstOrDefault <DiaUnit>(u => u.Name.StartsWith(SalvageName));
Vector3 vectorPlayerPosition = ZetaDia.Me.Position;
Vector3 vectorSalvageLocation = Vector3.Zero;
//Normal distance we use to move to specific location before moving to NPC
float _distanceRequired = CurrentAct != Act.A5 ? 50f : 14f; //Act 5 we want short range only!
if (Vector3.Distance(vectorPlayerPosition, SafetySalvageLocation) <= 2.5f)
{
MovedToSafetyLocation = true;
}
if (objBlacksmith == null || (!MovedToSafetyLocation && objBlacksmith.Distance > _distanceRequired))
{
vectorSalvageLocation = SafetySalvageLocation;
}
else
{
//MovedToSafetyLocation = true;
vectorSalvageLocation = objBlacksmith.Position;
}
//if (vectorSalvageLocation == Vector3.Zero)
// Character.FindActByLevelID(Bot.Character.Data.CurrentWorldDynamicID);
//Wait until we are not moving
if (FunkyGame.Hero.IsMoving)
{
return(RunStatus.Running);
}
float iDistanceFromSell = Vector3.Distance(vectorPlayerPosition, vectorSalvageLocation);
//Out-Of-Range...
if (objBlacksmith == null || iDistanceFromSell > 12f)//|| !GilesCanRayCast(vectorPlayerPosition, vectorSalvageLocation, Zeta.Internals.SNO.NavCellFlags.AllowWalk))
{
Navigator.PlayerMover.MoveTowards(vectorSalvageLocation);
return(RunStatus.Running);
}
if (!UIElements.SalvageWindow.IsVisible)
{
objBlacksmith.Interact();
return(RunStatus.Running);
}
if (!UIElements.InventoryWindow.IsVisible)
{
Backpack.InventoryBackPackToggle(true);
return(RunStatus.Running);
}
//Delays... (so we don't salvage everything in record time)
if (!Delay.Test(1.15))
{
return(RunStatus.Running);
}
if (UIElements.SalvageAllWrapper.IsVisible)
{
if (UI.Game.Dialog_Confirmation_OK.IsVisible)
{
UI.Game.Dialog_Confirmation_OK.Click();
return(RunStatus.Running);
}
if (UI.Game.SalvageAllNormal.IsEnabled && UI.Game.SalvageAllNormal.IsVisible && bShouldSalvageAllNormal && townRunItemCache.SalvageItems.Any(i => i.IsSalvagable && i.ThisQuality < ItemQuality.Magic1) && !bSalvageAllNormal)
{
//UI.Game.SalvageAllNormal.Click();
Logger.DBLog.DebugFormat("[FunkyTownRun] Salvaging All Normal Items");
ZetaDia.Me.Inventory.SalvageItemsOfRarity(SalvageRarity.Normal);
bSalvageAllNormal = true;
var removalList = townRunItemCache.SalvageItems.Where(i => i.IsSalvagable && i.ThisQuality < ItemQuality.Magic1).ToList();
foreach (var cacheAcdItem in removalList)
{
LogSalvagedItem(cacheAcdItem);
}
townRunItemCache.SalvageItems = townRunItemCache.SalvageItems.Except(removalList).ToList();
return(RunStatus.Running);
}
if (UI.Game.SalvageAllMagical.IsEnabled && UI.Game.SalvageAllMagical.IsVisible && bShouldSalvageAllMagical && townRunItemCache.SalvageItems.Any(i => i.IsSalvagable && i.ThisQuality < ItemQuality.Rare4) && !bSalvageAllMagic)
{
//UI.Game.SalvageAllMagical.Click();
FunkyTownRunPlugin.DBLog.DebugFormat("[FunkyTownRun] Salvaging All Magical Items");
ZetaDia.Me.Inventory.SalvageItemsOfRarity(SalvageRarity.Magic);
bSalvageAllMagic = true;
var removalList = townRunItemCache.SalvageItems.Where(i => i.IsSalvagable && i.ThisQuality < ItemQuality.Rare4).ToList();
foreach (var cacheAcdItem in removalList)
{
LogSalvagedItem(cacheAcdItem);
}
townRunItemCache.SalvageItems = townRunItemCache.SalvageItems.Except(removalList).ToList();
return(RunStatus.Running);
}
if (UI.Game.SalvageAllRare.IsEnabled && UI.Game.SalvageAllRare.IsVisible && bShouldSalvageAllRare && townRunItemCache.SalvageItems.Any(i => i.IsSalvagable && i.ThisQuality < ItemQuality.Legendary) && !bSalvageAllRare)
{
//UI.Game.SalvageAllRare.Click();
FunkyTownRunPlugin.DBLog.DebugFormat("[FunkyTownRun] Salvaging All Rare Items");
ZetaDia.Me.Inventory.SalvageItemsOfRarity(SalvageRarity.Rare);
bSalvageAllRare = true;
var removalList = townRunItemCache.SalvageItems.Where(i => i.IsSalvagable && i.ThisQuality < ItemQuality.Legendary).ToList();
foreach (var cacheAcdItem in removalList)
{
LogSalvagedItem(cacheAcdItem);
}
townRunItemCache.SalvageItems = townRunItemCache.SalvageItems.Except(removalList).ToList();
return(RunStatus.Running);
}
UpdateSalvageItemList();
}
if (townRunItemCache.SalvageItems.Count > 0)
{
CacheACDItem thisitem = townRunItemCache.SalvageItems.FirstOrDefault();
if (thisitem != null && thisitem.ACDItem != null)
{
LogSalvagedItem(thisitem);
FunkyTownRunPlugin.DBLog.DebugFormat("[FunkyTownRun] Salvaging Individual Item {0}", thisitem.ToString());
ZetaDia.Me.Inventory.SalvageItem(thisitem.ThisDynamicID);
}
townRunItemCache.SalvageItems.Remove(thisitem);
if (townRunItemCache.SalvageItems.Count > 0)
{
thisitem = townRunItemCache.SalvageItems.FirstOrDefault();
if (thisitem != null)
{
return(RunStatus.Running);
}
}
else
{
Delay.Reset();
return(RunStatus.Running);
}
}
return(RunStatus.Success);
}
internal static void LogGoodItems(CacheACDItem thisgooditem, PluginBaseItemTypes thisPluginBaseItemTypes, PluginItemTypes thisPluginItemType)
{
try
{
//Update this item
using (ZetaDia.Memory.AcquireFrame())
{
thisgooditem = new CacheACDItem(thisgooditem.ACDItem);
}
}
catch
{
DBLog.DebugFormat("Failure to update CacheACDItem during Logging");
}
//double iThisItemValue = ItemFunc.ValueThisItem(thisgooditem, thisPluginItemType);
FileStream LogStream = null;
try
{
string outputPath = FolderPaths.LoggingFolderPath + @"\StashLog.log";
LogStream = File.Open(outputPath, FileMode.Append, FileAccess.Write, FileShare.Read);
using (StreamWriter LogWriter = new StreamWriter(LogStream))
{
if (!TownRunManager.bLoggedAnythingThisStash)
{
TownRunManager.bLoggedAnythingThisStash = true;
LogWriter.WriteLine(DateTime.Now.ToString() + ":");
LogWriter.WriteLine("====================");
}
string sLegendaryString = "";
if (thisgooditem.ThisQuality >= ItemQuality.Legendary)
{
if (!thisgooditem.IsUnidentified)
{
//Prowl.AddNotificationToQueue(thisgooditem.ThisRealName + " [" + thisPluginItemType.ToString() + "] (Score=" + iThisItemValue.ToString() + ". " + TownRunManager.sValueItemStatString + ")", ZetaDia.Service.Hero.Name + " new legendary!", Prowl.ProwlNotificationPriority.Emergency);
sLegendaryString = " {legendary item}";
// Change made by bombastic
DBLog.Info("+=+=+=+=+=+=+=+=+ LEGENDARY FOUND +=+=+=+=+=+=+=+=+");
DBLog.Info("+ Name: " + thisgooditem.ThisRealName + " (" + thisPluginItemType.ToString() + ")");
//DBLog.Info("+ Score: " + Math.Round(iThisItemValue).ToString());
DBLog.Info("+ Attributes: " + thisgooditem.ItemStatString);
DBLog.Info("+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+");
}
else
{
DBLog.Info("+=+=+=+=+=+=+=+=+ LEGENDARY FOUND +=+=+=+=+=+=+=+=+");
DBLog.Info("+ Unid: " + thisPluginItemType.ToString());
DBLog.Info("+ Level: " + thisgooditem.ThisLevel.ToString());
DBLog.Info("+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+");
}
}
else
{
// Check for non-legendary notifications
bool bShouldNotify = false;
switch (thisPluginBaseItemTypes)
{
case PluginBaseItemTypes.WeaponOneHand:
case PluginBaseItemTypes.WeaponRange:
case PluginBaseItemTypes.WeaponTwoHand:
//if (ithisitemvalue >= settings.iNeedPointsToNotifyWeapon)
// bShouldNotify = true;
break;
case PluginBaseItemTypes.Armor:
case PluginBaseItemTypes.Offhand:
//if (ithisitemvalue >= settings.iNeedPointsToNotifyArmor)
//bShouldNotify = true;
break;
case PluginBaseItemTypes.Jewelry:
//if (ithisitemvalue >= settings.iNeedPointsToNotifyJewelry)
//bShouldNotify = true;
break;
}
//if (bShouldNotify)
//Prowl.AddNotificationToQueue(thisgooditem.ThisRealName + " [" + thisPluginItemType.ToString() + "] (Score=" + iThisItemValue.ToString() + ". " + TownRunManager.sValueItemStatString + ")", ZetaDia.Service.Hero.Name + " new item!", Prowl.ProwlNotificationPriority.Emergency);
}
if (!thisgooditem.IsUnidentified)
{
LogWriter.WriteLine(thisgooditem.ThisQuality.ToString() + " " + thisPluginItemType.ToString() + " '" + thisgooditem.ThisRealName + sLegendaryString);
LogWriter.WriteLine(" " + thisgooditem.ItemStatString);
LogWriter.WriteLine("");
}
else
{
LogWriter.WriteLine(thisgooditem.ThisQuality.ToString() + " " + thisPluginItemType.ToString() + " '" + sLegendaryString);
LogWriter.WriteLine("iLevel " + thisgooditem.ThisLevel.ToString());
LogWriter.WriteLine("");
}
}
}
catch (IOException)
{
DBLog.Info("Fatal Error: File access error for stash log file.");
}
}
public static void UpdateItemList()
{
List <int> SeenACDGuid = new List <int>();
//Clear New Item List
NewItemList.Clear();
using (ZetaDia.Memory.AcquireFrame())
{
foreach (var thisitem in ZetaDia.Me.Inventory.Backpack)
{
var ACDGuid = thisitem.ACDGuid;
SeenACDGuid.Add(ACDGuid);
if (CacheItemList.ContainsKey(ACDGuid))
{
var cachedItem = CacheItemList[ACDGuid];
//Stackable item that increased
if (CacheItemList[ACDGuid].IsStackableItem)
{
try
{
if (cachedItem.ThisItemStackQuantity != thisitem.ItemStackQuantity)
{
//Update it..
cachedItem.ThisItemStackQuantity = thisitem.ItemStackQuantity;
//Check if stack quanity is maxed to remove it from our list
if (cachedItem.ThisItemStackQuantity >= cachedItem.MaxStackQuanity &&
_stackableItems.Contains(cachedItem.SNO))
{
_stackableItems.Remove(cachedItem.SNO);
}
//Add it to new item list..
NewItemList.Add(CacheItemList[ACDGuid]);
}
}
catch (Exception ex)
{
//Logger.DBLog.DebugFormat("Item {0} stack quanity threw exception {1}",
//CacheItemList[ACDGuid].ThisInternalName, ex.Message);
}
}
continue;
}
var thiscacheditem = new CacheACDItem(thisitem);
CacheItemList.Add(thiscacheditem.ACDGUID, thiscacheditem);
//Add it to new item list..
NewItemList.Add(thiscacheditem);
//
_occupiedSlots += thiscacheditem.IsTwoSlot ? 2 : 1;
if (thiscacheditem.IsStackableItem &&
thiscacheditem.ThisItemStackQuantity < thiscacheditem.MaxStackQuanity &&
!_stackableItems.Contains(thiscacheditem.SNO))
{
_stackableItems.Add(thiscacheditem.SNO);
}
if (thiscacheditem.invCol >= 0 && thiscacheditem.invCol <= 9 && thiscacheditem.invRow >= 0 &&
thiscacheditem.invRow <= 5)
{
_backpackslotblocked[thiscacheditem.invCol, thiscacheditem.invRow] = true;
if (thiscacheditem.IsTwoSlot)
{
_backpackslotblocked[thiscacheditem.invCol, thiscacheditem.invRow + 1] = true;
}
}
}
}
//Trim away items missing..
var UnseenACDGuids = CacheItemList.Keys.Where(k => !SeenACDGuid.Contains(k)).ToList();
foreach (var unseenAcdguiD in UnseenACDGuids)
{
var item = CacheItemList[unseenAcdguiD];
if (item.IsStackableItem && _stackableItems.Contains(item.SNO))
{
_stackableItems.Remove(item.SNO);
}
_occupiedSlots -= item.IsTwoSlot ? 2 : 1;
_backpackslotblocked[item.invCol, item.invRow] = false;
if (item.IsTwoSlot)
{
_backpackslotblocked[item.invCol, item.invRow + 1] = false;
}
CacheItemList.Remove(unseenAcdguiD);
}
}
public void StashedItemLog(CacheACDItem i)
{
PluginItemTypes thisPluginItemType = ItemFunc.DetermineItemType(i);
if (thisPluginItemType == PluginItemTypes.InfernalKey)
{
Keys.Stashed++;
return;
}
if (thisPluginItemType == PluginItemTypes.HoradricCache)
{
HoradricCache.Stashed++;
}
if (thisPluginItemType == PluginItemTypes.KeyStone)
{
KeyStoneFragments.Stashed += i.ThisItemStackQuantity;
}
switch (i.ACDItem.ItemType)
{
case ItemType.CraftingPage:
case ItemType.CraftingPlan:
case ItemType.CraftingReagent:
Crafting.Stashed++;
break;
case ItemType.Gem:
Gems.Stashed++;
break;
case ItemType.Amulet:
case ItemType.Axe:
case ItemType.Belt:
case ItemType.Boots:
case ItemType.Bow:
case ItemType.Bracer:
case ItemType.CeremonialDagger:
case ItemType.Chest:
case ItemType.Cloak:
case ItemType.Crossbow:
case ItemType.Dagger:
case ItemType.Daibo:
case ItemType.FistWeapon:
case ItemType.FollowerSpecial:
case ItemType.Flail:
case ItemType.CrusaderShield:
case ItemType.Gloves:
case ItemType.HandCrossbow:
case ItemType.Helm:
case ItemType.Legs:
case ItemType.Mace:
case ItemType.MightyBelt:
case ItemType.MightyWeapon:
case ItemType.Mojo:
case ItemType.Orb:
case ItemType.Polearm:
case ItemType.Quiver:
case ItemType.Ring:
case ItemType.Shield:
case ItemType.Shoulder:
case ItemType.Spear:
case ItemType.SpiritStone:
case ItemType.Staff:
case ItemType.Sword:
case ItemType.VoodooMask:
case ItemType.Wand:
case ItemType.WizardHat:
if (i.ThisQuality == ItemQuality.Legendary)
{
Legendary.Stashed++;
}
else if (i.ThisQuality > ItemQuality.Magic3)
{
Rare.Stashed++;
}
else
{
Magical.Stashed++;
}
break;
}
}
internal static RunStatus UnidStashBehavior(object ret)
{
if (ZetaDia.Actors.Me == null)
{
Logger.DBLog.DebugFormat("GSError: Diablo 3 memory read error, or item became invalid [CoreStash-1]");
return(RunStatus.Failure);
}
Vector3 vectorPlayerPosition = ZetaDia.Me.Position;
Vector3 vectorStashLocation = new Vector3(0f, 0f, 0f);
DiaObject objPlayStash = ZetaDia.Actors.GetActorsOfType <GizmoPlayerSharedStash>(true).FirstOrDefault <GizmoPlayerSharedStash>();
if (objPlayStash != null)
{
vectorStashLocation = objPlayStash.Position;
}
else if (!ZetaDia.IsInTown)
{
return(RunStatus.Failure);
}
else
{
//Setup vector for movement
switch (ZetaDia.CurrentAct)
{
case Act.A1:
vectorStashLocation = new Vector3(2971.285f, 2798.801f, 24.04533f); break;
case Act.A2:
vectorStashLocation = new Vector3(323.4543f, 228.5806f, 0.1f); break;
case Act.A3:
case Act.A4:
vectorStashLocation = new Vector3(389.3798f, 390.7143f, 0.3321428f); break;
}
}
float iDistanceFromStash = Vector3.Distance(vectorPlayerPosition, vectorStashLocation);
if (iDistanceFromStash > 120f)
{
return(RunStatus.Failure);
}
//Out-Of-Range...
if (objPlayStash == null)
{
Navigator.PlayerMover.MoveTowards(vectorStashLocation);
return(RunStatus.Running);
}
if (iDistanceFromStash > 40f)
{
ZetaDia.Me.UsePower(SNOPower.Walk, vectorStashLocation, ZetaDia.Me.WorldDynamicId);
return(RunStatus.Running);
}
if (iDistanceFromStash > 7.5f && !UIElements.StashWindow.IsVisible)
{
//Use our click movement
Bot.NavigationCache.RefreshMovementCache();
//Wait until we are not moving to send click again..
if (Bot.NavigationCache.IsMoving)
{
return(RunStatus.Running);
}
ZetaDia.Me.UsePower(SNOPower.Axe_Operate_Gizmo, vectorStashLocation, ZetaDia.Me.WorldDynamicId, objPlayStash.ACDGuid);
return(RunStatus.Running);
}
if (!UIElements.StashWindow.IsVisible)
{
objPlayStash.Interact();
return(RunStatus.Running);
}
if (!bUpdatedStashMap)
{
// Array for what blocks are or are not blocked
for (int iRow = 0; iRow <= 29; iRow++)
{
for (int iColumn = 0; iColumn <= 6; iColumn++)
{
GilesStashSlotBlocked[iColumn, iRow] = false;
}
}
// Block off the entire of any "protected stash pages"
foreach (int iProtPage in CharacterSettings.Instance.ProtectedStashPages)
{
for (int iProtRow = 0; iProtRow <= 9; iProtRow++)
{
for (int iProtColumn = 0; iProtColumn <= 6; iProtColumn++)
{
GilesStashSlotBlocked[iProtColumn, iProtRow + (iProtPage * 10)] = true;
}
}
}
// Remove rows we don't have
for (int iRow = (ZetaDia.Me.NumSharedStashSlots / 7); iRow <= 29; iRow++)
{
for (int iColumn = 0; iColumn <= 6; iColumn++)
{
GilesStashSlotBlocked[iColumn, iRow] = true;
}
}
// Map out all the items already in the stash
foreach (ACDItem tempitem in ZetaDia.Me.Inventory.StashItems)
{
if (tempitem.BaseAddress != IntPtr.Zero)
{
int inventoryRow = tempitem.InventoryRow;
int inventoryColumn = tempitem.InventoryColumn;
// Mark this slot as not-free
GilesStashSlotBlocked[inventoryColumn, inventoryRow] = true;
// Try and reliably find out if this is a two slot item or not
GilesItemType tempItemType = Backpack.DetermineItemType(tempitem.InternalName, tempitem.ItemType, tempitem.FollowerSpecialType);
if (Backpack.DetermineIsTwoSlot(tempItemType) && inventoryRow != 19 && inventoryRow != 9 && inventoryRow != 29)
{
GilesStashSlotBlocked[inventoryColumn, inventoryRow + 1] = true;
}
else if (Backpack.DetermineIsTwoSlot(tempItemType) && (inventoryRow == 19 || inventoryRow == 9 || inventoryRow == 29))
{
Logger.DBLog.DebugFormat("GSError: DemonBuddy thinks this item is 2 slot even though it's at bottom row of a stash page: " + tempitem.Name + " [" + tempitem.InternalName +
"] type=" + tempItemType.ToString() + " @ slot " + (inventoryRow + 1).ToString(CultureInfo.InvariantCulture) + "/" +
(inventoryColumn + 1).ToString(CultureInfo.InvariantCulture));
}
}
} // Loop through all stash items
bUpdatedStashMap = true;
} // Need to update the stash map?
if (Bot.Character.Data.BackPack.townRunCache.hashGilesCachedUnidStashItems.Count > 0)
{
iCurrentItemLoops++;
if (iCurrentItemLoops < iItemDelayLoopLimit)
{
return(RunStatus.Running);
}
iCurrentItemLoops = 0;
RandomizeTheTimer();
CacheACDItem thisitem = Bot.Character.Data.BackPack.townRunCache.hashGilesCachedUnidStashItems.FirstOrDefault();
if (LastStashPoint[0] < 0 && LastStashPoint[1] < 0 && LastStashPage < 0)
{
bool bDidStashSucceed = GilesStashAttempt(thisitem, out LastStashPoint, out LastStashPage);
if (!bDidStashSucceed)
{
Logger.DBLog.DebugFormat("There was an unknown error stashing an item.");
if (OutOfGame.MuleBehavior)
{
return(RunStatus.Success);
}
}
else
{
return(RunStatus.Running);
}
}
else
{
//We have a valid place to stash.. so lets check if stash page is currently open
if (ZetaDia.Me.Inventory.CurrentStashPage == LastStashPage)
{
//Herbfunk: Current Game Stats
Bot.Game.CurrentGameStats.CurrentProfile.LootTracker.StashedItemLog(thisitem);
ZetaDia.Me.Inventory.MoveItem(thisitem.ThisDynamicID, ZetaDia.Me.CommonData.DynamicId, InventorySlot.SharedStash, LastStashPoint[0], LastStashPoint[1]);
LastStashPoint = new[] { -1, -1 };
LastStashPage = -1;
if (thisitem != null)
{
Bot.Character.Data.BackPack.townRunCache.hashGilesCachedUnidStashItems.Remove(thisitem);
}
if (Bot.Character.Data.BackPack.townRunCache.hashGilesCachedUnidStashItems.Count > 0)
{
return(RunStatus.Running);
}
}
else
{
//Lets switch the current page..
ZetaDia.Me.Inventory.SwitchStashPage(LastStashPage);
return(RunStatus.Running);
}
}
}
return(RunStatus.Success);
}