コード例 #1
0
        public static async Task <bool> Execute(ItemQualityColor qualityColor, List <ItemType> types = null, int totalAmount = -1, int vendorId = -1)
        {
            Logger.Log("BuyItemsFromVendor Started!");

            //if (ZetaDia.Me.Inventory.NumFreeBackpackSlots < totalAmount * 2)
            //{
            //    Logger.Log("Not enough bag space to buy {0} items", totalAmount);
            //    await BrainBehavior.CreateVendorBehavior().ExecuteCoroutine();
            //}

            foreach (var item in ZetaDia.Me.Inventory.MerchantItems)
            {
                item.PrintEFlags();
            }

            var items = ZetaDia.Me.Inventory.MerchantItems.ToList();

            var vendorLocation = Town.Locations.GetLocationFromActorId(vendorId);

            if (!await MoveToAndInteract.Execute(vendorLocation, vendorId, 5f))
            {
                return(false);
            }

            Logger.Log("BuyItemsFromVendor Finished!");
            return(true);
        }
コード例 #2
0
        public static async Task <bool> Execute()
        {
            if (!ZetaDia.IsInTown)
            {
                IsDumpingShards = false;
            }

            try
            {
                while (CanRun() && (!ShouldSaveShards || IsDumpingShards))
                {
                    IsDumpingShards = true;

                    var distance = Town.Locations.Kadala.Distance(ZetaDia.Me.Position);
                    if (distance > 8f && !await MoveToAndInteract.Execute(Town.Locations.Kadala, Town.ActorIds.Kadala, 3f))
                    {
                        Logger.Log("[Gamble] Failed to move to Kadala, quite unfortunate.");
                        break;
                    }

                    if (CanBuyItems)
                    {
                        await BuyItem();
                    }
                    else
                    {
                        Resources.GameUI.CloseVendorWindow();
                    }

                    if (!TrinityItemManager.IsAnyTwoSlotBackpackLocation)
                    {
                        BrainBehavior.ForceTownrun();
                    }

                    await Coroutine.Sleep(100);

                    await Coroutine.Yield();
                }
            }
            catch (Exception ex)
            {
                Logger.LogError("Exception in Gamble.Execute, {0}", ex);

                if (ex is CoroutineStoppedException)
                {
                    throw;
                }
            }

            return(true);
        }
コード例 #3
0
        public static async Task <bool> Execute(List <ACDItem> transmuteGroup)
        {
            if (!ZetaDia.IsInGame)
            {
                return(false);
            }

            if (transmuteGroup.Count > 9)
            {
                Logger.Log(" --> Can't convert more than 9 items!");
                return(false);
            }

            Logger.Log("Transmuting:");

            foreach (var item in transmuteGroup)
            {
                if (item == null || !item.IsValid || item.IsDisposed)
                {
                    Logger.Log(" --> Invalid Item Found {0}");
                    return(false);
                }

                Logger.Log(" --> {0} StackQuantity={1} Quality={2} CraftingMaterial={3}",
                           item.Name, item.ItemStackQuantity, item.GetItemQuality(), item.IsCraftingReagent);
            }

            await Coroutine.Yield();

            if (!UIElements.TransmuteItemsDialog.IsVisible)
            {
                await Coroutine.Sleep(500);

                await MoveToAndInteract.Execute(Town.Locations.KanaisCube, Town.ActorIds.KanaisCube, 8f);

                await Coroutine.Sleep(1000);

                if (!UIElements.TransmuteItemsDialog.IsVisible)
                {
                    Logger.Log("Cube window needs to be open before you can transmute anything.");
                    return(false);
                }
            }

            Logger.Log("Zip Zap!");
            ZetaDia.Me.Inventory.TransmuteItems(transmuteGroup);
            return(true);
        }
コード例 #4
0
        public static async Task <bool> Execute(List <ItemSelectionType> types = null)
        {
            if (!CanRun())
            {
                return(true);
            }

            Logger.LogVerbose("[CubeItemsToMaterials] Getting Materials from Stash");

            if (!Inventory.Materials.HasStackQuantityOfTypes(Inventory.MaterialConversionTypes, InventorySlot.BackpackItems, 100) && !await TakeItemsFromStash.Execute(Inventory.RareUpgradeIds, 5000))
            {
                return(true);
            }

            Logger.LogVerbose("[CubeItemsToMaterials] Time to Convert some junk into delicious crafting materials.");

            if (!await MoveToAndInteract.Execute(Town.Locations.KanaisCube, Town.ActorIds.KanaisCube, 3f))
            {
                Logger.Log("[CubeItemsToMaterials] Failed to move to the cube, quite unfortunate.");
                return(true);
            }

            if (_highest.Type == InventoryItemType.None)
            {
                Logger.Log("[CubeItemsToMaterials] Error: Highest material count is unknown.");
                return(true);
            }

            foreach (var material in _materials)
            {
                if (!await ConvertMaterials.Execute(_highest.Type, material.Key))
                {
                    Logger.Log("[Cube] Failed! Finished!");
                    return(true);
                }

                await Coroutine.Sleep(100);

                await Coroutine.Yield();
            }

            Logger.LogVerbose("[Cube] CubeItemsToMaterials Finished!");
            return(true);
        }
コード例 #5
0
        /// <summary>
        /// Convert rares into legendaries with Kanai's cube
        /// </summary>
        /// <param name="types">restrict the rares that can be selected by ItemType</param>
        public static async Task <bool> Execute(List <ItemSelectionType> types = null)
        {
            while (CanRun(types))
            {
                if (!ZetaDia.IsInTown)
                {
                    break;
                }

                Logger.Log("[CubeRaresToLegendary] CubeRaresToLegendary Started! Wooo!");

                var backpackGuids = new HashSet <int>(ZetaDia.Me.Inventory.Backpack.Select(i => i.ACDGuid));

                if (BackpackHasMaterials)
                {
                    if (Town.Locations.KanaisCube.Distance(ZetaDia.Me.Position) > 10f || !GameUI.KanaisCubeWindow.IsVisible)
                    {
                        if (!await MoveToAndInteract.Execute(Town.Locations.KanaisCube, Town.ActorIds.KanaisCube, 3f))
                        {
                            Logger.Log("Failed to move to the cube, quite unfortunate.");
                            break;
                        }
                        continue;
                    }

                    Logger.Log("[CubeRaresToLegendary] Ready to go, Lets transmute!");

                    var item             = GetBackPackRares(types).First();
                    var itemName         = item.Name;
                    var itemDynamicId    = item.DynamicId;
                    var itemInternalName = item.InternalName;
                    var transmuteGroup   = new List <ACDItem>
                    {
                        item,
                    };

                    transmuteGroup.AddRange(Inventory.GetStacksUpToQuantity(Inventory.Backpack.ArcaneDust, 50));
                    transmuteGroup.AddRange(Inventory.GetStacksUpToQuantity(Inventory.Backpack.VeiledCrystals, 50));
                    transmuteGroup.AddRange(Inventory.GetStacksUpToQuantity(Inventory.Backpack.ReusableParts, 50));
                    transmuteGroup.AddRange(Inventory.GetStacksUpToQuantity(Inventory.Backpack.DeathsBreath, 25));

                    await Transmute.Execute(transmuteGroup);

                    await Coroutine.Sleep(1500);

                    var newItem = ZetaDia.Me.Inventory.Backpack.FirstOrDefault(i => !backpackGuids.Contains(i.ACDGuid));
                    if (newItem != null)
                    {
                        var newLegendaryItem = Legendary.GetItemByACD(newItem);

                        Logger.Log("[CubeRaresToLegendary] Upgraded Rare '{0}' ---> '{1}' ({2})",
                                   itemName, newLegendaryItem.Name, newItem.ActorSNO);
                    }
                    else
                    {
                        Logger.Log("[CubeRaresToLegendary] Failed to upgrade Item '{0}' {1} DynId={2} HasBackpackMaterials={3}",
                                   itemName, itemInternalName, itemDynamicId, BackpackHasMaterials);
                    }

                    Inventory.InvalidItemDynamicIds.Add(itemDynamicId);
                }
                else if (StashHasMaterials)
                {
                    Logger.Log("[CubeRaresToLegendary] Getting Materials from Stash");
                    if (!await TakeItemsFromStash.Execute(Inventory.RareUpgradeIds, 5000))
                    {
                        return(true);
                    }
                }
                else
                {
                    Logger.Log("[CubeRaresToLegendary] Oh no! Out of materials!");
                    return(true);
                }

                await Coroutine.Sleep(500);

                await Coroutine.Yield();
            }

            return(true);
        }
コード例 #6
0
        /// <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);
        }