BREAKING CHANGE: Port AutoOffhand to Minecraft 1.18.2

This commit ports the AutoOffhand mod from Minecraft 1.16.5 to 1.18.2, adapting to significant changes in the Forge API and Minecraft mappings. Not all changes may be listed here.

**Key Changes:**

**1. API Updates & Package/Class Renames:**
    *   Updated numerous imports to reflect package changes in Forge and Minecraft (e.g., `net.minecraft.world.entity`, `net.minecraft.network.chat`, `com.mojang.blaze3d.platform`).
    *   Renamed core classes:
        *   `PlayerEntity` -> `Player`
        *   `ServerPlayerEntity` -> `ServerPlayer`
        *   `ProjectileEntity` -> `Projectile`
        *   `TridentEntity` -> `ThrownTrident`
        *   `CompoundNBT` -> `CompoundTag`
        *   `KeyBinding` -> `KeyMapping`
        *   `ITextComponent` -> `Component`
        *   `TranslationTextComponent` -> `TranslatableComponent`
        *   `PlayerInventory` -> `Inventory`
        *   `NetworkManager` -> `Connection`
    *   Updated method calls for renamed/refactored vanilla classes (e.g., `player.getLevel().isClientSide()`, `player.getInventory()`, `entity.isRemoved()`, `entity.discard()`).
    *   Registry names are now primarily accessed via `ForgeRegistries` (e.g., `ForgeRegistries.ITEMS.getKey(item)`, `ForgeRegistries.ENTITIES.getKey(entityType)`).

**2. Event System Changes:**
    *   **Capability Registration:** Moved from `FMLCommonSetupEvent` using `CapabilityManager` to the dedicated `RegisterCapabilitiesEvent` on the MOD event bus.
    *   **Command Registration:** Moved from `FMLServerStartingEvent` (Forge bus) to the dedicated `RegisterCommandsEvent` (Forge bus).
    *   **Setup Events:** Utilized `event.enqueueWork()` more consistently in `FMLCommonSetupEvent` and `FMLClientSetupEvent` for thread-safe operations like network registration and screen registration.

**3. Capability Handling:**
    *   Capability interface (`IPlayerConfig`) and provider (`PlayerConfigProvider`) remain structurally similar.
    *   Registration logic updated as described above.
    *   Event handlers (`onAttachCapabilitiesPlayer`, `onPlayerClone`, `onPlayerLoggedIn`, `onPlayerChangedDimension`) updated to use new class names (`Player`, `ServerPlayer`).

**4. Networking:**
    *   Network packet classes (`SyncConfigPacket`, `RequestConfigPacket`, etc.) remain largely the same.
    *   `NetworkHandler` registration moved to `commonSetup`'s `enqueueWork`.
    *   Checking if a client has the mod installed during login (`onPlayerLoggedIn`) now uses the `Connection` object instead of `NetworkManager`.

**5. Client-Side Changes:**
    *   **Container/Menu:**
        *   Registered `ConfigItemListContainer` using a `DeferredRegister<MenuType<?>>` in `ClientSetup`.
        *   Screen factory registered using `MenuScreens.register` within `clientSetup`'s `enqueueWork`.
    *   **Keybinding:**
        *   Uses `KeyMapping` and `InputConstants` instead of `KeyBinding` and `InputMappings`. Registration is often handled automatically for static final fields.
    *   **GUI:** Updated `ConfigItemListScreen` to use `Component` and `Inventory`.

**6. Item/Entity Handling:**
    *   **Pickup Logic (`onPlayerPickupItem`):** Updated to use `InteractionHand`, `player.getLevel().isClientSide()`, `entity.discard()`, `entity.isRemoved()`. Item registry name logging adapted.
    *   **Config Check (`shouldMoveToOffhand`):** Updated to use `Player` and `ForgeRegistries.ITEMS.getKey()`. Item comparison logic (`ConfigItemUtils.stacksMatchIgnoreDamageAndCount`) remains, assuming internal compatibility or necessary updates within that utility class.
    *   **Projectile Return (`onProjectileReturn`, `checkAndMoveSpecificInventoryItem`):**
        *   Updated entity types (`ThrownTrident`, `Projectile`).
        *   Uses `CompoundTag` for NBT handling.
        *   Uses `ForgeRegistries.ENTITIES.getKey()` for entity type comparison.
        *   Uses `TickTask` instead of `TickDelayedTask` for scheduling the inventory check.
        *   Uses `ItemStack.isSameItemSameTags()` for more precise item comparison when moving returned items.
        *   Updated inventory access (`player.getInventory()`).

**7. Configuration:**
    *   `ModConfig` loading remains registered in the main mod class constructor.
    *   `ConfigItemUtils` parsing logic is assumed to be compatible, interacting with updated APIs where necessary (e.g., registry names).

Author: Th-Underscore

README.md

@@ -2,7 +2,7 @@
 
 ## Description
 
-AutoOffhand is a server-side Minecraft Forge mod for Minecraft 1.16.5, designed to automatically manage your offhand slot. It moves specific items directly into your offhand when you pick them up, provided the slot is empty. It also intelligently handles returning projectiles like Loyalty Tridents, placing them back into your offhand if configured.
+AutoOffhand is a server-side Minecraft Forge mod for Minecraft [1.16.5](https://github.com/Th-Underscore/AutoOffhand/releases/tag/v0.0.1) and [1.18.2](https://github.com/Th-Underscore/AutoOffhand/releases/tag/v0.0.2), designed to automatically manage your offhand slot. It moves specific items directly into your offhand when you pick them up, provided the slot is empty. It also intelligently handles returning projectiles like Loyalty Tridents, placing them back into your offhand if configured.
 
 ## Features
 
@@ -25,6 +25,11 @@ AutoOffhand is a server-side Minecraft Forge mod for Minecraft 1.16.5, designed
     *   Add or remove item registry names (right-click) or specific item NBT strings (left-click) to customize your personal list.
     *   Use the `/autooffhand toggle` command to switch between using the server's global config list and your own.
 
+## Compatibility
+
+*   Tetra's Modular Items (https://www.curseforge.com/minecraft/mc-mods/tetra)
+*   If you want me to add more, please let me know!
+
 ## Building
 
 This project uses Forge Gradle. Use the following commands:

build.gradle

@@ -13,7 +13,7 @@ base {
     }
 
 // Mojang ships Java 17 to end users in 1.18+, so your mod should target Java 17.
-java.toolchain.languageVersion = JavaLanguageVersion.of(8)
+java.toolchain.languageVersion = JavaLanguageVersion.of(17)
 
 println "Java: ${System.getProperty 'java.version'}, JVM: ${System.getProperty 'java.vm.version'} (${System.getProperty 'java.vendor'}), Arch: ${System.getProperty 'os.arch'}"
 minecraft {

gradle.properties

@@ -7,17 +7,17 @@ org.gradle.daemon=false
 ## Environment Properties
 
 # The Minecraft version must agree with the Forge version to get a valid artifact
-minecraft_version=1.16.5
+minecraft_version=1.18.2
 # The Minecraft version range can use any release version of Minecraft as bounds.
 # Snapshots, pre-releases, and release candidates are not guaranteed to sort properly
 # as they do not follow standard versioning conventions.
-minecraft_version_range=[1.16.5,1.17)
+minecraft_version_range=[1.18,1.18.2]
 # The Forge version must agree with the Minecraft version to get a valid artifact
-forge_version=36.2.42
+forge_version=40.2.17
 # The Forge version range can use any version of Forge as bounds or match the loader version range
-forge_version_range=[36,)
+forge_version_range=[40,)
 # The loader version range can only use the major version of Forge/FML as bounds
-loader_version_range=[36,)
+loader_version_range=[40,)
 # The mapping channel to use for mappings.
 # The default set of supported mapping channels are ["official", "snapshot", "snapshot_nodoc", "stable", "stable_nodoc"].
 # Additional mapping channels can be registered through the "channelProviders" extension in a Gradle plugin.
@@ -35,7 +35,7 @@ loader_version_range=[36,)
 mapping_channel=official
 # The mapping version to query from the mapping channel.
 # This must match the format required by the mapping channel.
-mapping_version=1.16.5
+mapping_version=1.18.2
 
 
 ## Mod Properties
@@ -48,12 +48,12 @@ mod_name=AutoOffhand
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=All Rights Reserved
 # The mod version. See https://semver.org/
-mod_version=0.0.1
+mod_version=0.0.2+1.18.2
 # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
 # This should match the base package used for the mod sources.
 # See https://maven.apache.org/guides/mini/guide-naming-conventions.html
-mod_group_id=com.example.autooffhand
+mod_group_id=com.thunderscore.autooffhand
 # The authors of the mod. This is a simple text string that is used for display purposes in the mod list.
 mod_authors=Th-Underscore
 # The description of the mod. This is a simple multiline text string that is used for display purposes in the mod list.
-mod_description=Example mod description.\nNewline characters can be used and will be replaced properly.
+mod_description=Automatically switch specific items to the offhand on pickup.

src/main/java/com/thunderscore/autooffhand/AutoOffhand.java

@@ -1,101 +1,87 @@
 package com.thunderscore.autooffhand;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
 import com.thunderscore.autooffhand.capability.IPlayerConfig;
-import com.thunderscore.autooffhand.capability.PlayerConfig;
-import com.thunderscore.autooffhand.capability.PlayerConfigStorage;
 import com.thunderscore.autooffhand.command.ModCommands;
 import com.thunderscore.autooffhand.config.ModConfig;
-import com.thunderscore.autooffhand.inventory.ModContainers;
 import com.thunderscore.autooffhand.network.NetworkHandler;
-
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.common.capabilities.CapabilityManager;
+import net.minecraftforge.common.capabilities.RegisterCapabilitiesEvent;
+import net.minecraftforge.event.RegisterCommandsEvent;
 import net.minecraftforge.eventbus.api.IEventBus;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.ModLoadingContext;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.config.ModConfig.Type;
 import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
 import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
-import net.minecraftforge.fml.event.server.FMLServerStartingEvent;
 import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
 import net.minecraftforge.fml.loading.FMLEnvironment;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 // The value here should match an entry in the META-INF/mods.toml file
-@Mod(AutoOffhand.MOD_ID) // Updated class name reference
-public class AutoOffhand { // Updated class name
-
+@Mod(AutoOffhand.MOD_ID)
+public class AutoOffhand {
     // Make logger public so other classes can access it
     public static final Logger LOGGER = LogManager.getLogger();
-    public static final String MOD_ID = "autooffhand"; // Define mod ID constant
+    public static final String MOD_ID = "autooffhand";
 
     public AutoOffhand() {
         final IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus();
 
-        // Register the config - Changed to SERVER type and SERVER_SPEC
         ModLoadingContext.get().registerConfig(Type.SERVER, ModConfig.SERVER_SPEC);
 
-        // Register ContainerType Deferred Register ONLY on the client side
         if (FMLEnvironment.dist == Dist.CLIENT) {
-            ModContainers.CONTAINERS.register(modEventBus);
-            LOGGER.debug("Registered ModContainers DeferredRegister on CLIENT.");
-        } else {
-            LOGGER.debug("Skipped registering ModContainers DeferredRegister on SERVER.");
+            ClientSetup.CONTAINERS.register(modEventBus);
+            LOGGER.debug("Registered ClientSetup.CONTAINERS DeferredRegister on CLIENT.");
         }
 
+        // Register setup methods
         modEventBus.addListener(this::commonSetup);
         modEventBus.addListener(this::clientSetup);
+        // Register capability registration event handler
+        modEventBus.addListener(this::registerCapabilities);
         // Register the static onCommonSetup method from ForgeEventHandler for the FMLCommonSetupEvent
         modEventBus.addListener(ForgeEventHandler::onCommonSetup);
 
-        MinecraftForge.EVENT_BUS.register(this);
+        // Register Forge event bus listeners
+        MinecraftForge.EVENT_BUS.register(this); // For onRegisterCommands
+        MinecraftForge.EVENT_BUS.register(ForgeEventHandler.class); // For other game events
 
         LOGGER.debug("AutoOffhand Mod Initialized");
     }
 
-    // Runs during common setup (both client and server)
+    // Common setup (client and server)
     private void commonSetup(final FMLCommonSetupEvent event) {
         LOGGER.debug("AutoOffhand common setup starting.");
 
-        // Register Capability
-        event.enqueueWork(() -> { // Capabilities should be registered during enqueueWork
-            CapabilityManager.INSTANCE.register(
-                IPlayerConfig.class,                // Capability Interface
-                new PlayerConfigStorage(),          // Storage Implementation
-                PlayerConfig::new                   // Factory for default instance
-            );
-            LOGGER.debug("Registered PlayerConfig capability.");
-        });
-
-
-        // Register the new top-level event handler class (includes capability events now)
-        MinecraftForge.EVENT_BUS.register(ForgeEventHandler.class);
-        LOGGER.debug("AutoOffhand ForgeEventHandler class registered on Forge event bus.");
+        // Old capability registration removed. It's handled by registerCapabilities event now.
 
         // Register network packets
-        NetworkHandler.register();
-        LOGGER.debug("Registered network packets."); // Added log
+        event.enqueueWork(NetworkHandler::register); // Network registration often needs enqueueWork
+        LOGGER.debug("Scheduled network packet registration.");
     }
 
-    // Renamed from 'setup' - Runs during client setup ONLY
+    // Client setup ONLY
     private void clientSetup(final FMLClientSetupEvent event) {
         LOGGER.debug("AutoOffhand client setup starting.");
-        // Call client setup directly (removed enqueueWork)
-        ClientSetup.init(event);
-        LOGGER.debug("AutoOffhand client setup complete."); // Adjusted log message
+        // Call client setup directly
+        event.enqueueWork(() -> ClientSetup.init(event)); // ClientSetup might need enqueueWork too
+        LOGGER.debug("Scheduled client setup initialization.");
     }
 
-    // Event handler for FMLServerStartingEvent (called on the Forge bus, needs @SubscribeEvent)
+    // Event handler for RegisterCapabilitiesEvent (called on the MOD bus)
+    public void registerCapabilities(final RegisterCapabilitiesEvent event) {
+        event.register(IPlayerConfig.class);
+        LOGGER.debug("Registered PlayerConfig capability via RegisterCapabilitiesEvent.");
+    }
+
+    // Event handler for RegisterCommandsEvent (called on the FORGE bus)
     @SubscribeEvent
-    public void onServerStarting(FMLServerStartingEvent event) {
-        LOGGER.debug("Registering AutoOffhand commands...");
-        ModCommands.register(event.getServer().getCommands().getDispatcher());
+    public void onRegisterCommands(RegisterCommandsEvent event) {
+        LOGGER.debug("Registering AutoOffhand commands via RegisterCommandsEvent...");
+        ModCommands.register(event.getDispatcher()); // Pass the dispatcher directly
         LOGGER.debug("AutoOffhand commands registered.");
     }
-
-    // Removed the static inner ForgeEvents class as it's now in ForgeEventHandler.java
 }

src/main/java/com/thunderscore/autooffhand/ClientSetup.java

@@ -6,59 +6,65 @@
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.glfw.GLFW;
 
+import com.mojang.blaze3d.platform.InputConstants;
 import com.thunderscore.autooffhand.gui.ConfigItemListScreen;
 import com.thunderscore.autooffhand.inventory.ConfigItemListContainer;
-import com.thunderscore.autooffhand.inventory.ModContainers;
 import com.thunderscore.autooffhand.network.NetworkHandler;
 import com.thunderscore.autooffhand.network.RequestConfigPacket;
 
+import net.minecraft.world.inventory.MenuType;
+import net.minecraftforge.common.extensions.IForgeMenuType;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+import net.minecraftforge.registries.RegistryObject;
+
+import net.minecraft.client.KeyMapping;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.ScreenManager;
-import net.minecraft.client.settings.KeyBinding;
-import net.minecraft.client.util.InputMappings;
-import net.minecraft.entity.player.PlayerInventory;
-import net.minecraft.util.text.ITextComponent;
-import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.client.gui.screens.MenuScreens;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.world.entity.player.Inventory;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.client.event.InputEvent;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.client.registry.ClientRegistry;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
 
 @Mod.EventBusSubscriber(modid = AutoOffhand.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
 public class ClientSetup {
-    // Add logger for this class
     private static final Logger LOGGER = LogManager.getLogger();
 
-    // Define the keybinding
-    public static final KeyBinding OPEN_CONFIG_GUI_KEY = new KeyBinding(
+    public static final DeferredRegister<MenuType<?>> CONTAINERS = DeferredRegister.create(ForgeRegistries.CONTAINERS, AutoOffhand.MOD_ID);
+
+    public static final RegistryObject<MenuType<ConfigItemListContainer>> CONFIG_ITEM_LIST_CONTAINER = CONTAINERS.register(
+            "config_item_list_container", // Registry name must match the one expected by packets/screens
+            () -> IForgeMenuType.create((windowId, inv, data) -> new ConfigItemListContainer(windowId, inv))
+    );
+
+    public static final KeyMapping OPEN_CONFIG_GUI_KEY = new KeyMapping(
             "key." + AutoOffhand.MOD_ID + ".open_config_gui", // Translation key
-            InputMappings.Type.KEYSYM, // Type of input (keyboard)
-            GLFW.GLFW_KEY_O, // Default key (O) - Choose an appropriate default
+            InputConstants.Type.KEYSYM,
+            GLFW.GLFW_KEY_O, // Default key (O)
             "key.categories." + AutoOffhand.MOD_ID // Translation key for category
     );
 
-    // Called during FMLClientSetupEvent
     public static void init(final FMLClientSetupEvent event) {
-        // ContainerType Deferred Register is registered in the main mod constructor
-
-        // Register the keybinding
-        ClientRegistry.registerKeyBinding(OPEN_CONFIG_GUI_KEY);
-
-        // Register the ScreenFactory for our ContainerType
-        // Assumes ModContainers.CONFIG_ITEM_LIST_CONTAINER is registered elsewhere
-        ScreenManager.register(
-            ModContainers.CONFIG_ITEM_LIST_CONTAINER.get(), // Get the registered ContainerType
-            // Explicit lambda matching the IScreenFactory signature
-            (ConfigItemListContainer container, PlayerInventory inv, ITextComponent title) -> new ConfigItemListScreen(container, inv, title)
-        );
-
-        // Register an INSTANCE of this class to the Forge event bus for non-static methods
+        // Register an INSTANCE of this class to the Forge event bus for non-static methods like onKeyInput
         MinecraftForge.EVENT_BUS.register(new ClientSetup());
 
-        LOGGER.debug("Client setup complete.");
+        // Use enqueueWork for thread-safe operations like screen registration
+        event.enqueueWork(() -> {
+            // Register Menu Screen
+            MenuScreens.register(
+                CONFIG_ITEM_LIST_CONTAINER.get(),
+                // Use a lambda to explicitly call the constructor matching (container, inv, title)
+                (ConfigItemListContainer container, Inventory inv, Component title) -> new ConfigItemListScreen(container, inv, title)
+            );
+            LOGGER.debug("Registered menu screens.");
+        });
+
+        LOGGER.debug("Client setup init phase complete.");
     }
 
     /**
@@ -68,7 +74,7 @@ public static void init(final FMLClientSetupEvent event) {
      * @param initialConfigEntries The list of entries sent by the server.
      * @param isServerConfig True if the entries are for the server config, false for player config.
       */
-    public static void openConfigScreen(List<String> initialConfigEntries, boolean isServerConfig) { // Add isServerConfig parameter
+    public static void openConfigScreen(List<String> initialConfigEntries, boolean isServerConfig) {
         // Ensure we have a player and are on the client
         Minecraft mc = Minecraft.getInstance();
         if (mc.player != null) {
@@ -78,12 +84,12 @@ public static void openConfigScreen(List<String> initialConfigEntries, boolean i
                     // Create a new container instance on the client
                     // Note: The windowId (0) might be okay for client-opened screens,
                     // but needs verification if server interaction causes issues.
-                    new ConfigItemListContainer(0, mc.player.inventory),
-                    mc.player.inventory,
-                    // Dynamically change title based on config type (Explicit cast added)
-                    (ITextComponent) new TranslationTextComponent(isServerConfig ? "gui." + AutoOffhand.MOD_ID + ".config_item_list.title_server" : "gui." + AutoOffhand.MOD_ID + ".config_item_list.title_player"),
-                    initialConfigEntries, // Pass the list
-                    isServerConfig // Pass the flag to the screen constructor
+                    new ConfigItemListContainer(0, mc.player.getInventory()),
+                    mc.player.getInventory(),
+                    // Dynamically change title based on config type
+                    new TranslatableComponent(isServerConfig ? "gui." + AutoOffhand.MOD_ID + ".config_item_list.title_server" : "gui." + AutoOffhand.MOD_ID + ".config_item_list.title_player"), // Reverted to new TranslatableComponent
+                    initialConfigEntries,
+                    isServerConfig
                 )
             );
             LOGGER.debug("Opened config screen (isServerConfig={}). Initial entries provided: {}", isServerConfig, initialConfigEntries != null);