From 1dd1f6b54179320136383c99f2a1bf8ac6c0f70e Mon Sep 17 00:00:00 2001
From: M_Viper <admin@m-viper.de>
Date: Thu, 15 Jan 2026 13:34:29 +0100
Subject: [PATCH] Update from Git Manager GUI

---
 .../internal/utils/ReflectionUtil.java        | 512 +++++++++---------
 .../internal/utils/bukkit/BukkitUtils.java    |  16 +-
 2 files changed, 279 insertions(+), 249 deletions(-)

diff --git a/src/main/java/be/maximvdw/placeholderapi/internal/utils/ReflectionUtil.java b/src/main/java/be/maximvdw/placeholderapi/internal/utils/ReflectionUtil.java
index ffa8684..1afdd3a 100644
--- a/src/main/java/be/maximvdw/placeholderapi/internal/utils/ReflectionUtil.java
+++ b/src/main/java/be/maximvdw/placeholderapi/internal/utils/ReflectionUtil.java
@@ -10,109 +10,117 @@ import java.util.HashMap;
 import java.util.Map;
 
 public abstract class ReflectionUtil {
-	private static volatile Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<Class<?>, Class<?>>();
+    private static volatile Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<Class<?>, Class<?>>();
 
-	public static Class<?> obcPlayer = ReflectionUtil.getOBCClass("entity.CraftPlayer");
-	public static Method methodPlayerGetHandle = getMethod("getHandle", obcPlayer);
+    public static Class<?> obcPlayer = ReflectionUtil.getOBCClass("entity.CraftPlayer");
+    public static Method methodPlayerGetHandle = getMethod("getHandle", obcPlayer);
 
-	static {
-		CORRESPONDING_TYPES.put(Byte.class, byte.class);
-		CORRESPONDING_TYPES.put(Short.class, short.class);
-		CORRESPONDING_TYPES.put(Integer.class, int.class);
-		CORRESPONDING_TYPES.put(Long.class, long.class);
-		CORRESPONDING_TYPES.put(Character.class, char.class);
-		CORRESPONDING_TYPES.put(Float.class, float.class);
-		CORRESPONDING_TYPES.put(Double.class, double.class);
-		CORRESPONDING_TYPES.put(Boolean.class, boolean.class);
-	}
+    static {
+        CORRESPONDING_TYPES.put(Byte.class, byte.class);
+        CORRESPONDING_TYPES.put(Short.class, short.class);
+        CORRESPONDING_TYPES.put(Integer.class, int.class);
+        CORRESPONDING_TYPES.put(Long.class, long.class);
+        CORRESPONDING_TYPES.put(Character.class, char.class);
+        CORRESPONDING_TYPES.put(Float.class, float.class);
+        CORRESPONDING_TYPES.put(Double.class, double.class);
+        CORRESPONDING_TYPES.put(Boolean.class, boolean.class);
+    }
 
-	public enum DynamicPackage {
-		MINECRAFT_SERVER {
-			@Override
-			public String toString() {
-				return "net.minecraft.server." + Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-			}
-		},
-		CRAFTBUKKIT {
-			@Override
-			public String toString() {
-				return Bukkit.getServer().getClass().getPackage().getName();
-			}
-		}
-	}
+    public enum DynamicPackage {
+        MINECRAFT_SERVER {
+            @Override
+            public String toString() {
+                String pkgName = Bukkit.getServer().getClass().getPackage().getName();
+                // Fix für 1.21+: Prüfen der Länge, da split("\\.")[3] fehlschlägt
+                String[] parts = pkgName.split("\\.");
+                if (parts.length > 3) {
+                    return "net.minecraft.server." + parts[3];
+                } else {
+                    // Fallback für 1.21+, obwohl NMS Packages dort komplett anders sind
+                    return "net.minecraft.server";
+                }
+            }
+        },
+        CRAFTBUKKIT {
+            @Override
+            public String toString() {
+                return Bukkit.getServer().getClass().getPackage().getName();
+            }
+        }
+    }
 
-	public static class FieldEntry {
-		String key;
-		Object value;
+    public static class FieldEntry {
+        String key;
+        Object value;
 
-		public FieldEntry(String key, Object value) {
-			this.key = key;
-			this.value = value;
-		}
+        public FieldEntry(String key, Object value) {
+            this.key = key;
+            this.value = value;
+        }
 
-		public String getKey() {
-			return this.key;
-		}
+        public String getKey() {
+            return this.key;
+        }
 
-		public Object getValue() {
-			return this.value;
-		}
-	}
+        public Object getValue() {
+            return this.value;
+        }
+    }
 
-	private static Class<?> getPrimitiveType(Class<?> clazz) {
-		return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
-	}
+    private static Class<?> getPrimitiveType(Class<?> clazz) {
+        return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
+    }
 
-	private static Class<?>[] toPrimitiveTypeArray(Object[] objects) {
-		int a = objects != null ? objects.length : 0;
-		Class<?>[] types = new Class<?>[a];
-		for (int i = 0; i < a; i++)
-			types[i] = getPrimitiveType(objects[i].getClass());
-		return types;
-	}
+    private static Class<?>[] toPrimitiveTypeArray(Object[] objects) {
+        int a = objects != null ? objects.length : 0;
+        Class<?>[] types = new Class<?>[a];
+        for (int i = 0; i < a; i++)
+            types[i] = getPrimitiveType(objects[i].getClass());
+        return types;
+    }
 
-	private static Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
-		int a = classes != null ? classes.length : 0;
-		Class<?>[] types = new Class<?>[a];
-		for (int i = 0; i < a; i++)
-			types[i] = getPrimitiveType(classes[i]);
-		return types;
-	}
+    private static Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
+        int a = classes != null ? classes.length : 0;
+        Class<?>[] types = new Class<?>[a];
+        for (int i = 0; i < a; i++)
+            types[i] = getPrimitiveType(classes[i]);
+        return types;
+    }
 
-	private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
-		if (a.length != o.length)
-			return false;
-		for (int i = 0; i < a.length; i++)
-			if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i]))
-				return false;
-		return true;
-	}
+    private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
+        if (a.length != o.length)
+            return false;
+        for (int i = 0; i < a.length; i++)
+            if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i]))
+                return false;
+        return true;
+    }
 
-	public static Class<?> getClass(String name, DynamicPackage pack, String subPackage) throws Exception {
-		return Class
-				.forName(pack + (subPackage != null && subPackage.length() > 0 ? "." + subPackage : "") + "." + name);
-	}
+    public static Class<?> getClass(String name, DynamicPackage pack, String subPackage) throws Exception {
+        return Class
+                .forName(pack + (subPackage != null && subPackage.length() > 0 ? "." + subPackage : "") + "." + name);
+    }
 
-	public static Class<?> getClass(String name, DynamicPackage pack) {
-		try {
-			return getClass(name, pack, null);
-		} catch (Exception e) {
-		}
-		return null;
-	}
+    public static Class<?> getClass(String name, DynamicPackage pack) {
+        try {
+            return getClass(name, pack, null);
+        } catch (Exception e) {
+        }
+        return null;
+    }
 
-	public static Class<?> getClass(String name, String namespace) throws Exception {
-		return Class.forName(namespace + "." + name);
-	}
+    public static Class<?> getClass(String name, String namespace) throws Exception {
+        return Class.forName(namespace + "." + name);
+    }
 
-	public static Object getHandle(Object obj) {
-		try {
-			return getMethod("getHandle", obj.getClass()).invoke(obj);
-		} catch (Exception e) {
-			e.printStackTrace();
-			return null;
-		}
-	}
+    public static Object getHandle(Object obj) {
+        try {
+            return getMethod("getHandle", obj.getClass()).invoke(obj);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
 
     public static Object getHandle(Player player) {
         try {
@@ -123,187 +131,199 @@ public abstract class ReflectionUtil {
         }
     }
 
-	public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... paramTypes) {
-		Class<?>[] t = toPrimitiveTypeArray(paramTypes);
-		for (Constructor<?> c : clazz.getConstructors()) {
-			Class<?>[] types = toPrimitiveTypeArray(c.getParameterTypes());
-			if (equalsTypeArray(types, t))
-				return c;
-		}
-		return null;
-	}
+    public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... paramTypes) {
+        Class<?>[] t = toPrimitiveTypeArray(paramTypes);
+        for (Constructor<?> c : clazz.getConstructors()) {
+            Class<?>[] types = toPrimitiveTypeArray(c.getParameterTypes());
+            if (equalsTypeArray(types, t))
+                return c;
+        }
+        return null;
+    }
 
-	public static Object newInstance(Class<?> clazz, Object... args) throws Exception {
-		return getConstructor(clazz, toPrimitiveTypeArray(args)).newInstance(args);
-	}
+    public static Object newInstance(Class<?> clazz, Object... args) throws Exception {
+        return getConstructor(clazz, toPrimitiveTypeArray(args)).newInstance(args);
+    }
 
-	public static Object newInstance(String name, DynamicPackage pack, String subPackage, Object... args)
-			throws Exception {
-		return newInstance(getClass(name, pack, subPackage), args);
-	}
+    public static Object newInstance(String name, DynamicPackage pack, String subPackage, Object... args)
+            throws Exception {
+        return newInstance(getClass(name, pack, subPackage), args);
+    }
 
-	public static Object newInstance(String name, DynamicPackage pack, Object... args) throws Exception {
-		return newInstance(getClass(name, pack, null), args);
-	}
+    public static Object newInstance(String name, DynamicPackage pack, Object... args) throws Exception {
+        return newInstance(getClass(name, pack, null), args);
+    }
 
-	public static Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
-		Class<?>[] t = toPrimitiveTypeArray(paramTypes);
-		for (Method m : clazz.getMethods()) {
-			Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
-			if (m.getName().equals(name) && equalsTypeArray(types, t))
-				return m;
-		}
-		return null;
-	}
+    public static Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
+        Class<?>[] t = toPrimitiveTypeArray(paramTypes);
+        for (Method m : clazz.getMethods()) {
+            Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
+            if (m.getName().equals(name) && equalsTypeArray(types, t))
+                return m;
+        }
+        return null;
+    }
 
-	public static Object invokeMethod(String name, Class<?> clazz, Object obj, Object... args) throws Exception {
-		return getMethod(name, clazz, toPrimitiveTypeArray(args)).invoke(obj, args);
-	}
+    public static Object invokeMethod(String name, Class<?> clazz, Object obj, Object... args) throws Exception {
+        return getMethod(name, clazz, toPrimitiveTypeArray(args)).invoke(obj, args);
+    }
 
-	public static Field getField(String name, Class<?> clazz) throws Exception {
-		return clazz.getDeclaredField(name);
-	}
+    public static Field getField(String name, Class<?> clazz) throws Exception {
+        return clazz.getDeclaredField(name);
+    }
 
-	public static Object getValue(String name, Object obj) throws Exception {
-		Field f = getField(name, obj.getClass());
-		if (!f.isAccessible())
-			f.setAccessible(true);
-		return f.get(obj);
-	}
+    public static Object getValue(String name, Object obj) throws Exception {
+        Field f = getField(name, obj.getClass());
+        if (!f.isAccessible())
+            f.setAccessible(true);
+        return f.get(obj);
+    }
 
-	public static Object getValueFromClass(String name, Object obj, Class<?> clazz) throws Exception {
-		Field f = getField(name, clazz);
-		if (!f.isAccessible())
-			f.setAccessible(true);
-		return f.get(obj);
-	}
+    public static Object getValueFromClass(String name, Object obj, Class<?> clazz) throws Exception {
+        Field f = getField(name, clazz);
+        if (!f.isAccessible())
+            f.setAccessible(true);
+        return f.get(obj);
+    }
 
-	public static Object getValue(String name, Class<?> clazz) throws Exception {
-		Field f = getField(name, clazz);
-		if (!f.isAccessible())
-			f.setAccessible(true);
-		return f.get(clazz);
-	}
+    public static Object getValue(String name, Class<?> clazz) throws Exception {
+        Field f = getField(name, clazz);
+        if (!f.isAccessible())
+            f.setAccessible(true);
+        return f.get(clazz);
+    }
 
-	public static void setValue(Object obj, FieldEntry entry) throws Exception {
-		Field f = getField(entry.getKey(), obj.getClass());
-		if (!f.isAccessible())
-			f.setAccessible(true);
-		f.set(obj, entry.getValue());
-	}
+    public static void setValue(Object obj, FieldEntry entry) throws Exception {
+        Field f = getField(entry.getKey(), obj.getClass());
+        if (!f.isAccessible())
+            f.setAccessible(true);
+        f.set(obj, entry.getValue());
+    }
 
-	public static void setValue(String name, Object value, Object obj) throws Exception {
-		Field f = getField(name, obj.getClass());
-		if (!f.isAccessible())
-			f.setAccessible(true);
-		f.set(obj, value);
-	}
+    public static void setValue(String name, Object value, Object obj) throws Exception {
+        Field f = getField(name, obj.getClass());
+        if (!f.isAccessible())
+            f.setAccessible(true);
+        f.set(obj, value);
+    }
 
-	public static void setFinalValue(String name, Object value, Object obj) throws Exception {
-		Field f = obj.getClass().getDeclaredField(name);
-		if (!f.isAccessible())
-			f.setAccessible(true);
-		f.set(obj, value);
-	}
+    public static void setFinalValue(String name, Object value, Object obj) throws Exception {
+        Field f = obj.getClass().getDeclaredField(name);
+        if (!f.isAccessible())
+            f.setAccessible(true);
+        f.set(obj, value);
+    }
 
-	public static void setValues(Object obj, FieldEntry... entrys) throws Exception {
-		for (FieldEntry f : entrys)
-			setValue(obj, f);
-	}
+    public static void setValues(Object obj, FieldEntry... entrys) throws Exception {
+        for (FieldEntry f : entrys)
+            setValue(obj, f);
+    }
 
-	public static String getVersion() {
-		String name = Bukkit.getServer().getClass().getPackage().getName();
-		String version = name.substring(name.lastIndexOf('.') + 1) + ".";
-		return version;
-	}
+    public static String getVersion() {
+        String name = Bukkit.getServer().getClass().getPackage().getName();
+        // Fix für 1.21+ (Paper): Paketstruktur ist flach "org.bukkit.craftbukkit"
+        // Alte Versionen sind "org.bukkit.craftbukkit.v1_20_R3"
+        if (name.equals("org.bukkit.craftbukkit")) {
+            return ""; // Keine Versions-Extension für 1.21+ nötig
+        }
+        String version = name.substring(name.lastIndexOf('.') + 1) + ".";
+        return version;
+    }
 
-	public static Class<?> getNMSClass(String className) {
-		String fullName = "net.minecraft.server." + getVersion() + className;
-		Class<?> clazz = null;
-		try {
-			clazz = Class.forName(fullName);
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-		return clazz;
-	}
+    public static Class<?> getNMSClass(String className) {
+        // In 1.21 ist die Struktur von NMS komplett anders (Mojang Mappings), 
+        // diese Methode wird dort wahrscheinlich fehlschlagen, aber wir verhindern einen Absturz
+        // durch die falsche Versions-Logik.
+        String versionSuffix = getVersion();
+        String fullName = "net.minecraft.server." + versionSuffix + className;
+        Class<?> clazz = null;
+        try {
+            clazz = Class.forName(fullName);
+        } catch (Exception e) {
+            // Ignorieren oder Loggen, wenn NMS nicht gefunden wird (Kann in 1.21+ passieren)
+            // e.printStackTrace(); 
+        }
+        return clazz;
+    }
 
-	public static Class<?> getOBCClass(String className) {
-		String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
-		Class<?> clazz = null;
-		try {
-			clazz = Class.forName(fullName);
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-		return clazz;
-	}
+    public static Class<?> getOBCClass(String className) {
+        String versionSuffix = getVersion();
+        String fullName = "org.bukkit.craftbukkit." + versionSuffix + className;
+        Class<?> clazz = null;
+        try {
+            clazz = Class.forName(fullName);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return clazz;
+    }
 
 
-	public static Class<?> getNMSClassWithException(String className) throws Exception {
-		String fullName = "net.minecraft.server." + getVersion() + className;
-		Class<?> clazz = Class.forName(fullName);
-		return clazz;
-	}
+    public static Class<?> getNMSClassWithException(String className) throws Exception {
+        String versionSuffix = getVersion();
+        String fullName = "net.minecraft.server." + versionSuffix + className;
+        Class<?> clazz = Class.forName(fullName);
+        return clazz;
+    }
 
 
-	public static Field getField(Class<?> clazz, String name) {
-		try {
-			Field field = clazz.getDeclaredField(name);
-			field.setAccessible(true);
-			return field;
-		} catch (Exception e) {
-			e.printStackTrace();
-			return null;
-		}
-	}
+    public static Field getField(Class<?> clazz, String name) {
+        try {
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            return field;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
 
-	public static Method getMethod(Class<?> clazz, String name, Class<?>... args) {
-		for (Method m : clazz.getMethods())
-			if (m.getName().equals(name) && (args.length == 0 || ClassListEqual(args, m.getParameterTypes()))) {
-				m.setAccessible(true);
-				return m;
-			}
-		return null;
-	}
+    public static Method getMethod(Class<?> clazz, String name, Class<?>... args) {
+        for (Method m : clazz.getMethods())
+            if (m.getName().equals(name) && (args.length == 0 || ClassListEqual(args, m.getParameterTypes()))) {
+                m.setAccessible(true);
+                return m;
+            }
+        return null;
+    }
 
-	/**
-	 * Set a specified Field accessible
-	 *
-	 * @param f
-	 *            Field set accessible
-	 */
-	public static Field setAccessible(Field f)
-			throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-		f.setAccessible(true);
-		Field modifiersField = Field.class.getDeclaredField("modifiers");
-		modifiersField.setAccessible(true);
-		modifiersField.setInt(f, f.getModifiers() & 0xFFFFFFEF);
-		return f;
-	}
+    /**
+     * Set a specified Field accessible
+     *
+     * @param f
+     *            Field set accessible
+     */
+    public static Field setAccessible(Field f)
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        f.setAccessible(true);
+        Field modifiersField = Field.class.getDeclaredField("modifiers");
+        modifiersField.setAccessible(true);
+        modifiersField.setInt(f, f.getModifiers() & 0xFFFFFFEF);
+        return f;
+    }
 
-	/**
-	 * Set a specified Method accessible
-	 *
-	 * @param m
-	 *            Method set accessible
-	 */
-	public static Method setAccessible(Method m)
-			throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-		m.setAccessible(true);
-		return m;
-	}
+    /**
+     * Set a specified Method accessible
+     *
+     * @param m
+     *            Method set accessible
+     */
+    public static Method setAccessible(Method m)
+            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        m.setAccessible(true);
+        return m;
+    }
 
-	public static boolean ClassListEqual(Class<?>[] l1, Class<?>[] l2) {
-		boolean equal = true;
-		if (l1.length != l2.length)
-			return false;
-		for (int i = 0; i < l1.length; i++)
-			if (l1[i] != l2[i]) {
-				equal = false;
-				break;
-			}
-		return equal;
-	}
+    public static boolean ClassListEqual(Class<?>[] l1, Class<?>[] l2) {
+        boolean equal = true;
+        if (l1.length != l2.length)
+            return false;
+        for (int i = 0; i < l1.length; i++)
+            if (l1[i] != l2[i]) {
+                equal = false;
+                break;
+            }
+        return equal;
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/be/maximvdw/placeholderapi/internal/utils/bukkit/BukkitUtils.java b/src/main/java/be/maximvdw/placeholderapi/internal/utils/bukkit/BukkitUtils.java
index 361f62e..deff8ac 100644
--- a/src/main/java/be/maximvdw/placeholderapi/internal/utils/bukkit/BukkitUtils.java
+++ b/src/main/java/be/maximvdw/placeholderapi/internal/utils/bukkit/BukkitUtils.java
@@ -73,15 +73,25 @@ public class BukkitUtils {
         } catch (Throwable e) {
         }
     }
-    public static String getVersion() {
+        public static String getVersion() {
         if (Bukkit.getServer() == null) {
             return "";
         }
 
         if (version.equals("")) {
-            version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+            // Korrektur: Prüfen der Länge des Paket-Namens, da 1.21+ (Paper) die Version nicht mehr im Namen trägt
+            String[] pkgSplit = Bukkit.getServer().getClass().getPackage().getName().split("\\.");
+            if (pkgSplit.length >= 4) {
+                // Altes Format: org.bukkit.craftbukkit.v1_20_R3
+                version = pkgSplit[3];
+            } else {
+                // Neues Format: org.bukkit.craftbukkit
+                // Wir nutzen Bukkit.getVersion() oder setzten eine Default-Version für 1.21
+                // Da wir für 1.21 bauen, setzen wir hier v1_21_R1, damit die weiteren Logik greift
+                version = "v1_21_R1"; 
+            }
 
-            String[] data = BukkitUtils.getVersion().substring(1).split("_");
+            String[] data = version.substring(1).split("_");
             if (NumberUtils.isInteger(data[1]) && NumberUtils.isInteger(data[0])) {
                 versionMinor = Integer.parseInt(data[1]);
                 versionMajor = Integer.parseInt(data[0]);