Add normal Workbench

src/client/java/com/tcm/MineTale/MineTaleClient.java

@@ -1,25 +1,26 @@
 package com.tcm.MineTale;
 
 import com.tcm.MineTale.block.workbenches.screen.FurnaceWorkbenchScreen;
+import com.tcm.MineTale.block.workbenches.screen.WorkbenchWorkbenchScreen;
 import com.tcm.MineTale.block.workbenches.screen.CampfireWorkbenchScreen;
 import com.tcm.MineTale.registry.ModMenuTypes;
 
 import net.fabricmc.api.ClientModInitializer;
 import net.minecraft.client.gui.screens.MenuScreens;
 
 public class MineTaleClient implements ClientModInitializer {
-
-
-
 	/**
-	 * Registers client-side screen factories for custom workbench menu types.
+	 * Register client-side screen factories for custom workbench menu types.
 	 *
-	 * Binds the furnace and campfire workbench menu types to their corresponding screen constructors
-	 * so the client can create the appropriate GUI when those menus are opened.
+	 * Binds ModMenuTypes.FURNACE_WORKBENCH_MENU to FurnaceWorkbenchScreen,
+	 * ModMenuTypes.CAMPFIRE_WORKBENCH_MENU to CampfireWorkbenchScreen, and
+	 * ModMenuTypes.WORKBENCH_WORKBENCH_MENU to WorkbenchWorkbenchScreen so the client
+	 * can create the appropriate GUI when those menus open.
 	 */
 	@Override
 	public void onInitializeClient() {
 		MenuScreens.register(ModMenuTypes.FURNACE_WORKBENCH_MENU, FurnaceWorkbenchScreen::new);
 		MenuScreens.register(ModMenuTypes.CAMPFIRE_WORKBENCH_MENU, CampfireWorkbenchScreen::new);
+		MenuScreens.register(ModMenuTypes.WORKBENCH_WORKBENCH_MENU, WorkbenchWorkbenchScreen::new);
 	}
 }

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

@@ -0,0 +1,271 @@
+package com.tcm.MineTale.block.workbenches.screen;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import com.tcm.MineTale.MineTale;
+import com.tcm.MineTale.block.workbenches.menu.WorkbenchWorkbenchMenu;
+import com.tcm.MineTale.mixin.client.ClientRecipeBookAccessor;
+import com.tcm.MineTale.mixin.client.RecipeBookComponentAccessor;
+import com.tcm.MineTale.network.CraftRequestPayload;
+import com.tcm.MineTale.recipe.MineTaleRecipeBookComponent;
+import com.tcm.MineTale.registry.ModBlocks;
+import com.tcm.MineTale.registry.ModRecipeDisplay;
+import com.tcm.MineTale.registry.ModRecipes;
+
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.minecraft.client.ClientRecipeBook;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.navigation.ScreenPosition;
+import net.minecraft.client.gui.screens.inventory.AbstractRecipeBookScreen;
+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.resources.Identifier;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.display.RecipeDisplayEntry;
+import net.minecraft.world.item.crafting.display.RecipeDisplayId;
+import net.minecraft.world.item.crafting.display.SlotDisplayContext;
+import net.minecraft.network.chat.Component;
+
+public class WorkbenchWorkbenchScreen extends AbstractRecipeBookScreen<WorkbenchWorkbenchMenu> {
+    private static final Identifier TEXTURE = 
+        Identifier.fromNamespaceAndPath(MineTale.MOD_ID, "textures/gui/container/workbench_workbench.png");
+
+    private final MineTaleRecipeBookComponent mineTaleRecipeBook;
+
+    private Button craftOneBtn;
+    private Button craftTenBtn;
+    private Button craftAllBtn;
+
+    /**
+     * Initialize a workbench GUI screen using the provided container menu, player inventory, and title.
+     *
+     * @param menu      the menu supplying slots and synchronized state for this screen
+     * @param inventory the player's inventory to display and interact with
+     * @param title     the title component shown at the top of the screen
+     */
+    public WorkbenchWorkbenchScreen(WorkbenchWorkbenchMenu menu, Inventory inventory, Component title) {
+        this(menu, inventory, title, createRecipeBookComponent(menu));
+    }
+
+    /**
+     * Creates a WorkbenchWorkbenchScreen bound to the given menu, player inventory, title, and recipe book component.
+     *
+     * @param menu        the menu backing this screen
+     * @param inventory   the player's inventory shown in the screen
+     * @param title       the screen title component
+     * @param recipeBook  the MineTaleRecipeBookComponent used to display and manage recipes in this screen
+     */
+    private WorkbenchWorkbenchScreen(WorkbenchWorkbenchMenu menu, Inventory inventory, Component title, MineTaleRecipeBookComponent recipeBook) {
+        super(menu, recipeBook, inventory, title);
+        this.mineTaleRecipeBook = recipeBook;
+    }
+
+    /**
+     * Create a MineTaleRecipeBookComponent configured for the workbench screen.
+     *
+     * @param menu the workbench menu used to initialize the recipe book component
+     * @return a MineTaleRecipeBookComponent containing the workbench tab and associated recipe category
+     */
+    private static MineTaleRecipeBookComponent createRecipeBookComponent(WorkbenchWorkbenchMenu menu) {
+        ItemStack tabIcon = new ItemStack(ModBlocks.WORKBENCH_WORKBENCH_BLOCK.asItem());
+
+        List<RecipeBookComponent.TabInfo> tabs = List.of(
+            new RecipeBookComponent.TabInfo(tabIcon.getItem(), ModRecipeDisplay.WORKBENCH_SEARCH)
+        );
+
+        return new MineTaleRecipeBookComponent(menu, tabs, ModRecipes.WORKBENCH_TYPE);
+    }
+
+    /**
+         * Configure the screen's GUI dimensions and initialize widgets.
+         *
+         * Sets the layout size (imageWidth = 176, imageHeight = 166), delegates remaining
+         * layout initialization to the superclass, and creates the three craft buttons
+         * ("1", "30", "All") wired to their respective handlers.
+         */
+    @Override
+    protected void init() {
+        // Important: Set your GUI size before super.init()
+        this.imageWidth = 176;
+        this.imageHeight = 166;
+
+        super.init();
+
+        int defaultLeft = this.leftPos + 90;
+        int defaultTop = this.topPos + 25;
+
+        this.craftOneBtn = addRenderableWidget(Button.builder(Component.literal("Craft"), (button) -> {
+            handleCraftRequest(1);
+        }).bounds(defaultLeft, defaultTop, 75, 20).build());
+
+        this.craftTenBtn = addRenderableWidget(Button.builder(Component.literal("x10"), (button) -> {
+            handleCraftRequest(30);
+        }).bounds(defaultLeft, defaultTop + 22, 35, 20).build());
+
+        this.craftAllBtn = addRenderableWidget(Button.builder(Component.literal("All"), (button) -> {
+            handleCraftRequest(-1); // -1 represents "All" logic
+        }).bounds(defaultLeft + 40, defaultTop + 22, 35, 20).build());
+    }
+
+    /**
+     * Sends a crafting request for the currently selected recipe in the integrated recipe book.
+     *
+     * Locates the last recipe collection and last selected recipe ID from the recipe book component,
+     * resolves the recipe's result item, and sends a CraftRequestPayload to the server containing that
+     * item and the requested amount.
+     *
+     * @param amount the quantity to craft; use -1 to request crafting of the full available stack ("All")
+     */
+
+    private void handleCraftRequest(int amount) {
+        // 1. Cast the book component to the Accessor to get the selected data
+        RecipeBookComponentAccessor accessor = (RecipeBookComponentAccessor) this.mineTaleRecipeBook;
+
+        RecipeCollection collection = accessor.getLastRecipeCollection();
+        RecipeDisplayId displayId = accessor.getLastRecipe();
+
+        if (collection != null && displayId != null) {
+            // 2. Find the visual entry
+            for (RecipeDisplayEntry entry : collection.getSelectedRecipes(RecipeCollection.CraftableStatus.ANY)) {
+                if (entry.id().equals(displayId)) {
+                    // 3. Resolve result for the packet
+                    List<ItemStack> results = entry.resultItems(SlotDisplayContext.fromLevel(this.minecraft.level));
+
+                    if (!results.isEmpty()) {
+                        ItemStack resultStack = results.get(0);
+
+                        // 4. LOG FOR DEBUGGING
+                        System.out.println("Sending craft request for: " + resultStack + " amount: " + amount);
+
+                        ClientPlayNetworking.send(new CraftRequestPayload(resultStack, amount));
+                    }
+                    break;
+                }
+            }
+        } else {
+            System.out.println("Request failed: Collection or DisplayID is null!");
+        }
+    }
+
+    /**
+    * Draws the workbench GUI background texture at the screen's top-left corner.
+    *
+    * @param guiGraphics the graphics context used to draw GUI elements
+    * @param f           partial tick time for interpolation
+    * @param i           current mouse x coordinate relative to the window
+    * @param j           current mouse y coordinate relative to the window
+    */
+   protected void renderBg(GuiGraphics guiGraphics, float f, int i, int j) {
+      int k = this.leftPos;
+      int l = this.topPos;
+      guiGraphics.blit(RenderPipelines.GUI_TEXTURED, TEXTURE, k, l, 0.0F, 0.0F, this.imageWidth, this.imageHeight, 256, 256);
+   }
+
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        renderBackground(graphics, mouseX, mouseY, delta);
+        super.render(graphics, mouseX, mouseY, delta);
+
+        // Get the ID of the recipe clicked in the ghost-book
+        RecipeDisplayId displayId = this.mineTaleRecipeBook.getSelectedRecipeId();
+        RecipeDisplayEntry selectedEntry = null;
+
+        if (displayId != null && this.minecraft.level != null) {
+            ClientRecipeBook book = this.minecraft.player.getRecipeBook();
+            // Accessing the known recipes via your Accessor
+            Map<RecipeDisplayId, RecipeDisplayEntry> knownRecipes = ((ClientRecipeBookAccessor) book).getKnown();
+            selectedEntry = knownRecipes.get(displayId);
+        }
+
+        // 2. Button Activation Logic
+        if (selectedEntry != null) {
+            // We use the entry directly. It contains the 15 ingredients needed!
+            boolean canCraftOne = canCraft(this.minecraft.player, selectedEntry, 1);
+            boolean canCraftTen = canCraft(this.minecraft.player, selectedEntry, 10);
+
+            this.craftOneBtn.active = canCraftOne;
+            this.craftTenBtn.active = canCraftTen;
+            this.craftAllBtn.active = canCraftOne;
+        } else {
+            this.craftOneBtn.active = false;
+            this.craftTenBtn.active = false;
+            this.craftAllBtn.active = false;
+        }
+
+        renderTooltip(graphics, mouseX, mouseY);
+    }
+
+    private boolean canCraft(Player player, RecipeDisplayEntry entry, int craftCount) {
+        if (player == null || entry == null) return false;
+
+        // craftingRequirements() provides the list of all items (the 15 items for your chest)
+        Optional<List<Ingredient>> reqs = entry.craftingRequirements();
+        if (reqs.isEmpty()) return false;
+
+        // 1. Group duplicate ingredients (e.g., 5 Log entries become 1 Log entry with a value of 5)
+        Map<Ingredient, Integer> aggregatedRequirements = new HashMap<>();
+        for (Ingredient ing : reqs.get()) {
+            aggregatedRequirements.put(ing, aggregatedRequirements.getOrDefault(ing, 0) + 1);
+        }
+
+        // 2. Check the player's inventory against the totals
+        Inventory inv = player.getInventory();
+        for (Map.Entry<Ingredient, Integer> entryReq : aggregatedRequirements.entrySet()) {
+            // totalNeeded = (Amount in 1 recipe) * (Number of crafts, e.g. 1 or 30)
+            int totalNeeded = entryReq.getValue() * craftCount;
+
+            if (!hasIngredientAmount(inv, entryReq.getKey(), totalNeeded)) {
+                return false; // Player doesn't have enough of this specific ingredient
+            }
+        }
+
+        return true;
+    }
+
+    private boolean hasIngredientAmount(Inventory inventory, Ingredient ingredient, int totalRequired) {
+        System.out.println("DEBUG: Searching inventory for " + totalRequired + " of an ingredient...");
+        if (totalRequired <= 0) return true;
+
+        int found = 0;
+        for (int i = 0; i < inventory.getContainerSize(); i++) {
+            ItemStack stack = inventory.getItem(i);
+            if (!stack.isEmpty() && ingredient.test(stack)) {
+                found += stack.getCount();
+                System.out.println("DEBUG: Found " + stack.getCount() + " in slot " + i + ". Total found: " + found);
+            }
+            if (found >= totalRequired) {
+                System.out.println("DEBUG: Ingredient requirement MET");
+                return true;
+            }
+        }
+
+        System.out.println("DEBUG: Ingredient requirement FAILED. Only found: " + found + "/" + totalRequired);
+        return false;
+    }
+
+    /**
+     * Computes the on-screen position for the recipe book toggle button for this GUI.
+     *
+     * @return the screen position placed 5 pixels from the GUI's left edge and 49 pixels above the GUI's vertical center
+     */
+    @Override
+    protected ScreenPosition getRecipeBookButtonPosition() {
+        // 1. Calculate the start (left) of your workbench GUI
+        int guiLeft = (this.width - this.imageWidth) / 2;
+
+        // 2. Calculate the top of your workbench GUI
+        int guiTop = (this.height - this.imageHeight) / 2;
+
+        // 3. Standard Vanilla positioning: 
+        // Usually 5 pixels in from the left and 49 pixels up from the center
+        return new ScreenPosition(guiLeft + 5, guiTop + this.imageHeight / 2 - 49);
+    }
+}

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

@@ -5,14 +5,31 @@
 import net.fabricmc.fabric.api.datagen.v1.FabricDataOutput;
 import net.minecraft.client.data.models.BlockModelGenerators;
 import net.minecraft.client.data.models.ItemModelGenerators;
+import net.minecraft.client.data.models.blockstates.MultiVariantGenerator;
+import net.minecraft.client.data.models.blockstates.PropertyDispatch;
+import net.minecraft.client.data.models.model.ModelLocationUtils;
+import net.minecraft.client.renderer.block.model.VariantMutator;
+import net.minecraft.core.Direction;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.ChestType;
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
 
 public class ModModelProvider extends FabricModelProvider {
     /**
- * Creates a ModModelProvider using the given Fabric data output.
- *
- * @param output the FabricDataOutput used to write generated model and blockstate data
- */
-public ModModelProvider(FabricDataOutput output) { super(output); }
+     * Creates a ModModelProvider using the given Fabric data output.
+     *
+     * @param output the FabricDataOutput used to write generated model and blockstate data
+     */
+    public ModModelProvider(FabricDataOutput output) { super(output); }
+
+    // Recreate the rotation logic locally since the base one is private
+    private static final PropertyDispatch<VariantMutator> WORKBENCH_ROTATION = PropertyDispatch.modify(BlockStateProperties.HORIZONTAL_FACING)
+            .select(Direction.NORTH, BlockModelGenerators.NOP)
+            .select(Direction.EAST, BlockModelGenerators.Y_ROT_90)
+            .select(Direction.SOUTH, BlockModelGenerators.Y_ROT_180)
+            .select(Direction.WEST, BlockModelGenerators.Y_ROT_270);
 
     /**
      * Registers block state and model definitions for the mod's log blocks.
@@ -54,6 +71,38 @@ public void generateBlockStateModels(BlockModelGenerators blockStateModelGenerat
         blockStateModelGenerator.woodProvider(ModBlocks.STRIPPED_LOG).logWithHorizontal(ModBlocks.STRIPPED_LOG);
         blockStateModelGenerator.woodProvider(ModBlocks.WINDWILLOW_LOG).logWithHorizontal(ModBlocks.WINDWILLOW_LOG);
         blockStateModelGenerator.woodProvider(ModBlocks.WILD_WISTERIA_LOG).logWithHorizontal(ModBlocks.WILD_WISTERIA_LOG).wood(ModBlocks.WILD_WISTERIA_WOOD);
+
+        registerLargeWorkbench(blockStateModelGenerator, ModBlocks.FURNACE_WORKBENCH_BLOCK_T1);
+    }
+
+    private void registerLargeWorkbench(BlockModelGenerators generator, Block block) {
+        // 1. Get the base identifier (e.g., minetale:block/furnace_workbench_block_t1)
+        Identifier blockId = ModelLocationUtils.getModelLocation(block);
+
+        // 2. Build the references to your manual JSON files
+        // .withSuffix() creates: minetale:block/furnace_workbench_block_t1_bottom_left, etc.
+        Identifier bottomLeft  = blockId.withSuffix("_bottom_left");
+        Identifier bottomRight = blockId.withSuffix("_bottom_right");
+        Identifier topLeft     = blockId.withSuffix("_top_left");
+        Identifier topRight    = blockId.withSuffix("_top_right");
+        Identifier inventory   = blockId.withSuffix("_inventory");
+
+        // 3. Dispatch to Blockstate (Tells the game which model to show for each state)
+        generator.blockStateOutput.accept(MultiVariantGenerator.dispatch(block)
+            .with(PropertyDispatch.initial(BlockStateProperties.DOUBLE_BLOCK_HALF, BlockStateProperties.CHEST_TYPE)
+                .select(DoubleBlockHalf.LOWER, ChestType.LEFT,   BlockModelGenerators.plainVariant(bottomLeft))
+                .select(DoubleBlockHalf.LOWER, ChestType.RIGHT,  BlockModelGenerators.plainVariant(bottomRight))
+                .select(DoubleBlockHalf.UPPER, ChestType.LEFT,   BlockModelGenerators.plainVariant(topLeft))
+                .select(DoubleBlockHalf.UPPER, ChestType.RIGHT,  BlockModelGenerators.plainVariant(topRight))
+                // Support the 'SINGLE' state as a fallback
+                .select(DoubleBlockHalf.LOWER, ChestType.SINGLE, BlockModelGenerators.plainVariant(bottomLeft))
+                .select(DoubleBlockHalf.UPPER, ChestType.SINGLE, BlockModelGenerators.plainVariant(topLeft))
+            )
+            .with(WORKBENCH_ROTATION)
+        );
+
+        // 4. Map the Item in your hand to the inventory JSON
+        generator.registerSimpleItemModel(block, inventory);
     }
 
     /**