Move listener to permanent

Signed-off-by: Chaoscaot <max@maxsp.de>

.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/features/design/endstone/DesignEndStone.java

@@ -21,9 +21,7 @@ package de.steamwar.bausystem.features.design.endstone;
 
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.region.Region;
-import de.steamwar.entity.REntity;
-import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
+import de.steamwar.entity.*;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -59,15 +57,15 @@ public class DesignEndStone {
                 .filter(material -> material.getBlastResistance() > region.getGameModeConfig().Schematic.MaxDesignBlastResistance)
                 .collect(Collectors.toSet());
         calculateFromBottom = region.getGameModeConfig().Arena.NoFloor;
+    }
 
-        entityServer.setCallback((player, rEntity, entityAction) -> {
-            if (entityAction != REntityServer.EntityAction.ATTACK) return;
-            Location location = new Location(WORLD, rEntity.getX(), rEntity.getY(), rEntity.getZ());
-            Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-                location.getBlock().breakNaturally();
-                calc();
-            }, 1);
-        });
+    private void interact(Player player, RInteraction entity, REntityAction action) {
+        if (action != REntityAction.ATTACK) return;
+        Location location = new Location(WORLD, entity.getX(), entity.getY(), entity.getZ());
+        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
+            location.getBlock().breakNaturally();
+            calc();
+        }, 1);
     }
 
     public void calc() {
@@ -110,12 +108,15 @@ public class DesignEndStone {
                         Material material = WORLD.getBlockAt(cx, cy, cz).getType();
 
                         if (material != Material.WATER && material != Material.LAVA && limited.contains(material)) {
-                            Location location = new Location(WORLD, cx + 0.5, cy, cz + 0.5);
+                            Location location = new Location(WORLD, cx, cy, cz);
                             if (!locations.add(location)) break;
-                            RFallingBlockEntity entity = new RFallingBlockEntity(entityServer, location, Material.RED_STAINED_GLASS);
-                            entity.setNoGravity(true);
+                            RBlockDisplay entity = new RBlockDisplay(entityServer, location);
+                            entity.setBlock(Material.RED_STAINED_GLASS.createBlockData());
                             entity.setGlowing(true);
                             entities.add(entity);
+                            RInteraction interaction = new RInteraction(entityServer, location);
+                            interaction.setCallback(this::interact);
+                            entities.add(interaction);
                             break;
                         } else if (!material.isAir() && material != Material.WATER && material != Material.LAVA) {
                             break;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/detonator/Detonator.java

@@ -26,8 +26,9 @@ import de.steamwar.bausystem.features.autostart.AutostartListener;
 import de.steamwar.bausystem.features.detonator.storage.DetonatorStorage;
 import de.steamwar.bausystem.features.detonator.storage.ItemStorage;
 import de.steamwar.core.SWPlayer;
+import de.steamwar.entity.RBlockDisplay;
 import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
+import de.steamwar.entity.RInteraction;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.experimental.UtilityClass;
@@ -58,10 +59,6 @@ public class Detonator {
         @Override
         public void onMount(SWPlayer player) {
             entities.addPlayer(player.getPlayer());
-            entities.setCallback((player1, entity, action) -> {
-                Vector vector = new Vector(entity.getX(), entity.getY(), entity.getZ());
-                DetonatorListener.addLocationToDetonator(vector.toLocation(player.getWorld()).getBlock().getLocation(), player1);
-            });
         }
 
         @Override
@@ -70,8 +67,6 @@ public class Detonator {
         }
     }
 
-    private static final Vector HALF = new Vector(0.5, 0, 0.5);
-
     public static boolean isDetonator(ItemStack itemStack) {
         return ItemStorage.isDetonator(itemStack);
     }
@@ -79,8 +74,14 @@ public class Detonator {
     public static void showDetonator(Player p, List<Location> locs) {
         DetonatorComponent detonatorComponent = SWPlayer.of(p).getComponentOrDefault(DetonatorComponent.class, DetonatorComponent::new);
         locs.forEach(location -> {
-            RFallingBlockEntity entity = new RFallingBlockEntity(detonatorComponent.entities, location.clone().add(HALF), Material.RED_STAINED_GLASS);
-            entity.setNoGravity(true);
+            RBlockDisplay blockDisplay = new RBlockDisplay(detonatorComponent.entities, location);
+            blockDisplay.setBlock(Material.RED_STAINED_GLASS.createBlockData());
+
+            RInteraction interaction = new RInteraction(detonatorComponent.entities, location);
+            interaction.setCallback((player, entity, action) -> {
+                Vector vector = new Vector(entity.getX(), entity.getY(), entity.getZ());
+                DetonatorListener.addLocationToDetonator(vector.toLocation(player.getWorld()).getBlock().getLocation(), player);
+            });
         });
     }
 

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,20 +17,15 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.bausystem.utils;
+package de.steamwar.bausystem.features.experimental;
 
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
 
-public class TickEndEvent extends Event {
+@Linked
+public class ExperimentalCommand extends SWCommand {
 
-    private static final HandlerList handlers = new HandlerList();
-
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
+    public ExperimentalCommand() {
+        super("experimental", "experiment");
     }
 }

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/killchecker/KillcheckerVisualizer.java

@@ -24,9 +24,9 @@ import de.steamwar.bausystem.region.Point;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.utils.bossbar.BauSystemBossbar;
 import de.steamwar.bausystem.utils.bossbar.BossBarService;
+import de.steamwar.entity.RBlockDisplay;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.World;
@@ -290,8 +290,8 @@ public class KillcheckerVisualizer {
                 }
                 rEntities.get(point).die();
             }
-            RFallingBlockEntity entity = new RFallingBlockEntity(outlinePoints.contains(point) ? outline : inner, point.toLocation(WORLD, 0.5, 0, 0.5), MATERIALS[Math.min(count - 1, MATERIALS.length) - 1]);
-            entity.setNoGravity(true);
+            RBlockDisplay entity = new RBlockDisplay(outlinePoints.contains(point) ? outline : inner, point.toLocation(WORLD, 0.5, 0, 0.5));
+            entity.setBlock(MATERIALS[Math.min(count - 1, MATERIALS.length) - 1].createBlockData());
             rEntities.put(point, entity);
             if (outlinePoints.contains(point)) outlinePointsCache.add(point);
             killCount.put(point, count);

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 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<>();
+    private static final Map<Player, CursorType> cursorType = Collections.synchronizedMap(new HashMap<>());
+    private static final Map<Player, REntityServer> emptyTargetServers = Collections.synchronizedMap(new HashMap<>());
 
     public static boolean isSimulatorItem(ItemStack itemStack) {
         return ItemUtils.isItem(itemStack, "simulator");
     }
 
-    public SimulatorCursor() {
-        BiFunction<Player, ServerboundMovePlayerPacket, Object> function = (player, object) -> {
-            calcCursor(player);
-            return object;
-        };
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Rot.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, function);
+    private static boolean hasSimulatorItem(Player player) {
+        return isSimulatorItem(player.getInventory().getItemInMainHand()) || isSimulatorItem(player.getInventory().getItemInOffHand());
+    }
+
+    private static void scheduleCursorUpdate(Player player) {
+        BauSystem.runTaskLater(BauSystem.getInstance(), () -> calcCursor(player), 1);
     }
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            calcCursor(event.getPlayer());
-        }, 0);
+        scheduleCursorUpdate(event.getPlayer());
     }
 
     @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(), () -> {
-            calcCursor(event.getPlayer());
-        }, 1);
+        scheduleCursorUpdate(event.getPlayer());
+    }
+
+    @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());
-        synchronized (calculating) {
-            calculating.remove(event.getPlayer());
-        }
+        removeCursor(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 (calculating.contains(player)) return;
-            calculating.add(player);
-        }
-        if (!Permission.BUILD.hasPermission(player) || (!isSimulatorItem(player.getInventory().getItemInMainHand()) && !isSimulatorItem(player.getInventory().getItemInOffHand()))) {
-            if (removeCursor(player) || SimulatorWatcher.show(null, player)) {
+        if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
+            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);
-        RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(player, player.getLocation(), entities);
-        if (rayTraceResult == null) {
-            removeCursor(player);
-            if (simulator == null) {
-                SWUtils.sendToActionbar(player, "§eSelect Simulator");
-            } else {
-                SWUtils.sendToActionbar(player, "§eOpen Simulator");
-            }
-            synchronized (calculating) {
-                calculating.remove(player);
-            }
-            return;
+        Cursor cursor = getOrCreateCursor(player, simulator, cursorType.getOrDefault(player, CursorType.TNT));
+        cursor.renderDeduplicated();
+    }
+
+    private static Cursor getOrCreateCursor(Player player, Simulator simulator, CursorType type) {
+        REntityServer targetServer = simulator == null ? emptyTargetServers.computeIfAbsent(player, __ -> new REntityServer()) : SimulatorWatcher.getEntityServerOfSimulator(simulator);
+        SWPlayer swPlayer = SWPlayer.of(player);
+        Optional<Cursor> activeCursor = swPlayer.getComponent(Cursor.class);
+
+        Cursor cursor = activeCursor.orElse(null);
+        if (cursor == null || cursor.getTargetServer() != targetServer) {
+            swPlayer.removeComponent(Cursor.class);
+            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);
-        synchronized (calculating) {
-            calculating.remove(player);
-        }
+        return cursor;
     }
 
     private static synchronized boolean removeCursor(Player player) {
-        REntityServer entityServer = cursors.get(player);
-        boolean hadCursor = entityServer != null && !entityServer.getEntities().isEmpty();
-        if (entityServer != null) {
-            entityServer.getEntities().forEach(REntity::die);
+        Optional<Cursor> cursor = SWPlayer.of(player).getComponent(Cursor.class);
+        cursor.ifPresent(__ -> SWPlayer.of(player).removeComponent(Cursor.class));
+        REntityServer emptyTargetServer = emptyTargetServers.remove(player);
+        if (emptyTargetServer != null) {
+            emptyTargetServer.close();
         }
-        return hadCursor;
+        return cursor.isPresent();
     }
 
-    private static synchronized void showCursor(Player player, RayTraceUtils.RRayTraceResult rayTraceResult, boolean hasSimulatorSelected) {
-        REntityServer entityServer = cursors.computeIfAbsent(player, __ -> {
-            REntityServer rEntityServer = new REntityServer();
-            rEntityServer.addPlayer(player);
-            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 {
+    private static void sendCursorActionbar(Player player, Simulator simulator, boolean hasCursorLocation, boolean hasHitEntity) {
+        if (!hasCursorLocation) {
+            SWUtils.sendToActionbar(player, simulator == null ? "§eSelect Simulator" : "§eOpen Simulator");
+        } else if (simulator == null) {
             SWUtils.sendToActionbar(player, "§eCreate new Simulator");
-        }
-    }
-
-    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 if (hasHitEntity) {
+            SWUtils.sendToActionbar(player, "§eEdit Position");
         } 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())),
-        REDSTONE_BLOCK(Material.REDSTONE_BLOCK, Material.REDSTONE, SimulatorCursor::getPosBlockAligned, "Redstone Block", vector -> new RedstoneElement(vector).add(new RedstonePhase())),
-        OBSERVER(Material.OBSERVER, Material.QUARTZ, SimulatorCursor::getPosBlockAligned, "Observer", vector -> new ObserverElement(vector).add(new ObserverPhase())),
+        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, List.of(Cursor.CursorMode.BLOCK_ALIGNED), "Redstone Block", vector -> new RedstoneElement(vector).add(new RedstonePhase())),
+        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
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!ItemUtils.isItem(event.getItem(), "simulator")) {
+    private static void handlePlayerClick(Player player, Location cursorLocation, Optional<REntity> hitEntity, Action action) {
+        if (!Permission.BUILD.hasPermission(player)) return;
+        if (!hasSimulatorItem(player)) {
             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) {
-            REntity hitEntity = rayTraceResult.getHitEntity();
-            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;
-            }
+        if (hitEntity.isPresent()) {
+            openElement(player, simulator, hitEntity.get());
             return;
         }
 
-        // Add new Element to current simulator
-        createElement(player, rayTraceResult, simulator);
+        createElement(player, cursorLocation, 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;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/tpslimit/TPSSystem.java

@@ -19,13 +19,13 @@
 
 package de.steamwar.bausystem.features.tpslimit;
 
+import com.destroystokyo.paper.event.server.ServerTickEndEvent;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.SWUtils;
 import de.steamwar.bausystem.linkage.BauGuiItem;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.utils.ScoreboardElement;
-import de.steamwar.bausystem.utils.TickEndEvent;
 import de.steamwar.bausystem.utils.TickManager;
 import de.steamwar.bausystem.utils.bossbar.BauSystemBossbar;
 import de.steamwar.bausystem.utils.bossbar.BossBarService;
@@ -72,7 +72,7 @@ public class TPSSystem implements Listener {
     }
 
     @EventHandler
-    public void onTickEnd(TickEndEvent event) {
+    public void onTickEnd(ServerTickEndEvent event) {
         bossbar();
     }
 

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

@@ -143,14 +143,6 @@ public class Trace {
         } else {
             entityServer = new REntityServer();
             entityServer.addPlayer(player);
-            entityServer.setCallback((p, rEntity, entityAction) -> {
-                if (entityAction != REntityServer.EntityAction.INTERACT) {
-                    return;
-                }
-                if (rEntity instanceof TraceEntity) {
-                    ((TraceEntity) rEntity).printIntoChat(p);
-                }
-            });
             entityServerMap.put(player, entityServer);
         }
         render(getRecords(), entityServer, playerTraceShowData);
@@ -167,14 +159,6 @@ public class Trace {
         REntityServer entityServer = entityServerMap.computeIfAbsent(player, k -> {
             REntityServer newEntityServer = new REntityServer();
             newEntityServer.addPlayer(k);
-            newEntityServer.setCallback((p, rEntity, entityAction) -> {
-                if (entityAction != REntityServer.EntityAction.INTERACT) {
-                    return;
-                }
-                if (rEntity instanceof TraceEntity) {
-                    ((TraceEntity) rEntity).printIntoChat(p);
-                }
-            });
             return newEntityServer;
         });
 

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/tracer/rendering/TraceEntity.java

@@ -24,13 +24,18 @@ import de.steamwar.bausystem.configplayer.Config;
 import de.steamwar.bausystem.features.tracer.TNTPoint;
 import de.steamwar.bausystem.features.tracer.Trace;
 import de.steamwar.bausystem.features.tracer.TraceManager;
+import de.steamwar.entity.RBlockDisplay;
+import de.steamwar.entity.REntityAction;
 import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
+import de.steamwar.entity.RInteraction;
 import lombok.Getter;
 import net.md_5.bungee.api.chat.ClickEvent;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
+import org.bukkit.util.Transformation;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
 import yapion.hierarchy.types.YAPIONValue;
 
 import java.util.List;
@@ -41,7 +46,16 @@ import static de.steamwar.bausystem.features.util.TNTClickListener.TNT_CLICK_DET
 /**
  * Wrapper for the rendering of a record bundle
  */
-public class TraceEntity extends RFallingBlockEntity {
+public class TraceEntity extends RBlockDisplay {
+
+    private static final float TNT_VISUAL_SCALE = 0.98F;
+    private static final float TNT_VISUAL_OFFSET = -TNT_VISUAL_SCALE / 2.0F;
+    private static final Transformation TNT_VISUAL_TRANSFORM = new Transformation(
+            new Vector3f(TNT_VISUAL_OFFSET, 0.0F, TNT_VISUAL_OFFSET),
+            new Quaternionf(0, 0, 0, 1),
+            new Vector3f(TNT_VISUAL_SCALE, TNT_VISUAL_SCALE, TNT_VISUAL_SCALE),
+            new Quaternionf(0, 0, 0, 1)
+    );
 
     /**
      * The records represented by this REntity
@@ -55,13 +69,31 @@ public class TraceEntity extends RFallingBlockEntity {
     private final String uniqueTntIdsString;
 
     private final Trace trace;
+    private final RInteraction hitbox;
 
     public TraceEntity(REntityServer server, Location location, boolean isExplosion, List<TNTPoint> records, Trace trace) {
-        super(server, location, isExplosion ? Material.RED_STAINED_GLASS : Material.TNT);
+        super(server, location);
+        Material material = isExplosion ? Material.RED_STAINED_GLASS : Material.TNT;
         this.records = records;
         this.trace = trace;
         uniqueTntIdsString = records.stream().map(TNTPoint::getTntId).distinct().map(Object::toString).collect(Collectors.joining(" "));
-        setNoGravity(true);
+        hitbox = new RInteraction(server, location);
+        hitbox.setInteractionHeight(TNT_VISUAL_SCALE);
+        hitbox.setInteractionWidth(TNT_VISUAL_SCALE);
+        hitbox.setCallback((player, action) -> {
+            if (action == REntityAction.INTERACT) {
+                printIntoChat(player);
+            }
+        });
+        setTransform(TNT_VISUAL_TRANSFORM);
+        setBlock(material.createBlockData());
+
+    }
+
+    @Override
+    public void die() {
+        hitbox.die();
+        super.die();
     }
 
     /**

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/tracer/rendering/ViewFlag.java

@@ -20,8 +20,8 @@
 package de.steamwar.bausystem.features.tracer.rendering;
 
 import de.steamwar.bausystem.features.tracer.TNTPoint;
+import de.steamwar.entity.RBlockDisplay;
 import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.util.Vector;
@@ -129,8 +129,8 @@ public abstract class ViewFlag {
 
                 Location yLocation = previous.getLocation().clone().add(0, delta.getY(), 0);
                 if (yLocation.distanceSquared(representative.getLocation()) >= 1.0 / 256.0 && yLocation.distanceSquared(previous.getLocation()) >= 1.0 / 256.0) {
-                    RFallingBlockEntity y = new RFallingBlockEntity(server, yLocation, Material.WHITE_STAINED_GLASS);
-                    y.setNoGravity(true);
+                    RBlockDisplay y = new RBlockDisplay(server, yLocation);
+                    y.setBlock(Material.WHITE_STAINED_GLASS.createBlockData());
                 }
 
                 Location secoundLocation;
@@ -141,8 +141,8 @@ public abstract class ViewFlag {
                 }
 
                 if (secoundLocation.distanceSquared(representative.getLocation()) >= 1.0 / 256.0 && secoundLocation.distanceSquared(previous.getLocation()) >= 1.0 / 256.0) {
-                    RFallingBlockEntity second = new RFallingBlockEntity(server, secoundLocation, Material.WHITE_STAINED_GLASS);
-                    second.setNoGravity(true);
+                    RBlockDisplay second = new RBlockDisplay(server, secoundLocation);
+                    second.setBlock(Material.WHITE_STAINED_GLASS.createBlockData());
                 }
             }
         }

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;
-
-    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 CommandMap commandMap = ((CraftServer) Bukkit.getServer()).getCommandMap();
 
     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)

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

@@ -28,6 +28,7 @@ import de.steamwar.bausystem.utils.bossbar.BossBarService;
 import de.steamwar.linkage.Linked;
 import de.steamwar.network.packets.PacketHandler;
 import de.steamwar.network.packets.server.BaumemberUpdatePacket;
+import io.papermc.paper.event.player.PlayerPickBlockEvent;
 import org.bukkit.Bukkit;
 import org.bukkit.boss.BarColor;
 import org.bukkit.boss.BarStyle;
@@ -127,4 +128,11 @@ public class BauMemberUpdate extends PacketHandler implements Listener {
             }
         }, 1);
     }
+
+    @EventHandler
+    public void onPlayerClick(PlayerPickBlockEvent event) {
+        if(SPECTATORS.contains(event.getPlayer())) {
+            event.setCancelled(true);
+        }
+    }
 }

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;

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;

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()));
-            worldAccessor.set(blockState, blockLocation.getWorld());
+            CraftBlockState craftBlockState = (CraftBlockState) blockState;
+            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);
-        RegionSelector regionSelector = (RegionSelector) constructorInvoker.invoke(BukkitAdapter.adapt(player.getWorld()));
+        Function<World, RegionSelector> constructor = constructors.get(clazz);
+        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/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)
-        val serverDir =
-            if (serverDirectory.exists() && serverDirectory.isDirectory) serverDirectory else File(workingDir, server)
+        var serverDir = resolveServerDirectory(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")
-            val jarFile = jar?.absolutePath
+                ?: File(workingDir, "devtempworld")
+            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 20
+        "Lobby" to 21
     )
 
     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()
     }
-}
+}

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;
@@ -110,6 +113,7 @@ public class FightSystem extends JavaPlugin {
 
         hullHider = new HullHider();
         techHider = new TechHiderWrapper(hullHider);
+        FightSystem.getHullHider().getHullMap().values().forEach(hull -> hull.fill(true));
 
 
         FileSource.startReplay();

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/FightSchematic.java

@@ -158,6 +158,8 @@ public class FightSchematic extends StateDependent {
         FreezeWorld freezer = new FreezeWorld();
 
         team.teleportToSpawn();
+        // TODO: Implement hull generation based on clipboard content!
+        FightSystem.getHullHider().fill(team, false);
         Vector dims = WorldeditWrapper.impl.getDimensions(clipboard);
         WorldeditWrapper.impl.pasteClipboard(
                 clipboard,

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/fight/FightWorld.java

@@ -68,6 +68,13 @@ public class FightWorld extends StateDependent {
     }
 
     public static void resetWorld() {
+        World backup = new WorldCreator(Config.world.getName() + "/backup").createWorld();
+        assert backup != null;
+        Config.ArenaRegion.forEachChunk((x, z) -> {
+            CraftbukkitWrapper.impl.resetChunk(Config.world, backup, x, z);
+        });
+        Bukkit.unloadWorld(backup, false);
+
         List<Entity> entities = new ArrayList<>();
         Recording.iterateOverEntities(Objects::nonNull, entity -> {
             if (entity.getType() != EntityType.PLAYER && (!Config.GameModeConfig.Arena.Leaveable || Config.ArenaRegion.inRegion(entity.getLocation()))) {
@@ -77,14 +84,12 @@ public class FightWorld extends StateDependent {
         entities.forEach(Entity::remove);
         entities.clear();
 
-        World backup = new WorldCreator(Config.world.getName() + "/backup").createWorld();
-        assert backup != null;
+        FightSystem.getHullHider().getHullMap().values().forEach(hull -> hull.fill(true));
+
         Config.ArenaRegion.forEachChunk((x, z) -> {
-            CraftbukkitWrapper.impl.resetChunk(Config.world, backup, x, z);
             for (Player p : Bukkit.getOnlinePlayers()) {
                 de.steamwar.core.CraftbukkitWrapper.sendChunk(p, x, z);
             }
         });
-        Bukkit.unloadWorld(backup, false);
     }
 }

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

@@ -46,6 +46,7 @@ public class ArrowStopper {
     private void run() {
         Recording.iterateOverEntities(AbstractArrow.class::isInstance, entity -> {
             Projectile arrow = (Projectile) entity;
+            if(!(arrow.getShooter() instanceof Player)) return;
             if (invalidEntity(arrow)) return;
 
             Location prevLocation = arrow.getLocation().toVector().subtract(arrow.getVelocity()).toLocation(arrow.getWorld());

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

@@ -24,6 +24,7 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.utils.CraftbukkitWrapper;
 import de.steamwar.linkage.Linked;
 import net.minecraft.network.protocol.game.ServerboundUseItemOnPacket;
+import net.minecraft.network.protocol.game.ServerboundUseItemPacket;
 import org.bukkit.entity.Player;
 
 import java.io.*;
@@ -42,7 +43,7 @@ public class ClickAnalyzer {
     }
 
     public ClickAnalyzer() {
-        TinyProtocol.instance.addFilter(Recording.blockPlacePacket, this::onBlockPlace);
+        TinyProtocol.instance.addFilter(ServerboundUseItemPacket.class, this::onBlockPlace);
         TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, this::onBlockPlace);
     }
 

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/Permanent.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
@@ -31,17 +31,16 @@ import de.steamwar.linkage.Linked;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
+import org.bukkit.Tag;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.type.Dispenser;
+import org.bukkit.block.data.type.DriedGhast;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.TNTPrimed;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockDispenseEvent;
-import org.bukkit.event.block.BlockFromToEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.block.*;
 import org.bukkit.event.entity.EntityExplodeEvent;
 import org.bukkit.event.entity.FoodLevelChangeEvent;
 import org.bukkit.event.entity.PlayerDeathEvent;
@@ -258,4 +257,16 @@ public class Permanent implements Listener {
         event.setCancelled(true);
         FightSystem.getMessage().sendPrefixless("NO_BLOCK_BREAK", event.getPlayer(), ChatMessageType.ACTION_BAR);
     }
+
+    /**
+     * Prevents Dried Ghast from spawning and plants from growing
+     */
+    @EventHandler
+    public void onBlockGrow(BlockGrowEvent event) {
+        var type = event.getBlock().getType();
+
+        if (event.getBlock().getBlockData() instanceof DriedGhast || Tag.CROPS.isTagged(type) || Tag.SAPLINGS.isTagged(type)) {
+            event.setCancelled(true);
+        }
+    }
 }

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

@@ -1,74 +0,0 @@
-package de.steamwar.fightsystem.listener;
-
-import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentListener;
-import de.steamwar.linkage.Linked;
-import net.minecraft.network.protocol.game.ClientboundForgetLevelChunkPacket;
-import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.LevelChunk;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.CraftWorld;
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-
-@Linked
-public class PlayerJoinListener implements Listener {
-
-    public PlayerJoinListener() {
-        new StateDependentListener(true, FightState.All, this);
-    }
-
-    @EventHandler()
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        Player player = event.getPlayer();
-        World world = player.getWorld();
-
-        Location loc = player.getLocation();
-        int viewDistance = Bukkit.getViewDistance();
-
-        int chunkX = loc.getChunk().getX();
-        int chunkZ = loc.getChunk().getZ();
-
-        // Iterate through the chunks around the player and force a resend
-        for (int x = -viewDistance; x <= viewDistance; x++) {
-            for (int z = -viewDistance; z <= viewDistance; z++) {
-                Chunk chunk = world.getChunkAt(chunkX + x, chunkZ + z);
-                this.forceRefreshChunkForPlayer(player, chunk);
-            }
-        }
-    }
-
-    public void forceRefreshChunkForPlayer(Player player, Chunk bukkitChunk) {
-        ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-        CraftWorld craftWorld = (CraftWorld) bukkitChunk.getWorld();
-
-        int chunkX = bukkitChunk.getX();
-        int chunkZ = bukkitChunk.getZ();
-
-        LevelChunk nmsChunk = craftWorld.getHandle().getChunkSource().getChunk(chunkX, chunkZ, false);
-        if (nmsChunk == null) {
-            // Chunk isn't loaded in memory on the server side;
-            return;
-        }
-
-        ClientboundForgetLevelChunkPacket unloadPacket = new ClientboundForgetLevelChunkPacket(new ChunkPos(chunkX, chunkZ));
-        serverPlayer.connection.send(unloadPacket);
-
-        ClientboundLevelChunkWithLightPacket loadPacket = new ClientboundLevelChunkWithLightPacket(
-                nmsChunk,
-                craftWorld.getHandle().getLightEngine(),
-                null,
-                null,
-                true
-        );
-        serverPlayer.connection.send(loadPacket);
-    }
-}

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;
@@ -114,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(blockPlacePacket, place);
-                TinyProtocol.instance.removeFilter(blockDigPacket, dig);
+                TinyProtocol.instance.removeFilter(ServerboundUseItemPacket.class, place);
+                TinyProtocol.instance.removeFilter(ServerboundPlayerActionPacket.class, dig);
             }
         }.register();
         new StateDependentTask(ArenaMode.AntiReplay, FightState.All, () -> {
@@ -142,20 +141,13 @@ public class Recording implements Listener {
         GlobalRecorder.getInstance().entitySpeed(entity);
     }
 
-    private static final Class<?> blockDigPacket = ServerboundPlayerActionPacket.class;
-    private static final Class<?> playerDigType = blockDigPacket.getDeclaredClasses()[0];
-    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) {
+    private Object blockDig(Player p, ServerboundPlayerActionPacket packet) {
+        if (!isNotSent(p) && packet.getAction() == ServerboundPlayerActionPacket.Action.RELEASE_USE_ITEM) {
             GlobalRecorder.getInstance().bowSpan(p, false, false);
         }
         return packet;
     }
 
-    public static final Class<?> blockPlacePacket = ServerboundUseItemPacket.class;
-
     private Object blockPlace(Player p, ServerboundUseItemPacket packet) {
         boolean mainHand = packet.getHand() == InteractionHand.MAIN_HAND;
         if (!isNotSent(p) && (mainHand ? p.getInventory().getItemInMainHand() : p.getInventory().getItemInOffHand()).getType() == Material.BOW) {

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/Hull.java

@@ -165,6 +165,15 @@ public class Hull {
         rentities.remove(entity);
     }
 
+    public void fill(boolean visible) {
+        visibility.set(0, visibility.size(), visible);
+        occluding.set(0, occluding.size(), !visible);
+        uncoveredSurface.clear();
+        for (BitSet directionalVisibility : visibilityDirections.values()) {
+            directionalVisibility.set(0, directionalVisibility.size(), visible);
+        }
+    }
+
     public void initialize() {
         visibility.clear();
         occluding.clear();

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

@@ -19,8 +19,6 @@
 
 package de.steamwar.fightsystem.utils;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.entity.REntity;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.Fight;
@@ -28,17 +26,9 @@ import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.listener.Recording;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependent;
 import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.fightsystem.states.StateDependentTask;
 import lombok.Getter;
-import net.minecraft.core.Vec3i;
-import net.minecraft.network.protocol.game.ClientboundExplodePacket;
-import net.minecraft.network.protocol.game.ClientboundLevelEventPacket;
-import net.minecraft.network.protocol.game.ClientboundLevelParticlesPacket;
-import net.minecraft.network.protocol.game.ClientboundSoundPacket;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
@@ -54,8 +44,6 @@ import org.bukkit.event.player.PlayerQuitEvent;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
-import java.util.function.BiFunction;
-import java.util.function.Function;
 
 public class HullHider implements Listener {
 
@@ -79,10 +67,13 @@ public class HullHider implements Listener {
 
     public void initialize(FightTeam team) {
         if (!TechHiderWrapper.ENABLED) return;
-
         hullMap.get(team).initialize();
     }
 
+    public void fill(FightTeam team, boolean visible) {
+        if (!TechHiderWrapper.ENABLED) return;
+        hullMap.get(team).fill(visible);
+    }
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onJoin(PlayerJoinEvent e) {
@@ -140,18 +131,6 @@ public class HullHider implements Listener {
         return false;
     }
 
-    public boolean blockPrecise(Player player, int chunkX, int chunkY, int chunkZ) {
-        if (!TechHiderWrapper.ENABLED) return false;
-
-        for (Hull hull : hulls) {
-            if (hull.blockPrecise(player, chunkX, chunkY, chunkZ)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onSpawn(EntitySpawnEvent e) {
         for (Hull hull : hulls) {

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

@@ -29,21 +29,32 @@ import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependent;
 import de.steamwar.fightsystem.states.StateDependentListener;
+import de.steamwar.techhider.AccessPrivilegeProvider;
 import de.steamwar.techhider.TechHider;
 import lombok.Getter;
+import net.minecraft.core.Holder;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.level.material.Fluids;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.craftbukkit.CraftWorld;
 import org.bukkit.craftbukkit.util.CraftMagicNumbers;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
 
+import java.util.Collection;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class TechHiderWrapper extends StateDependent implements Listener {
 
@@ -51,21 +62,40 @@ public class TechHiderWrapper extends StateDependent implements Listener {
 
     @Getter
     private final ConcurrentHashMap<Player, Region> hiddenRegion = new ConcurrentHashMap<>();
-    private final TechHider techHider;
-
+    private final HullHider hullHider;
 
     public TechHiderWrapper(HullHider hullHider) {
-        super(ENABLED, FightState.Schem);
+        super(ENABLED, FightState.All);
+
+        this.hullHider = hullHider;
+
+        new StateDependentListener(ENABLED, FightState.All, this);
+        register();
+    }
+
+    @Override
+    public void enable() {
+        Set<BlockState> blockStatesToObfuscate = getBlockStatesToHideFromMaterials(Config.GameModeConfig.Techhider.HiddenBlocks);
+
         Set<Block> blocksToObfuscate = Config.GameModeConfig.Techhider.HiddenBlocks.stream()
                 .map(CraftMagicNumbers::getBlock)
                 .collect(Collectors.toUnmodifiableSet());
-        /* Set<BlockEntityType<?>> blockEntityTypeToObfuscate =  Config.GameModeConfig.Techhider.HiddenBlockEntities.stream()
-                .map((id) -> {
+
+        Set<BlockEntityType<?>> blockEntityTypeToObfuscate = Config.GameModeConfig.Techhider.HiddenBlockEntities.stream()
+                .map(id -> {
                     ResourceLocation loc = ResourceLocation.parse(id);
-                    return BuiltInRegistries.BLOCK_ENTITY_TYPE.get(loc).get().value();
+                    return BuiltInRegistries.BLOCK_ENTITY_TYPE.get(loc).orElse(null);
                 })
-                .collect(Collectors.toUnmodifiableSet()); */
-        techHider = new TechHider(CraftMagicNumbers.getBlock(Config.GameModeConfig.Techhider.ObfuscateWith)) {
+                .filter(Objects::nonNull)
+                .map(Holder.Reference::value)
+                .collect(Collectors.toUnmodifiableSet());
+
+        new TechHider(CraftMagicNumbers.getBlock(Config.GameModeConfig.Techhider.ObfuscateWith), new AccessPrivilegeProvider() {
+            @Override
+            public boolean isEveryonePrivilegedToAccessAllDataWithinChunk(int chunkX, int chunkZ) {
+                return Fight.teams().stream().map(FightTeam::getExtendRegion).allMatch(region -> region.chunkOutside(chunkX, chunkZ));
+            }
+
             @Override
             public boolean isPlayerPrivilegedToAccessPosition(Player p, int blockX, int blockY, int blockZ) {
                 return !hullHider.isBlockHidden(p, blockX, blockY, blockZ);
@@ -73,40 +103,36 @@ public class TechHiderWrapper extends StateDependent implements Listener {
 
             @Override
             public boolean isPlayerPrivilegedToAccessBlock(Player p, int blockX, int blockY, int blockZ, Block block) {
-                Region hiddenRegion = getHiddenRegion(p);
-                return !hiddenRegion.inRegion(blockX, blockY, blockZ) || !blocksToObfuscate.contains(block) ;
+                return !getHiddenRegion(p).inRegion(blockX, blockY, blockZ) || !blocksToObfuscate.contains(block);
             }
 
+            @Override
+            public boolean isPlayerPrivilegedToAccessBlockState(Player p, int blockX, int blockY, int blockZ, BlockState blockState) {
+                return !getHiddenRegion(p).inRegion(blockX, blockY, blockZ) || !blockStatesToObfuscate.contains(blockState);
+            }
+
+            // TODO will require entity tracking on the netty thread to prevent future race conditions
             @Override
             public boolean isPlayerPrivilegedToAccessEntity(Player p, int entityId) {
-                return false;
+                net.minecraft.world.entity.Entity nmsEntity = ((CraftWorld) p.getWorld()).getHandle().moonrise$getEntityLookup().get(entityId);
+
+                if (nmsEntity != null) {
+                    return !hullHider.isBlockHidden(p, nmsEntity.getBlockX(), nmsEntity.getBlockY(), nmsEntity.getBlockZ());
+                } else {
+                    return true;
+                }
             }
 
             @Override
-            public boolean isPlayerPrivilegedToAccessBlocEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type) {
-                //Region hiddenRegion = getHiddenRegion(p);
-                //return !hiddenRegion.inRegion(blockX, blockY, blockZ) || !blockEntityTypeToObfuscate.contains(type);
-                return false;
+            public boolean isPlayerPrivilegedToAccessBlockEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type) {
+                return !getHiddenRegion(p).inRegion(blockX, blockY, blockZ) || !blockEntityTypeToObfuscate.contains(type);
             }
 
             @Override
-            public boolean isPlayerPrivilegedToAccessContainer(Player p, int containerId) {
-                return false;
+            public boolean isPlayerPrivilegedToPerformAction(Player p) {
+                return p.getGameMode() != GameMode.SPECTATOR;
             }
-
-            @Override
-            public boolean isPlayerPrivilegedToAccessSound(Player p, ResourceLocation soundId) {
-                return false;
-            }
-        };
-
-        new StateDependentListener(ENABLED, FightState.Schem, this);
-        register();
-    }
-
-    @Override
-    public void enable() {
-
+        });
     }
 
     @Override
@@ -159,4 +185,27 @@ public class TechHiderWrapper extends StateDependent implements Listener {
 
         return Fight.getOpposite(team).getExtendRegion();
     }
+
+    private Stream<BlockState> getWaterloggedBlockStates() {
+        FluidState waterFluidState = Fluids.WATER.getSource(false);
+
+        return BuiltInRegistries.BLOCK.stream()
+                .map((block) -> block.getStateDefinition().getPossibleStates())
+                .flatMap(Collection::stream)
+                .filter((blockState -> blockState.getFluidState() == waterFluidState));
+    }
+
+    private Set<BlockState> getBlockStatesToHideFromMaterials(Set<Material> materials) {
+        Stream<BlockState> allStatesFromMaterials = materials.stream()
+                .map(CraftMagicNumbers::getBlock)
+                .map((block) -> block.getStateDefinition().getPossibleStates())
+                .flatMap(Collection::stream);
+
+        if(materials.contains(Material.WATER)) {
+            return Stream.concat(allStatesFromMaterials, getWaterloggedBlockStates()).collect(Collectors.toUnmodifiableSet());
+        }
+        else {
+            return allStatesFromMaterials.collect(Collectors.toUnmodifiableSet());
+        }
+    }
 }

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"
@@ -60,26 +50,6 @@ tasks.register<FightServer>("WarGear21") {
     dependsOn(":KotlinCore:shadowJar")
     template = "WarGear21"
     worldName = "arenas/Pentraki"
-    config = "WarGear20.yml"
+    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/boatrace/BoatRace.java

@@ -20,7 +20,9 @@
 package de.steamwar.lobby.boatrace;
 
 import de.steamwar.entity.REntity;
+import de.steamwar.entity.REntityAction;
 import de.steamwar.entity.REntityServer;
+import de.steamwar.entity.RInteraction;
 import de.steamwar.lobby.LobbySystem;
 import de.steamwar.lobby.util.LeaderboardManager;
 import de.steamwar.sql.SteamwarUser;
@@ -58,11 +60,12 @@ public class BoatRace implements EventListener, Listener {
 
     static {
         boatNpcServer = new REntityServer();
-        REntity starter = new REntity(boatNpcServer, EntityType.VILLAGER, BoatRacePositions.NPC);
-        boatNpcServer.setCallback((player, rEntity, entityAction) -> {
-            if (rEntity != starter) return;
-            Bukkit.getWorlds().get(0).getEntities().stream().filter(entity -> entity.getType() == EntityType.END_CRYSTAL).forEach(Entity::remove);
-            if (entityAction == REntityServer.EntityAction.INTERACT && !oneNotStarted) {
+        new REntity(boatNpcServer, EntityType.VILLAGER, BoatRacePositions.NPC);
+        RInteraction interaction = new RInteraction(boatNpcServer, BoatRacePositions.NPC.clone().subtract(0.5, 0, 0.5));
+        interaction.setInteractionHeight(1.95f);
+        interaction.setCallback((player, entity, action) -> {
+            Bukkit.getWorlds().get(0).getEntities().stream().filter(e -> e.getType() == EntityType.END_CRYSTAL).forEach(Entity::remove);
+            if (action == REntityAction.INTERACT && !oneNotStarted) {
                 oneNotStarted = true;
                 new BoatRace(player);
             }

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

@@ -254,7 +254,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/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,8 +37,8 @@ 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())
-                .depth(clipboard.getDimensions().getBlockZ()).blockScanResult(scan(clipboard, type))
+        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().x()).width(clipboard.getDimensions().x())
+                .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()))
@@ -46,19 +46,19 @@ public class AutoChecker {
     }
 
     public AutoCheckerResult sizeCheck(Clipboard clipboard, GameModeConfig<Material, String> type) {
-        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
-                .depth(clipboard.getDimensions().getBlockZ()).build();
+        return AutoCheckerResult.builder().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 y = min.getBlockY(); y <= max.getBlockY(); y++) {
-                for (int z = min.getBlockZ(); z <= max.getBlockZ(); z++) {
+        for (int x = min.x(); x <= max.x(); x++) {
+            for (int y = min.y(); y <= max.y(); y++) {
+                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 +69,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 j = min.getBlockY(); j <= max.getBlockY(); j++) {
-                    for (int k = min.getBlockZ(); k <= max.getBlockZ(); k++) {
+            for (int i = min.x(); i <= max.x(); i++) {
+                for (int j = min.y(); j <= max.y(); j++) {
+                    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/Reflection.java

@@ -1,502 +0,0 @@
-package com.comphenix.tinyprotocol;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import org.bukkit.Bukkit;
-
-/**
- * An utility class that simplifies reflection in Bukkit plugins.
- * 
- * @author Kristian
- */
-public final class Reflection {
-    /**
-     * An interface for invoking a specific constructor.
-     */
-    public interface ConstructorInvoker {
-        /**
-         * Invoke a constructor for a specific class.
-         * 
-         * @param arguments - the arguments to pass to the constructor.
-         * @return The constructed object.
-         */
-        public Object invoke(Object... arguments);
-    }
-
-    /**
-     * An interface for invoking a specific method.
-     */
-    public interface MethodInvoker {
-        /**
-         * Invoke a method on a specific target object.
-         * 
-         * @param target - the target object, or NULL for a static method.
-         * @param arguments - the arguments to pass to the method.
-         * @return The return value, or NULL if is void.
-         */
-        public Object invoke(Object target, Object... arguments);
-    }
-
-    /**
-     * An interface for retrieving the field content.
-     * 
-     * @param <T> - field type.
-     */
-    public interface FieldAccessor<T> {
-        /**
-         * Retrieve the content of a field.
-         * 
-         * @param target - the target object, or NULL for a static field.
-         * @return The value of the field.
-         */
-        public T get(Object target);
-
-        /**
-         * Set the content of a field.
-         * 
-         * @param target - the target object, or NULL for a static field.
-         * @param value - the new value of the field.
-         */
-        public void set(Object target, Object value);
-
-        /**
-         * Determine if the given object has this field.
-         * 
-         * @param target - the object to test.
-         * @return TRUE if it does, FALSE otherwise.
-         */
-        public boolean hasField(Object target);
-    }
-
-    // Deduce the net.minecraft.server.v* package
-    private static String OBC_PREFIX = Bukkit.getServer().getClass().getPackage().getName();
-    private static String NMS_PREFIX = OBC_PREFIX.replace("org.bukkit.craftbukkit", "net.minecraft.server");
-    private static String VERSION = OBC_PREFIX.replace("org.bukkit.craftbukkit", "").replace(".", "");
-
-    // Variable replacement
-    private static Pattern MATCH_VARIABLE = Pattern.compile("\\{([^\\}]+)\\}");
-
-    private Reflection() {
-        // Seal class
-    }
-
-    /**
-     * Retrieve a field accessor for a specific field type and name.
-     * 
-     * @param target - the target type.
-     * @param name - the name of the field, or NULL to ignore.
-     * @param fieldType - a compatible field type.
-     * @return The field accessor.
-     */
-    public static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType) {
-        return getField(target, name, fieldType, 0);
-    }
-
-    /**
-     * Retrieve a field accessor for a specific field type and name.
-     * 
-     * @param className - lookup name of the class, see {@link #getClass(String)}.
-     * @param name - the name of the field, or NULL to ignore.
-     * @param fieldType - a compatible field type.
-     * @return The field accessor.
-     */
-    public static <T> FieldAccessor<T> getField(String className, String name, Class<T> fieldType) {
-        return getField(getClass(className), name, fieldType, 0);
-    }
-
-    /**
-     * Retrieve a field accessor for a specific field type and name.
-     * 
-     * @param target - the target type.
-     * @param fieldType - a compatible field type.
-     * @param index - the number of compatible fields to skip.
-     * @return The field accessor.
-     */
-    public static <T> FieldAccessor<T> getField(Class<?> target, Class<T> fieldType, int index) {
-        return getField(target, null, fieldType, index);
-    }
-
-    /**
-     * Retrieve a field accessor for a specific field type and name.
-     * 
-     * @param className - lookup name of the class, see {@link #getClass(String)}.
-     * @param fieldType - a compatible field type.
-     * @param index - the number of compatible fields to skip.
-     * @return The field accessor.
-     */
-    public static <T> FieldAccessor<T> getField(String className, Class<T> fieldType, int index) {
-        return getField(getClass(className), fieldType, index);
-    }
-
-    // Common method
-    private static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType, int index) {
-        for (final Field field : target.getDeclaredFields()) {
-            if ((name == null || field.getName().equals(name)) && fieldType.isAssignableFrom(field.getType()) && index-- <= 0) {
-                field.setAccessible(true);
-
-                // A function for retrieving a specific field value
-                return new FieldAccessor<T>() {
-
-                    @Override
-                    @SuppressWarnings("unchecked")
-                    public T get(Object target) {
-                        try {
-                            return (T) field.get(target);
-                        } catch (IllegalAccessException e) {
-                            throw new RuntimeException("Cannot access reflection.", e);
-                        }
-                    }
-
-                    @Override
-                    public void set(Object target, Object value) {
-                        try {
-                            field.set(target, value);
-                        } catch (IllegalAccessException e) {
-                            throw new RuntimeException("Cannot access reflection.", e);
-                        }
-                    }
-
-                    @Override
-                    public boolean hasField(Object target) {
-                        // target instanceof DeclaringClass
-                        return field.getDeclaringClass().isAssignableFrom(target.getClass());
-                    }
-                };
-            }
-        }
-
-        // Search in parent classes
-        if (target.getSuperclass() != null)
-            return getField(target.getSuperclass(), name, fieldType, index);
-
-        throw new IllegalArgumentException("Cannot find field with type " + fieldType);
-    }
-
-    /**
-     * Retrieves a field with a given type and parameters. This is most useful
-     * when dealing with Collections.
-     *
-     * @param target the target class.
-     * @param fieldType Type of the field
-     * @param params Variable length array of type parameters
-     * @return The field
-     *
-     * @throws IllegalArgumentException If the field cannot be found
-     */
-    public static Field getParameterizedField(Class<?> target, Class<?> fieldType, Class<?>... params) {
-        for (Field field : target.getDeclaredFields()) {
-            if (field.getType().equals(fieldType)) {
-                Type type = field.getGenericType();
-                if (type instanceof ParameterizedType) {
-                    if (Arrays.equals(((ParameterizedType) type).getActualTypeArguments(), params))
-                        return field;
-                }
-            }
-        }
-
-        throw new IllegalArgumentException("Unable to find a field with type " + fieldType + " and params " + Arrays.toString(params));
-    }
-
-    /**
-     * Search for the first publicly and privately defined method of the given name and parameter count.
-     * 
-     * @param className - lookup name of the class, see {@link #getClass(String)}.
-     * @param methodName - the method name, or NULL to skip.
-     * @param params - the expected parameters.
-     * @return An object that invokes this specific method.
-     * @throws IllegalStateException If we cannot find this method.
-     */
-    public static MethodInvoker getMethod(String className, String methodName, Class<?>... params) {
-        return getTypedMethod(getClass(className), methodName, null, params);
-    }
-
-    /**
-     * Search for the first publicly and privately defined method of the given name and parameter count.
-     * 
-     * @param clazz - a class to start with.
-     * @param methodName - the method name, or NULL to skip.
-     * @param params - the expected parameters.
-     * @return An object that invokes this specific method.
-     * @throws IllegalStateException If we cannot find this method.
-     */
-    public static MethodInvoker getMethod(Class<?> clazz, String methodName, Class<?>... params) {
-        return getTypedMethod(clazz, methodName, null, params);
-    }
-
-    /**
-     * Search for the first publicly and privately defined method of the given name and parameter count.
-     * 
-     * @param clazz - a class to start with.
-     * @param methodName - the method name, or NULL to skip.
-     * @param returnType - the expected return type, or NULL to ignore.
-     * @param params - the expected parameters.
-     * @return An object that invokes this specific method.
-     * @throws IllegalStateException If we cannot find this method.
-     */
-    public static MethodInvoker getTypedMethod(Class<?> clazz, String methodName, Class<?> returnType, Class<?>... params) {
-        for (final 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 MethodInvoker() {
-
-                    @Override
-                    public Object invoke(Object target, Object... arguments) {
-                        try {
-                            return method.invoke(target, arguments);
-                        } catch (Exception e) {
-                            throw new RuntimeException("Cannot invoke method " + method, e);
-                        }
-                    }
-
-                };
-            }
-        }
-
-        // Search in every superclass
-        if (clazz.getSuperclass() != null)
-            return getMethod(clazz.getSuperclass(), methodName, params);
-
-        throw new IllegalStateException(String.format("Unable to find method %s (%s).", methodName, Arrays.asList(params)));
-    }
-
-    /**
-     * Search for the first publically and privately defined constructor of the given name and parameter count.
-     * 
-     * @param className - lookup name of the class, see {@link #getClass(String)}.
-     * @param params - the expected parameters.
-     * @return An object that invokes this constructor.
-     * @throws IllegalStateException If we cannot find this method.
-     */
-    public static ConstructorInvoker getConstructor(String className, Class<?>... params) {
-        return getConstructor(getClass(className), params);
-    }
-
-    /**
-     * Search for the first publically and privately defined constructor of the given name and parameter count.
-     * 
-     * @param clazz - a class to start with.
-     * @param params - the expected parameters.
-     * @return An object that invokes this constructor.
-     * @throws IllegalStateException If we cannot find this method.
-     */
-    public static ConstructorInvoker getConstructor(Class<?> clazz, Class<?>... params) {
-        for (final Constructor<?> constructor : clazz.getDeclaredConstructors()) {
-            if (Arrays.equals(constructor.getParameterTypes(), params)) {
-                constructor.setAccessible(true);
-
-                return new ConstructorInvoker() {
-
-                    @Override
-                    public Object invoke(Object... arguments) {
-                        try {
-                            return constructor.newInstance(arguments);
-                        } catch (Exception e) {
-                            throw new RuntimeException("Cannot invoke constructor " + constructor, e);
-                        }
-                    }
-
-                };
-            }
-        }
-
-        throw new IllegalStateException(String.format("Unable to find constructor for %s (%s).", clazz, Arrays.asList(params)));
-    }
-
-    /**
-     * Retrieve a class from its full name, without knowing its type on compile time.
-     * <p>
-     * This is useful when looking up fields by a NMS or OBC type.
-     * <p>
-     * 
-     * @see {@link #getClass()} for more information.
-     * @param lookupName - the class name with variables.
-     * @return The class.
-     */
-    public static Class<Object> getUntypedClass(String lookupName) {
-        @SuppressWarnings({ "rawtypes", "unchecked" })
-        Class<Object> clazz = (Class) getClass(lookupName);
-        return clazz;
-    }
-
-    /**
-     * Retrieve a class from its full name with alternatives, without knowing its type on compile time.
-     * <p>
-     * This is useful when looking up fields by a NMS or OBC type.
-     * <p>
-     * 
-     * @see {@link #getClass()} for more information.
-     * @param lookupName - the class name with variables.
-     * @param aliases - alternative names for this class.
-     * @return The class.
-     */
-    public static Class<Object> getUntypedClass(String lookupName, String... aliases) {
-        @SuppressWarnings({ "rawtypes", "unchecked" })
-        Class<Object> clazz = (Class) getClass(lookupName, aliases);
-        return clazz;
-    }
-
-    /**
-     * Retrieve a class from its full name.
-     * <p>
-     * Strings enclosed with curly brackets - such as {TEXT} - will be replaced according to the following table:
-     * <p>
-     * <table border="1">
-     * <tr>
-     * <th>Variable</th>
-     * <th>Content</th>
-     * </tr>
-     * <tr>
-     * <td>{nms}</td>
-     * <td>Actual package name of net.minecraft.server.VERSION</td>
-     * </tr>
-     * <tr>
-     * <td>{obc}</td>
-     * <td>Actual pacakge name of org.bukkit.craftbukkit.VERSION</td>
-     * </tr>
-     * <tr>
-     * <td>{version}</td>
-     * <td>The current Minecraft package VERSION, if any.</td>
-     * </tr>
-     * </table>
-     * 
-     * @param lookupName - the class name with variables.
-     * @return The looked up class.
-     * @throws IllegalArgumentException If a variable or class could not be found.
-     */
-    public static Class<?> getClass(String lookupName) {
-        return getCanonicalClass(expandVariables(lookupName));
-    }
-
-    /**
-     * Retrieve the first class that matches the full class name.
-     * <p>
-     * Strings enclosed with curly brackets - such as {TEXT} - will be replaced according to the following table:
-     * <p>
-     * <table border="1">
-     * <tr>
-     * <th>Variable</th>
-     * <th>Content</th>
-     * </tr>
-     * <tr>
-     * <td>{nms}</td>
-     * <td>Actual package name of net.minecraft.server.VERSION</td>
-     * </tr>
-     * <tr>
-     * <td>{obc}</td>
-     * <td>Actual pacakge name of org.bukkit.craftbukkit.VERSION</td>
-     * </tr>
-     * <tr>
-     * <td>{version}</td>
-     * <td>The current Minecraft package VERSION, if any.</td>
-     * </tr>
-     * </table>
-     * 
-     * @param lookupName - the class name with variables.
-     * @param aliases - alternative names for this class.
-     * @return Class object.
-     * @throws RuntimeException If we are unable to find any of the given classes.
-     */
-    public static Class<?> getClass(String lookupName, String... aliases) {
-        try {
-            // Try the main class first
-            return getClass(lookupName);
-        } catch (RuntimeException e) {
-            Class<?> success = null;
-
-            // Try every alias too
-            for (String alias : aliases) {
-                try {
-                    success = getClass(alias);
-                    break;
-                } catch (RuntimeException e1) {
-                    // e1.printStackTrace();
-                }
-            }
-
-            if (success != null) {
-                return success;
-            } else {
-                // Hack failed
-                throw new RuntimeException(String.format("Unable to find %s (%s)", lookupName, String.join(",", aliases)));
-            }
-        }
-    }
-
-    /**
-     * Retrieve a class in the net.minecraft.server.VERSION.* package.
-     * 
-     * @param name - the name of the class, excluding the package.
-     * @throws IllegalArgumentException If the class doesn't exist.
-     */
-    public static Class<?> getMinecraftClass(String name) {
-        return getCanonicalClass(NMS_PREFIX + "." + name);
-    }
-
-    /**
-     * Retrieve a class in the org.bukkit.craftbukkit.VERSION.* package.
-     * 
-     * @param name - the name of the class, excluding the package.
-     * @throws IllegalArgumentException If the class doesn't exist.
-     */
-    public static Class<?> getCraftBukkitClass(String name) {
-        return getCanonicalClass(OBC_PREFIX + "." + name);
-    }
-
-    /**
-     * Retrieve a class by its canonical name.
-     * 
-     * @param canonicalName - the canonical name.
-     * @return The class.
-     */
-    private static Class<?> getCanonicalClass(String canonicalName) {
-        try {
-            return Class.forName(canonicalName);
-        } catch (ClassNotFoundException e) {
-            throw new IllegalArgumentException("Cannot find " + canonicalName, e);
-        }
-    }
-
-    /**
-     * Expand variables such as "{nms}" and "{obc}" to their corresponding packages.
-     * 
-     * @param name - the full name of the class.
-     * @return The expanded string.
-     */
-    private static String expandVariables(String name) {
-        StringBuffer output = new StringBuffer();
-        Matcher matcher = MATCH_VARIABLE.matcher(name);
-
-        while (matcher.find()) {
-            String variable = matcher.group(1);
-            String replacement = "";
-
-            // Expand all detected variables
-            if ("nms".equalsIgnoreCase(variable))
-                replacement = NMS_PREFIX;
-            else if ("obc".equalsIgnoreCase(variable))
-                replacement = OBC_PREFIX;
-            else if ("version".equalsIgnoreCase(variable))
-                replacement = VERSION;
-            else
-                throw new IllegalArgumentException("Unknown variable: " + variable);
-
-            // Assume the expanded variables are all packages, and append a dot
-            if (replacement.length() > 0 && matcher.end() < name.length() && name.charAt(matcher.end()) != '.')
-                replacement += ".";
-            matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
-        }
-
-        matcher.appendTail(output);
-        return output.toString();
-    }
-}

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
-        boolean looking = true;
-        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;
-            }
+            serverChannels.add(serverChannel);
+            serverChannel.pipeline().addFirst(serverChannelHandler);
         }
     }
 
@@ -227,7 +216,7 @@ public class TinyProtocol {
         }
     }
 
-    public <T> void addFilter(Class<T> packetType, BiFunction<Player, ? super T, Object> filter) {
+    public <T extends Packet<?>> void addFilter(Class<T> packetType, BiFunction<Player, ? super T, Object> filter) {
         packetFilters.computeIfAbsent(packetType, c -> new CopyOnWriteArrayList<>()).add((BiFunction) filter);
     }
 
@@ -235,8 +224,8 @@ public class TinyProtocol {
         packetFilters.getOrDefault(packetType, Collections.emptyList()).remove(filter);
     }
 
-    public void addGlobalClientboundFilter(BiFunction<Player, Object, Object> filter) {
-        globalClientboundFilters.add(filter);
+    public void addGlobalClientboundFilter(BiFunction<Player, Packet<?>, Object> filter) {
+        globalClientboundFilters.add((BiFunction) filter);
     }
 
     /**
@@ -453,7 +442,7 @@ public class TinyProtocol {
             try {
                 msg = filterPacket(player, msg);
 
-                if(msg instanceof Packet<?>) {
+                if (msg instanceof Packet<?>) {
                     for (BiFunction<Player, Object, Object> filter : globalClientboundFilters) {
                         msg = filter.apply(player, msg);
                         if (msg == null) break;

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 {
-            final Field commandMapField = Bukkit.getServer().getClass().getDeclaredField("commandMap");
-            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);
-        }
+        commandMap = ((CraftServer) Bukkit.getServer()).getCommandMap();
+        knownCommandMap = commandMap.getKnownCommands();
     }
 
     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);
-        for (Object future : channels) {
-            ((ChannelFuture) future).channel().close().syncUninterruptibly();
+        List<ChannelFuture> channels = serverConnection.channels;
+        for (ChannelFuture future : channels) {
+            future.channel().close().syncUninterruptibly();
         }
         channels.clear();
 
@@ -145,8 +141,8 @@ class CheckpointUtilsJ9 {
 
         // Reopen socket
         serverConnection.startTcpServerListener(InetAddress.getLoopbackAddress(), port);
-        for (Object future : channels) {
-            ((ChannelFuture) future).channel().config().setAutoRead(true);
+        for (ChannelFuture future : channels) {
+            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
- *   (at your option) any later version.
+ *   the Free Software Foundation, either versionStrings 3 of the License, or
+ *   (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() {
-        return Reflection.MAJOR_VERSION;
+    private static final int 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);
-
-        Reflection.Field<WatchdogThread> getInstance = Reflection.getField(WatchdogThread.class, WatchdogThread.class, 0);
-        watchdogThreadId = getInstance.get(null).getId();
+        watchdogThreadId = WatchdogThread.instance.threadId();
     }
 
     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();
-        field = Reflection.getField(clazz, Services.class, 0);
-        current = field.get(MinecraftServer.getServer());
+        current = MinecraftServer.getServer().services;
         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());
-        field.set(MinecraftServer.getServer(), newServices);
+        MinecraftServer.getServer().services = new Services(current.sessionService(), current.servicesKeySet(), this, current.profileCache(), current.paperConfigurations());
     }
 }

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

@@ -20,6 +20,7 @@
 package de.steamwar.entity;
 
 import lombok.Getter;
+import lombok.Setter;
 import net.minecraft.network.syncher.EntityDataAccessor;
 import net.minecraft.network.syncher.EntityDataSerializers;
 import org.bukkit.Location;
@@ -27,13 +28,16 @@ import org.bukkit.entity.EntityType;
 
 import java.util.function.Consumer;
 
-public class RArmorStand extends REntity {
+@Getter
+public class RArmorStand extends REntity implements RInteractableEntity<RArmorStand> {
 
     private static final EntityDataAccessor<Byte> sizeWatcher = new EntityDataAccessor<>(15, EntityDataSerializers.BYTE);
 
-    @Getter
     private final Size size;
 
+    @Setter
+    private REntityActionListener<RArmorStand> callback = null;
+
     public RArmorStand(REntityServer server, Location location, Size size) {
         super(server, EntityType.ARMOR_STAND, location, 0);
         this.size = size;
@@ -45,7 +49,7 @@ public class RArmorStand extends REntity {
         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) {
-        List<Object> keyValueData = new ArrayList<>();
+    protected final void sendPacket(Consumer<Object> packetSink, BiConsumer<Boolean, EntityDataPacketBuilder>... dataSinkSinks) {
+        EntityDataPacketBuilder builder = entityDataPacket();
         boolean ignoreDefault = packetSink == updatePacketSink;
-        for (BiConsumer<Boolean, BiConsumer<Object, Object>> dataSinkSink : dataSinkSinks) {
-            dataSinkSink.accept(ignoreDefault, (dataWatcher, value) -> {
-                keyValueData.add(dataWatcher);
-                keyValueData.add(value);
-            });
-        }
-        if (!keyValueData.isEmpty()) {
-            packetSink.accept(getDataWatcherPacket(keyValueData.toArray()));
+        for (BiConsumer<Boolean, EntityDataPacketBuilder> dataSinkSink : dataSinkSinks) {
+            dataSinkSink.accept(ignoreDefault, builder);
         }
+        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.accept(leftRotationWatcher, transform.getLeftRotation());
-            dataSink.accept(scaleWatcher, transform.getScale());
-            dataSink.accept(rightRotationWatcher, transform.getRightRotation());
+            dataSink.add(translationWatcher, transform.getTranslation());
+            dataSink.add(leftRotationWatcher, transform.getLeftRotation());
+            dataSink.add(scaleWatcher, transform.getScale());
+            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.accept(positionOrRotationInterpolationDurationWatcher, interpolationDuration);
+            packetSink.add(transformationInterpolationDurationWatcher, 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);
-        animationEntity.set(packet, entityId);
-        animationAnimation.set(packet, (int) animation);
+        ClientboundAnimatePacket packet = new ClientboundAnimatePacket();
+        packet.id = entityId;
+        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);
-        statusEntity.set(packet, entityId);
-        statusStatus.set(packet, (byte) 2);
+        ClientboundEntityEventPacket packet = new ClientboundEntityEventPacket();
+        packet.entityId = entityId;
+        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(
-                nameWatcher, FlatteningWrapper.formatDisplayName(displayName),
-                nameVisibleWatcher, displayName != null
-        ));
+        server.updateEntity(this, entityDataPacket().add(nameWatcher, formatDisplayName(displayName))
+                .add(nameVisibleWatcher, displayName != null).build());
     }
 
     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 static final Reflection.Field<Integer> additionalData = Reflection.getField(ClientboundAddEntityPacket.class, int.class, 4);
-
-    private Object spawnPacketGenerator() {
-        Object packet = spawnPacketGenerator.apply(this);
-        additionalData.set(packet, objectData);
-        return packet;
+    private ClientboundAddEntityPacket spawnPacketGenerator() {
+        ResourceLocation key = CraftNamespacedKey.toMinecraft(entityType.getKey());
+        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);
     }
 
     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) {
-        ArrayList<SynchedEntityData.DataValue<?>> nativeWatchers = new ArrayList<>(1);
-        for (int i = 0; i < dataWatcherKeyValues.length; i += 2) {
-            nativeWatchers.add(((SynchedEntityData.DataItem<?>) BountifulWrapper.impl.getDataWatcherItem(dataWatcherKeyValues[i], dataWatcherKeyValues[i + 1])).value());
+    protected EntityDataPacketBuilder entityDataPacket() {
+        return new EntityDataPacketBuilder();
+    }
+
+    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);
-        headRotationEntity.set(packet, entityId);
-        headRotationYaw.set(packet, headYaw);
+        ClientboundRotateHeadPacket packet = new ClientboundRotateHeadPacket();
+        packet.entityId = entityId;
+        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/REntityAction.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,9 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.core;
+package de.steamwar.entity;
 
-import lombok.experimental.UtilityClass;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.network.chat.contents.PlainTextContents;
-
-import java.util.Optional;
-
-@UtilityClass
-public class FlatteningWrapper {
-
-    public Object formatDisplayName(String displayName) {
-        return displayName != null ? Optional.of((Object) MutableComponent.create(PlainTextContents.create(displayName))) : Optional.empty();
-    }
+public enum REntityAction {
+    INTERACT,
+    ATTACK,
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/REntityActionListener.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,20 +17,10 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.bausystem.utils;
+package de.steamwar.entity;
 
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
+import org.bukkit.entity.Player;
 
-public class TickStartEvent extends Event {
-
-    private static final HandlerList handlers = new HandlerList();
-
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
+public interface REntityActionListener<E extends REntity> {
+    void onAction(Player player, E entity, REntityAction action);
 }

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

@@ -51,7 +51,6 @@ public class REntityServer implements Listener {
     private final HashMap<Player, Location> lastLocation = new HashMap<>();
     private final HashMap<Player, Integer> viewDistance = new HashMap<>();
 
-    private EntityActionListener callback = null;
     private final Set<Player> playersThatClicked = Collections.synchronizedSet(new HashSet<>());
 
     private final BiFunction<Player, ServerboundInteractPacket, Object> filter = (player, packet) -> {
@@ -61,25 +60,19 @@ public class REntityServer implements Listener {
         if (playersThatClicked.contains(player)) return null;
 
         playersThatClicked.add(player);
-        EntityAction action = packet.isAttack() ? EntityAction.ATTACK : EntityAction.INTERACT;
+        REntityAction action = packet.isAttack() ? REntityAction.ATTACK : REntityAction.INTERACT;
         Bukkit.getScheduler().runTask(Core.getInstance(), () -> {
             playersThatClicked.remove(player);
-            callback.onAction(player, entity, action);
+            if (entity instanceof RInteractableEntity interactable && interactable.getCallback() != null) {
+                interactable.getCallback().onAction(player, entity, action);
+            }
         });
         return null;
     };
 
     public REntityServer() {
         Core.getInstance().getServer().getPluginManager().registerEvents(this, Core.getInstance());
-    }
-
-    public void setCallback(EntityActionListener callback) {
-        boolean uninitialized = this.callback == null;
-        this.callback = callback;
-
-        if (uninitialized) {
-            TinyProtocol.instance.addFilter(ServerboundInteractPacket.class, filter);
-        }
+        TinyProtocol.instance.addFilter(ServerboundInteractPacket.class, filter);
     }
 
     public void addPlayer(Player player) {
@@ -293,13 +286,4 @@ public class REntityServer implements Listener {
     private long chunkToId(int x, int z) {
         return ((long) x << 32) + z;
     }
-
-    public enum EntityAction {
-        INTERACT,
-        ATTACK,
-    }
-
-    public interface EntityActionListener {
-        void onAction(Player player, REntity entity, EntityAction action);
-    }
 }

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

@@ -21,15 +21,19 @@ package de.steamwar.entity;
 
 import de.steamwar.techhider.BlockIds;
 import lombok.Getter;
+import lombok.Setter;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.EntityType;
 
 @Getter
-public class RFallingBlockEntity extends REntity {
+public class RFallingBlockEntity extends REntity implements RInteractableEntity<RFallingBlockEntity> {
 
     private final Material material;
 
+    @Setter
+    private REntityActionListener<RFallingBlockEntity> callback = null;
+
     public RFallingBlockEntity(REntityServer server, Location location, Material material) {
         super(server, EntityType.FALLING_BLOCK, location, BlockIds.impl.materialToId(material));
         this.material = material;

SpigotCore/SpigotCore_Main/src/de/steamwar/entity/RInteractableEntity.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,18 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.techhider;
+package de.steamwar.entity;
 
-import de.steamwar.Reflection;
-import net.minecraft.core.SectionPos;
-import net.minecraft.world.level.block.entity.BlockEntityType;
-import net.minecraft.world.level.block.entity.SignBlockEntity;
-import net.minecraft.world.level.block.state.BlockState;
 import org.bukkit.entity.Player;
 
-import java.util.ArrayList;
-import java.util.function.BiFunction;
+import java.util.function.BiConsumer;
 
-public class ProtocolWrapper {
-    public static final ProtocolWrapper impl = new ProtocolWrapper();
+public interface RInteractableEntity<E extends REntity> {
+    REntityActionListener<E> getCallback();
+
+    void setCallback(REntityActionListener<E> callback);
+
+    default void setCallback(BiConsumer<Player, REntityAction> callback) {
+        setCallback((player, interaction, entityAction) -> callback.accept(player, entityAction));
+    }
 }

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

@@ -0,0 +1,110 @@
+/*
+ *   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.entity;
+
+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.function.BiConsumer;
+import java.util.function.Consumer;
+
+/**
+ * !! This class cannot be used in Versions lower than or equal to 1.19.4 !!
+ */
+@Getter
+public class RInteraction extends REntity implements RInteractableEntity<RInteraction> {
+
+    protected final Consumer<Object> updatePacketSink = o -> server.updateEntity(this, o);
+
+    @Setter
+    private REntityActionListener<RInteraction> callback = null;
+
+    private float interactionWidth = 1.0f;
+    private float interactionHeight = 1.0f;
+    private boolean responsive = false;
+
+    public RInteraction(REntityServer server, Location location) {
+        super(server, EntityType.INTERACTION, location);
+        server.addEntity(this);
+    }
+
+    @Override
+    protected void postSpawn(Consumer<Object> packetSink) {
+        super.postSpawn(packetSink);
+        sendPacket(packetSink,
+                this::getInteractionWidthData,
+                this::getInteractionHeightData,
+                this::getResponsiveData
+        );
+    }
+
+    @SafeVarargs
+    protected final void sendPacket(Consumer<Object> packetSink, BiConsumer<Boolean, EntityDataPacketBuilder>... dataSinkSinks) {
+        EntityDataPacketBuilder builder = entityDataPacket();
+        boolean ignoreDefault = packetSink == updatePacketSink;
+        for (BiConsumer<Boolean, EntityDataPacketBuilder> dataSinkSink : dataSinkSinks) {
+            dataSinkSink.accept(ignoreDefault, builder);
+        }
+        if (!builder.isEmpty()) builder.send(packetSink);
+    }
+
+    public void setInteractionWidth(float interactionWidth) {
+        this.interactionWidth = interactionWidth;
+        sendPacket(updatePacketSink, this::getInteractionWidthData);
+    }
+
+    private static final EntityDataAccessor<Float> interactionWidthWatcher = new EntityDataAccessor<>(8, EntityDataSerializers.FLOAT);
+
+    private void getInteractionWidthData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
+        if (ignoreDefault || interactionWidth != 1.0) {
+            dataSink.add(interactionWidthWatcher, interactionWidth);
+        }
+    }
+
+    public void setInteractionHeight(float interactionHeight) {
+        this.interactionHeight = interactionHeight;
+        sendPacket(updatePacketSink, this::getInteractionHeightData);
+    }
+
+    private static final EntityDataAccessor<Float> interactionHeightWatcher = new EntityDataAccessor<>(9, EntityDataSerializers.FLOAT);
+
+    private void getInteractionHeightData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
+        if (ignoreDefault || interactionHeight != 1.0) {
+            dataSink.add(interactionHeightWatcher, interactionHeight);
+        }
+    }
+
+    public void setResponsive(boolean responsive) {
+        this.responsive = responsive;
+        sendPacket(updatePacketSink, this::getResponsiveData);
+    }
+
+    private static final EntityDataAccessor<Boolean> responsiveWatcher = new EntityDataAccessor<>(10, EntityDataSerializers.BOOLEAN);
+
+    private void getResponsiveData(boolean ignoreDefault, EntityDataPacketBuilder dataSink) {
+        if (ignoreDefault || !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());
         }
     }
 }

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

@@ -21,13 +21,15 @@ package de.steamwar.entity;
 
 import com.mojang.authlib.GameProfile;
 import com.mojang.authlib.properties.Property;
-import de.steamwar.core.BountifulWrapper;
 import de.steamwar.core.ProtocolWrapper;
 import de.steamwar.network.CoreNetworkHandler;
 import de.steamwar.network.NetworkSender;
 import de.steamwar.network.packets.common.PlayerSkinRequestPacket;
 import lombok.Getter;
+import lombok.Setter;
 import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.network.syncher.EntityDataSerializers;
 import net.minecraft.world.phys.Vec3;
 import org.bukkit.GameMode;
 import org.bukkit.Location;
@@ -39,15 +41,19 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.function.Consumer;
 
-public class RPlayer extends REntity {
+public class RPlayer extends REntity implements RInteractableEntity<RPlayer> {
 
-    private static final Object skinPartsDataWatcher = BountifulWrapper.impl.getDataWatcherObject(17, Byte.class);
+    private static final EntityDataAccessor<Byte> skinPartsDataWatcher = new EntityDataAccessor<>(17, EntityDataSerializers.BYTE);
 
     @Getter
     private final UUID actualUUID;
     @Getter
     private final String name;
 
+    @Setter
+    @Getter
+    private REntityActionListener<RPlayer> callback = null;
+
     public RPlayer(REntityServer server, UUID uuid, String name, Location location) {
         super(server, EntityType.PLAYER, UUID.nameUUIDFromBytes(uuid.toString().getBytes(StandardCharsets.UTF_8)), location, 0);
         this.actualUUID = uuid;
@@ -80,7 +86,7 @@ public class RPlayer extends REntity {
     @Override
     void spawn(Consumer<Object> packetSink) {
         packetSink.accept(getNamedSpawnPacket());
-        packetSink.accept(getDataWatcherPacket(skinPartsDataWatcher, (byte) 0x7F));
+        entityDataPacket().add(skinPartsDataWatcher, (byte) 0x7F).send(packetSink);
 
         for (Map.Entry<Object, ItemStack> entry : itemSlots.entrySet()) {
             packetSink.accept(getEquipmentPacket(entry.getKey(), entry.getValue()));

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

@@ -77,9 +77,9 @@ public class RTextDisplay extends RDisplay {
 
     private static final EntityDataAccessor<Component> textWatcher = new EntityDataAccessor<>(23, EntityDataSerializers.COMPONENT);
 
-    private void getText(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getText(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || !text.isEmpty()) {
-            packetSink.accept(textWatcher, MutableComponent.create(PlainTextContents.create(text)));
+            packetSink.add(textWatcher, MutableComponent.create(PlainTextContents.create(text)));
         }
     }
 
@@ -90,9 +90,9 @@ public class RTextDisplay extends RDisplay {
 
     private static final EntityDataAccessor<Integer> lineWidthWatcher = new EntityDataAccessor<>(24, EntityDataSerializers.INT);
 
-    private void getLineWidth(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getLineWidth(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || lineWidth != 200) {
-            packetSink.accept(lineWidthWatcher, lineWidth);
+            packetSink.add(lineWidthWatcher, lineWidth);
         }
     }
 
@@ -103,9 +103,9 @@ public class RTextDisplay extends RDisplay {
 
     private static final EntityDataAccessor<Byte> textOpacityWatcher = new EntityDataAccessor<>(26, EntityDataSerializers.BYTE);
 
-    private void getTextOpacity(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getTextOpacity(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || textOpacity != (byte) -1) {
-            packetSink.accept(textOpacityWatcher, textOpacity);
+            packetSink.add(textOpacityWatcher, textOpacity);
         }
     }
 
@@ -126,9 +126,9 @@ public class RTextDisplay extends RDisplay {
 
     private static final EntityDataAccessor<Integer> backgroundColorWatcher = new EntityDataAccessor<>(25, EntityDataSerializers.INT);
 
-    private void getBackgroundColor(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getBackgroundColor(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         if (ignoreDefault || backgroundColor != null) {
-            packetSink.accept(backgroundColorWatcher, backgroundColor);
+            packetSink.add(backgroundColorWatcher, backgroundColor);
         }
     }
 
@@ -146,7 +146,7 @@ public class RTextDisplay extends RDisplay {
 
     private static final EntityDataAccessor<Byte> textStatusWatcher = new EntityDataAccessor<>(27, EntityDataSerializers.BYTE);
 
-    private void getTextStatus(boolean ignoreDefault, BiConsumer<Object, Object> packetSink) {
+    private void getTextStatus(boolean ignoreDefault, EntityDataPacketBuilder packetSink) {
         byte status = 0;
 
         if (shadowed) {
@@ -167,7 +167,7 @@ public class RTextDisplay extends RDisplay {
         }
 
         if (ignoreDefault || status != 0) {
-            packetSink.accept(textStatusWatcher, status);
+            packetSink.add(textStatusWatcher, status);
         }
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/AccessPrivilegeProvider.java

@@ -0,0 +1,41 @@
+/*
+ *   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.techhider;
+
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.entity.Player;
+
+public interface AccessPrivilegeProvider {
+    boolean isEveryonePrivilegedToAccessAllDataWithinChunk(int chunkX, int chunkZ);
+
+    boolean isPlayerPrivilegedToAccessPosition(Player p, int blockX, int blockY, int blockZ);
+
+    boolean isPlayerPrivilegedToAccessBlock(Player p, int blockX, int blockY, int blockZ, Block block);
+
+    boolean isPlayerPrivilegedToAccessBlockState(Player p, int blockX, int blockY, int blockZ, BlockState blockState);
+
+    boolean isPlayerPrivilegedToAccessEntity(Player p, int entityId);
+
+    boolean isPlayerPrivilegedToAccessBlockEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type);
+
+    boolean isPlayerPrivilegedToPerformAction(Player p);
+}

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/BlockIds.java

@@ -19,17 +19,12 @@
 
 package de.steamwar.techhider;
 
-import de.steamwar.Reflection;
-import net.minecraft.core.IdMapper;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.material.FluidState;
 import net.minecraft.world.level.material.Fluids;
 import org.bukkit.Material;
-import org.bukkit.Registry;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.Waterlogged;
 import org.bukkit.craftbukkit.util.CraftMagicNumbers;
 
 import java.util.HashSet;

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/ChunkHider.java

@@ -19,40 +19,22 @@
 
 package de.steamwar.techhider;
 
-import de.steamwar.Reflection;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
-import it.unimi.dsi.fastutil.ints.Int2IntArrayMap;
-import it.unimi.dsi.fastutil.ints.Int2IntMap;
-import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
-import lombok.Getter;
-import net.minecraft.core.Registry;
-import net.minecraft.core.SectionPos;
-import net.minecraft.core.registries.BuiltInRegistries;
-import net.minecraft.core.registries.Registries;
 import net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData;
 import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket;
-import net.minecraft.resources.ResourceLocation;
 import net.minecraft.util.SimpleBitStorage;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntityType;
-import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import net.minecraft.world.level.block.state.BlockState;
 import org.bukkit.entity.Player;
 
-import java.util.*;
-import java.util.function.BiFunction;
+import java.util.List;
 import java.util.function.UnaryOperator;
-import java.util.stream.Collectors;
 
-
-public abstract class ChunkHider {
-    private static final UnaryOperator<Object> chunkPacketShallowCloner = ProtocolUtils.shallowCloneGenerator(ClientboundLevelChunkWithLightPacket.class);
-    private static final UnaryOperator<Object> chunkDataShallowCloner = ProtocolUtils.shallowCloneGenerator(ClientboundLevelChunkPacketData.class);
-
-    private static final Reflection.Field<ClientboundLevelChunkPacketData> levelChunkPacketDataField = Reflection.getField(ClientboundLevelChunkWithLightPacket.class, ClientboundLevelChunkPacketData.class, 0);
-
-    private static final Reflection.Field<byte[]> chunkBlockDataField = Reflection.getField(ClientboundLevelChunkPacketData.class, byte[].class, 0);
-    private static final Reflection.Field<List> chunkBlockEntitiesDataField = Reflection.getField(ClientboundLevelChunkPacketData.class, List.class, 0);
+public class ChunkHider {
+    private static final UnaryOperator<ClientboundLevelChunkWithLightPacket> chunkPacketShallowCloner = ProtocolUtils.shallowCloneGenerator(ClientboundLevelChunkWithLightPacket.class, ClientboundLevelChunkWithLightPacket::new);
+    private static final UnaryOperator<ClientboundLevelChunkPacketData> chunkDataShallowCloner = ProtocolUtils.shallowCloneGenerator(ClientboundLevelChunkPacketData.class, ClientboundLevelChunkPacketData::new);
 
     private final int SECTION_SPAN_SIZE = 16;
     private final byte BIT_PER_BLOCK_INDIRECTION_LIMIT = 8;
@@ -61,21 +43,26 @@ public abstract class ChunkHider {
     private final int BLOCKS_PER_SECTION = 4096;
     private final int BIOMES_PER_SECTION = 64;
 
-    private final byte BITS_PER_LONG = 64;
+    private final int blockIdUsedForHiding;
+    private final AccessPrivilegeProvider accessPrivilegeProvider;
 
-    private final int blockIdUsedForHiding = 121;
+    public ChunkHider(Block blockUsedForObfuscation, AccessPrivilegeProvider accessPrivilegeProvider) {
+        blockIdUsedForHiding = Block.BLOCK_STATE_REGISTRY.getId(blockUsedForObfuscation.defaultBlockState());
+        this.accessPrivilegeProvider = accessPrivilegeProvider;
+    }
 
-    public ChunkHider(Block blockUsedForObfuscation) {
-        // blockIdUsedForHiding =  Block.BLOCK_STATE_REGISTRY.getId(blockUsedForObfuscation.defaultBlockState());
+    private int getLongsRequiredToEncodeEntries(int bitsPerEntry, int entryCount) {
+        int entriesPerLong = Long.SIZE / bitsPerEntry;
+        int dataLengthAsLongCount = (entryCount + entriesPerLong - 1) / entriesPerLong;
+
+        return dataLengthAsLongCount;
     }
 
     private long[] readSectionDataFromBuffer(ByteBuf dataSource, short bitsPerEntry, int entryCount) {
-        int entriesPerLong =  BITS_PER_LONG / bitsPerEntry;
-        int dataLengthAsLongCount = (entryCount + entriesPerLong - 1) / entriesPerLong;
-
+        int dataLengthAsLongCount = getLongsRequiredToEncodeEntries(bitsPerEntry, entryCount);
         long[] dataArray = new long[dataLengthAsLongCount];
 
-        for(int i = 0; i < dataLengthAsLongCount; i++){
+        for (int i = 0; i < dataLengthAsLongCount; i++) {
             dataArray[i] = dataSource.readLong();
         }
 
@@ -98,64 +85,49 @@ public abstract class ChunkHider {
 
             byte bitsPerBlock = in.readByte();
 
-            if(bitsPerBlock == 0) {
+            if (bitsPerBlock == 0) {
                 int sectionBlockId = ProtocolUtils.readVarInt(in);
 
                 out.writeShort(blockCount);
                 out.writeByte(bitsPerBlock);
                 ProtocolUtils.writeVarInt(out, sectionBlockId);
-            }
-            else if (bitsPerBlock <= BIT_PER_BLOCK_INDIRECTION_LIMIT) {
+            } else if (bitsPerBlock <= BIT_PER_BLOCK_INDIRECTION_LIMIT) {
                 int palletLength = ProtocolUtils.readVarInt(in);
                 int[] pallet = ProtocolUtils.readVarIntArray(in, palletLength);
 
-                System.out.println(Arrays.toString(pallet));
-
-                long[] rawData = readSectionDataFromBuffer(in, bitsPerBlock,  BLOCKS_PER_SECTION);
+                long[] rawData = readSectionDataFromBuffer(in, bitsPerBlock, BLOCKS_PER_SECTION);
                 SimpleBitStorage data = new SimpleBitStorage(bitsPerBlock, BLOCKS_PER_SECTION, rawData);
 
                 int[] resolvedData = new int[BLOCKS_PER_SECTION];
-                for(int i = 0; i < BLOCKS_PER_SECTION; i++){
+                for (int i = 0; i < BLOCKS_PER_SECTION; i++) {
                     int palletReference = data.get(i);
                     resolvedData[i] = pallet[palletReference];
                 }
 
-                int[] obfuscatedData = new int[BLOCKS_PER_SECTION];
-                for (int sectionY = 0; sectionY < 16; sectionY++) {
-                    for (int sectionZ = 0; sectionZ < 16; sectionZ++) {
-                        for (int sectionX = 0; sectionX < 16; sectionX++) {
-                            int blockDataIndex = (((sectionY * 16) + sectionZ) * 16) + sectionX;
+                int[] obfuscatedBlockData = obfuscateBlockDataArray(player, chunkX, chunkZ, yOffset, resolvedData);
 
-                            int worldX = sectionX * chunkX;
-                            int worldY = sectionY * yOffset;
-                            int worldZ = sectionZ * chunkZ;
+                long[] reEncodedData = encodeDirectBlockDataArray(obfuscatedBlockData);
 
-                            int blockId = resolvedData[blockDataIndex];
-                            System.out.println("DEV - " + blockId);
-                            Block block =  BuiltInRegistries.BLOCK.get(blockId).get().value();
 
-                            if(isPlayerPrivilegedToAccessPosition(player, worldX, worldY, worldZ) && isPlayerPrivilegedToAccessBlock(player, worldX, worldY, worldZ, block)) {
-                                obfuscatedData[blockDataIndex] = blockId;
-                            }
-                            else {
-                                obfuscatedData[blockDataIndex] = blockIdUsedForHiding;
-                            }
-                        }
-                    }
+                out.writeShort(blockCount);
+                out.writeByte(15);
+                for (long rawDataSegment : reEncodedData) {
+                    out.writeLong(rawDataSegment);
                 }
-
+                /*
                 Int2IntMap blockIdToPalletIndex = new Int2IntOpenHashMap();
-                int[] newPallet = new int[palletLength];
-                int runningIndex = 0;
+                IntArrayList newPallet = new IntArrayList();
 
                 for(int blockId : obfuscatedData) {
                     if(!blockIdToPalletIndex.containsKey(blockId)) {
-                        newPallet[runningIndex] = blockId;
-                        blockIdToPalletIndex.put(blockId, runningIndex);
-                        runningIndex++;
+                        newPallet.add(blockId);
+                        blockIdToPalletIndex.put(blockId, newPallet.size());
                     }
                 }
 
+                byte newBitsPerBlock = (byte) getUnsignedBitLength(newPallet.size());
+                int[] newPalletRaw = newPallet.toArray(new int[newPallet.size()]);
+
                 SimpleBitStorage reEncodedData = new SimpleBitStorage(bitsPerBlock, BLOCKS_PER_SECTION, new long[rawData.length]);
                 for(int i = 0; i < obfuscatedData.length; i++) {
                     int blockId = obfuscatedData[i];
@@ -164,56 +136,27 @@ public abstract class ChunkHider {
                     reEncodedData.set(i, palletReference);
                 }
 
-                out.writeByte(blockCount);
-                out.writeByte(bitsPerBlock);
+                out.writeShort(blockCount);
+                out.writeByte(newBitsPerBlock);
                 ProtocolUtils.writeVarInt(out, palletLength);
-                ProtocolUtils.writeVarIntArray(out, pallet);
+                ProtocolUtils.writeVarIntArray(out, newPalletRaw);
                 for(long rawDataSegment : reEncodedData.getRaw()) {
                     out.writeLong(rawDataSegment);
-                }
-            }
-            else {
-                long[] rawData = readSectionDataFromBuffer(in, bitsPerBlock,  BLOCKS_PER_SECTION);
-                SimpleBitStorage data = new SimpleBitStorage(bitsPerBlock, BLOCKS_PER_SECTION, rawData);
+                }*/
 
-                int[] resolvedData = new int[BLOCKS_PER_SECTION];
-                for(int i = 0; i < BLOCKS_PER_SECTION; i++){
-                    resolvedData[i] = data.get(i);
-                }
+            } else {
+                long[] rawData = readSectionDataFromBuffer(in, bitsPerBlock, BLOCKS_PER_SECTION);
 
-                int[] obfuscatedData = new int[BLOCKS_PER_SECTION];
-                for (int sectionY = 0; sectionY < 16; sectionY++) {
-                    for (int sectionZ = 0; sectionZ < 16; sectionZ++) {
-                        for (int sectionX = 0; sectionX < 16; sectionX++) {
-                            int blockDataIndex = (((sectionY * 16) + sectionZ) * 16) + sectionX;
+                int[] blockData = resolveDirectBlockDataArray(rawData, bitsPerBlock);
 
-                            int worldX = sectionX * chunkX;
-                            int worldY = sectionY * yOffset;
-                            int worldZ = sectionZ * chunkZ;
+                int[] obfuscatedBlockData = obfuscateBlockDataArray(player, chunkX, chunkZ, yOffset, blockData);
 
-                            int blockId = resolvedData[blockDataIndex];
-                            Block block =  BuiltInRegistries.BLOCK.get(blockId).get().value();
+                long[] reEncodedData = encodeDirectBlockDataArray(obfuscatedBlockData);
 
-                            if(isPlayerPrivilegedToAccessPosition(player, worldX, worldY, worldZ) && isPlayerPrivilegedToAccessBlock(player, worldX, worldY, worldZ, block)) {
-                                obfuscatedData[blockDataIndex] = blockId;
-                            }
-                            else {
-                                obfuscatedData[blockDataIndex] = blockIdUsedForHiding;
-                            }
-                        }
-                    }
-                }
 
-                SimpleBitStorage reEncodedData = new SimpleBitStorage(bitsPerBlock, BLOCKS_PER_SECTION, new long[rawData.length]);
-                for(int i = 0; i < obfuscatedData.length; i++) {
-                    int blockId = obfuscatedData[i];
-
-                    reEncodedData.set(i, blockId);
-                }
-
-                out.writeByte(blockCount);
-                out.writeByte(bitsPerBlock);
-                for(long rawDataSegment : reEncodedData.getRaw()) {
+                out.writeShort(blockCount);
+                out.writeByte(15);
+                for (long rawDataSegment : reEncodedData) {
                     out.writeLong(rawDataSegment);
                 }
             }
@@ -228,78 +171,120 @@ public abstract class ChunkHider {
         byte[] data = new byte[out.readableBytes()];
         out.readBytes(data);
 
-        List<Object> blockEntities = chunkBlockEntitiesDataField.get(chunkData);
-        List<Object> filteredBlockEntities = filterBlockEntities(player, blockEntities);
+        List<ClientboundLevelChunkPacketData.BlockEntityInfo> blockEntities = chunkData.blockEntitiesData;
+        List<ClientboundLevelChunkPacketData.BlockEntityInfo> filteredBlockEntities = filterBlockEntities(player, blockEntities, chunkX, chunkZ);
 
         return buildNewChunkPacket(packet, data, filteredBlockEntities);
 
     }
 
-    public abstract boolean isPlayerPrivilegedToAccessPosition(Player p, int blockX, int blockY, int blockZ);
-    public abstract boolean isPlayerPrivilegedToAccessBlock(Player p, int blockX, int blockY, int blockZ, Block block);
-    public abstract boolean isPlayerPrivilegedToAccessBlockEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type);
+    private int[] obfuscateBlockDataArray(Player player, int chunkX, int chunkZ, int yOffset, int[] blockDataArray) {
+        int[] obfuscatedData = new int[BLOCKS_PER_SECTION];
+        for (int sectionY = 0; sectionY < SECTION_SPAN_SIZE; sectionY++) {
+            for (int sectionZ = 0; sectionZ < SECTION_SPAN_SIZE; sectionZ++) {
+                for (int sectionX = 0; sectionX < SECTION_SPAN_SIZE; sectionX++) {
+                    int blockDataIndex = (((sectionY * SECTION_SPAN_SIZE) + sectionZ) * SECTION_SPAN_SIZE) + sectionX;
 
-    private ClientboundLevelChunkWithLightPacket buildNewChunkPacket(ClientboundLevelChunkWithLightPacket originalPacket, byte[] newBlockDataBuffer, List<Object> newBlockEntities) {
-        ClientboundLevelChunkWithLightPacket clonedPacket = (ClientboundLevelChunkWithLightPacket) chunkPacketShallowCloner.apply(originalPacket);
-        ClientboundLevelChunkPacketData clonedPacketChunkData = (ClientboundLevelChunkPacketData) chunkDataShallowCloner.apply(originalPacket.getChunkData());
+                    int worldX = sectionX + (SECTION_SPAN_SIZE * chunkX);
+                    int worldY = sectionY + yOffset;
+                    int worldZ = sectionZ + (SECTION_SPAN_SIZE * chunkZ);
 
-        chunkBlockDataField.set(clonedPacketChunkData, newBlockDataBuffer);
-        chunkBlockEntitiesDataField.set(clonedPacketChunkData, newBlockEntities);
+                    int blockId = blockDataArray[blockDataIndex];
+                    BlockState blockState = Block.BLOCK_STATE_REGISTRY.byId(blockId);
+                    Block block = blockState.getBlock();
 
-        levelChunkPacketDataField.set(clonedPacket, clonedPacketChunkData);
 
-        return  clonedPacket;
+                    if (accessPrivilegeProvider.isPlayerPrivilegedToAccessPosition(player, worldX, worldY, worldZ) && accessPrivilegeProvider.isPlayerPrivilegedToAccessBlock(player, worldX, worldY, worldZ, block) && accessPrivilegeProvider.isPlayerPrivilegedToAccessBlockState(player, worldX, worldY, worldZ, blockState)) {
+                        obfuscatedData[blockDataIndex] = blockId;
+                    } else {
+                        obfuscatedData[blockDataIndex] = blockIdUsedForHiding;
+                    }
+                }
+            }
+        }
+
+        return obfuscatedData;
     }
 
+    private int[] resolveDirectBlockDataArray(long[] rawDataArray, byte bitsPerBlock) {
+        SimpleBitStorage data = new SimpleBitStorage(bitsPerBlock, BLOCKS_PER_SECTION, rawDataArray);
 
-    private static final Class<?> blockEntitiyInfoClass = Reflection.getClass("net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData$BlockEntityInfo");
+        int[] resolvedData = new int[BLOCKS_PER_SECTION];
+        for (int i = 0; i < BLOCKS_PER_SECTION; i++) {
+            resolvedData[i] = data.get(i);
+        }
+
+        return resolvedData;
+    }
+
+    private long[] encodeDirectBlockDataArray(int[] blockDataArray) {
+        int longsRequiredToEncodeData = getLongsRequiredToEncodeEntries(15, blockDataArray.length);
+
+        SimpleBitStorage reEncodedData = new SimpleBitStorage(15, BLOCKS_PER_SECTION, new long[longsRequiredToEncodeData]);
+        for (int i = 0; i < blockDataArray.length; i++) {
+            int blockId = blockDataArray[i];
+
+            reEncodedData.set(i, blockId);
+        }
+
+        return reEncodedData.getRaw();
+    }
+
+    private ClientboundLevelChunkWithLightPacket buildNewChunkPacket(ClientboundLevelChunkWithLightPacket originalPacket, byte[] newBlockDataBuffer, List<ClientboundLevelChunkPacketData.BlockEntityInfo> newBlockEntities) {
+        ClientboundLevelChunkWithLightPacket clonedPacket = chunkPacketShallowCloner.apply(originalPacket);
+        ClientboundLevelChunkPacketData clonedPacketChunkData = chunkDataShallowCloner.apply(originalPacket.getChunkData());
+
+        clonedPacketChunkData.buffer = newBlockDataBuffer;
+        clonedPacketChunkData.blockEntitiesData = newBlockEntities;
+        clonedPacket.chunkData = clonedPacketChunkData;
+
+        return clonedPacket;
+    }
+
+    private List<ClientboundLevelChunkPacketData.BlockEntityInfo> filterBlockEntities(Player player, List<ClientboundLevelChunkPacketData.BlockEntityInfo> blockEntities, int chunkX, int chunkZ) {
+        int fourBitBitmask = 0b0000_1111;
 
-    private static final Reflection.Field<BlockEntityType> blockEntityInfoTypeField = Reflection.getField(blockEntitiyInfoClass, BlockEntityType.class, 0);
-    private static final Reflection.Field<Integer> packedXZField = Reflection.getField(blockEntitiyInfoClass, int.class, 0);
-    private static final Reflection.Field<Integer> yField = Reflection.getField(blockEntitiyInfoClass, int.class, 1);
-    private List<Object> filterBlockEntities(Player player, List<Object> blockEntities) {
         return blockEntities.stream()
                 .filter((blockEntityInfo) -> {
-                    BlockEntityType<?> type = blockEntityInfoTypeField.get(blockEntityInfo);
+                    BlockEntityType<?> type = blockEntityInfo.type;
+                    int packedXZ = blockEntityInfo.packedXZ;
 
-                    int packedXZ = packedXZField.get(blockEntityInfo);
+                    int localX = (packedXZ >> 4) & fourBitBitmask;
+                    int localZ = packedXZ & fourBitBitmask;
 
-                    int y = yField.get(blockEntityInfo);
-                    int x = SectionPos.sectionRelativeX((short) packedXZ);
-                    int z = SectionPos.sectionRelativeZ((short) packedXZ);
+                    int worldX = (chunkX * SECTION_SPAN_SIZE) + localX;
+                    int worldZ = (chunkZ * SECTION_SPAN_SIZE) + localZ;
 
-                    return isPlayerPrivilegedToAccessPosition(player, x, y, z) && isPlayerPrivilegedToAccessBlockEntity(player, x, y, z, type);
+                    int worldY = blockEntityInfo.y;
+
+                    return accessPrivilegeProvider.isPlayerPrivilegedToAccessPosition(player, worldX, worldY, worldZ) && accessPrivilegeProvider.isPlayerPrivilegedToAccessBlockEntity(player, worldX, worldY, worldZ, type);
                 }).toList();
     }
 
-    private void copyOverSectionBiomeData(ByteBuf oldData, ByteBuf newData){
-        short bitsPerBiome = oldData.readShort();
-        newData.writeShort(bitsPerBiome);
-        System.out.println(bitsPerBiome);
-        if(bitsPerBiome == 0) {
+    private void copyOverSectionBiomeData(ByteBuf oldData, ByteBuf newData) {
+        short bitsPerBiome = oldData.readByte();
+        newData.writeByte(bitsPerBiome);
+        if (bitsPerBiome == 0) {
             int sectionBiomeId = ProtocolUtils.readVarInt(oldData);
             ProtocolUtils.writeVarInt(newData, sectionBiomeId);
-        }
-        else if(bitsPerBiome <= BIT_PER_BIOME_INDIRECTION_LIMIT) {
+        } else if (bitsPerBiome <= BIT_PER_BIOME_INDIRECTION_LIMIT) {
             int palletLength = ProtocolUtils.readVarInt(oldData);
             ProtocolUtils.writeVarInt(newData, palletLength);
 
-            for(int i = 0; i < palletLength; i++) {
+            for (int i = 0; i < palletLength; i++) {
                 int palletEntry = ProtocolUtils.readVarInt(oldData);
                 ProtocolUtils.writeVarInt(newData, palletEntry);
             }
 
-            long[] rawData = readSectionDataFromBuffer(oldData, bitsPerBiome,  BIOMES_PER_SECTION);
-            for(long rawDataSegment : rawData ) {
+            long[] rawData = readSectionDataFromBuffer(oldData, bitsPerBiome, BIOMES_PER_SECTION);
+            for (long rawDataSegment : rawData) {
+                newData.writeLong(rawDataSegment);
+            }
+        } else {
+            long[] rawData = readSectionDataFromBuffer(oldData, bitsPerBiome, BIOMES_PER_SECTION);
+            for (long rawDataSegment : rawData) {
                 newData.writeLong(rawDataSegment);
             }
         }
-        else {
-            long[] rawData = readSectionDataFromBuffer(oldData, bitsPerBiome,  BIOMES_PER_SECTION);
-            for(long rawDataSegment : rawData ) {
-                newData.writeLong(rawDataSegment);
-            }
-        }
-
     }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/ProtocolUtils.java

@@ -19,64 +19,37 @@
 
 package de.steamwar.techhider;
 
-import com.google.common.primitives.Bytes;
-import de.steamwar.Reflection;
 import io.netty.buffer.ByteBuf;
 
-import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
+import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
 public class ProtocolUtils {
     private ProtocolUtils() {
     }
 
-    @Deprecated
-    public static BiFunction<Object, UnaryOperator<Object>, Object> arrayCloneGenerator(Class<?> elementClass) {
-        return (array, worker) -> {
-            int length = Array.getLength(array);
-            Object result = Array.newInstance(elementClass, length);
-
-            for (int i = 0; i < length; i++) {
-                Array.set(result, i, worker.apply(Array.get(array, i)));
-            }
-
-            return result;
-        };
-    }
-
-    public static UnaryOperator<Object> shallowCloneGenerator(Class<?> clazz) {
-        BiConsumer<Object, Object> filler = shallowFill(clazz);
+    public static <T> UnaryOperator<T> shallowCloneGenerator(Class<T> clazz, Supplier<T> supplier) {
+        BiConsumer<T, T> filler = shallowFill(clazz);
 
         return source -> {
-            Object clone = Reflection.newInstance(clazz);
+            T clone = supplier.get();
             filler.accept(source, clone);
             return clone;
         };
     }
 
-    public static <T> UnaryOperator<T> shallowTypedCloneGenerator(Class<T> clazz) {
-        BiConsumer<Object, Object> filler = shallowFill(clazz);
-
-        return source -> {
-            Object clone = Reflection.newInstance(clazz);
-            filler.accept(source, clone);
-            return (T) clone;
-        };
-    }
-
-    private static BiConsumer<Object, Object> shallowFill(Class<?> clazz) {
+    private static <T> BiConsumer<T, T> shallowFill(Class<T> clazz) {
         if (clazz == null) {
             return (source, clone) -> {
             };
         }
 
-        BiConsumer<Object, Object> superFiller = shallowFill(clazz.getSuperclass());
+        BiConsumer superFiller = shallowFill(clazz.getSuperclass());
 
         Field[] fds = clazz.getDeclaredFields();
         List<Field> fields = new ArrayList<>();
@@ -106,25 +79,6 @@ public class ProtocolUtils {
         return chunk;
     }
 
-    @Deprecated
-    public static int readVarInt(byte[] array, int startPos) {
-        int numRead = 0;
-        int result = 0;
-        byte read;
-        do {
-            read = array[startPos + numRead];
-            int value = (read & 0b01111111);
-            result |= (value << (7 * numRead));
-
-            numRead++;
-            if (numRead > 5) {
-                break;
-            }
-        } while ((read & 0b10000000) != 0);
-
-        return result;
-    }
-
     public static int readVarInt(ByteBuf buf) {
         int numRead = 0;
         int result = 0;
@@ -143,7 +97,7 @@ public class ProtocolUtils {
     public static int[] readVarIntArray(ByteBuf buffer, int length) {
         int[] array = new int[length];
 
-        for(int i = 0; i < length; i++) {
+        for (int i = 0; i < length; i++) {
             array[i] = readVarInt(buffer);
         }
 
@@ -162,58 +116,9 @@ public class ProtocolUtils {
         } while (value != 0);
     }
 
-    public static void writeVarIntArray(ByteBuf buf, int[] values){
-        for(int varInt : values) {
+    public static void writeVarIntArray(ByteBuf buf, int[] values) {
+        for (int varInt : values) {
             writeVarInt(buf, varInt);
         }
     }
-
-    @Deprecated
-    public static int readVarIntLength(byte[] array, int startPos) {
-        int numRead = 0;
-        byte read;
-        do {
-            read = array[startPos + numRead];
-            numRead++;
-            if (numRead > 5) {
-                break;
-            }
-        } while ((read & 0b10000000) != 0);
-
-        return numRead;
-    }
-
-    @Deprecated
-    public static byte[] writeVarInt(int value) {
-        List<Byte> buffer = new ArrayList<>(5);
-        do {
-            byte temp = (byte) (value & 0b01111111);
-            // Note: >>> means that the sign bit is shifted with the rest of the number rather than being left alone
-            value >>>= 7;
-            if (value != 0) {
-                temp |= 0b10000000;
-            }
-            buffer.add(temp);
-        } while (value != 0);
-        return Bytes.toArray(buffer);
-    }
-
-    @Deprecated
-    public static class ChunkPos {
-        final int x;
-        final int z;
-
-        public ChunkPos(int x, int z) {
-            this.x = x;
-            this.z = z;
-        }
-
-        public final int x() {
-            return x;
-        }
-
-        public final int z() {
-            return z;
-        }
-    }
 }

SpigotCore/SpigotCore_Main/src/de/steamwar/techhider/TechHider.java

@@ -1,207 +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.techhider;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.ToIntFunction;
-
+import com.comphenix.tinyprotocol.TinyProtocol;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
 import it.unimi.dsi.fastutil.shorts.ShortArraySet;
 import it.unimi.dsi.fastutil.shorts.ShortSets;
-import net.minecraft.network.UnconfiguredPipelineHandler;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.block.entity.BlockEntityType;
-import net.minecraft.world.phys.Vec3;
-import org.bukkit.entity.Player;
-
-import com.comphenix.tinyprotocol.TinyProtocol;
-
-import de.steamwar.Reflection;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.SectionPos;
 import net.minecraft.network.PacketListener;
 import net.minecraft.network.protocol.Packet;
-import net.minecraft.network.protocol.handshake.ClientIntentionPacket;
-import net.minecraft.network.protocol.common.ClientboundClearDialogPacket;
-import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
-import net.minecraft.network.protocol.common.ClientboundCustomReportDetailsPacket;
-import net.minecraft.network.protocol.common.ClientboundDisconnectPacket;
-import net.minecraft.network.protocol.common.ClientboundKeepAlivePacket;
-import net.minecraft.network.protocol.common.ClientboundPingPacket;
-import net.minecraft.network.protocol.common.ClientboundResourcePackPopPacket;
-import net.minecraft.network.protocol.common.ClientboundResourcePackPushPacket;
-import net.minecraft.network.protocol.common.ClientboundServerLinksPacket;
-import net.minecraft.network.protocol.common.ClientboundShowDialogPacket;
-import net.minecraft.network.protocol.common.ClientboundStoreCookiePacket;
-import net.minecraft.network.protocol.common.ClientboundTransferPacket;
-import net.minecraft.network.protocol.common.ClientboundUpdateTagsPacket;
+import net.minecraft.network.protocol.common.*;
 import net.minecraft.network.protocol.configuration.ClientboundFinishConfigurationPacket;
 import net.minecraft.network.protocol.configuration.ClientboundRegistryDataPacket;
+import net.minecraft.network.protocol.configuration.ClientboundSelectKnownPacks;
 import net.minecraft.network.protocol.configuration.ClientboundUpdateEnabledFeaturesPacket;
 import net.minecraft.network.protocol.cookie.ClientboundCookieRequestPacket;
-import net.minecraft.network.protocol.game.ClientboundAddEntityPacket;
-import net.minecraft.network.protocol.game.ClientboundAnimatePacket;
-import net.minecraft.network.protocol.game.ClientboundBlockChangedAckPacket;
-import net.minecraft.network.protocol.game.ClientboundBlockDestructionPacket;
-import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket;
-import net.minecraft.network.protocol.game.ClientboundBlockEventPacket;
-import net.minecraft.network.protocol.game.ClientboundBlockUpdatePacket;
-import net.minecraft.network.protocol.game.ClientboundBossEventPacket;
-import net.minecraft.network.protocol.game.ClientboundBundleDelimiterPacket;
-import net.minecraft.network.protocol.game.ClientboundBundlePacket;
-import net.minecraft.network.protocol.game.ClientboundChangeDifficultyPacket;
-import net.minecraft.network.protocol.game.ClientboundChunkBatchFinishedPacket;
-import net.minecraft.network.protocol.game.ClientboundChunkBatchStartPacket;
-import net.minecraft.network.protocol.game.ClientboundClearTitlesPacket;
-import net.minecraft.network.protocol.game.ClientboundCommandSuggestionsPacket;
-import net.minecraft.network.protocol.game.ClientboundCommandsPacket;
-import net.minecraft.network.protocol.game.ClientboundContainerClosePacket;
-import net.minecraft.network.protocol.game.ClientboundContainerSetContentPacket;
-import net.minecraft.network.protocol.game.ClientboundContainerSetDataPacket;
-import net.minecraft.network.protocol.game.ClientboundContainerSetSlotPacket;
-import net.minecraft.network.protocol.game.ClientboundCooldownPacket;
-import net.minecraft.network.protocol.game.ClientboundCustomChatCompletionsPacket;
-import net.minecraft.network.protocol.game.ClientboundDamageEventPacket;
-import net.minecraft.network.protocol.game.ClientboundDeleteChatPacket;
-import net.minecraft.network.protocol.game.ClientboundDisguisedChatPacket;
-import net.minecraft.network.protocol.game.ClientboundEntityEventPacket;
-import net.minecraft.network.protocol.game.ClientboundEntityPositionSyncPacket;
-import net.minecraft.network.protocol.game.ClientboundExplodePacket;
-import net.minecraft.network.protocol.game.ClientboundForgetLevelChunkPacket;
-import net.minecraft.network.protocol.game.ClientboundGameEventPacket;
-import net.minecraft.network.protocol.game.ClientboundHorseScreenOpenPacket;
-import net.minecraft.network.protocol.game.ClientboundHurtAnimationPacket;
-import net.minecraft.network.protocol.game.ClientboundInitializeBorderPacket;
-import net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket;
-import net.minecraft.network.protocol.game.ClientboundLevelEventPacket;
-import net.minecraft.network.protocol.game.ClientboundLevelParticlesPacket;
-import net.minecraft.network.protocol.game.ClientboundLightUpdatePacket;
-import net.minecraft.network.protocol.game.ClientboundLoginPacket;
-import net.minecraft.network.protocol.game.ClientboundMapItemDataPacket;
-import net.minecraft.network.protocol.game.ClientboundMerchantOffersPacket;
-import net.minecraft.network.protocol.game.ClientboundMoveEntityPacket;
-import net.minecraft.network.protocol.game.ClientboundMoveMinecartPacket;
-import net.minecraft.network.protocol.game.ClientboundMoveVehiclePacket;
-import net.minecraft.network.protocol.game.ClientboundOpenBookPacket;
-import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
-import net.minecraft.network.protocol.game.ClientboundOpenSignEditorPacket;
-import net.minecraft.network.protocol.game.ClientboundPlaceGhostRecipePacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerAbilitiesPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerChatPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerCombatEndPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerCombatEnterPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerCombatKillPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerInfoRemovePacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerLookAtPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerPositionPacket;
-import net.minecraft.network.protocol.game.ClientboundPlayerRotationPacket;
-import net.minecraft.network.protocol.game.ClientboundProjectilePowerPacket;
-import net.minecraft.network.protocol.game.ClientboundRecipeBookAddPacket;
-import net.minecraft.network.protocol.game.ClientboundRecipeBookRemovePacket;
-import net.minecraft.network.protocol.game.ClientboundRecipeBookSettingsPacket;
-import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket;
-import net.minecraft.network.protocol.game.ClientboundRemoveMobEffectPacket;
-import net.minecraft.network.protocol.game.ClientboundResetScorePacket;
-import net.minecraft.network.protocol.game.ClientboundRespawnPacket;
-import net.minecraft.network.protocol.game.ClientboundRotateHeadPacket;
-import net.minecraft.network.protocol.game.ClientboundSectionBlocksUpdatePacket;
-import net.minecraft.network.protocol.game.ClientboundSelectAdvancementsTabPacket;
-import net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket;
-import net.minecraft.network.protocol.game.ClientboundSetBorderCenterPacket;
-import net.minecraft.network.protocol.game.ClientboundSetBorderLerpSizePacket;
-import net.minecraft.network.protocol.game.ClientboundSetBorderSizePacket;
-import net.minecraft.network.protocol.game.ClientboundSetBorderWarningDelayPacket;
-import net.minecraft.network.protocol.game.ClientboundSetBorderWarningDistancePacket;
-import net.minecraft.network.protocol.game.ClientboundSetCameraPacket;
-import net.minecraft.network.protocol.game.ClientboundSetChunkCacheCenterPacket;
-import net.minecraft.network.protocol.game.ClientboundSetChunkCacheRadiusPacket;
-import net.minecraft.network.protocol.game.ClientboundSetCursorItemPacket;
-import net.minecraft.network.protocol.game.ClientboundServerDataPacket;
-import net.minecraft.network.protocol.game.ClientboundSetDefaultSpawnPositionPacket;
-import net.minecraft.network.protocol.game.ClientboundSetDisplayObjectivePacket;
-import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket;
-import net.minecraft.network.protocol.game.ClientboundSetEntityLinkPacket;
-import net.minecraft.network.protocol.game.ClientboundSetEntityMotionPacket;
-import net.minecraft.network.protocol.game.ClientboundSetEquipmentPacket;
-import net.minecraft.network.protocol.game.ClientboundSetExperiencePacket;
-import net.minecraft.network.protocol.game.ClientboundSetHeldSlotPacket;
-import net.minecraft.network.protocol.game.ClientboundSetHealthPacket;
-import net.minecraft.network.protocol.game.ClientboundSetObjectivePacket;
-import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket;
-import net.minecraft.network.protocol.game.ClientboundSetPlayerInventoryPacket;
-import net.minecraft.network.protocol.game.ClientboundSetPlayerTeamPacket;
-import net.minecraft.network.protocol.game.ClientboundSetScorePacket;
-import net.minecraft.network.protocol.game.ClientboundSetSimulationDistancePacket;
-import net.minecraft.network.protocol.game.ClientboundSetSubtitleTextPacket;
-import net.minecraft.network.protocol.game.ClientboundSetTimePacket;
-import net.minecraft.network.protocol.game.ClientboundSetTitleTextPacket;
-import net.minecraft.network.protocol.game.ClientboundSetTitlesAnimationPacket;
-import net.minecraft.network.protocol.game.ClientboundSoundEntityPacket;
-import net.minecraft.network.protocol.game.ClientboundSoundPacket;
-import net.minecraft.network.protocol.game.ClientboundStartConfigurationPacket;
-import net.minecraft.network.protocol.game.ClientboundStopSoundPacket;
-import net.minecraft.network.protocol.game.ClientboundSystemChatPacket;
-import net.minecraft.network.protocol.game.ClientboundTabListPacket;
-import net.minecraft.network.protocol.game.ClientboundTagQueryPacket;
-import net.minecraft.network.protocol.game.ClientboundTakeItemEntityPacket;
-import net.minecraft.network.protocol.game.ClientboundTeleportEntityPacket;
-import net.minecraft.network.protocol.game.ClientboundTickingStatePacket;
-import net.minecraft.network.protocol.game.ClientboundTickingStepPacket;
-import net.minecraft.network.protocol.game.ClientboundTrackedWaypointPacket;
-import net.minecraft.network.protocol.game.ClientboundUpdateAdvancementsPacket;
-import net.minecraft.network.protocol.game.ClientboundUpdateAttributesPacket;
-import net.minecraft.network.protocol.game.ClientboundUpdateMobEffectPacket;
-import net.minecraft.network.protocol.game.ClientboundUpdateRecipesPacket;
-import net.minecraft.network.protocol.login.ClientboundCustomQueryPacket;
-import net.minecraft.network.protocol.login.ClientboundHelloPacket;
-import net.minecraft.network.protocol.login.ClientboundLoginCompressionPacket;
-import net.minecraft.network.protocol.login.ClientboundLoginDisconnectPacket;
-import net.minecraft.network.protocol.login.ClientboundLoginFinishedPacket;
-import net.minecraft.network.protocol.configuration.ClientboundSelectKnownPacks;
+import net.minecraft.network.protocol.game.*;
+import net.minecraft.network.protocol.login.*;
 import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec3;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.ToIntFunction;
 
 /**
  * The TechHider follows the default-deny security principle,
  * any packet must be explicitly whitelisted or processed in a
  * way that is also compliant with the principle of default-deny.
  */
-public abstract class TechHider {
+public class TechHider {
     private final Set<Class<?>> bypassingPackets;
     private final Map<Class<? extends Packet<? extends PacketListener>>, BiFunction<Player, Packet<? extends PacketListener>, Packet<? extends PacketListener>>> packetProcessors;
 
-    private final Block blockUsedForObfuscation;
     private final BlockState blockStateUsedForObfuscation;
-    private ChunkHider chunkHider;
+    private final ChunkHider chunkHider;
+
+    private final AccessPrivilegeProvider privilegeProvider;
 
     // TODO handle packet bundle
-    public TechHider(Block blockUsedForObfuscation) {
-        this.blockUsedForObfuscation = blockUsedForObfuscation;
+    public TechHider(Block blockUsedForObfuscation, AccessPrivilegeProvider privilegeProvider) {
         this.blockStateUsedForObfuscation = blockUsedForObfuscation.defaultBlockState();
 
-        this.chunkHider = new ChunkHider(blockUsedForObfuscation) {
-            @Override
-            public boolean isPlayerPrivilegedToAccessBlock(Player p, int blockX, int blockY, int blockZ, Block block) {
-                return TechHider.this.isPlayerPrivilegedToAccessBlock(p, blockX, blockY, blockZ, block);
-            }
-
-            @Override
-            public boolean isPlayerPrivilegedToAccessBlockEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type) {
-                return TechHider.this.isPlayerPrivilegedToAccessBlocEntity(p, blockX, blockY, blockZ, type);
-            }
-
-            @Override
-            public boolean isPlayerPrivilegedToAccessPosition(Player p, int blockX, int blockY, int blockZ) {
-                return TechHider.this.isPlayerPrivilegedToAccessPosition(p, blockX, blockY, blockZ);
-            }
-        };
+        this.chunkHider = new ChunkHider(blockUsedForObfuscation, privilegeProvider);
+        this.privilegeProvider = privilegeProvider;
 
         this.bypassingPackets = new HashSet<>(List.of(
                 // --- 5.1.x Login Protocol ---
@@ -213,8 +78,7 @@ public abstract class TechHider {
                 ClientboundCookieRequestPacket.class, // 5.1.6 Cookie Request
 
                 // --- 6.1.x Configuration Protocol ---
-                ClientboundSelectKnownPacks.class,
-                ClientboundCustomPayloadPacket.class, // 6.1.2 Clientbound Plugin Message
+                ClientboundSelectKnownPacks.class, ClientboundCustomPayloadPacket.class, // 6.1.2 Clientbound Plugin Message
                 ClientboundFinishConfigurationPacket.class, // 6.1.4 Finish Configuration
                 ClientboundKeepAlivePacket.class, // 6.1.5 Clientbound Keep Alive
                 ClientboundPingPacket.class, // 6.1.6 Ping
@@ -227,7 +91,7 @@ public abstract class TechHider {
                 ClientboundCustomReportDetailsPacket.class, // 6.1.16 Custom Report Details
                 ClientboundServerLinksPacket.class, // 6.1.17 Server Links
                 ClientboundSystemChatPacket.class, // 6.1.18/19 Dialogs are often handled via System Chat or Custom
-                                                   // Payloads
+                // Payloads
                 ClientboundServerDataPacket.class, // 6.1.20 Code of Conduct is usually in Server Data
 
                 // --- 7.1.x Play Protocol ---
@@ -287,7 +151,7 @@ public abstract class TechHider {
                 ClientboundSetHeldSlotPacket.class, // 7.1.104 Set Held Item (Player owning the channel)
                 ClientboundSetObjectivePacket.class, // 7.1.105 Update Objectives
                 ClientboundSetPlayerInventoryPacket.class, // 7.1.107 Set Player Inventory Slot (Player owning the channel)
-                ClientboundSetPlayerTeamPacket.class, // 7.1.108 Update Teams
+                // ClientboundSetPlayerTeamPacket.class, // 7.1.108 Update Teams
                 ClientboundSetScorePacket.class, // 7.1.109 Update Score
                 ClientboundSetSimulationDistancePacket.class, // 7.1.110 Set Simulation Distance
                 ClientboundSetSubtitleTextPacket.class, // 7.1.111 Set Subtitle Text
@@ -312,23 +176,26 @@ public abstract class TechHider {
                 ClientboundBlockChangedAckPacket.class, // 7.1.5 Acknowledge Block Change
                 ClientboundChunkBatchFinishedPacket.class, // 7.1.12 Chunk Batch Finished (Delimiter)
                 ClientboundChunkBatchStartPacket.class, // 7.1.13 Chunk Batch Start (Delimiter)
-                // ClientboundChunksBiomesPacket.class, // 7.1.14 Chunk Biomes
+                ClientboundChunksBiomesPacket.class, // 7.1.14 Chunk Biomes
                 ClientboundContainerClosePacket.class, // 7.1.18 Close Container
                 ClientboundSetChunkCacheCenterPacket.class, // 7.1.93 Set Center Chunk
                 ClientboundForgetLevelChunkPacket.class, // 7.1.38 Unload Chunk
                 ClientboundUpdateTagsPacket.class, // 7.1.133 Update Tags (play)
                 ClientboundPlayerInfoRemovePacket.class, // 7.1.68 Player Info Remove
                 ClientboundPlayerInfoUpdatePacket.class, // 7.1.69 Player Info Update
-                ClientboundMoveVehiclePacket.class // 7.1.56 Move Vehicle (vehicle the player is in)
+                ClientboundMoveVehiclePacket.class, // 7.1.56 Move Vehicle (vehicle the player is in)
+                ClientboundStopSoundPacket.class, // 7.1.118 Stop Sound: sound state side channel
+
+                ClientboundLightUpdatePacket.class, // 7.1.48 Update Light
+
+                ClientboundContainerSetContentPacket.class, // 7.1.19 Set Container Content
+                ClientboundContainerSetDataPacket.class, // 7.1.20 Set Container Property
+                ClientboundContainerSetSlotPacket.class // 7.1.21 Set Container Slot
         ));
 
         BiFunction<Player, Packet<? extends PacketListener>, Packet<? extends PacketListener>> tossPacket = (p, packet) -> null;
         Map<Class<? extends Packet<? extends PacketListener>>, BiFunction<Player, Packet<? extends PacketListener>, Packet<? extends PacketListener>>> processors = new HashMap<>();
 
-        // 7.1.x Bundle Packet: packet container; blocked until nested packets are
-        // safely unbundled/processed.
-        processors.put(ClientboundBundlePacket.class, tossPacket);
-
         // --- Entity packets -
         // 7.1.2 Spawn Entity: entity type and position can reveal hidden contraptions.
         processors.put(ClientboundAddEntityPacket.class, (p, packet) -> this.processAddEntityPacket(p, (ClientboundAddEntityPacket) packet));
@@ -363,11 +230,15 @@ public abstract class TechHider {
         // 7.1.134 Projectile Power: projectile/entity signal.
         processors.put(ClientboundProjectilePowerPacket.class, this.buildEntityPacketProcessor(ClientboundProjectilePowerPacket::getId));
         // 7.1.123 Pickup Item: item/entity ids and pickup activity.
-        processors.put(ClientboundTakeItemEntityPacket.class,  this.buildEntityPacketProcessor(ClientboundTakeItemEntityPacket::getItemId));
+        processors.put(ClientboundTakeItemEntityPacket.class, this.buildEntityPacketProcessor(ClientboundTakeItemEntityPacket::getItemId));
         // 7.1.67 Combat Death: entity/player ids and death message context.
         processors.put(ClientboundPlayerCombatKillPacket.class, this.buildEntityPacketProcessor(ClientboundPlayerCombatKillPacket::playerId));
         // 7.1.52/53/55 Update Entity Position/Rotation: entity id and movement signal.
         processors.put(ClientboundMoveEntityPacket.class, (p, packet) -> this.processMoveEntityPacket(p, (ClientboundMoveEntityPacket) packet));
+        processors.put(ClientboundMoveEntityPacket.Pos.class, (p, packet) -> this.processMoveEntityPacket(p, (ClientboundMoveEntityPacket.Pos) packet));
+        processors.put(ClientboundMoveEntityPacket.Rot.class, (p, packet) -> this.processMoveEntityPacket(p, (ClientboundMoveEntityPacket.Rot) packet));
+        processors.put(ClientboundMoveEntityPacket.PosRot.class, (p, packet) -> this.processMoveEntityPacket(p, (ClientboundMoveEntityPacket.PosRot) packet));
+
         // 7.1.82 Set Head Rotation: entity id and rotation.
         processors.put(ClientboundRotateHeadPacket.class, (p, packet) -> this.processRotateHeadPacket(p, (ClientboundRotateHeadPacket) packet));
         // 7.1.76 Remove Entities: entity id visibility side channel.
@@ -401,25 +272,13 @@ public abstract class TechHider {
         // 7.1.47 Particle: particle type and position can reveal hidden machinery.
         processors.put(ClientboundLevelParticlesPacket.class, (p, packet) -> processLevelParticlesPacket(p, (ClientboundLevelParticlesPacket) packet));
 
-        // --- Lighting packets ---
-        // 7.1.48 Update Light: lighting can reveal hidden blocks/operations.
-        processors.put(ClientboundLightUpdatePacket.class, tossPacket);
-
-        // --- Container packets ---
-        // 7.1.19 Set Container Content
-        processors.put(ClientboundContainerSetContentPacket.class, buildContainerPacketProcessor(ClientboundContainerSetContentPacket::containerId));
-        // 7.1.20 Set Container Property
-        processors.put(ClientboundContainerSetDataPacket.class, buildContainerPacketProcessor(ClientboundContainerSetDataPacket::getContainerId));
-        // 7.1.21 Set Container Slot
-        processors.put(ClientboundContainerSetSlotPacket.class, buildContainerPacketProcessor(ClientboundContainerSetSlotPacket::getContainerId));
-
         // --- Sound packets ---
         // 7.1.115 Entity Sound Effect: entity id and sound.
-        processors.put(ClientboundSoundEntityPacket.class, tossPacket);
+        processors.put(ClientboundSoundEntityPacket.class, this.buildEntityPacketProcessor(ClientboundSoundEntityPacket::getId));
         // 7.1.116 Sound Effect: sound type and position.
-        processors.put(ClientboundSoundPacket.class, tossPacket);
-        // 7.1.118 Stop Sound: sound state side channel.
-        processors.put(ClientboundStopSoundPacket.class, tossPacket);
+        processors.put(ClientboundSoundPacket.class, this.<ClientboundSoundPacket>buildPositionBasedPacketProcessor(packet -> {
+            return new BlockPos.MutableBlockPos(packet.getX(), packet.getY(), packet.getZ()).immutable();
+        }));
 
         // --- Others ---
         // 7.1.137 Waypoint: world/entity tracking signal.
@@ -429,7 +288,7 @@ public abstract class TechHider {
         // 7.1.46 World Event: block position/event id can leak activity.
         processors.put(ClientboundLevelEventPacket.class, buildPositionBasedPacketProcessor(ClientboundLevelEventPacket::getPos));
         // 7.1.59 Open Sign Editor: block position.
-        processors.put(ClientboundOpenSignEditorPacket.class, buildPositionBasedPacketProcessor(ClientboundLevelEventPacket::getPos));
+        processors.put(ClientboundOpenSignEditorPacket.class, buildPositionBasedPacketProcessor(ClientboundOpenSignEditorPacket::getPos));
         // 7.1.37 Explosion: position, affected blocks, and knockback can reveal TNT/tech.
         processors.put(ClientboundExplodePacket.class, (p, rawPacket) -> {
             ClientboundExplodePacket packet = (ClientboundExplodePacket) rawPacket;
@@ -439,31 +298,50 @@ public abstract class TechHider {
             int blockZ = (int) pos.z;
 
 
-            return  proccessPositionBasedPacket(p, blockX, blockY, blockZ, packet);
+            return proccessPositionBasedPacket(p, blockX, blockY, blockZ, packet);
         });
 
         this.packetProcessors = processors;
 
-        TinyProtocol.instance.addGlobalClientboundFilter((player, packet) -> {
-            System.out.println(packet.getClass().toString());
+        TinyProtocol.instance.addGlobalClientboundFilter((player, rawPacket) -> {
+            try {
+                if (rawPacket instanceof ClientboundBundlePacket bundlePacket) {
+                    List<Packet<? super ClientGamePacketListener>> processedPackets = new ArrayList<>();
 
-            if(bypassingPackets.contains(packet.getClass())) {
-                System.out.println("bypassing");
-                return packet;
-            }
-            else if(packetProcessors.containsKey(packet.getClass())) {
-                System.out.println("processing");
-                return packetProcessors.get(packet.getClass()).apply(player, (Packet<? extends PacketListener>) packet);
-            }
-            else {
-                System.out.println("dropping");
+                    for (Packet<? super ClientGamePacketListener> packet : bundlePacket.subPackets()) {
+                        Packet<? super ClientGamePacketListener> processedPacket = (Packet<? super ClientGamePacketListener>) processPacket(player, packet);
+
+                        if (processedPacket != null) {
+                            processedPackets.add(processedPacket);
+                        }
+                    }
+
+                    return new ClientboundBundlePacket(processedPackets);
+                } else {
+                    return processPacket(player, rawPacket);
+                }
+            } catch (Throwable t) {
+                t.printStackTrace();
                 return null;
             }
         });
+
+        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, (p, packet) -> privilegeProvider.isPlayerPrivilegedToPerformAction(p) ? packet : null);
+        TinyProtocol.instance.addFilter(ServerboundInteractPacket.class, (p, packet) -> privilegeProvider.isPlayerPrivilegedToPerformAction(p) ? packet : null);
+    }
+
+    private Packet<?> processPacket(Player player, Packet<?> packet) {
+        if (bypassingPackets.contains(packet.getClass())) {
+            return packet;
+        } else if (packetProcessors.containsKey(packet.getClass())) {
+            return packetProcessors.get(packet.getClass()).apply(player, packet);
+        } else {
+            return null;
+        }
     }
 
     private Packet<? extends PacketListener> processAddEntityPacket(Player player, ClientboundAddEntityPacket packet) {
-        if(isPlayerPrivilegedToAccessEntity(player, packet.getId()) && isPlayerPrivilegedToAccessPosition(player, (int) packet.getX(), (int) packet.getY(), (int) packet.getZ())) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessEntity(player, packet.getId()) && privilegeProvider.isPlayerPrivilegedToAccessPosition(player, (int) packet.getX(), (int) packet.getY(), (int) packet.getZ())) {
             return packet;
         } else {
             return null;
@@ -471,39 +349,32 @@ public abstract class TechHider {
     }
 
     private Packet<? extends PacketListener> processEntityPacket(Player player, int entityId, Packet<? extends PacketListener> packet) {
-        if(isPlayerPrivilegedToAccessEntity(player, entityId)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessEntity(player, entityId)) {
             return packet;
         } else {
             return null;
         }
     }
-    private <TTargetPacket extends Packet<?>> BiFunction<Player,  Packet<? extends PacketListener>, Packet<? extends PacketListener>> buildEntityPacketProcessor(ToIntFunction<TTargetPacket> entityIdExtractor) {
+
+    private <TTargetPacket extends Packet<?>> BiFunction<Player, Packet<? extends PacketListener>, Packet<? extends PacketListener>> buildEntityPacketProcessor(ToIntFunction<TTargetPacket> entityIdExtractor) {
         return (p, rawPacket) -> {
             TTargetPacket packet = (TTargetPacket) rawPacket;
             return processEntityPacket(p, entityIdExtractor.applyAsInt(packet), packet);
         };
     }
 
-    private final Reflection.Field<Integer> moveEntityPacketEntityIdField = Reflection.getField(ClientboundMoveEntityPacket.class, int.class, 0);
     private Packet<?> processMoveEntityPacket(Player player, ClientboundMoveEntityPacket packet) {
-        int entityId = moveEntityPacketEntityIdField.get(packet);
-
-        if(isPlayerPrivilegedToAccessEntity(player, entityId)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessEntity(player, packet.entityId)) {
             return packet;
-        }
-        else {
+        } else {
             return null;
         }
     }
 
-    private  final Reflection.Field<Integer> rotateHeadPacketEntityIdField = Reflection.getField(ClientboundRotateHeadPacket.class, int.class, 0);
     private Packet<?> processRotateHeadPacket(Player player, ClientboundRotateHeadPacket packet) {
-        int entityId = rotateHeadPacketEntityIdField.get(packet);
-
-        if(isPlayerPrivilegedToAccessEntity(player, entityId)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessEntity(player, packet.entityId)) {
             return packet;
-        }
-        else {
+        } else {
             return null;
         }
     }
@@ -511,9 +382,7 @@ public abstract class TechHider {
     private Packet<?> processRemoveEntitiesPacket(Player player, ClientboundRemoveEntitiesPacket packet) {
         IntList entityIdsToRemove = packet.getEntityIds();
 
-        IntList filteredEntitiesToRemove = entityIdsToRemove.intStream()
-                .filter((id) -> isPlayerPrivilegedToAccessEntity(player, id))
-                .collect(IntArrayList::new, IntList::add, IntList::addAll);
+        IntList filteredEntitiesToRemove = entityIdsToRemove.intStream().filter((id) -> privilegeProvider.isPlayerPrivilegedToAccessEntity(player, id)).collect(IntArrayList::new, IntList::add, IntList::addAll);
 
         return new ClientboundRemoveEntitiesPacket(filteredEntitiesToRemove);
     }
@@ -522,10 +391,9 @@ public abstract class TechHider {
         int fromEntityId = packet.getSourceId();
         int toEntityId = packet.getDestId();
 
-        if(isPlayerPrivilegedToAccessEntity(player, fromEntityId) && isPlayerPrivilegedToAccessEntity(player, toEntityId)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessEntity(player, fromEntityId) && privilegeProvider.isPlayerPrivilegedToAccessEntity(player, toEntityId)) {
             return packet;
-        }
-        else {
+        } else {
             return null;
         }
     }
@@ -537,7 +405,7 @@ public abstract class TechHider {
         int blockY = blockPos.getY();
         int blockZ = blockPos.getZ();
 
-        if (isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ) && isPlayerPrivilegedToAccessBlock(player, blockX, blockY, blockZ, block)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ) && privilegeProvider.isPlayerPrivilegedToAccessBlock(player, blockX, blockY, blockZ, block)) {
             return packet;
         } else {
             return null;
@@ -546,14 +414,15 @@ public abstract class TechHider {
 
     private Packet<?> processBlockUpdatePacket(Player player, ClientboundBlockUpdatePacket packet) {
         BlockPos blockPos = packet.getPos();
-        Block block = packet.getBlockState().getBlock();
+        BlockState blockState = packet.getBlockState();
+        Block block = blockState.getBlock();
         int blockX = blockPos.getX();
         int blockY = blockPos.getY();
         int blockZ = blockPos.getZ();
 
-        if (isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ) && isPlayerPrivilegedToAccessBlock(player, blockX, blockY, blockZ, block)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ) && privilegeProvider.isPlayerPrivilegedToAccessBlock(player, blockX, blockY, blockZ, block) && privilegeProvider.isPlayerPrivilegedToAccessBlockState(player, blockX, blockY, blockZ, blockState)) {
             return packet;
-        } else if(isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ)) {
+        } else if (privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ)) {
             return new ClientboundBlockUpdatePacket(blockPos, blockStateUsedForObfuscation);
         } else {
             return null;
@@ -567,7 +436,7 @@ public abstract class TechHider {
         int blockY = blockPos.getY();
         int blockZ = blockPos.getZ();
 
-        if (isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ) && isPlayerPrivilegedToAccessBlocEntity(player, blockX, blockY, blockZ, blockEntityType)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ) && privilegeProvider.isPlayerPrivilegedToAccessBlockEntity(player, blockX, blockY, blockZ, blockEntityType)) {
             return packet;
         } else {
             return null;
@@ -578,23 +447,18 @@ public abstract class TechHider {
         BlockPos blockPos = packet.getPos();
         int entityBreakingBlockId = packet.getId();
 
-        if(isPlayerPrivilegedToAccessEntity(player, entityBreakingBlockId) && isPlayerPrivilegedToAccessPosition(player, blockPos.getX(), blockPos.getY(), blockPos.getZ())) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessEntity(player, entityBreakingBlockId) && privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockPos.getX(), blockPos.getY(), blockPos.getZ())) {
             return packet;
-        }
-        else {
+        } else {
             return null;
         }
     }
 
-    private final Reflection.Field<SectionPos> sectionPosField = Reflection.getField(ClientboundSectionBlocksUpdatePacket.class, SectionPos.class, 0);
-    private final Reflection.Field<short[]> oldPosField = Reflection.getField(ClientboundSectionBlocksUpdatePacket.class, short[].class, 0);
-    private final Reflection.Field<BlockState[]> oldStatesField = Reflection.getField(ClientboundSectionBlocksUpdatePacket.class, BlockState[].class, 0);
     private ClientboundSectionBlocksUpdatePacket processSectionUpdate(Player p, ClientboundSectionBlocksUpdatePacket packet) {
-        SectionPos sectionPos = sectionPosField.get(packet);
-        short[] oldPos = oldPosField.get(packet);
-        BlockState[] oldStates = oldStatesField.get(packet);
+        SectionPos sectionPos = packet.sectionPos;
+        short[] oldPos = packet.positions;
+        BlockState[] oldStates = packet.states;
 
-        boolean modified = false;
         List<Short> filteredPos = new ArrayList<>(oldPos.length);
         List<BlockState> filteredStates = new ArrayList<>(oldStates.length);
 
@@ -607,10 +471,10 @@ public abstract class TechHider {
             int worldY = sectionPos.relativeToBlockY(posShort);
             int worldZ = sectionPos.relativeToBlockZ(posShort);
 
-            if (isPlayerPrivilegedToAccessPosition(p, worldX, worldY, worldZ) && isPlayerPrivilegedToAccessBlock(p, worldX, worldY, worldZ, block)) {
+            if (privilegeProvider.isPlayerPrivilegedToAccessPosition(p, worldX, worldY, worldZ) && privilegeProvider.isPlayerPrivilegedToAccessBlock(p, worldX, worldY, worldZ, block) && privilegeProvider.isPlayerPrivilegedToAccessBlockState(p, worldX, worldY, worldZ, state)) {
                 filteredPos.add(posShort);
                 filteredStates.add(state);
-            } else if(isPlayerPrivilegedToAccessPosition(p, worldX, worldY, worldZ)){
+            } else if (privilegeProvider.isPlayerPrivilegedToAccessPosition(p, worldX, worldY, worldZ)) {
                 filteredPos.add(posShort);
                 filteredStates.add(blockStateUsedForObfuscation);
             }
@@ -619,9 +483,6 @@ public abstract class TechHider {
         if (filteredStates.isEmpty()) {
             return null;
         }
-        if (!modified) {
-            return packet;
-        }
 
         short[] newPos = new short[filteredPos.size()];
         for (int i = 0; i < newPos.length; i++) {
@@ -630,11 +491,7 @@ public abstract class TechHider {
 
         BlockState[] newStates = filteredStates.toArray(new BlockState[0]);
 
-        return new ClientboundSectionBlocksUpdatePacket(
-                sectionPos,
-                ShortSets.unmodifiable(new ShortArraySet(newPos)),
-                newStates
-        );
+        return new ClientboundSectionBlocksUpdatePacket(sectionPos, ShortSets.unmodifiable(new ShortArraySet(newPos)), newStates);
     }
 
     private Packet<?> processLevelParticlesPacket(Player player, ClientboundLevelParticlesPacket packet) {
@@ -642,40 +499,29 @@ public abstract class TechHider {
         int blockY = (int) packet.getY();
         int blockZ = (int) packet.getZ();
 
-        if(isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ)) {
             return packet;
-        }
-        else {
+        } else {
             return null;
         }
     }
 
     private ClientboundLevelChunkWithLightPacket processChunkWithLight(Player p, ClientboundLevelChunkWithLightPacket packet) {
-        return chunkHider.processLevelChunkWithLightPacket(p, packet);
-    }
-
-    private Packet<? extends PacketListener> processContainerPacket(Player player, int containerId, Packet<? extends PacketListener> packet) {
-        if(isPlayerPrivilegedToAccessContainer(player, containerId)) {
+        if (privilegeProvider.isEveryonePrivilegedToAccessAllDataWithinChunk(packet.getX(), packet.getZ())) {
             return packet;
         } else {
-            return null;
+            return chunkHider.processLevelChunkWithLightPacket(p, packet);
         }
     }
-    private <TTargetPacket extends Packet<?>> BiFunction<Player, Packet<?>, Packet<?>> buildContainerPacketProcessor(ToIntFunction<TTargetPacket> containerIdExtractor) {
-        return (p, rawPacket) -> {
-            TTargetPacket packet = (TTargetPacket) rawPacket;
-
-            return processContainerPacket(p, containerIdExtractor.applyAsInt(packet), packet);
-        };
-    }
 
     private Packet<? extends PacketListener> proccessPositionBasedPacket(Player player, int blockX, int blockY, int blockZ, Packet<? extends PacketListener> packet) {
-        if(isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ)) {
+        if (privilegeProvider.isPlayerPrivilegedToAccessPosition(player, blockX, blockY, blockZ)) {
             return packet;
         } else {
             return null;
         }
     }
+
     private <TTargetPacket extends Packet<?>> BiFunction<Player, Packet<?>, Packet<?>> buildPositionBasedPacketProcessor(Function<TTargetPacket, BlockPos> positionExtractor) {
         return (p, rawPacket) -> {
             TTargetPacket packet = (TTargetPacket) rawPacket;
@@ -687,11 +533,4 @@ public abstract class TechHider {
             return proccessPositionBasedPacket(p, blockX, blockY, blockZ, packet);
         };
     }
-
-    public abstract boolean isPlayerPrivilegedToAccessPosition(Player p, int blockX, int blockY, int blockZ);
-    public abstract boolean isPlayerPrivilegedToAccessBlock(Player p, int blockX, int blockY, int blockZ, Block block);
-    public abstract boolean isPlayerPrivilegedToAccessEntity(Player p, int entityId);
-    public abstract boolean isPlayerPrivilegedToAccessBlocEntity(Player p, int blockX, int blockY, int blockZ, BlockEntityType<?> type);
-    public abstract boolean isPlayerPrivilegedToAccessContainer(Player p, int containerId);
-    public abstract boolean isPlayerPrivilegedToAccessSound(Player p, ResourceLocation soundId);
 }