コード例 #1
0
ファイル: ItemSort.cs プロジェクト: shmilyzxt/db-plugins
        internal static async Task <bool> SortTask(InventorySlot inventorySlot)
        {
            IsSorting = true;

            if (!ZetaDia.IsInGame)
            {
                return(false);
            }
            if (ZetaDia.IsLoadingWorld)
            {
                return(false);
            }
            if (!ZetaDia.Me.IsFullyValid())
            {
                return(false);
            }

            if (ZetaDia.Me.IsParticipatingInTieredLootRun)
            {
                Logger.LogNormal("Cannot sort while in trial/greater rift");
                RemoveBehavior();
                return(false);
            }

            if (inventorySlot == InventorySlot.SharedStash && !await TrinityCoroutines.Common.ReturnToStashTask())
            {
                return(true);
            }
            Logger.Log("Starting sort task for {0}", inventorySlot);

            List <ItemWrapper> wrappedItems;

            // Setup grid
            if (inventorySlot == InventorySlot.BackpackItems)
            {
                wrappedItems = ZetaDia.Me.Inventory.Backpack.Where(i => i.IsValid).Select(i => new ItemWrapper(i)).ToList();

                _usedGrid = new bool[10, 6];
                // Block off the entire of any "protected bag slots"
                foreach (InventorySquare square in CharacterSettings.Instance.ProtectedBagSlots)
                {
                    _usedGrid[square.Column, square.Row] = true;
                    Logger.LogDebug("Slot {0},{1} is protected", square.Column, square.Row);
                }
            }
            else if (inventorySlot == InventorySlot.SharedStash)
            {
                wrappedItems = ZetaDia.Me.Inventory.StashItems.Where(i => i.IsValid).Select(i => new ItemWrapper(i)).ToList();

                int maxStashRow = ZetaDia.Me.Inventory.NumSharedStashSlots / 7;
                // 7 columns, 10 rows x 5 pages
                _usedGrid = new bool[7, maxStashRow];
            }
            else
            {
                Logger.LogError("Unsupported Inventory Slot {0}", inventorySlot);
                return(false);
            }


            var equipment = wrappedItems.Where(i => i.IsEquipment).OrderByDescending(i => i);

            _sortedItemsQueue = new Queue <ItemWrapper>(equipment);
            Logger.LogDebug("Queued {0} items for forward sort", _sortedItemsQueue.Count());

            foreach (var item in equipment)
            {
                Logger.LogDebug("{0}", item.Name);
            }

            var misc = wrappedItems.Where(i => !i.IsEquipment).OrderByDescending(i => i);

            _reverseSortedItemsQueue = new Queue <ItemWrapper>(misc);
            Logger.LogDebug("Queued {0} items for reverse sort", _reverseSortedItemsQueue.Count());

            foreach (var item in misc)
            {
                Logger.LogDebug("{0}", item.Name);
            }

            if (!_reverseSortedItemsQueue.Any() && !_sortedItemsQueue.Any())
            {
                _reverseSortedItemsQueue = null;
                _sortedItemsQueue        = null;
                Logger.Log("No items found to sort?");
                RemoveBehavior();
                return(false);
            }

            if (!UIElements.InventoryWindow.IsVisible && inventorySlot == InventorySlot.BackpackItems)
            {
                Logger.Log("Opening inventory window");
                var inventoryButton = UIElement.FromName("Root.NormalLayer.game_dialog_backgroundScreenPC.button_inventory");
                if (inventoryButton != null && inventoryButton.IsEnabled && inventoryButton.IsVisible)
                {
                    inventoryButton.Click();
                    await Coroutine.Sleep(50);

                    await Coroutine.Yield();
                }
                else
                {
                    Logger.LogError("Derp - couldn't find inventory Button!");
                }
            }

            Logger.Log("Executing sort task");
            if (GameUI.IsElementVisible(GameUI.StashDialogMainPage) && inventorySlot == InventorySlot.SharedStash)
            {
                await SortItems(inventorySlot);
                await ReverseItems(inventorySlot);

                Logger.Log("Waiting 5 seconds...");
                BotMain.StatusText = "Waiting 5 seconds...";
                await Coroutine.Sleep(5000);

                if (TrinityCoroutines.Common.StartedOutOfTown && ZetaDia.IsInTown)
                {
                    await CommonBehaviors.TakeTownPortalBack().ExecuteCoroutine();
                }
            }
            else if (inventorySlot == InventorySlot.BackpackItems)
            {
                await SortItems(inventorySlot);
                await ReverseItems(inventorySlot);
            }

            RemoveBehavior();
            return(true);
        }
コード例 #2
0
        public static async Task <bool> CleanTask()
        {
            try
            {
                if (!ZetaDia.IsInGame)
                {
                    return(false);
                }
                if (ZetaDia.IsLoadingWorld)
                {
                    return(false);
                }
                if (!ZetaDia.Me.IsFullyValid())
                {
                    return(false);
                }

                if (ZetaDia.Me.IsParticipatingInTieredLootRun)
                {
                    Logger.LogNormal("Cannot clean stash while in trial/greater rift");
                    RemoveBehavior("Cannot clean stash while in trial/greater rift");
                    return(false);
                }

                if (TrinityItemManager.FindValidBackpackLocation(true) == new Vector2(-1, -1))
                {
                    Trinity.ForceVendorRunASAP = true;
                    return(false);
                }
                if (!await TrinityCoroutines.Common.ReturnToStashTask())
                {
                    _isFinished = true;
                    return(false);
                }
                if (GameUI.IsElementVisible(GameUI.StashDialogMainPage))
                {
                    Logger.Log("Cleaning stash...");

                    foreach (var item in ZetaDia.Me.Inventory.StashItems.Where(i => i.ACDGuid != 0 && i.IsValid).ToList())
                    {
                        CachedACDItem cItem = CachedACDItem.GetCachedItem(item);
                        // Don't take potions from the stash
                        if (cItem.TrinityItemType == TrinityItemType.HealthPotion)
                        {
                            continue;
                        }

                        try
                        {
                            if (!ItemManager.Current.ShouldStashItem(item))
                            {
                                Logger.Log("Removing {0} from stash", item.Name);
                                ZetaDia.Me.Inventory.QuickWithdraw(item);
                                await Coroutine.Sleep(ItemMovementDelay);

                                await Coroutine.Yield();

                                if (TrinityItemManager.FindValidBackpackLocation(true) == new Vector2(-1, -1))
                                {
                                    Trinity.ForceVendorRunASAP = true;
                                    return(false);
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Logger.LogError(ex.ToString());
                        }
                    }

                    _isFinished = true;
                    Trinity.ForceVendorRunASAP = true;
                    Logger.Log("Waiting 5 seconds...");
                    BotMain.StatusText = "Waiting 5 seconds...";
                    await Coroutine.Sleep(5000);

                    if (TrinityCoroutines.Common.StartedOutOfTown && ZetaDia.IsInTown)
                    {
                        await CommonBehaviors.TakeTownPortalBack().ExecuteCoroutine();
                    }
                }
                if (_isFinished)
                {
                    RemoveBehavior("finished!");
                }
                return(true);
            }
            catch (Exception ex)
            {
                _isFinished = true;
                Logger.LogError(ex.ToString());
                return(false);
            }
        }