Initial FightSWCommand

Reviewed-on: SteamWar/SteamWar#478

.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"

.gitignore

@@ -15,6 +15,11 @@ bin/
 .vscode
 .settings
 
+# Language Server
+**/.project
+**/.factorypath
+**/.classpath
+
 # Other
 lib
 /WebsiteBackend/data

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 {
@@ -34,6 +35,7 @@ dependencies {
     compileOnly(libs.classindex)
     annotationProcessor(libs.classindex)
     compileOnly(project(":SpigotCore", "default"))
+    compileOnly(project(":KotlinCore", "default"))
 
     compileOnly(libs.axiom)
     compileOnly(libs.authlib)
@@ -47,3 +49,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

@@ -0,0 +1,31 @@
+/*
+ *   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;
+
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+
+@Linked
+public class ExperimentalCommand extends SWCommand {
+
+    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, 0, 0));
+            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/region/TestblockCommand.java

@@ -185,17 +185,16 @@ public class TestblockCommand extends SWCommand {
         return new TypeMapper<SchematicNode>() {
             @Override
             public List<String> tabCompletes(CommandSender commandSender, PreviousArguments previousArguments, String s) {
-                List<String> stringList = new ArrayList<>(SchematicNode.getNodeTabcomplete(SteamwarUser.get(((Player) commandSender).getUniqueId()), s));
+                List<String> stringList = new ArrayList<>();
                 stringList.addAll(SchematicNode.getNodeTabcomplete(SteamwarUser.byId(0), s));
+                stringList.addAll(SchematicNode.getNodeTabcomplete(SteamwarUser.get(((Player) commandSender).getUniqueId()), s));
                 return stringList;
             }
 
             @Override
             public SchematicNode map(CommandSender commandSender, PreviousArguments previousArguments, String s) {
-                SchematicNode node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
-                if (node == null) {
-                    node = SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
-                }
+                SchematicNode node = SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
+                if (node == null) node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
                 return node;
             }
         };

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

@@ -19,7 +19,7 @@
 
 package de.steamwar.bausystem.features.simulator;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
+import com.destroystokyo.paper.event.server.ServerTickEndEvent;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.SWUtils;
@@ -38,77 +38,88 @@ 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 Set<Player> scheduledUpdates = new HashSet<>();
+
+    private static void scheduleCursorUpdate(Player player) {
+        scheduledUpdates.add(player);
+    }
+
+    @EventHandler
+    public void onServerTickEnd(ServerTickEndEvent event) {
+        scheduledUpdates.forEach(SimulatorCursor::calcCursor);
+        scheduledUpdates.clear();
     }
 
     @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 +130,8 @@ 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());
+        scheduledUpdates.remove(event.getPlayer());
     }
 
     private static final Map<Player, Long> LAST_SNEAKS = new HashMap<>();
@@ -138,7 +147,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 +173,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 +185,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 +292,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 +300,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;
@@ -38,7 +39,6 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
-import de.steamwar.techhider.legacy.TechHider;
 
 import java.util.*;
 import java.util.stream.Collectors;

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

@@ -165,6 +165,7 @@ public class TPSSystem implements Listener {
         }
 
         @Register(value = "default", description = "TPSLIMIT_DEFAULT_HELP")
+        @Register(value = "rate")
         public void reset(@Validator Player player) {
             TickManager.impl.setTickRate(20.0F);
             sendTickRateChange();
@@ -187,15 +188,18 @@ public class TPSSystem implements Listener {
         }
 
         @Register(value = {"rate", "0"}, description = "TICK_FREEZE_HELP")
-        @Register(value = "freeze", description = "TICK_FREEZE_HELP_2")
-        public void freeze(@Validator Player player) {
+        public void rate(@Validator Player player) {
             TickManager.impl.setFreeze(true);
             sendTickRateChange();
         }
 
-        @Register(value = "unfreeze", description = "TICK_UNFREEZE_HELP")
-        public void unfreeze(@Validator Player player) {
-            TickManager.impl.setTickRate(20.0F);
+        @Register(value = "freeze", description = "TICK_FREEZE_HELP_2")
+        public void freezeToggle(@Validator Player player) {
+            if (TickManager.impl.isFrozen()) {
+                TickManager.impl.setTickRate(20.0F);
+            } else {
+                TickManager.impl.setFreeze(true);
+            }
             sendTickRateChange();
         }
     }

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

@@ -153,7 +153,11 @@ public class TraceCommand extends SWCommand {
 
     @Register(value = "isolate", description = "TRACE_COMMAND_HELP_ISOLATE")
     public void isolate(@Validator Player player, Trace trace, @ErrorMessage("TRACE_RECORD_ID_INVALID") TNTPoint... records) {
-        TraceManager.instance.isolate(player, records);
+        if (records.length == 0) {
+            TraceManager.instance.isolate(player, trace, trace.getRecords().toArray(TNTPoint[]::new));
+        } else {
+            TraceManager.instance.isolate(player, trace, records);
+        }
         BauSystem.MESSAGE.send("TRACE_MESSAGE_ISOLATE", player);
     }
 

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

@@ -347,9 +347,10 @@ public class TraceManager implements Listener {
      * Toggles the isolated render for the given records and player
      *
      * @param player  the player the trace is shown to
-     * @param records the record for which isolation is toggled
+     * @param ptrace  the trace for whitch isolation is toggled
+     * @param records the records of the trace for which isolation is toggled
      */
-    public void isolate(Player player, TNTPoint... records) {
+    public void isolate(Player player, Trace ptrace, TNTPoint... records) {
         unfollow(player);
 
         Region region = Region.getRegion(player.getLocation());
@@ -374,12 +375,20 @@ public class TraceManager implements Listener {
             isolateFlag.toggleId(record.getTntId());
         }
 
+        if (isolateFlag.isEmpty() && playerTraceShowData.hasViewFlagOnly(IsolateFlag.class) && records.length != 0) {
+            playerTraceShowData.removeViewFlag(IsolateFlag.class);
+        }
+
         PlayerTraceShowData finalPlayerTraceShowData = playerTraceShowData;
         tracesByRegion.getOrDefault(region, Collections.emptyMap()).forEach((integer, trace) -> {
-            trace.render(player, finalPlayerTraceShowData);
-            followerMap.getOrDefault(player, Collections.emptySet()).forEach(follower -> {
-                trace.render(follower, finalPlayerTraceShowData);
-            });
+            if (trace.getUuid() == ptrace.getUuid() || finalPlayerTraceShowData.hasNoViewFlags()) {
+                trace.render(player, finalPlayerTraceShowData);
+                followerMap.getOrDefault(player, Collections.emptySet()).forEach(follower -> {
+                    trace.render(follower, finalPlayerTraceShowData);
+                });
+            } else {
+                trace.hide(player);
+            }
         });
     }
 

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

@@ -135,6 +135,13 @@ public class TraceRecorder implements Listener {
             Iterator<TNTPrimed> iter = trackedTNT.getOrDefault(region, Collections.emptyList()).iterator();
             while (iter.hasNext()) {
                 TNTPrimed tnt = iter.next();
+                if (tnt.isDead()) {
+                    iter.remove();
+                    tntSpawnRegion.remove(tnt);
+                    historyMap.remove(tnt);
+                    tntSpawnRegion.remove(tnt);
+                    continue;
+                }
                 if (tnt.getFuseTicks() == 80) continue;
                 TNTPoint record = record(tnt, wrappedTrace, Collections.emptyList());
                 if (record == null) {

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

@@ -95,4 +95,8 @@ public class PlayerTraceShowData {
     public void addViewFlag(ViewFlag viewFlag) {
         viewFlags.put(viewFlag.getClass(), viewFlag);
     }
+
+    public <T extends ViewFlag> void removeViewFlag(Class<T> clazz) {
+        viewFlags.remove(clazz);
+    }
 }

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

@@ -25,7 +25,9 @@ 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.RInteraction;
 import lombok.Getter;
 import net.md_5.bungee.api.chat.ClickEvent;
 import org.bukkit.Location;
@@ -46,9 +48,9 @@ import static de.steamwar.bausystem.features.util.TNTClickListener.TNT_CLICK_DET
  */
 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(
+    public static final float TNT_VISUAL_SCALE = 0.98F;
+    public static final float TNT_VISUAL_OFFSET = -TNT_VISUAL_SCALE / 2.0F;
+    public 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),
@@ -67,6 +69,7 @@ public class TraceEntity extends RBlockDisplay {
     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);
@@ -74,8 +77,23 @@ public class TraceEntity extends RBlockDisplay {
         this.records = records;
         this.trace = trace;
         uniqueTntIdsString = records.stream().map(TNTPoint::getTntId).distinct().map(Object::toString).collect(Collectors.joining(" "));
+        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,9 @@ 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());
+                    y.setTransform(TraceEntity.TNT_VISUAL_TRANSFORM);
                 }
 
                 Location secoundLocation;
@@ -141,8 +142,9 @@ 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());
+                    second.setTransform(TraceEntity.TNT_VISUAL_TRANSFORM);
                 }
             }
         }

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

@@ -51,6 +51,10 @@ public class IsolateFlag extends ViewFlag {
         }
     }
 
+    public boolean isEmpty() {
+        return tntToIsolate.isEmpty();
+    }
+
     @Override
     public Stream<TNTPoint> filter(Stream<TNTPoint> records) {
         if (tntToIsolate.isEmpty()) return records;

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)
@@ -143,6 +139,7 @@ public class NoClipCommand extends SWCommand implements Listener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlock(BlockCanBuildEvent event) {
+        if (event.getPlayer() == null) return;
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
             event.setBuildable(true);
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/world/AntiPlayerCollision.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.bausystem.features.world;
+
+import de.steamwar.linkage.Linked;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+@Linked
+public class AntiPlayerCollision implements Listener {
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Scoreboard board = event.getPlayer().getScoreboard();
+        Team team = board.getTeam("players");
+        if (team == null) team = board.registerNewTeam("players");
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.NEVER);
+        team.addPlayer(event.getPlayer());
+    }
+}

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

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

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

@@ -25,6 +25,7 @@ import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.BauweltMember;
+import de.steamwar.techhider.legacy.TechHider;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
@@ -39,7 +40,6 @@ import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.util.Vector;
-import de.steamwar.techhider.legacy.TechHider;
 
 import java.util.HashSet;
 import java.util.Set;

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

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

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

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

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

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

BauSystem/build.gradle.kts

@@ -37,5 +37,6 @@ tasks.register<DevServer>("DevBau21") {
     dependsOn(":SpigotCore:shadowJar")
     dependsOn(":BauSystem:shadowJar")
     dependsOn(":SchematicSystem:shadowJar")
+    dependsOn(":KotlinCore:shadowJar")
     template = "Bau21"
 }

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/database/ResetCommand.kt

@@ -7,6 +7,7 @@ import com.github.ajalt.mordant.rendering.TextColors
 import com.github.ajalt.mordant.rendering.TextStyles
 import de.steamwar.db.Database
 import de.steamwar.db.execute
+import de.steamwar.db.executeScript
 import de.steamwar.db.useDb
 import java.io.File
 
@@ -22,13 +23,25 @@ class ResetCommand : CliktCommand() {
 
             val schema = schemaFile.readText()
 
-            val tables = execute("SHOW TABLES;") { it.getString(1) }
-            for (table in tables) {
-                execute("DROP TABLE IF EXISTS $table;") { }
+            execute("SET FOREIGN_KEY_CHECKS=0;") { }
+
+            val databaseObjects = execute("SHOW FULL TABLES;") { it.getString(1) to it.getString(2) }
+            for (view in databaseObjects.filter { it.second == "VIEW" }.map { it.first }) {
+                execute("DROP VIEW IF EXISTS `${view.replace("`", "``")}`;") { }
+            }
+            for (table in databaseObjects.filter { it.second == "BASE TABLE" }.map { it.first }) {
+                execute("DROP TABLE IF EXISTS `${table.replace("`", "``")}`;") { }
             }
 
-            execute(schema) { }
+            executeScript(schema)
+
+            val seed = javaClass.getResource("/db/reset-seed.sql")
+                ?: throw CliktError("Reset seed file not found!")
+
+            executeScript(seed.readText())
+
+            execute("SET FOREIGN_KEY_CHECKS=1;") { }
 
             echo(TextColors.brightGreen(TextStyles.bold("Database reset!")))
         }
-}
+}

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,35 +71,47 @@ 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}")
                 }
+                worldFile.parentFile?.mkdirs()
                 templateFile.copyRecursively(worldFile)
             }
+            val worldDir = worldFile.parentFile ?: workingDir
 
             val devFile = File("/configs/DevServer/${System.getProperty("user.name")}.$port.$version")
             if (System.getProperty("user.name") != "minecraft") {
@@ -108,10 +122,11 @@ class DevCommand : CliktCommand("dev") {
                 args, jvmArgs, listOf(
                     jarFile,
                     *(if (forceUpgrade) arrayOf("-forceUpgrade") else arrayOf()),
+                    "--log-strip-color",
                     "--port", port.toString(),
                     "--level-name", worldFile.name,
-                    "--world-dir", workingDir.absolutePath,
-                    "--nogui",
+                    "--world-dir", worldDir.absolutePath,
+                    "nogui",
                     *(if (plugins != null) arrayOf("--plugins", plugins!!.absolutePathString()) else arrayOf())
                 ), serverDir
             )
@@ -123,6 +138,12 @@ class DevCommand : CliktCommand("dev") {
         }
     }
 
+    data class GameModeTemplate(
+        val serverDir: File,
+        val worldTemplate: File,
+        val spigot: Boolean
+    )
+
     val jvmDefaultParams = arrayOf(
         "-Xmx1G",
         "-Xgc:excessiveGCratio=80",
@@ -138,6 +159,16 @@ class DevCommand : CliktCommand("dev") {
 
     val jvmArgOverrides = arrayOf("--add-opens", "java.base/jdk.internal.misc=ALL-UNNAMED")
 
+    val jvmNonJava8Params = arrayOf(
+        *jvmArgOverrides,
+        "-XX:-CRIUSecProvider"
+    )
+
+    val extendedStartupParams = arrayOf(
+        "-Dpaper.disablePluginRemapping=true",
+        "-javaagent:/jars/AccessWidener.jar=start"
+    )
+
     val supportedVersionJars = mapOf(
         8 to "/jars/paper-1.8.8.jar",
         9 to "/jars/spigot-1.9.4.jar",
@@ -152,8 +183,7 @@ class DevCommand : CliktCommand("dev") {
     )
 
     val additionalVersions = mapOf(
-        "Tutorial" to 15,
-        "Lobby" to 20
+        "Lobby" to 21
     )
 
     fun findVersion(server: String): Int? =
@@ -166,6 +196,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}"
@@ -176,13 +241,23 @@ class DevCommand : CliktCommand("dev") {
     }
 
     fun runServer(args: List<String>, jvmArgs: List<String>, cmd: List<String>, serverDir: File) {
+        val effectiveJvmArgs = mutableListOf<String>()
+        effectiveJvmArgs += jvmArgs
+        if (!isVelocity(server)) {
+            extendedStartupParams.forEach { arg ->
+                if (effectiveJvmArgs.none { it == arg }) {
+                    effectiveJvmArgs += arg
+                }
+            }
+        }
+
         val process = ProcessBuilder(
             jvm?.absolutePath
-                ?: if (isJava8(server)) "/usr/lib/jvm/openj9-8/bin/java" else "java",
-            *jvmArgs.toTypedArray(),
+                ?: if (isJava8(server)) "/usr/lib/jvm/openj9-8/bin/java" else "/usr/lib/jvm/openj9-21/bin/java",
+            *effectiveJvmArgs.toTypedArray(),
             *args.toTypedArray(),
             *jvmDefaultParams,
-            *(if (isJava8(server)) arrayOf() else jvmArgOverrides),
+            *(if (isJava8(server)) arrayOf() else jvmNonJava8Params),
             *(if (profile) arrayOf("-javaagent:/jars/LixfelsProfiler.jar=start") else arrayOf()),
             "-Xshareclasses:nonfatal,name=$server",
             "-jar",
@@ -191,4 +266,4 @@ class DevCommand : CliktCommand("dev") {
         Runtime.getRuntime().addShutdownHook(Thread { if (process.isAlive) process.destroyForcibly() })
         process.waitFor()
     }
-}
+}

CLI/src/db/Database.kt

@@ -16,15 +16,14 @@ import java.sql.ResultSet
 import java.util.*
 
 object Database {
-    lateinit var host: String
-    lateinit var port: String
-    lateinit var database: String
+    val host: String
+    val port: String
+    val database: String
+    val username: String
+    val password: String
     lateinit var db: Database
 
-    fun ensureConnected() {
-        if (::db.isInitialized) {
-            return
-        }
+    init {
         val config = File(System.getProperty("user.home"), "mysql.properties")
 
         if (!config.exists()) {
@@ -38,9 +37,14 @@ object Database {
         host = props.getProperty("host")
         port = props.getProperty("port")
         database = props.getProperty("database")
+        username = props.getProperty("user")
+        password = props.getProperty("password")
+    }
 
-        val username = props.getProperty("user")
-        val password = props.getProperty("password")
+    fun ensureConnected() {
+        if (::db.isInitialized) {
+            return
+        }
 
         val url = "jdbc:mariadb://$host:$port/$database"
 
@@ -79,6 +83,113 @@ fun <T> JdbcTransaction.executeSingle(sql: String, transform: (ResultSet) -> T):
     }.single()
 }
 
+fun JdbcTransaction.executeScript(sql: String) {
+    for (statement in splitSqlScript(sql)) {
+        exec(statement) { }
+    }
+}
+
+private fun splitSqlScript(sql: String): List<String> {
+    val statements = mutableListOf<String>()
+    val current = StringBuilder()
+    var quote: Char? = null
+    var inLineComment = false
+    var inBlockComment = false
+    var index = 0
+
+    fun addStatement() {
+        val statement = current.toString().trim()
+        if (statement.isNotEmpty()) {
+            statements += statement
+        }
+        current.clear()
+    }
+
+    while (index < sql.length) {
+        val char = sql[index]
+        val next = sql.getOrNull(index + 1)
+
+        if (inLineComment) {
+            current.append(char)
+            if (char == '\n') {
+                inLineComment = false
+            }
+            index++
+            continue
+        }
+
+        if (inBlockComment) {
+            current.append(char)
+            if (char == '*' && next == '/') {
+                current.append(next)
+                inBlockComment = false
+                index += 2
+            } else {
+                index++
+            }
+            continue
+        }
+
+        if (quote != null) {
+            current.append(char)
+            if (char == '\\' && quote != '`' && next != null) {
+                current.append(next)
+                index += 2
+                continue
+            }
+            if (char == quote) {
+                if (next == quote) {
+                    current.append(next)
+                    index += 2
+                    continue
+                }
+                quote = null
+            }
+            index++
+            continue
+        }
+
+        when {
+            char == '-' && next == '-' -> {
+                current.append(char).append(next)
+                inLineComment = true
+                index += 2
+            }
+
+            char == '#' -> {
+                current.append(char)
+                inLineComment = true
+                index++
+            }
+
+            char == '/' && next == '*' -> {
+                current.append(char).append(next)
+                inBlockComment = true
+                index += 2
+            }
+
+            char == '\'' || char == '"' || char == '`' -> {
+                current.append(char)
+                quote = char
+                index++
+            }
+
+            char == ';' -> {
+                addStatement()
+                index++
+            }
+
+            else -> {
+                current.append(char)
+                index++
+            }
+        }
+    }
+
+    addStatement()
+    return statements
+}
+
 fun useDb(statement: JdbcTransaction.() -> Unit) {
     de.steamwar.db.Database.ensureConnected()
     transaction(de.steamwar.db.Database.db, statement = statement)

CommonCore/SQL/build.gradle.kts

@@ -19,6 +19,7 @@
 
 plugins {
     steamwar.kotlin
+    kotlin("plugin.lombok")
 }
 
 kotlin {
@@ -40,4 +41,8 @@ dependencies {
     compileOnlyApi(libs.exposedDao)
     compileOnlyApi(libs.exposedJdbc)
     compileOnlyApi(libs.exposedTime)
+    testImplementation(kotlin("test"))
 }
+repositories {
+    mavenCentral()
+}

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

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

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

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

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

@@ -159,10 +159,13 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
         }
 
     override fun delete() =
-        useDb { super.delete() }
+        useDb {
+            EventRelation.deleteRelations(this@EventGroup)
+            super.delete()
+        }
 
     enum class EventGroupType {
         GROUP_STAGE,
         ELIMINATION_STAGE
     }
-}
+}

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

@@ -24,8 +24,10 @@ import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.dao.id.EntityID
 import org.jetbrains.exposed.v1.core.dao.id.IntIdTable
 import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.core.or
 import org.jetbrains.exposed.v1.dao.IntEntity
 import org.jetbrains.exposed.v1.dao.IntEntityClass
+import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.select
 
 object EventRelationTable : IntIdTable("EventRelation") {
@@ -59,6 +61,23 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
         fun getGroupRelations(group: EventGroup) =
             useDb { find { (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP) }.toList() }
 
+        @JvmStatic
+        fun deleteRelations(fight: EventFight) =
+            useDb {
+                EventRelationTable.deleteWhere {
+                    (EventRelationTable.fightId eq fight.id) or
+                        ((EventRelationTable.fromId eq fight.id.value) and (EventRelationTable.fromType eq FromType.FIGHT))
+                }
+            }
+
+        @JvmStatic
+        fun deleteRelations(group: EventGroup) =
+            useDb {
+                EventRelationTable.deleteWhere {
+                    (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP)
+                }
+            }
+
         @JvmStatic
         fun create(fight: EventFight, fightTeam: FightTeam, fromType: FromType, fromId: Int, fromPlace: Int) =
             useDb {
@@ -159,4 +178,4 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
     enum class FromType {
         FIGHT, GROUP
     }
-}
+}

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

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

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

@@ -146,12 +146,12 @@ public final class GameModeConfig<M, W> {
     public final List<String> CheckQuestions;
 
     /**
-     * The allowed checkers to check this schematic type denoted by a list of SteamWar ids.
+     * The allowed checkers to check this schematic type denoted by a list of SteamwarUser ids.
      * The people need the {@link UserPerm#CHECK} to be able to check though.
      *
      * @implSpec {@code []} by default -> denoting every person with {@link UserPerm#CHECK} can check it
      */
-    public final List<Integer> Checkers;
+    public final Set<Integer> Checkers;
 
     /**
      * Bundle for countdowns during the fight
@@ -246,7 +246,7 @@ public final class GameModeConfig<M, W> {
         }
 
         CheckQuestions = loader.getStringList("CheckQuestions");
-        Checkers = loader.getIntList("Checkers");
+        Checkers = loader.getIntSet("Checkers");
         Times = new TimesConfig(loader.with("Times"));
         // Arena would be here to be in config order but needs Schematic.Size and EnterStages loaded afterwards
         Schematic = new SchematicConfig<>(loader.with("Schematic"));
@@ -488,6 +488,27 @@ public final class GameModeConfig<M, W> {
          */
         public final boolean NoFloor;
 
+        /**
+         * Allows Wind Charges to cross the Middle.
+         *
+         * @implSpec {@code false} by default
+         */
+        public final boolean WindchargesCanCrossMiddle;
+
+        /**
+         * Allows Wind Charge interaction with Blocks.
+         *
+         * @implSpec {@code true} by default
+         */
+        public final boolean WindchargesInteractWithBlocks;
+
+        /**
+         * Allows Wind Charge to destroy Water.
+         *
+         * @implSpec {@code false} by default
+         */
+        public final boolean WindchargesDestroyWater;
+
         private ArenaConfig(YMLWrapper<M, W> loader, SchematicConfig.SizeConfig Size, List<Integer> EnterStages) {
             loaded = loader.canLoad();
             WaterDepth = loader.getInt("WaterDepth", 0);
@@ -505,6 +526,9 @@ public final class GameModeConfig<M, W> {
             Leaveable = loader.getBoolean("Leaveable", false);
             AllowMissiles = loader.getBoolean("AllowMissiles", !EnterStages.isEmpty());
             NoFloor = loader.getBoolean("NoFloor", false);
+            WindchargesCanCrossMiddle = loader.getBoolean("WindchargesCanCrossMiddle", false);
+            WindchargesInteractWithBlocks = loader.getBoolean("WindchargesInteractWithBlocks", true);
+            WindchargesDestroyWater = loader.getBoolean("WindchargesDestroyWater", false);
         }
 
         @ToString
@@ -664,13 +688,6 @@ public final class GameModeConfig<M, W> {
          */
         public final int MaxBlocks;
 
-        /**
-         * Maximal amount of items per dispenser
-         *
-         * @implSpec {@code 128} by default
-         */
-        public final int MaxDispenserItems;
-
         /**
          * Maximal blast resistance for the blocks
          *
@@ -686,10 +703,12 @@ public final class GameModeConfig<M, W> {
         public final double MaxDesignBlastResistance;
 
         /**
-         * List of limited material (combinations)<br/>
-         * List contains tags Amount (integer) and Materials (List of material names in Spigot 1.12 AND Spigot 1.15 format)
+         * List of limited block materials
+         *
+         * @implSpec {@link SQLWrapper#getInventoryMaterials)} are all disallowed by default to have any content but are unlimited in number.
+         * @implSpec Any Block that has more Blast Resistance than {@link #MaxBlastResistance} will be defaulted to 0.
          */
-        public final Map<Set<M>, Integer> Limited;
+        public final List<BlockRule<M>> Limited;
 
         private SchematicConfig(YMLWrapper<M, ?> loader) {
             loaded = loader.canLoad();
@@ -707,32 +726,140 @@ public final class GameModeConfig<M, W> {
             IgnorePublicOnly = loader.getBoolean("IgnorePublicOnly", false);
             UnlimitedPrepare = loader.getBoolean("UnlimitedPrepare", false);
             MaxBlocks = loader.getInt("MaxBlocks", 0);
-            MaxDispenserItems = loader.getInt("MaxDispenserItems", 128);
             MaxBlastResistance = loader.getDouble("MaxBlastResistance", Double.MAX_VALUE);
             MaxDesignBlastResistance = loader.getDouble("MaxDesignBlastResistance", MaxBlastResistance);
 
-            Map<Set<M>, Integer> Limited = new HashMap<>();
-            for (Map<?, ?> entry : loader.getMapList("Limited")) {
-                int amount = (Integer) entry.get("Amount");
-                Set<String> materials = new HashSet<>((List<String>) entry.get("Materials"));
-                if (amount == 0) {
-                    materials.forEach(material -> {
-                        Limited.put(Collections.singleton(loader.materialMapper.apply(material.toUpperCase())), 0);
-                    });
-                } else {
-                    Limited.put(Collections.unmodifiableSet(materials.stream().map(String::toUpperCase).map(loader.materialMapper).collect(Collectors.toSet())), amount);
-                }
+            List<BlockRule<M>> limited = new ArrayList<>();
+            Set<M> blocks = new HashSet<>();
+            for (YMLWrapper<M, ?> limitedLoader : loader.withAsList("Limited")) {
+                BlockRule<M> blockRule = new BlockRule<>(limitedLoader);
+                blocks.addAll(blockRule.Materials);
+                limited.add(blockRule);
             }
-            SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance).forEach(material -> {
-                if (Limited.entrySet().stream().anyMatch(entry -> entry.getKey().contains(material))) return;
-                Limited.put(Collections.singleton((M) material), 0);
-            });
-            this.Limited = Collections.unmodifiableMap(Limited);
+            for (M material : (List<M>) SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance)) {
+                if (material == null || !blocks.add(material)) continue;
+                limited.add(new BlockRule<>(material, 0));
+            }
+            for (M material : (Set<M>) SQLWrapper.impl.getInventoryMaterials()) {
+                if (material == null || !blocks.add(material)) continue;
+                limited.add(new BlockRule<>(material, Integer.MAX_VALUE));
+            }
+            this.Limited = Collections.unmodifiableList(limited);
 
             this.ReplacementsWithoutBlockUpdates = loader.getMap("ReplacementsWithoutBlockUpdates", loader.materialMapper, loader.materialMapper);
             this.ReplacementsWithBlockUpdates = loader.getMap("ReplacementsWithBlockUpdates", loader.materialMapper, loader.materialMapper);
         }
 
+        public int getMaxCount(M material) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .mapToInt(rule -> rule.Amount)
+                    .max()
+                    .orElse(Integer.MAX_VALUE);
+        }
+
+        public boolean isInventory(M material) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .anyMatch(rule -> rule.Content.loaded);
+        }
+
+        public Integer getItemAmount(M material, M item) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .filter(rule -> rule.Content.Items.contains(item))
+                    .mapToInt(rule -> rule.Content.Amount)
+                    .max()
+                    .orElse(0);
+        }
+
+        @ToString
+        public static final class BlockRule<M> {
+
+            /**
+             * The block materials this rule applies to
+             */
+            public final Set<M> Materials;
+
+            /**
+             * Maximal amount of Blocks allowed in the schematic
+             *
+             * @implSpec {@code 0} by default
+             */
+            public final int Amount;
+
+            /**
+             * The item content filter for Blocks
+             *
+             * @implSpec no Items with {@code Amount 0} (denies any item) by default
+             */
+            public final Content<M> Content;
+
+            /**
+             * Resolves one {@code Materials} entry to the concrete materials it denotes: {@code storage}
+             * for {@link SQLWrapper#getStorageMaterials()}, {@code all} for
+             * {@link SQLWrapper#getInventoryMaterials()}, or the material itself otherwise.
+             */
+            private Set<M> expandInventoryGroup(YMLWrapper<M, ?> loader, String name) {
+                switch (name.toUpperCase()) {
+                    case "STORAGE":
+                        return (Set<M>) SQLWrapper.impl.getStorageMaterials();
+                    case "INVENTORY":
+                        return (Set<M>) SQLWrapper.impl.getInventoryMaterials();
+                    default:
+                        M material = loader.materialMapper.apply(name.toUpperCase());
+                        return material != null ? Collections.singleton(material) : Collections.emptySet();
+                }
+            }
+
+            private BlockRule(YMLWrapper<M, ?> loader) {
+                Set<M> blocks = loader.getStringList("Materials")
+                        .stream()
+                        .flatMap(value -> expandInventoryGroup(loader, value).stream())
+                        .collect(Collectors.toSet());
+                Materials = Collections.unmodifiableSet(blocks);
+                Amount = loader.getInt("Amount", 0);
+                Content = new Content<>(loader.with("Content"));
+            }
+
+            private BlockRule(M block, int amount) {
+                Materials = Collections.singleton(block);
+                Amount = amount;
+                Content = new Content<>();
+            }
+
+            @ToString
+            public static final class Content<M> {
+
+                public final boolean loaded;
+
+                /**
+                 * Items allowed by this rule
+                 */
+                public final Set<M> Items;
+
+                /**
+                 * Maximal amount of an allowed item per single block instance
+                 *
+                 * @implSpec {@code 0} by default
+                 */
+                public final int Amount;
+
+                private Content(YMLWrapper<M, ?> loader) {
+                    loaded = loader.canLoad();
+                    List<M> items = loader.getMaterialList("Items");
+                    Items = Collections.unmodifiableSet(new HashSet<>(items));
+                    Amount = loader.getInt("Amount", 0);
+                }
+
+                private Content() {
+                    loaded = false;
+                    Items = new HashSet<>();
+                    Amount = 0;
+                }
+            }
+        }
+
         @ToString
         public static final class SizeConfig {
 
@@ -929,6 +1056,13 @@ public final class GameModeConfig<M, W> {
          */
         public final boolean PersonalKits;
 
+        /**
+         * Maximal blast resistance for the blocks in the kit
+         *
+         * @implSpec {@code 9.0} by default
+         */
+        public final double MaxBlastResistance;
+
         /**
          * Items (Valid spigot material values) that are not allowed in the personal kit
          */
@@ -940,7 +1074,10 @@ public final class GameModeConfig<M, W> {
             MemberDefault = loader.getString("MemberDefault", "default");
             LeaderDefault = loader.getString("LeaderDefault", "default");
             PersonalKits = loader.getBoolean("PersonalKits", false);
-            ForbiddenItems = loader.getMaterialList("ForbiddenItems");
+            MaxBlastResistance = loader.getDouble("MaxBlastResistance", 9.0);
+            List forbiddenItems = new ArrayList<>(loader.getMaterialList("ForbiddenItems"));
+            forbiddenItems.addAll(SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance));
+            ForbiddenItems = Collections.unmodifiableList(forbiddenItems);
         }
     }
 

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

@@ -24,6 +24,7 @@ import de.steamwar.ImplementationProvider;
 import java.io.File;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 
 public interface SQLWrapper<M> {
     SQLWrapper<?> impl = ImplementationProvider.getImpl("de.steamwar.sql.SQLWrapperImpl");
@@ -36,5 +37,21 @@ public interface SQLWrapper<M> {
         return Collections.emptyList();
     }
 
+    /**
+     * Storage-type inventory materials (chests, barrels, shulker boxes of any color) - the
+     * {@code storage} group usable in {@code GameModeConfig}'s {@code Limited}.
+     */
+    default Set<M> getStorageMaterials() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * Every inventory material - the {@code all} group usable in {@code GameModeConfig}'s
+     * {@code Limited}. Expected to be a superset of {@link #getStorageMaterials()}.
+     */
+    default Set<M> getInventoryMaterials() {
+        return Collections.emptySet();
+    }
+
     void additionalExceptionMetadata(StringBuilder builder);
 }

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

@@ -76,6 +76,25 @@ final class YMLWrapper<M, W> {
         return new YMLWrapper<>(false, Collections.emptyMap(), materialMapper, winconditionMapper);
     }
 
+    public List<YMLWrapper<M, W>> withAsList(String path) {
+        if (document.containsKey(path)) {
+            Object value = document.get(path);
+            if (value instanceof List) {
+                List<?> list = (List<?>) value;
+                List<Map> maps = list.stream()
+                        .filter(Map.class::isInstance)
+                        .map(Map.class::cast)
+                        .collect(Collectors.toList());
+                if (maps.size() == list.size()) {
+                    return (List) maps.stream()
+                            .map(map -> new YMLWrapper(true, map, materialMapper, winconditionMapper))
+                            .collect(Collectors.toList());
+                }
+            }
+        }
+        return Collections.emptyList();
+    }
+
     public <T> T get(String path, T defaultValue, Function<Object, T> mapper) {
         Object value = this.document.get(path);
         if (value == null) return defaultValue;
@@ -139,6 +158,12 @@ final class YMLWrapper<M, W> {
         return get(path, o -> (List<Integer>) o);
     }
 
+    public Set<Integer> getIntSet(String path) {
+        List<Integer> list = get(path, o -> (List<Integer>) o);
+        if (list.isEmpty()) return Collections.emptySet();
+        return Collections.unmodifiableSet(new HashSet<>(list));
+    }
+
     public List<SchematicType> getSchematicTypeList(String path) {
         List<String> list = getStringList(path);
         if (list.isEmpty()) {

FightSystem/FightSystem_Core/src/config.yml

@@ -64,6 +64,10 @@ Arena:
   AllowMissiles: false # defaults to true if EnterStages are present otherwise 'false'
   # Denotes that there is no floor for this GameMode
   NoFloor: false # defaults to false if missing
+  # Allows Wind Charges to cross the Middle.
+  WindchargesCanCrossMiddle: false # defaults to false if missing
+  # Allows Wind Charge interaction with Blocks.
+  WindchargesInteractWithBlocks: false # defaults to false if missing
 
 Schematic:
   # The size of the schematics
@@ -103,15 +107,23 @@ Schematic:
   UnlimitedPrepare: false # defaults to false if missing
   # Maximal amount of blocks allowed in the schematic
   MaxBlocks: 0 # defaults to 0 (ignored) if missing
-  # Maximal amount of items per dispenser
-  MaxDispenserItems: 128 # defaults to 128 if missing
   # Maximal blast resistance for the design blocks
   MaxDesignBlastResistance: 100000000 # defaults to Double.MAX_VALUE if missing
-  # List of limited material (combinations)
-  # List contains tags Amount (integer) and Materials (List of material names in Spigot 1.12 AND Spigot 1.15 format)
+  # List of limited block materials
+  # InventoryMaterials are all disallowed by default to have any content but are unlimited in number
+  # Any Block that has more Blast Resistance than MaxBlastResistance will be defaulted to 0.
   Limited:
-    - Materials: [ ]
-      Amount: 0
+    - Blocks: [ DISPENSER ]
+      MaxCount: 64
+    - Blocks: [ DISPENSER ]
+      MaxCount: 16
+      Content:
+        Items: [ ARROW, FIRE_CHARGE ]
+        Amount: 128
+    - Blocks: [ storage ]
+      Content:
+        Items: [ TNT ]
+        Amount: 1728
 
 # The name of the game mode presented to the players
 GameName: WarGear # defaults to WarGear if missing

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

@@ -39,6 +39,7 @@ public enum ArenaMode {
     public static final Set<ArenaMode> Test = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK));
     public static final Set<ArenaMode> Prepare = Collections.unmodifiableSet(EnumSet.of(PREPARE));
     public static final Set<ArenaMode> Replay = Collections.unmodifiableSet(EnumSet.of(REPLAY, TEST));
+    public static final Set<ArenaMode> TestOrReferee = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK, EVENT));
 
     public static final Set<ArenaMode> AntiReplay = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(REPLAY)));
     public static final Set<ArenaMode> AntiTest = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK)));

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

@@ -22,7 +22,6 @@ package de.steamwar.fightsystem;
 import com.comphenix.tinyprotocol.TinyProtocol;
 import de.steamwar.core.Core;
 import de.steamwar.core.WorldEditRendererCUIEditor;
-import de.steamwar.fightsystem.commands.TechareaCommand;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.listener.ClickAnalyzer;
@@ -32,7 +31,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;
@@ -124,8 +126,6 @@ public class FightSystem extends JavaPlugin {
             if (checkSchematicNode.isPrepared()) {
                 Fight.getRedTeam().setSchem(checkSchematicNode, NodeData.getRevisions(checkSchematicNode) - 1);
             }
-
-            new TechareaCommand();
         } else if (Config.mode == ArenaMode.PREPARE) {
             Fight.getUnrotated().setSchem(SchematicNode.getSchematicNode(Config.PrepareSchemID));
         }

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

@@ -24,35 +24,25 @@ import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Kit;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.sql.UserPerm;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class AkCommand implements CommandExecutor {
+public class AkCommand extends FightSWCommand {
 
     public AkCommand() {
-        new StateDependentCommand(ArenaMode.Test, FightState.All, "ak", this);
+        super(ArenaMode.Test, FightState.All, "ak");
     }
 
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-        if (!player.isOp()) return false;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return player.isOp() && user.hasPerm(UserPerm.ADMINISTRATION) && Core.getInstance() != FightSystem.getPlugin();
+    }
 
-        if (!SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.ADMINISTRATION) && Core.getInstance() != FightSystem.getPlugin()) {
-            return false;
-        }
-
-        Kit.createKit(args[0], player);
-        return false;
+    @Register
+    public void run(@Validator Player player, String name) {
+        Kit.createKit(name, player);
     }
 }

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

@@ -0,0 +1,95 @@
+/*
+ *   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.fightsystem.commands;
+
+import de.steamwar.command.SWCommand;
+import de.steamwar.command.TypeValidator;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.states.FightState;
+import de.steamwar.fightsystem.states.StateDependent;
+import de.steamwar.sql.SteamwarUser;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandSendEvent;
+
+import java.util.Set;
+
+public abstract class FightSWCommand extends SWCommand implements Listener {
+
+    private final String command;
+    private final String[] aliases;
+
+    protected FightSWCommand(Set<ArenaMode> mode, Set<FightState> states, String command) {
+        super(command);
+        this.command = command;
+        this.aliases = new String[0];
+        stateDependant(mode, states);
+    }
+
+    protected FightSWCommand(Set<ArenaMode> mode, Set<FightState> states, String command, String... aliases) {
+        super(command, aliases);
+        this.command = command;
+        this.aliases = aliases;
+        stateDependant(mode, states);
+    }
+
+    private void stateDependant(Set<ArenaMode> mode, Set<FightState> states) {
+        FightSWCommand.this.unregister();
+        new StateDependent(mode, states) {
+            @Override
+            public void enable() {
+                System.out.println("--- Enable: " + command);
+                FightSWCommand.this.register();
+            }
+
+            @Override
+            public void disable() {
+                System.out.println("--- Disable: " + command);
+                FightSWCommand.this.unregister();
+            }
+        }.register();
+    }
+
+    public static void postFightStateChange() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            player.updateCommands();
+        }
+    }
+
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return true;
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public final void onPlayerCommandSend(PlayerCommandSendEvent event) {
+        if (hasPerm(event.getPlayer(), SteamwarUser.get(event.getPlayer().getUniqueId()))) return;
+        event.getCommands().remove(command);
+        for (String alias : aliases) {
+            event.getCommands().remove(alias);
+        }
+    }
+
+    @ClassValidator(value = Player.class, local = true)
+    public final TypeValidator<Player> permissionCheck() {
+        return (sender, value, messageSender) -> hasPerm(value, SteamwarUser.get(value.getUniqueId()));
+    }
+}

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

@@ -19,92 +19,28 @@
 
 package de.steamwar.fightsystem.commands;
 
-import com.google.common.collect.ImmutableList;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
-import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.linkage.Linked;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.Bukkit;
+import de.steamwar.sql.SteamwarUser;
 import org.bukkit.GameMode;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.defaults.BukkitCommand;
-import org.bukkit.craftbukkit.CraftServer;
 import org.bukkit.entity.Player;
-import org.bukkit.util.StringUtil;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
 
 @Linked
-public class GamemodeCommand extends BukkitCommand {
-
-    private static final List<String> GAMEMODE_NAMES = ImmutableList.of("adventure", "creative", "survival",
-            "spectator");
+public class GamemodeCommand extends FightSWCommand {
 
     public GamemodeCommand() {
-        super("gamemode");
-        List<String> aliases = new ArrayList<>();
-        aliases.add("gm");
-        this.setAliases(aliases);
-
-        Map<String, Command> knownCommands = ((CraftServer) Bukkit.getServer()).getCommandMap().getKnownCommands();
-        knownCommands.remove("gamemode");
-        Commands.injectCommand(this);
+        super(ArenaMode.TestOrReferee, FightState.All, "gamemode", "gm");
     }
 
     @Override
-    public boolean execute(CommandSender sender, String currentAlias, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        } else if (args.length == 0) {
-            FightSystem.getMessage().sendPrefixless("GAMEMODE_HELP", sender);
-            return false;
-        }
-
-        Player p = (Player) sender;
-
-        if (!(Config.test() || Config.isReferee(p))) {
-            FightSystem.getMessage().sendPrefixless("GAMEMODE_NOT_ALLOWED", p, ChatMessageType.ACTION_BAR);
-            return false;
-        }
-
-        GameMode mode = createMode(args[0]);
-
-        if (mode == null) {
-            FightSystem.getMessage().sendPrefixless("GAMEMODE_UNKNOWN", p, ChatMessageType.ACTION_BAR, args[0]);
-            return false;
-        }
-
-        p.setGameMode(mode);
-        return true;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Config.test() || Config.isReferee(player);
     }
 
-    @SuppressWarnings("deprecation")
-    private GameMode createMode(String modeArg) {
-        try {
-            return GameMode.getByValue(Integer.parseInt(modeArg));
-        } catch (NumberFormatException ignored) {
-            if ((modeArg.equalsIgnoreCase("creative")) || (modeArg.equalsIgnoreCase("c"))) {
-                return GameMode.CREATIVE;
-            } else if ((modeArg.equalsIgnoreCase("adventure")) || (modeArg.equalsIgnoreCase("a"))) {
-                return GameMode.ADVENTURE;
-            } else if ((modeArg.equalsIgnoreCase("spectator")) || (modeArg.equalsIgnoreCase("sp"))) {
-                return GameMode.SPECTATOR;
-            } else if ((modeArg.equalsIgnoreCase("survival")) || (modeArg.equalsIgnoreCase("s"))) {
-                return GameMode.SURVIVAL;
-            }
-        }
-        return null;
+    @Register(description = "GAMEMODE_HELP")
+    public void execute(@Validator Player player, GameMode gameMode) {
+        player.setGameMode(gameMode);
     }
-
-    @Override
-    public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
-        if (args.length == 1) {
-            return StringUtil.copyPartialMatches(args[0], GAMEMODE_NAMES, new ArrayList<>(GAMEMODE_NAMES.size()));
-        }
-        return ImmutableList.of();
-    }
-
 }

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

@@ -20,34 +20,31 @@
 package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
+import de.steamwar.fightsystem.listener.Check;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
-import de.steamwar.sql.UserPerm;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class InfoCommand implements CommandExecutor {
+public class InfoCommand extends FightSWCommand {
 
     public InfoCommand() {
-        new StateDependentCommand(ArenaMode.All, FightState.All, "fightinfo", this);
+        super(ArenaMode.All, FightState.All, "fightinfo");
     }
 
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) return false;
-
-        Player player = (Player) sender;
-        if (!SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.CHECK)) return false;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Check.checkPermission(user, Config.GameModeConfig);
+    }
 
+    @Register
+    public void run(@Validator Player player) {
         for (FightTeam team : Fight.teams()) {
             if (!team.isLeaderless()) {
                 FightSystem.getMessage().send("INFO_LEADER", player, team.getColoredName(), team.getLeader().getEntity().getName());
@@ -58,6 +55,5 @@ public class InfoCommand implements CommandExecutor {
                 FightSystem.getMessage().send("INFO_SCHEMATIC", player, team.getColoredName(), schematic.getName(), SteamwarUser.byId(schematic.getOwner()).getUserName(), schematic.getRank());
             }
         }
-        return false;
     }
 }

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

@@ -21,32 +21,23 @@ package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class KitCommand implements CommandExecutor {
+public class KitCommand extends FightSWCommand {
 
     public KitCommand() {
-        new StateDependentCommand(ArenaMode.AntiReplay, FightState.Setup, "kit", this);
+        super(ArenaMode.AntiReplay, FightState.Setup, "kit");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
+    @Register
+    public void execute(Player player) {
+        GUI.kitSelection(player, "");
+    }
 
-        if (args.length != 1) {
-            GUI.kitSelection(player, "");
-        } else {
-            Commands.kit(player, args[0]);
-        }
-        return false;
+    @Register
+    public void execute(Player player, String query) { // TODO: TabCompletion of Kit Names!
+        GUI.kitSelection(player, query);
     }
 }

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

@@ -21,28 +21,18 @@ package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class LeaveCommand implements CommandExecutor {
+public class LeaveCommand extends FightSWCommand {
 
     public LeaveCommand() {
-        new StateDependentCommand(ArenaMode.AntiReplay, FightState.Setup, "leave", this);
+        super(ArenaMode.AntiReplay, FightState.Setup, "leave");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
+    @Register
+    public void execute(Player player) {
         Commands.leaveTeam(player);
-        return false;
     }
 }

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

@@ -20,52 +20,42 @@
 package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
+import de.steamwar.fightsystem.listener.Check;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SchematicType;
 import de.steamwar.sql.SteamwarUser;
-import de.steamwar.sql.UserPerm;
 import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class LockschemCommand implements CommandExecutor {
+public class LockschemCommand extends FightSWCommand {
 
     public LockschemCommand() {
-        new StateDependentCommand(ArenaMode.All, FightState.Schem, "lockschem", this);
+        super(ArenaMode.All, FightState.Schem, "lockschem");
     }
 
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) return false;
-        Player player = (Player) sender;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Check.checkPermission(user, Config.GameModeConfig);
+    }
 
-        if (!SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.CHECK)) return false;
-
-        if (args.length != 1) {
-            FightSystem.getMessage().sendPrefixless("LOCKSCHEM_HELP", player);
-            return false;
-        }
-
-        String teamName = args[0];
+    @Register(description = "LOCKSCHEM_HELP")
+    public void execute(@Validator Player player, String teamName) {
         FightTeam fightTeam = Fight.getTeamByName(teamName);
 
         if (fightTeam == null) {
             FightSystem.getMessage().sendPrefixless("UNKNOWN_TEAM", player, ChatMessageType.ACTION_BAR);
-            return false;
+            return;
         }
 
         SchematicNode.getSchematicNode(fightTeam.getSchematic()).setSchemtype(SchematicType.Normal);
         FightSystem.getMessage().sendPrefixless("LOCKSCHEM_LOCKED", player, ChatMessageType.ACTION_BAR);
         fightTeam.broadcastSystem("LOCKSCHEM_LOCKED_BY", player.getName());
-        return false;
     }
 }

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

@@ -21,28 +21,18 @@ package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class ReadyCommand implements CommandExecutor {
+public class ReadyCommand extends FightSWCommand {
 
     public ReadyCommand() {
-        new StateDependentCommand(ArenaMode.AntiPrepare, FightState.PostSchemSetup, "ready", this);
+        super(ArenaMode.AntiPrepare, FightState.PostSchemSetup, "ready");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
+    @Register
+    public void execute(Player player) {
         Commands.toggleReady(player);
-        return false;
     }
 }

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

@@ -20,35 +20,19 @@
 package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
-import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class RemoveCommand implements CommandExecutor {
+public class RemoveCommand extends FightSWCommand {
 
     public RemoveCommand() {
-        new StateDependentCommand(ArenaMode.VariableTeams, FightState.Setup, "remove", this);
+        super(ArenaMode.VariableTeams, FightState.Setup, "remove");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
-        if (args.length != 1) {
-            FightSystem.getMessage().sendPrefixless("REMOVE_HELP", player);
-            return false;
-        }
-
-        Commands.kick(player, args[0]);
-        return false;
+    @Register(description = "REMOVE_HELP")
+    public void execute(Player player, Player teamMember) {
+        Commands.kick(player, teamMember.getName());
     }
 }

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

@@ -26,37 +26,28 @@ import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.fight.JoinRequest;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 import java.util.function.BiConsumer;
 
 @Linked
-public class RequestsCommand implements CommandExecutor {
+public class RequestsCommand extends FightSWCommand {
 
     public RequestsCommand() {
-        new StateDependentCommand(ArenaMode.VariableTeams, FightState.AntiSpectate, "request", this);
-        new StateDependentCommand(ArenaMode.VariableTeams, FightState.AntiSpectate, "requests", this);
+        super(ArenaMode.VariableTeams, FightState.AntiSpectate, "request", "requests");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) return false;
-        Player player = (Player) sender;
+    @Register
+    public void execute(Player player) {
         FightPlayer fp = Fight.getFightPlayer(player);
         if (fp == null || !(fp.isLeader() || fp.isLiving())) {
             GUI.joinRequest(player);
-            return false;
+            return;
         }
 
-        if (Commands.checkGetLeader(player) == null) return false;
-
+        if (Commands.checkGetLeader(player) == null) return;
         GUI.chooseJoinRequests(player);
-        return false;
     }
 
     public static void onJoinRequest(Player player, JoinRequest request, BiConsumer<JoinRequest, FightTeam> handleJoinRequest) {

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

@@ -24,32 +24,22 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.record.PacketProcessor;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class SkipCommand implements CommandExecutor {
+public class SkipCommand extends FightSWCommand {
 
     public SkipCommand() {
-        new StateDependentCommand(ArenaMode.AntiPrepare, ArenaMode.Replay.contains(Config.mode) ? FightState.All : FightState.TeamFix, "skip", this);
+        super(ArenaMode.AntiPrepare, ArenaMode.Replay.contains(Config.mode) ? FightState.All : FightState.TeamFix, "skip");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
+    @Register
+    public void execute(Player player) {
         if (PacketProcessor.isReplaying() && player.getUniqueId().equals(Fight.getBlueTeam().getDesignatedLeader())) {
             PacketProcessor.currentReplay().skipToSubtitle();
         } else {
             Commands.toggleSkip(player);
         }
-        return false;
     }
 }

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

@@ -21,27 +21,18 @@ package de.steamwar.fightsystem.commands;
 
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class StateCommand implements CommandExecutor {
+public class StateCommand extends FightSWCommand {
 
     public StateCommand() {
-        new StateDependentCommand(ArenaMode.Test, FightState.All, "state", this);
+        super(ArenaMode.Test, FightState.All, "state");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-
-        GUI.state((Player) sender);
-        return false;
+    @Register
+    public void execute(Player player) {
+        GUI.state(player);
     }
 }

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

@@ -22,26 +22,18 @@ package de.steamwar.fightsystem.commands;
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class TBCommand implements CommandExecutor {
+public class TBCommand extends FightSWCommand {
 
     public TBCommand() {
-        new StateDependentCommand(ArenaMode.Check, FightState.All, "resettb", this);
+        super(ArenaMode.Check, FightState.All, "resettb");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
+    @Register
+    public void execute(Player player) {
         Fight.getRedTeam().pasteSchem();
-        return false;
     }
 }

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

@@ -20,34 +20,20 @@ package de.steamwar.fightsystem.commands;
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import net.minecraft.server.MinecraftServer;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 @Linked
-public class TPSWarpCommand implements CommandExecutor {
+public class TPSWarpCommand extends FightSWCommand {
 
     public TPSWarpCommand() {
-        new StateDependentCommand(ArenaMode.Prepare, FightState.PostSchemSetup, "tpswarp", this);
-        new StateDependentCommand(ArenaMode.Prepare, FightState.PostSchemSetup, "tpslimit", this);
+        super(ArenaMode.Prepare, FightState.PostSchemSetup, "tpswarp", "tpslimit");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        float tps;
-        try {
-            tps = Float.parseFloat(args[0]);
-        } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
-            FightSystem.getMessage().send("TPSWARP_HELP", sender);
-            return false;
-        }
-
+    @Register(description = "TPSWARP_HELP")
+    public void execute(Player player, float tps) {
         MinecraftServer.getServer().tickRateManager().setTickRate(tps);
-
         FightSystem.getMessage().broadcastActionbar("TPSWARP_SET", tps);
-        return false;
     }
 }

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

@@ -19,42 +19,39 @@
 
 package de.steamwar.fightsystem.commands;
 
-import de.steamwar.command.SWCommand;
 import de.steamwar.entity.CWireframe;
 import de.steamwar.entity.REntityServer;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
-import de.steamwar.fightsystem.FightSystem;
-import org.bukkit.Bukkit;
+import de.steamwar.fightsystem.states.FightState;
+import de.steamwar.fightsystem.states.OneShotStateDependent;
+import de.steamwar.linkage.Linked;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
-public class TechareaCommand extends SWCommand {
-    private final Map<UUID, REntityServer> servers = new HashMap<>();
+@Linked
+public class TechareaCommand extends FightSWCommand {
+    private REntityServer entityServer = new REntityServer();
 
     public TechareaCommand() {
-        super("techarea");
-
-        Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), () -> servers.forEach((uuid, rEntityServer) -> rEntityServer.tick()), 2, 2);
-    }
-
-    @Register
-    public void genericCommand(Player player) {
-        if (servers.containsKey(player.getUniqueId())) {
-            servers.get(player.getUniqueId()).close();
-        } else {
+        super(ArenaMode.Check, FightState.All, "techarea");
+        new OneShotStateDependent(ArenaMode.Check, FightState.All, () -> {
+            if (!entityServer.getEntities().isEmpty()) return;
             REntityServer server = new REntityServer();
             CWireframe wireframe = new CWireframe(server);
 
             wireframe.setPos1(Config.BlueInsetRegion.getMinLocation(Config.world));
             wireframe.setPos2(Config.BlueInsetRegion.getMaxLocation(Config.world).subtract(1, 1, 1));
             wireframe.setBlock(Material.RED_CONCRETE.createBlockData());
+        });
+    }
 
-            server.addPlayer(player);
-            servers.put(player.getUniqueId(), server);
+    @Register
+    public void genericCommand(Player player) {
+        if (entityServer.getPlayers().contains(player)) {
+            entityServer.removePlayer(player);
+        } else {
+            entityServer.addPlayer(player);
         }
     }
 }

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

@@ -25,27 +25,24 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SWException;
 import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 import java.io.StringWriter;
 import java.util.Arrays;
 import java.util.logging.Level;
 
 @Linked
-public class TechhiderbugCommand implements CommandExecutor {
+public class TechhiderbugCommand extends FightSWCommand {
 
     public TechhiderbugCommand() {
-        new StateDependentCommand(ArenaMode.All, FightState.All, "techhiderbug", this);
+        super(ArenaMode.All, FightState.All, "techhiderbug");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command cmd, String alias, String[] args) {
+    @Register
+    public void execute(Player player, String... args) {
         StringWriter writer = new StringWriter();
 
         try {
@@ -76,7 +73,6 @@ public class TechhiderbugCommand implements CommandExecutor {
             Bukkit.getLogger().log(Level.SEVERE, "Error while generating bug report", e);
         }
 
-        SWException.log("Techhider-Bug reported by " + sender.getName() + ": " + Arrays.toString(args), writer.toString());
-        return false;
+        SWException.log("Techhider-Bug reported by " + player.getName() + ": " + Arrays.toString(args), writer.toString());
     }
 }

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

@@ -23,28 +23,20 @@ import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightWorld;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 @Linked
-public class WGCommand implements CommandExecutor {
+public class WGCommand extends FightSWCommand {
 
     public WGCommand() {
-        new StateDependentCommand(ArenaMode.Check, FightState.All, "resetwg", this);
+        super(ArenaMode.Check, FightState.All, "resetwg");
     }
 
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
+    @Register
+    public void execute(Player player) {
         FightWorld.resetWorld();
         Fight.getBlueTeam().pasteSchem();
         Fight.getRedTeam().pasteSchem();
-        return false;
     }
 }

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

@@ -25,49 +25,34 @@ import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import de.steamwar.sql.SteamwarUser;
 import org.bukkit.entity.Player;
 
 @Linked
-public class WinCommand implements CommandExecutor {
+public class WinCommand extends FightSWCommand {
 
     public WinCommand() {
-        new StateDependentCommand(ArenaMode.Event, FightState.Ingame, "win", this);
+        super(ArenaMode.Event, FightState.Ingame, "win");
     }
 
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player p = (Player) sender;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Config.isReferee(player);
+    }
 
-        if (!Config.isReferee(p)) {
-            FightSystem.getMessage().sendPrefixless("NOT_FIGHTLEADER", p, ChatMessageType.ACTION_BAR);
-            return false;
-        }
-
-        if (args.length == 0) {
-            FightSystem.getMessage().sendPrefixless("WIN_HELP", p);
-            return false;
-        }
-
-        if (args[0].equalsIgnoreCase("tie")) {
+    @Register
+    public void execute(@Validator Player player, String teamName) {
+        if (teamName.equalsIgnoreCase("tie")) {
             FightSystem.setSpectateState(null, "Referee", "WIN_FIGHTLEADER");
-            return false;
+            return;
         }
 
         for (FightTeam team : Fight.teams()) {
-            if (args[0].equalsIgnoreCase(team.getName())) {
+            if (teamName.equalsIgnoreCase(team.getName())) {
                 FightSystem.setSpectateState(team, "Referee", "WIN_FIGHTLEADER");
-                return false;
+                return;
             }
         }
-        return false;
     }
 }

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

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

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

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

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

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

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/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/Check.java

@@ -25,6 +25,7 @@ import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.linkage.Linked;
+import de.steamwar.sql.GameModeConfig;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.sql.UserPerm;
@@ -44,14 +45,28 @@ public class Check implements Listener {
         new StateDependentListener(ArenaMode.Check, FightState.All, this);
     }
 
+    private boolean checkPermission(SteamwarUser user, SchematicNode schematic) {
+        GameModeConfig<Object, String> gameModeConfig = GameModeConfig.getAll().stream()
+                .filter(gmc -> gmc.Schematic.Type != null && gmc.Schematic.Type.checkType() != null && schematic.getSchemtype().name().equals(gmc.Schematic.Type.checkType().name()))
+                .findFirst()
+                .orElse(null);
+        if (gameModeConfig == null) gameModeConfig = GameModeConfig.getDefaults();
+        return checkPermission(user, gameModeConfig);
+    }
+
+    public static boolean checkPermission(SteamwarUser user, GameModeConfig gameModeConfig) {
+        if (user.hasPerm(UserPerm.ADMINISTRATION)) return true;
+        if (gameModeConfig.Checkers.isEmpty() && user.hasPerm(UserPerm.CHECK)) return true;
+        return gameModeConfig.Checkers.contains(user.getId());
+    }
+
     @EventHandler
     public void onJoin(PlayerJoinEvent e) {
         Player player = e.getPlayer();
         SteamwarUser user = SteamwarUser.get(player.getUniqueId());
 
-        if (user.hasPerm(UserPerm.CHECK)) return;
-
         SchematicNode schem = SchematicNode.getSchematicNode(Config.CheckSchemID);
+        if (checkPermission(user, schem)) return;
         if (user.getId() == schem.getOwner()) return;
 
         FightSystem.getMessage().send("CHECK_JOIN_DENIED", player);

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

@@ -20,7 +20,6 @@
 package de.steamwar.fightsystem.listener;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
@@ -37,7 +36,6 @@ import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.fightsystem.utils.SWSound;
 import de.steamwar.linkage.Linked;
-import net.minecraft.network.protocol.Packet;
 import net.minecraft.network.protocol.game.ServerboundPlayerActionPacket;
 import net.minecraft.network.protocol.game.ServerboundUseItemPacket;
 import net.minecraft.world.InteractionHand;
@@ -115,18 +113,18 @@ public class Recording implements Listener {
         }.register();
         new StateDependent(ArenaMode.AntiReplay, FightState.Ingame) {
             private final BiFunction<Player, ServerboundUseItemPacket, Object> place = Recording.this::blockPlace;
-            private final BiFunction<Player, Object, Object> dig = Recording.this::blockDig;
+            private final BiFunction<Player, ServerboundPlayerActionPacket, Object> dig = Recording.this::blockDig;
 
             @Override
             public void enable() {
                 TinyProtocol.instance.addFilter(ServerboundUseItemPacket.class, place);
-                TinyProtocol.instance.addFilter(blockDigPacket, dig);
+                TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, dig);
             }
 
             @Override
             public void disable() {
                 TinyProtocol.instance.removeFilter(ServerboundUseItemPacket.class, place);
-                TinyProtocol.instance.removeFilter(blockDigPacket, dig);
+                TinyProtocol.instance.removeFilter(ServerboundPlayerActionPacket.class, dig);
             }
         }.register();
         new StateDependentTask(ArenaMode.AntiReplay, FightState.All, () -> {
@@ -143,13 +141,8 @@ public class Recording implements Listener {
         GlobalRecorder.getInstance().entitySpeed(entity);
     }
 
-    private static final Class<? extends Packet<?>> blockDigPacket = ServerboundPlayerActionPacket.class;
-    private 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;

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

@@ -72,6 +72,9 @@ public class WaterRemover implements Listener {
 
     @EventHandler
     public void handleEntityExplode(EntityExplodeEvent event) {
+        if (event.getEntityType() == EntityType.WIND_CHARGE && !Config.GameModeConfig.Arena.WindchargesDestroyWater) {
+            return;
+        }
         event.setYield(0); //No drops (additionally to world config)
 
         FightTeam spawn = tnt.remove(event.getEntity().getEntityId());

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/WindchargeInteractionDisabler.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.fightsystem.listener;
+
+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.EntityType;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityExplodeEvent;
+
+@Linked
+public class WindchargeInteractionDisabler implements Listener {
+
+    public WindchargeInteractionDisabler() {
+        new StateDependentListener(!Config.GameModeConfig.Arena.WindchargesInteractWithBlocks, FightState.Running, this);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void handleEntityExplode(EntityExplodeEvent event) {
+        if (event.getEntityType() != EntityType.WIND_CHARGE) return;
+        event.blockList().clear();
+    }
+}

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

@@ -23,14 +23,14 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.linkage.Linked;
+import net.minecraft.world.entity.projectile.windcharge.WindCharge;
 import org.bukkit.Location;
-import org.bukkit.entity.WindCharge;
 
 @Linked
 public class WindchargeStopper {
 
     public WindchargeStopper() {
-        new StateDependentTask(true, FightState.Running, this::run, 1, 1);
+        new StateDependentTask(!Config.GameModeConfig.Arena.WindchargesCanCrossMiddle, FightState.Running, this::run, 1, 1);
     }
 
     private static final int middleLine = Config.SpecSpawn.getBlockZ();
@@ -39,13 +39,13 @@ public class WindchargeStopper {
 
     private void run() {
         Recording.iterateOverEntities(windChargeClass::isInstance, entity -> {
+            Location nextlocation = entity.getLocation().add(entity.getVelocity());
             Location location = entity.getLocation();
-            Location prevLocation = location.clone().subtract(entity.getVelocity());
 
-            boolean passedMiddle = location.getBlockZ() > middleLine && prevLocation.getBlockZ() > middleLine ||
-                    location.getBlockZ() < middleLine && prevLocation.getBlockZ() < middleLine;
+            boolean passedMiddle = nextlocation.getBlockZ() >= middleLine && location.getBlockZ() <= middleLine ||
+                    nextlocation.getBlockZ() <= middleLine && location.getBlockZ() >= middleLine;
 
-            if (!passedMiddle) {
+            if (passedMiddle) {
                 entity.remove();
             }
         });

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/states/FightState.java

@@ -19,6 +19,7 @@
 
 package de.steamwar.fightsystem.states;
 
+import de.steamwar.fightsystem.commands.FightSWCommand;
 import lombok.Getter;
 
 import java.util.*;
@@ -62,6 +63,7 @@ public enum FightState {
     }
 
     public static void setFightState(FightState state) {
+        if (fightState.equals(state)) return;
         fightState = state;
 
         for (Map.Entry<IStateDependent, Boolean> feature : stateDependentFeatures.entrySet()) {
@@ -77,6 +79,7 @@ public enum FightState {
                 feature.setValue(false);
             }
         }
+        FightSWCommand.postFightStateChange();
     }
 
     public static boolean setup() {

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

@@ -1,58 +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.fightsystem.states;
-
-import de.steamwar.fightsystem.ArenaMode;
-import de.steamwar.fightsystem.FightSystem;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.PluginCommand;
-
-import java.util.Set;
-
-public class StateDependentCommand extends StateDependent {
-
-    private static final CommandExecutor unavailable = (sender, cmd, s, strings) -> {
-        FightSystem.getMessage().sendPrefixless("COMMAND_CURRENTLY_UNAVAILABLE", sender, ChatMessageType.ACTION_BAR);
-        return false;
-    };
-
-    private final PluginCommand command;
-    private final CommandExecutor executor;
-
-    public StateDependentCommand(Set<ArenaMode> mode, Set<FightState> states, String name, CommandExecutor executor) {
-        super(mode, states);
-        this.executor = executor;
-        this.command = FightSystem.getPlugin().getCommand(name);
-        assert command != null;
-        disable();
-        register();
-    }
-
-    @Override
-    public void enable() {
-        command.setExecutor(executor);
-    }
-
-    @Override
-    public void disable() {
-        command.setExecutor(unavailable);
-    }
-}

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

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

FightSystem/FightSystem_Core/src/plugin.yml

@@ -10,22 +10,4 @@ depend:
   - WorldEdit
 api-version: "1.13"
 
-commands:
-  ak:
-  request:
-  requests:
-  fightinfo:
-  leave:
-  ready:
-  kit:
-  remove:
-  lockschem:
-  state:
-  skip:
-  win:
-  resetwg:
-  resettb:
-  tpslimit:
-  tpswarp:
-  techhiderbug:
-  unrank:
+commands:

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"
@@ -64,22 +54,14 @@ tasks.register<FightServer>("WarGear21") {
     jar = "/jars/paper-1.21.6.jar"
 }
 
-tasks.register<FightServer>("SpaceCraftDev20") {
+tasks.register<FightServer>("WarShip21") {
     group = "run"
-    description = "Run a SpaceCraftDev 1.20 Fight Server"
+    description = "Run a WarShip 1.21 Fight Server"
     dependsOn(":SpigotCore:shadowJar")
     dependsOn(":FightSystem:shadowJar")
-    template = "SpaceCraft20"
-    worldName = "arenas/AS_Horizon"
-    config = "SpaceCraftDev20.yml"
+    dependsOn(":KotlinCore:shadowJar")
+    template = "WarShip21"
+    worldName = "arenas/Artic"
+    config = "WarShip21.yml"
+    jar = "/jars/paper-1.21.6.jar"
 }
-
-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"
-}