Esempio n. 1
0
        private void fixItemList(Netcode.NetObjectList <Item> items)
        {
            var Game1hats = Game1.content.Load <Dictionary <int, string> >("Data\\hats");

            for (int i = 0; i < items.Count; ++i)
            {
                var item = items[i];
                if (item is StardewValley.Object obj)
                {
                    if (!obj.bigCraftable)
                    {
                        if (fixId(oldObjectIds, objectIds, obj.parentSheetIndex, Game1.objectInformation))
                        {
                            items[i] = null;
                        }
                    }
                    else
                    {
                        if (fixId(oldBigCraftableIds, bigCraftableIds, obj.parentSheetIndex, Game1.bigCraftablesInformation))
                        {
                            items[i] = null;
                        }
                    }
                }
                else if (item is Hat hat)
                {
                    if (fixId(oldHatIds, hatIds, hat.which, Game1hats))
                    {
                        items[i] = null;
                    }
                }
            }
        }
Esempio n. 2
0
 internal static void DumpObject(string sName, Netcode.NetObjectList <Item> oList)
 {
     if (oList == null)
     {
         LogTrace("NetObjectList<Item> " + sName, "is null");
     }
     else
     {
         LogTrace("NetObjectList<Item> " + sName, "");
         LogTrace("{", "");
         foreach (Item oItem in oList)
         {
             DumpObject("oItem", oItem);
             LogTrace(",", "");
         }
         LogTrace("{", "");
     }
 }
Esempio n. 3
0
        private StardewValley.Object checkChests(StardewValley.Object seedmaker)
        {
            OverlaidDictionary allObjectsinLocation = allSeedMakers[seedmaker].location.objects;

            OverlaidDictionary.KeysCollection keyCollection = allObjectsinLocation.Keys;
            foreach (Vector2 objectKey in keyCollection)
            {
                if (allObjectsinLocation[objectKey] is Chest && Vector2.Distance(objectKey, seedmaker.TileLocation) <= 1.0)
                {
                    Chest thisChest = (allObjectsinLocation[objectKey] as Chest);
                    Netcode.NetObjectList <Item> currentItems = thisChest.items;
                    for (int index = 0; index < currentItems.Count; index++)
                    {
                        if (currentItems[index] == null || currentItems[index].ParentSheetIndex == 433)
                        {
                            continue;
                        }
                        {
                            Dictionary <int, string> dictionary = Game1.temporaryContent.Load <Dictionary <int, string> >("Data\\Crops");
                            foreach (KeyValuePair <int, string> keyValuePair in dictionary)
                            {
                                if (Convert.ToInt32(keyValuePair.Value.Split('/')[3]) == currentItems[index].ParentSheetIndex)
                                {
                                    allChests[thisChest].previousItem = currentItems[index];
                                    return(currentItems[index] as StardewValley.Object);
                                }
                            }
                        }
                    }
                    if (allChests[thisChest].previousItem != null)
                    {
                        Item returnItem = allChests[thisChest].previousItem;
                        allChests[thisChest].previousItem = null;
                        return(returnItem as StardewValley.Object);
                    }
                }
            }
            return(null);
        }
        public static bool StackToNearbyChests(int range, InventoryPage inventoryPage)
        {
            if (inventoryPage == null)
            {
                return(false);
            }

            bool   movedAtLeastOneTotal = false;
            Farmer who = Game1.player;

            List <Chest> chests = GetChestsAroundFarmer(who, range, true);

            foreach (Chest chest in chests)
            {
                List <Item> stackOverflowItems = new List <Item>();

                Netcode.NetObjectList <Item> chestItems = (chest.SpecialChestType == Chest.SpecialChestTypes.MiniShippingBin || chest.SpecialChestType == Chest.SpecialChestTypes.JunimoChest)
                        ? chest.GetItemsForPlayer(who.UniqueMultiplayerID)
                        : chest.items;

                // Fill chest stacks with player inventory items
                foreach (Item chestItem in chestItems)
                {
                    if (chestItem is null)
                    {
                        continue;
                    }

                    IList <Item> playerInventory = inventoryPage.inventory.actualInventory;

                    foreach (Item playerItem in playerInventory)
                    {
                        if (playerItem is null || !playerItem.canStackWith(chestItem))
                        {
                            continue;
                        }

                        if (ModEntry.Config.IsEnableFavoriteItems && ConvenientInventory.FavoriteItemSlots[playerInventory.IndexOf(playerItem)])
                        {
                            // Skip favorited items
                            continue;
                        }

                        int beforeStack = playerItem.Stack;
                        playerItem.Stack = chestItem.addToStack(playerItem);
                        bool movedAtLeastOne = beforeStack != playerItem.Stack;

                        movedAtLeastOneTotal = movedAtLeastOneTotal || movedAtLeastOne;

                        if (movedAtLeastOne)
                        {
                            ClickableComponent inventoryComponent = inventoryPage.inventory.inventory[playerInventory.IndexOf(playerItem)];

                            ConvenientInventory.AddTransferredItemSprite(new TransferredItemSprite(
                                                                             playerItem.getOne(), inventoryComponent.bounds.X, inventoryComponent.bounds.Y)
                                                                         );

                            if (playerItem.Stack == 0)
                            {
                                who.removeItemFromInventory(playerItem);
                            }
                        }

                        if (chestItem.Stack == chestItem.maximumStackSize())
                        {
                            if (ModEntry.Config.IsQuickStackOverflowItems)
                            {
                                stackOverflowItems.Add(chestItem.getOne());
                            }

                            inventoryPage.inventory.ShakeItem(playerItem);
                            break;
                        }
                    }
                }

                // Add overflow stacks to chest when applicable
                if (ModEntry.Config.IsQuickStackOverflowItems && chestItems.Count < chest.GetActualCapacity())
                {
                    IList <Item> playerInventory = inventoryPage.inventory.actualInventory;

                    foreach (Item stackOverflowItem in stackOverflowItems)
                    {
                        if (stackOverflowItem is null)
                        {
                            continue;
                        }

                        foreach (Item playerItem in playerInventory)
                        {
                            if (playerItem is null || !playerItem.canStackWith(stackOverflowItem))
                            {
                                continue;
                            }

                            if (ModEntry.Config.IsEnableFavoriteItems && ConvenientInventory.FavoriteItemSlots[playerInventory.IndexOf(playerItem)])
                            {
                                // Skip favorited items
                                continue;
                            }

                            int  beforeStack     = playerItem.Stack;
                            Item leftoverItem    = chest.addItem(playerItem);
                            bool movedAtLeastOne = leftoverItem is null || beforeStack != leftoverItem.Stack;

                            movedAtLeastOneTotal = movedAtLeastOneTotal || movedAtLeastOne;

                            if (movedAtLeastOne)
                            {
                                ClickableComponent inventoryComponent = inventoryPage.inventory.inventory[playerInventory.IndexOf(playerItem)];

                                ConvenientInventory.AddTransferredItemSprite(new TransferredItemSprite(
                                                                                 playerItem.getOne(), inventoryComponent.bounds.X, inventoryComponent.bounds.Y)
                                                                             );
                            }

                            if (leftoverItem is null)
                            {
                                who.removeItemFromInventory(playerItem);
                            }
                            else
                            {
                                inventoryPage.inventory.ShakeItem(playerItem);
                            }
                        }
                    }
                }
            }

            Game1.playSound(movedAtLeastOneTotal ? "Ship" : "cancel");

            return(movedAtLeastOneTotal);
        }