Fix 1_16_R2 bukkit config reload error

- Refactored VersionParam to include patch version specification
- Added ConstructorParam to cache constructors & get the default constructor.

Bukkit/src/main/java/net/frankheijden/serverutils/bukkit/entities/BukkitReflection.java

@@ -23,6 +23,7 @@ public class BukkitReflection extends ReflectionUtils {
 
     @Override
     public boolean isCompatible(VersionParam versionParam) {
-        return versionParam.min <= MINOR && MINOR <= versionParam.max;
+        return versionParam.min.minor <= MINOR && versionParam.min.patch <= PATCH
+                && MINOR <= versionParam.max.minor && PATCH <= versionParam.max.patch;
     }
 }

Bukkit/src/main/java/net/frankheijden/serverutils/bukkit/reflection/RCraftServer.java

@@ -9,9 +9,9 @@ import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.get
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.getDeclaredMethod;
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.invoke;
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.set;
+import static net.frankheijden.serverutils.common.reflection.VersionParam.exact;
 import static net.frankheijden.serverutils.common.reflection.VersionParam.max;
 import static net.frankheijden.serverutils.common.reflection.VersionParam.min;
-import static net.frankheijden.serverutils.common.reflection.VersionParam.versionOf;
 
 import java.io.File;
 import java.lang.reflect.Field;
@@ -53,7 +53,7 @@ public class RCraftServer {
                     fieldOf("console"),
                     fieldOf("commandsConfiguration"),
                     fieldOf("overrideAllCommandBlockCommands"),
-                    fieldOf("unrestrictedAdvancements", versionOf(12)),
+                    fieldOf("unrestrictedAdvancements", exact(12)),
                     fieldOf("ignoreVanillaPermissions", min(13)),
                     fieldOf("monsterSpawn"),
                     fieldOf("animalSpawn"),

Bukkit/src/main/java/net/frankheijden/serverutils/bukkit/reflection/RDedicatedServer.java

@@ -1,6 +1,7 @@
 package net.frankheijden.serverutils.bukkit.reflection;
 
 import static net.frankheijden.serverutils.bukkit.entities.BukkitReflection.MINOR;
+import static net.frankheijden.serverutils.bukkit.entities.BukkitReflection.PATCH;
 import static net.frankheijden.serverutils.common.reflection.FieldParam.fieldOf;
 import static net.frankheijden.serverutils.common.reflection.MethodParam.methodOf;
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.get;
@@ -9,6 +10,7 @@ import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.get
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.invoke;
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.set;
 import static net.frankheijden.serverutils.common.reflection.VersionParam.between;
+import static net.frankheijden.serverutils.common.reflection.VersionParam.exact;
 import static net.frankheijden.serverutils.common.reflection.VersionParam.max;
 import static net.frankheijden.serverutils.common.reflection.VersionParam.min;
 
@@ -18,6 +20,7 @@ import java.lang.reflect.Method;
 import java.util.Map;
 
 import net.frankheijden.serverutils.bukkit.entities.BukkitReflection;
+import net.frankheijden.serverutils.common.reflection.VersionParam;
 
 public class RDedicatedServer {
 
@@ -50,8 +53,10 @@ public class RDedicatedServer {
                     methodOf("setForceGamemode", boolean.class),
                     methodOf("n", between(13, 15), boolean.class),
                     methodOf("aZ", max(15)),
+                    methodOf("aZ", min(new VersionParam.Version(16, 2))),
                     methodOf("i", min(16), boolean.class),
-                    methodOf("aY", min(16)));
+                    methodOf("aY", exact(new VersionParam.Version(16, 1))),
+                    methodOf("getCustomRegistry", min(new VersionParam.Version(16, 2))));
         } catch (Exception ex) {
             ex.printStackTrace();
         }
@@ -70,7 +75,14 @@ public class RDedicatedServer {
         Object options = get(fields, console, "options");
 
         if (MINOR >= 13) {
-            Object propertyManager = RDedicatedServerSettings.newInstance(options);
+            Object propertyManager;
+            if (MINOR >= 16 && PATCH >= 2) {
+                propertyManager = RDedicatedServerSettings.newInstance(invoke(methods, console, "getCustomRegistry"),
+                        options);
+            } else {
+                propertyManager = RDedicatedServerSettings.newInstance(options);
+            }
+
             set(fields, console, "propertyManager", propertyManager);
             Object config = invoke(RDedicatedServerSettings.getMethods(), propertyManager, "getProperties");
             invoke(methods, console, "setPVP", getConfigValue(config, "pvp"));
@@ -78,16 +90,20 @@ public class RDedicatedServer {
             invoke(methods, console, "setMotd", getConfigValue(config, "motd"));
             invoke(methods, console, "setForceGamemode", getConfigValue(config, "forceGamemode"));
 
+            Object resourcePackHash;
+            if (MINOR <= 15 || (MINOR == 16 && PATCH == 1)) {
+                resourcePackHash = invoke(methods, console, "aZ");
+            } else {
+                resourcePackHash = invoke(methods, console, "aY");
+            }
+            invoke(methods, console, "setResourcePack", getConfigValue(config, "resourcePack"), resourcePackHash);
+
             if (MINOR <= 15) {
                 invoke(methods, console, "setSpawnAnimals", getConfigValue(config, "spawnAnimals"));
                 invoke(methods, console, "setSpawnNPCs", getConfigValue(config, "spawnNpcs"));
-                invoke(methods, console, "setResourcePack", getConfigValue(config, "resourcePack"),
-                        invoke(methods, console, "aZ"));
                 invoke(methods, console, "n", getConfigValue(config, "enforceWhitelist"));
                 set(fields, console, "o", getConfigValue(config, "gamemode"));
             } else {
-                invoke(methods, console, "setResourcePack", getConfigValue(config, "resourcePack"),
-                        invoke(methods, console, "aY"));
                 invoke(methods, console, "i", getConfigValue(config, "enforceWhitelist"));
             }
         } else {

Bukkit/src/main/java/net/frankheijden/serverutils/bukkit/reflection/RDedicatedServerSettings.java

@@ -1,9 +1,13 @@
 package net.frankheijden.serverutils.bukkit.reflection;
 
+import static net.frankheijden.serverutils.common.reflection.ConstructorParam.constructorOf;
 import static net.frankheijden.serverutils.common.reflection.MethodParam.methodOf;
+import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.getAllConstructors;
 import static net.frankheijden.serverutils.common.reflection.ReflectionUtils.getAllMethods;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.util.List;
 import java.util.Map;
 
 import net.frankheijden.serverutils.bukkit.entities.BukkitReflection;
@@ -12,6 +16,7 @@ public class RDedicatedServerSettings {
 
     private static Class<?> serverSettingsClass;
     private static Map<String, Method> methods;
+    private static List<Constructor<?>> constructors;
 
     static {
         try {
@@ -19,13 +24,32 @@ public class RDedicatedServerSettings {
                     BukkitReflection.NMS));
             methods = getAllMethods(serverSettingsClass,
                     methodOf("getProperties"));
+            constructors = getAllConstructors(serverSettingsClass,
+                    constructorOf(Class.forName("joptsimple.OptionSet")),
+                    constructorOf(Class.forName(String.format("net.minecraft.server.%s.IRegistryCustom",
+                            BukkitReflection.NMS)), Class.forName("joptsimple.OptionSet")));
         } catch (Exception ex) {
             ex.printStackTrace();
         }
     }
 
-    public static Object newInstance(Object options)throws ReflectiveOperationException {
-        return serverSettingsClass.getDeclaredConstructor(Class.forName("joptsimple.OptionSet")).newInstance(options);
+    /**
+     * Retrieves the default constructor.
+     * @return The default constructor of DedicatedServerSettings.
+     * @throws NoSuchMethodException If no constructor was found.
+     */
+    public static Constructor<?> getConstructor() throws NoSuchMethodException {
+        if (constructors.size() == 0) throw new NoSuchMethodException("No constructor found for "
+                + serverSettingsClass.getName());
+        return constructors.get(0);
+    }
+
+    public static Object newInstance(Object options) throws ReflectiveOperationException {
+        return getConstructor().newInstance(options);
+    }
+
+    public static Object newInstance(Object registry, Object options) throws ReflectiveOperationException {
+        return getConstructor().newInstance(registry, options);
     }
 
     public static Map<String, Method> getMethods() {

Common/src/main/java/net/frankheijden/serverutils/common/reflection/ConstructorParam.java

@@ -0,0 +1,14 @@
+package net.frankheijden.serverutils.common.reflection;
+
+public class ConstructorParam {
+
+    public final Class<?>[] params;
+
+    private ConstructorParam(Class<?>[] params) {
+        this.params = params;
+    }
+
+    public static ConstructorParam constructorOf(Class<?>... params) {
+        return new ConstructorParam(params);
+    }
+}

Common/src/main/java/net/frankheijden/serverutils/common/reflection/FieldParam.java

@@ -3,8 +3,9 @@ package net.frankheijden.serverutils.common.reflection;
 import static net.frankheijden.serverutils.common.reflection.VersionParam.ALL_VERSIONS;
 
 public class FieldParam {
-    public String field;
-    public VersionParam versionParam;
+
+    public final String field;
+    public final VersionParam versionParam;
 
     private FieldParam(String field, VersionParam versionParam) {
         this.field = field;

Common/src/main/java/net/frankheijden/serverutils/common/reflection/MethodParam.java

@@ -4,9 +4,9 @@ import static net.frankheijden.serverutils.common.reflection.VersionParam.ALL_VE
 
 public class MethodParam {
 
-    public String method;
-    public VersionParam versionParam;
-    public Class<?>[] params;
+    public final String method;
+    public final VersionParam versionParam;
+    public final Class<?>[] params;
 
     private MethodParam(String method, VersionParam versionParam, Class<?>... params) {
         this.method = method;

Common/src/main/java/net/frankheijden/serverutils/common/reflection/ReflectionUtils.java

@@ -1,9 +1,12 @@
 package net.frankheijden.serverutils.common.reflection;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public abstract class ReflectionUtils {
@@ -122,6 +125,24 @@ public abstract class ReflectionUtils {
         return map;
     }
 
+    /**
+     * Fetches all constructors by their parameter input.
+     * @param clazz The class to find constructors on.
+     * @param constructorParams The constructor parameters.
+     * @return The list of constructors.
+     */
+    public static List<Constructor<?>> getAllConstructors(Class<?> clazz, ConstructorParam... constructorParams) {
+        List<Constructor<?>> constructors = new ArrayList<>();
+        for (ConstructorParam constructorParam : constructorParams) {
+            try {
+                constructors.add(clazz.getDeclaredConstructor(constructorParam.params));
+            } catch (NoSuchMethodException ignored) {
+                //
+            }
+        }
+        return constructors;
+    }
+
     /**
      * Invokes a method on an instance.
      * Will return null if method not present in map.

Common/src/main/java/net/frankheijden/serverutils/common/reflection/VersionParam.java

@@ -2,29 +2,73 @@ package net.frankheijden.serverutils.common.reflection;
 
 public class VersionParam {
 
-    public static VersionParam ALL_VERSIONS = new VersionParam(Integer.MIN_VALUE, Integer.MAX_VALUE);
+    public static final Version MIN_VERSION = new Version(Integer.MIN_VALUE, Integer.MIN_VALUE);
+    public static final Version MAX_VERSION = new Version(Integer.MAX_VALUE, Integer.MAX_VALUE);
+    public static final VersionParam ALL_VERSIONS = new VersionParam(MIN_VERSION, MAX_VERSION);
 
-    public int min;
-    public int max;
+    public final Version min;
+    public final Version max;
 
     private VersionParam(int min, int max) {
+        this(min, Integer.MIN_VALUE, max, Integer.MAX_VALUE);
+    }
+
+    private VersionParam(int min, int minPatch, int max, int maxPatch) {
+        this(new Version(min, minPatch), new Version(max, maxPatch));
+    }
+
+    private VersionParam(Version min, Version max) {
         this.min = min;
         this.max = max;
     }
 
-    public static VersionParam versionOf(int ver) {
+    public static VersionParam exact(int minor) {
+        return new VersionParam(minor, minor);
+    }
+
+    public static VersionParam exact(Version ver) {
         return new VersionParam(ver, ver);
     }
 
-    public static VersionParam between(int min, int max) {
+    public static VersionParam between(int minMinor, int maxMinor) {
+        return new VersionParam(minMinor, maxMinor);
+    }
+
+    public static VersionParam between(Version min, Version max) {
         return new VersionParam(min, max);
     }
 
-    public static VersionParam min(int min) {
-        return between(min, Integer.MAX_VALUE);
+    public static VersionParam min(int minMinor) {
+        return between(minMinor, Integer.MAX_VALUE);
     }
 
-    public static VersionParam max(int max) {
-        return between(Integer.MIN_VALUE, max);
+    public static VersionParam min(Version min) {
+        return between(min, MAX_VERSION);
+    }
+
+    public static VersionParam max(int maxMinor) {
+        return between(Integer.MIN_VALUE, maxMinor);
+    }
+
+    public static VersionParam max(Version max) {
+        return between(MIN_VERSION, max);
+    }
+
+    public static class Version {
+        public final int minor;
+        public final int patch;
+
+        public Version(int minor, int patch) {
+            this.minor = minor;
+            this.patch = patch;
+        }
+
+        public int getMinor() {
+            return minor;
+        }
+
+        public int getPatch() {
+            return patch;
+        }
     }
 }