public static void SortStash()
{
if (!BotMain.IsRunning)
{
TaskDispatcher.Start(ret => SortTask(InventorySlot.SharedStash), ret => !IsSorting);
return;
}
try
{
GoldInactivity.Instance.ResetCheckGold();
XpInactivity.Instance.ResetCheckXp();
if (!_hookInserted)
{
_sortBehavior = CreateSortBehavior(inventorySlot: InventorySlot.SharedStash);
TreeHooks.Instance.InsertHook(HookName, 0, _sortBehavior);
_hookInserted = true;
BotMain.OnStop += bot => RemoveBehavior();
}
}
catch (Exception ex)
{
Logger.LogError("Error running Sort stash: " + ex);
RemoveBehavior();
}
}
private static void btnClick_MassConvertRareToMagic(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting Conversion of Backpack VeiledCrystals to ArcaneDust");
if (Trinity.Settings.Loot.Pickup.MiscItemQuality > TrinityItemQuality.Common)
{
Logger.LogError("Aborting - Too dangerous to put crafting items into backpack when MiscItemQuality setting is set above common");
return;
}
var from = InventoryItemType.VeiledCrystal;
var to = InventoryItemType.ArcaneDust;
if (!UIElements.TransmuteItemsDialog.IsVisible || !ConvertMaterials.CanRun(from, to))
{
Logger.LogError("You need to have the cube window open and all the required materials in your backpack.");
return;
}
LastStartedConvert = DateTime.UtcNow;
CoroutineHelper.RunCoroutine(() => ConvertMaterials.Execute(from, to), result => !ConvertMaterials.CanRun(from, to) || CheckConvertTimeout());
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void btnClick_Test1(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
using (ZetaDia.Memory.AcquireFrame())
{
ZetaDia.Actors.Update();
foreach (var item in ZetaDia.Me.Inventory.Backpack)
{
var stackHi = item.GetAttribute <int>(ActorAttributeType.ItemStackQuantityHi);
var stackLo = item.GetAttribute <int>(ActorAttributeType.ItemStackQuantityLo);
Logger.Log("Item: {0} {1} ItemStackQuantity={2} StackHi={3} StackLo={4}",
item.Name, item.ACDGuid, item.ItemStackQuantity, stackHi, stackLo);
}
}
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
public static void RunCleanStash()
{
if (!BotMain.IsRunning)
{
TaskDispatcher.Start(ret => CleanTask(), ret => !IsCleaning);
return;
}
try
{
GoldInactivity.Instance.ResetCheckGold();
XpInactivity.Instance.ResetCheckXp();
if (!_hookInserted)
{
_cleanBehavior = CreateCleanBehavior();
TreeHooks.Instance.InsertHook(HookName, 0, _cleanBehavior);
_hookInserted = true;
BotMain.OnStop += bot => RemoveBehavior("Bot stopped");
}
}
catch (Exception ex)
{
Logger.LogError("Error running clean stash: " + ex);
RemoveBehavior("Exception");
}
}
public static bool CheckConvertTimeout()
{
if (DateTime.UtcNow.Subtract(LastStartedConvert).TotalSeconds > 20)
{
Logger.LogError("Timeout");
return(true);
}
return(false);
}
private static void StopTestHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Worker.Stop();
}
catch (Exception ex)
{
Logger.LogError("Error Starting LazyCache: " + ex);
}
}
private static void CacheTestCacheEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Finished Cache Test");
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
private static void LogInvalidHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
DebugUtil.LogInvalidItems();
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
private static void ShowCacheWindowEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
CacheUI.CreateWindow();
}
catch (Exception ex)
{
Logger.LogError("Error showing CacheUI:" + ex);
}
}
private static void DumpBuildEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
DebugUtil.LogBuildAndItems();
}
catch (Exception ex)
{
Logger.LogError("DumpBuildEventHandler: " + ex);
}
}
private static void SortBackEventHandler(object sender, RoutedEventArgs e)
{
try
{
ItemSort.SortBackpack();
}
catch (Exception ex)
{
Logger.LogError("Error sorting backpack:" + ex);
}
}
/**************
*
* WARNING
*
* ALWAYS surround your RoutedEventHandlers in try/catch. Failure to do so will result in Demonbuddy CRASHING if an exception is thrown.
*
* WARNING
*
*************/
private static void btnClick_LogRunTime(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Bot {0} has been running for {1} hours {2} minutes and {3} seconds", ZetaDia.CPlayer.HeroName, GameStats.Instance.RunTime.Hours, GameStats.Instance.RunTime.Minutes, GameStats.Instance.RunTime.Seconds);
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
private static void SortStashEventHandler(object sender, RoutedEventArgs e)
{
try
{
ItemSort.SortStash();
}
catch (Exception ex)
{
Logger.LogError("Error dropping legendaries:" + ex);
}
}
private static void GetNewActorSNOsEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
DebugUtil.LogNewItems();
}
catch (Exception ex)
{
Logger.LogError("Error logging new items:" + ex);
}
}
public static async Task <bool> ReturnToStashTask()
{
if (ZetaDia.Me.IsInCombat)
{
Logger.LogDebug("Cannot return to stash while in combat");
return(false);
}
if (!ZetaDia.IsInTown && ZetaDia.Me.IsFullyValid() && !ZetaDia.Me.IsInCombat && UIElements.BackgroundScreenPCButtonRecall.IsEnabled)
{
StartedOutOfTown = true;
await CommonCoroutines.UseTownPortal("Returning to stash");
return(true);
}
if (!GameUI.IsElementVisible(GameUI.StashDialogMainPage) && ZetaDia.IsInTown)
{
// Move to Stash
if (TownRun.StashLocation.Distance2D(ZetaDia.Me.Position) > 10f)
{
await MoveTo(TownRun.StashLocation, "Shared Stash");
return(true);
}
if (TownRun.StashLocation.Distance2D(ZetaDia.Me.Position) <= 10f && TownRun.SharedStash == null)
{
Logger.LogError("Shared Stash actor is null!");
return(false);
}
// Open Stash
if (TownRun.StashLocation.Distance2D(ZetaDia.Me.Position) <= 10f && TownRun.SharedStash != null && !GameUI.IsElementVisible(GameUI.StashDialogMainPage))
{
while (ZetaDia.Me.Movement.IsMoving)
{
Navigator.PlayerMover.MoveStop();
await Coroutine.Yield();
}
Logger.Log("Opening Stash");
TownRun.SharedStash.Interact();
await Coroutine.Sleep(200);
await Coroutine.Yield();
if (GameUI.IsElementVisible(GameUI.StashDialogMainPage))
{
return(true);
}
return(true);
}
}
return(true);
}
private static void ShowMainTrinityUIEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
var configWindow = UILoader.GetDisplayWindow();
configWindow.ShowDialog();
}
catch (Exception ex)
{
Logger.LogError("Error showing Configuration from TabUI:" + ex);
}
}
private static void btnClick_TestItemList(object sender, RoutedEventArgs routedEventArgs)
{
try
{
using (new MemoryHelper())
{
DebugUtil.ItemListTest();
}
}
catch (Exception ex)
{
Logger.LogError("Exception {0}", ex);
}
}
internal static Tuple <int, int> FindEmptySquare(InventorySlot inventorySlot, int targetCol, int targetRow, bool isTwoSquare, bool isForward)
{
switch (inventorySlot)
{
case InventorySlot.BackpackItems:
return(FindEmptyBackpackSquare(targetCol, targetRow, isTwoSquare, isForward));
case InventorySlot.SharedStash:
return(FindEmptyStashSquare(targetCol, targetRow, isTwoSquare, isForward));
default:
Logger.LogError("Invalid location to find empty slot: {0}", inventorySlot);
return(new Tuple <int, int>(-1, -1));
}
}
private static void btnClick_UpgradeRares(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
CoroutineHelper.RunCoroutine(() => CubeRaresToLegendary.Execute());
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void btnClick_MoveToCube(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
CoroutineHelper.RunCoroutine(() => Navigator.MoveTo(Town.Locations.KanaisCube));
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void btnClick_HijackTest(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("HijackTest Started");
CoroutineHelper.ForceRunCoroutine(() => CubeRaresToLegendary.Execute(), result => !CubeRaresToLegendary.CanRun());
Logger.Log("HijackTest Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void btnClick_BuyVendorBlues(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
CoroutineHelper.RunCoroutine(() => BuyItemsFromVendor.Execute(ItemQualityColor.Yellow),
ret => BuyItemsFromVendor.CanRun(ItemQualityColor.Yellow));
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void ResetTVarsEventHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
var doReset = MessageBox.Show("This will reset all of the advanced Trinity Variables. Are you sure?", "Reset Trinity Variables",
MessageBoxButton.OKCancel, MessageBoxImage.Warning);
if (doReset == MessageBoxResult.OK)
{
V.ResetAll();
}
}
catch (Exception ex)
{
Logger.LogError("Error Resetting TVar's:" + ex);
}
}
private static void CleanStashEventHandler(object sender, RoutedEventArgs e)
{
try
{
var result = MessageBox.Show("Are you sure? This may remove and salvage/sell items from your stash! Permanently!", "Clean Stash Confirmation",
MessageBoxButton.OKCancel);
if (result == MessageBoxResult.OK)
{
CleanStash.RunCleanStash();
}
}
catch (Exception ex)
{
Logger.LogError("Error Cleaning Stash:" + ex);
}
}
private static void btnClick_ScanUIElement(object sender, RoutedEventArgs routedEventArgs)
{
try
{
//[1E8E8E20] Last clicked: 0x80E63C97B008F590, Name: Root.NormalLayer.vendor_dialog_mainPage.training_dialog
//[1E94FCC0] Mouseover: 0x244BD04C84DF92F1, Name: Root.NormalLayer.vendor_dialog_mainPage
using (new MemoryHelper())
{
UIElement.FromHash(0x244BD04C84DF92F1).FindDecedentsWithText("jeweler");
}
}
catch (Exception ex)
{
Logger.LogError("Error btnClick_ScanUIElement:" + ex);
}
}
private static void btnClick_SpecialTestHandler(object sender, RoutedEventArgs routedEventArgs)
{
try
{
Logger.Log("Starting");
// A1 Open World Stash Location
var stashlocation = new Vector3(388.16f, 509.63f, 23.94531f);
CoroutineHelper.RunCoroutine(() => Navigator.MoveTo(TownRun.StashLocation));
Logger.Log("Finished");
}
catch (Exception ex)
{
Logger.LogError("Exception: " + ex);
}
}
private static void ReloadItemRulesEventHandler(object sender, RoutedEventArgs e)
{
try
{
if (Trinity.StashRule == null)
{
Trinity.StashRule = new Interpreter();
}
if (Trinity.StashRule != null)
{
BotMain.PauseWhile(Trinity.StashRule.reloadFromUI);
}
}
catch (Exception ex)
{
Logger.LogError("Error Reloading Item Rules:" + ex);
}
}
private static void DropLegendariesEventHandler(object sender, RoutedEventArgs e)
{
try
{
using (new MemoryHelper())
{
ZetaDia.Me.Inventory.Backpack.Where(i => i.ItemQualityLevel == ItemQuality.Legendary).ForEach(i => i.Drop());
if (BotMain.IsRunning && !BotMain.IsPausedForStateExecution)
{
BotMain.PauseFor(TimeSpan.FromSeconds(2));
}
}
}
catch (Exception ex)
{
Logger.LogError("Error dropping legendaries:" + ex);
}
}
public static async Task <bool> ClearSpot(InventorySlot location, int col, int row, bool isTwoSquare, bool isForward)
{
var myDynamicId = ZetaDia.Me.CommonData.DynamicId;
int lastRow = isTwoSquare ? row + 1 : row;
for (; row <= lastRow; row++)
{
if (ZetaDia.Me.Inventory.ItemInLocation(location, col, row))
{
var item = GetItemInLocation(location, col, row);
if (item != null)
{
var newSpot = FindEmptySquare(location, col, row, isTwoSquare, isForward: isForward);
if (newSpot.Item1 != -1 && newSpot.Item2 != -1)
{
string msg = String.Format("Clearing location {0},{1} - Moving item {2} to {3},{4}", col, row, item.Name, newSpot.Item1, newSpot.Item2);
BotMain.StatusText = msg;
Logger.LogDebug(msg);
ZetaDia.Me.Inventory.MoveItem(item.DynamicId, myDynamicId, location, newSpot.Item1, newSpot.Item2);
await Coroutine.Sleep(ItemMovementDelay);
await Coroutine.Yield();
}
else
{
Logger.LogDebug("Couldn't find a new location for {0} at {1},{2}", item.Name, col, row);
}
}
else
{
Logger.LogError("Item in location {0},{1} was not found!", col, row);
}
}
}
return(true);
}
/// <summary>
/// Moves items from the Stash to the Backpack
/// </summary>
/// <param name="itemIds">list of items to withdraw</param>
/// <param name="maxAmount">amount to withdraw up to (including counts already in backpack)</param>
/// <returns></returns>
public static async Task <bool> Execute(IEnumerable <int> itemIds, int maxAmount)
{
Logger.Log("TakeItemsFromStash Started!");
if (!ZetaDia.IsInGame || !ZetaDia.IsInTown)
{
return(true);
}
if (Town.Locations.Stash.Distance(ZetaDia.Me.Position) > 3f)
{
await MoveToAndInteract.Execute(Town.Locations.Stash, Town.ActorIds.Stash, 8f);
}
var stash = Town.Actors.Stash;
if (stash == null)
{
Logger.Log("Unable to find Stash");
return(false);
}
if (!UIElements.StashWindow.IsVisible && Town.Locations.Stash.Distance(ZetaDia.Me.Position) <= 10f)
{
Logger.Log("Stash window not open, interacting");
stash.Interact();
}
var itemIdsHashSet = new HashSet <int>(itemIds);
var amountWithdrawn = itemIdsHashSet.ToDictionary(k => k, v => (long)0);
var overageTaken = itemIdsHashSet.ToDictionary(k => k, v => false);
var lastStackTaken = itemIdsHashSet.ToDictionary(k => k, v => default(ACDItem));
foreach (var item in ZetaDia.Me.Inventory.Backpack.Where(i => i.ACDGuid != 0 && i.IsValid && itemIdsHashSet.Contains(i.ActorSNO)).ToList())
{
amountWithdrawn[item.ActorSNO] += item.ItemStackQuantity;
lastStackTaken[item.ActorSNO] = item;
}
foreach (var item in ZetaDia.Me.Inventory.StashItems.Where(i => i.ACDGuid != 0 && i.IsValid && itemIdsHashSet.Contains(i.ActorSNO)).ToList())
{
try
{
if (!item.IsValid || item.IsDisposed)
{
continue;
}
var stackSize = item.ItemStackQuantity;
var numTakenAlready = amountWithdrawn[item.ActorSNO];
// We have enough of this material already
var alreadyTakenEnough = numTakenAlready >= maxAmount;
if (alreadyTakenEnough)
{
continue;
}
// We have enough of everything already.
if (amountWithdrawn.All(i => i.Value >= maxAmount))
{
break;
}
// Only take up to the required amount.
var willBeOverMax = numTakenAlready + stackSize > maxAmount;
if (!willBeOverMax || !overageTaken[item.ActorSNO])
{
var lastItem = lastStackTaken[item.ActorSNO];
var amountRequiredToMax = maxAmount - numTakenAlready;
if (willBeOverMax && lastItem != null && lastItem.IsValid && !lastItem.IsDisposed && stackSize > amountRequiredToMax)
{
// Tried InventoryManager.SplitStack but it didnt work, reverting to moving onto existing stacks.
var amountToSplit = stackSize - lastItem.ItemStackQuantity;
Logger.Log("Merging Stash Stack {0} onto Backpack Stack. StackSize={1} WithdrawnAlready={2}", item.Name, amountToSplit, numTakenAlready);
ZetaDia.Me.Inventory.MoveItem(item.DynamicId, ZetaDia.Me.CommonData.DynamicId, InventorySlot.BackpackItems, lastItem.InventoryColumn, lastItem.InventoryRow);
amountWithdrawn[item.ActorSNO] += amountToSplit;
overageTaken[item.ActorSNO] = true;
}
else
{
Logger.Log("Removing {0} ({3}) from stash. StackSize={1} WithdrawnAlready={2}", item.Name, stackSize, numTakenAlready, item.ActorSNO);
if (item.IsValid && !item.IsDisposed)
{
ZetaDia.Me.Inventory.QuickWithdraw(item);
amountWithdrawn[item.ActorSNO] += stackSize;
lastStackTaken[item.ActorSNO] = item;
}
}
await Coroutine.Sleep(25);
await Coroutine.Yield();
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
}
await Coroutine.Sleep(1000);
Logger.Log("TakeItemsFromStash Finished!");
return(true);
}