Improve color gradient

Reviewed-on: #429

.gitea/workflows/build.yml

@@ -51,6 +51,7 @@ jobs:
           rm -rf deploy
           mkdir -p deploy
 
+          cp "AccessWidener/build/libs/AccessWidener-all.jar" "deploy/AccessWidener.jar"
           cp "BauSystem/build/libs/BauSystem-all.jar" "deploy/BauSystem.jar"
           cp "FightSystem/build/libs/FightSystem-all.jar" "deploy/FightSystem.jar"
           cp "KotlinCore/build/libs/KotlinCore-all.jar" "deploy/KotlinCore.jar"

AccessWidener/build.gradle.kts

@@ -0,0 +1,45 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    `java-library`
+    alias(libs.plugins.shadow)
+}
+
+dependencies {
+    implementation("org.ow2.asm:asm:9.7")
+    implementation("org.ow2.asm:asm-commons:9.7")
+}
+
+tasks.shadowJar {
+    manifest {
+        attributes(
+            "Manifest-Version" to "1.0",
+            "Build-Jdk-Spec" to "21",
+            "Main-Class" to "de.steamwar.Main",
+            "Premain-Class" to "de.steamwar.Agent",
+            "Can-Retransform-Classes" to "true",
+            "Can-Redefine-Classes" to "true",
+        )
+    }
+}
+
+tasks.build {
+    dependsOn(tasks.shadowJar)
+}

AccessWidener/src/main/java/de/steamwar/AccessWidenerEntry.java

@@ -0,0 +1,49 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+/**
+ * A single parsed line from a .accesswidener file.
+ * <p>
+ * Examples:
+ * accessible class  net/minecraft/server/level/ServerPlayer
+ * accessible method net/minecraft/server/level/ServerPlayer getStats ()V
+ * mutable    field  net/minecraft/world/entity/Entity id I
+ * extendable class  net/minecraft/world/level/chunk/LevelChunk
+ */
+public record AccessWidenerEntry(
+        /** accessible | mutable | extendable (may have "transitive-" prefix) */
+        String directive,
+        /** class | method | field */
+        String memberType,
+        /** Internal class name, e.g. net/minecraft/server/level/ServerPlayer */
+        String target,
+        /** Method/field name, null for class entries */
+        String name,
+        /** Descriptor, null for class entries */
+        String descriptor) {
+    /**
+     * Returns true if this entry targets the class with the given internal name.
+     */
+    public boolean targets(String internalName) {
+        return target.equals(internalName);
+    }
+}
+

AccessWidener/src/main/java/de/steamwar/AccessWidenerParser.java

@@ -0,0 +1,104 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Parses Fabric-compatible .accesswidener files.
+ * <p>
+ * Supported format:
+ * <pre>
+ *   accessWidener v2 named
+ *
+ *   # comments are supported
+ *   accessible class  net/minecraft/Foo
+ *   accessible method net/minecraft/Foo someMethod ()V
+ *   accessible field  net/minecraft/Foo someField I
+ *   mutable    field  net/minecraft/Foo someField I
+ *   extendable class  net/minecraft/Foo
+ *   extendable method net/minecraft/Foo someMethod ()V
+ *
+ *   # transitive variants (expose widening to dependents)
+ *   transitive-accessible class net/minecraft/Foo
+ * </pre>
+ */
+public final class AccessWidenerParser {
+
+    private AccessWidenerParser() {
+    }
+
+    public static List<AccessWidenerEntry> parse(InputStream in) throws IOException {
+        List<AccessWidenerEntry> entries = new ArrayList<>();
+
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
+
+            String line;
+            boolean headerSeen = false;
+
+            while ((line = reader.readLine()) != null) {
+                // Strip inline comments
+                int commentIdx = line.indexOf('#');
+                if (commentIdx >= 0) line = line.substring(0, commentIdx);
+                line = line.strip();
+
+                if (line.isEmpty()) continue;
+
+                if (!headerSeen) {
+                    // First non-blank, non-comment line must be the header
+                    if (!line.startsWith("accessWidener")) {
+                        throw new IOException("Missing accessWidener header, got: " + line);
+                    }
+                    headerSeen = true;
+                    continue;
+                }
+
+                AccessWidenerEntry entry = parseLine(line);
+                if (entry != null) entries.add(entry);
+            }
+        }
+
+        return entries;
+    }
+
+    private static AccessWidenerEntry parseLine(String line) {
+        String[] parts = line.split("\\s+");
+        if (parts.length < 3) return null;
+
+        String directive = parts[0]; // accessible / mutable / extendable / transitive-*
+        String memberType = parts[1]; // class / method / field
+        String target = parts[2]; // internal class name
+
+        return switch (memberType) {
+            case "class" -> new AccessWidenerEntry(directive, "class", target, null, null);
+            case "method", "field" -> {
+                if (parts.length < 5) yield null;
+                yield new AccessWidenerEntry(directive, memberType, target, parts[3], parts[4]);
+            }
+            default -> null;
+        };
+    }
+}

AccessWidener/src/main/java/de/steamwar/Agent.java

@@ -0,0 +1,75 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.instrument.Instrumentation;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+/**
+ * Java agent entry point.
+ * <p>
+ * At JVM startup:  java -javaagent:paper-access-widener-agent.jar -jar server.jar
+ * <p>
+ * On attach the agent:
+ * <ol>
+ *     <li>Find all .jar files inside the plugins folder</li>
+ *     <li>Scan all found jars for *.accesswidener resources</li>
+ *     <li>Transform any class during loading</li>
+ * </ol>
+ */
+public class Agent {
+    private Agent() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    private static final Logger LOG = Logger.getLogger("AccessWidenerAgent");
+
+    // -javaagent: startup
+    public static void premain(String args, Instrumentation inst) {
+        init(inst);
+    }
+
+    private static void init(Instrumentation inst) {
+        LOG.info("[AccessWidener] Agent initialising.");
+
+        List<AccessWidenerEntry> entries = new ArrayList<>();
+        File file = new File(new File(".").getAbsoluteFile(), "plugins/");
+        File[] files = file.listFiles();
+        if (files == null) files = new File[0];
+        for (File jarFile : files) {
+            if (!jarFile.isFile()) continue;
+            if (!jarFile.getName().endsWith(".jar")) continue;
+            try {
+                entries.addAll(Utils.findAndParseAccessWideners(jarFile.toPath()));
+            } catch (IOException e) {
+                LOG.warning("Failed to parse access wideners from " + jarFile.getAbsolutePath());
+            }
+        }
+        LOG.info("[AccessWidener] Loaded " + entries.size() + " access wideners.");
+
+        inst.addTransformer(new WideningTransformer(entries), false);
+        LOG.info("[AccessWidener] Agent ready.");
+    }
+}
+

AccessWidener/src/main/java/de/steamwar/ClassPatcher.java

@@ -0,0 +1,83 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Uses ASM to patch class bytecode according to a list of access widener entries.
+ *
+ * Returns {@code null} if the class is not targeted by any entry (no-op signal
+ * to the caller so it can skip the write).
+ */
+public class ClassPatcher {
+
+    private static final Logger LOG = Logger.getLogger("ClassPatcher");
+
+    private final List<AccessWidenerEntry> entries;
+
+    /** Pre-computed set of targeted internal names for fast filtering. */
+    private final Set<String> targets;
+
+    private final Set<String> targetsPublicConstructor;
+
+    public ClassPatcher(List<AccessWidenerEntry> entries) {
+        this.entries = entries;
+        this.targets = entries.stream()
+                .map(AccessWidenerEntry::target)
+                .flatMap(s -> {
+                    if (!s.contains("$")) return Stream.of(s);
+                    int index = s.lastIndexOf('$');
+                    return Stream.of(s, s.substring(0, index));
+                })
+                .collect(Collectors.toSet());
+        this.targetsPublicConstructor = entries.stream()
+                .filter(entry -> entry.directive().equals("transitive-extendable"))
+                .map(AccessWidenerEntry::target)
+                .collect(Collectors.toSet());
+    }
+
+    /**
+     * Patches {@code classBytes} if {@code className} is targeted.
+     *
+     * @return patched bytes, or {@code null} if no changes were needed
+     */
+    public byte[] patch(String className, byte[] classBytes) {
+        if (!targets.contains(className)) return null;
+
+        try {
+            ClassReader cr = new ClassReader(classBytes);
+            ClassWriter cw = new ClassWriter(cr, 0);
+            cr.accept(new ClassTransformer(cw, className, entries, targetsPublicConstructor.contains(className)), ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+            return cw.toByteArray();
+        } catch (Exception e) {
+            LOG.warning("[AccessWidener] Failed to transform " + className + ": " + e.getMessage());
+            return null;
+        }
+    }
+}
+

AccessWidener/src/main/java/de/steamwar/ClassTransformer.java

@@ -0,0 +1,125 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.List;
+
+public class ClassTransformer extends ClassVisitor {
+
+    private final String internalName;
+    private final List<AccessWidenerEntry> entries;
+    private final boolean appendPublicConstructor;
+
+    public ClassTransformer(ClassVisitor cv, String internalName, List<AccessWidenerEntry> entries, boolean appendPublicConstructor) {
+        super(Opcodes.ASM9, cv);
+        this.internalName = internalName;
+        this.entries = entries;
+        this.appendPublicConstructor = appendPublicConstructor;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.targets(internalName) || !"class".equals(e.memberType())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, false);
+        }
+        if (appendPublicConstructor) {
+            MethodVisitor methodVisitor = visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+            methodVisitor.visitCode();
+            methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
+            methodVisitor.visitMethodInsn(
+                    Opcodes.INVOKESPECIAL,
+                    "java/lang/Object",
+                    "<init>",
+                    "()V",
+                    false
+            );
+            methodVisitor.visitInsn(Opcodes.RETURN);
+            methodVisitor.visitMaxs(1, 1);
+            methodVisitor.visitEnd();
+        }
+        super.visit(version, newAccess, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public void visitInnerClass(String name, String outerName, String innerName, int access) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.target().equals(name) || !"class".equals(e.memberType())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, false);
+        }
+        super.visitInnerClass(name, outerName, innerName, newAccess);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.targets(internalName) || !"method".equals(e.memberType())) continue;
+            if (!name.equals(e.name()) || !descriptor.equals(e.descriptor())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, false);
+        }
+        return super.visitMethod(newAccess, name, descriptor, signature, exceptions);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.targets(internalName) || !"field".equals(e.memberType())) continue;
+            if (!name.equals(e.name())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, true);
+        }
+        return super.visitField(newAccess, name, descriptor, signature, value);
+    }
+
+    /**
+     * Apply a directive to an access bitmask.
+     *
+     * @param directive accessible / mutable / extendable (with optional "transitive-" prefix)
+     * @param access    current access flags
+     * @param isField   true when processing a field (mutable removes final)
+     */
+    private static int applyDirective(String directive, int access, boolean isField) {
+        // Strip transitive- prefix — the widening itself is the same
+        String effective = directive.startsWith("transitive-") ? directive.substring("transitive-".length()) : directive;
+
+        return switch (effective) {
+            case "accessible" -> makePublic(access);
+            case "extendable" -> makePublic(removeFinal(access));
+            case "mutable" -> isField ? removeFinal(access) : access;
+            default -> access;
+        };
+    }
+
+    private static int makePublic(int access) {
+        return (access & ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) | Opcodes.ACC_PUBLIC;
+    }
+
+    private static int removeFinal(int access) {
+        return access & ~Opcodes.ACC_FINAL;
+    }
+}

AccessWidener/src/main/java/de/steamwar/Main.java

@@ -0,0 +1,125 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Command-line tool that produces a widened copy of a JAR for use as a
+ * compile-time stub in IntelliJ / Gradle.
+ *
+ * Usage:
+ *   java -jar jar-widener.jar <input.jar> <output.jar> [file.accesswidener ...]
+ *
+ * The output JAR is identical to the input JAR except that every class
+ * targeted by the access widener entries has its access flags patched:
+ *   accessible  → public
+ *   extendable  → public + non-final
+ *   mutable     → non-final field
+ *
+ * Intended for use as a Gradle task so IntelliJ sees the already-widened
+ * class when you Ctrl+click NMS code, and javac compiles without complaints.
+ */
+public class Main {
+
+    public static void main(String[] args) throws Exception {
+        if (args.length < 2) {
+            System.err.println("Usage: jar-widener <input.jar> <output.jar> [*.accesswidener ...]");
+            System.exit(1);
+        }
+
+        Path inputJar  = Path.of(args[0]);
+        Path outputJar = Path.of(args[1]);
+
+        if (!Files.exists(inputJar)) {
+            System.err.println("Input JAR not found: " + inputJar);
+            System.exit(1);
+        }
+
+        // --- Collect all access widener entries ---
+        List<AccessWidenerEntry> entries = new ArrayList<>();
+
+        if (args.length > 2) {
+            for (int i = 2; i < args.length; i++) {
+                Path awFile = Path.of(args[i]);
+                if (!Files.exists(awFile)) {
+                    System.err.println("Warning: access widener file not found, skipping: " + awFile);
+                    continue;
+                }
+                try (InputStream in = Files.newInputStream(awFile)) {
+                    List<AccessWidenerEntry> parsed = AccessWidenerParser.parse(in);
+                    System.out.println("Loaded " + parsed.size() + " entries from " + awFile.getFileName());
+                    entries.addAll(parsed);
+                }
+            }
+        }
+
+        if (entries.isEmpty()) {
+            System.out.println("No access widener entries found — copying JAR unchanged.");
+            Files.createDirectories(outputJar.getParent());
+            Files.copy(inputJar, outputJar, StandardCopyOption.REPLACE_EXISTING);
+            return;
+        }
+
+        System.out.println("Widening " + inputJar.getFileName()
+                + " with " + entries.size() + " total entr"
+                + (entries.size() == 1 ? "y" : "ies") + "...");
+
+        // --- Copy input → output, transforming .class files in place ---
+        Files.createDirectories(outputJar.getParent());
+        Files.copy(inputJar, outputJar, StandardCopyOption.REPLACE_EXISTING);
+
+        ClassPatcher patcher = new ClassPatcher(entries);
+
+        try (FileSystem fs = FileSystems.newFileSystem(outputJar)) {
+            // Walk every .class entry in the JAR
+            try (var stream = Files.walk(fs.getPath("/"))) {
+                stream.filter(p -> p.toString().endsWith(".class"))
+                        .forEach(classPath -> patchClass(fs, classPath, patcher));
+            }
+        }
+
+        System.out.println("Done. Widened JAR written to " + outputJar);
+    }
+
+    private static void patchClass(FileSystem fs, Path classPath, ClassPatcher patcher) {
+        // Derive internal class name from path  e.g. /net/minecraft/Foo.class → net/minecraft/Foo
+        String internalName = classPath.toString()
+                .replaceFirst("^/", "")
+                .replace(".class", "");
+
+        try {
+            byte[] original = Files.readAllBytes(classPath);
+            byte[] patched  = patcher.patch(internalName, original);
+
+            if (patched != null) {
+                Files.write(classPath, patched);
+                System.out.println("  Widened: " + internalName);
+            }
+        } catch (IOException e) {
+            System.err.println("  Warning: failed to patch " + internalName + ": " + e.getMessage());
+        }
+    }
+}
+

AccessWidener/src/main/java/de/steamwar/Utils.java

@@ -0,0 +1,60 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class Utils {
+
+    private static final Logger LOG = Logger.getLogger("AccessWidenerAgent");
+
+    private Utils() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    public static List<AccessWidenerEntry> findAndParseAccessWideners(Path jarPath) throws IOException {
+        List<AccessWidenerEntry> results = new ArrayList<>();
+
+        try (ZipFile zip = new ZipFile(jarPath.toFile())) {
+            Enumeration<? extends ZipEntry> entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                if (entry.isDirectory() || !entry.getName().endsWith(".accesswidener")) continue;
+
+                try (InputStream in = zip.getInputStream(entry)) {
+                    results.addAll(AccessWidenerParser.parse(in));
+                } catch (IOException e) {
+                    LOG.warning("[AccessWidener] Failed to parse " + entry.getName()
+                            + " in " + jarPath.getFileName() + ": " + e.getMessage());
+                }
+            }
+        }
+
+        return results;
+    }
+}

AccessWidener/src/main/java/de/steamwar/WideningTransformer.java

@@ -0,0 +1,44 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.security.ProtectionDomain;
+import java.util.List;
+
+/**
+ * Transforms class bytecode to apply access widening rules.
+ * <p>
+ * Also monitors for new plugin ClassLoaders appearing (when plugins load after
+ * the agent attaches) and automatically picks up their .accesswidener files.
+ */
+public class WideningTransformer implements ClassFileTransformer {
+
+    private final ClassPatcher patcher;
+
+    public WideningTransformer(List<AccessWidenerEntry> entries) {
+        patcher = new ClassPatcher(entries);
+    }
+
+    @Override
+    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
+        return patcher.patch(className, classfileBuffer);
+    }
+}

BauSystem/BauSystem_Main/build.gradle.kts

@@ -19,6 +19,7 @@
 
 plugins {
     steamwar.java
+    widener
 }
 
 tasks.compileJava {
@@ -47,3 +48,7 @@ dependencies {
     implementation(libs.luaj)
     implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
 }
+
+widener {
+    fromCatalog(libs.nms)
+}

BauSystem/BauSystem_Main/src/BauSystem.properties

@@ -834,6 +834,10 @@ SKIN_NO_REGION = §7You are not in a region with a changealbe skin
 SKIN_ALREADY_EXISTS = §cThis skin already exists like this
 SKIN_MESSAGE = §7Skin created
 SKIN_MESSAGE_HOVER = §eClick to copy for YoyoNow and send
+# Blast Resistance
+BLASTRESISTANCE_HELP = §8/§eblastresistance §8-§7 Calculate min/max and average blast resistance of current clipboard
+BLASTRESISTANCE_NO_CLIPBOARD = §cYou currently do not have a clipboard to be used.
+BLASTRESISTANCE_RESULT = §7BlastResistance §8>>§7 Min§8: §e{0}§7   Max§8: §e{1}§7   Avg§8: §e{2}
 # Panzern
 PANZERN_HELP = §8/§epanzern §8[§7Block§8] §8[§7Slab§8] §8- §7Armor your WorldEdit selection
 PANZERN_PREPARE1 = §71. Check, if barrels reach until border of armor.

BauSystem/BauSystem_Main/src/BauSystem_de.properties

@@ -772,6 +772,10 @@ SKIN_NO_REGION = §7Du steht in keiner Region, welche mit einem Skin versehen we
 SKIN_ALREADY_EXISTS = §cDieser Skin existiert in der Form bereits
 SKIN_MESSAGE = §7Skin erstellt
 SKIN_MESSAGE_HOVER = §eKlicken zum kopieren für YoyoNow und an diesen senden
+# Blast Resistance
+BLASTRESISTANCE_HELP = §8/§eblastresistance §8-§7 Minimal-, Maximal- und durchschnittliche Sprengfestigkeit des aktuellen Inhalts der Zwischenablage berechnen
+BLASTRESISTANCE_NO_CLIPBOARD = §cDerzeit steht Ihnen keine Zwischenablage zur Verfügung.
+BLASTRESISTANCE_RESULT = §7BlastResistance §8>>§7 Min§8: §e{0}§7   Max§8: §e{1}§7   Avg§8: §e{2}
 # Panzern
 PANZERN_HELP = §8/§epanzern §8[§7Block§8] §8[§7Slab§8] §8- §7Panzer deine WorldEdit Auswahl
 PANZERN_PREPARE1 = §71. Gucke nochmal nach, ob Läufe auch bis zur Panzergrenze führen.

BauSystem/BauSystem_Main/src/bausystem.accesswidener

@@ -0,0 +1,13 @@
+accessWidener v2 named
+
+# For NoClipCommand
+accessible field net/minecraft/server/level/ServerPlayerGameMode gameModeForPlayer Lnet/minecraft/world/level/GameType;
+
+# For PlaceItemUtils
+accessible field org/bukkit/craftbukkit/block/CraftBlockState position Lnet/minecraft/core/BlockPos;
+mutable field org/bukkit/craftbukkit/block/CraftBlockState position Lnet/minecraft/core/BlockPos;
+accessible field org/bukkit/craftbukkit/block/CraftBlockState world Lorg/bukkit/craftbukkit/CraftWorld;
+mutable field org/bukkit/craftbukkit/block/CraftBlockState world Lorg/bukkit/craftbukkit/CraftWorld;
+
+# For TickManager
+accessible field net/minecraft/server/ServerTickRateManager remainingSprintTicks J

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/BauSystem.java

@@ -133,12 +133,7 @@ public class BauSystem extends JavaPlugin implements Listener {
 
         Bukkit.getWorlds().get(0).setGameRule(GameRule.SEND_COMMAND_FEEDBACK, false);
 
-        String identifier;
+        String identifier = BauServerInfo.getOwnerUser().getUUID().toString().replace("-", "");
-        if (BauServerInfo.getWorldId() != null) {
-            identifier = BauServerInfo.getWorldId().toString().replace("-", "");
-        } else {
-            identifier = BauServerInfo.getOwnerUser().getUUID().toString().replace("-", "");
-        }
         WorldIdentifier.set("bau/" + Core.getVersion() + "/" + identifier);
     }
 
@@ -229,4 +224,4 @@ public class BauSystem extends JavaPlugin implements Listener {
         AtomicReference<BukkitTask> task = new AtomicReference<>();
         task.set(runTaskTimer(plugin, () -> consumer.accept(task.get()), delay, period));
     }
-}
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/Permission.java

@@ -60,16 +60,11 @@ public enum Permission {
     }
 
     public boolean hasPermission(Player member) {
-        SteamwarUser steamwarUser = SteamwarUser.get(member.getUniqueId());
+        if (SteamwarUser.get(member.getUniqueId()).getId() == BauServer.getInstance().getOwnerID()) {
-        BauServer server = BauServer.getInstance();
-        if (!server.isTeamWorld() && steamwarUser.getId() == server.getOwnerID()) {
             return this != SPECTATOR;
         }
-        if (server.isTeamWorld() && steamwarUser.getTeam() == server.getTeamID()) {
+        BauweltMember bauweltMember = BauweltMember.getBauMember(BauServer.getInstance().getOwner(), member.getUniqueId());
-            return this != SPECTATOR;
-        }
-        BauweltMember bauweltMember = BauweltMember.getBauMember(server.getWorldID(), steamwarUser.getId());
         if (bauweltMember == null) return this == SPECTATOR;
         return permissionPredicate.test(bauweltMember);
     }
-}
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/config/BauServer.java

@@ -34,41 +34,16 @@ public class BauServer {
     }
 
     private Integer owner;
-    private UUID world;
-    private Integer team;
 
     public UUID getOwner() {
-        Integer ownerId = getOwnerID();
+        return SteamwarUser.byId(getOwnerID()).getUUID();
-        return ownerId == null ? null : SteamwarUser.byId(ownerId).getUUID();
     }
 
-    public Integer getOwnerID() {
+    public int getOwnerID() {
         //Lazy loading to improve startup time of the server in 1.15
         if (owner == null) {
             owner = BauServerInfo.getOwnerId();
         }
         return owner;
     }
-
+}
-    public boolean hasOwner() {
-        return getOwnerID() != null;
-    }
-
-    public UUID getWorldID() {
-        if (world == null) {
-            world = BauServerInfo.getWorldId();
-        }
-        return world;
-    }
-
-    public Integer getTeamID() {
-        if (team == null) {
-            team = BauServerInfo.getTeamId();
-        }
-        return team;
-    }
-
-    public boolean isTeamWorld() {
-        return getTeamID() != null;
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/bau/BauInfoBauGuiItem.java

@@ -47,7 +47,7 @@ public class BauInfoBauGuiItem extends BauGuiItem {
     @Override
     public ItemStack getItem(Player player) {
         SWItem itemStack;
-        if (!player.getName().endsWith("⍇") && !BauServer.getInstance().isTeamWorld()) {
+        if (!player.getName().endsWith("⍇")) {
             itemStack = SWItem.getPlayerSkull(SteamwarUser.get(BauServer.getInstance().getOwner()).getUserName());
         } else {
             itemStack = new SWItem(Material.PLAYER_HEAD, "");

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/bau/InfoCommand.java

@@ -47,9 +47,7 @@ public class InfoCommand extends SWCommand {
 
     @Register(description = "BAU_INFO_COMMAND_HELP")
     public void genericCommand(Player p) {
-        if (!bauServer.isTeamWorld()) {
+        BauSystem.MESSAGE.send("BAU_INFO_COMMAND_OWNER", p, SteamwarUser.byId(bauServer.getOwnerID()).getUserName());
-            BauSystem.MESSAGE.send("BAU_INFO_COMMAND_OWNER", p, SteamwarUser.byId(bauServer.getOwnerID()).getUserName());
-        }
         Region region = Region.getRegion(p.getLocation());
         for (Flag flag : Flag.getFlags()) {
             if (!region.getRegionData().has(flag).isApplicable()) continue;
@@ -60,7 +58,7 @@ public class InfoCommand extends SWCommand {
         }
 
         if (Permission.BUILD.hasPermission(p)) {
-            List<BauweltMember> members = BauweltMember.getWorldMembers(bauServer.getWorldID());
+            List<BauweltMember> members = BauweltMember.getMembers(bauServer.getOwnerID());
             Map<Permission, List<BauweltMember>> memberByPermission = new HashMap<>();
             members.forEach(member -> {
                 if (Permission.SUPERVISOR.hasPermission(member)) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/experimental/ExperimentalCommand.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,18 +17,15 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.core;
+package de.steamwar.bausystem.features.experimental;
 
-import lombok.experimental.UtilityClass;
+import de.steamwar.command.SWCommand;
-import net.minecraft.network.chat.MutableComponent;
+import de.steamwar.linkage.Linked;
-import net.minecraft.network.chat.contents.PlainTextContents;
 
-import java.util.Optional;
+@Linked
+public class ExperimentalCommand extends SWCommand {
 
-@UtilityClass
+    public ExperimentalCommand() {
-public class FlatteningWrapper {
+        super("experimental", "experiment");
-
-    public Object formatDisplayName(String displayName) {
-        return displayName != null ? Optional.of((Object) MutableComponent.create(PlainTextContents.create(displayName))) : Optional.empty();
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/experimental/redstone_engine/RedstoneEngine.java

@@ -0,0 +1,135 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.experimental.redstone_engine;
+
+import de.steamwar.bausystem.features.experimental.ExperimentalCommand;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.utils.ScoreboardElement;
+import de.steamwar.command.AbstractSWCommand;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+import io.papermc.paper.configuration.WorldConfiguration;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.title.TitlePart;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import java.util.Collection;
+import java.util.List;
+
+@AbstractSWCommand.PartOf(ExperimentalCommand.class)
+@Linked
+public class RedstoneEngine extends SWCommand implements Listener, ScoreboardElement {
+
+    public RedstoneEngine() {
+        super("");
+    }
+
+    private WorldConfiguration.Misc getConfig() {
+        return ((CraftWorld) Bukkit.getWorlds().get(0)).getHandle().paperConfig().misc;
+    }
+
+    @Register("redstone")
+    @Register("redstoneengine")
+    public void setRedstoneEngine(Player player, @StaticValue("alternate_current") String __, WorldConfiguration.Misc.AlternateCurrentUpdateOrder updateOrder) {
+        WorldConfiguration.Misc misc = getConfig();
+        misc.redstoneImplementation = WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT;
+        misc.alternateCurrentUpdateOrder = updateOrder;
+        broadcastTitle(Bukkit.getOnlinePlayers());
+    }
+
+    @Register("redstone")
+    @Register("redstoneengine")
+    public void setRedstoneEngine(Player player, WorldConfiguration.Misc.RedstoneImplementation implementation) {
+        getConfig().redstoneImplementation = implementation;
+        broadcastTitle(Bukkit.getOnlinePlayers());
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        WorldConfiguration.Misc misc = getConfig();
+        if (misc.redstoneImplementation != WorldConfiguration.Misc.RedstoneImplementation.EIGENCRAFT) {
+            broadcastTitle(List.of(event.getPlayer()));
+        }
+    }
+
+    private void broadcastTitle(Collection<? extends Player> players) {
+        WorldConfiguration.Misc misc = getConfig();
+        Component title = switch (misc.redstoneImplementation) {
+            case VANILLA -> Component.text("⚠").color(NamedTextColor.RED).append(Component.text(" Redstone: Vanilla ").color(NamedTextColor.WHITE)).append(Component.text("⚠").color(NamedTextColor.RED));
+            case EIGENCRAFT -> Component.text("Redstone: Eigencraft");
+            case ALTERNATE_CURRENT -> Component.text("⚠").color(NamedTextColor.RED).append(Component.text(" Redstone: AC ").color(NamedTextColor.WHITE)).append(Component.text("⚠").color(NamedTextColor.RED));
+        };
+        Component subtitle;
+        if (misc.redstoneImplementation != WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT) {
+            subtitle = Component.text().build();
+        } else {
+            subtitle = switch (misc.alternateCurrentUpdateOrder) {
+                case VERTICAL_FIRST_INWARD -> Component.text("Y first inwards"); // Y before XZ
+                case VERTICAL_FIRST_OUTWARD -> Component.text("Y first outwards"); // XZ before Y
+                case HORIZONTAL_FIRST_INWARD -> Component.text("XZ first inwards"); // Y before XZ
+                case HORIZONTAL_FIRST_OUTWARD -> Component.text("XZ first outwards"); // XZ before Y
+            };
+        }
+        players.forEach(player -> {
+            player.sendTitlePart(TitlePart.TITLE, title);
+            player.sendTitlePart(TitlePart.SUBTITLE, subtitle);
+        });
+    }
+
+    @Override
+    public ScoreboardGroup getGroup() {
+        return ScoreboardGroup.FOOTER;
+    }
+
+    @Override
+    public int order() {
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public String get(Region region, Player p) {
+        WorldConfiguration.Misc misc = getConfig();
+        switch (misc.redstoneImplementation) {
+            case ALTERNATE_CURRENT:
+                switch (misc.alternateCurrentUpdateOrder) {
+                    case VERTICAL_FIRST_INWARD:
+                        return "§eRedstone§8: §cAC §8(§7Y in§8)";
+                    case VERTICAL_FIRST_OUTWARD:
+                        return "§eRedstone§8: §cAC §8(§7Y out§8)";
+                    case HORIZONTAL_FIRST_INWARD:
+                        return "§eRedstone§8: §cAC §8(§7XZ in§8)";
+                    case HORIZONTAL_FIRST_OUTWARD:
+                        return "§eRedstone§8: §cAC §8(§7XZ out§8)";
+                }
+                return "§eRedstone§8: §cAC";
+            case EIGENCRAFT:
+                return null;
+            case VANILLA:
+            default:
+                return "§eRedstone§8: §cVanilla";
+        }
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/region/ColorCommand.java

@@ -20,7 +20,6 @@
 package de.steamwar.bausystem.features.region;
 
 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.region.RegionUtils;
@@ -84,9 +83,6 @@ public class ColorCommand extends SWCommand {
     @ClassValidator(value = Player.class, local = true)
     public TypeValidator<Player> validator() {
         return (commandSender, player, messageSender) -> {
-            if (bauServer.isTeamWorld()) {
-                return !messageSender.send(!Permission.SUPERVISOR.hasPermission(player), "NO_PERMISSION");
-            }
             return !messageSender.send(!bauServer.getOwner().equals(player.getUniqueId()), "NO_PERMISSION");
         };
     }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/region/ResetCommand.java

@@ -68,7 +68,7 @@ public class ResetCommand extends SWCommand {
         Region region = regionCheck(p);
         if (region == null) return;
 
-        if (bauServer.hasOwner() && !p.getUniqueId().equals(bauServer.getOwner())) {
+        if (!p.getUniqueId().equals(bauServer.getOwner())) {
             if (Punishment.isPunished(SteamwarUser.get(bauServer.getOwner()), Punishment.PunishmentType.NoSchemReceiving, punishment -> BauSystem.MESSAGE.send("REGION_TB_NO_SCHEMRECEIVING", p, punishment.getEndTime()))) {
                 return;
             }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/region/TestblockCommand.java

@@ -91,7 +91,7 @@ public class TestblockCommand extends SWCommand {
             }
         }
 
-        if (bauServer.hasOwner() && !p.getUniqueId().equals(bauServer.getOwner())) {
+        if (!p.getUniqueId().equals(bauServer.getOwner())) {
             if (Punishment.isPunished(SteamwarUser.get(bauServer.getOwner()), Punishment.PunishmentType.NoSchemReceiving, punishment -> BauSystem.MESSAGE.send("REGION_TB_NO_SCHEMRECEIVING", p, punishment.getEndTime()))) {
                 return;
             }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/SimulatorCursor.java

@@ -19,7 +19,6 @@
 
 package de.steamwar.bausystem.features.simulator;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.SWUtils;
@@ -38,77 +37,80 @@ import de.steamwar.bausystem.features.simulator.gui.SimulatorGui;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.bausystem.utils.ItemUtils;
-import de.steamwar.bausystem.utils.RayTraceUtils;
+import de.steamwar.core.SWPlayer;
+import de.steamwar.cursor.Cursor;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
 import de.steamwar.inventory.SWAnvilInv;
 import de.steamwar.linkage.Linked;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.BlockFace;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
 
 import java.util.*;
-import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @Linked
 public class SimulatorCursor implements Listener {
 
-    private static final World WORLD = Bukkit.getWorlds().get(0);
+    private static final Map<Player, CursorType> cursorType = Collections.synchronizedMap(new HashMap<>());
-
+    private static final Map<Player, REntityServer> emptyTargetServers = Collections.synchronizedMap(new HashMap<>());
-    private static Map<Player, CursorType> cursorType = Collections.synchronizedMap(new HashMap<>());
-    private static Map<Player, REntityServer> cursors = Collections.synchronizedMap(new HashMap<>());
-    private static final Set<Player> calculating = new HashSet<>();
 
     public static boolean isSimulatorItem(ItemStack itemStack) {
         return ItemUtils.isItem(itemStack, "simulator");
     }
 
-    public SimulatorCursor() {
+    private static boolean hasSimulatorItem(Player player) {
-        BiFunction<Player, ServerboundMovePlayerPacket, Object> function = (player, object) -> {
+        return isSimulatorItem(player.getInventory().getItemInMainHand()) || isSimulatorItem(player.getInventory().getItemInOffHand());
-            calcCursor(player);
+    }
-            return object;
+
-        };
+    private static void scheduleCursorUpdate(Player player) {
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, function);
+        BauSystem.runTaskLater(BauSystem.getInstance(), () -> calcCursor(player), 1);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Rot.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, function);
     }
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
+        scheduleCursorUpdate(event.getPlayer());
-            calcCursor(event.getPlayer());
-        }, 0);
     }
 
     @EventHandler
     public void onPlayerDropItem(PlayerDropItemEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        calcCursor(event.getPlayer());
+        scheduleCursorUpdate(event.getPlayer());
     }
 
     @EventHandler
     public void onPlayerItemHeld(PlayerItemHeldEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
+        scheduleCursorUpdate(event.getPlayer());
-            calcCursor(event.getPlayer());
+    }
-        }, 1);
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) return;
+        if (!Permission.BUILD.hasPermission(player)) return;
+        scheduleCursorUpdate(player);
+    }
+
+    @EventHandler
+    public void onInventoryDrag(InventoryDragEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) return;
+        if (!Permission.BUILD.hasPermission(player)) return;
+        scheduleCursorUpdate(player);
     }
 
     @EventHandler
@@ -119,10 +121,7 @@ public class SimulatorCursor implements Listener {
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent event) {
         cursorType.remove(event.getPlayer());
-        cursors.remove(event.getPlayer());
+        removeCursor(event.getPlayer());
-        synchronized (calculating) {
-            calculating.remove(event.getPlayer());
-        }
     }
 
     private static final Map<Player, Long> LAST_SNEAKS = new HashMap<>();
@@ -138,7 +137,7 @@ public class SimulatorCursor implements Listener {
     public void onPlayerToggleSneak(PlayerToggleSneakEvent event) {
         if (!event.isSneaking()) return;
         Player player = event.getPlayer();
-        if (!isSimulatorItem(player.getInventory().getItemInMainHand()) && !isSimulatorItem(player.getInventory().getItemInOffHand())) {
+        if (!hasSimulatorItem(player)) {
             return;
         }
         if (LAST_SNEAKS.containsKey(player)) {
@@ -164,17 +163,10 @@ public class SimulatorCursor implements Listener {
     }
 
     public static void calcCursor(Player player) {
-        synchronized (calculating) {
+        if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
-            if (calculating.contains(player)) return;
+            if (removeCursor(player) | SimulatorWatcher.show(null, player)) {
-            calculating.add(player);
-        }
-        if (!Permission.BUILD.hasPermission(player) || (!isSimulatorItem(player.getInventory().getItemInMainHand()) && !isSimulatorItem(player.getInventory().getItemInOffHand()))) {
-            if (removeCursor(player) || SimulatorWatcher.show(null, player)) {
                 SWUtils.sendToActionbar(player, "");
             }
-            synchronized (calculating) {
-                calculating.remove(player);
-            }
             return;
         }
 
@@ -183,203 +175,98 @@ public class SimulatorCursor implements Listener {
             removeCursor(player);
             SimulatorWatcher.show(null, player);
             SWUtils.sendToActionbar(player, "§cGenerating Stab");
-            synchronized (calculating) {
-                calculating.remove(player);
-            }
             return;
         }
 
         SimulatorWatcher.show(simulator, player);
-        List<REntity> entities = SimulatorWatcher.getEntitiesOfSimulator(simulator);
+        Cursor cursor = getOrCreateCursor(player, simulator, cursorType.getOrDefault(player, CursorType.TNT));
-        RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(player, player.getLocation(), entities);
+        cursor.renderDeduplicated();
-        if (rayTraceResult == null) {
+    }
-            removeCursor(player);
+
-            if (simulator == null) {
+    private static Cursor getOrCreateCursor(Player player, Simulator simulator, CursorType type) {
-                SWUtils.sendToActionbar(player, "§eSelect Simulator");
+        REntityServer targetServer = simulator == null ? emptyTargetServers.computeIfAbsent(player, __ -> new REntityServer()) : SimulatorWatcher.getEntityServerOfSimulator(simulator);
-            } else {
+        SWPlayer swPlayer = SWPlayer.of(player);
-                SWUtils.sendToActionbar(player, "§eOpen Simulator");
+        Optional<Cursor> activeCursor = swPlayer.getComponent(Cursor.class);
-            }
+
-            synchronized (calculating) {
+        Cursor cursor = activeCursor.orElse(null);
-                calculating.remove(player);
+        if (cursor == null || cursor.getTargetServer() != targetServer) {
-            }
+            swPlayer.removeComponent(Cursor.class);
-            return;
+            cursor = new Cursor(
+                    targetServer,
+                    player,
+                    Material.GLASS,
+                    type.material,
+                    type.cursorModes,
+                    (location, hitEntity, action) -> handlePlayerClick(player, location, hitEntity, action),
+                    (location, hitEntity) -> sendCursorActionbar(player, SimulatorStorage.getSimulator(player), location != null, hitEntity.isPresent())
+            );
+        } else {
+            cursor.setCursorMaterial(type.material);
+            cursor.setAllowedCursorModes(type.cursorModes);
         }
 
-        showCursor(player, rayTraceResult, simulator != null);
+        return cursor;
-        synchronized (calculating) {
-            calculating.remove(player);
-        }
     }
 
     private static synchronized boolean removeCursor(Player player) {
-        REntityServer entityServer = cursors.get(player);
+        Optional<Cursor> cursor = SWPlayer.of(player).getComponent(Cursor.class);
-        boolean hadCursor = entityServer != null && !entityServer.getEntities().isEmpty();
+        cursor.ifPresent(__ -> SWPlayer.of(player).removeComponent(Cursor.class));
-        if (entityServer != null) {
+        REntityServer emptyTargetServer = emptyTargetServers.remove(player);
-            entityServer.getEntities().forEach(REntity::die);
+        if (emptyTargetServer != null) {
+            emptyTargetServer.close();
         }
-        return hadCursor;
+        return cursor.isPresent();
     }
 
-    private static synchronized void showCursor(Player player, RayTraceUtils.RRayTraceResult rayTraceResult, boolean hasSimulatorSelected) {
+    private static void sendCursorActionbar(Player player, Simulator simulator, boolean hasCursorLocation, boolean hasHitEntity) {
-        REntityServer entityServer = cursors.computeIfAbsent(player, __ -> {
+        if (!hasCursorLocation) {
-            REntityServer rEntityServer = new REntityServer();
+            SWUtils.sendToActionbar(player, simulator == null ? "§eSelect Simulator" : "§eOpen Simulator");
-            rEntityServer.addPlayer(player);
+        } else if (simulator == null) {
-            return rEntityServer;
-        });
-
-        CursorType type = cursorType.getOrDefault(player, CursorType.TNT);
-        REntity hitEntity = rayTraceResult.getHitEntity();
-        Location location = hitEntity != null ? new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ()).toLocation(WORLD) :
-                type.position.apply(player, rayTraceResult).toLocation(WORLD);
-
-        Material material = hitEntity != null ? Material.GLASS : type.getMaterial();
-        List<RFallingBlockEntity> entities = entityServer.getEntitiesByType(RFallingBlockEntity.class);
-        entities.removeIf(rFallingBlockEntity -> {
-            if (rFallingBlockEntity.getMaterial() != material) {
-                rFallingBlockEntity.die();
-                return true;
-            }
-            rFallingBlockEntity.move(location);
-            return false;
-        });
-        if (entities.isEmpty()) {
-            RFallingBlockEntity rFallingBlockEntity = new RFallingBlockEntity(entityServer, location, material);
-            rFallingBlockEntity.setNoGravity(true);
-            if (material == Material.GLASS) {
-                rFallingBlockEntity.setGlowing(true);
-            }
-        }
-
-        if (hasSimulatorSelected) {
-            if (hitEntity != null) {
-                SWUtils.sendToActionbar(player, "§eEdit Position");
-            } else {
-                SWUtils.sendToActionbar(player, "§eAdd new " + type.name);
-            }
-        } else {
             SWUtils.sendToActionbar(player, "§eCreate new Simulator");
-        }
+        } else if (hasHitEntity) {
-    }
+            SWUtils.sendToActionbar(player, "§eEdit Position");
-
-    public static Vector getPosFree(Player player, RayTraceUtils.RRayTraceResult result) {
-        Vector pos = result.getHitPosition();
-
-        BlockFace face = result.getHitBlockFace();
-        if (face != null) {
-            switch (face) {
-                case DOWN:
-                    pos.setY(pos.getY() - 0.98);
-                    break;
-                case EAST:
-                    pos.setX(pos.getX() + 0.49);
-                    break;
-                case WEST:
-                    pos.setX(pos.getX() - 0.49);
-                    break;
-                case NORTH:
-                    pos.setZ(pos.getZ() - 0.49);
-                    break;
-                case SOUTH:
-                    pos.setZ(pos.getZ() + 0.49);
-                    break;
-                default:
-                    break;
-            }
-
-            if (face.getModY() == 0 && player.isSneaking()) {
-                pos.setY(pos.getY() - 0.49);
-            }
-        }
-
-        if (!player.isSneaking()) {
-            pos.setX(pos.getBlockX() + 0.5);
-            if (face == null || face.getModY() == 0) {
-                pos.setY(pos.getBlockY() + 0.0);
-            }
-            pos.setZ(pos.getBlockZ() + 0.5);
-        }
-
-        return pos;
-    }
-
-    private static Vector getPosBlockAligned(Player player, RayTraceUtils.RRayTraceResult result) {
-        Vector pos = result.getHitPosition();
-
-        BlockFace face = result.getHitBlockFace();
-        if (face != null) {
-            switch (face) {
-                case DOWN:
-                    pos.setY(pos.getY() - 0.98);
-                    break;
-                case EAST:
-                    pos.setX(pos.getX() + 0.49);
-                    break;
-                case WEST:
-                    pos.setX(pos.getX() - 0.49);
-                    break;
-                case NORTH:
-                    pos.setZ(pos.getZ() - 0.49);
-                    break;
-                case SOUTH:
-                    pos.setZ(pos.getZ() + 0.49);
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        pos.setX(pos.getBlockX() + 0.5);
-        if (pos.getY() - pos.getBlockY() != 0 && face == BlockFace.UP) {
-            pos.setY(pos.getBlockY() + 1.0);
         } else {
-            pos.setY(pos.getBlockY());
+            SWUtils.sendToActionbar(player, "§eAdd new " + cursorType.getOrDefault(player, CursorType.TNT).name);
         }
-        pos.setZ(pos.getBlockZ() + 0.5);
-        return pos;
     }
 
     @Getter
     @AllArgsConstructor
     public enum CursorType {
-        TNT(Material.TNT, Material.GUNPOWDER, SimulatorCursor::getPosFree, "TNT", vector -> new TNTElement(vector).add(new TNTPhase())),
+        TNT(Material.TNT, Material.GUNPOWDER, List.of(Cursor.CursorMode.FREE, Cursor.CursorMode.SURFACE_ALIGNED), "TNT", vector -> new TNTElement(vector).add(new TNTPhase())),
-        REDSTONE_BLOCK(Material.REDSTONE_BLOCK, Material.REDSTONE, SimulatorCursor::getPosBlockAligned, "Redstone Block", vector -> new RedstoneElement(vector).add(new RedstonePhase())),
+        REDSTONE_BLOCK(Material.REDSTONE_BLOCK, Material.REDSTONE, List.of(Cursor.CursorMode.BLOCK_ALIGNED), "Redstone Block", vector -> new RedstoneElement(vector).add(new RedstonePhase())),
-        OBSERVER(Material.OBSERVER, Material.QUARTZ, SimulatorCursor::getPosBlockAligned, "Observer", vector -> new ObserverElement(vector).add(new ObserverPhase())),
+        OBSERVER(Material.OBSERVER, Material.QUARTZ, List.of(Cursor.CursorMode.BLOCK_ALIGNED), "Observer", vector -> new ObserverElement(vector).add(new ObserverPhase())),
         ;
 
         public final Material material;
         public final Material nonSelectedMaterial;
-        public final BiFunction<Player, RayTraceUtils.RRayTraceResult, Vector> position;
+        public final List<Cursor.CursorMode> cursorModes;
         public final String name;
         public final Function<Vector, SimulatorElement<?>> elementFunction;
     }
 
-    @EventHandler
+    private static void handlePlayerClick(Player player, Location cursorLocation, Optional<REntity> hitEntity, Action action) {
-    public void onPlayerInteract(PlayerInteractEvent event) {
+        if (!Permission.BUILD.hasPermission(player)) return;
-        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
+        if (!hasSimulatorItem(player)) {
-        if (!ItemUtils.isItem(event.getItem(), "simulator")) {
             return;
         }
 
-        event.setCancelled(true);
-        Player player = event.getPlayer();
         Simulator simulator = SimulatorStorage.getSimulator(player);
 
-        if (event.getAction() == Action.LEFT_CLICK_BLOCK || event.getAction() == Action.LEFT_CLICK_AIR) {
+        if (action == Action.LEFT_CLICK_BLOCK || action == Action.LEFT_CLICK_AIR) {
             if (simulator == null) {
                 return;
             }
-            SimulatorExecutor.run(event.getPlayer(), simulator, null);
+            SimulatorExecutor.run(player, simulator, null);
             return;
         }
 
-        if (event.getAction() != Action.RIGHT_CLICK_BLOCK && event.getAction() != Action.RIGHT_CLICK_AIR) {
+        if (action != Action.RIGHT_CLICK_BLOCK && action != Action.RIGHT_CLICK_AIR) {
             return;
         }
 
-
-        RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(player, player.getLocation(), SimulatorWatcher.getEntitiesOfSimulator(simulator));
         if (simulator == null) {
-            if (rayTraceResult == null) {
+            if (cursorLocation == null) {
                 SimulatorStorage.openSimulatorSelector(player);
             } else {
                 SWAnvilInv anvilInv = new SWAnvilInv(player, "Name");
@@ -395,7 +282,7 @@ public class SimulatorCursor implements Listener {
                     }
                     sim = new Simulator(s);
                     SimulatorStorage.addSimulator(s, sim);
-                    createElement(player, rayTraceResult, sim);
+                    createElement(player, cursorLocation, sim);
                     SimulatorStorage.setSimulator(player, sim);
                 });
                 anvilInv.open();
@@ -403,57 +290,56 @@ public class SimulatorCursor implements Listener {
             return;
         }
 
-        if (rayTraceResult == null) {
+        if (cursorLocation == null) {
             new SimulatorGui(player, simulator).open();
             return;
         }
 
-        if (rayTraceResult.getHitEntity() != null) {
+        if (hitEntity.isPresent()) {
-            REntity hitEntity = rayTraceResult.getHitEntity();
+            openElement(player, simulator, hitEntity.get());
-            Vector vector = new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ());
-            List<SimulatorElement<?>> elements = simulator.getGroups().stream().map(SimulatorGroup::getElements).flatMap(List::stream).filter(element -> {
-                return element.getWorldPos().distanceSquared(vector) < (1 / 16.0) * (1 / 16.0);
-            }).collect(Collectors.toList());
-
-            switch (elements.size()) {
-                case 0:
-                    return;
-                case 1:
-                    // Open single element present in Simulator
-                    SimulatorElement<?> element = elements.get(0);
-                    SimulatorGroup group1 = element.getGroup(simulator);
-                    SimulatorBaseGui back = new SimulatorGui(player, simulator);
-                    if (group1.getElements().size() > 1) {
-                        back = new SimulatorGroupGui(player, simulator, group1, back);
-                    }
-                    element.open(player, simulator, group1, back);
-                    break;
-                default:
-                    List<SimulatorGroup> parents = elements.stream().map(e -> e.getGroup(simulator)).distinct().collect(Collectors.toList());
-                    if (parents.size() == 1) {
-                        // Open multi element present in Simulator in existing group
-                        SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
-                        new SimulatorGroupGui(player, simulator, parents.get(0), simulatorGui).open();
-                    } else {
-                        // Open multi element present in Simulator in implicit group
-                        SimulatorGroup group2 = new SimulatorGroup();
-                        group2.setMaterial(null);
-                        group2.getElements().addAll(elements);
-                        SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
-                        new SimulatorGroupGui(player, simulator, group2, simulatorGui).open();
-                    }
-                    break;
-            }
             return;
         }
 
-        // Add new Element to current simulator
+        createElement(player, cursorLocation, simulator);
-        createElement(player, rayTraceResult, simulator);
     }
 
-    private void createElement(Player player, RayTraceUtils.RRayTraceResult rayTraceResult, Simulator simulator) {
+    private static void openElement(Player player, Simulator simulator, REntity hitEntity) {
+        Vector vector = new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ());
+        List<SimulatorElement<?>> elements = simulator.getGroups().stream().map(SimulatorGroup::getElements).flatMap(List::stream).filter(element -> {
+            return element.getWorldPos().distanceSquared(vector) < (1 / 16.0) * (1 / 16.0);
+        }).collect(Collectors.toList());
+
+        switch (elements.size()) {
+            case 0:
+                return;
+            case 1:
+                SimulatorElement<?> element = elements.get(0);
+                SimulatorGroup group1 = element.getGroup(simulator);
+                SimulatorBaseGui back = new SimulatorGui(player, simulator);
+                if (group1.getElements().size() > 1) {
+                    back = new SimulatorGroupGui(player, simulator, group1, back);
+                }
+                element.open(player, simulator, group1, back);
+                break;
+            default:
+                List<SimulatorGroup> parents = elements.stream().map(e -> e.getGroup(simulator)).distinct().collect(Collectors.toList());
+                if (parents.size() == 1) {
+                    SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
+                    new SimulatorGroupGui(player, simulator, parents.get(0), simulatorGui).open();
+                } else {
+                    SimulatorGroup group2 = new SimulatorGroup();
+                    group2.setMaterial(null);
+                    group2.getElements().addAll(elements);
+                    SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
+                    new SimulatorGroupGui(player, simulator, group2, simulatorGui).open();
+                }
+                break;
+        }
+    }
+
+    private static void createElement(Player player, Location cursorLocation, Simulator simulator) {
         CursorType type = cursorType.getOrDefault(player, CursorType.TNT);
-        Vector vector = type.position.apply(player, rayTraceResult);
+        Vector vector = cursorLocation.toVector();
         if (type == CursorType.REDSTONE_BLOCK) {
             vector.subtract(new Vector(0.5, 0, 0.5));
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/SimulatorWatcher.java

@@ -124,4 +124,11 @@ public class SimulatorWatcher {
         }
         return entityServer.getEntities();
     }
+
+    synchronized REntityServer getEntityServerOfSimulator(Simulator simulator) {
+        if (simulator == null) {
+            return null;
+        }
+        return entityServers.computeIfAbsent(simulator, __ -> createSim(new REntityServer(), simulator));
+    }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/blastresistance/BlastResistanceCommand.java

@@ -0,0 +1,72 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.blastresistance;
+
+import com.google.common.util.concurrent.AtomicDouble;
+import com.sk89q.worldedit.LocalSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.world.block.BlockState;
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Linked
+public class BlastResistanceCommand extends SWCommand {
+
+    public BlastResistanceCommand() {
+        super("blastresistance");
+    }
+
+    @Register(description = "BLASTRESISTANCE_HELP")
+    public void command(@Validator Player player) {
+        LocalSession localSession = WorldEdit.getInstance().getSessionManager().get(BukkitAdapter.adapt(player));
+        Clipboard clipboard;
+        try {
+            clipboard = localSession.getClipboard().getClipboards().getFirst();
+        } catch (WorldEditException e) {
+            BauSystem.MESSAGE.send("BLASTRESISTANCE_NO_CLIPBOARD", player);
+            return;
+        }
+
+        AtomicDouble min = new AtomicDouble(0);
+        AtomicDouble max = new AtomicDouble(0);
+        AtomicDouble sum = new AtomicDouble(0);
+        AtomicInteger count = new AtomicInteger(0);
+        clipboard.forEach(blockVector3 -> {
+            BlockState blockState = clipboard.getBlock(blockVector3);
+            Material material = BukkitAdapter.adapt(blockState).getMaterial();
+            if (material == Material.WATER || material == Material.LAVA) return;
+            double blastResistance = BukkitAdapter.adapt(blockState).getMaterial().getBlastResistance();
+            min.set(Math.min(min.get(), blastResistance));
+            max.set(Math.max(max.get(), blastResistance));
+            sum.addAndGet(blastResistance);
+            count.getAndIncrement();
+        });
+
+        BauSystem.MESSAGE.send("BLASTRESISTANCE_RESULT", player, min.get(), max.get(), sum.get() / count.get());
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/techhider/TechHiderCommand.java

@@ -31,6 +31,7 @@ import de.steamwar.command.TypeMapper;
 import de.steamwar.core.CraftbukkitWrapper;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.techhider.legacy.TechHider;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
@@ -38,7 +39,6 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
-import de.steamwar.techhider.legacy.TechHider;
 
 import java.util.*;
 import java.util.stream.Collectors;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/tracer/Trace.java

@@ -25,7 +25,6 @@ import de.steamwar.bausystem.features.tracer.rendering.TraceEntity;
 import de.steamwar.bausystem.features.tracer.rendering.ViewFlag;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.entity.REntity;
-import de.steamwar.entity.REntityAction;
 import de.steamwar.entity.REntityServer;
 import lombok.Getter;
 import lombok.Setter;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/util/BindCommand.java

@@ -38,6 +38,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.NamespacedKey;
 import org.bukkit.command.CommandMap;
 import org.bukkit.command.CommandSender;
+import org.bukkit.craftbukkit.CraftServer;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -47,7 +48,6 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.persistence.PersistentDataType;
 
-import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -73,19 +73,7 @@ public class BindCommand extends SWCommand implements Listener {
         }
     }
 
-    private static final CommandMap commandMap;
+    private static final CommandMap commandMap = ((CraftServer) Bukkit.getServer()).getCommandMap();
-
-    static {
-        Field knownCommandsField;
-        try {
-            knownCommandsField = Bukkit.getServer().getClass().getDeclaredField("commandMap");
-            knownCommandsField.setAccessible(true);
-            commandMap = (CommandMap) knownCommandsField.get(Bukkit.getServer());
-        } catch (IllegalAccessException | NoSuchFieldException var2) {
-            Bukkit.shutdown();
-            throw new SecurityException("Oh shit. Commands cannot be registered.", var2);
-        }
-    }
 
     private static final NamespacedKey KEY = SWUtils.getNamespaceKey("command");
 

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/util/NoClipCommand.java

@@ -21,7 +21,6 @@ package de.steamwar.bausystem.features.util;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
 import com.mojang.authlib.GameProfile;
-import de.steamwar.Reflection;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.features.tpslimit.TPSUtils;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
@@ -30,7 +29,6 @@ import de.steamwar.core.ProtocolWrapper;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
 import net.minecraft.network.protocol.game.*;
-import net.minecraft.server.level.ServerPlayerGameMode;
 import net.minecraft.world.entity.player.Abilities;
 import net.minecraft.world.level.GameType;
 import org.bukkit.Bukkit;
@@ -103,10 +101,8 @@ public class NoClipCommand extends SWCommand implements Listener {
         TinyProtocol.instance.addFilter(ServerboundSetCreativeModeSlotPacket.class, third);
     }
 
-    private static final Reflection.Field<GameType> playerGameMode = Reflection.getField(ServerPlayerGameMode.class, GameType.class, 0);
-
     private void setInternalGameMode(Player player, GameMode gameMode) {
-        playerGameMode.set(((CraftPlayer) player).getHandle().gameMode, GameType.byId(gameMode.getValue()));
+        ((CraftPlayer) player).getHandle().gameMode.gameModeForPlayer = GameType.byId(gameMode.getValue());
     }
 
     @Register(help = true)
@@ -143,6 +139,7 @@ public class NoClipCommand extends SWCommand implements Listener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlock(BlockCanBuildEvent event) {
+        if (event.getPlayer() == null) return;
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
             event.setBuildable(true);
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/AntiBauAddMemberFix.java

@@ -20,7 +20,6 @@
 package de.steamwar.bausystem.features.world;
 
 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.core.CRIUWakeupEvent;
 import de.steamwar.linkage.Linked;
@@ -37,13 +36,12 @@ public class AntiBauAddMemberFix implements Listener {
     @EventHandler(priority = EventPriority.LOW)
     public void onPlayerJoin(PlayerJoinEvent event) {
         if (BauSystem.DEV_SERVER) return;
-        if (Permission.SUPERVISOR.hasPermission(event.getPlayer())) {
+        if (event.getPlayer().getUniqueId().equals(BauServer.getInstance().getOwner())) {
             return;
         }
-        if (BauweltMember.getBauMember(BauServer.getInstance().getWorldID(), event.getPlayer().getUniqueId()) == null) {
+        if (BauweltMember.getBauMember(BauServer.getInstance().getOwner(), event.getPlayer().getUniqueId()) == null) {
             event.getPlayer().kickPlayer("");
-            String owner = BauServer.getInstance().isTeamWorld() ? "team " + BauServer.getInstance().getTeamID() : SteamwarUser.byId(BauServer.getInstance().getOwnerID()).getUserName();
+            throw new SecurityException("The player " + event.getPlayer().getName() + " joined on the server of " + SteamwarUser.byId(BauServer.getInstance().getOwnerID()).getUserName() + " without being added!");
-            throw new SecurityException("The player " + event.getPlayer().getName() + " joined on the server of " + owner + " without being added!");
         }
     }
 

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/AxiomPermissionCheck.java

@@ -33,7 +33,7 @@ public class AxiomPermissionCheck implements Listener {
 
     @EventHandler
     public void onAxiomHandshake(AxiomHandshakeEvent event) {
-        if (Permission.SUPERVISOR.hasPermission(event.getPlayer()) || (BauServer.getInstance().hasOwner() && BauServer.getInstance().getOwner().equals(event.getPlayer().getUniqueId()))) {
+        if (Permission.SUPERVISOR.hasPermission(event.getPlayer()) || BauServer.getInstance().getOwner().equals(event.getPlayer().getUniqueId())) {
             event.setMaxBufferSize(Short.MAX_VALUE);
             return;
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/BauLockStateScoreboard.java

@@ -28,7 +28,7 @@ import de.steamwar.data.BauLockState;
 import de.steamwar.linkage.Linked;
 import de.steamwar.network.packets.PacketHandler;
 import de.steamwar.network.packets.server.BaulockUpdatePacket;
-import de.steamwar.sql.SteamwarWorld;
+import de.steamwar.sql.UserConfig;
 import lombok.Getter;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -37,13 +37,13 @@ import org.bukkit.event.Listener;
 @Linked
 public class BauLockStateScoreboard extends PacketHandler implements ScoreboardElement, Listener {
 
+    private static final String BAU_LOCK_CONFIG_NAME = "baulockstate";
+
     @Getter
     private BauLockState lockState = loadLockState();
 
     private BauLockState loadLockState() {
-        if (BauServer.getInstance().isTeamWorld()) return BauLockState.OPEN;
+        String state = UserConfig.getConfig(BauServer.getInstance().getOwner(), BAU_LOCK_CONFIG_NAME);
-        SteamwarWorld world = SteamwarWorld.getWorld(BauServer.getInstance().getWorldID());
-        String state = world == null ? null : world.getLockState();
         return state == null ? BauLockState.OPEN : BauLockState.valueOf(state);
     }
 
@@ -69,7 +69,6 @@ public class BauLockStateScoreboard extends PacketHandler implements ScoreboardE
 
     @Override
     public String get(Region region, Player p) {
-        if (BauServer.getInstance().isTeamWorld()) return null;
         if (!BauServer.getInstance().getOwner().equals(p.getUniqueId())) {
             return null;
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/BauMemberUpdate.java

@@ -36,8 +36,6 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.PlayerDeathEvent;
-import org.bukkit.event.inventory.ClickType;
-import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.player.PlayerItemConsumeEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/KickallCommand.java

@@ -42,11 +42,7 @@ public class KickallCommand extends SWCommand {
         if (!Permission.OWNER.hasPermission(player)) return;
 
         Bukkit.getOnlinePlayers().forEach(p -> {
-            if (bauServer.isTeamWorld()) {
+            if (!bauServer.getOwner().equals(p.getUniqueId())) p.kickPlayer("");
-                if (!Permission.SUPERVISOR.hasPermission(p)) p.kickPlayer("");
-            } else if (!bauServer.getOwner().equals(p.getUniqueId())) {
-                p.kickPlayer("");
-            }
         });
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/SpectatorListener.java

@@ -25,6 +25,7 @@ import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.BauweltMember;
+import de.steamwar.techhider.legacy.TechHider;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
@@ -39,7 +40,6 @@ import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.util.Vector;
-import de.steamwar.techhider.legacy.TechHider;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -143,14 +143,17 @@ public class SpectatorListener implements Listener {
     public void onPlayerJoin(PlayerJoinEvent event) {
         enableOrDisableTechhider();
         if (BauSystem.DEV_SERVER) return;
-        if (Permission.SUPERVISOR.hasPermission(event.getPlayer())) {
+        if (event.getPlayer().getUniqueId().equals(BauServer.getInstance().getOwner())) {
             return;
         }
-        BauweltMember bauweltMember = BauweltMember.getBauMember(BauServer.getInstance().getWorldID(), event.getPlayer().getUniqueId());
+        BauweltMember bauweltMember = BauweltMember.getBauMember(BauServer.getInstance().getOwner(), event.getPlayer().getUniqueId());
         if (bauweltMember == null) {
             event.getPlayer().kickPlayer("");
             return;
         }
+        if (Permission.SUPERVISOR.hasPermission(event.getPlayer())) {
+            return;
+        }
         if (!anySupervisorOnline(null)) {
             Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
                 event.getPlayer().kickPlayer("");

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/WorldEditListener.java

@@ -57,7 +57,7 @@ public class WorldEditListener implements Listener {
 
     private static final Set<String> commands = new HashSet<>();
     private static final Set<String> commandExclusions = new HashSet<>();
-    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r"};
+    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r", "//download", "/download"};
 
     public static boolean isWorldEditCommand(String command) {
         for (String shortcut : shortcutCommands) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/xray/XrayCommand.java

@@ -28,6 +28,7 @@ import de.steamwar.command.SWCommand;
 import de.steamwar.core.CraftbukkitWrapper;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.techhider.legacy.TechHider;
 import net.md_5.bungee.api.ChatMessageType;
 import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import net.minecraft.server.level.ServerPlayer;
@@ -40,7 +41,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
-import de.steamwar.techhider.legacy.TechHider;
 
 import java.util.*;
 import java.util.function.BiFunction;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/utils/PlaceItemUtils.java

@@ -19,7 +19,6 @@
 
 package de.steamwar.bausystem.utils;
 
-import de.steamwar.Reflection;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.experimental.UtilityClass;
@@ -86,9 +85,6 @@ public class PlaceItemUtils {
                 .collect(Collectors.toSet());
     }
 
-    private static final Reflection.Field<?> positionAccessor = Reflection.getField(CraftBlockState.class, BlockPos.class, 0);
-    private static final Reflection.Field<?> worldAccessor = Reflection.getField(CraftBlockState.class, CraftWorld.class, 0);
-
     /**
      * Attempt to place an {@link ItemStack} the {@link Player} is holding against a {@link Block} inside the World.
      * This can be easily used inside the {@link org.bukkit.event.player.PlayerInteractEvent} to mimik placing a
@@ -288,8 +284,9 @@ public class PlaceItemUtils {
         } else {
             // If a BlockState is present set the Position and World to the Block you want to place
             Location blockLocation = block.getLocation();
-            positionAccessor.set(blockState, new BlockPos(blockLocation.getBlockX(), blockLocation.getBlockY(), blockLocation.getBlockZ()));
+            CraftBlockState craftBlockState = (CraftBlockState) blockState;
-            worldAccessor.set(blockState, blockLocation.getWorld());
+            craftBlockState.position = new BlockPos(blockLocation.getBlockX(), blockLocation.getBlockY(), blockLocation.getBlockZ());
+            craftBlockState.world = (CraftWorld) blockLocation.getWorld();
         }
 
         if (blockData.getMaterial().isSolid()) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/utils/TickManager.java

@@ -20,7 +20,6 @@
 package de.steamwar.bausystem.utils;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.bausystem.BauSystem;
 import net.minecraft.network.protocol.game.ClientboundTickingStatePacket;
 import net.minecraft.server.MinecraftServer;
@@ -33,7 +32,6 @@ public class TickManager implements Listener {
     public static final TickManager impl = new TickManager();
 
     private static final ServerTickRateManager manager = MinecraftServer.getServer().tickRateManager();
-    private static final Reflection.Field<Long> remainingSprintTicks = Reflection.getField(ServerTickRateManager.class, long.class, 0);
 
     private boolean blockTpsPacket = true;
     private int totalSteps;
@@ -121,7 +119,7 @@ public class TickManager implements Listener {
 
     public long getRemainingTicks() {
         if (isSprinting()) {
-            return remainingSprintTicks.get(manager);
+            return manager.remainingSprintTicks;
         } else {
             return manager.frozenTicksToRun();
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/utils/WorldEditUtils.java

@@ -19,6 +19,7 @@
 
 package de.steamwar.bausystem.utils;
 
+import com.fastasyncworldedit.core.regions.selector.PolyhedralRegionSelector;
 import com.sk89q.worldedit.EditSession;
 import com.sk89q.worldedit.IncompleteRegionException;
 import com.sk89q.worldedit.LocalSession;
@@ -32,16 +33,19 @@ import com.sk89q.worldedit.internal.registry.InputParser;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.Region;
 import com.sk89q.worldedit.regions.RegionSelector;
+import com.sk89q.worldedit.regions.selector.*;
 import com.sk89q.worldedit.regions.selector.limit.SelectorLimits;
-import de.steamwar.Reflection;
+import com.sk89q.worldedit.world.World;
 import de.steamwar.bausystem.shared.Pair;
 import lombok.SneakyThrows;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Location;
-import org.bukkit.World;
 import org.bukkit.entity.Player;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @UtilityClass
@@ -91,17 +95,36 @@ public class WorldEditUtils {
                 .getRegionSelector(BukkitAdapter.adapt(player.getWorld()));
         return new Pair<>(regionSelector.getClass(), regionSelector.getVertices()
                 .stream()
-                .map(blockVector3 -> blockVector3 == null ? null : adapt(player.getWorld(), blockVector3))
+                .map(blockVector3 -> {
+                    if (blockVector3 == null) {
+                        return null;
+                    } else {
+                        return BukkitAdapter.adapt(player.getWorld(), blockVector3);
+                    }
+                })
                 .collect(Collectors.toList()));
     }
 
+    private static final Map<Class<? extends RegionSelector>, Function<World, RegionSelector>> constructors = new HashMap<>();
+    static {
+        constructors.put(CuboidRegionSelector.class, CuboidRegionSelector::new);
+        constructors.put(ExtendingCuboidRegionSelector.class, ExtendingCuboidRegionSelector::new);
+        constructors.put(Polygonal2DRegionSelector.class, Polygonal2DRegionSelector::new);
+        constructors.put(EllipsoidRegionSelector.class, EllipsoidRegionSelector::new);
+        constructors.put(SphereRegionSelector.class, SphereRegionSelector::new);
+        constructors.put(CylinderRegionSelector.class, CylinderRegionSelector::new);
+        constructors.put(ConvexPolyhedralRegionSelector.class, ConvexPolyhedralRegionSelector::new);
+        constructors.put(PolyhedralRegionSelector.class, PolyhedralRegionSelector::new);
+    }
+
     public void setVertices(Player player, Class<? extends RegionSelector> clazz, List<Location> vertices) {
         LocalSession localSession = WorldEdit.getInstance()
                 .getSessionManager()
                 .get(BukkitAdapter.adapt(player));
 
-        Reflection.Constructor constructorInvoker = Reflection.getConstructor(clazz, com.sk89q.worldedit.world.World.class);
+        Function<World, RegionSelector> constructor = constructors.get(clazz);
-        RegionSelector regionSelector = (RegionSelector) constructorInvoker.invoke(BukkitAdapter.adapt(player.getWorld()));
+        if (constructor == null) return;
+        RegionSelector regionSelector = constructor.apply(BukkitAdapter.adapt(player.getWorld()));
         localSession.setRegionSelector(BukkitAdapter.adapt(player.getWorld()), regionSelector);
 
         if (vertices.isEmpty()) return;
@@ -127,13 +150,9 @@ public class WorldEditUtils {
         try {
             BlockVector3 min = regionSelector.getRegion().getMinimumPoint();
             BlockVector3 max = regionSelector.getRegion().getMaximumPoint();
-            return new Pair<>(adapt(player.getWorld(), min), adapt(player.getWorld(), max));
+            return new Pair<>(BukkitAdapter.adapt(player.getWorld(), min), BukkitAdapter.adapt(player.getWorld(), max));
         } catch (IncompleteRegionException e) {
             return null;
         }
     }
-
-    private Location adapt(World world, BlockVector3 blockVector3) {
-        return new Location(world, blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ());
-    }
 }

BauSystem/BauSystem_Main/src/plugin.yml

@@ -4,7 +4,7 @@ version: "2.0"
 depend: [ WorldEdit, SpigotCore ]
 load: POSTWORLD
 main: de.steamwar.bausystem.BauSystem
-api-version: "1.13"
+api-version: "1.21"
 website: "https://steamwar.de"
 description: "So unseriös wie wir sind: BauSystem nur besser."
 

CLI/build.gradle.kts

@@ -18,6 +18,7 @@ dependencies {
     implementation("com.github.ajalt.clikt:clikt:5.0.3")
     implementation("com.github.ajalt.mordant:mordant:3.0.2")
     implementation(libs.logback)
+    implementation("org.yaml:snakeyaml:2.2")
     implementation("org.mariadb.jdbc:mariadb-java-client:3.3.1")
 
     implementation(libs.exposedCore)

CLI/src/Main.kt

@@ -11,23 +11,13 @@ import de.steamwar.commands.profiler.ProfilerCommand
 import de.steamwar.commands.user.UserCommand
 import de.steamwar.commands.user.UserInfoCommand
 import de.steamwar.commands.user.UserSearchCommand
-import de.steamwar.commands.world.MigrationCommand
-import de.steamwar.commands.world.SaveToStorageCommand
-import de.steamwar.commands.world.TemplateCommand
-import de.steamwar.commands.world.TemplateCreateCommand
-import de.steamwar.commands.world.WorldCommand
 
 fun main(args: Array<String>) =
     SteamWar()
         .subcommands(
             DatabaseCommand().subcommands(InfoCommand(), ResetCommand()),
             UserCommand().subcommands(UserInfoCommand(), UserSearchCommand()),
-            WorldCommand().subcommands(
-                MigrationCommand(),
-                SaveToStorageCommand(),
-                TemplateCommand().subcommands(TemplateCreateCommand())
-            ),
             DevCommand(),
             ProfilerCommand()
         )
-        .main(args)
+        .main(args)

CLI/src/commands/dev/DevCommand.kt

@@ -14,9 +14,11 @@ import com.github.ajalt.clikt.parameters.types.file
 import com.github.ajalt.clikt.parameters.types.long
 import com.github.ajalt.clikt.parameters.types.path
 import com.sun.security.auth.module.UnixSystem
+import org.yaml.snakeyaml.Yaml
 import java.io.File
 import kotlin.io.path.absolute
 import kotlin.io.path.absolutePathString
+import kotlin.random.Random
 
 const val LOG4J_CONFIG = """<?xml version="1.0" encoding="UTF-8"?>
 <Configuration status="WARN" packages="com.mojang.util">
@@ -69,32 +71,42 @@ class DevCommand : CliktCommand("dev") {
     override fun run() {
         val args = mutableListOf<String>()
 
-        val serverDirectory = File(workingDir, server)
+        var serverDir = resolveServerDirectory(server)
-        val serverDir =
-            if (serverDirectory.exists() && serverDirectory.isDirectory) serverDirectory else File(workingDir, server)
 
         if (isVelocity(server)) {
             runServer(
                 args, jvmArgs, listOf(
                     jar?.absolutePath
-                        ?: File("/jar/Velocity.jar").absolutePath
+                        ?: File("/jars/Velocity.jar").absolutePath
                 ), serverDir
             )
         } else {
             setLogConfig(args)
             val version = findVersion(server)
                 ?: throw CliktError("Unknown Server Version")
+            val gameModeTemplate = if (serverDir.isDirectory) null else loadGameModeTemplate(server)
+            if (gameModeTemplate != null) {
+                serverDir = gameModeTemplate.serverDir
+                args += "-Dconfig=$server.yml"
+            }
             val worldFile = world?.absolute()?.toFile()
-                ?: File(serverDir, "devtempworld")
+                ?: File(workingDir, "devtempworld")
-            val jarFile = jar?.absolutePath
+            var jarFile = jar?.absolutePath
                 ?: additionalVersions[server]?.let { supportedVersionJars[it] }
                 ?: supportedVersionJars[version]
                 ?: throw CliktError("Unknown Server Version")
+            if (gameModeTemplate != null) {
+                jarFile = if (gameModeTemplate.spigot) {
+                    jarFile.replace("paper", "spigot")
+                } else {
+                    jarFile.replace("spigot", "paper")
+                }
+            }
 
             if (!worldFile.exists()) {
-                val templateFile = File(serverDir, "Bauwelt")
+                val templateFile = gameModeTemplate?.worldTemplate ?: File(serverDir, "Bauwelt")
                 if (!templateFile.exists()) {
-                    throw CliktError("World Template not found!")
+                    throw CliktError("Could not find world template: ${templateFile.absolutePath}")
                 }
                 templateFile.copyRecursively(worldFile)
             }
@@ -123,6 +135,12 @@ class DevCommand : CliktCommand("dev") {
         }
     }
 
+    data class GameModeTemplate(
+        val serverDir: File,
+        val worldTemplate: File,
+        val spigot: Boolean
+    )
+
     val jvmDefaultParams = arrayOf(
         "-Xmx1G",
         "-Xgc:excessiveGCratio=80",
@@ -152,8 +170,7 @@ class DevCommand : CliktCommand("dev") {
     )
 
     val additionalVersions = mapOf(
-        "Tutorial" to 15,
+        "Lobby" to 21
-        "Lobby" to 20
     )
 
     fun findVersion(server: String): Int? =
@@ -166,6 +183,41 @@ class DevCommand : CliktCommand("dev") {
     fun isVelocity(server: String): Boolean =
         server.endsWith("Velocity")
 
+    fun resolveServerDirectory(server: String): File {
+        val localServer = File(workingDir, server)
+        if (localServer.isDirectory) {
+            return localServer
+        }
+        return File("/servers", server)
+    }
+
+    fun loadGameModeTemplate(server: String): GameModeTemplate? {
+        val configFile = File("/configs/GameModes/$server.yml")
+        if (!configFile.exists()) {
+            throw CliktError("Server/GameMode not found")
+        }
+
+        val document = configFile.reader().use { reader ->
+            Yaml().load<Map<String, Any?>>(reader)
+        } ?: throw CliktError("GameMode config is empty: ${configFile.absolutePath}")
+        val serverConfig = document["Server"] as? Map<*, *>
+            ?: throw CliktError("GameMode config is missing Server section: ${configFile.absolutePath}")
+        val folder = serverConfig["Folder"] as? String
+            ?: throw CliktError("GameMode config is missing Server.Folder: ${configFile.absolutePath}")
+        val maps = (serverConfig["Maps"] as? List<*>)
+            ?.filterIsInstance<String>()
+            ?.takeIf { it.isNotEmpty() }
+            ?: throw CliktError("GameMode config is missing Server.Maps: ${configFile.absolutePath}")
+
+        val serverDir = File("/servers", folder)
+        val worldTemplate = File(File(serverDir, "arenas"), maps[Random.nextInt(maps.size)])
+        return GameModeTemplate(
+            serverDir = serverDir,
+            worldTemplate = worldTemplate,
+            spigot = serverConfig["Spigot"] == true
+        )
+    }
+
     fun setLogConfig(args: MutableList<String>) {
         args += "-DlogPath=${workingDir.absolutePath}/logs"
         args += "-Dlog4j.configurationFile=${log4jConfig.absolutePath}"
@@ -191,4 +243,4 @@ class DevCommand : CliktCommand("dev") {
         Runtime.getRuntime().addShutdownHook(Thread { if (process.isAlive) process.destroyForcibly() })
         process.waitFor()
     }
-}
+}

CLI/src/commands/world/MigrationCommand.kt

@@ -1,243 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-import de.steamwar.db.Database
-import de.steamwar.sql.SteamwarUser
-import de.steamwar.sql.SteamwarWorld
-import de.steamwar.sql.UserConfig
-import org.jetbrains.exposed.v1.jdbc.transactions.transaction
-import java.io.File
-import java.sql.SQLException
-import java.util.UUID
-
-class MigrationCommand : CliktCommand(name = "migrate") {
-    private val userWorldPattern = Regex("""userworlds(\d+)""")
-    private val builderWorldPattern = Regex("""builder(\d+)""")
-    private val trailingVersionPattern = Regex("""(\d+)$""")
-
-    override fun run() {
-        Database.ensureConnected()
-
-        val bau = migrateBauWorlds()
-        val builder = migrateBuilderWorlds()
-        val arena = migrateArenaWorlds()
-        migrateBauLockConfig()
-        migrateBauweltMembers()
-
-        echo("Imported ${bau.imported} build worlds, skipped ${bau.skipped}, missing users ${bau.missingOwner}.")
-        echo("Imported ${builder.imported} builder worlds, skipped ${builder.skipped}.")
-        echo("Imported ${arena.imported} arena worlds, skipped ${arena.skipped}.")
-        echo("World migration completed.")
-    }
-
-    private fun migrateBauWorlds(): MigrationStats {
-        val stats = MigrationStats()
-        val worldsRoot = File("/worlds")
-        worldsRoot.listFiles { file -> file.isDirectory && userWorldPattern.matches(file.name) }
-            ?.forEach { versionFolder ->
-                val version = userWorldPattern.matchEntire(versionFolder.name)!!.groupValues[1].toInt()
-                versionFolder.listFiles { file -> file.isDirectory && isWorldDirectory(file) }
-                    ?.sortedBy { it.name }
-                    ?.forEach { legacyWorld ->
-                        val owner = legacyWorld.ownerUser()
-                        if (owner == null) {
-                            stats.missingOwner++
-                            echo("Skipped build world ${legacyWorld.path}: no matching user.")
-                            return@forEach
-                        }
-
-                        val lockState = UserConfig.getConfig(owner.id.value, BAU_LOCK_CONFIG_NAME)
-                        val world = SteamwarWorld.getOrCreateBauWorld(owner, owner.userName, version, legacyWorld)
-                        if (world.lockState == null && lockState != null) {
-                            world.changeLockState(lockState)
-                        }
-                        stats.imported++
-                    }
-            } ?: run {
-            stats.skipped++
-            echo("Skipped build worlds: /worlds does not exist.")
-        }
-        return stats
-    }
-
-    private fun migrateBuilderWorlds(): MigrationStats {
-        val stats = MigrationStats()
-        val worldsRoot = File("/worlds")
-        worldsRoot.listFiles { file -> file.isDirectory && builderWorldPattern.matches(file.name) }
-            ?.forEach { versionFolder ->
-                val version = builderWorldPattern.matchEntire(versionFolder.name)!!.groupValues[1].toInt()
-                versionFolder.listFiles { file -> file.isDirectory && isWorldDirectory(file) }
-                    ?.sortedBy { it.name }
-                    ?.forEach { legacyWorld ->
-                        SteamwarWorld.getOrCreateBuilderWorld(legacyWorld.name, version, legacyWorld)
-                        stats.imported++
-                    }
-            } ?: run {
-            stats.skipped++
-            echo("Skipped builder worlds: /worlds does not exist.")
-        }
-        return stats
-    }
-
-    private fun migrateArenaWorlds(): MigrationStats {
-        val stats = MigrationStats()
-        val configs = parseGameModeConfigs(File("/configs/GameModes"))
-        if (configs.isEmpty()) {
-            stats.skipped++
-            echo("Skipped arena worlds: no game mode configs found in /configs/GameModes.")
-            return stats
-        }
-
-        for (config in configs) {
-            val version = trailingVersionPattern.find(config.serverFolder)?.value?.toIntOrNull()
-            if (version == null) {
-                stats.skipped++
-                echo("Skipped arena mode ${config.modeName}: server folder '${config.serverFolder}' has no version suffix.")
-                continue
-            }
-
-            val arenaRoot = File("/servers/${config.serverFolder}/arenas")
-            for (map in config.maps) {
-                val legacyWorld = File(arenaRoot, map)
-                if (!isWorldDirectory(legacyWorld)) {
-                    stats.skipped++
-                    continue
-                }
-
-                SteamwarWorld.getOrCreateArenaWorld(config.modeName, map, version, legacyWorld)
-                stats.imported++
-            }
-        }
-
-        return stats
-    }
-
-    private fun migrateBauLockConfig() {
-        transaction(Database.db) {
-            exec(
-                """
-                UPDATE `world` w
-                JOIN `UserConfig` uc ON uc.`User` = w.`Owner` AND uc.`Config` = 'baulockstate'
-                SET w.`LockState` = uc.`Value`
-                WHERE w.`Owner` IS NOT NULL AND w.`LockState` IS NULL
-                """.trimIndent()
-            )
-        }
-    }
-
-    private fun migrateBauweltMembers() {
-        if (!columnExists("BauweltMember", "WorldID") || !columnExists("BauweltMember", "BauweltID")) {
-            echo("Skipped BauweltMember data migration: expected WorldID and BauweltID columns are not both present.")
-            return
-        }
-
-        execIgnore(
-            """
-            INSERT IGNORE INTO `BauweltMember` (`WorldID`, `MemberID`, `Build`, `WorldEdit`, `World`)
-            SELECT w.`id`, bm.`MemberID`, bm.`Build`, bm.`WorldEdit`, bm.`World`
-            FROM `BauweltMember` bm
-            JOIN `world` w ON w.`Owner` = bm.`BauweltID` AND w.`Deleted` = 0
-            """.trimIndent(),
-            "Skipped BauweltMember data migration"
-        )
-    }
-
-    private fun parseGameModeConfigs(configRoot: File): List<ArenaMigrationConfig> {
-        if (!configRoot.isDirectory) return emptyList()
-
-        return configRoot.listFiles { file -> file.isFile && file.extension == "yml" && !file.name.endsWith(".kits.yml") }
-            ?.mapNotNull { file ->
-                val server = parseServerBlock(file)
-                val folder = server.folder ?: return@mapNotNull null
-                ArenaMigrationConfig(file.nameWithoutExtension, folder, server.maps)
-            }
-            ?: emptyList()
-    }
-
-    private fun parseServerBlock(file: File): ParsedServerBlock {
-        var inServer = false
-        var inMaps = false
-        var folder: String? = null
-        val maps = mutableListOf<String>()
-
-        file.readLines().forEach { line ->
-            val trimmed = line.trim()
-            if (trimmed.isEmpty() || trimmed.startsWith("#")) return@forEach
-
-            val indent = line.indexOfFirst { !it.isWhitespace() }.let { if (it == -1) 0 else it }
-            if (indent == 0) {
-                inServer = trimmed == "Server:"
-                inMaps = false
-                return@forEach
-            }
-
-            if (!inServer) return@forEach
-
-            when {
-                indent <= 2 && trimmed.startsWith("Folder:") -> folder = trimmed.substringAfter(":").cleanYamlValue()
-                indent <= 2 && trimmed.startsWith("Maps:") -> {
-                    val value = trimmed.substringAfter(":").trim()
-                    inMaps = true
-                    if (value.startsWith("[") && value.endsWith("]")) {
-                        maps += value.removePrefix("[").removeSuffix("]")
-                            .split(",")
-                            .map { it.cleanYamlValue() }
-                            .filter { it.isNotEmpty() }
-                        inMaps = false
-                    }
-                }
-                inMaps && trimmed.startsWith("-") -> maps += trimmed.removePrefix("-").cleanYamlValue()
-                inMaps && indent <= 2 -> inMaps = false
-            }
-        }
-
-        return ParsedServerBlock(folder, maps)
-    }
-
-    private fun File.ownerUser(): SteamwarUser? {
-        name.toIntOrNull()?.let { return SteamwarUser.byId(it) }
-        return runCatching { SteamwarUser.get(UUID.fromString(name)) }.getOrNull()
-    }
-
-    private fun isWorldDirectory(file: File): Boolean =
-        file.isDirectory && (File(file, "level.dat").isFile || File(file, "region").isDirectory)
-
-    private fun String.cleanYamlValue(): String =
-        trim().trim('"').trim('\'')
-
-    private fun columnExists(table: String, column: String): Boolean =
-        transaction(Database.db) {
-            exec("SHOW COLUMNS FROM `$table` LIKE '$column'") { result -> result.next() } ?: false
-        }
-
-    private fun execIgnore(sql: String, prefix: String) {
-        try {
-            transaction(Database.db) {
-                exec(sql)
-            }
-        } catch (e: SQLException) {
-            echo("$prefix: ${e.message}")
-        }
-    }
-
-    private data class MigrationStats(
-        var imported: Int = 0,
-        var skipped: Int = 0,
-        var missingOwner: Int = 0,
-    )
-
-    private data class ArenaMigrationConfig(
-        val modeName: String,
-        val serverFolder: String,
-        val maps: List<String>,
-    )
-
-    private data class ParsedServerBlock(
-        val folder: String?,
-        val maps: List<String>,
-    )
-
-    private companion object {
-        private const val BAU_LOCK_CONFIG_NAME = "baulockstate"
-    }
-}

CLI/src/commands/world/SaveToStorageCommand.kt

@@ -1,30 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-import de.steamwar.db.Database
-import de.steamwar.sql.SteamwarWorld
-import java.time.LocalTime
-
-class SaveToStorageCommand : CliktCommand(name = "saveToStorage") {
-    override fun run() {
-        Database.ensureConnected()
-
-        var archived = 0
-        for (world in SteamwarWorld.getWorldsToArchive()) {
-            if (!beforeCutoff()) {
-                echo("Stopping before 04:00. Archived $archived worlds.")
-                return
-            }
-
-            if (world.archiveIfNeeded()) {
-                archived++
-                echo("Archived ${world.uuid} (${world.type}/${world.name}).")
-            }
-        }
-
-        echo("Storage save completed. Archived $archived worlds.")
-    }
-
-    private fun beforeCutoff(): Boolean =
-        LocalTime.now().isBefore(LocalTime.of(4, 0))
-}

CLI/src/commands/world/TemplateCommand.kt

@@ -1,24 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-import com.github.ajalt.clikt.parameters.arguments.argument
-import com.github.ajalt.clikt.parameters.types.int
-import com.github.ajalt.clikt.parameters.types.path
-import de.steamwar.db.Database
-import de.steamwar.sql.SteamwarWorld
-
-class TemplateCommand : CliktCommand(name = "template") {
-    override fun run() = Unit
-}
-
-class TemplateCreateCommand : CliktCommand(name = "create") {
-    private val name by argument()
-    private val version by argument().int()
-    private val source by argument().path(canBeFile = false, mustExist = true)
-
-    override fun run() {
-        Database.ensureConnected()
-        SteamwarWorld.getOrCreateTemplateWorld(name, version, source.toFile())
-        echo("Template world '$name' created.")
-    }
-}

CLI/src/commands/world/WorldCommand.kt

@@ -1,7 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-
-class WorldCommand : CliktCommand(name = "world") {
-    override fun run() = Unit
-}

CommonCore/SQL/src/de/steamwar/sql/BauweltMember.kt

@@ -19,6 +19,7 @@
 
 package de.steamwar.sql
 
+import de.steamwar.sql.BauweltMemberTable.bauweltId
 import de.steamwar.sql.internal.useDb
 import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.dao.id.CompositeID
@@ -31,37 +32,45 @@ import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.util.*
 
 object BauweltMemberTable : CompositeIdTable("BauweltMember") {
-    val worldId = reference("WorldID", WorldTable).index()
+    val bauweltId = reference("BauweltID", SteamwarUserTable).index()
     val memberId = reference("MemberID", SteamwarUserTable).index()
     val build = bool("Build")
     val worldEdit = bool("WorldEdit")
     val world = bool("World")
 
-    override val primaryKey = PrimaryKey(worldId, memberId)
+    override val primaryKey = PrimaryKey(bauweltId, memberId)
 
     init {
-        addIdColumn(worldId)
+        addIdColumn(bauweltId)
         addIdColumn(memberId)
     }
 }
 
 class BauweltMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
     companion object : CompositeEntityClass<BauweltMember>(BauweltMemberTable) {
-        private val cache = mutableMapOf<Pair<UUID, Int>, BauweltMember>()
+        private val cache = mutableMapOf<Int, BauweltMember>()
 
         private fun cache(member: BauweltMember) =
-            cache.put(member.worldID to member.memberID, member)
+            cache.put(member.memberID, member)
 
         @JvmStatic
         fun clear() =
             cache.clear()
 
         @JvmStatic
-        fun addMember(worldId: UUID, newMemberId: Int) =
+        @Deprecated("Use addMember(ownerId: Int, newMemberId: Int)")
+        fun addMember(ownerId: UUID, newMemberId: UUID) =
+            addMember(SteamwarUser.get(ownerId)!!.id, SteamwarUser.get(newMemberId)!!.id)
+
+        @JvmStatic
+        fun addMember(ownerId: Int, newMemberId: Int) =
+            addMember(EntityID(ownerId, SteamwarUserTable), EntityID(newMemberId, SteamwarUserTable))
+
+        fun addMember(ownerId: EntityID<Int>, newMemberId: EntityID<Int>) =
             useDb {
                 BauweltMemberTable.insertIgnore {
-                    it[BauweltMemberTable.worldId] = EntityID(worldId, WorldTable)
+                    it[bauweltId] = ownerId
-                    it[memberId] = EntityID(newMemberId, SteamwarUserTable)
+                    it[memberId] = newMemberId
                     it[build] = false
                     it[worldEdit] = false
                     it[world] = false
@@ -69,32 +78,31 @@ class BauweltMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
             }
 
         @JvmStatic
-        fun addMember(worldId: UUID, newMemberId: UUID) =
+        @Deprecated("Use getBauMember(bauwelt: Int, member: Int)")
-            addMember(worldId, SteamwarUser.get(newMemberId)!!.id.value)
+        fun getBauMember(bauwelt: UUID, member: UUID) =
-
-        @JvmStatic
-        fun getBauMember(world: UUID, member: Int) =
-            cache[world to member]
-                ?: useDb {
-                    find { (BauweltMemberTable.worldId eq world) and (BauweltMemberTable.memberId eq member) }.firstOrNull()?.also { cache(it) }
-                }
-
-        @JvmStatic
-        fun getBauMember(world: UUID, member: UUID) =
-            getBauMember(world, SteamwarUser.get(member)!!.id.value)
-
-        @JvmStatic
-        fun getWorldMembers(world: UUID) =
             useDb {
-                find { BauweltMemberTable.worldId eq world }.toList().also { it.forEach { cache(it) } }
+                find { (bauweltId eq SteamwarUser.get(bauwelt)!!.id) and (BauweltMemberTable.memberId eq SteamwarUser.get(member)!!.id) }.firstOrNull()?.also { cache(it) }
             }
 
         @JvmStatic
-        fun getMembers(world: UUID) =
+        fun getBauMember(bauwelt: Int, member: Int) =
-            getWorldMembers(world)
+            useDb {
+                find { (bauweltId eq bauwelt) and (BauweltMemberTable.memberId eq member) }.firstOrNull()?.also { cache(it) }
+            }
+
+        @JvmStatic
+        @Deprecated("Use getMembers(bauwelt: Int)")
+        fun getMembers(bauwelt: UUID) =
+            getMembers(SteamwarUser.get(bauwelt)!!.id.value)
+
+        @JvmStatic
+        fun getMembers(bauwelt: Int) =
+            useDb {
+                find { bauweltId eq bauwelt }.toList().also { it.forEach { cache(it) } }
+            }
     }
 
-    val worldID by BauweltMemberTable.worldId.transform({ EntityID(it, WorldTable) }, { it.value })
+    val bauweltID by BauweltMemberTable.bauweltId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
     val memberID by BauweltMemberTable.memberId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
     private var worldEditInternal by BauweltMemberTable.worldEdit
     var worldEdit: Boolean
@@ -136,4 +144,4 @@ class BauweltMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
         useDb {
             delete()
         }
-}
+}

CommonCore/SQL/src/de/steamwar/sql/CheckedSchematic.kt

@@ -86,6 +86,24 @@ class CheckedSchematic(id: EntityID<CompositeID>) : CompositeEntity(id) {
             useDb {
                 find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.seen eq false) }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
             }
+
+        @JvmStatic
+        fun countAccepted(owner: SteamwarUser) =
+            useDb {
+                find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.declineReason eq "freigegeben") }.count()
+            }
+
+        @JvmStatic
+        fun countAccepted(owner: SteamwarUser, type: String) =
+            useDb {
+                find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.declineReason eq "freigegeben") and (CheckedSchematicTable.nodeType like "$type%") }.count()
+            }
+
+        @JvmStatic
+        fun countChecked(validator: SteamwarUser) =
+            useDb {
+                find { CheckedSchematicTable.validator eq validator.id }.count()
+            }
     }
 
     val node by CheckedSchematicTable.nodeId.transform({ it?.let { EntityID(it, SchematicNodeTable) } }, { it?.value })

CommonCore/SQL/src/de/steamwar/sql/EventFight.kt

@@ -130,6 +130,43 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
                     }
                 )
             }
+
+        @JvmStatic
+        fun countEventFights(fighter: SteamwarUser) =
+            useDb {
+                exec(
+                    "SELECT COUNT(DISTINCT F.FightID) AS FightCount FROM FightPlayer INNER JOIN Fight F on FightPlayer.FightID = F.FightID INNER JOIN EventFight EF on F.FightID = EF.Fight WHERE UserID = ?",
+                    args = listOf(IntegerColumnType() to fighter.id.value)
+                ) {
+                    if (it.next()) {
+                        it.getLong("FightCount")
+                    } else {
+                        0
+                    }
+                }
+                    ?: 0
+            }
+
+        @JvmStatic
+        fun countPlacement(fighter: SteamwarUser, placement: Int) =
+            useDb {
+                exec(
+                    """
+                        SELECT COUNT(DISTINCT EventFight.EventID) AS PlacementCount FROM TeamTeilnahme
+                            INNER JOIN EventFight ON EventFight.EventID = TeamTeilnahme.EventID
+                            INNER JOIN FightPlayer ON FightPlayer.FightID = EventFight.Fight
+                        WHERE (IF(FightPlayer.Team = 1, EventFight.TeamBlue, EventFight.TeamRed)) = TeamTeilnahme.TeamID AND UserID = ? AND Placement = ?
+                    """.trimIndent(),
+                    args = listOf(IntegerColumnType() to fighter.id.value, IntegerColumnType() to placement)
+                ) {
+                    if (it.next()) {
+                        it.getInt("PlacementCount")
+                    } else {
+                        0
+                    }
+                }
+                    ?: 0
+            }
     }
 
     val fightID by EventFightTable.id.transform({ EntityID(it, EventFightTable) }, { it.value })

CommonCore/SQL/src/de/steamwar/sql/FightPlayer.kt

@@ -20,9 +20,12 @@
 package de.steamwar.sql
 
 import de.steamwar.sql.internal.useDb
+import org.jetbrains.exposed.v1.core.IntegerColumnType
+import org.jetbrains.exposed.v1.core.VarCharColumnType
 import org.jetbrains.exposed.v1.core.dao.id.CompositeID
 import org.jetbrains.exposed.v1.core.dao.id.CompositeIdTable
 import org.jetbrains.exposed.v1.core.dao.id.EntityID
+import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.core.inList
 import org.jetbrains.exposed.v1.dao.CompositeEntity
 import org.jetbrains.exposed.v1.dao.CompositeEntityClass
@@ -69,6 +72,28 @@ class FightPlayer(id: EntityID<CompositeID>) : CompositeEntity(id) {
             useDb {
                 find { FightPlayerTable.fightId inList fightIds.toList() }.toList()
             }
+
+        @JvmStatic
+        fun countFights(userId: Int) =
+            useDb {
+                find { FightPlayerTable.userId eq userId }.count()
+            }
+
+        @JvmStatic
+        fun countFights(userId: Int, type: String) =
+            useDb {
+                exec(
+                    "SELECT COUNT(*) AS FightCount FROM FightPlayer INNER JOIN Fight F on FightPlayer.FightID = F.FightID WHERE UserID = ? AND GameMode LIKE ?",
+                    args = listOf(IntegerColumnType() to userId, VarCharColumnType() to "$type%")
+                ) {
+                    if (it.next()) {
+                        it.getInt("FightCount")
+                    } else {
+                        0
+                    }
+                }
+                    ?: 0
+            }
     }
 
     val fightID by FightPlayerTable.fightId.transform({ EntityID(it, FightTable) }, { it.value })

CommonCore/SQL/src/de/steamwar/sql/GameModeConfig.java

@@ -146,12 +146,12 @@ public final class GameModeConfig<M, W> {
     public final List<String> CheckQuestions;
 
     /**
-     * The allowed checkers to check this schematic type denoted by a list of SteamWar ids.
+     * The allowed checkers to check this schematic type denoted by a list of SteamwarUser ids.
      * The people need the {@link UserPerm#CHECK} to be able to check though.
      *
      * @implSpec {@code []} by default -> denoting every person with {@link UserPerm#CHECK} can check it
      */
-    public final List<Integer> Checkers;
+    public final Set<Integer> Checkers;
 
     /**
      * Bundle for countdowns during the fight
@@ -246,7 +246,7 @@ public final class GameModeConfig<M, W> {
         }
 
         CheckQuestions = loader.getStringList("CheckQuestions");
-        Checkers = loader.getIntList("Checkers");
+        Checkers = loader.getIntSet("Checkers");
         Times = new TimesConfig(loader.with("Times"));
         // Arena would be here to be in config order but needs Schematic.Size and EnterStages loaded afterwards
         Schematic = new SchematicConfig<>(loader.with("Schematic"));

CommonCore/SQL/src/de/steamwar/sql/UserPerm.kt

@@ -50,8 +50,6 @@ enum class UserPerm {
     PUNISHMENTS,
     TICKET_LOG,
     BUILD,
-    BUILD_EXTRA_WORLDS,
-    BUILD_UNLIMITED_WORLDS,
     CHECK,
     MODERATION,
     ADMINISTRATION;
@@ -97,4 +95,4 @@ enum class UserPerm {
     }
 
     data class Prefix(val colorCode: String, val chatPrefix: String, val teamPrefix: Boolean = false)
-}
+}

CommonCore/SQL/src/de/steamwar/sql/World.kt

@@ -1,345 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.sql
-
-import de.steamwar.sql.internal.useDb
-import org.jetbrains.exposed.v1.core.and
-import org.jetbrains.exposed.v1.core.dao.id.EntityID
-import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
-import org.jetbrains.exposed.v1.core.eq
-import org.jetbrains.exposed.v1.core.not
-import org.jetbrains.exposed.v1.core.or
-import org.jetbrains.exposed.v1.core.SortOrder
-import org.jetbrains.exposed.v1.dao.Entity
-import org.jetbrains.exposed.v1.dao.EntityClass
-import org.jetbrains.exposed.v1.javatime.CurrentTimestamp
-import org.jetbrains.exposed.v1.javatime.timestamp
-import java.io.File
-import java.time.Instant
-import java.time.temporal.ChronoUnit
-import java.util.UUID
-
-object WorldTable : UUIDTable("world") {
-    val name = varchar("Name", 512)
-    val version = integer("Version")
-    val type = enumeration<WorldType>("Type")
-    val owner = reference("Owner", SteamwarUserTable).nullable()
-    val team = reference("Team", TeamTable).nullable()
-    val lockState = varchar("LockState", 32).nullable()
-    val deleted = bool("Deleted").default(false)
-    val created = timestamp("Created").defaultExpression(CurrentTimestamp)
-    val lastUsed = timestamp("LastUsed").defaultExpression(CurrentTimestamp)
-}
-
-enum class WorldType {
-    BAU,
-    BUILDER,
-    TEAM,
-    ARENA,
-    TEMPLATE,
-}
-
-class SteamwarWorld(id: EntityID<UUID>) : Entity<UUID>(id) {
-    var name by WorldTable.name
-        private set
-    var version by WorldTable.version
-        private set
-    var type by WorldTable.type
-        private set
-    var owner by WorldTable.owner
-        private set
-    var team by WorldTable.team
-        private set
-    var lockState by WorldTable.lockState
-        private set
-    var deleted by WorldTable.deleted
-        private set
-    val created by WorldTable.created
-    var lastUsed by WorldTable.lastUsed
-        private set
-
-    val archived: Boolean
-        get() = !storageDirectory.exists() && archiveFile.exists()
-
-    val shouldArchive: Boolean
-        get() = !archived && (deleted || lastUsed.plus(7, ChronoUnit.DAYS).isBefore(Instant.now()))
-
-    val uuid: UUID
-        get() = id.value
-
-    val storageDirectory: File
-        get() = File(WORLD_STORAGE, id.value.toString())
-
-    private val archiveFile: File
-        get() = File(ARCHIVE_WORLD_STORAGE, "${id.value}.zip")
-
-    @JvmOverloads
-    fun setupAndGetStoragePath(prototype: File? = null): String {
-        if (archived) {
-            loadFromArchive()
-        }
-
-        val needsInitialization = !storageDirectory.exists() || storageDirectory.list()?.isEmpty() == true
-        if (needsInitialization) {
-            if (prototype != null && prototype.exists()) {
-                prototype.copyRecursively(storageDirectory, overwrite = true)
-            } else {
-                storageDirectory.mkdirs()
-            }
-        }
-
-        useDb {
-            lastUsed = Instant.now()
-        }
-
-        return storageDirectory.path
-    }
-
-    fun markDeleted() = useDb {
-        deleted = true
-    }
-
-    fun rename(newName: String) = useDb {
-        name = newName
-    }
-
-    fun archiveIfNeeded(): Boolean {
-        if (!shouldArchive) return false
-
-        File(ARCHIVE_WORLD_STORAGE).mkdirs()
-        return archiveWorld() == 0
-    }
-
-    fun changeVersion(newVersion: Int) = useDb {
-        version = newVersion
-    }
-
-    fun changeLockState(newLockState: String?) = useDb {
-        lockState = newLockState
-    }
-
-    private fun archiveWorld() = ProcessBuilder("zip", "-u9oymrqq", "$ARCHIVE_WORLD_STORAGE/${id.value}.zip", id.value.toString())
-        .directory(File(WORLD_STORAGE))
-        .inheritIO()
-        .start()
-        .waitFor()
-
-
-    private fun loadFromArchive() = ProcessBuilder("unzip", "-qq", "-o", "$ARCHIVE_WORLD_STORAGE/${id.value}.zip", "-d", WORLD_STORAGE)
-        .inheritIO()
-        .start()
-        .waitFor()
-
-    companion object : EntityClass<UUID, SteamwarWorld>(WorldTable) {
-        const val WORLD_STORAGE = "/worlds/storage"
-        const val ARCHIVE_WORLD_STORAGE = "/mnt/storage/worlds/storage"
-        const val DEFAULT_BAU_WORLD_LIMIT = 3
-        const val EXTRA_BAU_WORLD_LIMIT = 10
-        const val TEAM_WORLD_LIMIT = 2
-
-        @JvmStatic
-        fun getWorld(uuid: UUID) = useDb {
-            findById(uuid)
-        }
-
-        @JvmStatic
-        fun getBauWorld(user: SteamwarUser, version: Int) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getBauWorld(user: SteamwarUser, name: String, version: Int) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getBauWorlds(user: SteamwarUser) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.created to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        fun countBauWorlds(user: SteamwarUser) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.count()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateBauWorld(user: SteamwarUser, version: Int, prototype: File? = null): SteamwarWorld =
-            getBauWorld(user, version) ?: createWorld(user, user.userName, version, WorldType.BAU, prototype)
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateBauWorld(user: SteamwarUser, name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getBauWorld(user, name, version) ?: createWorld(user, name, version, WorldType.BAU, prototype)
-
-        @JvmStatic
-        fun getBuilderWorld(name: String, version: Int) = useDb {
-            find {
-                (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BUILDER) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getBuilderWorlds(version: Int) = useDb {
-            find {
-                (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BUILDER) and
-                        not(WorldTable.deleted)
-            }.toList()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateBuilderWorld(name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getBuilderWorld(name, version) ?: createWorld(null, name, version, WorldType.BUILDER, prototype)
-
-        @JvmStatic
-        fun getTeamWorld(team: Team, name: String, version: Int) = useDb {
-            find {
-                (WorldTable.team eq team.id) and
-                        (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.TEAM) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getTeamWorlds(team: Team) = useDb {
-            find {
-                (WorldTable.team eq team.id) and
-                        (WorldTable.type eq WorldType.TEAM) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.created to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateTeamWorld(team: Team, name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getTeamWorld(team, name, version) ?: createWorld(null, name, version, WorldType.TEAM, prototype, team)
-
-        @JvmStatic
-        fun countTeamWorlds(team: Team) = useDb {
-            find {
-                (WorldTable.team eq team.id) and
-                        (WorldTable.type eq WorldType.TEAM) and
-                        not(WorldTable.deleted)
-            }.count()
-        }
-
-        @JvmStatic
-        fun getArenaWorld(mode: String, map: String, version: Int) = useDb {
-            find {
-                (WorldTable.name eq arenaWorldName(mode, map)) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.ARENA) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateArenaWorld(mode: String, map: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getArenaWorld(mode, map, version) ?: createWorld(null, arenaWorldName(mode, map), version, WorldType.ARENA, prototype)
-
-        @JvmStatic
-        fun getTemplateWorld(name: String, version: Int) = useDb {
-            find {
-                (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.TEMPLATE) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getTemplateWorlds() = useDb {
-            find {
-                (WorldTable.type eq WorldType.TEMPLATE) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.name to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        fun getTemplateWorlds(version: Int) = useDb {
-            find {
-                (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.TEMPLATE) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.name to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateTemplateWorld(name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getTemplateWorld(name, version) ?: createWorld(null, name, version, WorldType.TEMPLATE, prototype)
-
-        @JvmStatic
-        fun getAllActiveWorlds() = useDb {
-            find { not(WorldTable.deleted) }.toList()
-        }
-
-        @JvmStatic
-        fun getWorldsToArchive() = useDb {
-            find {
-                not(WorldTable.deleted) or (WorldTable.deleted eq true)
-            }.toList().filter { it.shouldArchive }
-        }
-
-        private fun arenaWorldName(mode: String, map: String) = "$mode/$map"
-
-        @JvmStatic
-        @JvmOverloads
-        fun createWorld(user: SteamwarUser?, name: String, version: Int, type: WorldType, prototype: File? = null, team: Team? = null): SteamwarWorld {
-            val world = useDb { new {
-                this.name = name
-                this.version = version
-                this.type = type
-                this.owner = user?.id
-                this.team = team?.id
-            } }
-
-            world.setupAndGetStoragePath(prototype)
-            return world
-        }
-    }
-}

CommonCore/SQL/src/de/steamwar/sql/YMLWrapper.java

@@ -139,6 +139,12 @@ final class YMLWrapper<M, W> {
         return get(path, o -> (List<Integer>) o);
     }
 
+    public Set<Integer> getIntSet(String path) {
+        List<Integer> list = get(path, o -> (List<Integer>) o);
+        if (list.isEmpty()) return Collections.emptySet();
+        return Collections.unmodifiableSet(new HashSet<>(list));
+    }
+
     public List<SchematicType> getSchematicTypeList(String path) {
         List<String> list = getStringList(path);
         if (list.isEmpty()) {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/FightSystem.java

@@ -32,7 +32,10 @@ import de.steamwar.fightsystem.record.GlobalRecorder;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.OneShotStateDependent;
 import de.steamwar.fightsystem.states.StateDependentListener;
-import de.steamwar.fightsystem.utils.*;
+import de.steamwar.fightsystem.utils.FightUI;
+import de.steamwar.fightsystem.utils.HullHider;
+import de.steamwar.fightsystem.utils.SWSound;
+import de.steamwar.fightsystem.utils.TechHiderWrapper;
 import de.steamwar.linkage.AbstractLinker;
 import de.steamwar.linkage.SpigotLinker;
 import de.steamwar.message.Message;

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EnternCountdown.java

@@ -27,12 +27,9 @@ import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.utils.Message;
 import de.steamwar.fightsystem.utils.Region;
 import de.steamwar.fightsystem.utils.SWSound;
-import de.steamwar.techhider.ProtocolUtils;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;
 
-import java.util.List;
-
 public class EnternCountdown extends Countdown {
 
     private static int calcTime(FightPlayer fp, Countdown countdown) {
@@ -47,7 +44,6 @@ public class EnternCountdown extends Countdown {
     }
 
     private final FightPlayer fightPlayer;
-    private List<ProtocolUtils.ChunkPos> chunkPos;
 
     public EnternCountdown(FightPlayer fp, Countdown countdown) {
         super(calcTime(fp, countdown), new Message("ENTERN_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false);

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/Fight.java

@@ -24,6 +24,7 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.record.GlobalRecorder;
 import lombok.Getter;
 import org.bukkit.Bukkit;
+import org.bukkit.Registry;
 import org.bukkit.Sound;
 import org.bukkit.entity.LivingEntity;
 
@@ -88,7 +89,7 @@ public class Fight {
     }
 
     public static void playSound(Sound sound, float volume, float pitch) {
-        GlobalRecorder.getInstance().soundAtPlayer(sound.name(), volume, pitch);
+        GlobalRecorder.getInstance().soundAtPlayer(Registry.SOUNDS.getKey(sound).getKey(), volume, pitch);
         //volume: max. 100, pitch: max. 2
         Bukkit.getServer().getOnlinePlayers().forEach(player -> player.playSound(player, sound, volume, pitch));
     }

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightTeam.java

@@ -35,7 +35,9 @@ import de.steamwar.fightsystem.listener.TeamArea;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.OneShotStateDependent;
 import de.steamwar.fightsystem.states.StateDependent;
-import de.steamwar.fightsystem.utils.*;
+import de.steamwar.fightsystem.utils.FightUI;
+import de.steamwar.fightsystem.utils.ItemBuilder;
+import de.steamwar.fightsystem.utils.Region;
 import de.steamwar.fightsystem.winconditions.Wincondition;
 import de.steamwar.fightsystem.winconditions.Winconditions;
 import de.steamwar.inventory.SWItem;

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/EntityDamage.java

@@ -24,6 +24,7 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.linkage.Linked;
+import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
@@ -38,11 +39,13 @@ public class EntityDamage implements Listener {
 
     @EventHandler
     public void handleEntityDamage(EntityDamageEvent event) {
+        if (!(event.getEntity() instanceof Player)) return;
         if (Config.ArenaRegion.in2dRegion(event.getEntity().getLocation())) event.setCancelled(true);
     }
 
     @EventHandler
     public void handleEntityDamageByEntity(EntityDamageByEntityEvent event) {
+        if (!(event.getEntity() instanceof Player)) return;
         if (Config.ArenaRegion.in2dRegion(event.getEntity().getLocation())) event.setCancelled(true);
     }
 }

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/InFightInventory.java

@@ -25,7 +25,6 @@ import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Material;
-import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.inventory.InventoryClickEvent;

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Recording.java

@@ -20,7 +20,6 @@
 package de.steamwar.fightsystem.listener;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
@@ -37,7 +36,6 @@ import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.fightsystem.utils.SWSound;
 import de.steamwar.linkage.Linked;
-import net.minecraft.network.protocol.Packet;
 import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket;
 import net.minecraft.network.protocol.game.ServerboundUseItemPacket;
 import net.minecraft.world.InteractionHand;
@@ -115,18 +113,18 @@ public class Recording implements Listener {
         }.register();
         new StateDependent(ArenaMode.AntiReplay, FightState.Ingame) {
             private final BiFunction<Player, ServerboundUseItemPacket, Object> place = Recording.this::blockPlace;
-            private final BiFunction<Player, Object, Object> dig = Recording.this::blockDig;
+            private final BiFunction<Player, ServerboundPlayerActionPacket, Object> dig = Recording.this::blockDig;
 
             @Override
             public void enable() {
                 TinyProtocol.instance.addFilter(ServerboundUseItemPacket.class, place);
-                TinyProtocol.instance.addFilter(blockDigPacket, dig);
+                TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, dig);
             }
 
             @Override
             public void disable() {
                 TinyProtocol.instance.removeFilter(ServerboundUseItemPacket.class, place);
-                TinyProtocol.instance.removeFilter(blockDigPacket, dig);
+                TinyProtocol.instance.removeFilter(ServerboundPlayerActionPacket.class, dig);
             }
         }.register();
         new StateDependentTask(ArenaMode.AntiReplay, FightState.All, () -> {
@@ -143,13 +141,8 @@ public class Recording implements Listener {
         GlobalRecorder.getInstance().entitySpeed(entity);
     }
 
-    private static final Class<? extends Packet<?>> blockDigPacket = ServerboundPlayerActionPacket.class;
+    private Object blockDig(Player p, ServerboundPlayerActionPacket packet) {
-    private static final Class<?> playerDigType = blockDigPacket.getDeclaredClasses()[0];
+        if (!isNotSent(p) && packet.getAction() == ServerboundPlayerActionPacket.Action.RELEASE_USE_ITEM) {
-    private static final Reflection.Field<?> blockDigType = Reflection.getField(blockDigPacket, playerDigType, 0);
-    private static final Object releaseUseItem = playerDigType.getEnumConstants()[5];
-
-    private Object blockDig(Player p, Object packet) {
-        if (!isNotSent(p) && blockDigType.get(packet) == releaseUseItem) {
             GlobalRecorder.getInstance().bowSpan(p, false, false);
         }
         return packet;

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/PacketProcessor.java

@@ -34,7 +34,9 @@ import de.steamwar.fightsystem.fight.FightWorld;
 import de.steamwar.fightsystem.fight.FreezeWorld;
 import de.steamwar.fightsystem.listener.FightScoreboard;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.utils.*;
+import de.steamwar.fightsystem.utils.FightUI;
+import de.steamwar.fightsystem.utils.Message;
+import de.steamwar.fightsystem.utils.TechHiderWrapper;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.sql.Team;
@@ -510,11 +512,13 @@ public class PacketProcessor implements Listener {
         float volume = source.readFloat();
         float pitch = source.readFloat();
 
-        Sound sound = Sound.valueOf(soundName);
+        Sound sound = Registry.SOUNDS.get(NamespacedKey.minecraft(soundName));
+        if (sound == null) sound = Sound.valueOf(soundName); // TODO: Remove in 26.x because of no longer needed backwards compatibility
+        Sound finalSound = sound;
 
         execSync(() -> {
             Location location = new Location(Config.world, x, y, z);
-            location.getWorld().playSound(location, sound, SoundCategory.valueOf(soundCategory), volume, pitch);
+            location.getWorld().playSound(location, finalSound, SoundCategory.valueOf(soundCategory), volume, pitch);
         });
     }
 
@@ -524,9 +528,11 @@ public class PacketProcessor implements Listener {
         float volume = source.readFloat();
         float pitch = source.readFloat();
 
-        Sound sound = Sound.valueOf(soundName);
+        Sound sound = Registry.SOUNDS.get(NamespacedKey.minecraft(soundName));
+        if (sound == null) sound = Sound.valueOf(soundName); // TODO: Remove in 26.x because of no longer needed backwards compatibility
+        Sound finalSound = sound;
 
-        execSync(() -> Fight.playSound(sound, volume, pitch));
+        execSync(() -> Fight.playSound(finalSound, volume, pitch));
     }
 
     private void pasteSchem(FightTeam team) throws IOException {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/Recorder.java

@@ -33,6 +33,7 @@ import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
+ import org.bukkit.Registry;
 import org.bukkit.block.Block;
 import org.bukkit.craftbukkit.block.CraftBlockState;
 import org.bukkit.entity.Entity;
@@ -238,7 +239,7 @@ public interface Recorder {
     }
 
     default void sound(int x, int y, int z, SWSound soundType, String soundCategory, float volume, float pitch) {
-        write(0x32, x, y, z, soundType.getSound().name(), soundCategory, volume, pitch);
+        write(0x32, x, y, z, Registry.SOUNDS.getKey(soundType.getSound()).getKey(), soundCategory, volume, pitch);
     }
 
     default void soundAtPlayer(String soundType, float volume, float pitch) {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/TechHiderWrapper.java

@@ -19,7 +19,6 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.Reflection;
 import de.steamwar.core.CraftbukkitWrapper;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.events.BoardingEvent;
@@ -51,7 +50,7 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
 
 import java.util.Collection;
-import java.util.Optional;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
@@ -82,18 +81,13 @@ public class TechHiderWrapper extends StateDependent implements Listener {
                 .map(CraftMagicNumbers::getBlock)
                 .collect(Collectors.toUnmodifiableSet());
 
-        Object blockEntityType;
-        try {
-            blockEntityType = BuiltInRegistries.class.getDeclaredField("BLOCK_ENTITY_TYPE").get(null);
-        } catch (Exception e) {
-            throw new IllegalStateException(e);
-        }
-        Reflection.Method method = Reflection.getTypedMethod(Reflection.getClass("net.minecraft.core.Registry"), "get", Optional.class, ResourceLocation.class);
         Set<BlockEntityType<?>> blockEntityTypeToObfuscate = Config.GameModeConfig.Techhider.HiddenBlockEntities.stream()
-                .map((id) -> {
+                .map(id -> {
                     ResourceLocation loc = ResourceLocation.parse(id);
-                    return ((Optional<Holder.Reference<BlockEntityType<?>>>) method.invoke(blockEntityType, loc)).get().value();
+                    return BuiltInRegistries.BLOCK_ENTITY_TYPE.get(loc).orElse(null);
                 })
+                .filter(Objects::nonNull)
+                .map(Holder.Reference::value)
                 .collect(Collectors.toUnmodifiableSet());
 
         new TechHider(CraftMagicNumbers.getBlock(Config.GameModeConfig.Techhider.ObfuscateWith), new AccessPrivilegeProvider() {

FightSystem/build.gradle.kts

@@ -30,16 +30,6 @@ dependencies {
     implementation(project(":FightSystem:FightSystem_Core"))
 }
 
-tasks.register<FightServer>("WarGear20") {
-    group = "run"
-    description = "Run a WarGear 1.20 Fight Server"
-    dependsOn(":SpigotCore:shadowJar")
-    dependsOn(":FightSystem:shadowJar")
-    template = "WarGear20"
-    worldName = "arenas/Pentraki"
-    config = "WarGear20.yml"
-}
-
 tasks.register<FightServer>("HalloweenWS") {
     group = "run"
     description = "Run a Halloween 1.21 Fight Replay Server"
@@ -63,23 +53,3 @@ tasks.register<FightServer>("WarGear21") {
     config = "WarGear21.yml"
     jar = "/jars/paper-1.21.6.jar"
 }
-
-tasks.register<FightServer>("SpaceCraftDev20") {
-    group = "run"
-    description = "Run a SpaceCraftDev 1.20 Fight Server"
-    dependsOn(":SpigotCore:shadowJar")
-    dependsOn(":FightSystem:shadowJar")
-    template = "SpaceCraft20"
-    worldName = "arenas/AS_Horizon"
-    config = "SpaceCraftDev20.yml"
-}
-
-tasks.register<FightServer>("QuickGear20") {
-    group = "run"
-    description = "Run a QuickGear 1.20 Fight Server"
-    dependsOn(":SpigotCore:shadowJar")
-    dependsOn(":FightSystem:shadowJar")
-    template = "QuickGear20"
-    worldName = "arenas/WarGearPark"
-    config = "QuickGear20.yml"
-}

LobbySystem/build.gradle.kts

@@ -19,6 +19,7 @@
 
 plugins {
     steamwar.java
+    widener
 }
 
 dependencies {
@@ -32,11 +33,16 @@ dependencies {
     compileOnly(libs.fawe)
 }
 
-tasks.register<DevServer>("DevLobby20") {
+widener {
+    fromCatalog(libs.nms)
+    fromCatalog(libs.paperapi)
+}
+
+tasks.register<DevServer>("DevLobby") {
     group = "run"
-    description = "Run a 1.20 Dev Lobby"
+    description = "Run a Dev Lobby"
     dependsOn(":SpigotCore:shadowJar")
     dependsOn(":LobbySystem:jar")
-    template = "Lobby20"
+    template = "Lobby21"
     worldName = "Lobby"
 }

LobbySystem/src/de/steamwar/lobby/map/ColorInit.java

@@ -42,7 +42,7 @@ public class ColorInit {
         if (inputStream == null) {
             colors = new byte[256 * 256 * 256];
             for (int i = 0; i < colors.length; i++) {
-                colors[i] = MapPalette.matchColor(new Color(i));
+                colors[i] = matchColor(new Color(i));
             }
         } else {
             try {
@@ -57,4 +57,26 @@ public class ColorInit {
         }
         System.out.println("[ColorInit] Initialization took " + (System.currentTimeMillis() - time) + "ms");
     }
+
+    public static byte matchColor(Color color) {
+        if (color.getAlpha() < 128) return 0;
+
+        if (MapPalette.mapColorCache != null && MapPalette.mapColorCache.isCached()) {
+            return MapPalette.mapColorCache.matchColor(color);
+        }
+
+        int index = 0;
+        double best = -1;
+
+        for (int i = 4; i < MapPalette.colors.length; i++) {
+            double distance = MapPalette.getDistance(color, MapPalette.colors[i]);
+            if (distance < best || best == -1) {
+                best = distance;
+                index = i;
+            }
+        }
+
+        // Minecraft has 248 colors, some of which have negative byte representations
+        return (byte) (index < 128 ? index : -129 + (index - 127));
+    }
 }

LobbySystem/src/de/steamwar/lobby/map/CustomMap.java

@@ -42,7 +42,10 @@ import java.awt.image.BufferedImage;
 import java.awt.image.WritableRaster;
 import java.io.File;
 import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.Month;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicReference;
 
 public class CustomMap implements Listener {
 
@@ -56,7 +59,7 @@ public class CustomMap implements Listener {
             new Vector(2346, 45, 1297), new Vector(2345, 45, 1297), new Vector(2344, 45, 1297), new Vector(2343, 45, 1297), new Vector(2342, 45, 1297), new Vector(2341, 45, 1297), new Vector(2340, 45, 1297)
     );
 
-    private static final CustomMap RIGHT = new CustomMap(new File(System.getProperty("user.home") + "/lobbyBanner/right.png"),
+    private static final CustomMap RIGHT = new CustomMap(new File(System.getProperty("user.home") + "/lobbyBanner/right/"),
             new Vector(2330, 48, 1297), new Vector(2329, 48, 1297), new Vector(2328, 48, 1297), new Vector(2327, 48, 1297), new Vector(2326, 48, 1297), new Vector(2325, 48, 1297), new Vector(2324, 48, 1297),
             new Vector(2330, 47, 1297), new Vector(2329, 47, 1297), new Vector(2328, 47, 1297), new Vector(2327, 47, 1297), new Vector(2326, 47, 1297), new Vector(2325, 47, 1297), new Vector(2324, 47, 1297),
             new Vector(2330, 46, 1297), new Vector(2329, 46, 1297), new Vector(2328, 46, 1297), new Vector(2327, 46, 1297), new Vector(2326, 46, 1297), new Vector(2325, 46, 1297), new Vector(2324, 46, 1297),
@@ -66,32 +69,51 @@ public class CustomMap implements Listener {
     private File mapFile;
     private Map<Vector, Integer> itemFrameIndex = new HashMap<>();
     private ItemFrame[] itemFrames;
-    private long lastModified = Long.MAX_VALUE;
+    private boolean update = true;
 
-    public CustomMap(File mapFile, Vector... itemFrames) {
+    public CustomMap(File mapFileOrDirectory, Vector... itemFrames) {
-        this.mapFile = mapFile;
+        this.mapFile = mapFileOrDirectory;
         this.itemFrames = new ItemFrame[itemFrames.length];
         for (int i = 0; i < itemFrames.length; i++) {
             itemFrameIndex.put(itemFrames[i], i);
         }
 
-        Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
+        if (mapFileOrDirectory.isDirectory()) {
-            long modified = mapFile.lastModified();
+            AtomicReference<Month> lastMonth = new AtomicReference<>(LocalDateTime.now().getMonth());
-            if (modified > lastModified) {
+            Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
-                lastModified = modified;
+                Month current = LocalDateTime.now().getMonth();
-                System.out.println("Updating Banner: " + mapFile.getName());
+                if (!current.equals(lastMonth.get()) || update) {
-                Bukkit.getScheduler().runTaskAsynchronously(LobbySystem.getInstance(), () -> {
+                    lastMonth.set(current);
-                    try {
+                    update = false;
-                        run();
+                    this.mapFile = new File(mapFileOrDirectory, current.getValue() + ".png");
-                    } catch (IOException e) {
+                    update();
-                        // Ignore
+                }
-                    }
+            }, 200L, 1200L);
-                });
+        } else {
-            }
+            AtomicReference<Long> lastModified = new AtomicReference<>(Long.MAX_VALUE);
-        }, 200L, 200L);
+            Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
+                long modified = mapFileOrDirectory.lastModified();
+                if (modified > lastModified.get() || update) {
+                    lastModified.set(modified);
+                    update = false;
+                    update();
+                }
+            }, 200L, 200L);
+        }
         Bukkit.getPluginManager().registerEvents(this, LobbySystem.getInstance());
     }
 
+    private void update() {
+        System.out.println("Updating Banner: " + mapFile.getName());
+        Bukkit.getScheduler().runTaskAsynchronously(LobbySystem.getInstance(), () -> {
+            try {
+                run();
+            } catch (IOException e) {
+                // Ignore
+            }
+        });
+    }
+
     @EventHandler
     public void onChunkLoad(ChunkLoadEvent event) {
         for (Entity entity : event.getChunk().getEntities()) {
@@ -101,7 +123,7 @@ public class CustomMap implements Listener {
             if (itemFrameIndex.containsKey(vector)) {
                 if (itemFrames[itemFrameIndex.get(vector)] != null) continue;
                 itemFrames[itemFrameIndex.get(vector)] = itemFrame;
-                lastModified = 0;
+                update = true;
 
                 ItemStack itemStack = new ItemStack(Material.FILLED_MAP, 1);
                 MapMeta mapMeta = (MapMeta) itemStack.getItemMeta();
@@ -254,7 +276,8 @@ public class CustomMap implements Listener {
                 int green = pixels[i2];
                 int i3 = (y * width + x) * numBands + 2;
                 int blue = pixels[i3];
-                Color nearest = MapPalette.getColor(ColorInit.getColorByte(red, green, blue));
+                int colorIndex = ColorInit.getColorByte(red, green, blue);
+                Color nearest = MapPalette.colors[colorIndex >= 0 ? colorIndex : colorIndex + 256];
 
                 pixels[(y * width + x) * numBands] = nearest.getRed();
                 pixels[i2] = nearest.getGreen();

LobbySystem/src/lobby.accesswidener

@@ -0,0 +1,6 @@
+accessWidener v2 named
+
+# For CustomMap and ColorInit
+accessible field org/bukkit/map/MapPalette colors [Ljava/awt/Color;
+accessible method org/bukkit/map/MapPalette getDistance (Ljava/awt/Color;Ljava/awt/Color;)D
+accessible field org/bukkit/map/MapPalette mapColorCache Lorg/bukkit/map/MapPalette$MapColorCache;

MissileWars/build.gradle.kts

@@ -29,5 +29,15 @@ dependencies {
     compileOnly(libs.paperapi)
 
     compileOnly(libs.nms)
-    compileOnly(libs.worldedit)
+    compileOnly(libs.fawe)
+}
+
+tasks.register<FightServer>("MissileWars21") {
+    group = "run"
+    description = "Run a 1.21 Dev MissileWars"
+    dependsOn(":SpigotCore:shadowJar")
+    dependsOn(":MissileWars:jar")
+    template = "MissileWars"
+    worldName = "Great_Wall"
+    jar = "/jars/paper-1.21.6.jar"
 }

MissileWars/src/de/steamwar/misslewars/items/Missile.java

@@ -30,6 +30,8 @@ import com.sk89q.worldedit.function.operation.Operations;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.math.transform.AffineTransform;
 import com.sk89q.worldedit.session.ClipboardHolder;
+import com.sk89q.worldedit.util.SideEffect;
+import com.sk89q.worldedit.util.SideEffectSet;
 import com.sk89q.worldedit.world.World;
 import com.sk89q.worldedit.world.block.BlockTypes;
 import de.steamwar.misslewars.MissileWars;
@@ -109,11 +111,17 @@ public class Missile extends SpecialItem {
         v = aT.apply(v.toVector3()).toBlockPoint();
         v = v.add(location.getBlockX(), location.getBlockY(), location.getBlockZ());
 
-        EditSession e = WorldEdit.getInstance().getEditSessionFactory().getEditSession(world, -1);
+        EditSession e = WorldEdit.getInstance().getEditSessionFactory()
+                .getEditSession(world, -1);
+        e.setSideEffectApplier(SideEffectSet.defaults()
+                .with(SideEffect.NEIGHBORS, SideEffect.State.ON)
+                .with(SideEffect.LIGHTING, SideEffect.State.ON)
+                .with(SideEffect.UPDATE, SideEffect.State.ON));
         ClipboardHolder ch = new ClipboardHolder(clipboard);
         ch.setTransform(aT);
         Operations.completeBlindly(ch.createPaste(e).to(v).ignoreAirBlocks(true).build());
         e.flushSession();
+
         return true;
     }
 

MissileWars/src/de/steamwar/misslewars/slowmo/SlowMoRunner.java

@@ -20,9 +20,12 @@
 package de.steamwar.misslewars.slowmo;
 
 import de.steamwar.misslewars.MissileWars;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.TickRateManager;
 import org.bukkit.Bukkit;
 
 public class SlowMoRunner {
+    private static TickRateManager tickRateManager = MinecraftServer.getServer().tickRateManager();
 
     private static long currentTime = 0;
     private static long current = 0;
@@ -40,14 +43,14 @@ public class SlowMoRunner {
             if (currentTime > 0) {
                 current += 1;
                 if (current % 5 == 0) {
-                    SlowMoUtils.unfreeze();
+                    tickRateManager.setFrozen(false);
                     current = 0;
                 } else {
-                    SlowMoUtils.freeze();
+                    tickRateManager.setFrozen(true);
                 }
                 currentTime--;
             } else {
-                SlowMoUtils.unfreeze();
+                tickRateManager.setFrozen(false);
             }
         }, 0, 1);
     }

MissileWars/src/de/steamwar/misslewars/slowmo/SlowMoUtils.java

@@ -1,74 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.misslewars.slowmo;
-
-import net.minecraft.server.level.ServerLevel;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.CraftWorld;
-
-import java.lang.reflect.Field;
-
-public class SlowMoUtils {
-
-    private static final Field field;
-    public static final boolean freezeEnabled;
-
-    private static boolean frozen = false;
-
-    private static final World world;
-
-    static {
-        Field temp;
-        try {
-            temp = ServerLevel.class.getField("freezed");
-        } catch (NoSuchFieldException e) {
-            temp = null;
-        }
-        field = temp;
-        if (field != null) field.setAccessible(true);
-        freezeEnabled = field != null;
-        world = Bukkit.getWorlds().get(0);
-    }
-
-    public static void freeze() {
-        setFreeze(world, true);
-    }
-
-    public static void unfreeze() {
-        setFreeze(world, false);
-    }
-
-    public static boolean frozen() {
-        return freezeEnabled && frozen;
-    }
-
-    private static void setFreeze(World world, boolean state) {
-        if (freezeEnabled) {
-            if (frozen == state) return;
-            try {
-                field.set(((CraftWorld) world).getHandle(), state);
-                frozen = state;
-            } catch (IllegalAccessException e) {
-                // Ignored;
-            }
-        }
-    }
-}

SchematicSystem/src/de/steamwar/schematicsystem/autocheck/AutoChecker.java

@@ -37,28 +37,38 @@ public class AutoChecker {
     public static final AutoChecker impl = new AutoChecker();
 
     public AutoCheckerResult check(Clipboard clipboard, GameModeConfig<Material, String> type) {
-        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
+        return AutoCheckerResult.builder()
-                .depth(clipboard.getDimensions().getBlockZ()).blockScanResult(scan(clipboard, type))
+                .type(type)
-                .entities(clipboard.getEntities().stream().map(Entity::getLocation)
+                .height(clipboard.getDimensions().y())
-                        .map(blockVector3 -> new BlockPos(blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ()))
+                .width(clipboard.getDimensions().x())
-                        .collect(Collectors.toList()))
+                .depth(clipboard.getDimensions().z())
+                .blockScanResult(scan(clipboard, type))
+                .entities(
+                        clipboard.getEntities().stream()
+                                .map(Entity::getLocation)
+                                .map(blockVector3 -> new BlockPos(blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ()))
+                                .collect(Collectors.toList()))
                 .build();
     }
 
     public AutoCheckerResult sizeCheck(Clipboard clipboard, GameModeConfig<Material, String> type) {
-        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
+        return AutoCheckerResult.builder()
-                .depth(clipboard.getDimensions().getBlockZ()).build();
+                .type(type)
+                .height(clipboard.getDimensions().y())
+                .width(clipboard.getDimensions().x())
+                .depth(clipboard.getDimensions().z())
+                .build();
     }
 
     public AutoChecker.BlockScanResult scan(Clipboard clipboard, GameModeConfig<Material, String> type) {
         AutoChecker.BlockScanResult result = new AutoChecker.BlockScanResult();
         BlockVector3 min = clipboard.getMinimumPoint();
         BlockVector3 max = clipboard.getMaximumPoint();
-        for (int x = min.getBlockX(); x <= max.getBlockX(); x++) {
+        for (int x = min.x(); x <= max.x(); x++) {
-            for (int y = min.getBlockY(); y <= max.getBlockY(); y++) {
+            for (int y = min.y(); y <= max.y(); y++) {
-                for (int z = min.getBlockZ(); z <= max.getBlockZ(); z++) {
+                for (int z = min.z(); z <= max.z(); z++) {
                     final BaseBlock block = clipboard.getFullBlock(BlockVector3.at(x, y, z));
-                    final Material material = Material.matchMaterial(block.getBlockType().getId());
+                    final Material material = Material.matchMaterial(block.getBlockType().id());
                     if (material == null) {
                         continue;
                     }
@@ -69,7 +79,7 @@ public class AutoChecker {
                         checkInventory(result, block, material, new BlockPos(x, y, z), type);
                     }
 
-                    if (x == min.getBlockX() || x == max.getBlockX() || y == max.getBlockY() || z == min.getBlockZ() || z == max.getBlockZ()) {
+                    if (x == min.x() || x == max.x() || y == max.y() || z == min.z() || z == max.z()) {
                         result.getDesignBlocks().computeIfAbsent(material, m -> new ArrayList<>()).add(new BlockPos(x, y, z));
                     }
                 }

SchematicSystem/src/de/steamwar/schematicsystem/commands/schematiccommand/SchematicCommand.java

@@ -245,12 +245,12 @@ public class SchematicCommand extends SWCommand {
             BlockState replaceType = Objects.requireNonNull(toReplace.contains(Material.END_STONE) ? BlockTypes.IRON_BLOCK : BlockTypes.END_STONE).getDefaultState();
             BlockVector3 min = clipboard.getMinimumPoint();
             BlockVector3 max = clipboard.getMaximumPoint();
-            for (int i = min.getBlockX(); i <= max.getBlockX(); i++) {
+            for (int i = min.x(); i <= max.x(); i++) {
-                for (int j = min.getBlockY(); j <= max.getBlockY(); j++) {
+                for (int j = min.y(); j <= max.y(); j++) {
-                    for (int k = min.getBlockZ(); k <= max.getBlockZ(); k++) {
+                    for (int k = min.z(); k <= max.z(); k++) {
                         BlockVector3 vector = BlockVector3.at(i, j, k);
                         BaseBlock block = clipboard.getFullBlock(vector);
-                        if (toReplace.contains(Material.matchMaterial(block.getBlockType().getId()))) {
+                        if (toReplace.contains(Material.matchMaterial(block.getBlockType().id()))) {
                             clipboard.setBlock(vector, replaceType.toBaseBlock());
                         }
                     }

SpigotCore/SpigotCore_Main/build.gradle.kts

@@ -19,6 +19,7 @@
 
 plugins {
     steamwar.java
+    widener
 }
 
 tasks.compileJava {
@@ -58,6 +59,8 @@ dependencies {
     compileOnly(libs.netty)
     compileOnly(libs.brigadier)
     compileOnly(libs.fastutil)
-
+}
-    implementation(libs.anvilgui)
+
+widener {
+    fromCatalog(libs.nms)
 }

SpigotCore/SpigotCore_Main/src/com/comphenix/tinyprotocol/TinyProtocol.java

@@ -1,7 +1,6 @@
 package com.comphenix.tinyprotocol;
 
 import com.google.common.collect.MapMaker;
-import de.steamwar.Reflection;
 import de.steamwar.core.CRIUWakeupEvent;
 import de.steamwar.core.Core;
 import io.netty.channel.*;
@@ -180,22 +179,12 @@ public class TinyProtocol {
         networkManagers = serverConnection.getConnections();
         // We need to synchronize against this list
         createServerChannelHandler();
+        for (ChannelFuture item : serverConnection.channels) {
+            // Channel future that contains the server connection
+            Channel serverChannel = item.channel();
 
-        // Find the correct list, or implicitly throw an exception
+            serverChannels.add(serverChannel);
-        boolean looking = true;
+            serverChannel.pipeline().addFirst(serverChannelHandler);
-        for (int i = 0; looking; i++) {
-            List<Object> list = Reflection.getField(serverConnection.getClass(), List.class, i).get(serverConnection);
-
-            for (Object item : list) {
-                if (!(item instanceof ChannelFuture)) break;
-
-                // Channel future that contains the server connection
-                Channel serverChannel = ((ChannelFuture) item).channel();
-
-                serverChannels.add(serverChannel);
-                serverChannel.pipeline().addFirst(serverChannelHandler);
-                looking = false;
-            }
         }
     }
 

SpigotCore/SpigotCore_Main/src/de/steamwar/Reflection.java

@@ -1,315 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar;
-
-import de.steamwar.core.Core;
-import jdk.internal.misc.Unsafe;
-import lombok.AllArgsConstructor;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-
-
-@UtilityClass
-public final class Reflection {
-
-    public static final int MAJOR_VERSION;
-    public static final int MINOR_VERSION;
-
-    static {
-        String[] version = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.");
-        MAJOR_VERSION = Integer.parseInt(version[1]);
-        MINOR_VERSION = version.length > 2 ? Integer.parseInt(version[2]) : 0;
-    }
-
-    private static final String ORG_BUKKIT_CRAFTBUKKIT = Bukkit.getServer().getClass().getPackage().getName();
-    public static final String LEGACY_NET_MINECRAFT_SERVER = ORG_BUKKIT_CRAFTBUKKIT.replace("org.bukkit.craftbukkit", "net.minecraft.server");
-
-    private static final Map<String, String> spigotClassnames = new HashMap<>();
-
-    static {
-        // See https://mappings.dev for complete mappings
-        spigotClassnames.put("net.minecraft.Util", "net.minecraft.SystemUtils");
-
-        spigotClassnames.put("net.minecraft.core.BlockPos", "net.minecraft.core.BlockPosition");
-        spigotClassnames.put("net.minecraft.core.DefaultedRegistry", "net.minecraft.core.RegistryBlocks");
-        spigotClassnames.put("net.minecraft.core.IdMapper", "net.minecraft.core.RegistryBlockID");
-        spigotClassnames.put("net.minecraft.core.Vec3i", "net.minecraft.core.BaseBlockPosition");
-
-        spigotClassnames.put("net.minecraft.nbt.CompoundTag", "net.minecraft.nbt.NBTTagCompound");
-
-        spigotClassnames.put("net.minecraft.network.Connection", "net.minecraft.network.NetworkManager");
-
-        spigotClassnames.put("net.minecraft.network.chat.Component", "net.minecraft.network.chat.IChatBaseComponent");
-
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundAddEntityPacket", "net.minecraft.network.protocol.game.PacketPlayOutSpawnEntity");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundAddPlayerPacket", "net.minecraft.network.protocol.game.PacketPlayOutNamedEntitySpawn");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundAnimatePacket", "net.minecraft.network.protocol.game.PacketPlayOutAnimation");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundBlockDestructionPacket", "net.minecraft.network.protocol.game.PacketPlayOutBlockBreak");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket", "net.minecraft.network.protocol.game.PacketPlayOutTileEntityData");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundBlockEventPacket", "net.minecraft.network.protocol.game.PacketPlayOutBlockAction");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundBlockUpdatePacket", "net.minecraft.network.protocol.game.PacketPlayOutBlockChange");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundContainerClosePacket", "net.minecraft.network.protocol.game.PacketPlayOutCloseWindow");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundEntityEventPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityStatus");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundExplodePacket", "net.minecraft.network.protocol.game.PacketPlayOutExplosion");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundGameEventPacket", "net.minecraft.network.protocol.game.PacketPlayOutGameStateChange");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData$BlockEntityInfo", "net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData$a");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundLevelEventPacket", "net.minecraft.network.protocol.game.PacketPlayOutWorldEvent");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundLevelParticlesPacket", "net.minecraft.network.protocol.game.PacketPlayOutWorldParticles");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundMoveEntityPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntity");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$Pos", "net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutRelEntityMove");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$PosRot", "net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutRelEntityMoveLook");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$Rot", "net.minecraft.network.protocol.game.PacketPlayOutEntity$PacketPlayOutEntityLook");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundOpenSignEditorPacket", "net.minecraft.network.protocol.game.PacketPlayOutOpenSignEditor");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityDestroy");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundRotateHeadPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityHeadRotation");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSectionBlocksUpdatePacket", "net.minecraft.network.protocol.game.PacketPlayOutMultiBlockChange");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityMetadata");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSetEntityMotionPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityVelocity");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityEquipment");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSetObjectivePacket", "net.minecraft.network.protocol.game.PacketPlayOutScoreboardObjective");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSetScorePacket", "net.minecraft.network.protocol.game.PacketPlayOutScoreboardScore");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundSoundPacket", "net.minecraft.network.protocol.game.PacketPlayOutNamedSoundEffect");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ClientboundTeleportEntityPacket", "net.minecraft.network.protocol.game.PacketPlayOutEntityTeleport");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundContainerClickPacket", "net.minecraft.network.protocol.game.PacketPlayInWindowClick");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundInteractPacket", "net.minecraft.network.protocol.game.PacketPlayInUseEntity");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundInteractPacket$Action", "net.minecraft.network.protocol.game.PacketPlayInUseEntity$EnumEntityUseAction");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundInteractPacket$ActionType", "net.minecraft.network.protocol.game.PacketPlayInUseEntity$b");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Pos", "net.minecraft.network.protocol.game.PacketPlayInFlying$PacketPlayInPosition");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$PosRot", "net.minecraft.network.protocol.game.PacketPlayInFlying$PacketPlayInPositionLook");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Rot", "net.minecraft.network.protocol.game.PacketPlayInFlying$PacketPlayInLook");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundPlayerActionPacket", "net.minecraft.network.protocol.game.PacketPlayInBlockDig");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundSetCreativeModeSlotPacket", "net.minecraft.network.protocol.game.PacketPlayInSetCreativeSlot");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundSignUpdatePacket", "net.minecraft.network.protocol.game.PacketPlayInUpdateSign");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundUseItemPacket", "net.minecraft.network.protocol.game.PacketPlayInBlockPlace");
-        spigotClassnames.put("net.minecraft.network.protocol.game.ServerboundUseItemOnPacket", "net.minecraft.network.protocol.game.PacketPlayInUseItem");
-
-        spigotClassnames.put("net.minecraft.network.syncher.EntityDataAccessor", "net.minecraft.network.syncher.DataWatcherObject");
-        spigotClassnames.put("net.minecraft.network.syncher.EntityDataSerializer", "net.minecraft.network.syncher.DataWatcherSerializer");
-        spigotClassnames.put("net.minecraft.network.syncher.EntityDataSerializers", "net.minecraft.network.syncher.DataWatcherRegistry");
-        spigotClassnames.put("net.minecraft.network.syncher.SynchedEntityData$DataItem", "net.minecraft.network.syncher.DataWatcher$Item");
-
-        spigotClassnames.put("net.minecraft.server.ServerScoreboard$Method", "net.minecraft.server.ScoreboardServer$Action");
-
-        spigotClassnames.put("net.minecraft.server.level.ChunkMap", "net.minecraft.server.level.PlayerChunkMap");
-        spigotClassnames.put("net.minecraft.server.level.ChunkMap$TrackedEntity", "net.minecraft.server.level.PlayerChunkMap$EntityTracker");
-        spigotClassnames.put("net.minecraft.server.level.ServerChunkCache", "net.minecraft.server.level.ChunkProviderServer");
-        spigotClassnames.put("net.minecraft.server.level.ServerLevel", "net.minecraft.server.level.WorldServer");
-        spigotClassnames.put("net.minecraft.server.level.ServerPlayer", "net.minecraft.server.level.EntityPlayer");
-
-        spigotClassnames.put("net.minecraft.server.network.ServerConnectionListener", "net.minecraft.server.network.ServerConnection");
-
-        spigotClassnames.put("net.minecraft.world.InteractionHand", "net.minecraft.world.EnumHand");
-
-        spigotClassnames.put("net.minecraft.world.entity.EntityType", "net.minecraft.world.entity.EntityTypes");
-        spigotClassnames.put("net.minecraft.world.entity.Pose", "net.minecraft.world.entity.EntityPose");
-
-        spigotClassnames.put("net.minecraft.world.entity.item.PrimedTnt", "net.minecraft.world.entity.item.EntityTNTPrimed");
-
-        spigotClassnames.put("net.minecraft.world.entity.projectile.AbstractArrow", "net.minecraft.world.entity.projectile.EntityArrow");
-
-        spigotClassnames.put("net.minecraft.world.level.GameType", "net.minecraft.world.level.EnumGamemode");
-        spigotClassnames.put("net.minecraft.world.level.LevelAccessor", "net.minecraft.world.level.GeneratorAccess");
-
-        spigotClassnames.put("net.minecraft.world.level.block.state.BlockState", "net.minecraft.world.level.block.state.IBlockData");
-        spigotClassnames.put("net.minecraft.world.level.block.state.StateDefinition", "net.minecraft.world.level.block.state.BlockStateList");
-
-        spigotClassnames.put("net.minecraft.world.level.chunk.LevelChunk", "net.minecraft.world.level.chunk.Chunk");
-
-        spigotClassnames.put("net.minecraft.world.level.material.FlowingFluid", "net.minecraft.world.level.material.FluidTypeFlowing");
-        spigotClassnames.put("net.minecraft.world.level.material.Fluids", "net.minecraft.world.level.material.FluidTypes");
-        spigotClassnames.put("net.minecraft.world.level.material.FluidState", "net.minecraft.world.level.material.Fluid");
-
-        spigotClassnames.put("net.minecraft.world.phys.BlockHitResult", "net.minecraft.world.phys.MovingObjectPositionBlock");
-        spigotClassnames.put("net.minecraft.world.phys.Vec3", "net.minecraft.world.phys.Vec3D");
-
-        spigotClassnames.put("net.minecraft.resources.ResourceLocation", "net.minecraft.resources.MinecraftKey");
-
-        spigotClassnames.put("net.minecraft.util.ProgressListener", "net.minecraft.util.IProgressUpdate");
-    }
-
-    public static Class<?> getClass(String name) {
-        try {
-            if (name.startsWith("org.bukkit.craftbukkit")) {
-                return Class.forName(ORG_BUKKIT_CRAFTBUKKIT + name.substring(22));
-            } else if (MAJOR_VERSION < 17 && name.startsWith("net.minecraft")) {
-                return Class.forName(LEGACY_NET_MINECRAFT_SERVER + "." + spigotClassnames.getOrDefault(name, name).split("[.](?=[^.]*$)")[1]);
-            } else if (MAJOR_VERSION < 21 || MINOR_VERSION < 4) {
-                return Class.forName(spigotClassnames.getOrDefault(name, name));
-            } else {
-                Class<?> clazz = null;
-                try {
-                    clazz = Class.forName(name);
-                } catch (ClassNotFoundException e) {
-                }
-                if (clazz != null && clazz.getName().equals(name)) {
-                    return clazz;
-                }
-
-                try {
-                    return Core.class.getClassLoader().getParent().loadClass(name);
-                } catch (ClassNotFoundException e) {
-                    if (clazz == null) {
-                        throw e;
-                    }
-
-                    return clazz;
-                }
-            }
-        } catch (ClassNotFoundException e) {
-            throw new IllegalArgumentException("Cannot find " + name, e);
-        }
-    }
-
-    @AllArgsConstructor
-    public static class Field<T> {
-        private final java.lang.reflect.Field f;
-
-        @SuppressWarnings("unchecked")
-        public T get(Object target) {
-            try {
-                return (T) f.get(target);
-            } catch (IllegalAccessException e) {
-                throw new IllegalArgumentException("Cannot read field", e);
-            }
-        }
-
-        public void set(Object target, Object value) {
-            try {
-                f.set(target, value);
-            } catch (IllegalAccessException e) {
-                throw new IllegalArgumentException("Cannot write field", e);
-            }
-        }
-    }
-
-    public static <T> Field<T> getField(Class<?> target, String name, Class<T> fieldType) {
-        return getField(target, name, fieldType, 0);
-    }
-
-    public static <T> Field<T> getField(Class<?> target, Class<T> fieldType, int index) {
-        return getField(target, null, fieldType, index);
-    }
-
-    public static <T> Field<T> getField(Class<?> target, Class<T> fieldType, int index, Class<?>... parameters) {
-        return getField(target, null, fieldType, index, parameters);
-    }
-
-    private static <T> Field<T> getField(Class<?> target, String name, Class<T> fieldType, int index, Class<?>... parameters) {
-        for (final java.lang.reflect.Field field : target.getDeclaredFields()) {
-            if (matching(field, name, fieldType, parameters) && index-- <= 0) {
-                field.setAccessible(true);
-                return new Field<>(field);
-            }
-        }
-
-        // Search in parent classes
-        if (target.getSuperclass() != null) {
-            return getField(target.getSuperclass(), name, fieldType, index);
-        }
-
-        throw new IllegalArgumentException("Cannot find field with type " + fieldType);
-    }
-
-    private static <T> boolean matching(java.lang.reflect.Field field, String name, Class<T> fieldType, Class<?>... parameters) {
-        if (name != null && !field.getName().equals(name)) return false;
-
-        if (!fieldType.isAssignableFrom(field.getType())) return false;
-
-        if (parameters.length > 0) {
-            Type[] arguments = ((ParameterizedType) field.getGenericType()).getActualTypeArguments();
-
-            for (int i = 0; i < parameters.length; i++) {
-                if (arguments[i] instanceof ParameterizedType ? ((ParameterizedType) arguments[i]).getRawType() != parameters[i] : arguments[i] != parameters[i]) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    @AllArgsConstructor
-    public static class Method {
-        private final java.lang.reflect.Method m;
-
-        public Object invoke(Object target, Object... arguments) {
-            try {
-                return m.invoke(target, arguments);
-            } catch (Exception e) {
-                throw new IllegalArgumentException("Cannot invoke method " + m, e);
-            }
-        }
-    }
-
-    public static Method getTypedMethod(Class<?> clazz, String methodName, Class<?> returnType, Class<?>... params) {
-        for (final java.lang.reflect.Method method : clazz.getDeclaredMethods()) {
-            if ((methodName == null || method.getName().equals(methodName))
-                    && (returnType == null || method.getReturnType().equals(returnType))
-                    && Arrays.equals(method.getParameterTypes(), params)) {
-                method.setAccessible(true);
-                return new Method(method);
-            }
-        }
-
-        // Search in every superclass
-        if (clazz.getSuperclass() != null) {
-            return getTypedMethod(clazz.getSuperclass(), methodName, returnType, params);
-        }
-
-        throw new IllegalArgumentException(String.format("Cannot find method %s (%s).", methodName, Arrays.asList(params)));
-    }
-
-    @AllArgsConstructor
-    public static class Constructor {
-        private final java.lang.reflect.Constructor<?> c;
-
-        public Object invoke(Object... arguments) {
-            try {
-                return c.newInstance(arguments);
-            } catch (Exception e) {
-                throw new IllegalArgumentException("Cannot invoke constructor " + c, e);
-            }
-        }
-    }
-
-    public static Constructor getConstructor(Class<?> clazz, Class<?>... params) {
-        for (final java.lang.reflect.Constructor<?> constructor : clazz.getDeclaredConstructors()) {
-            if (Arrays.equals(constructor.getParameterTypes(), params)) {
-                constructor.setAccessible(true);
-                return new Constructor(constructor);
-            }
-        }
-
-        throw new IllegalStateException(String.format("Unable to find constructor for %s (%s).", clazz, Arrays.asList(params)));
-    }
-
-    public static Object newInstance(Class<?> clazz) {
-        try {
-            return Unsafe.getUnsafe().allocateInstance(clazz);
-        } catch (InstantiationException e) {
-            throw new SecurityException("Could not create object", e);
-        }
-    }
-}

SpigotCore/SpigotCore_Main/src/de/steamwar/command/CommandRegistering.java

@@ -22,35 +22,20 @@ package de.steamwar.command;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandMap;
 import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.craftbukkit.CraftServer;
 
-import java.lang.reflect.Field;
 import java.util.Map;
 
 @UtilityClass
 class CommandRegistering {
 
-    private static final CommandMap commandMap;
+    private static final SimpleCommandMap commandMap;
     private static final Map<String, Command> knownCommandMap;
 
     static {
-        try {
+        commandMap = ((CraftServer) Bukkit.getServer()).getCommandMap();
-            final Field commandMapField = Bukkit.getServer().getClass().getDeclaredField("commandMap");
+        knownCommandMap = commandMap.getKnownCommands();
-            commandMapField.setAccessible(true);
-            commandMap = (CommandMap) commandMapField.get(Bukkit.getServer());
-        } catch (NoSuchFieldException | IllegalAccessException exception) {
-            Bukkit.shutdown();
-            throw new SecurityException("Oh shit. Commands cannot be registered.", exception);
-        }
-        try {
-            final Field knownCommandsField = SimpleCommandMap.class.getDeclaredField("knownCommands");
-            knownCommandsField.setAccessible(true);
-            knownCommandMap = (Map<String, Command>) knownCommandsField.get(commandMap);
-        } catch (NoSuchFieldException | IllegalAccessException exception) {
-            Bukkit.shutdown();
-            throw new SecurityException("Oh shit. Commands cannot be registered.", exception);
-        }
     }
 
     static void unregister(Command command) {

SpigotCore/SpigotCore_Main/src/de/steamwar/core/BountifulWrapper.java

@@ -19,20 +19,11 @@
 
 package de.steamwar.core;
 
-import de.steamwar.Reflection;
 import net.md_5.bungee.api.ChatMessageType;
 import net.md_5.bungee.api.chat.BaseComponent;
-import net.minecraft.network.syncher.EntityDataAccessor;
-import net.minecraft.network.syncher.EntityDataSerializer;
-import net.minecraft.network.syncher.EntityDataSerializers;
-import net.minecraft.network.syncher.SynchedEntityData;
-import net.minecraft.world.entity.PositionMoveRotation;
-import net.minecraft.world.phys.Vec3;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
 
-import java.util.UUID;
-
 public class BountifulWrapper {
     public static final BountifulWrapper impl = new BountifulWrapper();
 
@@ -44,60 +35,4 @@ public class BountifulWrapper {
         if (type == ChatMessageType.CHAT) type = ChatMessageType.SYSTEM;
         player.spigot().sendMessage(type, msg);
     }
-
-    private static final Class<?> dataWatcherRegistry = EntityDataSerializers.class;
-    private static final Class<?> dataWatcherSerializer = EntityDataSerializer.class;
-
-    public Object getDataWatcherObject(int index, Class<?> type) {
-        return new EntityDataAccessor<>(index, (EntityDataSerializer<Object>) Reflection.getField(dataWatcherRegistry, dataWatcherSerializer, 0, type).get(null));
-    }
-
-    public Object getDataWatcherItem(Object dwo, Object value) {
-        return new SynchedEntityData.DataItem<>((EntityDataAccessor<Object>) dwo, value);
-    }
-
-    public BountifulWrapper.PositionSetter getPositionSetter(Class<?> packetClass, int fieldOffset) {
-        try {
-            Reflection.Field<PositionMoveRotation> field = Reflection.getField(packetClass, PositionMoveRotation.class, 0);
-
-            return (packet, x, y, z, pitch, yaw) -> {
-                field.set(packet, new PositionMoveRotation(new Vec3(x, y, z), field.get(packet).deltaMovement(), yaw, pitch));
-            };
-        } catch (IllegalArgumentException e) {
-            Reflection.Field<Double> posX = Reflection.getField(packetClass, double.class, fieldOffset);
-            Reflection.Field<Double> posY = Reflection.getField(packetClass, double.class, fieldOffset + 1);
-            Reflection.Field<Double> posZ = Reflection.getField(packetClass, double.class, fieldOffset + 2);
-            boolean isByteClass = packetClass.getSimpleName().contains("PacketPlayOutEntityTeleport") || packetClass.getSimpleName().contains("PacketPlayOutNamedEntitySpawn");
-            Class<?> pitchYawType = isByteClass ? byte.class : int.class;
-            Reflection.Field<?> lookYaw = Reflection.getField(packetClass, pitchYawType, isByteClass ? 0 : 1);
-            Reflection.Field<?> lookPitch = Reflection.getField(packetClass, pitchYawType, isByteClass ? 1 : 2);
-
-            return (packet, x, y, z, pitch, yaw) -> {
-                posX.set(packet, x);
-                posY.set(packet, y);
-                posZ.set(packet, z);
-                if (isByteClass) {
-                    lookYaw.set(packet, (byte) (yaw * 256 / 360));
-                    lookPitch.set(packet, (byte) (pitch * 256 / 360));
-                } else {
-                    lookYaw.set(packet, (int) (yaw * 256 / 360));
-                    lookPitch.set(packet, (int) (pitch * 256 / 360));
-                }
-            };
-        }
-    }
-
-    public BountifulWrapper.UUIDSetter getUUIDSetter(Class<?> packetClass) {
-        Reflection.Field<UUID> uuidField = Reflection.getField(packetClass, UUID.class, 0);
-
-        return uuidField::set;
-    }
-
-    public interface PositionSetter {
-        void set(Object packet, double x, double y, double z, float pitch, float yaw);
-    }
-
-    public interface UUIDSetter {
-        void set(Object packet, UUID uuid);
-    }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/core/CheckpointUtilsJ9.java

@@ -20,7 +20,6 @@
 package de.steamwar.core;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.sql.internal.Statement;
 import io.netty.channel.ChannelFuture;
 import net.minecraft.server.MinecraftServer;
@@ -96,9 +95,6 @@ class CheckpointUtilsJ9 {
         }
     }
 
-
-    private static final Reflection.Field<List> channelFutures = Reflection.getField(ServerConnectionListener.class, List.class, 0, ChannelFuture.class);
-
     private static void freezeInternal(Path path) throws Exception {
         Bukkit.getPluginManager().callEvent(new CRIUSleepEvent());
 
@@ -109,9 +105,9 @@ class CheckpointUtilsJ9 {
 
         // Close socket
         ServerConnectionListener serverConnection = MinecraftServer.getServer().getConnection();
-        List<?> channels = channelFutures.get(serverConnection);
+        List<ChannelFuture> channels = serverConnection.channels;
-        for (Object future : channels) {
+        for (ChannelFuture future : channels) {
-            ((ChannelFuture) future).channel().close().syncUninterruptibly();
+            future.channel().close().syncUninterruptibly();
         }
         channels.clear();
 
@@ -145,8 +141,8 @@ class CheckpointUtilsJ9 {
 
         // Reopen socket
         serverConnection.startTcpServerListener(InetAddress.getLoopbackAddress(), port);
-        for (Object future : channels) {
+        for (ChannelFuture future : channels) {
-            ((ChannelFuture) future).channel().config().setAutoRead(true);
+            future.channel().config().setAutoRead(true);
         }
 
         Bukkit.getPluginManager().callEvent(new CRIUWakeupEvent());

SpigotCore/SpigotCore_Main/src/de/steamwar/core/Core.java

@@ -5,8 +5,8 @@
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
+ *   the Free Software Foundation, either versionStrings 3 of the License, or
- *   (at your option) any later version.
+ *   (at your option) any later versionStrings.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -20,7 +20,6 @@
 package de.steamwar.core;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.command.SWCommandUtils;
 import de.steamwar.command.SWTypeMapperCreator;
 import de.steamwar.command.TabCompletionCache;
@@ -49,9 +48,13 @@ public class Core extends JavaPlugin {
 
     public static final Message MESSAGE = new Message("SpigotCore", Core.class.getClassLoader());
 
+    @Getter
     @Deprecated
-    public static int getVersion() {
+    private static final int version;
-        return Reflection.MAJOR_VERSION;
+
+    static {
+        String[] versionStrings = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.");
+        version = Integer.parseInt(versionStrings[1]);
     }
 
     @Getter

SpigotCore/SpigotCore_Main/src/de/steamwar/core/ErrorHandler.java

@@ -19,7 +19,6 @@
 
 package de.steamwar.core;
 
-import de.steamwar.Reflection;
 import de.steamwar.sql.SWException;
 import org.spigotmc.WatchdogThread;
 
@@ -39,9 +38,7 @@ public class ErrorHandler extends Handler {
 
     public ErrorHandler() {
         Logger.getLogger("").addHandler(this);
-
+        watchdogThreadId = WatchdogThread.instance.threadId();
-        Reflection.Field<WatchdogThread> getInstance = Reflection.getField(WatchdogThread.class, WatchdogThread.class, 0);
-        watchdogThreadId = getInstance.get(null).getId();
     }
 
     void unregister() {

SpigotCore/SpigotCore_Main/src/de/steamwar/core/WorldIdentifier.java

@@ -20,7 +20,6 @@
 package de.steamwar.core;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.linkage.Linked;
 import net.minecraft.network.protocol.game.ClientboundLoginPacket;
 import net.minecraft.network.protocol.game.CommonPlayerSpawnInfo;
@@ -33,13 +32,8 @@ public class WorldIdentifier {
 
     private static ResourceKey<Level> resourceKey = null;
 
-    private static final Class<?> resourceKeyClass = ResourceKey.class;
-    private static final Class<?> minecraftKeyClass = ResourceLocation.class;
-    private static final Reflection.Constructor resourceKeyConstructor = Reflection.getConstructor(resourceKeyClass, minecraftKeyClass, minecraftKeyClass);
-    private static final Reflection.Constructor minecraftKeyConstructor = Reflection.getConstructor(minecraftKeyClass, String.class, String.class);
-
     public static void set(String name) {
-        resourceKey = (ResourceKey<Level>) resourceKeyConstructor.invoke(minecraftKeyConstructor.invoke("minecraft", "dimension"), minecraftKeyConstructor.invoke("steamwar", name));
+        resourceKey = new ResourceKey<>(new ResourceLocation("minecraft", "dimension"), new ResourceLocation("steamwar", name));
     }
 
     public WorldIdentifier() {

SpigotCore/SpigotCore_Main/src/de/steamwar/core/authlib/SteamwarGameProfileRepository.java

@@ -22,7 +22,6 @@ package de.steamwar.core.authlib;
 import com.mojang.authlib.GameProfile;
 import com.mojang.authlib.GameProfileRepository;
 import com.mojang.authlib.ProfileLookupCallback;
-import de.steamwar.Reflection;
 import de.steamwar.sql.SteamwarUser;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.Services;
@@ -35,13 +34,10 @@ public class SteamwarGameProfileRepository implements GameProfileRepository {
     public static final SteamwarGameProfileRepository impl = new SteamwarGameProfileRepository();
 
     private static final GameProfileRepository fallback;
-    private static final Reflection.Field<Services> field;
     private static final Services current;
 
     static {
-        Class<?> clazz = MinecraftServer.getServer().getClass();
+        current = MinecraftServer.getServer().services;
-        field = Reflection.getField(clazz, Services.class, 0);
-        current = field.get(MinecraftServer.getServer());
         fallback = current.profileRepository();
     }
 
@@ -68,7 +64,6 @@ public class SteamwarGameProfileRepository implements GameProfileRepository {
     }
 
     public void inject() {
-        Services newServices = new Services(current.sessionService(), current.servicesKeySet(), this, current.profileCache(), current.paperConfigurations());
+        MinecraftServer.getServer().services = new Services(current.sessionService(), current.servicesKeySet(), this, current.profileCache(), current.paperConfigurations());
-        field.set(MinecraftServer.getServer(), newServices);
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/core/events/AntiNocom.java

@@ -20,16 +20,13 @@
 package de.steamwar.core.events;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.core.Core;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SWException;
 import de.steamwar.techhider.ProtocolUtils;
-import de.steamwar.techhider.TechHider;
 import net.minecraft.core.BlockPos;
 import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket;
 import net.minecraft.network.protocol.game.ServerboundUseItemOnPacket;
-import net.minecraft.world.phys.BlockHitResult;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -38,7 +35,6 @@ import org.bukkit.event.player.PlayerQuitEvent;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Function;
 
 @Linked
 public class AntiNocom implements Listener {

SpigotCore/SpigotCore_Main/src/de/steamwar/cursor/Cursor.java

@@ -0,0 +1,240 @@
+package de.steamwar.cursor;
+
+import de.steamwar.core.SWPlayer;
+import de.steamwar.entity.REntity;
+import de.steamwar.entity.REntityServer;
+import de.steamwar.entity.RFallingBlockEntity;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+import org.bukkit.util.Vector;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+@Getter
+public class Cursor implements SWPlayer.Component {
+    private final World WORLD = Bukkit.getWorlds().get(0);
+
+    private final REntityServer targetServer;
+    private final Player owner;
+
+    private final AtomicBoolean isRendering = new AtomicBoolean(false);
+
+    private RFallingBlockEntity cursorEntity;
+    private final REntityServer cursorServer;
+    private Location cursorLocation;
+    private REntity hitEntity;
+
+    @Setter
+    private Material cursorMaterial;
+    @Setter
+    private List<CursorMode> allowedCursorModes;
+    private final Material highlightMaterial;
+    private final ClickHandler onClick;
+    private final BiConsumer<Location, Optional<REntity>> onRender;
+
+
+    public Cursor(REntityServer targetServer, Player owner, Material highlightMaterial, Material cursorMaterial, List<CursorMode> allowedModes, ClickHandler onClick) {
+        this(targetServer, owner, highlightMaterial, cursorMaterial, allowedModes, onClick, (location, hitEntity) -> {
+        });
+    }
+
+    public Cursor(REntityServer targetServer, Player owner, Material highlightMaterial, Material cursorMaterial, List<CursorMode> allowedModes, ClickHandler onClick, BiConsumer<Location, Optional<REntity>> onRender) {
+        this.targetServer = targetServer;
+        this.owner = owner;
+        this.highlightMaterial = highlightMaterial;
+        this.cursorMaterial = cursorMaterial;
+        this.allowedCursorModes = allowedModes;
+        this.onClick = onClick;
+        this.onRender = onRender;
+
+        cursorServer = new REntityServer();
+        cursorServer.addPlayer(owner);
+
+        SWPlayer.of(owner).setComponent(this);
+    }
+
+    public void renderDeduplicated() {
+        if (!isRendering.getAndSet(true)) {
+            render();
+            isRendering.set(false);
+        }
+    }
+
+    private void render() {
+        RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(owner, owner.getLocation(), targetServer.getEntities());
+        if (rayTraceResult == null) {
+            if (cursorEntity != null)
+                cursorEntity.die();
+            cursorEntity = null;
+            cursorLocation = null;
+            hitEntity = null;
+            onRender.accept(null, Optional.empty());
+            return;
+        }
+
+        REntity hitEntity = rayTraceResult.getHitEntity() == cursorEntity ? null : rayTraceResult.getHitEntity();
+
+
+        Material activeCursorMaterial = hitEntity == null ? cursorMaterial : highlightMaterial;
+        CursorMode activeCursorMode = allowedCursorModes.stream().filter((mode) -> mode.isActive.test(owner)).min(Comparator.comparingInt(a -> a.priority))
+                .orElse(CursorMode.BLOCK_ALIGNED);
+
+        Location activeCursorLocation = hitEntity == null ? activeCursorMode.positionTransform.apply(owner, rayTraceResult).toLocation(WORLD)
+                : new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ()).toLocation(WORLD);
+
+        cursorLocation = activeCursorLocation;
+        this.hitEntity = hitEntity;
+
+        if (cursorEntity == null) {
+            cursorEntity = new RFallingBlockEntity(cursorServer, activeCursorLocation, activeCursorMaterial);
+            cursorEntity.setNoGravity(true);
+        } else if (cursorEntity.getMaterial() == activeCursorMaterial) {
+            cursorEntity.move(activeCursorLocation);
+        } else {
+            cursorEntity.die();
+            cursorEntity = new RFallingBlockEntity(cursorServer, activeCursorLocation, activeCursorMaterial);
+            cursorEntity.setNoGravity(true);
+            if (activeCursorMaterial == highlightMaterial) {
+                cursorEntity.setGlowing(true);
+            }
+        }
+        onRender.accept(cursorLocation, Optional.ofNullable(hitEntity));
+    }
+
+    protected void handlePlayerClick(Action clickAction) {
+        renderDeduplicated();
+        onClick.onClick(this.cursorLocation, Optional.ofNullable(this.hitEntity), clickAction);
+    }
+
+    @Override
+    public void onUnmount(SWPlayer player) {
+        cursorServer.close();
+    }
+
+    @AllArgsConstructor
+    public enum CursorMode {
+        FREE(1, (player, rayTraceResult) -> {
+            Vector pos = rayTraceResult.getHitPosition();
+
+            BlockFace face = rayTraceResult.getHitBlockFace();
+            if (face != null) {
+                switch (face) {
+                    case DOWN:
+                        pos.setY(pos.getY() - 0.98);
+                        break;
+                    case EAST:
+                        pos.setX(pos.getX() + 0.49);
+                        break;
+                    case WEST:
+                        pos.setX(pos.getX() - 0.49);
+                        break;
+                    case NORTH:
+                        pos.setZ(pos.getZ() - 0.49);
+                        break;
+                    case SOUTH:
+                        pos.setZ(pos.getZ() + 0.49);
+                        break;
+                    default:
+                        break;
+                }
+
+                if (face.getModY() == 0 && player.isSneaking()) {
+                    pos.setY(pos.getY() - 0.49);
+                }
+            }
+
+            return pos;
+        }, Player::isSneaking),
+
+        SURFACE_ALIGNED(2, (player, rayTraceResult) -> {
+            Vector hitPosition = rayTraceResult.getHitPosition().clone();
+            Vector pos = blockAlignedPosition(rayTraceResult);
+            BlockFace face = rayTraceResult.getHitBlockFace();
+
+            if (face != null && face != BlockFace.SELF) {
+                switch (face) {
+                    case UP:
+                        pos.setY(hitPosition.getY());
+                        break;
+                    case DOWN:
+                        pos.setY(hitPosition.getY() + face.getModY());
+                        break;
+                    case EAST:
+                    case WEST:
+                        pos.setX(hitPosition.getX() + face.getModX() * 0.5);
+                        break;
+                    case NORTH:
+                    case SOUTH:
+                        pos.setZ(hitPosition.getZ() + face.getModZ() * 0.5);
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            return pos;
+        }, (player) -> true),
+
+        BLOCK_ALIGNED(0, (player, rayTraceResult) -> blockAlignedPosition(rayTraceResult), (player) -> true);
+
+
+        private final int priority;
+        private final BiFunction<Player, RayTraceUtils.RRayTraceResult, Vector> positionTransform;
+        private final Predicate<Player> isActive;
+
+        private static Vector blockAlignedPosition(RayTraceUtils.RRayTraceResult rayTraceResult) {
+            Vector pos = rayTraceResult.getHitPosition();
+
+            BlockFace face = rayTraceResult.getHitBlockFace();
+            if (face != null) {
+                switch (face) {
+                    case DOWN:
+                        pos.setY(pos.getY() - 0.98);
+                        break;
+                    case EAST:
+                        pos.setX(pos.getX() + 0.49);
+                        break;
+                    case WEST:
+                        pos.setX(pos.getX() - 0.49);
+                        break;
+                    case NORTH:
+                        pos.setZ(pos.getZ() - 0.49);
+                        break;
+                    case SOUTH:
+                        pos.setZ(pos.getZ() + 0.49);
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            pos.setX(pos.getBlockX() + 0.5);
+            if (pos.getY() - pos.getBlockY() != 0 && face == BlockFace.UP) {
+                pos.setY(pos.getBlockY() + 1.0);
+            } else {
+                pos.setY(pos.getBlockY());
+            }
+            pos.setZ(pos.getBlockZ() + 0.5);
+            return pos;
+        }
+    }
+
+    @FunctionalInterface
+    public interface ClickHandler {
+        void onClick(Location location, Optional<REntity> hitEntity, Action action);
+    }
+}

SpigotCore/SpigotCore_Main/src/de/steamwar/cursor/CursorListener.java

@@ -0,0 +1,56 @@
+package de.steamwar.cursor;
+
+import com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.core.Core;
+import de.steamwar.core.SWPlayer;
+import de.steamwar.linkage.Linked;
+import lombok.Getter;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+import java.util.Optional;
+
+
+@Linked
+public class CursorListener implements Listener {
+    @Getter
+    private static CursorListener instance;
+
+    public CursorListener() {
+        if (instance == null) {
+            instance = this;
+        }
+
+        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, this::updateCursorFromPacket);
+        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Rot.class, this::updateCursorFromPacket);
+        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, this::updateCursorFromPacket);
+
+        Bukkit.getScheduler().runTaskTimer(Core.getInstance(), () -> {
+            SWPlayer.allWithSingleComponent(Cursor.class)
+                    .map(SWPlayer.SWPlayerWithComponent::getComponent)
+                    .forEach(Cursor::renderDeduplicated);
+        }, 1, 1);
+    }
+
+    public Packet<?> updateCursorFromPacket(Player player, Packet<?> packet) {
+        SWPlayer swPlayer = SWPlayer.of(player);
+        Optional<Cursor> activeCursor = swPlayer.getComponent(Cursor.class);
+
+        activeCursor.ifPresent(Cursor::renderDeduplicated);
+
+        return packet;
+    }
+
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        SWPlayer.of(event.getPlayer()).getComponent(Cursor.class).ifPresent(cursor -> {
+            event.setCancelled(true);
+            cursor.handlePlayerClick(event.getAction());
+        });
+    }
+}

SpigotCore/SpigotCore_Main/src/de/steamwar/cursor/RayTraceUtils.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,7 +17,7 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.bausystem.utils;
+package de.steamwar.cursor;
 
 import de.steamwar.entity.REntity;
 import lombok.Data;

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RArmorStand.java

@@ -49,7 +49,7 @@ public class RArmorStand extends REntity implements RInteractableEntity<RArmorSt
         super.spawn(packetSink);
 
         if (size != null && size != Size.NORMAL) {
-            packetSink.accept(getDataWatcherPacket(sizeWatcher, size.value));
+            entityDataPacket().add(sizeWatcher, size.value).send(packetSink);
         }
     }
 

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RBlockDisplay.java

@@ -61,9 +61,9 @@ public class RBlockDisplay extends RDisplay {
 
     private static final EntityDataAccessor<BlockState> blockWatcher = new EntityDataAccessor<>(23, EntityDataSerializers.BLOCK_STATE);
 
-    private void getBlock(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getBlock(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || !block.getAsString(true).equals(DEFAULT_BLOCK.getAsString(true))) {
-            packetSink.accept(blockWatcher, ((CraftBlockData) block).getState());
+            packetSink.add(blockWatcher, ((CraftBlockData) block).getState());
         }
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RDisplay.java

@@ -89,18 +89,13 @@ public abstract class RDisplay extends REntity {
     }
 
     @SafeVarargs
-    protected final void sendPacket(Consumer<Object> packetSink, BiConsumer<Boolean, BiConsumer<Object, Object>>... dataSinkSinks) {
+    protected final void sendPacket(Consumer<Object> packetSink, BiConsumer<Boolean, EntityDataPacketBuilder>... dataSinkSinks) {
-        List<Object> keyValueData = new ArrayList<>();
+        EntityDataPacketBuilder builder = entityDataPacket();
         boolean ignoreDefault = packetSink == updatePacketSink;
-        for (BiConsumer<Boolean, BiConsumer<Object, Object>> dataSinkSink : dataSinkSinks) {
+        for (BiConsumer<Boolean, EntityDataPacketBuilder> dataSinkSink : dataSinkSinks) {
-            dataSinkSink.accept(ignoreDefault, (dataWatcher, value) -> {
+            dataSinkSink.accept(ignoreDefault, builder);
-                keyValueData.add(dataWatcher);
-                keyValueData.add(value);
-            });
-        }
-        if (!keyValueData.isEmpty()) {
-            packetSink.accept(getDataWatcherPacket(keyValueData.toArray()));
         }
+        if (!builder.isEmpty()) builder.send(packetSink);
     }
 
     public void setTransform(@NonNull Transformation transform) {
@@ -113,12 +108,12 @@ public abstract class RDisplay extends REntity {
     private static final EntityDataAccessor<Vector3f> scaleWatcher = new EntityDataAccessor<>(12, EntityDataSerializers.VECTOR3);
     private static final EntityDataAccessor<Quaternionf> rightRotationWatcher = new EntityDataAccessor<>(14, EntityDataSerializers.QUATERNION);
 
-    private void getTransformData(boolean ignoreDefault, BiConsumer<Object, Object> dataSink) {
+    private void getTransformData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
         if (ignoreDefault || !transform.equals(DEFAULT_TRANSFORM)) {
-            dataSink.accept(translationWatcher, transform.getTranslation());
+            dataSink.add(translationWatcher, transform.getTranslation());
-            dataSink.accept(leftRotationWatcher, transform.getLeftRotation());
+            dataSink.add(leftRotationWatcher, transform.getLeftRotation());
-            dataSink.accept(scaleWatcher, transform.getScale());
+            dataSink.add(scaleWatcher, transform.getScale());
-            dataSink.accept(rightRotationWatcher, transform.getRightRotation());
+            dataSink.add(rightRotationWatcher, transform.getRightRotation());
         }
     }
 
@@ -130,10 +125,10 @@ public abstract class RDisplay extends REntity {
     private static final EntityDataAccessor<Integer> transformationInterpolationDurationWatcher = new EntityDataAccessor<>(9, EntityDataSerializers.INT);
     private static final EntityDataAccessor<Integer> positionOrRotationInterpolationDurationWatcher = new EntityDataAccessor<>(10, EntityDataSerializers.INT);
 
-    private void getInterpolationDuration(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getInterpolationDuration(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || interpolationDelay != 0) {
-            packetSink.accept(transformationInterpolationDurationWatcher, interpolationDuration);
+            packetSink.add(transformationInterpolationDurationWatcher, interpolationDuration);
-            packetSink.accept(positionOrRotationInterpolationDurationWatcher, interpolationDuration);
+            packetSink.add(positionOrRotationInterpolationDurationWatcher, interpolationDuration);
         }
     }
 
@@ -144,9 +139,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Float> viewRangeWatcher = new EntityDataAccessor<>(17, EntityDataSerializers.FLOAT);
 
-    private void getViewRange(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getViewRange(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || viewRange != 1.0F) {
-            packetSink.accept(viewRangeWatcher, viewRange);
+            packetSink.add(viewRangeWatcher, viewRange);
         }
     }
 
@@ -157,9 +152,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Float> shadowRadiusWatcher = new EntityDataAccessor<>(18, EntityDataSerializers.FLOAT);
 
-    private void getShadowRadius(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getShadowRadius(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || shadowRadius != 0.0F) {
-            packetSink.accept(shadowRadiusWatcher, shadowRadius);
+            packetSink.add(shadowRadiusWatcher, shadowRadius);
         }
     }
 
@@ -170,9 +165,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Float> shadowStrengthWatcher = new EntityDataAccessor<>(19, EntityDataSerializers.FLOAT);
 
-    private void getShadowStrength(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getShadowStrength(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || shadowStrength != 1.0F) {
-            packetSink.accept(shadowStrengthWatcher, shadowStrength);
+            packetSink.add(shadowStrengthWatcher, shadowStrength);
         }
     }
 
@@ -183,9 +178,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Float> displayWidthWatcher = new EntityDataAccessor<>(20, EntityDataSerializers.FLOAT);
 
-    private void getDisplayWidth(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getDisplayWidth(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || displayWidth != 0.0F) {
-            packetSink.accept(displayWidthWatcher, displayWidth);
+            packetSink.add(displayWidthWatcher, displayWidth);
         }
     }
 
@@ -196,9 +191,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Float> displayHeightWatcher = new EntityDataAccessor<>(21, EntityDataSerializers.FLOAT);
 
-    private void getDisplayHeight(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getDisplayHeight(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || displayHeight != 0.0F) {
-            packetSink.accept(displayHeightWatcher, displayHeight);
+            packetSink.add(displayHeightWatcher, displayHeight);
         }
     }
 
@@ -209,9 +204,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Integer> interpolationDelayWatcher = new EntityDataAccessor<>(8, EntityDataSerializers.INT);
 
-    private void getInterpolationDelay(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getInterpolationDelay(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || interpolationDelay != 0) {
-            packetSink.accept(interpolationDelayWatcher, interpolationDelay);
+            packetSink.add(interpolationDelayWatcher, interpolationDelay);
         }
     }
 
@@ -222,9 +217,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Byte> billboardWatcher = new EntityDataAccessor<>(15, EntityDataSerializers.BYTE);
 
-    private void getBillboard(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getBillboard(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || billboard != Display.Billboard.FIXED) {
-            packetSink.accept(billboardWatcher, (byte) billboard.ordinal());
+            packetSink.add(billboardWatcher, (byte) billboard.ordinal());
         }
     }
 
@@ -235,9 +230,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Integer> glowColorOverrideWatcher = new EntityDataAccessor<>(22, EntityDataSerializers.INT);
 
-    private void getGlowColorOverride(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getGlowColorOverride(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || glowColorOverride != null) {
-            packetSink.accept(glowColorOverrideWatcher, glowColorOverride == null ? -1 : glowColorOverride.asARGB());
+            packetSink.add(glowColorOverrideWatcher, glowColorOverride == null ? -1 : glowColorOverride.asARGB());
         }
     }
 
@@ -248,9 +243,9 @@ public abstract class RDisplay extends REntity {
 
     private static final EntityDataAccessor<Integer> brightnessWatcher = new EntityDataAccessor<>(16, EntityDataSerializers.INT);
 
-    private void getBrightness(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getBrightness(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || brightness != null) {
-            packetSink.accept(brightnessWatcher, brightness == null ? -1 : brightness.getBlockLight() << 4 | brightness.getSkyLight() << 20);
+            packetSink.add(brightnessWatcher, brightness == null ? -1 : brightness.getBlockLight() << 4 | brightness.getSkyLight() << 20);
         }
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/REntity.java

@@ -20,13 +20,12 @@
 package de.steamwar.entity;
 
 import com.mojang.datafixers.util.Pair;
-import de.steamwar.Reflection;
-import de.steamwar.core.BountifulWrapper;
-import de.steamwar.core.FlatteningWrapper;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import lombok.Getter;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.contents.PlainTextContents;
 import net.minecraft.network.protocol.game.*;
 import net.minecraft.network.syncher.EntityDataAccessor;
 import net.minecraft.network.syncher.EntityDataSerializers;
@@ -44,7 +43,6 @@ import org.bukkit.inventory.ItemStack;
 
 import java.util.*;
 import java.util.function.Consumer;
-import java.util.function.Function;
 
 public class REntity {
 
@@ -174,14 +172,10 @@ public class REntity {
         server.postEntityMove(this, fromX, fromZ);
     }
 
-    private static final Class<?> animationPacket = ClientboundAnimatePacket.class;
-    private static final Reflection.Field<Integer> animationEntity = Reflection.getField(animationPacket, int.class, 5);
-    private static final Reflection.Field<Integer> animationAnimation = Reflection.getField(animationPacket, int.class, 6);
-
     public void showAnimation(byte animation) {
-        Object packet = Reflection.newInstance(animationPacket);
+        ClientboundAnimatePacket packet = new ClientboundAnimatePacket();
-        animationEntity.set(packet, entityId);
+        packet.id = entityId;
-        animationAnimation.set(packet, (int) animation);
+        packet.action = animation;
         server.updateEntity(this, packet);
     }
 
@@ -189,25 +183,21 @@ public class REntity {
         server.updateEntity(this, new ClientboundSetEntityMotionPacket(entityId, new Vec3(calcVelocity(dX), calcVelocity(dY), calcVelocity(dZ))));
     }
 
-    private static final Class<?> statusPacket = ClientboundEntityEventPacket.class;
-    private static final Reflection.Field<Integer> statusEntity = Reflection.getField(statusPacket, int.class, 0);
-    private static final Reflection.Field<Byte> statusStatus = Reflection.getField(statusPacket, byte.class, 0);
-
     public void showDamage() {
-        Object packet = Reflection.newInstance(statusPacket);
+        ClientboundEntityEventPacket packet = new ClientboundEntityEventPacket();
-        statusEntity.set(packet, entityId);
+        packet.entityId = entityId;
-        statusStatus.set(packet, (byte) 2);
+        packet.eventId = (byte) 2;
         server.updateEntity(this, packet);
     }
 
     public void setPose(Pose pose) {
         this.pose = pose;
-        server.updateEntity(this, getDataWatcherPacket(poseDataWatcher, pose));
+        server.updateEntity(this, entityDataPacket().add(poseDataWatcher, pose).build());
     }
 
     public void setOnFire(boolean perma) {
         fireTick = perma ? -1 : 21;
-        server.updateEntity(this, getDataWatcherPacket(entityStatusWatcher, getEntityStatus()));
+        server.updateEntity(this, entityDataPacket().add(entityStatusWatcher, getEntityStatus()).build());
     }
 
     public boolean isOnFire() {
@@ -216,20 +206,18 @@ public class REntity {
 
     public void setInvisible(boolean invisible) {
         this.invisible = invisible;
-        server.updateEntity(this, getDataWatcherPacket(entityStatusWatcher, getEntityStatus()));
+        server.updateEntity(this, entityDataPacket().add(entityStatusWatcher, getEntityStatus()).build());
     }
 
     public void setBowDrawn(boolean drawn, boolean offHand) {
         bowDrawn = drawn;
-        server.updateEntity(this, getDataWatcherPacket(poseDataWatcher, Pose.SHOOTING));
+        server.updateEntity(this, entityDataPacket().add(poseDataWatcher, Pose.SHOOTING).build());
     }
 
     public void setDisplayName(String displayName) {
         this.displayName = displayName;
-        server.updateEntity(this, getDataWatcherPacket(
+        server.updateEntity(this, entityDataPacket().add(nameWatcher, formatDisplayName(displayName))
-                nameWatcher, FlatteningWrapper.formatDisplayName(displayName),
+                .add(nameVisibleWatcher, displayName != null).build());
-                nameVisibleWatcher, displayName != null
-        ));
     }
 
     public void setItem(Object slot, ItemStack stack) {
@@ -243,22 +231,18 @@ public class REntity {
 
     public void setNoGravity(boolean noGravity) {
         this.noGravity = noGravity;
-        server.updateEntity(this, getDataWatcherPacket(noGravityDataWatcher, noGravity));
+        server.updateEntity(this, entityDataPacket().add(noGravityDataWatcher, noGravity).build());
     }
 
     public void setGlowing(boolean glowing) {
         this.isGlowing = glowing;
-        server.updateEntity(this, getDataWatcherPacket(entityStatusWatcher, getEntityStatus()));
+        server.updateEntity(this, entityDataPacket().add(entityStatusWatcher, getEntityStatus()).build());
     }
 
-    private static final Function<REntity, Object> spawnPacketGenerator = entitySpawnPacketGenerator(ClientboundAddEntityPacket.class, 2);
+    private ClientboundAddEntityPacket spawnPacketGenerator() {
-
+        ResourceLocation key = CraftNamespacedKey.toMinecraft(entityType.getKey());
-    private static final Reflection.Field<Integer> additionalData = Reflection.getField(ClientboundAddEntityPacket.class, int.class, 4);
+        net.minecraft.world.entity.EntityType<?> entityType = BuiltInRegistries.ENTITY_TYPE.get(key).get().value();
-
+        return new ClientboundAddEntityPacket(entityId, uuid, x, y, z, pitch, yaw, entityType, objectData, Vec3.ZERO, 0);
-    private Object spawnPacketGenerator() {
-        Object packet = spawnPacketGenerator.apply(this);
-        additionalData.set(packet, objectData);
-        return packet;
     }
 
     void list(Consumer<Object> packetSink) {
@@ -276,20 +260,22 @@ public class REntity {
         }
 
         if (pose != Pose.STANDING) {
-            packetSink.accept(getDataWatcherPacket(poseDataWatcher, pose));
+            entityDataPacket().add(poseDataWatcher, pose).send(packetSink);
         }
 
         byte status = getEntityStatus();
         if (status != 0) {
-            packetSink.accept(getDataWatcherPacket(entityStatusWatcher, getEntityStatus()));
+            entityDataPacket().add(entityStatusWatcher, getEntityStatus()).send(packetSink);
         }
 
         if (displayName != null) {
-            packetSink.accept(getDataWatcherPacket(nameWatcher, FlatteningWrapper.formatDisplayName(displayName), nameVisibleWatcher, true));
+            entityDataPacket().add(nameWatcher, formatDisplayName(displayName))
+                    .add(nameVisibleWatcher, true)
+                    .send(packetSink);
         }
 
         if (noGravity) {
-            packetSink.accept(getDataWatcherPacket(noGravityDataWatcher, true));
+            entityDataPacket().add(noGravityDataWatcher, true).send(packetSink);
         }
     }
 
@@ -297,7 +283,7 @@ public class REntity {
         if (fireTick > 0) {
             fireTick--;
             if (fireTick == 0) {
-                server.updateEntity(this, getDataWatcherPacket(entityStatusWatcher, getEntityStatus()));
+                server.updateEntity(this, entityDataPacket().add(entityStatusWatcher, getEntityStatus()).build());
             }
         }
     }
@@ -328,13 +314,29 @@ public class REntity {
         return status;
     }
 
-    protected Object getDataWatcherPacket(Object... dataWatcherKeyValues) {
+    protected EntityDataPacketBuilder entityDataPacket() {
-        ArrayList<SynchedEntityData.DataValue<?>> nativeWatchers = new ArrayList<>(1);
+        return new EntityDataPacketBuilder();
-        for (int i = 0; i < dataWatcherKeyValues.length; i += 2) {
+    }
-            nativeWatchers.add(((SynchedEntityData.DataItem<?>) BountifulWrapper.impl.getDataWatcherItem(dataWatcherKeyValues[i], dataWatcherKeyValues[i + 1])).value());
+
+    public class EntityDataPacketBuilder {
+        private List<SynchedEntityData.DataValue<?>> values = new ArrayList<>();
+
+        public <T> EntityDataPacketBuilder add(EntityDataAccessor<T> accessor, T value) {
+            values.add(new SynchedEntityData.DataItem<>(accessor, value).value());
+            return this;
         }
 
-        return new ClientboundSetEntityDataPacket(entityId, nativeWatchers);
+        public boolean isEmpty() {
+            return values.isEmpty();
+        }
+
+        public ClientboundSetEntityDataPacket build() {
+            return new ClientboundSetEntityDataPacket(entityId, values);
+        }
+
+        public void send(Consumer<Object> packetSink) {
+            packetSink.accept(build());
+        }
     }
 
     private Object getTeleportPacket() {
@@ -359,14 +361,10 @@ public class REntity {
         }
     }
 
-    private static final Class<?> headRotationPacket = ClientboundRotateHeadPacket.class;
-    private static final Reflection.Field<Integer> headRotationEntity = Reflection.getField(headRotationPacket, int.class, 0);
-    private static final Reflection.Field<Byte> headRotationYaw = Reflection.getField(headRotationPacket, byte.class, 0);
-
     private Object getHeadRotationPacket() {
-        Object packet = Reflection.newInstance(headRotationPacket);
+        ClientboundRotateHeadPacket packet = new ClientboundRotateHeadPacket();
-        headRotationEntity.set(packet, entityId);
+        packet.entityId = entityId;
-        headRotationYaw.set(packet, headYaw);
+        packet.yHeadRot = headYaw;
         return packet;
     }
 
@@ -374,33 +372,6 @@ public class REntity {
         return new ClientboundSetEquipmentPacket(entityId, Collections.singletonList(Pair.of((EquipmentSlot) slot, CraftItemStack.asNMSCopy(stack))));
     }
 
-    private static final Reflection.Field<net.minecraft.world.entity.EntityType> spawnType = Reflection.getField(ClientboundAddEntityPacket.class, net.minecraft.world.entity.EntityType.class, 0);
-
-    private static Function<REntity, Object> entitySpawnPacketGenerator(Class<?> spawnPacket, int posOffset) {
-        BountifulWrapper.UUIDSetter uuid = BountifulWrapper.impl.getUUIDSetter(spawnPacket);
-        Function<REntity, Object> packetGenerator = spawnPacketGenerator(spawnPacket, posOffset);
-
-        return entity -> {
-            Object packet = packetGenerator.apply(entity);
-            uuid.set(packet, entity.uuid);
-            ResourceLocation key = CraftNamespacedKey.toMinecraft(entity.entityType.getKey());
-            spawnType.set(packet, BuiltInRegistries.ENTITY_TYPE.get(key).get().value());
-            return packet;
-        };
-    }
-
-    protected static Function<REntity, Object> spawnPacketGenerator(Class<?> spawnPacket, int posOffset) {
-        Reflection.Field<Integer> entityId = Reflection.getField(spawnPacket, int.class, 0);
-        BountifulWrapper.PositionSetter position = BountifulWrapper.impl.getPositionSetter(spawnPacket, posOffset);
-
-        return entity -> {
-            Object packet = Reflection.newInstance(spawnPacket);
-            entityId.set(packet, entity.entityId);
-            position.set(packet, entity.x, entity.y, entity.z, entity.pitch, entity.yaw);
-            return packet;
-        };
-    }
-
     private byte rotToByte(float rot) {
         return (byte) ((int) (rot * 256.0F / 360.0F));
     }
@@ -408,4 +379,8 @@ public class REntity {
     private int calcVelocity(double value) {
         return (int) (Math.max(-3.9, Math.min(value, 3.9)) * 8000);
     }
+
+    private static Optional<Component> formatDisplayName(String displayName) {
+        return displayName != null ? Optional.of(MutableComponent.create(PlainTextContents.create(displayName))) : Optional.empty();
+    }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RFallingBlockEntity.java

@@ -20,7 +20,6 @@
 package de.steamwar.entity;
 
 import de.steamwar.techhider.BlockIds;
-import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.Location;

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RInteraction.java

@@ -19,14 +19,13 @@
 
 package de.steamwar.entity;
 
-import de.steamwar.core.BountifulWrapper;
 import lombok.Getter;
 import lombok.Setter;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.network.syncher.EntityDataSerializers;
 import org.bukkit.Location;
 import org.bukkit.entity.EntityType;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
@@ -61,18 +60,13 @@ public class RInteraction extends REntity implements RInteractableEntity<RIntera
     }
 
     @SafeVarargs
-    protected final void sendPacket(Consumer<Object> packetSink, BiConsumer<Boolean, BiConsumer<Object, Object>>... dataSinkSinks) {
+    protected final void sendPacket(Consumer<Object> packetSink, BiConsumer<Boolean, EntityDataPacketBuilder>... dataSinkSinks) {
-        List<Object> keyValueData = new ArrayList<>();
+        EntityDataPacketBuilder builder = entityDataPacket();
         boolean ignoreDefault = packetSink == updatePacketSink;
-        for (BiConsumer<Boolean, BiConsumer<Object, Object>> dataSinkSink : dataSinkSinks) {
+        for (BiConsumer<Boolean, EntityDataPacketBuilder> dataSinkSink : dataSinkSinks) {
-            dataSinkSink.accept(ignoreDefault, (dataWatcher, value) -> {
+            dataSinkSink.accept(ignoreDefault, builder);
-                keyValueData.add(dataWatcher);
-                keyValueData.add(value);
-            });
-        }
-        if (!keyValueData.isEmpty()) {
-            packetSink.accept(getDataWatcherPacket(keyValueData.toArray()));
         }
+        if (!builder.isEmpty()) builder.send(packetSink);
     }
 
     public void setInteractionWidth(float interactionWidth) {
@@ -80,11 +74,11 @@ public class RInteraction extends REntity implements RInteractableEntity<RIntera
         sendPacket(updatePacketSink, this::getInteractionWidthData);
     }
 
-    private static final Object interactionWidthWatcher = BountifulWrapper.impl.getDataWatcherObject(8, Float.class);
+    private static final EntityDataAccessor<Float> interactionWidthWatcher = new EntityDataAccessor<>(8, EntityDataSerializers.FLOAT);
 
-    private void getInteractionWidthData(boolean ignoreDefault, BiConsumer<Object, Object> dataSink) {
+    private void getInteractionWidthData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
         if (ignoreDefault || interactionWidth != 1.0) {
-            dataSink.accept(interactionWidthWatcher, interactionWidth);
+            dataSink.add(interactionWidthWatcher, interactionWidth);
         }
     }
 
@@ -93,11 +87,11 @@ public class RInteraction extends REntity implements RInteractableEntity<RIntera
         sendPacket(updatePacketSink, this::getInteractionHeightData);
     }
 
-    private static final Object interactionHeightWatcher = BountifulWrapper.impl.getDataWatcherObject(9, Float.class);
+    private static final EntityDataAccessor<Float> interactionHeightWatcher = new EntityDataAccessor<>(9, EntityDataSerializers.FLOAT);
 
-    private void getInteractionHeightData(boolean ignoreDefault, BiConsumer<Object, Object> dataSink) {
+    private void getInteractionHeightData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
         if (ignoreDefault || interactionHeight != 1.0) {
-            dataSink.accept(interactionHeightWatcher, interactionHeight);
+            dataSink.add(interactionHeightWatcher, interactionHeight);
         }
     }
 
@@ -106,11 +100,11 @@ public class RInteraction extends REntity implements RInteractableEntity<RIntera
         sendPacket(updatePacketSink, this::getResponsiveData);
     }
 
-    private static final Object responsiveWatcher = BountifulWrapper.impl.getDataWatcherObject(10, Boolean.class);
+    private static final EntityDataAccessor<Boolean> responsiveWatcher = new EntityDataAccessor<>(10, EntityDataSerializers.BOOLEAN);
 
-    private void getResponsiveData(boolean ignoreDefault, BiConsumer<Object, Object> dataSink) {
+    private void getResponsiveData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
         if (ignoreDefault || !responsive) {
-            dataSink.accept(responsiveWatcher, responsive);
+            dataSink.add(responsiveWatcher, responsive);
         }
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RItemDisplay.java

@@ -63,9 +63,9 @@ public class RItemDisplay extends RDisplay {
 
     private static final EntityDataAccessor<net.minecraft.world.item.ItemStack> itemStackWatcher = new EntityDataAccessor<>(23, EntityDataSerializers.ITEM_STACK);
 
-    private void getItemStack(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getItemStack(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || !itemStack.equals(DEFAULT_ITEM_STACK)) {
-            packetSink.accept(itemStackWatcher, CraftItemStack.asNMSCopy(itemStack));
+            packetSink.add(itemStackWatcher, CraftItemStack.asNMSCopy(itemStack));
         }
     }
 
@@ -76,9 +76,9 @@ public class RItemDisplay extends RDisplay {
         sendPacket(updatePacketSink, this::getItemDisplayTransform);
     }
 
-    private void getItemDisplayTransform(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getItemDisplayTransform(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || itemDisplayTransform != ItemDisplay.ItemDisplayTransform.NONE) {
-            packetSink.accept(itemDisplayTransformWatcher, (byte) itemDisplayTransform.ordinal());
+            packetSink.add(itemDisplayTransformWatcher, (byte) itemDisplayTransform.ordinal());
         }
     }
 }