Update to MC 1.21.10

Author: rubensworks

.gitignore

@@ -27,3 +27,6 @@ keystore.jks
 secrets.properties
 build_number.properties
 changelog.txt
+
+.cache
+config

build.gradle

@@ -1,6 +1,6 @@
 plugins {
-    id 'net.neoforged.gradle.userdev' version '7.0.192'
-    id 'net.darkhax.curseforgegradle' version '1.1.26'
+    id 'net.neoforged.moddev' version '2.0.119'
+    id 'net.darkhax.curseforgegradle' version '1.1.28'
 	id 'com.github.kt3k.coveralls' version '2.12.0'
     id 'com.diffplug.spotless' version '6.25.0'
     id 'com.github.johnrengelman.shadow' version '8.1.1'
@@ -11,7 +11,6 @@ apply plugin: 'idea'
 apply plugin: 'maven-publish'
 apply plugin: 'jacoco'
 
-import net.neoforged.gradle.common.tasks.PotentiallySignJar
 import net.darkhax.curseforgegradle.Constants
 import net.darkhax.curseforgegradle.TaskPublishCurseForge
 
@@ -114,7 +113,13 @@ repositories {
 }
 
 dependencies {
-    implementation "net.neoforged:neoforge:${project.neoforge_version}"
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.7.1'
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.7.1'
+    testImplementation 'org.junit.platform:junit-platform-suite-api:1.14.1'
+    testImplementation 'org.hamcrest:hamcrest:2.1'
+    testImplementation "org.mockito:mockito-core:2.+"
+    testRuntimeOnly 'org.junit.platform:junit-platform-suite-engine'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 
     // Add something like 'cyclopscore_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local CyclopsCore version.
     if(secrets.cyclopscore_version_local) {
@@ -134,16 +139,17 @@ dependencies {
         }
     }
 
-    // Add something like 'integratedtunnelscompat_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local Integrated Tunnels Compat version.
-    if(secrets.integratedtunnelscompat_version_local) {
-        shadow("org.cyclops.integratedtunnelscompat:integratedtunnelscompat-${project.minecraft_version}-neoforge:${secrets.integratedtunnelscompat_version_local}") {
-            transitive = false
-        }
-    } else {
-        shadow("org.cyclops.integratedtunnelscompat:integratedtunnelscompat-${project.minecraft_version}-neoforge:${project.integratedtunnelscompat_version}") {
-            transitive = false
-        }
-    }
+    // TODO: restore
+//    // Add something like 'integratedtunnelscompat_version_local=0.1.0-DEV' to your gradle.properties if you want to use a custom local Integrated Tunnels Compat version.
+//    if(secrets.integratedtunnelscompat_version_local) {
+//        shadow("org.cyclops.integratedtunnelscompat:integratedtunnelscompat-${project.minecraft_version}-neoforge:${secrets.integratedtunnelscompat_version_local}") {
+//            transitive = false
+//        }
+//    } else {
+//        shadow("org.cyclops.integratedtunnelscompat:integratedtunnelscompat-${project.minecraft_version}-neoforge:${project.integratedtunnelscompat_version}") {
+//            transitive = false
+//        }
+//    }
 
     if(secrets.commoncapabilities_version_local) {
         implementation "org.cyclops.commoncapabilities:commoncapabilities-${project.minecraft_version}-neoforge:${secrets.commoncapabilities_version_local}:deobf"
@@ -157,50 +163,55 @@ dependencies {
     modLib ("io.netty:netty-codec-http:4.1.77.Final") {
         transitive = false
     }
-
-	testImplementation "junit:junit:4.12"
 }
 
-minecraft {
-    accessTransformers {
-        file('src/main/resources/META-INF/accesstransformer.cfg')
-    }
+test {
+    useJUnitPlatform()
 }
 
-subsystems {
+neoForge {
+    version = "${neoforge_version}"
+
     parchment {
-        minecraftVersion = "${project.parchment_minecraft_version}"
-        mappingsVersion = "${project.parchment_version}"
+        mappingsVersion = "${parchment_version}"
+        minecraftVersion = "${parchment_minecraft_version}"
     }
-}
-
-runs {
-    configureEach {
-		systemProperty 'forge.logging.markers', 'REGISTRIES'
-        systemProperty 'forge.logging.console.level', 'debug'
-        systemProperty 'forge.logging.console.level', 'debug'
-        modSource project.sourceSets.main
 
-        dependencies {
-            runtime project.configurations.modLib
-        }
-    }
-	
-    client {
-        systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
+    // Automatically enable neoforge AccessTransformers if the file exists
+    def at = file('src/main/resources/META-INF/accesstransformer.cfg')
+    if (at.exists()) {
+        accessTransformers = [ at.absolutePath ]
     }
 
-    server {
-        systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
-        argument '--nogui'
+    validateAccessTransformers = true
+
+    runs {
+        client {
+            client()
+        }
+        server {
+            server()
+            programArgument '--nogui'
+        }
+        gameTestServer {
+            type = "gameTestServer"
+        }
+        configureEach {
+            systemProperty 'forge.logging.markers', 'REGISTRIES'
+            logLevel = org.slf4j.event.Level.DEBUG
+            systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
+        }
     }
 
-    gameTestServer {
-        systemProperty 'neoforge.enabledGameTestNamespaces', "cyclopscore,${mod_id}"
+    mods {
+        "${mod_id}" {
+            sourceSet(sourceSets.main)
+        }
     }
 
-    clientData {
-        arguments.addAll '--mod', project.mod_id, '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath()
+    unitTest {
+        enable()
+        testedMod = mods.integratedtunnels
     }
 }
 
@@ -226,21 +237,6 @@ javadoc {
     options.addStringOption('Xdoclint:accessibility,html,reference,syntax', '-quiet')
 }
 
-task signJar(type: PotentiallySignJar, dependsOn: jar) {
-	dependsOn(tasks.jar)
-
-    onlyIf {
-        System.getenv().SIGN_KEYSTORE
-    }
-
-    keyStore = System.getenv().SIGN_KEYSTORE
-    alias = System.getenv().SIGN_ALIAS
-    storePass = System.getenv().SIGN_STOREPASS
-    keyPass = System.getenv().SIGN_KEYPASS
-    input = jar.archivePath
-    output = jar.archivePath
-}
-
 task deobfJar(type: Jar) {
     from sourceSets.main.output
     archiveClassifier.set('deobf')

gradle.properties

@@ -4,7 +4,7 @@ group=org.cyclops.integratedtunnels
 java_version=21
 
 # Common
-minecraft_version=1.21.8
+minecraft_version=1.21.10
 mod_name=IntegratedTunnels
 mod_author=rubensworks (aka kroeser)
 mod_id=integratedtunnels
@@ -15,13 +15,13 @@ display_url=https://www.curseforge.com/minecraft/mc-mods/integrated-tunnels
 description=Transfer other stuff over Integrated Dynamics networks.
 fingerprint=bd0353b3e8a2810d60dd584e256e364bc3bedd44
 
-parchment_version=2025.06.15
-parchment_minecraft_version=1.21.5
+parchment_version=2025.10.12
+parchment_minecraft_version=1.21.10
 curseforge_project_id=251389
 modrinth_project_id=Etqy1Omb
 
 # NeoForge
-neoforge_version=21.8.20
+neoforge_version=21.10.53-beta
 neoforge_loader_version_range=[4,)
 neoforge_update_json_url=https://raw.githubusercontent.com/CyclopsMC/Versions/master/neoforge_update/integrated-tunnels.json
 
@@ -31,7 +31,7 @@ org.gradle.daemon=false
 org.gradle.caching=true
 
 # Dependencies
-cyclopscore_version=1.25.5-800
-integrateddynamics_version=1.24.1-1388
+cyclopscore_version=1.25.5-858
+integrateddynamics_version=1.24.1-1415
 integratedtunnelscompat_version=1.0.0-69
-commoncapabilities_version=2.9.7-251
+commoncapabilities_version=2.9.7-299

src/main/java/org/cyclops/integratedtunnels/Capabilities.java

@@ -1,15 +1,17 @@
 package org.cyclops.integratedtunnels;
 
 import net.minecraft.resources.ResourceLocation;
-import net.neoforged.neoforge.energy.IEnergyStorage;
-import net.neoforged.neoforge.fluids.capability.IFluidHandler;
-import net.neoforged.neoforge.items.IItemHandler;
+import net.neoforged.neoforge.transfer.ResourceHandler;
+import net.neoforged.neoforge.transfer.energy.EnergyHandler;
+import net.neoforged.neoforge.transfer.fluid.FluidResource;
+import net.neoforged.neoforge.transfer.item.ItemResource;
 import org.cyclops.commoncapabilities.IngredientComponents;
 import org.cyclops.commoncapabilities.api.capability.itemhandler.ISlotlessItemHandler;
-import org.cyclops.commoncapabilities.ingredient.storage.IngredientComponentStorageWrapperHandlerEnergyStorage;
-import org.cyclops.commoncapabilities.ingredient.storage.IngredientComponentStorageWrapperHandlerFluidStack;
+import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
+import org.cyclops.commoncapabilities.ingredient.storage.IngredientComponentStorageWrapperHandlerEnergyHandler;
 import org.cyclops.commoncapabilities.ingredient.storage.IngredientComponentStorageWrapperHandlerItemStack;
 import org.cyclops.commoncapabilities.ingredient.storage.IngredientComponentStorageWrapperHandlerItemStackSlotless;
+import org.cyclops.commoncapabilities.ingredient.storage.IngredientComponentStorageWrapperHandlerResourceHandler;
 import org.cyclops.integrateddynamics.api.network.NetworkCapability;
 import org.cyclops.integrateddynamics.api.part.PartCapability;
 import org.cyclops.integrateddynamics.core.part.event.RegisterPartCapabilitiesEvent;
@@ -24,33 +26,33 @@ public class Capabilities {
     public static final class ItemNetwork {
         public static final NetworkCapability<IItemNetwork> NETWORK = NetworkCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "item_network"), IItemNetwork.class);
     }
-    public static final class ItemHandler {
-        public static final NetworkCapability<IItemHandler> NETWORK = NetworkCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "item_handler"), IItemHandler.class);
-        public static final PartCapability<IItemHandler> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "item_handler"), IItemHandler.class);
+    public static final class Item {
+        public static final NetworkCapability<ResourceHandler<ItemResource>> NETWORK = NetworkCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "item_handler"), ResourceHandler.asClass());
+        public static final PartCapability<ResourceHandler<ItemResource>> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "item_handler"), ResourceHandler.asClass());
     }
     public static final class SlotlessItemHandler {
         public static final PartCapability<ISlotlessItemHandler> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "slotless_item_handler"), ISlotlessItemHandler.class);
     }
     public static final class FluidNetwork {
         public static final NetworkCapability<IFluidNetwork> NETWORK = NetworkCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "fluid_network"), IFluidNetwork.class);
     }
-    public static final class FluidHandler {
-        public static final NetworkCapability<IFluidHandler> NETWORK = NetworkCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "fluid_handler"), IFluidHandler.class);
-        public static final PartCapability<IFluidHandler> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "fluid_handler"), IFluidHandler.class);
+    public static final class Fluid {
+        public static final NetworkCapability<ResourceHandler<FluidResource>> NETWORK = NetworkCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "fluid_handler"), ResourceHandler.asClass());
+        public static final PartCapability<ResourceHandler<FluidResource>> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "fluid_handler"), ResourceHandler.asClass());
     }
-    public static final class EnergyStorage {
-        public static final PartCapability<IEnergyStorage> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "energy_storage"), IEnergyStorage.class);
+    public static final class Energy {
+        public static final PartCapability<EnergyHandler> PART = PartCapability.create(ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "energy_storage"), EnergyHandler.class);
     }
 
     public static void registerPartCapabilities(RegisterPartCapabilitiesEvent event) {
-        event.register(net.neoforged.neoforge.capabilities.Capabilities.ItemHandler.BLOCK, ItemHandler.PART);
+        event.register(net.neoforged.neoforge.capabilities.Capabilities.Item.BLOCK, Item.PART);
         event.register(org.cyclops.commoncapabilities.api.capability.Capabilities.SlotlessItemHandler.BLOCK, SlotlessItemHandler.PART);
-        event.register(net.neoforged.neoforge.capabilities.Capabilities.FluidHandler.BLOCK, FluidHandler.PART);
-        event.register(net.neoforged.neoforge.capabilities.Capabilities.EnergyStorage.BLOCK, EnergyStorage.PART);
+        event.register(net.neoforged.neoforge.capabilities.Capabilities.Fluid.BLOCK, Fluid.PART);
+        event.register(net.neoforged.neoforge.capabilities.Capabilities.Energy.BLOCK, Energy.PART);
 
-        IngredientComponents.ENERGY.setStorageWrapperHandler(EnergyStorage.PART, new IngredientComponentStorageWrapperHandlerEnergyStorage<>(IngredientComponents.ENERGY, EnergyStorage.PART));
-        IngredientComponents.ITEMSTACK.setStorageWrapperHandler(ItemHandler.PART, new IngredientComponentStorageWrapperHandlerItemStack<>(IngredientComponents.ITEMSTACK, ItemHandler.PART, SlotlessItemHandler.PART));
+        IngredientComponents.ENERGY.setStorageWrapperHandler(Energy.PART, new IngredientComponentStorageWrapperHandlerEnergyHandler<>(IngredientComponents.ENERGY, Energy.PART));
+        IngredientComponents.ITEMSTACK.setStorageWrapperHandler(Item.PART, new IngredientComponentStorageWrapperHandlerItemStack<>(IngredientComponents.ITEMSTACK, Item.PART, SlotlessItemHandler.PART));
         IngredientComponents.ITEMSTACK.setStorageWrapperHandler(SlotlessItemHandler.PART, new IngredientComponentStorageWrapperHandlerItemStackSlotless<>(IngredientComponents.ITEMSTACK, SlotlessItemHandler.PART));
-        IngredientComponents.FLUIDSTACK.setStorageWrapperHandler(FluidHandler.PART, new IngredientComponentStorageWrapperHandlerFluidStack<>(IngredientComponents.FLUIDSTACK, FluidHandler.PART));
+        IngredientComponents.FLUIDSTACK.setStorageWrapperHandler(Fluid.PART, new IngredientComponentStorageWrapperHandlerResourceHandler<>(IngredientComponents.FLUIDSTACK, Fluid.PART, IngredientComponent.FLUIDSTACK_CONVERTER));
     }
 }

src/main/java/org/cyclops/integratedtunnels/api/world/IBlockPlaceHandler.java

@@ -5,6 +5,7 @@
 import net.minecraft.core.Direction;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.Level;
+import net.neoforged.neoforge.transfer.transaction.TransactionContext;
 
 /**
  * An interface for custom block placing actions.
@@ -36,7 +37,8 @@ public interface IBlockPlaceHandler {
      * @param hitY The Y position that is being targeted.
      * @param hitZ The Z position that is being targeted.
      * @param player The placing player.
+     * @param transactionContext The transaction.
      */
-    public void placeBlock(ItemStack itemStack, Level world, BlockPos pos, Direction side, float hitX, float hitY, float hitZ, Player player);
+    public void placeBlock(ItemStack itemStack, Level world, BlockPos pos, Direction side, float hitX, float hitY, float hitZ, Player player, TransactionContext transactionContext);
 
 }

src/main/java/org/cyclops/integratedtunnels/capability/network/TunnelNetworkCapabilityConstructors.java

@@ -1,8 +1,10 @@
 package org.cyclops.integratedtunnels.capability.network;
 
 import net.neoforged.bus.api.SubscribeEvent;
-import net.neoforged.neoforge.fluids.capability.IFluidHandler;
-import net.neoforged.neoforge.items.IItemHandler;
+import net.neoforged.neoforge.transfer.ResourceHandler;
+import net.neoforged.neoforge.transfer.fluid.FluidResource;
+import net.neoforged.neoforge.transfer.ResourceHandler;
+import net.neoforged.neoforge.transfer.item.ItemResource;
 import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
 import org.cyclops.cyclopscore.modcompat.capabilities.DefaultCapabilityProvider;
 import org.cyclops.integrateddynamics.api.network.AttachCapabilitiesEventNetwork;
@@ -20,17 +22,17 @@ public class TunnelNetworkCapabilityConstructors {
     @SubscribeEvent
     public void onNetworkLoad(AttachCapabilitiesEventNetwork event) {
         ItemNetwork itemNetwork = new ItemNetwork(IngredientComponent.ITEMSTACK);
-        IItemHandler itemHandler = itemNetwork.getChannelExternal(net.neoforged.neoforge.capabilities.Capabilities.ItemHandler.BLOCK,
+        ResourceHandler<ItemResource> itemHandler = itemNetwork.getChannelExternal(net.neoforged.neoforge.capabilities.Capabilities.Item.BLOCK,
                 IPositionedAddonsNetworkIngredients.DEFAULT_CHANNEL);
         event.register(Capabilities.ItemNetwork.NETWORK, new DefaultCapabilityProvider<>(itemNetwork));
-        event.register(Capabilities.ItemHandler.NETWORK, new DefaultCapabilityProvider<>(itemHandler));
+        event.register(Capabilities.Item.NETWORK, new DefaultCapabilityProvider<>(itemHandler));
         event.addFullNetworkListener(itemNetwork);
 
         FluidNetwork fluidNetwork = new FluidNetwork(IngredientComponent.FLUIDSTACK);
-        IFluidHandler fluidChannel = fluidNetwork.getChannelExternal(net.neoforged.neoforge.capabilities.Capabilities.FluidHandler.BLOCK,
+        ResourceHandler<FluidResource> fluidChannel = fluidNetwork.getChannelExternal(net.neoforged.neoforge.capabilities.Capabilities.Fluid.BLOCK,
                 IPositionedAddonsNetworkIngredients.DEFAULT_CHANNEL);
         event.register(Capabilities.FluidNetwork.NETWORK, new DefaultCapabilityProvider<>(fluidNetwork));
-        event.register(Capabilities.FluidHandler.NETWORK, new DefaultCapabilityProvider<>(fluidChannel));
+        event.register(Capabilities.Fluid.NETWORK, new DefaultCapabilityProvider<>(fluidChannel));
         event.addFullNetworkListener(fluidNetwork);
     }