Update mod to 1.20.4

build.gradle

@@ -1,7 +1,7 @@
 //file:noinspection GroovyAssignabilityCheck
 
 plugins {
-	id 'fabric-loom' version '1.2-SNAPSHOT'
+	id 'fabric-loom' version '1.4-SNAPSHOT'
 	id 'maven-publish'
 	id 'com.github.johnrengelman.shadow' version '8.+'
 }
@@ -50,7 +50,7 @@ dependencies {
 	modImplementation("net.fabricmc.fabric-api:fabric-api:${project.fabric_version}")
 
 	// Worldedit API
-	modImplementation("com.sk89q.worldedit:worldedit-fabric-mc1.18.2:7.2.10")
+	modImplementation("com.sk89q.worldedit:worldedit-fabric-mc1.20.4:7.2.18-SNAPSHOT")
 }
 
 processResources {
@@ -102,4 +102,4 @@ publishing {
 		// The repositories here will be used for publishing your artifact, not for
 		// retrieving dependencies.
 	}
-}
+}

gradle.properties

@@ -4,14 +4,14 @@ org.gradle.parallel=true
 
 # Fabric Properties
 	# check these on https://fabricmc.net/develop
-	minecraft_version=1.18.2
-	yarn_mappings=1.18.2+build.4
-	loader_version=0.14.6
+	minecraft_version=1.20.4
+	yarn_mappings=1.20.4+build.3
+	loader_version=0.15.3
 
 # Mod Properties
-	mod_version = 1.18.2-2.0.0
+	mod_version = 1.20.4-2.0.0
 	maven_group = tools.redstone
 	archives_base_name = redstonetools
 
 # Dependencies
-	fabric_version=0.53.0+1.18.2
+	fabric_version=0.92.0+1.20.4

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java

@@ -1,21 +1,25 @@
 package tools.redstone.redstonetools;
 
 import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.command.v2.ArgumentTypeRegistry;
 import net.fabricmc.loader.api.FabricLoader;
-import net.minecraft.client.MinecraftClient;
+import net.minecraft.command.argument.serialize.ArgumentSerializer;
+import net.minecraft.util.Identifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import rip.hippo.inject.Doctor;
 import rip.hippo.inject.Injector;
 import tools.redstone.redstonetools.utils.DependencyLookup;
 import tools.redstone.redstonetools.utils.ReflectionUtils;
 
+import java.lang.reflect.InvocationTargetException;
 import java.nio.file.Path;
 
 public class RedstoneToolsClient implements ClientModInitializer {
 
     public static final String MOD_ID = "redstonetools";
-    public static final String MOD_VERSION = "v" + FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow().getMetadata().getVersion().getFriendlyString();
+    public static final String MOD_VERSION = "v" + FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow()
+            .getMetadata().getVersion().getFriendlyString();
     public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
     public static final Path CONFIG_DIR = FabricLoader.getInstance().getConfigDir().resolve("redstonetools");
     public static final Injector INJECTOR = Doctor.createInjector(ReflectionUtils.getModules());
@@ -27,12 +31,41 @@ public void onInitializeClient() {
         // Register game rules
         RedstoneToolsGameRules.register();
 
+        // Register arguments
+        ReflectionUtils.getAllArguments().forEach(argument -> {
+            var nestedClasses = (Class<ArgumentSerializer>[]) argument
+                    .getDeclaredClasses();
+
+            if (nestedClasses.length == 0) {
+                LOGGER.error("Failed to register {} because no serializer nested class was found",
+                        argument.getSimpleName());
+                return;
+            }
+
+            Identifier id = new Identifier(MOD_ID, argument.getSimpleName().toLowerCase());
+
+            try {
+                var serializer = nestedClasses[0].getDeclaredConstructor().newInstance();
+
+                ArgumentTypeRegistry.registerArgumentType(
+                        id,
+                        argument, serializer);
+            } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+                    | InvocationTargetException | NoSuchMethodException | SecurityException e) {
+                LOGGER.error("Failed to register argument type {}. Skipping registration.",
+                        argument.getName());
+            }
+        });
+
         // Register features
-        ReflectionUtils.getFeatures().forEach(feature -> {
+        ReflectionUtils.getFeatures().forEach(feature ->
+
+        {
             LOGGER.trace("Registering feature {}", feature.getClass().getName());
 
             if (feature.requiresWorldEdit() && !DependencyLookup.WORLDEDIT_PRESENT) {
-                LOGGER.warn("Feature {} requires WorldEdit, but WorldEdit is not loaded. Skipping registration.", feature.getName());
+                LOGGER.warn("Feature {} requires WorldEdit, but WorldEdit is not loaded. Skipping registration.",
+                        feature.getName());
                 return;
             }
             feature.register();

src/main/java/tools/redstone/redstonetools/di/FeatureModule.java

@@ -3,6 +3,7 @@
 import com.google.auto.service.AutoService;
 import rip.hippo.inject.DoctorModule;
 import rip.hippo.inject.binding.Binder;
+import tools.redstone.redstonetools.features.AbstractFeature;
 import tools.redstone.redstonetools.utils.ReflectionUtils;
 
 @AutoService(DoctorModule.class)

src/main/java/tools/redstone/redstonetools/features/AbstractFeature.java

@@ -1,7 +1,9 @@
 package tools.redstone.redstonetools.features;
 
 import com.mojang.brigadier.CommandDispatcher;
-import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.minecraft.command.CommandRegistryAccess;
+import net.minecraft.server.command.CommandManager.RegistrationEnvironment;
 import net.minecraft.server.command.ServerCommandSource;
 
 public abstract class AbstractFeature {
@@ -55,6 +57,6 @@ public void register() {
         CommandRegistrationCallback.EVENT.register(this::registerCommands);
     }
 
-    protected abstract void registerCommands(CommandDispatcher<ServerCommandSource> dispatcher, boolean dedicated);
+    protected abstract void registerCommands(CommandDispatcher<ServerCommandSource> dispatcher, CommandRegistryAccess registryAccess, RegistrationEnvironment environment);
 
 }

src/main/java/tools/redstone/redstonetools/features/arguments/Argument.java

@@ -1,20 +1,20 @@
 package tools.redstone.redstonetools.features.arguments;
 
-import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer;
+import tools.redstone.redstonetools.features.arguments.serializers.GenericArgumentType;
 import com.mojang.brigadier.context.CommandContext;
 
 public class Argument<T> {
     private String name;
-    private final TypeSerializer<T, ?> type;
+    private final GenericArgumentType<T, ?> type;
     private boolean optional = false;
     private volatile T value;
     private T defaultValue;
 
-    private Argument(TypeSerializer<T, ?> type) {
+    private Argument(GenericArgumentType<T, ?> type) {
         this.type = type;
     }
 
-    public static <T> Argument<T> ofType(TypeSerializer<T, ?> type) {
+    public static <T> Argument<T> ofType(GenericArgumentType<T, ?> type) {
         return new Argument<>(type);
     }
 
@@ -48,7 +48,7 @@ public String getName() {
         return name;
     }
 
-    public TypeSerializer<T, ?> getType() {
+    public GenericArgumentType<T, ?> getType() {
         return type;
     }
 

src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java

@@ -0,0 +1,71 @@
+package tools.redstone.redstonetools.features.arguments.serializers;
+
+import com.google.auto.service.AutoService;
+import net.minecraft.command.CommandRegistryAccess;
+import net.minecraft.command.argument.serialize.ArgumentSerializer;
+
+import java.math.BigInteger;
+import java.util.Optional;
+
+@AutoService(GenericArgumentType.class)
+public class BigIntegerArgumentType extends IntLikeArgumentType<BigInteger> {
+    private static final BigIntegerArgumentType INSTANCE = new BigIntegerArgumentType(null, null);
+
+    public static BigIntegerArgumentType bigInteger() {
+        return INSTANCE;
+    }
+
+    public static BigIntegerArgumentType bigInteger(BigInteger min) {
+        return new BigIntegerArgumentType(min, null);
+    }
+
+    public static BigIntegerArgumentType bigInteger(BigInteger min, BigInteger max) {
+        return new BigIntegerArgumentType(min, max);
+    }
+
+    private BigIntegerArgumentType(BigInteger min, BigInteger max) {
+        super(BigInteger.class, min, max);
+
+    }
+
+    @Override
+    protected Optional<BigInteger> tryParseOptional(String string, int radix) {
+        try {
+            return Optional.of(new BigInteger(string, radix));
+        } catch (NumberFormatException ignored) {
+            return Optional.empty();
+        }
+    }
+
+    public static class BigIntegerSerializer extends Serializer<BigIntegerArgumentType, ArgumentSerializer.ArgumentTypeProperties<BigIntegerArgumentType>>{
+
+        @Override
+        public ArgumentTypeProperties<BigIntegerArgumentType> getArgumentTypeProperties(BigIntegerArgumentType argumentType) {
+            return new Properties(argumentType.max,argumentType.min);
+        }
+
+        public final class Properties
+                implements ArgumentSerializer.ArgumentTypeProperties<BigIntegerArgumentType>{
+            final BigInteger max, min;
+
+            public Properties(BigInteger max, BigInteger min) {
+                this.max = max;
+                this.min = min;
+            }
+
+            @Override
+            public BigIntegerArgumentType createType(CommandRegistryAccess commandRegistryAccess) {
+                return new BigIntegerArgumentType(this.max,this.min);
+            }
+
+            @Override
+            public ArgumentSerializer<BigIntegerArgumentType, ?> getSerializer() {
+                return BigIntegerSerializer.this;
+            }
+        }
+    }
+
+
+
+
+}

src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java

@@ -1,7 +1,11 @@
 package tools.redstone.redstonetools.features.arguments.serializers;
 
+import com.google.auto.service.AutoService;
+import net.minecraft.command.CommandRegistryAccess;
+import net.minecraft.command.argument.serialize.ArgumentSerializer;
 import tools.redstone.redstonetools.utils.BlockColor;
 
+@AutoService(GenericArgumentType.class)
 public class BlockColorSerializer extends EnumSerializer<BlockColor> {
     private static final BlockColorSerializer INSTANCE = new BlockColorSerializer();
 
@@ -12,4 +16,27 @@ private BlockColorSerializer() {
     public static BlockColorSerializer blockColor() {
         return INSTANCE;
     }
+
+    public static class Serializer
+            extends GenericArgumentType.Serializer<BlockColorSerializer, Serializer.Properties> {
+
+        public final class Properties
+                implements ArgumentSerializer.ArgumentTypeProperties<BlockColorSerializer> {
+
+            @Override
+            public BlockColorSerializer createType(CommandRegistryAccess var1) {
+                return blockColor();
+            }
+
+            @Override
+            public ArgumentSerializer<BlockColorSerializer, ?> getSerializer() {
+                return new Serializer();
+            }
+        }
+
+        @Override
+        public Properties getArgumentTypeProperties(BlockColorSerializer var1) {
+            return new Properties();
+        }
+    }
 }