Update polymer

gradle.properties

@@ -4,18 +4,18 @@ org.gradle.jvmargs=-Xmx1G
 # check these on https://modmuss50.me/fabric.html
 
 minecraft_version=1.21
-yarn_mappings=1.21+build.1
+yarn_mappings=1.21+build.2
 loader_version=0.15.11
 
 # Fabric API
-fabric_version=0.100.1+1.21
+fabric_version=0.100.3+1.21
 
 # Mod Properties
-mod_version=2.6
+mod_version=2.6.1
 maven_group=systems.brn
 archives_base_name=Server_storage
 
 # Dependencies
-polymer_version=0.9.0+1.21-rc1
+polymer_version=0.9.2+1.21
 server_translations_api_version=2.3.1+1.21-pre2
 servergui_version=1.6.0+1.21

src/main/java/systems/brn/server_storage/lib/CraftingEntry.java

@@ -4,9 +4,12 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.recipe.CraftingRecipe;
 import net.minecraft.recipe.RecipeEntry;
 
+import java.util.ArrayList;
+
 public class CraftingEntry {
     public final ItemStack itemStack;
     public final RecipeEntry<CraftingRecipe> recipeEntry;
+    public final ArrayList<MyCraftingRecipe> myCraftingRecipeEntries;
     public CraftingEntry(ItemStack itemStack, RecipeEntry<CraftingRecipe> recipeEntry) {
         this.itemStack = itemStack;
         this.recipeEntry = recipeEntry;

src/main/java/systems/brn/server_storage/lib/MyCraftingRecipe.java

@@ -0,0 +1,15 @@
+package systems.brn.server_storage.lib;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.recipe.CraftingRecipe;
+import net.minecraft.recipe.RecipeEntry;
+
+import java.util.HashMap;
+
+public class MyCraftingRecipe {
+    HashMap<ItemStack, Integer> inputs = new HashMap<>();
+    HashMap<ItemStack, Integer> outputs = new HashMap<>();
+    MyCraftingRecipe(RecipeEntry<CraftingRecipe> recipeEntry) {
+        recipeEntry.value().getIngredients()
+    }
+}

src/main/java/systems/brn/server_storage/lib/StorageOperations.java

@@ -26,7 +26,9 @@ public class StorageOperations {
         } else {
             // Sort by count in descending order
             sortedMap = new TreeMap<>((o1, o2) -> {
-                int countCompare = Integer.compare(o2.getCount(), o1.getCount());
+                int count1 = itemStackMap.get(o1);
+                int count2 = itemStackMap.get(o2);
+                int countCompare = Integer.compare(count2, count1);
                 // If counts are equal, compare items alphabetically by name
                 return countCompare == 0 ? String.valueOf(o1.getItem()).compareToIgnoreCase(String.valueOf(o2.getItem())) : countCompare;
             });

src/main/java/systems/brn/server_storage/lib/Util.java

@@ -13,7 +13,9 @@ import net.minecraft.text.Text;
 import net.minecraft.util.Formatting;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 public class Util {
@@ -24,7 +26,7 @@ public class Util {
             ItemStack slotStack = inventory.getStack(i);
             if (!slotStack.isEmpty()) {
                 Item itemName = slotStack.getItem();
-                pages.add(String.valueOf(itemName) + " " + slotStack.getCount());
+                pages.add(itemName + " " + slotStack.getCount());
             }
         }
         return stringToBookContent(String.join(System.lineSeparator(), pages));
@@ -112,46 +114,81 @@ public class Util {
             int maxAmount = -1;
             boolean canMake = true;
             for (Ingredient ingredient : recipe.value().getIngredients()) {
+                HashMap<ItemStack, Integer> inputsTemp = new HashMap<>();
                 for (ItemStack stack : ingredient.getMatchingStacks()) {
                     if (stack.isEmpty()) {
                         break;
                     } else {
                         //if inventory contains stack
                         boolean foundUsableStack = false;
-                        for (int i = 0; i < inventory.size(); i++) {
+                        for (Map.Entry<ItemStack, Integer> entry : inputsTemp.entrySet()) {
-                            if (inventory.getStack(i).getItem().equals(stack.getItem())) {
+                            ItemStack stackIn = entry.getKey();
-                                if (maxAmount == -1) {
+                            Integer count = entry.getValue();
-                                    maxAmount = inventory.getStack(i).getCount();
+                            if (stackIn.getItem() == stack.getItem()) {
-                                } else {
+                                count += stack.getCount();
-                                    maxAmount = Math.min(maxAmount, inventory.getStack(i).getCount());
+                                entry.setValue(count); // Update the value in the map
-                                }
                                 foundUsableStack = true;
                                 break;
                             }
                         }
                         if (!foundUsableStack) {
-                            canMake = false;
+                            inputsTemp.put(stack, stack.getCount());
-                            break;
                         }
                     }
                 }
-            }
+                HashMap<ItemStack, Integer> inputs = new HashMap<>();
-            if (maxAmount > 1 && canMake) {
+                for (Map.Entry<ItemStack, Integer> entry : inputsTemp.entrySet()) {
-                Item outputItem = recipe.value().getResult(server.getRegistryManager()).getItem();
+                    ItemStack stackIn = entry.getKey();
-                CraftingEntry entry = new CraftingEntry(new ItemStack(outputItem, maxAmount), recipe);
+                    Integer count = entry.getValue();
-                boolean needToAdd = true;
+                    stackIn.setCount(count);
-                for (int i = 0; i < craftingEntries.size(); i++) {
+                    inputs.put(stackIn, stackIn.getCount());
-                    CraftingEntry entryLoop = craftingEntries.get(i);
+                }
-                    if (entryLoop.itemStack.getItem().equals(outputItem)) {
+                for (int i = 0; i < inventory.size(); i++) {
-                        needToAdd = false;
+                    ItemStack slotStack = inventory.getStack(i);
-                        if (maxAmount > entryLoop.itemStack.getCount()) {
+                    Item slotItem = slotStack.getItem();
-                            craftingEntries.set(i, entry);
+                    int slotCount = slotStack.getCount();
-                            break;
+                    for (Map.Entry<ItemStack, Integer> entry : inputs.entrySet()) {
+                        ItemStack stackIn = entry.getKey();
+                        Integer count = entry.getValue();
+                        if (stackIn.getItem() == slotItem) {
+                            count -= slotCount;
+                            entry.setValue(count);
                         }
                     }
                 }
-                if (needToAdd) {
+                for (Map.Entry<ItemStack, Integer> entry : inputs.entrySet()) {
-                    craftingEntries.add(entry);
+                    ItemStack stackIn = entry.getKey();
+                    Integer count = entry.getValue();
+                    if (count > 0) {
+                        canMake = false;
+                    } else {
+                        int thisMaxAmount = Math.floorDivExact(Math.abs(count), stackIn.getCount());
+                        if (maxAmount == -1) {
+                            maxAmount = thisMaxAmount;
+                        } else {
+                            maxAmount = Math.min(maxAmount, thisMaxAmount);
+                        }
+                    }
+                }
+                if (maxAmount > 1 && canMake) {
+                    Item outputItem = recipe.value().getResult(server.getRegistryManager()).getItem();
+                    CraftingEntry entry = new CraftingEntry(new ItemStack(outputItem, maxAmount), recipe);
+                    boolean needToAdd = true;
+                    for (int i = 0; i < craftingEntries.size(); i++) {
+                        CraftingEntry entryLoop = craftingEntries.get(i);
+                        if (entryLoop.itemStack.getItem().equals(outputItem)) {
+                            needToAdd = false;
+                            if (maxAmount > entryLoop.itemStack.getCount()) {
+                                craftingEntries.set(i, entry);
+                                break;
+                            }
+                        }
+                    }
+                    if (needToAdd) {
+                        craftingEntries.add(entry);
+                    }
+                } else {
+                    break;
                 }
             }
         }

src/main/java/systems/brn/server_storage/screens/CraftingScreen.java

@@ -117,7 +117,7 @@ public class CraftingScreen extends PagedGui {
         }
 
         // Add the result to the appropriate inventory
-        ItemStack outputStack = recipeEntry.value().getResult(storageScreen.getPlayer().getRegistryManager());
+        ItemStack outputStack = recipeEntry.value().getResult(storageScreen.getPlayer().getRegistryManager()).copy();
         if (toPlayerInventory) {
             if (canInsertItemIntoPlayerInventory(player, outputStack) == outputStack.getCount()) {
                 player.getInventory().insertStack(outputStack);

src/main/resources/fabric.mod.json

@@ -18,7 +18,7 @@
   },
   "depends": {
     "fabricloader": ">=${loader_version}",
-    "fabric": "*",
+    "fabric": ">=${fabric_version}",
-    "minecraft": "${minecraft_version}"
+    "minecraft": ">=${minecraft_version}"
   }
 }