Move a lot more logic into component

Remove old cursor
Refactor to player components
2026-06-03 21:13:44 +02:00 · 2026-06-03 20:48:50 +02:00 · 2026-06-03 20:46:51 +02:00
160 changed files with 2106 additions and 6461 deletions
@@ -51,7 +51,6 @@ 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"
@@ -15,11 +15,6 @@ bin/
 .vscode
 .settings
 # Language Server
 **/.project
 **/.factorypath
 **/.classpath
 # Other
 lib
 /WebsiteBackend/data
@@ -1,45 +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/>.
 */
 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)
 }
@@ -1,49 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 /**
 * 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);
    }
 }
@@ -1,104 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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;
        };
    }
 }
@@ -1,75 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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.");
    }
 }
@@ -1,83 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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;
        }
    }
 }
@@ -1,125 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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;
    }
 }
@@ -1,125 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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());
        }
    }
 }
@@ -1,60 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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;
    }
 }
@@ -1,44 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar;
 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);
    }
 }
@@ -19,7 +19,6 @@
 plugins {
    steamwar.java
    widener
 }
 tasks.compileJava {
@@ -35,7 +34,6 @@ dependencies {
    compileOnly(libs.classindex)
    annotationProcessor(libs.classindex)
    compileOnly(project(":SpigotCore", "default"))
    compileOnly(project(":KotlinCore", "default"))
    compileOnly(libs.axiom)
    compileOnly(libs.authlib)
@@ -49,7 +47,3 @@ dependencies {
    implementation(libs.luaj)
    implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
 }
 widener {
    fromCatalog(libs.nms)
 }
@@ -834,10 +834,6 @@ 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.
@@ -772,10 +772,6 @@ 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.
@@ -1,13 +0,0 @@
 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
@@ -1,31 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.bausystem.features.experimental;
 import de.steamwar.command.SWCommand;
 import de.steamwar.linkage.Linked;
@Linked
 public class ExperimentalCommand extends SWCommand {
    public ExperimentalCommand() {
        super("experimental", "experiment");
    }
 }
@@ -1,135 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.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";
        }
    }
 }
@@ -290,7 +290,7 @@ public class KillcheckerVisualizer {
                }
                rEntities.get(point).die();
            }
-            RBlockDisplay entity = new RBlockDisplay(outlinePoints.contains(point) ? outline : inner, point.toLocation(WORLD, 0, 0, 0));
+            RBlockDisplay entity = new RBlockDisplay(outlinePoints.contains(point) ? outline : inner, point.toLocation(WORLD, 0.5, 0, 0.5));
            entity.setBlock(MATERIALS[Math.min(count - 1, MATERIALS.length) - 1].createBlockData());
            rEntities.put(point, entity);
            if (outlinePoints.contains(point)) outlinePointsCache.add(point);
@@ -185,16 +185,17 @@ 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<>();
+                List<String> stringList = new ArrayList<>(SchematicNode.getNodeTabcomplete(SteamwarUser.get(((Player) commandSender).getUniqueId()), s));
                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.byId(0), s);
+                SchematicNode node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
-                if (node == null) node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
+                if (node == null) {
                    node = SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
                }
                return node;
            }
        };
@@ -38,7 +38,7 @@ import java.util.Collection;
 public class SimulatorCommand extends SWCommand {
    @LinkedInstance
-    public SimulatorCursor simulatorCursor;
+    public SimulatorCursorManager simulatorCursorManager;
    public SimulatorCommand() {
        super("sim", "simulator");
@@ -47,12 +47,12 @@ public class SimulatorCommand extends SWCommand {
    @Register(description = "SIMULATOR_HELP")
    public void genericCommand(@Validator Player p) {
        SWUtils.giveItemToPlayer(p, SimulatorStorage.getWand(p));
-        simulatorCursor.calcCursor(p);
+        simulatorCursorManager.calcCursor(p);
    }
    @Register(value = "change", description = "SIMULATOR_CHANGE_HELP")
    public void change(@Validator Player p) {
-        if (!SimulatorCursor.isSimulatorItem(p.getInventory().getItemInMainHand()) && !SimulatorCursor.isSimulatorItem(p.getInventory().getItemInOffHand())) {
+        if (!SimulatorCursorManager.isSimulatorItem(p.getInventory().getItemInMainHand()) && !SimulatorCursorManager.isSimulatorItem(p.getInventory().getItemInOffHand())) {
            BauSystem.MESSAGE.send("SIMULATOR_NO_SIM_IN_HAND", p);
            return;
        }
@@ -1,364 +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.bausystem.features.simulator;
 import com.destroystokyo.paper.event.server.ServerTickEndEvent;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.SWUtils;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.data.observer.ObserverElement;
 import de.steamwar.bausystem.features.simulator.data.observer.ObserverPhase;
 import de.steamwar.bausystem.features.simulator.data.redstone.RedstoneElement;
 import de.steamwar.bausystem.features.simulator.data.redstone.RedstonePhase;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
 import de.steamwar.bausystem.features.simulator.execute.SimulatorExecutor;
 import de.steamwar.bausystem.features.simulator.gui.SimulatorGroupGui;
 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.core.SWPlayer;
 import de.steamwar.cursor.Cursor;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
 import de.steamwar.inventory.SWAnvilInv;
 import de.steamwar.linkage.Linked;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 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.Function;
 import java.util.stream.Collectors;
@Linked
 public class SimulatorCursor implements Listener {
    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");
    }
    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;
        scheduleCursorUpdate(event.getPlayer());
    }
    @EventHandler
    public void onPlayerDropItem(PlayerDropItemEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
        scheduleCursorUpdate(event.getPlayer());
    }
    @EventHandler
    public void onPlayerItemHeld(PlayerItemHeldEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
        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
    public void onBauMemberUpdate(BauMemberUpdateEvent event) {
        event.getChanged().forEach(SimulatorCursor::calcCursor);
    }
    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
        cursorType.remove(event.getPlayer());
        removeCursor(event.getPlayer());
        scheduledUpdates.remove(event.getPlayer());
    }
    private static final Map<Player, Long> LAST_SNEAKS = new HashMap<>();
    static {
        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
            long millis = System.currentTimeMillis();
            LAST_SNEAKS.entrySet().removeIf(entry -> millis - entry.getValue() > 200);
        }, 1, 1);
    }
    @EventHandler(priority = EventPriority.HIGH)
    public void onPlayerToggleSneak(PlayerToggleSneakEvent event) {
        if (!event.isSneaking()) return;
        Player player = event.getPlayer();
        if (!hasSimulatorItem(player)) {
            return;
        }
        if (LAST_SNEAKS.containsKey(player)) {
            CursorType currentType = cursorType.getOrDefault(player, CursorType.TNT);
            if (currentType == CursorType.TNT) {
                cursorType.put(player, CursorType.REDSTONE_BLOCK);
            } else {
                cursorType.put(player, CursorType.TNT);
            }
            calcCursor(player);
        } else {
            LAST_SNEAKS.put(player, System.currentTimeMillis());
        }
    }
    public static CursorType getCursorType(Player player) {
        return cursorType.getOrDefault(player, CursorType.TNT);
    }
    public static void setCursorType(Player player, CursorType cursorType) {
        SimulatorCursor.cursorType.put(player, cursorType);
        calcCursor(player);
    }
    public static void calcCursor(Player player) {
        if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
            if (removeCursor(player) | SimulatorWatcher.show(null, player)) {
                SWUtils.sendToActionbar(player, "");
            }
            return;
        }
        Simulator simulator = SimulatorStorage.getSimulator(player);
        if (simulator != null && simulator.getStabGenerator() != null) {
            removeCursor(player);
            SimulatorWatcher.show(null, player);
            SWUtils.sendToActionbar(player, "§cGenerating Stab");
            return;
        }
        SimulatorWatcher.show(simulator, player);
        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);
        }
        return cursor;
    }
    private static synchronized boolean removeCursor(Player player) {
        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 cursor.isPresent();
    }
    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");
        } else if (hasHitEntity) {
            SWUtils.sendToActionbar(player, "§eEdit Position");
        } else {
            SWUtils.sendToActionbar(player, "§eAdd new " + cursorType.getOrDefault(player, CursorType.TNT).name);
        }
    }
    @Getter
    @AllArgsConstructor
    public enum CursorType {
        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 List<Cursor.CursorMode> cursorModes;
        public final String name;
        public final Function<Vector, SimulatorElement<?>> elementFunction;
    }
    private static void handlePlayerClick(Player player, Location cursorLocation, Optional<REntity> hitEntity, Action action) {
        if (!Permission.BUILD.hasPermission(player)) return;
        if (!hasSimulatorItem(player)) {
            return;
        }
        Simulator simulator = SimulatorStorage.getSimulator(player);
        if (action == Action.LEFT_CLICK_BLOCK || action == Action.LEFT_CLICK_AIR) {
            if (simulator == null) {
                return;
            }
            SimulatorExecutor.run(player, simulator, null);
            return;
        }
        if (action != Action.RIGHT_CLICK_BLOCK && action != Action.RIGHT_CLICK_AIR) {
            return;
        }
        if (simulator == null) {
            if (cursorLocation == null) {
                SimulatorStorage.openSimulatorSelector(player);
            } else {
                SWAnvilInv anvilInv = new SWAnvilInv(player, "Name");
                anvilInv.setCallback(s -> {
                    Simulator sim = SimulatorStorage.getSimulator(s);
                    if (sim != null) {
                        BauSystem.MESSAGE.send("SIMULATOR_NAME_ALREADY_EXISTS", player);
                        return;
                    }
                    if (!s.matches("[a-zA-Z_0-9-]+")) {
                        BauSystem.MESSAGE.send("SIMULATOR_NAME_INVALID", player);
                        return;
                    }
                    sim = new Simulator(s);
                    SimulatorStorage.addSimulator(s, sim);
                    createElement(player, cursorLocation, sim);
                    SimulatorStorage.setSimulator(player, sim);
                });
                anvilInv.open();
            }
            return;
        }
        if (cursorLocation == null) {
            new SimulatorGui(player, simulator).open();
            return;
        }
        if (hitEntity.isPresent()) {
            openElement(player, simulator, hitEntity.get());
            return;
        }
        createElement(player, cursorLocation, 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 = cursorLocation.toVector();
        if (type == CursorType.REDSTONE_BLOCK) {
            vector.subtract(new Vector(0.5, 0, 0.5));
        }
        SimulatorElement<?> element = type.elementFunction.apply(vector);
        SimulatorGroup group = new SimulatorGroup().add(element);
        simulator.getGroups().add(group);
        SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
        element.open(player, simulator, group, simulatorGui);
        SimulatorWatcher.update(simulator);
        calcCursor(player);
    }
 }
@@ -0,0 +1,440 @@
 /*
 *   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.bausystem.features.simulator;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.SWUtils;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.data.observer.ObserverElement;
 import de.steamwar.bausystem.features.simulator.data.observer.ObserverPhase;
 import de.steamwar.bausystem.features.simulator.data.redstone.RedstoneElement;
 import de.steamwar.bausystem.features.simulator.data.redstone.RedstonePhase;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
 import de.steamwar.bausystem.features.simulator.execute.SimulatorExecutor;
 import de.steamwar.bausystem.features.simulator.gui.SimulatorGroupGui;
 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.core.SWPlayer;
 import de.steamwar.cursor.Cursor;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
 import de.steamwar.inventory.SWAnvilInv;
 import de.steamwar.linkage.Linked;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 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.player.PlayerDropItemEvent;
 import org.bukkit.event.player.PlayerItemHeldEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerToggleSneakEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@Linked
 public class SimulatorCursorManager implements Listener {
    private static class SimulatorCursorComponent implements SWPlayer.Component {
        private Player player;
        private Cursor cursor;
        private CursorType cursorType = CursorType.TNT;
        private REntityServer emptyTargetServer;
        private REntityServer currentTargetServer;
        private long lastSneakMillis;
        private SimulatorCursorComponent() {
        }
        private SimulatorCursorComponent(CursorType cursorType) {
            this.cursorType = cursorType;
        }
        private REntityServer getOrCreateEmptyTargetServer() {
            if (emptyTargetServer == null) {
                emptyTargetServer = new REntityServer();
            }
            return emptyTargetServer;
        }
        private boolean handleSneak(long now) {
            boolean doubleSneak = now - lastSneakMillis <= 200;
            lastSneakMillis = doubleSneak ? 0 : now;
            return doubleSneak;
        }
        private CursorType getCursorType() {
            return cursorType;
        }
        private void setCursorType(CursorType cursorType) {
            this.cursorType = cursorType;
            refresh();
        }
        private void switchCursorMode() {
            cursorType = cursorType == CursorType.TNT ? CursorType.REDSTONE_BLOCK : CursorType.TNT;
            refresh();
        }
        private void refresh() {
            if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
                deactivateCursor(player);
                return;
            }
            Simulator simulator = SimulatorStorage.getSimulator(player);
            if (simulator != null && simulator.getStabGenerator() != null) {
                removeGenericCursor();
                boolean watcherRemoved = SimulatorWatcher.show(null, player);
                if (watcherRemoved) {
                    SWUtils.sendToActionbar(player, "");
                }
                SWUtils.sendToActionbar(player, "§cGenerating Stab");
                return;
            }
            SimulatorWatcher.show(simulator, player);
            REntityServer targetServer = simulator == null ? getOrCreateEmptyTargetServer() : SimulatorWatcher.getEntityServerOfSimulator(simulator);
            if (cursor == null || currentTargetServer != targetServer) {
                removeGenericCursor();
                currentTargetServer = targetServer;
                cursor = new Cursor(
                        targetServer,
                        player,
                        Material.GLASS,
                        cursorType.material,
                        cursorType.cursorModes,
                        this::handlePlayerClick,
                        (location, hitEntity) -> sendCursorActionbar(simulator, location != null, hitEntity.isPresent())
                );
            } else {
                cursor.setCursorMaterial(cursorType.material);
                cursor.setAllowedCursorModes(cursorType.cursorModes);
            }
            cursor.renderDeduplicated();
        }
        private void removeGenericCursor() {
            if (cursor == null && !SWPlayer.of(player).hasComponent(Cursor.class)) {
                currentTargetServer = null;
                return;
            }
            SWPlayer.of(player).removeComponent(Cursor.class);
            cursor = null;
            currentTargetServer = null;
        }
        private void closeEmptyTargetServer() {
            if (emptyTargetServer == null) {
                return;
            }
            emptyTargetServer.close();
            emptyTargetServer = null;
        }
        private void sendCursorActionbar(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");
            } else if (hasHitEntity) {
                SWUtils.sendToActionbar(player, "§eEdit Position");
            } else {
                SWUtils.sendToActionbar(player, "§eAdd new " + cursorType.name);
            }
        }
        private void handlePlayerClick(Location cursorLocation, Optional<REntity> hitEntity, Action action) {
            if (!Permission.BUILD.hasPermission(player)) return;
            if (!hasSimulatorItem(player)) {
                return;
            }
            Simulator simulator = SimulatorStorage.getSimulator(player);
            if (action == Action.LEFT_CLICK_BLOCK || action == Action.LEFT_CLICK_AIR) {
                if (simulator == null) {
                    return;
                }
                SimulatorExecutor.run(player, simulator, null);
                return;
            }
            if (action != Action.RIGHT_CLICK_BLOCK && action != Action.RIGHT_CLICK_AIR) {
                return;
            }
            if (simulator == null) {
                if (cursorLocation == null) {
                    SimulatorStorage.openSimulatorSelector(player);
                } else {
                    SWAnvilInv anvilInv = new SWAnvilInv(player, "Name");
                    anvilInv.setCallback(s -> {
                        Simulator sim = SimulatorStorage.getSimulator(s);
                        if (sim != null) {
                            BauSystem.MESSAGE.send("SIMULATOR_NAME_ALREADY_EXISTS", player);
                            return;
                        }
                        if (!s.matches("[a-zA-Z_0-9-]+")) {
                            BauSystem.MESSAGE.send("SIMULATOR_NAME_INVALID", player);
                            return;
                        }
                        sim = new Simulator(s);
                        SimulatorStorage.addSimulator(s, sim);
                        createElement(player, cursorLocation, sim);
                        SimulatorStorage.setSimulator(player, sim);
                    });
                    anvilInv.open();
                }
                return;
            }
            if (cursorLocation == null) {
                new SimulatorGui(player, simulator).open();
                return;
            }
            if (hitEntity.isPresent()) {
                openElement(player, simulator, hitEntity.get());
                return;
            }
            createElement(player, cursorLocation, simulator);
        }
        @Override
        public void onMount(SWPlayer player) {
            this.player = player.getPlayer();
            refresh();
        }
        @Override
        public void onUnmount(SWPlayer player) {
            boolean hadCursor = cursor != null || player.hasComponent(Cursor.class);
            removeGenericCursor();
            closeEmptyTargetServer();
            boolean watcherRemoved = SimulatorWatcher.show(null, this.player);
            if (hadCursor || watcherRemoved) {
                SWUtils.sendToActionbar(this.player, "");
            }
        }
    }
    public static boolean isSimulatorItem(ItemStack itemStack) {
        return ItemUtils.isItem(itemStack, "simulator");
    }
    private static boolean hasSimulatorItem(Player player) {
        return isSimulatorItem(player.getInventory().getItemInMainHand()) || isSimulatorItem(player.getInventory().getItemInOffHand());
    }
    @EventHandler
    public void onPlayerDropItem(PlayerDropItemEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
        calcCursor(event.getPlayer());
    }
    @EventHandler
    public void onPlayerItemHeld(PlayerItemHeldEvent event) {
        Player player = event.getPlayer();
        if (!Permission.BUILD.hasPermission(player)) return;
        boolean hasSimulatorInNewMainHand = isSimulatorItem(player.getInventory().getItem(event.getNewSlot()));
        boolean hasSimulatorInOffHand = isSimulatorItem(player.getInventory().getItemInOffHand());
        if (!hasSimulatorInNewMainHand && !hasSimulatorInOffHand) {
            boolean cursorRemoved = deactivateCursor(player);
            boolean watcherRemoved = SimulatorWatcher.show(null, player);
            if (cursorRemoved || watcherRemoved) {
                SWUtils.sendToActionbar(player, "");
            }
            return;
        }
        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> calcCursor(player), 1);
    }
    @EventHandler
    public void onBauMemberUpdate(BauMemberUpdateEvent event) {
        event.getChanged().forEach(SimulatorCursorManager::calcCursor);
    }
    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
        deactivateCursor(event.getPlayer());
    }
    @EventHandler(priority = EventPriority.HIGH)
    public void onPlayerToggleSneak(PlayerToggleSneakEvent event) {
        if (!event.isSneaking()) return;
        Player player = event.getPlayer();
        if (!hasSimulatorItem(player)) {
            return;
        }
        SimulatorCursorComponent component = activateOrRefresh(player);
        if (component == null) {
            return;
        }
        boolean shouldSwitch = component.handleSneak(System.currentTimeMillis());
        if (shouldSwitch) {
            component.switchCursorMode();
        }
    }
    public static CursorType getCursorType(Player player) {
        return SWPlayer.of(player).getComponent(SimulatorCursorComponent.class)
                .map(SimulatorCursorComponent::getCursorType)
                .orElse(CursorType.TNT);
    }
    public static void setCursorType(Player player, CursorType cursorType) {
        Optional<SimulatorCursorComponent> component = SWPlayer.of(player).getComponent(SimulatorCursorComponent.class);
        if (component.isPresent()) {
            component.get().setCursorType(cursorType);
            return;
        }
        if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
            return;
        }
        SWPlayer.of(player).setComponent(new SimulatorCursorComponent(cursorType));
    }
    public static void calcCursor(Player player) {
        activateOrRefresh(player);
    }
    private static SimulatorCursorComponent activateOrRefresh(Player player) {
        if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
            boolean cursorRemoved = deactivateCursor(player);
            boolean watcherRemoved = SimulatorWatcher.show(null, player);
            if (cursorRemoved || watcherRemoved) {
                SWUtils.sendToActionbar(player, "");
            }
            return null;
        }
        SWPlayer swPlayer = SWPlayer.of(player);
        Optional<SimulatorCursorComponent> existingComponent = swPlayer.getComponent(SimulatorCursorComponent.class);
        if (existingComponent.isPresent()) {
            SimulatorCursorComponent component = existingComponent.get();
            component.refresh();
            return component;
        }
        SimulatorCursorComponent component = new SimulatorCursorComponent();
        swPlayer.setComponent(component);
        return component;
    }
    private static synchronized boolean deactivateCursor(Player player) {
        SWPlayer swPlayer = SWPlayer.of(player);
        boolean hadSimulatorCursor = swPlayer.hasComponent(SimulatorCursorComponent.class);
        boolean hadCursor = swPlayer.hasComponent(Cursor.class);
        swPlayer.removeComponent(SimulatorCursorComponent.class);
        if (!hadSimulatorCursor) {
            swPlayer.removeComponent(Cursor.class);
        }
        return hadSimulatorCursor || hadCursor;
    }
    @Getter
    @AllArgsConstructor
    public enum CursorType {
        TNT(Material.TNT, Material.GUNPOWDER, List.of(Cursor.CursorMode.SURFACE_ALIGNED, Cursor.CursorMode.FREE), "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 List<Cursor.CursorMode> cursorModes;
        public final String name;
        public final Function<Vector, SimulatorElement<?>> elementFunction;
    }
    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 = getCursorType(player);
        Vector vector = cursorLocation.toVector();
        if (type == CursorType.REDSTONE_BLOCK) {
            vector.subtract(new Vector(0.5, 0, 0.5));
        }
        SimulatorElement<?> element = type.elementFunction.apply(vector);
        SimulatorGroup group = new SimulatorGroup().add(element);
        simulator.getGroups().add(group);
        SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
        element.open(player, simulator, group, simulatorGui);
        SimulatorWatcher.update(simulator);
        calcCursor(player);
    }
 }
@@ -59,7 +59,7 @@ public class SimulatorStorage implements Enable {
    }
    public static Simulator getSimulator(ItemStack itemStack) {
-        if (!SimulatorCursor.isSimulatorItem(itemStack)) {
+        if (!SimulatorCursorManager.isSimulatorItem(itemStack)) {
            return null;
        }
        String selection = ItemUtils.getTag(itemStack, simulatorSelection);
@@ -181,9 +181,9 @@ public class SimulatorStorage implements Enable {
        ItemStack mainHand = player.getInventory().getItemInMainHand();
        ItemStack offHand = player.getInventory().getItemInOffHand();
        ItemStack itemStack;
-        if (SimulatorCursor.isSimulatorItem(mainHand)) {
+        if (SimulatorCursorManager.isSimulatorItem(mainHand)) {
            itemStack = mainHand;
-        } else if (SimulatorCursor.isSimulatorItem(offHand)) {
+        } else if (SimulatorCursorManager.isSimulatorItem(offHand)) {
            itemStack = offHand;
        } else {
            itemStack = null;
@@ -19,7 +19,7 @@
 package de.steamwar.bausystem.features.simulator.gui;
-import de.steamwar.bausystem.features.simulator.SimulatorCursor;
+import de.steamwar.bausystem.features.simulator.SimulatorCursorManager;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
 import de.steamwar.data.CMDs;
@@ -50,14 +50,14 @@ public class SimulatorCursorSwitcherGui extends SimulatorBaseGui {
        }).setCustomModelData(CMDs.BACK));
        int slot = 2;
-        SimulatorCursor.CursorType currentType = SimulatorCursor.getCursorType(player);
+        SimulatorCursorManager.CursorType currentType = SimulatorCursorManager.getCursorType(player);
-        for (SimulatorCursor.CursorType type : SimulatorCursor.CursorType.values()) {
+        for (SimulatorCursorManager.CursorType type : SimulatorCursorManager.CursorType.values()) {
            boolean selected = type == currentType;
            SWItem swItem = new SWItem(selected ? type.material : type.nonSelectedMaterial, "§e" + type.name)
                    .setCustomModelData(selected ? 0 : CMDs.Simulator.NEW_PHASE)
                    .setLore(Collections.singletonList("§eClick to select"))
                    .setCallback(click -> {
-                        SimulatorCursor.setCursorType(player, type);
+                        SimulatorCursorManager.setCursorType(player, type);
                        player.closeInventory();
                    });
            inventory.setItem(slot, swItem);
@@ -19,7 +19,7 @@
 package de.steamwar.bausystem.features.simulator.gui;
-import de.steamwar.bausystem.features.simulator.SimulatorCursor;
+import de.steamwar.bausystem.features.simulator.SimulatorCursorManager;
 import de.steamwar.bausystem.features.simulator.SimulatorWatcher;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
@@ -50,7 +50,7 @@ public class SimulatorGui extends SimulatorPageGui<SimulatorGroup> {
        inventory.setItem(4, simulator.toItem(player, clickType -> {
            new SimulatorMaterialGui(player, simulator, simulator::getMaterial, simulator::setMaterial, this).open();
        }));
-        SimulatorCursor.CursorType cursorType = SimulatorCursor.getCursorType(player);
+        SimulatorCursorManager.CursorType cursorType = SimulatorCursorManager.getCursorType(player);
        inventory.setItem(48, new SWItem(cursorType.material, "§7Placing §8-§e " + cursorType.name, clickType -> {
            new SimulatorCursorSwitcherGui(player, simulator, this).open();
        }));
@@ -1,72 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.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());
    }
 }
@@ -31,7 +31,6 @@ 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;
@@ -39,6 +38,7 @@ 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;
@@ -165,7 +165,6 @@ 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();
@@ -188,18 +187,15 @@ public class TPSSystem implements Listener {
        }
        @Register(value = {"rate", "0"}, description = "TICK_FREEZE_HELP")
-        public void rate(@Validator Player player) {
+        @Register(value = "freeze", description = "TICK_FREEZE_HELP_2")
        public void freeze(@Validator Player player) {
            TickManager.impl.setFreeze(true);
            sendTickRateChange();
        }
-        @Register(value = "freeze", description = "TICK_FREEZE_HELP_2")
+        @Register(value = "unfreeze", description = "TICK_UNFREEZE_HELP")
-        public void freezeToggle(@Validator Player player) {
+        public void unfreeze(@Validator Player player) {
-            if (TickManager.impl.isFrozen()) {
+            TickManager.impl.setTickRate(20.0F);
                TickManager.impl.setTickRate(20.0F);
            } else {
                TickManager.impl.setFreeze(true);
            }
            sendTickRateChange();
        }
    }
@@ -25,6 +25,7 @@ import de.steamwar.bausystem.features.tracer.rendering.TraceEntity;
 import de.steamwar.bausystem.features.tracer.rendering.ViewFlag;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityAction;
 import de.steamwar.entity.REntityServer;
 import lombok.Getter;
 import lombok.Setter;
@@ -153,11 +153,7 @@ 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) {
-        if (records.length == 0) {
+        TraceManager.instance.isolate(player, records);
            TraceManager.instance.isolate(player, trace, trace.getRecords().toArray(TNTPoint[]::new));
        } else {
            TraceManager.instance.isolate(player, trace, records);
        }
        BauSystem.MESSAGE.send("TRACE_MESSAGE_ISOLATE", player);
    }
@@ -347,10 +347,9 @@ 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 ptrace  the trace for whitch isolation is toggled
+     * @param records the record for which isolation is toggled
     * @param records the records of the trace for which isolation is toggled
     */
-    public void isolate(Player player, Trace ptrace, TNTPoint... records) {
+    public void isolate(Player player, TNTPoint... records) {
        unfollow(player);
        Region region = Region.getRegion(player.getLocation());
@@ -375,20 +374,12 @@ 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) -> {
-            if (trace.getUuid() == ptrace.getUuid() || finalPlayerTraceShowData.hasNoViewFlags()) {
+            trace.render(player, finalPlayerTraceShowData);
-                trace.render(player, finalPlayerTraceShowData);
+            followerMap.getOrDefault(player, Collections.emptySet()).forEach(follower -> {
-                followerMap.getOrDefault(player, Collections.emptySet()).forEach(follower -> {
+                trace.render(follower, finalPlayerTraceShowData);
-                    trace.render(follower, finalPlayerTraceShowData);
+            });
                });
            } else {
                trace.hide(player);
            }
        });
    }
@@ -135,13 +135,6 @@ 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) {
@@ -95,8 +95,4 @@ 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);
    }
 }
@@ -48,9 +48,9 @@ import static de.steamwar.bausystem.features.util.TNTClickListener.TNT_CLICK_DET
 */
 public class TraceEntity extends RBlockDisplay {
-    public static final float TNT_VISUAL_SCALE = 0.98F;
+    private static final float TNT_VISUAL_SCALE = 0.98F;
-    public static final float TNT_VISUAL_OFFSET = -TNT_VISUAL_SCALE / 2.0F;
+    private static final float TNT_VISUAL_OFFSET = -TNT_VISUAL_SCALE / 2.0F;
-    public static final Transformation TNT_VISUAL_TRANSFORM = new Transformation(
+    private static final Transformation TNT_VISUAL_TRANSFORM = new Transformation(
            new Vector3f(TNT_VISUAL_OFFSET, 0.0F, TNT_VISUAL_OFFSET),
            new Quaternionf(0, 0, 0, 1),
            new Vector3f(TNT_VISUAL_SCALE, TNT_VISUAL_SCALE, TNT_VISUAL_SCALE),
@@ -131,7 +131,6 @@ public abstract class ViewFlag {
                if (yLocation.distanceSquared(representative.getLocation()) >= 1.0 / 256.0 && yLocation.distanceSquared(previous.getLocation()) >= 1.0 / 256.0) {
                    RBlockDisplay y = new RBlockDisplay(server, yLocation);
                    y.setBlock(Material.WHITE_STAINED_GLASS.createBlockData());
                    y.setTransform(TraceEntity.TNT_VISUAL_TRANSFORM);
                }
                Location secoundLocation;
@@ -144,7 +143,6 @@ public abstract class ViewFlag {
                if (secoundLocation.distanceSquared(representative.getLocation()) >= 1.0 / 256.0 && secoundLocation.distanceSquared(previous.getLocation()) >= 1.0 / 256.0) {
                    RBlockDisplay second = new RBlockDisplay(server, secoundLocation);
                    second.setBlock(Material.WHITE_STAINED_GLASS.createBlockData());
                    second.setTransform(TraceEntity.TNT_VISUAL_TRANSFORM);
                }
            }
        }
@@ -51,10 +51,6 @@ public class IsolateFlag extends ViewFlag {
        }
    }
    public boolean isEmpty() {
        return tntToIsolate.isEmpty();
    }
    @Override
    public Stream<TNTPoint> filter(Stream<TNTPoint> records) {
        if (tntToIsolate.isEmpty()) return records;
@@ -38,7 +38,6 @@ 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;
@@ -48,6 +47,7 @@ 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,7 +73,19 @@ public class BindCommand extends SWCommand implements Listener {
        }
    }
-    private static final CommandMap commandMap = ((CraftServer) Bukkit.getServer()).getCommandMap();
+    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 NamespacedKey KEY = SWUtils.getNamespaceKey("command");
@@ -21,6 +21,7 @@ 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;
@@ -29,6 +30,7 @@ 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;
@@ -101,8 +103,10 @@ 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) {
-        ((CraftPlayer) player).getHandle().gameMode.gameModeForPlayer = GameType.byId(gameMode.getValue());
+        playerGameMode.set(((CraftPlayer) player).getHandle().gameMode, GameType.byId(gameMode.getValue()));
    }
    @Register(help = true)
@@ -139,7 +143,6 @@ 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);
        }
@@ -36,6 +36,8 @@ 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;
@@ -25,7 +25,6 @@ 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;
@@ -40,6 +39,7 @@ 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;
@@ -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", "//download", "/download"};
+    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r"};
    public static boolean isWorldEditCommand(String command) {
        for (String shortcut : shortcutCommands) {
@@ -28,7 +28,6 @@ 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;
@@ -41,6 +40,7 @@ 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;
@@ -19,6 +19,7 @@
 package de.steamwar.bausystem.utils;
 import de.steamwar.Reflection;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.experimental.UtilityClass;
@@ -85,6 +86,9 @@ 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
@@ -284,9 +288,8 @@ 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();
-            CraftBlockState craftBlockState = (CraftBlockState) blockState;
+            positionAccessor.set(blockState, new BlockPos(blockLocation.getBlockX(), blockLocation.getBlockY(), blockLocation.getBlockZ()));
-            craftBlockState.position = new BlockPos(blockLocation.getBlockX(), blockLocation.getBlockY(), blockLocation.getBlockZ());
+            worldAccessor.set(blockState, blockLocation.getWorld());
            craftBlockState.world = (CraftWorld) blockLocation.getWorld();
        }
        if (blockData.getMaterial().isSolid()) {
@@ -20,6 +20,7 @@
 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;
@@ -32,6 +33,7 @@ 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;
@@ -119,7 +121,7 @@ public class TickManager implements Listener {
    public long getRemainingTicks() {
        if (isSprinting()) {
-            return manager.remainingSprintTicks;
+            return remainingSprintTicks.get(manager);
        } else {
            return manager.frozenTicksToRun();
        }
@@ -19,7 +19,6 @@
 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;
@@ -33,19 +32,16 @@ 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 com.sk89q.worldedit.world.World;
+import de.steamwar.Reflection;
 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
@@ -95,36 +91,17 @@ public class WorldEditUtils {
                .getRegionSelector(BukkitAdapter.adapt(player.getWorld()));
        return new Pair<>(regionSelector.getClass(), regionSelector.getVertices()
                .stream()
-                .map(blockVector3 -> {
+                .map(blockVector3 -> blockVector3 == null ? null : adapt(player.getWorld(), 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));
-        Function<World, RegionSelector> constructor = constructors.get(clazz);
+        Reflection.Constructor constructorInvoker = Reflection.getConstructor(clazz, com.sk89q.worldedit.world.World.class);
-        if (constructor == null) return;
+        RegionSelector regionSelector = (RegionSelector) constructorInvoker.invoke(BukkitAdapter.adapt(player.getWorld()));
        RegionSelector regionSelector = constructor.apply(BukkitAdapter.adapt(player.getWorld()));
        localSession.setRegionSelector(BukkitAdapter.adapt(player.getWorld()), regionSelector);
        if (vertices.isEmpty()) return;
@@ -150,9 +127,13 @@ public class WorldEditUtils {
        try {
            BlockVector3 min = regionSelector.getRegion().getMinimumPoint();
            BlockVector3 max = regionSelector.getRegion().getMaximumPoint();
-            return new Pair<>(BukkitAdapter.adapt(player.getWorld(), min), BukkitAdapter.adapt(player.getWorld(), max));
+            return new Pair<>(adapt(player.getWorld(), min), 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());
    }
 }
@@ -4,7 +4,7 @@ version: "2.0"
 depend: [ WorldEdit, SpigotCore ]
 load: POSTWORLD
 main: de.steamwar.bausystem.BauSystem
-api-version: "1.21"
+api-version: "1.13"
 website: "https://steamwar.de"
 description: "So unseriös wie wir sind: BauSystem nur besser."
@@ -37,6 +37,5 @@ tasks.register<DevServer>("DevBau21") {
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":BauSystem:shadowJar")
    dependsOn(":SchematicSystem:shadowJar")
    dependsOn(":KotlinCore:shadowJar")
    template = "Bau21"
 }
@@ -18,7 +18,6 @@ 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)
@@ -7,7 +7,6 @@ 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
@@ -23,24 +22,12 @@ class ResetCommand : CliktCommand() {
            val schema = schemaFile.readText()
-            execute("SET FOREIGN_KEY_CHECKS=0;") { }
+            val tables = execute("SHOW TABLES;") { it.getString(1) }
-
+            for (table in tables) {
-            val databaseObjects = execute("SHOW FULL TABLES;") { it.getString(1) to it.getString(2) }
+                execute("DROP TABLE IF EXISTS $table;") { }
            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("`", "``")}`;") { }
            }
-            executeScript(schema)
+            execute(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!")))
        }
@@ -14,11 +14,9 @@ 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">
@@ -71,47 +69,35 @@ class DevCommand : CliktCommand("dev") {
    override fun run() {
        val args = mutableListOf<String>()
-        var serverDir = resolveServerDirectory(server)
+        val serverDirectory = File(workingDir, server)
        val serverDir =
            if (serverDirectory.exists() && serverDirectory.isDirectory) serverDirectory else File(workingDir, server)
        if (isVelocity(server)) {
            runServer(
                args, jvmArgs, listOf(
                    jar?.absolutePath
-                        ?: File("/jars/Velocity.jar").absolutePath
+                        ?: File("/jar/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(workingDir, "devtempworld")
+                ?: File(serverDir, "devtempworld")
-            var jarFile = jar?.absolutePath
+            val 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 = gameModeTemplate?.worldTemplate ?: File(serverDir, "Bauwelt")
+                val templateFile = File(serverDir, "Bauwelt")
                if (!templateFile.exists()) {
-                    throw CliktError("Could not find world template: ${templateFile.absolutePath}")
+                    throw CliktError("World Template not found!")
                }
                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") {
@@ -122,11 +108,10 @@ 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", worldDir.absolutePath,
+                    "--world-dir", workingDir.absolutePath,
-                    "nogui",
+                    "--nogui",
                    *(if (plugins != null) arrayOf("--plugins", plugins!!.absolutePathString()) else arrayOf())
                ), serverDir
            )
@@ -138,12 +123,6 @@ class DevCommand : CliktCommand("dev") {
        }
    }
    data class GameModeTemplate(
        val serverDir: File,
        val worldTemplate: File,
        val spigot: Boolean
    )
    val jvmDefaultParams = arrayOf(
        "-Xmx1G",
        "-Xgc:excessiveGCratio=80",
@@ -159,16 +138,6 @@ 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",
@@ -183,7 +152,8 @@ class DevCommand : CliktCommand("dev") {
    )
    val additionalVersions = mapOf(
-        "Lobby" to 21
+        "Tutorial" to 15,
        "Lobby" to 20
    )
    fun findVersion(server: String): Int? =
@@ -196,41 +166,6 @@ 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}"
@@ -241,23 +176,13 @@ 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 "/usr/lib/jvm/openj9-21/bin/java",
+                ?: if (isJava8(server)) "/usr/lib/jvm/openj9-8/bin/java" else "java",
-            *effectiveJvmArgs.toTypedArray(),
+            *jvmArgs.toTypedArray(),
            *args.toTypedArray(),
            *jvmDefaultParams,
-            *(if (isJava8(server)) arrayOf() else jvmNonJava8Params),
+            *(if (isJava8(server)) arrayOf() else jvmArgOverrides),
            *(if (profile) arrayOf("-javaagent:/jars/LixfelsProfiler.jar=start") else arrayOf()),
            "-Xshareclasses:nonfatal,name=$server",
            "-jar",
@@ -16,14 +16,15 @@ import java.sql.ResultSet
 import java.util.*
 object Database {
-    val host: String
+    lateinit var host: String
-    val port: String
+    lateinit var port: String
-    val database: String
+    lateinit var database: String
    val username: String
    val password: String
    lateinit var db: Database
-    init {
+    fun ensureConnected() {
        if (::db.isInitialized) {
            return
        }
        val config = File(System.getProperty("user.home"), "mysql.properties")
        if (!config.exists()) {
@@ -37,14 +38,9 @@ object Database {
        host = props.getProperty("host")
        port = props.getProperty("port")
        database = props.getProperty("database")
        username = props.getProperty("user")
        password = props.getProperty("password")
    }
-    fun ensureConnected() {
+        val username = props.getProperty("user")
-        if (::db.isInitialized) {
+        val password = props.getProperty("password")
            return
        }
        val url = "jdbc:mariadb://$host:$port/$database"
@@ -83,113 +79,6 @@ 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)
@@ -86,24 +86,6 @@ 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 })
@@ -130,43 +130,6 @@ 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 })
@@ -237,7 +200,6 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
    override fun delete() =
        useDb {
            EventRelation.deleteRelations(this@EventFight)
            super.delete()
        }
 }
@@ -159,10 +159,7 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
        }
    override fun delete() =
-        useDb {
+        useDb { super.delete() }
            EventRelation.deleteRelations(this@EventGroup)
            super.delete()
        }
    enum class EventGroupType {
        GROUP_STAGE,
@@ -24,10 +24,8 @@ 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") {
@@ -61,23 +59,6 @@ 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 {
@@ -20,12 +20,9 @@
 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
@@ -72,28 +69,6 @@ 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 })
@@ -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 SteamwarUser ids.
+     * The allowed checkers to check this schematic type denoted by a list of SteamWar 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 Set<Integer> Checkers;
+    public final List<Integer> Checkers;
    /**
     * Bundle for countdowns during the fight
@@ -246,7 +246,7 @@ public final class GameModeConfig<M, W> {
        }
        CheckQuestions = loader.getStringList("CheckQuestions");
-        Checkers = loader.getIntSet("Checkers");
+        Checkers = loader.getIntList("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,27 +488,6 @@ 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);
@@ -526,9 +505,6 @@ 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
@@ -953,13 +929,6 @@ 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
         */
@@ -971,10 +940,7 @@ public final class GameModeConfig<M, W> {
            MemberDefault = loader.getString("MemberDefault", "default");
            LeaderDefault = loader.getString("LeaderDefault", "default");
            PersonalKits = loader.getBoolean("PersonalKits", false);
-            MaxBlastResistance = loader.getDouble("MaxBlastResistance", 9.0);
+            ForbiddenItems = loader.getMaterialList("ForbiddenItems");
            List forbiddenItems = new ArrayList<>(loader.getMaterialList("ForbiddenItems"));
            forbiddenItems.addAll(SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance));
            ForbiddenItems = Collections.unmodifiableList(forbiddenItems);
        }
    }
@@ -139,12 +139,6 @@ 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()) {
@@ -64,10 +64,6 @@ 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
@@ -32,10 +32,7 @@ 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.FightUI;
+import de.steamwar.fightsystem.utils.*;
 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;
@@ -27,9 +27,12 @@ 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) {
@@ -44,6 +47,7 @@ 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);
@@ -24,7 +24,6 @@ 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;
@@ -89,7 +88,7 @@ public class Fight {
    }
    public static void playSound(Sound sound, float volume, float pitch) {
-        GlobalRecorder.getInstance().soundAtPlayer(Registry.SOUNDS.getKey(sound).getKey(), volume, pitch);
+        GlobalRecorder.getInstance().soundAtPlayer(sound.name(), volume, pitch);
        //volume: max. 100, pitch: max. 2
        Bukkit.getServer().getOnlinePlayers().forEach(player -> player.playSound(player, sound, volume, pitch));
    }
@@ -35,9 +35,7 @@ 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.FightUI;
+import de.steamwar.fightsystem.utils.*;
 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;
@@ -25,7 +25,6 @@ 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;
@@ -45,24 +44,14 @@ 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.equals(schematic.getSchemtype()))
                .findFirst()
                .orElse(null);
        if (gameModeConfig == null) gameModeConfig = GameModeConfig.getDefaults();
        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);
@@ -24,7 +24,6 @@ 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;
@@ -39,13 +38,11 @@ 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);
    }
 }
@@ -25,6 +25,7 @@ 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;
@@ -1,7 +1,7 @@
 /*
 *   This file is a part of the SteamWar software.
 *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *   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
@@ -31,16 +31,17 @@ 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.*;
+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.entity.EntityExplodeEvent;
 import org.bukkit.event.entity.FoodLevelChangeEvent;
 import org.bukkit.event.entity.PlayerDeathEvent;
@@ -257,16 +258,4 @@ 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);
        }
    }
 }
@@ -20,6 +20,7 @@
 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;
@@ -36,6 +37,7 @@ 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;
@@ -113,18 +115,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, ServerboundPlayerActionPacket, Object> dig = Recording.this::blockDig;
+            private final BiFunction<Player, Object, Object> dig = Recording.this::blockDig;
            @Override
            public void enable() {
                TinyProtocol.instance.addFilter(ServerboundUseItemPacket.class, place);
-                TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, dig);
+                TinyProtocol.instance.addFilter(blockDigPacket, dig);
            }
            @Override
            public void disable() {
                TinyProtocol.instance.removeFilter(ServerboundUseItemPacket.class, place);
-                TinyProtocol.instance.removeFilter(ServerboundPlayerActionPacket.class, dig);
+                TinyProtocol.instance.removeFilter(blockDigPacket, dig);
            }
        }.register();
        new StateDependentTask(ArenaMode.AntiReplay, FightState.All, () -> {
@@ -141,8 +143,13 @@ public class Recording implements Listener {
        GlobalRecorder.getInstance().entitySpeed(entity);
    }
-    private Object blockDig(Player p, ServerboundPlayerActionPacket packet) {
+    private static final Class<? extends Packet<?>> blockDigPacket = ServerboundPlayerActionPacket.class;
-        if (!isNotSent(p) && packet.getAction() == ServerboundPlayerActionPacket.Action.RELEASE_USE_ITEM) {
+    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) {
            GlobalRecorder.getInstance().bowSpan(p, false, false);
        }
        return packet;
@@ -72,9 +72,6 @@ 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());
@@ -1,44 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.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();
    }
 }
@@ -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(!Config.GameModeConfig.Arena.WindchargesCanCrossMiddle, FightState.Running, this::run, 1, 1);
+        new StateDependentTask(true, 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 = nextlocation.getBlockZ() >= middleLine && location.getBlockZ() <= middleLine ||
+            boolean passedMiddle = location.getBlockZ() > middleLine && prevLocation.getBlockZ() > middleLine ||
-                    nextlocation.getBlockZ() <= middleLine && location.getBlockZ() >= middleLine;
+                    location.getBlockZ() < middleLine && prevLocation.getBlockZ() < middleLine;
-            if (passedMiddle) {
+            if (!passedMiddle) {
                entity.remove();
            }
        });
@@ -34,9 +34,7 @@ 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.FightUI;
+import de.steamwar.fightsystem.utils.*;
 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;
@@ -512,13 +510,11 @@ public class PacketProcessor implements Listener {
        float volume = source.readFloat();
        float pitch = source.readFloat();
-        Sound sound = Registry.SOUNDS.get(NamespacedKey.minecraft(soundName));
+        Sound sound = Sound.valueOf(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, finalSound, SoundCategory.valueOf(soundCategory), volume, pitch);
+            location.getWorld().playSound(location, sound, SoundCategory.valueOf(soundCategory), volume, pitch);
        });
    }
@@ -528,11 +524,9 @@ public class PacketProcessor implements Listener {
        float volume = source.readFloat();
        float pitch = source.readFloat();
-        Sound sound = Registry.SOUNDS.get(NamespacedKey.minecraft(soundName));
+        Sound sound = Sound.valueOf(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(finalSound, volume, pitch));
+        execSync(() -> Fight.playSound(sound, volume, pitch));
    }
    private void pasteSchem(FightTeam team) throws IOException {
@@ -33,7 +33,6 @@ 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;
@@ -239,7 +238,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, Registry.SOUNDS.getKey(soundType.getSound()).getKey(), soundCategory, volume, pitch);
+        write(0x32, x, y, z, soundType.getSound().name(), soundCategory, volume, pitch);
    }
    default void soundAtPlayer(String soundType, float volume, float pitch) {
@@ -19,6 +19,7 @@
 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;
@@ -50,7 +51,7 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
 import java.util.Collection;
-import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
@@ -81,13 +82,18 @@ 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 BuiltInRegistries.BLOCK_ENTITY_TYPE.get(loc).orElse(null);
+                    return ((Optional<Holder.Reference<BlockEntityType<?>>>) method.invoke(blockEntityType, loc)).get().value();
                })
                .filter(Objects::nonNull)
                .map(Holder.Reference::value)
                .collect(Collectors.toUnmodifiableSet());
        new TechHider(CraftMagicNumbers.getBlock(Config.GameModeConfig.Techhider.ObfuscateWith), new AccessPrivilegeProvider() {
@@ -30,6 +30,16 @@ 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"
@@ -53,3 +63,23 @@ tasks.register<FightServer>("WarGear21") {
    config = "WarGear21.yml"
    jar = "/jars/paper-1.21.6.jar"
 }
 tasks.register<FightServer>("SpaceCraftDev20") {
    group = "run"
    description = "Run a SpaceCraftDev 1.20 Fight Server"
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":FightSystem:shadowJar")
    template = "SpaceCraft20"
    worldName = "arenas/AS_Horizon"
    config = "SpaceCraftDev20.yml"
 }
 tasks.register<FightServer>("QuickGear20") {
    group = "run"
    description = "Run a QuickGear 1.20 Fight Server"
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":FightSystem:shadowJar")
    template = "QuickGear20"
    worldName = "arenas/WarGearPark"
    config = "QuickGear20.yml"
 }
@@ -1,5 +1,3 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 /*
 *   This file is a part of the SteamWar software.
 *
@@ -36,7 +34,6 @@ dependencies {
    compileOnly(libs.paperapi)
    compileOnly(project(":SpigotCore"))
    implementation(libs.coroutinesCore)
    implementation(libs.exposedCore)
    implementation(libs.exposedDao)
    implementation(libs.exposedJdbc)
@@ -44,8 +41,3 @@ dependencies {
    implementation(libs.mysql)
    implementation("org.slf4j:slf4j-simple:2.0.17")
 }
 val compileKotlin: KotlinCompile by tasks
 compileKotlin.compilerOptions {
    freeCompilerArgs.set(listOf("-XXLanguage:+ContextParameters"))
 }
@@ -1,23 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
@DslMarker
 annotation class RenderMarker()
@@ -1,26 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
 interface RenderObject {
    fun destroy()
    fun render()
 }
@@ -1,90 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalForInheritanceCoroutinesApi
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlin.reflect.KProperty
 private val uiStateScope = CoroutineScope(SupervisorJob() + Dispatchers.Unconfined)
 context(render: StateFlowListener)
 fun <T> StateFlow<T>.listen(): StateFlow<T> {
    render.track(this) {
        drop(1).onEach { render.update() }.launchIn(uiStateScope)
    }
    return this
 }
 context(render: StateFlowListener)
 fun <T> MutableStateFlow<T>.listen(): MutableStateFlow<T> {
    render.track(this) {
        drop(1).onEach { render.update() }.launchIn(uiStateScope)
    }
    return this
 }
 fun <T> StateFlow<T>.listen(callback: (T) -> Unit): () -> Unit {
    callback(value)
    val job = drop(1).onEach { callback(it) }.launchIn(uiStateScope)
    return { job.cancel() }
 }
 operator fun <T> StateFlow<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
 operator fun <T> MutableStateFlow<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T) {
    this.value = value
 }
 fun <T, R> StateFlow<T>.map(mapper: (T) -> R): StateFlow<R> = MappedStateFlow(this, mapper)
@OptIn(ExperimentalForInheritanceCoroutinesApi::class)
 private class MappedStateFlow<T, R>(
    private val parent: StateFlow<T>,
    private val mapper: (T) -> R,
 ): StateFlow<R> {
    override val replayCache: List<R>
        get() = listOf(value)
    override val value: R
        get() = mapper(parent.value)
    override suspend fun collect(collector: FlowCollector<R>): Nothing {
        var initialized = false
        var previous: Any? = null
        parent.collect {
            val mapped = mapper(it)
            if (!initialized || previous != mapped) {
                initialized = true
                previous = mapped
                collector.emit(mapped)
            }
        }
    }
 }
@@ -1,41 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
 import kotlinx.coroutines.Job
 abstract class StateFlowListener {
    private val jobs = mutableMapOf<Any, Job>()
    internal fun track(key: Any, createJob: () -> Job) {
        if (key in jobs) return
        val job = createJob()
        jobs[key] = job
        job.invokeOnCompletion { jobs.remove(key) }
    }
    abstract fun update()
    open fun destroy() {
        jobs.values.toList().forEach { it.cancel() }
        jobs.clear()
    }
 }
@@ -1,46 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
 import de.steamwar.kotlin.ui.components.item
 import de.steamwar.kotlin.util.count
 import kotlinx.coroutines.flow.MutableStateFlow
 import org.bukkit.Material
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 val Counter = MutableStateFlow(0)
 class TestInv(player: Player): UIInventory(player) {
    override fun view() {
        inventory(3, "") {
            item {
                val amount by Counter.map { it + 1 }.listen()
                item = ItemStack.of(Material.STONE)
                    .count(amount)
                x = 0
                y = 0
                onClick {
                    Counter.value += 1
                }
            }
        }
    }
 }
@@ -1,55 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
 import de.steamwar.kotlin.ui.context.WindowContext
 import org.bukkit.entity.Player
 import org.bukkit.event.inventory.InventoryType
 abstract class UIInventory(val player: Player): StateFlowListener() {
    var window: UIWindow? = null
    abstract fun view()
    fun open() {
        if (window == null) {
            view()
            assert(window != null) { "View method must create a inventory" }
        }
        window!!.open()
    }
    fun render() {
        window?.onClose()
        window = null
        open()
    }
    override fun update() = render()
    protected fun inventory(size: Int, title: String, init: WindowContext.() -> Unit) {
        window = UIWindow(size, title, player, init)
    }
    protected fun inventory(type: InventoryType, title: String, init: WindowContext.() -> Unit) {
        window = UIWindow(type, title, player, init)
    }
 }
@@ -1,91 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui
 import de.steamwar.kotlin.KotlinCore
 import de.steamwar.kotlin.ui.context.WindowContext
 import net.kyori.adventure.text.Component
 import org.bukkit.Bukkit
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
 import org.bukkit.event.Listener
 import org.bukkit.event.inventory.ClickType
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryCloseEvent
 import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.InventoryHolder
 import org.bukkit.inventory.InventoryView
 class UIWindow(val player: Player, val render: WindowContext.() -> Unit): InventoryHolder {
    val onClicks = mutableMapOf<Int, (event: InventoryClickEvent) -> Unit>()
    private var updating = false
    lateinit var bukkitInv: Inventory
        private set
    val context by lazy { WindowContext(this) }
    constructor(size: Int, title: String, player: Player, render: WindowContext.() -> Unit): this(player, render) {
        bukkitInv = KotlinCore.plugin.server.createInventory(this, size * 9, Component.translatable(title))
    }
    constructor(type: InventoryType, title: String, player: Player, render: WindowContext.() -> Unit): this(player, render) {
        assert(type != InventoryType.CHEST) { "Chest inventories should use the constructor with size" }
        bukkitInv = KotlinCore.plugin.server.createInventory(this, type, Component.translatable(title))
    }
    fun open() {
        render(context)
        player.openInventory(bukkitInv)
    }
    fun onClose() {
        if (updating) return
        onClicks.clear()
        context.destroy()
    }
    override fun getInventory() = bukkitInv
    companion object : Listener {
        init {
            Bukkit.getPluginManager().registerEvents(this, KotlinCore.plugin)
        }
        @EventHandler
        fun onInventoryClick(event: InventoryClickEvent) {
            val window = event.inventory.holder
            if (window is UIWindow) {
                event.isCancelled = true
                if (window.context.skipDoubleClick && event.click == ClickType.DOUBLE_CLICK) return
                window.onClicks[event.slot]?.invoke(event)
            }
        }
        @EventHandler
        fun onInventoryClose(event: InventoryCloseEvent) {
            val window = event.inventory.holder
            if (window is UIWindow) {
                window.onClose()
            }
        }
    }
 }
@@ -1,66 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui.components
 import de.steamwar.kotlin.ui.StateFlowListener
 import de.steamwar.kotlin.ui.RenderMarker
 import de.steamwar.kotlin.ui.RenderObject
 import de.steamwar.kotlin.ui.context.GroupContext
 import de.steamwar.kotlin.ui.context.RenderParent
 import org.bukkit.Material
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.inventory.ItemStack
@RenderMarker
 class ItemContext(val parent: RenderParent, val renderFunc: ItemContext.() -> Unit): RenderObject, StateFlowListener() {
    override fun update() {
        val oldX = x
        val oldY = y
        render()
        if (oldX != x || oldY != y) {
            parent.resetSlot(oldX, oldY)
        }
    }
    override fun destroy() {
        super.destroy()
        parent.resetSlot(x, y)
    }
    override fun render() {
        renderFunc(this)
        parent.renderItem(x, y, item, onClick)
    }
    init {
        render()
    }
    var item: ItemStack = ItemStack.of(Material.AIR)
    var onClick: (event: InventoryClickEvent) -> Unit = {}
    var x: Int = 0
    var y: Int = 0
    fun onClick(func: (event: InventoryClickEvent) -> Unit) {
        onClick = func
    }
 }
 fun GroupContext.item(init: ItemContext.() -> Unit) = children.add(ItemContext(this, init))
@@ -1,65 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui.context
 import de.steamwar.kotlin.ui.StateFlowListener
 import de.steamwar.kotlin.ui.RenderMarker
 import de.steamwar.kotlin.ui.RenderObject
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.inventory.ItemStack
@RenderMarker
 open class GroupContext(val parent: RenderParent?, val init: GroupContext.() -> Unit): StateFlowListener(), RenderObject, RenderParent {
    val children = mutableListOf<RenderObject>()
    val updatedSlots = mutableSetOf<Pair<Int, Int>>()
    override fun update() = render()
    override fun destroy() {
        children.forEach { it.destroy() }
        super.destroy()
    }
    init {
        init(this)
    }
    override fun renderItem(x: Int, y: Int, item: ItemStack, onClick: (event: InventoryClickEvent) -> Unit) {
        updatedSlots.add(x to y)
        parent?.renderItem(x, y, item, onClick)
    }
    override fun resetSlot(x: Int, y: Int) {
        parent?.resetSlot(x, y)
    }
    fun group(init: GroupContext.() -> Unit) {
        children.add(GroupContext(this, init))
    }
    override fun render() {
        children.forEach { it.destroy() }
        children.clear()
        val oldUpdatedSlots = updatedSlots.toList()
        updatedSlots.clear()
        init(this)
        (oldUpdatedSlots - updatedSlots).forEach { resetSlot(it.first, it.second) }
    }
 }
@@ -1,29 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui.context
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.inventory.ItemStack
 interface RenderParent {
    fun renderItem(x: Int, y: Int, item: ItemStack, onClick: (event: InventoryClickEvent) -> Unit)
    fun resetSlot(x: Int, y: Int)
 }
@@ -1,54 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.ui.context
 import de.steamwar.kotlin.ui.RenderMarker
 import de.steamwar.kotlin.ui.UIWindow
 import org.bukkit.Material
 import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.InventoryType
 import org.bukkit.inventory.ItemStack
@RenderMarker
 class WindowContext(val window: UIWindow): GroupContext(null, {}) {
    override fun renderItem(x: Int, y: Int, item: ItemStack, onClick: (event: InventoryClickEvent) -> Unit) {
        val slot = calculateSlot(x, y)
        window.bukkitInv.setItem(slot, item)
        window.onClicks[slot] = onClick
    }
    override fun resetSlot(x: Int, y: Int) {
        val slot = calculateSlot(x, y)
        window.bukkitInv.setItem(slot, ItemStack.of(Material.AIR))
        window.onClicks.remove(slot)
    }
    private fun calculateSlot(x: Int, y: Int) = when (window.inventory.type) {
        InventoryType.DROPPER, InventoryType.DISPENSER -> x + y * 3
        InventoryType.HOPPER -> x
        else -> x + y * 9
    }
    fun outsideClick(click: (event: InventoryClickEvent) -> Unit) {
        window.onClicks[-999] = click
    }
    var skipDoubleClick = true
 }
@@ -1,50 +0,0 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.kotlin.util
 import net.kyori.adventure.text.Component
 import org.bukkit.Bukkit
 import org.bukkit.Material
 import org.bukkit.enchantments.Enchantment
 import org.bukkit.inventory.ItemFlag
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.SkullMeta
 import org.bukkit.inventory.meta.components.CustomModelDataComponent
 fun ItemStack.count(count: Int) = apply { amount = count }
 fun ItemStack.name(name: Component) = apply { itemMeta = itemMeta.also { it.displayName(name) } }
 fun ItemStack.lored(lore: List<Component>) = apply { itemMeta = itemMeta.also { it.lore(lore) } }
 fun String.asMaterial(): Material = Material.matchMaterial(this) ?: Material.BARRIER
 fun skull(owner: String): ItemStack = ItemStack(Material.PLAYER_HEAD)
    .also {
        it.editMeta(SkullMeta::class.java) {
            it.playerProfile = Bukkit.getOfflinePlayer(owner.trimStart('.')).playerProfile.also { pp -> pp.complete() }
        }
    }
 fun ItemStack.hideAttributes() = apply { itemMeta = itemMeta.also { it.addItemFlags(*ItemFlag.entries.toTypedArray()) } }
 fun ItemStack.enchanted() = apply { itemMeta = itemMeta.also { it.addEnchant(Enchantment.UNBREAKING, 10, true) } }
 fun ItemStack.customModelData(model: CustomModelDataComponent) = apply { itemMeta = itemMeta.also { it.setCustomModelDataComponent(model) } }
@@ -19,7 +19,6 @@
 plugins {
    steamwar.java
    widener
 }
 dependencies {
@@ -33,17 +32,11 @@ dependencies {
    compileOnly(libs.fawe)
 }
-widener {
+tasks.register<DevServer>("DevLobby20") {
    fromCatalog(libs.nms)
    fromCatalog(libs.paperapi)
 }
 tasks.register<DevServer>("DevLobby") {
    group = "run"
-    description = "Run a Dev Lobby"
+    description = "Run a 1.20 Dev Lobby"
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":KotlinCore:shadowJar")
    dependsOn(":LobbySystem:jar")
-    template = "Lobby21"
+    template = "Lobby20"
    worldName = "Lobby"
 }
@@ -20,6 +20,7 @@
 package de.steamwar.lobby.boatrace;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityAction;
 import de.steamwar.entity.REntityServer;
 import de.steamwar.entity.RInteraction;
 import de.steamwar.lobby.LobbySystem;
@@ -35,7 +36,6 @@ import org.bukkit.entity.Boat;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.boat.*;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
@@ -44,7 +44,6 @@ import org.bukkit.event.vehicle.VehicleMoveEvent;
 import org.bukkit.scheduler.BukkitTask;
 import java.util.EventListener;
 import java.util.Random;
 import static de.steamwar.lobby.util.LeaderboardManager.renderTime;
@@ -62,11 +61,11 @@ public class BoatRace implements EventListener, Listener {
    static {
        boatNpcServer = new REntityServer();
        new REntity(boatNpcServer, EntityType.VILLAGER, BoatRacePositions.NPC);
-        RInteraction interaction = new RInteraction(boatNpcServer, BoatRacePositions.NPC.clone());
+        RInteraction interaction = new RInteraction(boatNpcServer, BoatRacePositions.NPC.clone().subtract(0.5, 0, 0.5));
        interaction.setInteractionHeight(1.95f);
        interaction.setCallback((player, entity, action) -> {
            Bukkit.getWorlds().get(0).getEntities().stream().filter(e -> e.getType() == EntityType.END_CRYSTAL).forEach(Entity::remove);
-            if (!oneNotStarted) {
+            if (action == REntityAction.INTERACT && !oneNotStarted) {
                oneNotStarted = true;
                new BoatRace(player);
            }
@@ -154,24 +153,10 @@ public class BoatRace implements EventListener, Listener {
        oneNotStarted = false;
    }
    private final Class<? extends Boat>[] boatClasses = new Class[]{
            AcaciaBoat.class,
            BambooRaft.class,
            BirchBoat.class,
            CherryBoat.class,
            DarkOakBoat.class,
            JungleBoat.class,
            MangroveBoat.class,
            OakBoat.class,
            PaleOakBoat.class,
            SpruceBoat.class,
    };
    private final Random random = new Random();
    public BoatRace(Player player) {
        this.player = player;
-        boat = Bukkit.getWorlds().get(0).spawn(BoatRacePositions.START, boatClasses[random.nextInt(boatClasses.length)]);
+        boat = Bukkit.getWorlds().get(0).spawn(BoatRacePositions.START, Boat.class);
        // boat.setBoatType(Boat.Type.values()[new Random().nextInt(Boat.Type.values().length)]);
        boat.addPassenger(player);
        bossBar = Bukkit.createBossBar("", BarColor.BLUE, BarStyle.SOLID);
        task = Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
@@ -42,7 +42,7 @@ public class ColorInit {
        if (inputStream == null) {
            colors = new byte[256 * 256 * 256];
            for (int i = 0; i < colors.length; i++) {
-                colors[i] = matchColor(new Color(i));
+                colors[i] = MapPalette.matchColor(new Color(i));
            }
        } else {
            try {
@@ -57,26 +57,4 @@ public class ColorInit {
        }
        System.out.println("[ColorInit] Initialization took " + (System.currentTimeMillis() - time) + "ms");
    }
    public static byte matchColor(Color color) {
        if (color.getAlpha() < 128) return 0;
        if (MapPalette.mapColorCache != null && MapPalette.mapColorCache.isCached()) {
            return MapPalette.mapColorCache.matchColor(color);
        }
        int index = 0;
        double best = -1;
        for (int i = 4; i < MapPalette.colors.length; i++) {
            double distance = MapPalette.getDistance(color, MapPalette.colors[i]);
            if (distance < best || best == -1) {
                best = distance;
                index = i;
            }
        }
        // Minecraft has 248 colors, some of which have negative byte representations
        return (byte) (index < 128 ? index : -129 + (index - 127));
    }
 }
@@ -42,10 +42,7 @@ import java.awt.image.BufferedImage;
 import java.awt.image.WritableRaster;
 import java.io.File;
 import java.io.IOException;
 import java.time.LocalDateTime;
 import java.time.Month;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 public class CustomMap implements Listener {
@@ -59,7 +56,7 @@ public class CustomMap implements Listener {
            new Vector(2346, 45, 1297), new Vector(2345, 45, 1297), new Vector(2344, 45, 1297), new Vector(2343, 45, 1297), new Vector(2342, 45, 1297), new Vector(2341, 45, 1297), new Vector(2340, 45, 1297)
    );
-    private static final CustomMap RIGHT = new CustomMap(new File(System.getProperty("user.home") + "/lobbyBanner/right/"),
+    private static final CustomMap RIGHT = new CustomMap(new File(System.getProperty("user.home") + "/lobbyBanner/right.png"),
            new Vector(2330, 48, 1297), new Vector(2329, 48, 1297), new Vector(2328, 48, 1297), new Vector(2327, 48, 1297), new Vector(2326, 48, 1297), new Vector(2325, 48, 1297), new Vector(2324, 48, 1297),
            new Vector(2330, 47, 1297), new Vector(2329, 47, 1297), new Vector(2328, 47, 1297), new Vector(2327, 47, 1297), new Vector(2326, 47, 1297), new Vector(2325, 47, 1297), new Vector(2324, 47, 1297),
            new Vector(2330, 46, 1297), new Vector(2329, 46, 1297), new Vector(2328, 46, 1297), new Vector(2327, 46, 1297), new Vector(2326, 46, 1297), new Vector(2325, 46, 1297), new Vector(2324, 46, 1297),
@@ -69,49 +66,30 @@ public class CustomMap implements Listener {
    private File mapFile;
    private Map<Vector, Integer> itemFrameIndex = new HashMap<>();
    private ItemFrame[] itemFrames;
-    private boolean update = true;
+    private long lastModified = Long.MAX_VALUE;
-    public CustomMap(File mapFileOrDirectory, Vector... itemFrames) {
+    public CustomMap(File mapFile, Vector... itemFrames) {
-        this.mapFile = mapFileOrDirectory;
+        this.mapFile = mapFile;
        this.itemFrames = new ItemFrame[itemFrames.length];
        for (int i = 0; i < itemFrames.length; i++) {
            itemFrameIndex.put(itemFrames[i], i);
        }
-        if (mapFileOrDirectory.isDirectory()) {
+        Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
-            AtomicReference<Month> lastMonth = new AtomicReference<>(LocalDateTime.now().getMonth());
+            long modified = mapFile.lastModified();
-            Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
+            if (modified > lastModified) {
-                Month current = LocalDateTime.now().getMonth();
+                lastModified = modified;
-                if (!current.equals(lastMonth.get()) || update) {
+                System.out.println("Updating Banner: " + mapFile.getName());
-                    lastMonth.set(current);
+                Bukkit.getScheduler().runTaskAsynchronously(LobbySystem.getInstance(), () -> {
-                    update = false;
+                    try {
-                    this.mapFile = new File(mapFileOrDirectory, current.getValue() + ".png");
+                        run();
-                    update();
+                    } catch (IOException e) {
-                }
+                        // Ignore
-            }, 200L, 1200L);
+                    }
-        } else {
+                });
            AtomicReference<Long> lastModified = new AtomicReference<>(Long.MAX_VALUE);
            Bukkit.getScheduler().runTaskTimer(LobbySystem.getInstance(), () -> {
                long modified = mapFileOrDirectory.lastModified();
                if (modified > lastModified.get() || update) {
                    lastModified.set(modified);
                    update = false;
                    update();
                }
            }, 200L, 200L);
        }
        Bukkit.getPluginManager().registerEvents(this, LobbySystem.getInstance());
    }
    private void update() {
        System.out.println("Updating Banner: " + mapFile.getName());
        Bukkit.getScheduler().runTaskAsynchronously(LobbySystem.getInstance(), () -> {
            try {
                run();
            } catch (IOException e) {
                // Ignore
            }
-        });
+        }, 200L, 200L);
        Bukkit.getPluginManager().registerEvents(this, LobbySystem.getInstance());
    }
    @EventHandler
@@ -123,7 +101,7 @@ public class CustomMap implements Listener {
            if (itemFrameIndex.containsKey(vector)) {
                if (itemFrames[itemFrameIndex.get(vector)] != null) continue;
                itemFrames[itemFrameIndex.get(vector)] = itemFrame;
-                update = true;
+                lastModified = 0;
                ItemStack itemStack = new ItemStack(Material.FILLED_MAP, 1);
                MapMeta mapMeta = (MapMeta) itemStack.getItemMeta();
@@ -276,8 +254,7 @@ public class CustomMap implements Listener {
                int green = pixels[i2];
                int i3 = (y * width + x) * numBands + 2;
                int blue = pixels[i3];
-                int colorIndex = ColorInit.getColorByte(red, green, blue);
+                Color nearest = MapPalette.getColor(ColorInit.getColorByte(red, green, blue));
                Color nearest = MapPalette.colors[colorIndex >= 0 ? colorIndex : colorIndex + 256];
                pixels[(y * width + x) * numBands] = nearest.getRed();
                pixels[i2] = nearest.getGreen();
@@ -1,6 +0,0 @@
 accessWidener v2 named
 # For CustomMap and ColorInit
 accessible field org/bukkit/map/MapPalette colors [Ljava/awt/Color;
 accessible method org/bukkit/map/MapPalette getDistance (Ljava/awt/Color;Ljava/awt/Color;)D
 accessible field org/bukkit/map/MapPalette mapColorCache Lorg/bukkit/map/MapPalette$MapColorCache;
@@ -29,15 +29,5 @@ dependencies {
    compileOnly(libs.paperapi)
    compileOnly(libs.nms)
-    compileOnly(libs.fawe)
+    compileOnly(libs.worldedit)
 }
 tasks.register<FightServer>("MissileWars21") {
    group = "run"
    description = "Run a 1.21 Dev MissileWars"
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":MissileWars:jar")
    template = "MissileWars"
    worldName = "Great_Wall"
    jar = "/jars/paper-1.21.6.jar"
 }
@@ -30,8 +30,6 @@ import com.sk89q.worldedit.function.operation.Operations;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.math.transform.AffineTransform;
 import com.sk89q.worldedit.session.ClipboardHolder;
 import com.sk89q.worldedit.util.SideEffect;
 import com.sk89q.worldedit.util.SideEffectSet;
 import com.sk89q.worldedit.world.World;
 import com.sk89q.worldedit.world.block.BlockTypes;
 import de.steamwar.misslewars.MissileWars;
@@ -111,17 +109,11 @@ public class Missile extends SpecialItem {
        v = aT.apply(v.toVector3()).toBlockPoint();
        v = v.add(location.getBlockX(), location.getBlockY(), location.getBlockZ());
-        EditSession e = WorldEdit.getInstance().getEditSessionFactory()
+        EditSession e = WorldEdit.getInstance().getEditSessionFactory().getEditSession(world, -1);
                .getEditSession(world, -1);
        e.setSideEffectApplier(SideEffectSet.defaults()
                .with(SideEffect.NEIGHBORS, SideEffect.State.ON)
                .with(SideEffect.LIGHTING, SideEffect.State.ON)
                .with(SideEffect.UPDATE, SideEffect.State.ON));
        ClipboardHolder ch = new ClipboardHolder(clipboard);
        ch.setTransform(aT);
        Operations.completeBlindly(ch.createPaste(e).to(v).ignoreAirBlocks(true).build());
        e.flushSession();
        return true;
    }
@@ -20,12 +20,9 @@
 package de.steamwar.misslewars.slowmo;
 import de.steamwar.misslewars.MissileWars;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.TickRateManager;
 import org.bukkit.Bukkit;
 public class SlowMoRunner {
    private static TickRateManager tickRateManager = MinecraftServer.getServer().tickRateManager();
    private static long currentTime = 0;
    private static long current = 0;
@@ -43,14 +40,14 @@ public class SlowMoRunner {
            if (currentTime > 0) {
                current += 1;
                if (current % 5 == 0) {
-                    tickRateManager.setFrozen(false);
+                    SlowMoUtils.unfreeze();
                    current = 0;
                } else {
-                    tickRateManager.setFrozen(true);
+                    SlowMoUtils.freeze();
                }
                currentTime--;
            } else {
-                tickRateManager.setFrozen(false);
+                SlowMoUtils.unfreeze();
            }
        }, 0, 1);
    }
@@ -0,0 +1,74 @@
 /*
 *   This file is a part of the SteamWar software.
 *
 *   Copyright (C) 2025 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 package de.steamwar.misslewars.slowmo;
 import net.minecraft.server.level.ServerLevel;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.craftbukkit.CraftWorld;
 import java.lang.reflect.Field;
 public class SlowMoUtils {
    private static final Field field;
    public static final boolean freezeEnabled;
    private static boolean frozen = false;
    private static final World world;
    static {
        Field temp;
        try {
            temp = ServerLevel.class.getField("freezed");
        } catch (NoSuchFieldException e) {
            temp = null;
        }
        field = temp;
        if (field != null) field.setAccessible(true);
        freezeEnabled = field != null;
        world = Bukkit.getWorlds().get(0);
    }
    public static void freeze() {
        setFreeze(world, true);
    }
    public static void unfreeze() {
        setFreeze(world, false);
    }
    public static boolean frozen() {
        return freezeEnabled && frozen;
    }
    private static void setFreeze(World world, boolean state) {
        if (freezeEnabled) {
            if (frozen == state) return;
            try {
                field.set(((CraftWorld) world).getHandle(), state);
                frozen = state;
            } catch (IllegalAccessException e) {
                // Ignored;
            }
        }
    }
 }
@@ -37,55 +37,40 @@ public class AutoChecker {
    public static final AutoChecker impl = new AutoChecker();
    public AutoCheckerResult check(Clipboard clipboard, GameModeConfig<Material, String> type) {
-        return AutoCheckerResult.builder()
+        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
-                .type(type)
+                .depth(clipboard.getDimensions().getBlockZ()).blockScanResult(scan(clipboard, type))
-                .height(clipboard.getDimensions().y())
+                .entities(clipboard.getEntities().stream().map(Entity::getLocation)
-                .width(clipboard.getDimensions().x())
+                        .map(blockVector3 -> new BlockPos(blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ()))
-                .depth(clipboard.getDimensions().z())
+                        .collect(Collectors.toList()))
                .blockScanResult(scan(clipboard, type))
                .entities(
                        clipboard.getEntities().stream()
                                .map(Entity::getLocation)
                                .map(blockVector3 -> new BlockPos(blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ()))
                                .collect(Collectors.toList()))
                .build();
    }
    public AutoCheckerResult sizeCheck(Clipboard clipboard, GameModeConfig<Material, String> type) {
-        return AutoCheckerResult.builder()
+        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
-                .type(type)
+                .depth(clipboard.getDimensions().getBlockZ()).build();
                .height(clipboard.getDimensions().y())
                .width(clipboard.getDimensions().x())
                .depth(clipboard.getDimensions().z())
                .build();
    }
    public AutoChecker.BlockScanResult scan(Clipboard clipboard, GameModeConfig<Material, String> type) {
        AutoChecker.BlockScanResult result = new AutoChecker.BlockScanResult();
        BlockVector3 min = clipboard.getMinimumPoint();
        BlockVector3 max = clipboard.getMaximumPoint();
-        for (int x = min.x(); x <= max.x(); x++) {
+        for (int x = min.getBlockX(); x <= max.getBlockX(); x++) {
-            for (int y = min.y(); y <= max.y(); y++) {
+            for (int y = min.getBlockY(); y <= max.getBlockY(); y++) {
-                for (int z = min.z(); z <= max.z(); z++) {
+                for (int z = min.getBlockZ(); z <= max.getBlockZ(); z++) {
                    final BaseBlock block = clipboard.getFullBlock(BlockVector3.at(x, y, z));
-                    final Material material = Material.matchMaterial(block.getBlockType().id());
+                    final Material material = Material.matchMaterial(block.getBlockType().getId());
                    if (material == null) {
                        continue;
                    }
-                    BlockPos pos = new BlockPos(x, y, z);
+                    result.getBlockCounts().merge(material, 1, Integer::sum);
                    if (AutoCheckerItems.impl.getInventoryMaterials().contains(material)) {
-                        checkInventory(result, block, material, pos, type);
+                        checkInventory(result, block, material, new BlockPos(x, y, z), type);
                        if (result.getDispenserItems().getOrDefault(pos, 0) > 0) {
                            result.getBlockCounts().merge(material, 1, Integer::sum);
                        }
                    } else {
                        result.getBlockCounts().merge(material, 1, Integer::sum);
                    }
-                    if (x == min.x() || x == max.x() || y == max.y() || z == min.z() || z == max.z()) {
+                    if (x == min.getBlockX() || x == max.getBlockX() || y == max.getBlockY() || z == min.getBlockZ() || z == max.getBlockZ()) {
-                        result.getDesignBlocks().computeIfAbsent(material, m -> new ArrayList<>()).add(pos);
+                        result.getDesignBlocks().computeIfAbsent(material, m -> new ArrayList<>()).add(new BlockPos(x, y, z));
                    }
                }
            }
@@ -245,12 +245,12 @@ public class SchematicCommand extends SWCommand {
            BlockState replaceType = Objects.requireNonNull(toReplace.contains(Material.END_STONE) ? BlockTypes.IRON_BLOCK : BlockTypes.END_STONE).getDefaultState();
            BlockVector3 min = clipboard.getMinimumPoint();
            BlockVector3 max = clipboard.getMaximumPoint();
-            for (int i = min.x(); i <= max.x(); i++) {
+            for (int i = min.getBlockX(); i <= max.getBlockX(); i++) {
-                for (int j = min.y(); j <= max.y(); j++) {
+                for (int j = min.getBlockY(); j <= max.getBlockY(); j++) {
-                    for (int k = min.z(); k <= max.z(); k++) {
+                    for (int k = min.getBlockZ(); k <= max.getBlockZ(); k++) {
                        BlockVector3 vector = BlockVector3.at(i, j, k);
                        BaseBlock block = clipboard.getFullBlock(vector);
-                        if (toReplace.contains(Material.matchMaterial(block.getBlockType().id()))) {
+                        if (toReplace.contains(Material.matchMaterial(block.getBlockType().getId()))) {
                            clipboard.setBlock(vector, replaceType.toBaseBlock());
                        }
                    }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
D4rkr34lm	04519d4cf2	Move a lot more logic into component	2026-06-03 21:13:44 +02:00
D4rkr34lm	88de8c81e7	Remove old cursor	2026-06-03 20:48:50 +02:00
D4rkr34lm	db655bf9db	Refactor to player components	2026-06-03 20:46:51 +02:00