initial files for furnace block

build.gradle

@@ -37,7 +37,7 @@ dependencies {
 	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 
 	// Fabric API. This is technically optional, but you probably want it anyway.
-	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
+	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"
 
 }
 

gradle.properties

@@ -1,5 +1,5 @@
 # Done to increase the memory available to gradle.
-org.gradle.jvmargs=-Xmx1G
+org.gradle.jvmargs=-Xmx4G
 org.gradle.parallel=true
 
 # IntelliJ IDEA is not yet fully compatible with configuration cache, see: https://github.com/FabricMC/fabric-loom/issues/1349
@@ -8,13 +8,13 @@ org.gradle.configuration-cache=false
 # Fabric Properties
 # check these on https://fabricmc.net/develop
 minecraft_version=1.21.11
-loader_version=0.18.2
-loom_version=1.14-SNAPSHOT
+loader_version=0.18.4
+loom_version=1.15-SNAPSHOT
+
+# Fabric API
+fabric_api_version=0.141.2+1.21.11
 
 # Mod Properties
 mod_version=1.0.0
 maven_group=com.tcm
-archives_base_name=MineTale
-
-# Dependencies
-fabric_version=0.139.4+1.21.11
+archives_base_name=MineTale

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

@@ -1,10 +1,17 @@
 package com.tcm.MineTale;
 
+import com.tcm.MineTale.block.workbenches.screen.FurnaceWorkbenchScreen;
+import com.tcm.MineTale.registry.ModMenuTypes;
+
 import net.fabricmc.api.ClientModInitializer;
+import net.minecraft.client.gui.screens.MenuScreens;
 
 public class MineTaleClient implements ClientModInitializer {
+	/**
+	 * Registers the screen factory for the furnace workbench menu so the client can create FurnaceWorkbenchScreen instances for that menu type.
+	 */
 	@Override
 	public void onInitializeClient() {
-		// This entrypoint is suitable for setting up client-specific logic, such as rendering.
+		MenuScreens.register(ModMenuTypes.FURNACE_WORKBENCH_MENU, FurnaceWorkbenchScreen::new);
 	}
 }

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

@@ -0,0 +1,65 @@
+package com.tcm.MineTale.block.workbenches.screen;
+
+import com.tcm.MineTale.block.workbenches.menu.FurnaceWorkbenchMenu;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.client.renderer.RenderPipelines;
+import net.minecraft.resources.Identifier;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.network.chat.Component;
+
+public class FurnaceWorkbenchScreen extends AbstractContainerScreen<FurnaceWorkbenchMenu> {
+    private static final Identifier TEXTURE = 
+        // Identifier.fromNamespaceAndPath(MineTale.MOD_ID, "textures/gui/container/furnace_workbench.png");
+        Identifier.withDefaultNamespace("textures/gui/container/furnace.png");
+
+    /**
+     * Creates a new furnace workbench screen for the given menu, player inventory, and title.
+     *
+     * @param menu      the container menu that provides slots and syncs 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 FurnaceWorkbenchScreen(FurnaceWorkbenchMenu menu, Inventory inventory, Component title) {
+        super(menu, inventory, title);
+    }
+
+    /**
+     * Initializes the screen and centers the title horizontally by setting {@code titleLabelX}.
+     */
+    @Override
+    protected void init() {
+        super.init();
+        this.titleLabelX = (this.imageWidth - this.font.width(this.title)) / 2;
+    }
+
+    /**
+    * Draws the furnace workbench background texture onto the screen.
+    *
+    * @param guiGraphics the graphics context used for drawing
+    * @param f           partial tick time used for interpolation
+    * @param i           current mouse x position
+    * @param j           current mouse y position
+    */
+   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);
+   }
+
+    /**
+     * Renders the furnace workbench screen, drawing its background, contents, and tooltips.
+     *
+     * @param graphics the graphics context used for rendering
+     * @param mouseX   the current mouse X coordinate
+     * @param mouseY   the current mouse Y coordinate
+     * @param delta    the frame time delta (partial tick) used for animated rendering
+     */
+    @Override
+    public void render(GuiGraphics graphics, int mouseX, int mouseY, float delta) {
+        renderBackground(graphics, mouseX, mouseY, delta);
+        super.render(graphics, mouseX, mouseY, delta);
+        renderTooltip(graphics, mouseX, mouseY);
+    }
+}

src/main/java/com/tcm/MineTale/MineTale.java

@@ -10,6 +10,7 @@
 import com.tcm.MineTale.registry.ModEntities;
 import com.tcm.MineTale.registry.ModEntityDataSerializers;
 import com.tcm.MineTale.registry.ModItems;
+import com.tcm.MineTale.registry.ModMenuTypes;
 
 public class MineTale implements ModInitializer {
 	public static final String MOD_ID = "minetale";
@@ -19,10 +20,17 @@ public class MineTale implements ModInitializer {
 	// That way, it's clear which mod wrote info, warnings, and errors.
 	public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
 
+	/**
+	 * Initializes and registers the mod's game content and subsystems during Fabric startup.
+	 *
+	 * <p>Triggers initialization for blocks, block entities, menu types, entities, items, and entity
+	 * data serializers so they are registered with the game before gameplay begins.</p>
+	 */
 	@Override
 	public void onInitialize() {
 		ModBlocks.initialize();
 		ModBlockEntities.initialize();
+		ModMenuTypes.initialize();
 		ModEntities.initialize();
 		ModItems.initialize();
 

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

@@ -3,7 +3,10 @@
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.util.RandomSource;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.MenuProvider;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.context.BlockPlaceContext;
 import net.minecraft.world.level.Level;
@@ -18,11 +21,15 @@
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.StateDefinition;
 import net.minecraft.world.level.block.state.properties.*;
+import net.minecraft.world.phys.BlockHitResult;
+
 import org.jetbrains.annotations.Nullable;
 
+import com.tcm.MineTale.block.workbenches.entity.AbstractWorkbenchEntity;
+
 import java.util.function.Supplier;
 
-public abstract class AbstractWorkbench<E extends BlockEntity> extends BaseEntityBlock {
+public abstract class AbstractWorkbench<E extends AbstractWorkbenchEntity> extends BaseEntityBlock {
     public static final EnumProperty<Direction> FACING = HorizontalDirectionalBlock.FACING;
     public static final EnumProperty<DoubleBlockHalf> HALF = BlockStateProperties.DOUBLE_BLOCK_HALF;
     public static final EnumProperty<ChestType> TYPE = BlockStateProperties.CHEST_TYPE;
@@ -127,8 +134,98 @@ private boolean isCompatiblePart(BlockState current, BlockState neighbor) {
         return true;
     }
 
+    /**
+     * Registers the block state properties used by this block.
+     *
+     * @param builder the state builder to populate with this block's properties (`FACING`, `HALF`, `TYPE`)
+     */
     @Override
     protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
         builder.add(FACING, HALF, TYPE);
     }
+
+    /**
+     * Create the block entity for the primary anchor of a multipart workbench.
+     *
+     * @param pos   the position where the block entity would be created
+     * @param state the block state at the position
+     * @return the new block entity when this block is the primary anchor (lower half with TYPE `LEFT` or `SINGLE`), or `null` if this block is a secondary part
+     */
+    @Nullable
+    @Override
+    public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        // We only want a Block Entity at the 'primary' anchor point of the structure.
+        // For 1x1: HALF=LOWER, TYPE=SINGLE
+        // For 2x1: HALF=LOWER, TYPE=LEFT
+        // For 2x2: HALF=LOWER, TYPE=LEFT
+
+        boolean isLower = state.getValue(HALF) == DoubleBlockHalf.LOWER;
+        ChestType type = state.getValue(TYPE);
+
+        // If it's the RIGHT side of a wide block, or the UPPER half of a tall block, return null.
+        if (isLower && (type == ChestType.LEFT || type == ChestType.SINGLE)) {
+            return this.blockEntityType.get().create(pos, state);
+        }
+
+        return null;
+    }
+
+    /**
+     * Open the workbench menu for the block's master part when a player interacts without an item.
+     *
+     * @param state     the block state at the clicked position
+     * @param level     the level in which the interaction occurs
+     * @param pos       the position of the block that was interacted with
+     * @param player    the player performing the interaction
+     * @param hitResult details about the hit (hit position and face)
+     * @return {@code InteractionResult.CONSUME} if a menu was opened on the server, {@code InteractionResult.SUCCESS} on the client, {@code InteractionResult.PASS} otherwise
+     */
+    @Override
+    protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hitResult) {
+        if (level.isClientSide()) {
+            return InteractionResult.SUCCESS;
+        }
+
+        // 1. Find the Master Position (Bottom-Left)
+        BlockPos masterPos = getMasterPos(state, pos);
+        BlockEntity blockEntity = level.getBlockEntity(masterPos);
+
+        // 2. Check if the Master block has the MenuProvider trait
+        if (blockEntity instanceof MenuProvider menuProvider) {
+            // 3. Open the Screen (this triggers the ScreenHandler/Menu)
+            player.openMenu(menuProvider);
+            return InteractionResult.CONSUME;
+        }
+
+        return InteractionResult.PASS;
+    }
+
+    /**
+     * Compute the master (bottom-left) anchor position for this workbench block.
+     *
+     * The master is the block that serves as the primary anchor for multi-block
+     * behavior and block-entity placement: if this block is the upper half the
+     * master is one block below; if this block is the right-side part the master
+     * is one block to the left relative to the block's facing.
+     *
+     * @param state the block state used to determine HALF, TYPE, and FACING
+     * @param pos   the current block position
+     * @return the position of the master (bottom-left) block for this workbench
+     */
+    public BlockPos getMasterPos(BlockState state, BlockPos pos) {
+        BlockPos master = pos;
+        Direction facing = state.getValue(FACING);
+
+        // Move down if we are the upper half
+        if (state.getValue(HALF) == DoubleBlockHalf.UPPER) {
+            master = master.below();
+        }
+
+        // Move left if we are the right side (relative to facing)
+        if (state.getValue(TYPE) == ChestType.RIGHT) {
+            master = master.relative(facing.getCounterClockWise());
+        }
+
+        return master;
+    }
 }