fix: AI comments

Author: The-Code-Monkey

src/client/java/com/tcm/MineTale/block/workbenches/screen/WorkbenchWorkbenchScreen.java

@@ -4,7 +4,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 import com.tcm.MineTale.MineTale;
 import com.tcm.MineTale.block.workbenches.menu.AbstractWorkbenchContainerMenu;
@@ -26,7 +25,7 @@
 import net.minecraft.client.gui.screens.recipebook.RecipeBookComponent;
 import net.minecraft.client.gui.screens.recipebook.RecipeCollection;
 import net.minecraft.client.renderer.RenderPipelines;
-import net.minecraft.core.HolderSet;
+import net.minecraft.core.Holder;
 import net.minecraft.resources.Identifier;
 import net.minecraft.world.entity.player.Inventory;
 import net.minecraft.world.entity.player.Player;
@@ -222,32 +221,31 @@ private boolean canCraft(Player player, RecipeDisplayEntry entry, int craftCount
         Optional<List<Ingredient>> reqs = entry.craftingRequirements();
         if (reqs.isEmpty()) return false;
 
-        // 1. Group ingredients by their underlying Item HolderSet.
-        // Since Ingredient doesn't override hashCode, we use the values field directly
-        // or use a List of Holders as the key for stable hashing.
-        Map<HolderSet<Item>, Integer> aggregatedRequirements = new HashMap<>();
-        
-        // Helper map to get back to an Ingredient object for the final check
-        Map<HolderSet<Item>, Ingredient> holderToIngredient = new HashMap<>();
+        // 1. Group ingredients by their underlying Item Holders.
+        // Using List<Holder<Item>> as the key ensures structural equality (content-based hashing).
+        Map<List<Holder<Item>>, Integer> aggregatedRequirements = new HashMap<>();
+        Map<List<Holder<Item>>, Ingredient> holderToIngredient = new HashMap<>();
 
         for (Ingredient ing : reqs.get()) {
-            // Accessing the 'values' via a custom accessor or reflection if private, 
-            // but based on your source, we can use the Ingredient object itself 
-            // IF we use a helper that handles the hashing correctly.
-            
-            // Strategy: Use the stream of holders as a List key (Lists have stable hashcodes)
+            // Collect holders into a List to get a stable hashCode() and equals()
             @SuppressWarnings("deprecation")
-            HolderSet<Item> key = ing.items().collect(Collectors.collectingAndThen(Collectors.toList(), HolderSet::direct));
-            
+            List<Holder<Item>> key = ing.items().toList(); 
+
+            // Aggregate the counts (how many of this specific ingredient set are required)
             aggregatedRequirements.put(key, aggregatedRequirements.getOrDefault(key, 0) + 1);
+
+            // Map the list back to the original ingredient for use in hasIngredientAmount
             holderToIngredient.putIfAbsent(key, ing);
         }
 
-        // 2. Check the player's inventory
+        // 2. Check the player's inventory against the aggregated totals
         Inventory inv = player.getInventory();
-        for (Map.Entry<HolderSet<Item>, Integer> entryReq : aggregatedRequirements.entrySet()) {
+        for (Map.Entry<List<Holder<Item>>, Integer> entryReq : aggregatedRequirements.entrySet()) {
+            List<Holder<Item>> key = entryReq.getKey();
             int totalNeeded = entryReq.getValue() * craftCount;
-            Ingredient originalIng = holderToIngredient.get(entryReq.getKey());
+            
+            // Retrieve the original Ingredient object associated with this list of holders
+            Ingredient originalIng = holderToIngredient.get(key);
 
             if (!hasIngredientAmount(inv, originalIng, totalNeeded)) {
                 return false;

src/client/java/com/tcm/MineTale/datagen/ModModelProvider.java

@@ -86,22 +86,25 @@ public void generateBlockStateModels(BlockModelGenerators blockStateModelGenerat
      * @param block the furnace workbench block to register models for
      */
     private void registerFurnaceWorkbench(BlockModelGenerators generator, Block block) {
-        // 1. Manually define the shared model paths
-        // Path: assets/minetale/models/block/bench/furnace_top.json
         Identifier topModel = Identifier.fromNamespaceAndPath(MineTale.MOD_ID, "block/bench/furnace_top");
         Identifier bottomModel = Identifier.fromNamespaceAndPath(MineTale.MOD_ID, "block/bench/furnace_bottom");
         Identifier inventoryModel = Identifier.fromNamespaceAndPath(MineTale.MOD_ID, "block/bench/furnace_inventory");
 
-        // 4. Dispatch to Blockstate
         generator.blockStateOutput.accept(MultiVariantGenerator.dispatch(block)
-            .with(PropertyDispatch.initial(BlockStateProperties.DOUBLE_BLOCK_HALF)
-                .select(DoubleBlockHalf.LOWER, BlockModelGenerators.plainVariant(bottomModel))
-                .select(DoubleBlockHalf.UPPER, BlockModelGenerators.plainVariant(topModel))
+            .with(PropertyDispatch.initial(
+                    BlockStateProperties.DOUBLE_BLOCK_HALF, 
+                    BlockStateProperties.CHEST_TYPE, 
+                    BlockStateProperties.LIT
+                )
+                .generate((half, type, lit) -> {
+                    return half == DoubleBlockHalf.UPPER 
+                        ? BlockModelGenerators.plainVariant(topModel) 
+                        : BlockModelGenerators.plainVariant(bottomModel);
+                })
             )
             .with(WORKBENCH_ROTATION)
         );
 
-        // 5. Register the Item Model
         generator.registerSimpleItemModel(block, inventoryModel);
     }
 

src/main/java/com/tcm/MineTale/block/workbenches/FurnaceWorkbench.java

@@ -131,11 +131,11 @@ public RenderShape getRenderShape(BlockState state) {
     public VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
         Direction dir = state.getValue(FACING);
         boolean isUpper = state.getValue(HALF) == DoubleBlockHalf.UPPER;
-        boolean isRightSide = state.getValue(TYPE) == ChestType.LEFT || state.getValue(TYPE) == ChestType.SINGLE;
+        boolean isLeftSide = state.getValue(TYPE) == ChestType.LEFT || state.getValue(TYPE) == ChestType.SINGLE;
 
         VoxelShape baseShape = isUpper 
-            ? (isRightSide ? RAW_UL : RAW_UR) 
-            : (isRightSide ? RAW_LL : RAW_LR);
+            ? (isLeftSide ? RAW_UL : RAW_UR) 
+            : (isLeftSide ? RAW_LL : RAW_LR);
 
         // Call the method now living in AbstractWorkbench
         return rotateShape(dir, baseShape);